Demos/Device/Incomplete/Sideshow/Lib/SideshowCommands.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #define  INCLUDE_FROM_SIDESHOWCOMMANDS_H
  32 #include "SideshowCommands.h"
  33
  34 UNICODE_STRING_t(80) UserSID       = {LengthInBytes: sizeof(SECURITY_INTERACTIVE_RID_SID),
  35                                       UnicodeString: SECURITY_INTERACTIVE_RID_SID};
  36
  37 Unicode_String_t DeviceName        = {LengthInBytes: sizeof(L"LUFA Sideshow Device"),
  38                                       UnicodeString: L"LUFA Sideshow Device"};
  39
  40 Unicode_String_t Manufacturer      = {LengthInBytes: sizeof(L"Dean Camera"),
  41                                       UnicodeString: L"Dean Camera"};
  42
  43 Unicode_String_t SupportedLanguage = {LengthInBytes: sizeof(L"en-US:1"),
  44                                       UnicodeString: L"en-US:1"};
  45
  46 void Sideshow_ProcessCommandPacket(void)
  47 {
  48         SideShow_PacketHeader_t PacketHeader;
  49
  50         Endpoint_SelectEndpoint(SIDESHOW_OUT_EPNUM);
  51         Endpoint_Read_Stream_LE(&PacketHeader, sizeof(SideShow_PacketHeader_t));
  52
  53         PacketHeader.Type.Response = true;
  54
  55         printf("\r\nCmd: %lX", (PacketHeader.Type.TypeLong & 0x00FFFFFF));
  56
  57         switch (PacketHeader.Type.TypeLong & 0x00FFFFFF)
  58         {
  59                 case SIDESHOW_CMD_PING:
  60                         SideShow_Ping(&PacketHeader);
  61                         break;
  62                 case SIDESHOW_CMD_SYNC:
  63                         SideShow_Sync(&PacketHeader);
  64                         break;
  65                 case SIDESHOW_CMD_GET_CURRENT_USER:
  66                         SideShow_GetCurrentUser(&PacketHeader);
  67                         break;
  68                 case SIDESHOW_CMD_SET_CURRENT_USER:
  69                         SideShow_SetCurrentUser(&PacketHeader);
  70                         break;
  71                 case SIDESHOW_CMD_GET_CAPABILITIES:
  72                         SideShow_GetCapabilities(&PacketHeader);
  73                         break;
  74                 case SIDESHOW_CMD_GET_DEVICE_NAME:
  75                         SideShow_GetString(&PacketHeader, &DeviceName);
  76                         break;
  77                 case SIDESHOW_CMD_GET_MANUFACTURER:
  78                         SideShow_GetString(&PacketHeader, &Manufacturer);
  79                         break;
  80                 case SIDESHOW_CMD_GET_APPLICATION_ORDER:
  81                         SideShow_GetApplicationOrder(&PacketHeader);
  82                         break;
  83                 case SIDESHOW_CMD_GET_SUPPORTED_ENDPOINTS:
  84                         SideShow_GetSupportedEndpoints(&PacketHeader);
  85                         break;
  86                 case SIDESHOW_CMD_ADD_APPLICATION:
  87                         SideShow_AddApplication(&PacketHeader);
  88                         break;
  89                 case SIDESHOW_CMD_ADD_CONTENT:
  90                         SideShow_AddContent(&PacketHeader);
  91                         break;
  92                 case SIDESHOW_CMD_DELETE_CONTENT:
  93                         SideShow_DeleteContent(&PacketHeader);
  94                         break;
  95                 case SIDESHOW_CMD_DELETE_ALL_CONTENT:
  96                         SideShow_DeleteAllContent(&PacketHeader);
  97                         break;
  98                 case SIDESHOW_CMD_DELETE_APPLICATION:
  99                         SideShow_DeleteApplication(&PacketHeader);
 100                         break;
 101                 case SIDESHOW_CMD_DELETE_ALL_APPLICATIONS:
 102                         SideShow_DeleteAllApplications(&PacketHeader);
 103                         break;
 104                 default:
 105                         PacketHeader.Length -= sizeof(SideShow_PacketHeader_t);
 106
 107                         Endpoint_Discard_Stream(PacketHeader.Length);
 108                         Endpoint_ClearOUT();
 109
 110                         PacketHeader.Length   = sizeof(SideShow_PacketHeader_t);
 111                         PacketHeader.Type.NAK = true;
 112
 113                         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 114                         Endpoint_Write_Stream_LE(&PacketHeader, sizeof(SideShow_PacketHeader_t));
 115                         Endpoint_ClearIN();
 116
 117                         printf(" UNK");
 118         }
 119 }
 120
 121 static void SideShow_Ping(SideShow_PacketHeader_t* const PacketHeader)
 122 {
 123         Endpoint_ClearOUT();
 124
 125         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 126         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 127         Endpoint_ClearIN();
 128 }
 129
 130 static void SideShow_Sync(SideShow_PacketHeader_t* const PacketHeader)
 131 {
 132         GUID_t ProtocolGUID;
 133
 134         Endpoint_Read_Stream_LE(&ProtocolGUID, sizeof(GUID_t));
 135         Endpoint_ClearOUT();
 136
 137         if (!(GUID_COMPARE(&ProtocolGUID, (uint32_t[])STANDARD_PROTOCOL_GUID)))
 138           PacketHeader->Type.NAK = true;
 139
 140         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 141         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 142         Endpoint_Write_Stream_LE(&ProtocolGUID, sizeof(GUID_t));
 143         Endpoint_ClearIN();
 144 }
 145
 146 static void SideShow_GetCurrentUser(SideShow_PacketHeader_t* const PacketHeader)
 147 {
 148         Endpoint_ClearOUT();
 149
 150         PacketHeader->Length = sizeof(SideShow_PacketHeader_t) + sizeof(uint32_t) + UserSID.LengthInBytes;
 151
 152         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 153         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 154         SideShow_Write_Unicode_String(&UserSID);
 155         Endpoint_ClearIN();
 156 }
 157
 158 static void SideShow_SetCurrentUser(SideShow_PacketHeader_t* const PacketHeader)
 159 {
 160         SideShow_Read_Unicode_String(&UserSID, sizeof(UserSID.UnicodeString));
 161         Endpoint_ClearOUT();
 162
 163         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 164
 165         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 166         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 167         Endpoint_ClearIN();
 168 }
 169
 170 static void SideShow_GetCapabilities(SideShow_PacketHeader_t* const PacketHeader)
 171 {
 172         SideShow_PropertyKey_t  Property;
 173         SideShow_PropertyData_t PropertyData;
 174
 175         Endpoint_Read_Stream_LE(&Property, sizeof(SideShow_PropertyKey_t));
 176         Endpoint_ClearOUT();
 177
 178         printf(" ID: %lu", Property.PropertyID);
 179
 180         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 181
 182         if (GUID_COMPARE(&Property.PropertyGUID, (uint32_t[])SIDESHOW_PROPERTY_GUID))
 183         {
 184                 switch (Property.PropertyID)
 185                 {
 186                         case PROPERTY_SIDESHOW_SCREENTYPE:
 187                                 PropertyData.DataType    = VT_I4;
 188                                 PropertyData.Data.Data32 = ScreenText;
 189                                 PacketHeader->Length += sizeof(uint32_t);
 190
 191                                 break;
 192                         case PROPERTY_SIDESHOW_SCREENWIDTH:
 193                         case PROPERTY_SIDESHOW_CLIENTWIDTH:
 194                                 PropertyData.DataType    = VT_UI2;
 195                                 PropertyData.Data.Data16 = 16;
 196                                 PacketHeader->Length += sizeof(uint16_t);
 197
 198                                 break;
 199                         case PROPERTY_SIDESHOW_SCREENHEIGHT:
 200                         case PROPERTY_SIDESHOW_CLIENTHEIGHT:
 201                                 PropertyData.DataType    = VT_UI2;
 202                                 PropertyData.Data.Data16 = 2;
 203                                 PacketHeader->Length += sizeof(uint16_t);
 204
 205                                 break;
 206                         case PROPERTY_SIDESHOW_COLORDEPTH:
 207                                 PropertyData.DataType    = VT_UI2;
 208                                 PropertyData.Data.Data16 = 1;
 209                                 PacketHeader->Length += sizeof(uint16_t);
 210
 211                                 break;
 212                         case PROPERTY_SIDESHOW_COLORTYPE:
 213                                 PropertyData.DataType    = VT_UI2;
 214                                 PropertyData.Data.Data16 = BlackAndWhiteDisplay;
 215                                 PacketHeader->Length += sizeof(uint16_t);
 216
 217                                 break;
 218                         case PROPERTY_SIDESHOW_DATACACHE:
 219                                 PropertyData.DataType    = VT_BOOL;
 220                                 PropertyData.Data.Data16 = false;
 221                                 PacketHeader->Length += sizeof(uint16_t);
 222
 223                                 break;
 224                         case PROPERTY_SIDESHOW_SUPPORTEDLANGS:
 225                         case PROPERTY_SIDESHOW_CURRENTLANG:
 226                                 PropertyData.DataType    = VT_LPWSTR;
 227                                 PropertyData.Data.DataPointer = &SupportedLanguage;
 228                                 PacketHeader->Length += SupportedLanguage.LengthInBytes;
 229
 230                                 break;
 231                         default:
 232                                 PropertyData.DataType    = VT_EMPTY;
 233                                 break;
 234                 }
 235         }
 236         else if (GUID_COMPARE(&Property.PropertyGUID, (uint32_t[])DEVICE_PROPERTY_GUID))
 237         {
 238                 switch (Property.PropertyID)
 239                 {
 240                         case PROPERTY_DEVICE_DEVICETYPE:
 241                                 PropertyData.DataType    = VT_UI4;
 242                                 PropertyData.Data.Data32 = GenericDevice;
 243                                 PacketHeader->Length += sizeof(uint32_t);
 244
 245                                 break;
 246                 }
 247         }
 248         else
 249         {
 250                 PacketHeader->Type.NAK = true;
 251
 252                 printf(" WRONG GUID");
 253                 printf(" %lX %lX %lX %lX", Property.PropertyGUID.Chunks[0], Property.PropertyGUID.Chunks[1],
 254                                            Property.PropertyGUID.Chunks[2],  Property.PropertyGUID.Chunks[3]);
 255         }
 256
 257         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 258         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 259
 260         if (!(PacketHeader->Type.NAK))
 261         {
 262                 switch (PropertyData.DataType)
 263                 {
 264                         case VT_UI4:
 265                         case VT_I4:
 266                                 Endpoint_Write_Stream_LE(&PropertyData.Data.Data32, sizeof(uint32_t));
 267                                 break;
 268                         case VT_UI2:
 269                         case VT_I2:
 270                         case VT_BOOL:
 271                                 Endpoint_Write_Stream_LE(&PropertyData.Data.Data16, sizeof(uint16_t));
 272                                 break;
 273                         case VT_LPWSTR:
 274                                 SideShow_Write_Unicode_String((Unicode_String_t*)PropertyData.Data.Data16);
 275                                 break;
 276                 }
 277         }
 278
 279         Endpoint_ClearIN();
 280         return;
 281 }
 282
 283 static void SideShow_GetString(SideShow_PacketHeader_t* const PacketHeader, void* const UnicodeStruct)
 284 {
 285         Endpoint_ClearOUT();
 286
 287         PacketHeader->Length = sizeof(SideShow_PacketHeader_t) +
 288                                sizeof(uint32_t) + ((Unicode_String_t*)UnicodeStruct)->LengthInBytes;
 289
 290         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 291         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 292         SideShow_Write_Unicode_String(UnicodeStruct);
 293         Endpoint_ClearIN();
 294 }
 295
 296 static void SideShow_GetApplicationOrder(SideShow_PacketHeader_t* const PacketHeader)
 297 {
 298         uint8_t  TotalApplications = 0;
 299
 300         Endpoint_ClearOUT();
 301
 302         for (uint8_t App = 0; App < MAX_APPLICATIONS; App++)
 303         {
 304                 if (InstalledApplications[App].InUse)
 305                   TotalApplications++;
 306         }
 307
 308         PacketHeader->Length = sizeof(SideShow_PacketHeader_t) +
 309                                sizeof(uint32_t) + (TotalApplications * sizeof(GUID_t));
 310
 311         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 312         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 313         Endpoint_Write_DWord_LE(TotalApplications);
 314
 315         for (uint8_t App = 0; App < MAX_APPLICATIONS; App++)
 316         {
 317                 if (InstalledApplications[App].InUse)
 318                   Endpoint_Write_Stream_LE(&InstalledApplications[App].ApplicationID, sizeof(GUID_t));
 319         }
 320
 321         Endpoint_ClearIN();
 322 }
 323
 324 static void SideShow_GetSupportedEndpoints(SideShow_PacketHeader_t* const PacketHeader)
 325 {
 326         GUID_t SupportedEndpointGUID = (GUID_t){Chunks: SIMPLE_CONTENT_FORMAT_GUID};
 327
 328         Endpoint_ClearOUT();
 329
 330         PacketHeader->Length = sizeof(SideShow_PacketHeader_t) + sizeof(uint32_t) + sizeof(GUID_t);
 331
 332         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 333         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 334         Endpoint_Write_DWord_LE(1);
 335         Endpoint_Write_Stream_LE(&SupportedEndpointGUID, sizeof(GUID_t));
 336         Endpoint_ClearIN();
 337 }
 338
 339 static void SideShow_AddApplication(SideShow_PacketHeader_t* const PacketHeader)
 340 {
 341         SideShow_Application_t* CurrApp;
 342         GUID_t                  ApplicationID;
 343
 344         Endpoint_Read_Stream_LE(&ApplicationID, sizeof(GUID_t));
 345
 346         CurrApp = SideShow_GetApplicationFromGUID(&ApplicationID);
 347
 348         if (CurrApp == NULL)
 349           CurrApp = SideShow_GetFreeApplication();
 350
 351         if (CurrApp == NULL)
 352         {
 353                 PacketHeader->Length -= sizeof(SideShow_PacketHeader_t) + sizeof(GUID_t);
 354
 355                 Endpoint_Discard_Stream(PacketHeader->Length);
 356                 Endpoint_ClearOUT();
 357
 358                 PacketHeader->Type.NAK = true;
 359         }
 360         else
 361         {
 362                 CurrApp->ApplicationID = ApplicationID;
 363                 Endpoint_Read_Stream_LE(&CurrApp->EndpointID, sizeof(GUID_t));
 364                 SideShow_Read_Unicode_String(&CurrApp->ApplicationName, sizeof(CurrApp->ApplicationName.UnicodeString));
 365                 Endpoint_Read_Stream_LE(&CurrApp->CachePolicy, sizeof(uint32_t));
 366                 Endpoint_Read_Stream_LE(&CurrApp->OnlineOnly, sizeof(uint32_t));
 367                 SideShow_Discard_Byte_Stream();
 368                 SideShow_Discard_Byte_Stream();
 369                 SideShow_Discard_Byte_Stream();
 370                 Endpoint_ClearOUT();
 371
 372                 CurrApp->InUse = true;
 373                 CurrApp->HaveContent = false;
 374                 CurrApp->CurrentContentID = 1;
 375         }
 376
 377         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 378
 379         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 380         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 381         Endpoint_ClearIN();
 382 }
 383
 384 static void SideShow_DeleteApplication(SideShow_PacketHeader_t* const PacketHeader)
 385 {
 386         GUID_t ApplicationGUID;
 387
 388         Endpoint_Read_Stream_LE(&ApplicationGUID, sizeof(GUID_t));
 389         Endpoint_ClearOUT();
 390
 391         SideShow_Application_t* AppToDelete = SideShow_GetApplicationFromGUID(&ApplicationGUID);
 392
 393         if (AppToDelete != NULL)
 394           AppToDelete->InUse = false;
 395         else
 396           PacketHeader->Type.NAK = true;
 397
 398         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 399
 400         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 401         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 402         Endpoint_ClearIN();
 403 }
 404
 405 static void SideShow_DeleteAllApplications(SideShow_PacketHeader_t* const PacketHeader)
 406 {
 407         Endpoint_ClearOUT();
 408
 409         for (uint8_t App = 0; App < MAX_APPLICATIONS; App++)
 410           InstalledApplications[App].InUse = false;
 411
 412         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 413         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 414         Endpoint_ClearIN();
 415 }
 416
 417 static void SideShow_AddContent(SideShow_PacketHeader_t* const PacketHeader)
 418 {
 419         GUID_t ApplicationID;
 420         GUID_t EndpointID;
 421         SideShow_Application_t* Application;
 422
 423         Endpoint_Read_Stream_LE(&ApplicationID, sizeof(GUID_t));
 424         Endpoint_Read_Stream_LE(&EndpointID, sizeof(GUID_t));
 425
 426         Application = SideShow_GetApplicationFromGUID(&ApplicationID);
 427
 428         if (Application == NULL)
 429         {
 430                 SideShow_Discard_Byte_Stream();
 431                 PacketHeader->Type.NAK = true;
 432         }
 433         else if (!(SideShow_AddSimpleContent(PacketHeader, Application)))
 434         {
 435                 PacketHeader->Type.NAK = true;
 436         }
 437
 438         Endpoint_ClearOUT();
 439
 440         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 441
 442         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 443         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 444         Endpoint_ClearIN();
 445 }
 446
 447 static void SideShow_DeleteContent(SideShow_PacketHeader_t* const PacketHeader)
 448 {
 449         GUID_t   ApplicationID;
 450         GUID_t   EndpointID;
 451         uint32_t ContentID;
 452
 453         Endpoint_Read_Stream_LE(&ApplicationID, sizeof(GUID_t));
 454         Endpoint_Read_Stream_LE(&EndpointID, sizeof(GUID_t));
 455         Endpoint_Read_Stream_LE(&ContentID, sizeof(uint32_t));
 456         Endpoint_ClearOUT();
 457
 458         SideShow_Application_t* Application = SideShow_GetApplicationFromGUID(&ApplicationID);
 459
 460         if ((Application != NULL) && (Application->CurrentContentID == ContentID))
 461           Application->HaveContent = false;
 462         else
 463           PacketHeader->Type.NAK = true;
 464
 465         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 466
 467         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 468         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 469         Endpoint_ClearIN();
 470 }
 471
 472 static void SideShow_DeleteAllContent(SideShow_PacketHeader_t* const PacketHeader)
 473 {
 474         GUID_t ApplicationID;
 475         GUID_t EndpointID;
 476
 477         Endpoint_Read_Stream_LE(&ApplicationID, sizeof(GUID_t));
 478         Endpoint_Read_Stream_LE(&EndpointID, sizeof(GUID_t));
 479         Endpoint_ClearOUT();
 480
 481         SideShow_Application_t* Application = SideShow_GetApplicationFromGUID(&ApplicationID);
 482
 483         if (Application != NULL)
 484           Application->HaveContent = false;
 485         else
 486           PacketHeader->Type.NAK = true;
 487
 488         PacketHeader->Length = sizeof(SideShow_PacketHeader_t);
 489
 490         Endpoint_SelectEndpoint(SIDESHOW_IN_EPNUM);
 491         Endpoint_Write_Stream_LE(PacketHeader, sizeof(SideShow_PacketHeader_t));
 492         Endpoint_ClearIN();
 493 }