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