LUFA/Drivers/USB/LowLevel/DevChapter9.c

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