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 (USB_DeviceState != DEVICE_STATE_Addressed)
 149           return;
 150
 151 #if defined(FIXED_NUM_CONFIGURATIONS)
 152         if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
 153           return;
 154 #else
 155         #if defined(USE_FLASH_DESCRIPTORS)
 156                 #define MemoryAddressSpace  MEMSPACE_FLASH
 157         #elif defined(USE_EEPROM_DESCRIPTORS)
 158                 #define MemoryAddressSpace  MEMSPACE_EEPROM
 159         #elif defined(USE_SRAM_DESCRIPTORS)
 160                 #define MemoryAddressSpace  MEMSPACE_SRAM
 161         #else
 162                 uint8_t MemoryAddressSpace;
 163         #endif
 164
 165         USB_Descriptor_Device_t* DevDescriptorPtr;
 166
 167         if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr
 168         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 169                                        , &MemoryAddressSpace
 170         #endif
 171                                        ) == NO_DESCRIPTOR)
 172         {
 173                 return;
 174         }
 175
 176         if (MemoryAddressSpace == MEMSPACE_FLASH)
 177         {
 178                 if (((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 179                   return;
 180         }
 181         else if (MemoryAddressSpace == MEMSPACE_EEPROM)
 182         {
 183                 if (((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 184                   return;
 185         }
 186         else
 187         {
 188                 if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 189                   return;
 190         }
 191 #endif
 192
 193         Endpoint_ClearSETUP();
 194
 195         USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 196
 197         Endpoint_ClearStatusStage();
 198
 199         USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Addressed;
 200
 201         EVENT_USB_Device_ConfigurationChanged();
 202 }
 203
 204 void USB_Device_GetConfiguration(void)
 205 {
 206         Endpoint_ClearSETUP();
 207
 208         Endpoint_Write_Byte(USB_ConfigurationNumber);
 209         Endpoint_ClearIN();
 210
 211         Endpoint_ClearStatusStage();
 212 }
 213
 214 #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 215 static char USB_Device_NibbleToASCII(uint8_t Nibble)
 216 {
 217         Nibble = ((Nibble & 0x0F) + '0');
 218         return (Nibble > '9') ? (Nibble + ('A' - '9' - 1)) : Nibble;
 219 }
 220
 221 static void USB_Device_GetInternalSerialDescriptor(void)
 222 {
 223         struct
 224         {
 225                 USB_Descriptor_Header_t Header;
 226                 int16_t                 UnicodeString[20];
 227         } SignatureDescriptor;
 228
 229         SignatureDescriptor.Header.Type = DTYPE_String;
 230         SignatureDescriptor.Header.Size = sizeof(SignatureDescriptor);
 231
 232         uint8_t SigReadAddress = 0x0E;
 233
 234         ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
 235         {
 236                 for (uint8_t SerialCharNum = 0; SerialCharNum < 20; SerialCharNum++)
 237                 {
 238                         uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
 239
 240                         if (SerialCharNum & 0x01)
 241                         {
 242                                 SerialByte >>= 4;
 243                                 SigReadAddress++;
 244                         }
 245
 246                         SignatureDescriptor.UnicodeString[SerialCharNum] = USB_Device_NibbleToASCII(SerialByte);
 247                 }
 248         }
 249
 250         Endpoint_ClearSETUP();
 251
 252         Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 253
 254         Endpoint_ClearOUT();
 255 }
 256 #endif
 257
 258 static void USB_Device_GetDescriptor(void)
 259 {
 260         void*    DescriptorPointer;
 261         uint16_t DescriptorSize;
 262
 263         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 264         uint8_t  DescriptorAddressSpace;
 265         #endif
 266
 267         #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 268         if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
 269         {
 270                 USB_Device_GetInternalSerialDescriptor();
 271                 return;
 272         }
 273         #endif
 274
 275         if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 276                                                          &DescriptorPointer
 277         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 278                                                          , &DescriptorAddressSpace
 279         #endif
 280                                                                                                          )) == NO_DESCRIPTOR)
 281         {
 282                 return;
 283         }
 284
 285         Endpoint_ClearSETUP();
 286
 287         #if defined(USE_RAM_DESCRIPTORS)
 288         Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 289         #elif defined(USE_EEPROM_DESCRIPTORS)
 290         Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 291         #elif defined(USE_FLASH_DESCRIPTORS)
 292         Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 293         #else
 294         if (DescriptorAddressSpace == MEMSPACE_FLASH)
 295           Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 296         else if (DescriptorAddressSpace == MEMSPACE_EEPROM)
 297           Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 298         else
 299           Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 300         #endif
 301
 302         Endpoint_ClearOUT();
 303 }
 304
 305 static void USB_Device_GetStatus(void)
 306 {
 307         uint8_t CurrentStatus = 0;
 308
 309         switch (USB_ControlRequest.bmRequestType)
 310         {
 311 #if !defined(NO_DEVICE_SELF_POWER) || !defined(NO_DEVICE_REMOTE_WAKEUP)
 312                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 313         #if !defined(NO_DEVICE_SELF_POWER)
 314                         if (USB_CurrentlySelfPowered)
 315                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 316         #endif
 317
 318         #if !defined(NO_DEVICE_REMOTE_WAKEUP)
 319                         if (USB_RemoteWakeupEnabled)
 320                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 321         #endif
 322                         break;
 323 #endif
 324 #if !defined(CONTROL_ONLY_DEVICE)
 325                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 326                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 327
 328                         CurrentStatus = Endpoint_IsStalled();
 329
 330                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 331
 332                         break;
 333 #endif
 334                 default:
 335                         return;
 336         }
 337
 338         Endpoint_ClearSETUP();
 339
 340         Endpoint_Write_Word_LE(CurrentStatus);
 341         Endpoint_ClearIN();
 342
 343         Endpoint_ClearStatusStage();
 344 }
 345
 346 static void USB_Device_ClearSetFeature(void)
 347 {
 348         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 349         {
 350 #if !defined(NO_DEVICE_REMOTE_WAKEUP)
 351                 case REQREC_DEVICE:
 352                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 353                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 354                         else
 355                           return;
 356
 357                         break;
 358 #endif
 359 #if !defined(CONTROL_ONLY_DEVICE)
 360                 case REQREC_ENDPOINT:
 361                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 362                         {
 363                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 364
 365                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 366                                   return;
 367
 368                                 Endpoint_SelectEndpoint(EndpointIndex);
 369
 370                                 if (!(Endpoint_IsEnabled()))
 371                                   return;
 372
 373                                 if (USB_ControlRequest.bRequest == REQ_SetFeature)
 374                                 {
 375                                         Endpoint_StallTransaction();
 376                                 }
 377                                 else
 378                                 {
 379                                         Endpoint_ClearStall();
 380                                         Endpoint_ResetFIFO(EndpointIndex);
 381                                         Endpoint_ResetDataToggle();
 382                                 }
 383                         }
 384
 385                         break;
 386 #endif
 387                 default:
 388                         return;
 389         }
 390
 391         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 392
 393         Endpoint_ClearSETUP();
 394
 395         Endpoint_ClearStatusStage();
 396 }
 397
 398 #endif