LUFA/Drivers/USB/HighLevel/DeviceStandardReq.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_USB_DRIVER
  32 #include "USBMode.h"
  33
  34 #if defined(USB_CAN_BE_DEVICE)
  35
  36 #define  __INCLUDE_FROM_DEVICESTDREQ_C
  37 #include "DeviceStandardReq.h"
  38
  39 uint8_t USB_ConfigurationNumber;
  40
  41 #if !defined(NO_DEVICE_SELF_POWER)
  42 bool    USB_CurrentlySelfPowered;
  43 #endif
  44
  45 #if !defined(NO_DEVICE_REMOTE_WAKEUP)
  46 bool    USB_RemoteWakeupEnabled;
  47 #endif
  48
  49 void USB_Device_ProcessControlRequest(void)
  50 {
  51         bool     RequestHandled = false;
  52         uint8_t* RequestHeader  = (uint8_t*)&USB_ControlRequest;
  53
  54         for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
  55           *(RequestHeader++) = Endpoint_Read_Byte();
  56
  57         uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
  58
  59         switch (USB_ControlRequest.bRequest)
  60         {
  61                 case REQ_GetStatus:
  62                         if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  63                             (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT)))
  64                         {
  65                                 USB_Device_GetStatus();
  66                                 RequestHandled = true;
  67                         }
  68
  69                         break;
  70                 case REQ_ClearFeature:
  71                 case REQ_SetFeature:
  72                         if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  73                             (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT)))
  74                         {
  75                                 USB_Device_ClearSetFeature();
  76                                 RequestHandled = true;
  77                         }
  78
  79                         break;
  80                 case REQ_SetAddress:
  81                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
  82                         {
  83                                 USB_Device_SetAddress();
  84                                 RequestHandled = true;
  85                         }
  86
  87                         break;
  88                 case REQ_GetDescriptor:
  89                         if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  90                             (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE)))
  91                         {
  92                                 USB_Device_GetDescriptor();
  93                                 RequestHandled = true;
  94                         }
  95
  96                         break;
  97                 case REQ_GetConfiguration:
  98                         if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
  99                         {
 100                                 USB_Device_GetConfiguration();
 101                                 RequestHandled = true;
 102                         }
 103
 104                         break;
 105                 case REQ_SetConfiguration:
 106                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
 107                         {
 108                                 USB_Device_SetConfiguration();
 109                                 RequestHandled = true;
 110                         }
 111
 112                         break;
 113         }
 114
 115         if (!(RequestHandled))
 116           EVENT_USB_Device_UnhandledControlRequest();
 117
 118         if (Endpoint_IsSETUPReceived())
 119         {
 120                 Endpoint_StallTransaction();
 121                 Endpoint_ClearSETUP();
 122         }
 123 }
 124
 125 static void USB_Device_SetAddress(void)
 126 {
 127         uint8_t DeviceAddress = (USB_ControlRequest.wValue & 0x7F);
 128
 129         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 130         {
 131                 Endpoint_ClearSETUP();
 132
 133                 Endpoint_ClearStatusStage();
 134
 135                 while (!(Endpoint_IsINReady()));
 136
 137                 USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
 138
 139                 USB_Device_SetDeviceAddress(DeviceAddress);
 140         }
 141 }
 142
 143 static void USB_Device_SetConfiguration(void)
 144 {
 145         #if defined(FIXED_NUM_CONFIGURATIONS)
 146         if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
 147           return;
 148         #else
 149         USB_Descriptor_Device_t* DevDescriptorPtr;
 150
 151         #if defined(USE_FLASH_DESCRIPTORS)
 152                 #define MemoryAddressSpace  MEMSPACE_FLASH
 153         #elif defined(USE_EEPROM_DESCRIPTORS)
 154                 #define MemoryAddressSpace  MEMSPACE_EEPROM
 155         #elif defined(USE_SRAM_DESCRIPTORS)
 156                 #define MemoryAddressSpace  MEMSPACE_SRAM
 157         #else
 158                 uint8_t MemoryAddressSpace;
 159         #endif
 160
 161         if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr
 162         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 163                                        , &MemoryAddressSpace
 164         #endif
 165                                        ) == NO_DESCRIPTOR)
 166         {
 167                 return;
 168         }
 169
 170         if (MemoryAddressSpace == MEMSPACE_FLASH)
 171         {
 172                 if (((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 173                   return;
 174         }
 175         else if (MemoryAddressSpace == MEMSPACE_EEPROM)
 176         {
 177                 if (((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 178                   return;
 179         }
 180         else
 181         {
 182                 if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 183                   return;
 184         }
 185         #endif
 186
 187         Endpoint_ClearSETUP();
 188
 189         USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 190
 191         Endpoint_ClearStatusStage();
 192
 193         if (USB_ConfigurationNumber)
 194           USB_DeviceState = DEVICE_STATE_Configured;
 195         else
 196           USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
 197
 198         EVENT_USB_Device_ConfigurationChanged();
 199 }
 200
 201 static void USB_Device_GetConfiguration(void)
 202 {
 203         Endpoint_ClearSETUP();
 204
 205         Endpoint_Write_Byte(USB_ConfigurationNumber);
 206         Endpoint_ClearIN();
 207
 208         Endpoint_ClearStatusStage();
 209 }
 210
 211 #if !defined(NO_INTERNAL_SERIAL) && (USE_INTERNAL_SERIAL != NO_DESCRIPTOR)
 212 static char USB_Device_NibbleToASCII(uint8_t Nibble)
 213 {
 214         Nibble &= 0x0F;
 215         return (Nibble >= 10) ? (('A' - 10) + Nibble) : ('0' + Nibble);
 216 }
 217
 218 static void USB_Device_GetInternalSerialDescriptor(void)
 219 {
 220         struct
 221         {
 222                 USB_Descriptor_Header_t Header;
 223                 wchar_t                 UnicodeString[20];
 224         } SignatureDescriptor;
 225
 226         SignatureDescriptor.Header.Type = DTYPE_String;
 227         SignatureDescriptor.Header.Size = sizeof(SignatureDescriptor);
 228
 229         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 230         {
 231                 uint8_t SigReadAddress = 0x0E;
 232
 233                 for (uint8_t SerialCharNum = 0; SerialCharNum < 20; SerialCharNum++)
 234                 {
 235                         uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
 236
 237                         if (SerialCharNum & 0x01)
 238                         {
 239                                 SerialByte >>= 4;
 240                                 SigReadAddress++;
 241                         }
 242
 243                         SignatureDescriptor.UnicodeString[SerialCharNum] = USB_Device_NibbleToASCII(SerialByte);
 244                 }
 245         }
 246
 247         Endpoint_ClearSETUP();
 248
 249         Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 250
 251         Endpoint_ClearOUT();
 252 }
 253 #endif
 254
 255 static void USB_Device_GetDescriptor(void)
 256 {
 257         const void* DescriptorPointer;
 258         uint16_t    DescriptorSize;
 259
 260         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 261         uint8_t DescriptorAddressSpace;
 262         #endif
 263
 264         #if !defined(NO_INTERNAL_SERIAL) && (USE_INTERNAL_SERIAL != NO_DESCRIPTOR)
 265         if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
 266         {
 267                 USB_Device_GetInternalSerialDescriptor();
 268                 return;
 269         }
 270         #endif
 271
 272         if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 273                                                          &DescriptorPointer
 274         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 275                                                          , &DescriptorAddressSpace
 276         #endif
 277                                                                                                          )) == NO_DESCRIPTOR)
 278         {
 279                 return;
 280         }
 281
 282         Endpoint_ClearSETUP();
 283
 284         #if defined(USE_RAM_DESCRIPTORS)
 285         Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 286         #elif defined(USE_EEPROM_DESCRIPTORS)
 287         Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 288         #elif defined(USE_FLASH_DESCRIPTORS)
 289         Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 290         #else
 291         if (DescriptorAddressSpace == MEMSPACE_FLASH)
 292           Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 293         else if (DescriptorAddressSpace == MEMSPACE_EEPROM)
 294           Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 295         else
 296           Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 297         #endif
 298
 299         Endpoint_ClearOUT();
 300 }
 301
 302 static void USB_Device_GetStatus(void)
 303 {
 304         uint8_t CurrentStatus = 0;
 305
 306         switch (USB_ControlRequest.bmRequestType)
 307         {
 308                 #if !defined(NO_DEVICE_SELF_POWER) || !defined(NO_DEVICE_REMOTE_WAKEUP)
 309                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 310                         #if !defined(NO_DEVICE_SELF_POWER)
 311                         if (USB_CurrentlySelfPowered)
 312                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 313                         #endif
 314
 315                         #if !defined(NO_DEVICE_REMOTE_WAKEUP)
 316                         if (USB_RemoteWakeupEnabled)
 317                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 318                         #endif
 319                         break;
 320                 #endif
 321                 #if !defined(CONTROL_ONLY_DEVICE)
 322                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 323                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 324
 325                         CurrentStatus = Endpoint_IsStalled();
 326
 327                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 328
 329                         break;
 330                 #endif
 331                 default:
 332                         return;
 333         }
 334
 335         Endpoint_ClearSETUP();
 336
 337         Endpoint_Write_Word_LE(CurrentStatus);
 338         Endpoint_ClearIN();
 339
 340         Endpoint_ClearStatusStage();
 341 }
 342
 343 static void USB_Device_ClearSetFeature(void)
 344 {
 345         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 346         {
 347                 #if !defined(NO_DEVICE_REMOTE_WAKEUP)
 348                 case REQREC_DEVICE:
 349                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 350                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 351                         else
 352                           return;
 353
 354                         break;
 355                 #endif
 356                 #if !defined(CONTROL_ONLY_DEVICE)
 357                 case REQREC_ENDPOINT:
 358                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 359                         {
 360                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 361
 362                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 363                                   return;
 364
 365                                 Endpoint_SelectEndpoint(EndpointIndex);
 366
 367                                 if (Endpoint_IsEnabled())
 368                                 {
 369                                         if (USB_ControlRequest.bRequest == REQ_SetFeature)
 370                                         {
 371                                                 Endpoint_StallTransaction();
 372                                         }
 373                                         else
 374                                         {
 375                                                 Endpoint_ClearStall();
 376                                                 Endpoint_ResetFIFO(EndpointIndex);
 377                                                 Endpoint_ResetDataToggle();
 378                                         }
 379                                 }
 380                         }
 381
 382                         break;
 383                 #endif
 384                 default:
 385                         return;
 386         }
 387
 388         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 389
 390         Endpoint_ClearSETUP();
 391
 392         Endpoint_ClearStatusStage();
 393 }
 394
 395 #endif
 396