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         #elif defined(USE_EEPROM_DESCRIPTORS)
 245         Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 246         #else
 247         Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 248         #endif
 249
 250         Endpoint_ClearOUT();
 251 }
 252
 253 static void USB_Device_GetStatus(void)
 254 {
 255         uint8_t CurrentStatus = 0;
 256
 257         switch (USB_ControlRequest.bmRequestType)
 258         {
 259                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 260                         if (USB_CurrentlySelfPowered)
 261                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 262
 263                         if (USB_RemoteWakeupEnabled)
 264                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 265
 266                         break;
 267 #if !defined(CONTROL_ONLY_DEVICE)
 268                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 269                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex);
 270
 271                         CurrentStatus = Endpoint_IsStalled();
 272
 273                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 274
 275                         break;
 276 #endif
 277         }
 278
 279         Endpoint_ClearSETUP();
 280
 281         Endpoint_Write_Word_LE(CurrentStatus);
 282
 283         Endpoint_ClearIN();
 284
 285         while (!(Endpoint_IsOUTReceived()));
 286         Endpoint_ClearOUT();
 287 }
 288
 289 static void USB_Device_ClearSetFeature(void)
 290 {
 291         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 292         {
 293                 case REQREC_DEVICE:
 294                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 295                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 296                         else
 297                           return;
 298
 299                         break;
 300 #if !defined(CONTROL_ONLY_DEVICE)
 301                 case REQREC_ENDPOINT:
 302                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 303                         {
 304                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 305
 306                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 307                                   return;
 308
 309                                 Endpoint_SelectEndpoint(EndpointIndex);
 310
 311                                 if (Endpoint_IsEnabled())
 312                                 {
 313                                         if (USB_ControlRequest.bRequest == REQ_ClearFeature)
 314                                         {
 315                                                 Endpoint_ClearStall();
 316                                                 Endpoint_ResetFIFO(EndpointIndex);
 317                                                 Endpoint_ResetDataToggle();
 318                                         }
 319                                         else
 320                                         {
 321                                                 Endpoint_StallTransaction();
 322                                         }
 323                                 }
 324                         }
 325
 326                         break;
 327 #endif
 328         }
 329
 330         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 331
 332         Endpoint_ClearSETUP();
 333
 334         Endpoint_ClearIN();
 335 }
 336
 337 #endif