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