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 ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 183                                                          &DescriptorPointer)) == NO_DESCRIPTOR)
 184         {
 185                 return;
 186         }
 187
 188         Endpoint_ClearSETUP();
 189
 190         #if defined(USE_RAM_DESCRIPTORS)
 191         Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 192         #else
 193         bool SendZLP;
 194
 195         if (USB_ControlRequest.wLength > DescriptorSize)
 196           USB_ControlRequest.wLength = DescriptorSize;
 197
 198         while (USB_ControlRequest.wLength)
 199         {
 200                 while (!(Endpoint_IsINReady()))
 201                 {
 202                         if (Endpoint_IsOUTReceived())
 203                         {
 204                                 Endpoint_ClearOUT();
 205                                 return;
 206                         }
 207                 }
 208
 209                 while (USB_ControlRequest.wLength && (Endpoint_BytesInEndpoint() < USB_ControlEndpointSize))
 210                 {
 211                         #if defined (USE_EEPROM_DESCRIPTORS)
 212                         Endpoint_Write_Byte(eeprom_read_byte(DescriptorPointer++));
 213                         #else
 214                         Endpoint_Write_Byte(pgm_read_byte(DescriptorPointer++));
 215                         #endif
 216
 217                         USB_ControlRequest.wLength--;
 218                 }
 219
 220                 SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);
 221                 Endpoint_ClearIN();
 222         }
 223
 224         if (SendZLP)
 225         {
 226                 while (!(Endpoint_IsINReady()));
 227                 Endpoint_ClearIN();
 228         }
 229
 230         while (!(Endpoint_IsOUTReceived()));
 231         #endif
 232
 233         Endpoint_ClearOUT();
 234 }
 235
 236 static void USB_Device_GetStatus(void)
 237 {
 238         uint8_t CurrentStatus = 0;
 239
 240         switch (USB_ControlRequest.bmRequestType)
 241         {
 242                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 243                         if (USB_CurrentlySelfPowered)
 244                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 245
 246                         if (USB_RemoteWakeupEnabled)
 247                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 248
 249                         break;
 250 #if !defined(CONTROL_ONLY_DEVICE)
 251                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 252                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex);
 253
 254                         CurrentStatus = Endpoint_IsStalled();
 255
 256                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 257
 258                         break;
 259 #endif
 260         }
 261
 262         Endpoint_ClearSETUP();
 263
 264         Endpoint_Write_Word_LE(CurrentStatus);
 265
 266         Endpoint_ClearIN();
 267
 268         while (!(Endpoint_IsOUTReceived()));
 269         Endpoint_ClearOUT();
 270 }
 271
 272 static void USB_Device_ClearSetFeature(void)
 273 {
 274         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 275         {
 276                 case REQREC_DEVICE:
 277                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_REMOTE_WAKEUP)
 278                           USB_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 279                         else
 280                           return;
 281
 282                         break;
 283 #if !defined(CONTROL_ONLY_DEVICE)
 284                 case REQREC_ENDPOINT:
 285                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_ENDPOINT_HALT)
 286                         {
 287                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 288
 289                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 290                                   return;
 291
 292                                 Endpoint_SelectEndpoint(EndpointIndex);
 293
 294                                 if (Endpoint_IsEnabled())
 295                                 {
 296                                         if (USB_ControlRequest.bRequest == REQ_ClearFeature)
 297                                         {
 298                                                 Endpoint_ClearStall();
 299                                                 Endpoint_ResetFIFO(EndpointIndex);
 300                                                 Endpoint_ResetDataToggle();
 301                                         }
 302                                         else
 303                                         {
 304                                                 Endpoint_StallTransaction();
 305                                         }
 306                                 }
 307                         }
 308
 309                         break;
 310 #endif
 311         }
 312
 313         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 314
 315         Endpoint_ClearSETUP();
 316
 317         Endpoint_ClearIN();
 318 }
 319
 320 #endif