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         if (DeviceAddress)
 140           USB_DeviceState = DEVICE_STATE_Addressed;
 141
 142         USB_Device_SetDeviceAddress(DeviceAddress);
 143
 144         return;
 145 }
 146
 147 static void USB_Device_SetConfiguration(void)
 148 {
 149 #if defined(FIXED_NUM_CONFIGURATIONS)
 150         if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
 151           return;
 152 #else
 153         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 154         uint8_t MemoryAddressSpace;
 155         #endif
 156
 157         USB_Descriptor_Device_t* DevDescriptorPtr;
 158
 159         if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr
 160         #if !defined(USE_FLASH_DESCRIPTORS) && !defined(USE_EEPROM_DESCRIPTORS) && !defined(USE_RAM_DESCRIPTORS)
 161                                        , &MemoryAddressSpace
 162         #endif
 163                                        ) == NO_DESCRIPTOR)
 164         {
 165                 return;
 166         }
 167
 168         #if defined(USE_RAM_DESCRIPTORS)
 169         if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 170           return;
 171         #elif defined (USE_EEPROM_DESCRIPTORS)
 172         if ((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations))
 173           return;
 174         #elif defined (USE_FLASH_DESCRIPTORS)
 175         if ((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations))
 176           return;
 177         #else
 178         if (MemoryAddressSpace == MEMSPACE_FLASH)
 179         {
 180                 if (((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 181                   return;
 182         }
 183         else if (MemoryAddressSpace == MEMSPACE_EEPROM)
 184         {
 185                 if (((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 186                   return;
 187         }
 188         else
 189         {
 190                 if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 191                   return;
 192         }
 193         #endif
 194 #endif
 195
 196         Endpoint_ClearSETUP();
 197
 198         USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 199
 200         Endpoint_ClearStatusStage();
 201
 202         USB_DeviceState = (USB_ConfigurationNumber) ? DEVICE_STATE_Configured : DEVICE_STATE_Addressed;
 203
 204         EVENT_USB_Device_ConfigurationChanged();
 205 }
 206
 207 void USB_Device_GetConfiguration(void)
 208 {
 209         Endpoint_ClearSETUP();
 210
 211         Endpoint_Write_Byte(USB_ConfigurationNumber);
 212         Endpoint_ClearIN();
 213
 214         Endpoint_ClearStatusStage();
 215 }
 216
 217 #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 218 static char USB_Device_NibbleToASCII(uint8_t Nibble)
 219 {
 220         Nibble = ((Nibble & 0x0F) + '0');
 221         return (Nibble > '9') ? (Nibble + ('A' - '9' - 1)) : Nibble;
 222 }
 223
 224 static void USB_Device_GetInternalSerialDescriptor(void)
 225 {
 226         struct
 227         {
 228                 USB_Descriptor_Header_t Header;
 229                 int16_t                 UnicodeString[20];
 230         } SignatureDescriptor;
 231
 232         SignatureDescriptor.Header.Type = DTYPE_String;
 233         SignatureDescriptor.Header.Size = sizeof(SignatureDescriptor);
 234
 235         uint8_t SigReadAddress = 0x0E;
 236
 237         for (uint8_t SerialCharNum = 0; SerialCharNum < 20; SerialCharNum++)
 238         {
 239                 uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
 240
 241                 if (SerialCharNum & 0x01)
 242                 {
 243                         SerialByte >>= 4;
 244                         SigReadAddress++;
 245                 }
 246
 247                 SignatureDescriptor.UnicodeString[SerialCharNum] = USB_Device_NibbleToASCII(SerialByte);
 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(USB_ControlRequest.wIndex & 0xFF);
 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                                 {
 372                                         if (USB_ControlRequest.bRequest == REQ_SetFeature)
 373                                         {
 374                                                 Endpoint_StallTransaction();
 375                                         }
 376                                         else
 377                                         {
 378                                                 Endpoint_ClearStall();
 379                                                 Endpoint_ResetFIFO(EndpointIndex);
 380                                                 Endpoint_ResetDataToggle();
 381                                         }
 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