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) == NO_DESCRIPTOR)
 148         #endif
 149         {
 150                 return;
 151         }
 152
 153         #if defined(USE_RAM_DESCRIPTORS)
 154         if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 155           return;
 156         #elif defined (USE_EEPROM_DESCRIPTORS)
 157         if ((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations))
 158           return;
 159         #elif defined (USE_FLASH_DESCRIPTORS)
 160         if ((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations))
 161           return;
 162         #else
 163         if (MemoryAddressSpace == MEMSPACE_FLASH)
 164         {
 165                 if (((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 166                   return;
 167         }
 168         else if (MemoryAddressSpace == MEMSPACE_EEPROM)
 169         {
 170                 if (((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 171                   return;
 172         }
 173         else
 174         {
 175                 if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 176                   return;
 177         }
 178         #endif
 179 #endif
 180
 181         Endpoint_ClearSETUP();
 182
 183         USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 184
 185         Endpoint_ClearIN();
 186
 187         if (!(AlreadyConfigured) && USB_ConfigurationNumber)
 188           EVENT_USB_DeviceEnumerationComplete();
 189
 190         EVENT_USB_ConfigurationChanged();
 191 }
 192
 193 void USB_Device_GetConfiguration(void)
 194 {
 195         Endpoint_ClearSETUP();
 196
 197         Endpoint_Write_Byte(USB_ConfigurationNumber);
 198
 199         Endpoint_ClearIN();
 200
 201         while (!(Endpoint_IsOUTReceived()));
 202         Endpoint_ClearOUT();
 203 }
 204
 205 #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 206 static void USB_Device_GetInternalSerialDescriptor(void)
 207 {
 208         struct
 209         {
 210                 USB_Descriptor_Header_t Header;
 211                 int16_t                 UnicodeString[12];
 212         } SignatureDescriptor;
 213
 214         uint8_t SigReadAddress  = 0x0E;
 215         bool    OddNibbleRead   = false;
 216
 217         #if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)
 218                 SignatureDescriptor.Header.Size            = sizeof(SignatureDescriptor);
 219                 SignatureDescriptor.Header.Type            = DTYPE_String;
 220         #else
 221                 SignatureDescriptor.Header.bLength         = sizeof(SignatureDescriptor);
 222                 SignatureDescriptor.Header.bDescriptorType = DTYPE_String;
 223         #endif
 224
 225         for (uint8_t SerialCharNum = 0; SerialCharNum < 12; SerialCharNum++)
 226         {
 227                 uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
 228
 229                 if (OddNibbleRead)
 230                 {
 231                         SerialByte >>= 4;
 232                         SigReadAddress++;
 233                 }
 234                 else
 235                 {
 236                         SerialByte &= 0x0F;
 237                 }
 238
 239                 OddNibbleRead = !(OddNibbleRead);
 240
 241                 if (SerialByte < 0x0A)
 242                   SerialByte += '0';
 243                 else
 244                   SerialByte += ('A' - 0x0A);
 245
 246                 SignatureDescriptor.UnicodeString[SerialCharNum] = SerialByte;
 247         }
 248
 249         Endpoint_ClearSETUP();
 250         Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 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) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 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                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 309                         if (USB_CurrentlySelfPowered)
 310                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 311
 312                         if (USB_RemoteWakeupEnabled)
 313                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 314
 315                         break;
 316 #if !defined(CONTROL_ONLY_DEVICE)
 317                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 318                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex);
 319
 320                         CurrentStatus = Endpoint_IsStalled();
 321
 322                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 323
 324                         break;
 325 #endif
 326         }
 327
 328         Endpoint_ClearSETUP();
 329
 330         Endpoint_Write_Word_LE(CurrentStatus);
 331
 332         Endpoint_ClearIN();
 333
 334         while (!(Endpoint_IsOUTReceived()));
 335         Endpoint_ClearOUT();
 336 }
 337
 338 static void USB_Device_ClearSetFeature(void)
 339 {
 340         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 341         {
 342                 case REQREC_DEVICE:
 343                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 344                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 345                         else
 346                           return;
 347
 348                         break;
 349 #if !defined(CONTROL_ONLY_DEVICE)
 350                 case REQREC_ENDPOINT:
 351                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 352                         {
 353                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 354
 355                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 356                                   return;
 357
 358                                 Endpoint_SelectEndpoint(EndpointIndex);
 359
 360                                 if (Endpoint_IsEnabled())
 361                                 {
 362                                         if (USB_ControlRequest.bRequest == REQ_ClearFeature)
 363                                         {
 364                                                 Endpoint_ClearStall();
 365                                                 Endpoint_ResetFIFO(EndpointIndex);
 366                                                 Endpoint_ResetDataToggle();
 367                                         }
 368                                         else
 369                                         {
 370                                                 Endpoint_StallTransaction();
 371                                         }
 372                                 }
 373                         }
 374
 375                         break;
 376 #endif
 377         }
 378
 379         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 380
 381         Endpoint_ClearSETUP();
 382
 383         Endpoint_ClearIN();
 384 }
 385
 386 #endif