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(USE_SINGLE_DEVICE_CONFIGURATION)
 136         if ((uint8_t)USB_ControlRequest.wValue > 1)
 137 #else
 138         USB_Descriptor_Device_t* DevDescriptorPtr;
 139
 140         if ((CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr) == NO_DESCRIPTOR) ||
 141         #if defined(USE_RAM_DESCRIPTORS)
 142             ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations))
 143         #elif defined (USE_EEPROM_DESCRIPTORS)
 144             ((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 145         #else
 146             ((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 147         #endif
 148 #endif
 149         {
 150                 return;
 151         }
 152
 153         Endpoint_ClearSETUP();
 154
 155         USB_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 156
 157         Endpoint_ClearIN();
 158
 159         if (!(AlreadyConfigured) && USB_ConfigurationNumber)
 160           EVENT_USB_DeviceEnumerationComplete();
 161
 162         EVENT_USB_ConfigurationChanged();
 163 }
 164
 165 void USB_Device_GetConfiguration(void)
 166 {
 167         Endpoint_ClearSETUP();
 168
 169         Endpoint_Write_Byte(USB_ConfigurationNumber);
 170
 171         Endpoint_ClearIN();
 172
 173         while (!(Endpoint_IsOUTReceived()));
 174         Endpoint_ClearOUT();
 175 }
 176
 177 static void USB_Device_GetDescriptor(void)
 178 {
 179         void*    DescriptorPointer;
 180         uint16_t DescriptorSize;
 181
 182         #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 183         if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
 184         {
 185                 struct
 186                 {
 187                         USB_Descriptor_Header_t Header;
 188                         int16_t                 UnicodeString[12];
 189                 } SignatureDescriptor;
 190
 191                 #if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)
 192                         SignatureDescriptor.Header.Size            = sizeof(SignatureDescriptor);
 193                         SignatureDescriptor.Header.Type            = DTYPE_String;
 194                 #else
 195                         SignatureDescriptor.Header.bLength         = sizeof(SignatureDescriptor);
 196                         SignatureDescriptor.Header.bDescriptorType = DTYPE_String;
 197                 #endif
 198
 199                 uint8_t  SigReadAddress  = 0x0E;
 200                 bool     OddRead         = false;
 201
 202                 for (uint8_t SerialCharNum = 0; SerialCharNum < 12; SerialCharNum++)
 203                 {
 204                         uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
 205
 206                         if (OddRead)
 207                         {
 208                                 SerialByte >>= 4;
 209                                 SigReadAddress++;
 210                         }
 211                         else
 212                         {
 213                                 SerialByte &= 0x0F;
 214                         }
 215
 216                         OddRead = !(OddRead);
 217
 218                         if (SerialByte < 0x0A)
 219                           SerialByte += '0';
 220                         else
 221                           SerialByte += ('A' - 0x0A);
 222
 223                         SignatureDescriptor.UnicodeString[SerialCharNum] = SerialByte;
 224                 }
 225
 226                 Endpoint_ClearSETUP();
 227                 Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 228                 Endpoint_ClearOUT();
 229
 230                 return;
 231         }
 232         #endif
 233
 234         if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 235                                                          &DescriptorPointer)) == NO_DESCRIPTOR)
 236         {
 237                 return;
 238         }
 239
 240         Endpoint_ClearSETUP();
 241
 242         #if defined(USE_RAM_DESCRIPTORS)
 243         Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 244         #else
 245         bool SendZLP;
 246
 247         if (USB_ControlRequest.wLength > DescriptorSize)
 248           USB_ControlRequest.wLength = DescriptorSize;
 249
 250         while (USB_ControlRequest.wLength)
 251         {
 252                 while (!(Endpoint_IsINReady()))
 253                 {
 254                         if (Endpoint_IsOUTReceived())
 255                         {
 256                                 Endpoint_ClearOUT();
 257                                 return;
 258                         }
 259                 }
 260
 261                 while (USB_ControlRequest.wLength && (Endpoint_BytesInEndpoint() < USB_ControlEndpointSize))
 262                 {
 263                         #if defined (USE_EEPROM_DESCRIPTORS)
 264                         Endpoint_Write_Byte(eeprom_read_byte(DescriptorPointer++));
 265                         #else
 266                         Endpoint_Write_Byte(pgm_read_byte(DescriptorPointer++));
 267                         #endif
 268
 269                         USB_ControlRequest.wLength--;
 270                 }
 271
 272                 SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);
 273                 Endpoint_ClearIN();
 274         }
 275
 276         if (SendZLP)
 277         {
 278                 while (!(Endpoint_IsINReady()));
 279                 Endpoint_ClearIN();
 280         }
 281
 282         while (!(Endpoint_IsOUTReceived()));
 283         #endif
 284
 285         Endpoint_ClearOUT();
 286 }
 287
 288 static void USB_Device_GetStatus(void)
 289 {
 290         uint8_t CurrentStatus = 0;
 291
 292         switch (USB_ControlRequest.bmRequestType)
 293         {
 294                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 295                         if (USB_CurrentlySelfPowered)
 296                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 297
 298                         if (USB_RemoteWakeupEnabled)
 299                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 300
 301                         break;
 302 #if !defined(CONTROL_ONLY_DEVICE)
 303                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 304                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex);
 305
 306                         CurrentStatus = Endpoint_IsStalled();
 307
 308                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 309
 310                         break;
 311 #endif
 312         }
 313
 314         Endpoint_ClearSETUP();
 315
 316         Endpoint_Write_Word_LE(CurrentStatus);
 317
 318         Endpoint_ClearIN();
 319
 320         while (!(Endpoint_IsOUTReceived()));
 321         Endpoint_ClearOUT();
 322 }
 323
 324 static void USB_Device_ClearSetFeature(void)
 325 {
 326         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 327         {
 328                 case REQREC_DEVICE:
 329                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 330                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 331                         else
 332                           return;
 333
 334                         break;
 335 #if !defined(CONTROL_ONLY_DEVICE)
 336                 case REQREC_ENDPOINT:
 337                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 338                         {
 339                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 340
 341                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 342                                   return;
 343
 344                                 Endpoint_SelectEndpoint(EndpointIndex);
 345
 346                                 if (Endpoint_IsEnabled())
 347                                 {
 348                                         if (USB_ControlRequest.bRequest == REQ_ClearFeature)
 349                                         {
 350                                                 Endpoint_ClearStall();
 351                                                 Endpoint_ResetFIFO(EndpointIndex);
 352                                                 Endpoint_ResetDataToggle();
 353                                         }
 354                                         else
 355                                         {
 356                                                 Endpoint_StallTransaction();
 357                                         }
 358                                 }
 359                         }
 360
 361                         break;
 362 #endif
 363         }
 364
 365         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 366
 367         Endpoint_ClearSETUP();
 368
 369         Endpoint_ClearIN();
 370 }
 371
 372 #endif