LUFA/Drivers/USB/LowLevel/DevChapter9.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 "../HighLevel/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_DEVICE)
  35
  36 #define  __INCLUDE_FROM_DEVCHAPTER9_C
  37 #include "DevChapter9.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         Endpoint_ClearSETUP();
 130
 131         Endpoint_ClearStatusStage();
 132
 133         while (!(Endpoint_IsINReady()))
 134         {
 135                 if (USB_DeviceState == DEVICE_STATE_Unattached)
 136                   return;
 137         }
 138
 139         USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
 140
 141         UDADDR = ((1 << ADDEN) | DeviceAddress);
 142
 143         return;
 144 }
 145
 146 static void USB_Device_SetConfiguration(void)
 147 {
 148 #if defined(FIXED_NUM_CONFIGURATIONS)
 149         if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
 150           return;
 151 #else
 152         #if defined(USE_FLASH_DESCRIPTORS)
 153                 #define MemoryAddressSpace  MEMSPACE_FLASH
 154         #elif defined(USE_EEPROM_DESCRIPTORS)
 155                 #define MemoryAddressSpace  MEMSPACE_EEPROM
 156         #elif defined(USE_SRAM_DESCRIPTORS)
 157                 #define MemoryAddressSpace  MEMSPACE_SRAM
 158         #else
 159                 uint8_t MemoryAddressSpace;
 160         #endif
 161
 162         USB_Descriptor_Device_t* DevDescriptorPtr;
 163
 164         if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr
 165         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 166                                        , &MemoryAddressSpace
 167         #endif
 168                                        ) == NO_DESCRIPTOR)
 169         {
 170                 return;
 171         }
 172
 173         if (MemoryAddressSpace == MEMSPACE_FLASH)
 174         {
 175                 if (((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 176                   return;
 177         }
 178         else if (MemoryAddressSpace == MEMSPACE_EEPROM)
 179         {
 180                 if (((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 181                   return;
 182         }
 183         else
 184         {
 185                 if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 186                   return;
 187         }
 188 #endif
 189
 190         Endpoint_ClearSETUP();
 191
 192         USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 193
 194         Endpoint_ClearStatusStage();
 195
 196         USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Addressed;
 197
 198         EVENT_USB_Device_ConfigurationChanged();
 199 }
 200
 201 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 = ((Nibble & 0x0F) + '0');
 215         return (Nibble > '9') ? (Nibble + ('A' - '9' - 1)) : Nibble;
 216 }
 217
 218 static void USB_Device_GetInternalSerialDescriptor(void)
 219 {
 220         struct
 221         {
 222                 USB_Descriptor_Header_t Header;
 223                 int16_t                 UnicodeString[20];
 224         } SignatureDescriptor;
 225
 226         SignatureDescriptor.Header.Type = DTYPE_String;
 227         SignatureDescriptor.Header.Size = sizeof(SignatureDescriptor);
 228
 229         uint8_t SigReadAddress = 0x0E;
 230
 231         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 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         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                                   return;
 369
 370                                 if (USB_ControlRequest.bRequest == REQ_SetFeature)
 371                                 {
 372                                         Endpoint_StallTransaction();
 373                                 }
 374                                 else
 375                                 {
 376                                         Endpoint_ClearStall();
 377                                         Endpoint_ResetFIFO(EndpointIndex);
 378                                         Endpoint_ResetDataToggle();
 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