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