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 #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 178 static void USB_Device_GetInternalSerialDescriptor(void)
 179 {
 180         struct
 181         {
 182                 USB_Descriptor_Header_t Header;
 183                 int16_t                 UnicodeString[12];
 184         } SignatureDescriptor;
 185
 186         uint8_t SigReadAddress  = 0x0E;
 187         bool    OddNibbleRead   = false;
 188
 189         #if defined(USE_NONSTANDARD_DESCRIPTOR_NAMES)
 190                 SignatureDescriptor.Header.Size            = sizeof(SignatureDescriptor);
 191                 SignatureDescriptor.Header.Type            = DTYPE_String;
 192         #else
 193                 SignatureDescriptor.Header.bLength         = sizeof(SignatureDescriptor);
 194                 SignatureDescriptor.Header.bDescriptorType = DTYPE_String;
 195         #endif
 196
 197         for (uint8_t SerialCharNum = 0; SerialCharNum < 12; SerialCharNum++)
 198         {
 199                 uint8_t SerialByte = boot_signature_byte_get(SigReadAddress);
 200
 201                 if (OddNibbleRead)
 202                 {
 203                         SerialByte >>= 4;
 204                         SigReadAddress++;
 205                 }
 206                 else
 207                 {
 208                         SerialByte &= 0x0F;
 209                 }
 210
 211                 OddNibbleRead = !(OddNibbleRead);
 212
 213                 if (SerialByte < 0x0A)
 214                   SerialByte += '0';
 215                 else
 216                   SerialByte += ('A' - 0x0A);
 217
 218                 SignatureDescriptor.UnicodeString[SerialCharNum] = SerialByte;
 219         }
 220
 221         Endpoint_ClearSETUP();
 222         Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 223         Endpoint_ClearOUT();
 224 }
 225 #endif
 226
 227 static void USB_Device_GetDescriptor(void)
 228 {
 229         void*    DescriptorPointer;
 230         uint16_t DescriptorSize;
 231
 232         #if !defined(NO_INTERNAL_SERIAL) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR))
 233         if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
 234         {
 235                 USB_Device_GetInternalSerialDescriptor();
 236                 return;
 237         }
 238         #endif
 239
 240         if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 241                                                          &DescriptorPointer)) == NO_DESCRIPTOR)
 242         {
 243                 return;
 244         }
 245
 246         Endpoint_ClearSETUP();
 247
 248         #if defined(USE_RAM_DESCRIPTORS)
 249         Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 250         #elif defined(USE_EEPROM_DESCRIPTORS)
 251         Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 252         #else
 253         Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 254         #endif
 255
 256         Endpoint_ClearOUT();
 257 }
 258
 259 static void USB_Device_GetStatus(void)
 260 {
 261         uint8_t CurrentStatus = 0;
 262
 263         switch (USB_ControlRequest.bmRequestType)
 264         {
 265                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 266                         if (USB_CurrentlySelfPowered)
 267                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 268
 269                         if (USB_RemoteWakeupEnabled)
 270                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 271
 272                         break;
 273 #if !defined(CONTROL_ONLY_DEVICE)
 274                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 275                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex);
 276
 277                         CurrentStatus = Endpoint_IsStalled();
 278
 279                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 280
 281                         break;
 282 #endif
 283         }
 284
 285         Endpoint_ClearSETUP();
 286
 287         Endpoint_Write_Word_LE(CurrentStatus);
 288
 289         Endpoint_ClearIN();
 290
 291         while (!(Endpoint_IsOUTReceived()));
 292         Endpoint_ClearOUT();
 293 }
 294
 295 static void USB_Device_ClearSetFeature(void)
 296 {
 297         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 298         {
 299                 case REQREC_DEVICE:
 300                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 301                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 302                         else
 303                           return;
 304
 305                         break;
 306 #if !defined(CONTROL_ONLY_DEVICE)
 307                 case REQREC_ENDPOINT:
 308                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 309                         {
 310                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 311
 312                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 313                                   return;
 314
 315                                 Endpoint_SelectEndpoint(EndpointIndex);
 316
 317                                 if (Endpoint_IsEnabled())
 318                                 {
 319                                         if (USB_ControlRequest.bRequest == REQ_ClearFeature)
 320                                         {
 321                                                 Endpoint_ClearStall();
 322                                                 Endpoint_ResetFIFO(EndpointIndex);
 323                                                 Endpoint_ResetDataToggle();
 324                                         }
 325                                         else
 326                                         {
 327                                                 Endpoint_StallTransaction();
 328                                         }
 329                                 }
 330                         }
 331
 332                         break;
 333 #endif
 334         }
 335
 336         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 337
 338         Endpoint_ClearSETUP();
 339
 340         Endpoint_ClearIN();
 341 }
 342
 343 #endif