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 "USBMode.h"
  32 #if defined(USB_CAN_BE_DEVICE)
  33
  34 #define  INCLUDE_FROM_DEVCHAPTER9_C
  35 #include "DevChapter9.h"
  36
  37 uint8_t USB_ConfigurationNumber;
  38 bool    USB_RemoteWakeupEnabled;
  39 bool    USB_CurrentlySelfPowered;
  40
  41 void USB_Device_ProcessControlPacket(void)
  42 {
  43         uint8_t bmRequestType  = Endpoint_Read_Byte();
  44         uint8_t bRequest       = Endpoint_Read_Byte();
  45         bool    RequestHandled = false;
  46
  47         switch (bRequest)
  48         {
  49                 case REQ_GetStatus:
  50                         if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  51                             (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT)))
  52                         {
  53                                 USB_Device_GetStatus(bmRequestType);
  54                                 RequestHandled = true;
  55                         }
  56
  57                         break;
  58 #if !defined(NO_CLEARSET_FEATURE_REQUEST)
  59                 case REQ_ClearFeature:
  60                 case REQ_SetFeature:
  61                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT))
  62                         {
  63                                 USB_Device_ClearSetFeature(bRequest, bmRequestType);
  64                                 RequestHandled = true;
  65                         }
  66
  67                         break;
  68 #endif
  69                 case REQ_SetAddress:
  70                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
  71                         {
  72                                 USB_Device_SetAddress();
  73                                 RequestHandled = true;
  74                         }
  75
  76                         break;
  77                 case REQ_GetDescriptor:
  78                         if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  79                             (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE)))
  80                         {
  81                                 USB_Device_GetDescriptor();
  82                                 RequestHandled = true;
  83                         }
  84
  85                         break;
  86                 case REQ_GetConfiguration:
  87                         if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
  88                         {
  89                                 USB_Device_GetConfiguration();
  90                                 RequestHandled = true;
  91                         }
  92
  93                         break;
  94                 case REQ_SetConfiguration:
  95                         if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
  96                         {
  97                                 USB_Device_SetConfiguration();
  98                                 RequestHandled = true;
  99                         }
 100
 101                         break;
 102         }
 103
 104         if (!(RequestHandled))
 105           RAISE_EVENT(USB_UnhandledControlPacket, bRequest, bmRequestType);
 106
 107         if (Endpoint_IsSetupReceived())
 108         {
 109                 Endpoint_StallTransaction();
 110                 Endpoint_ClearSetupReceived();
 111         }
 112 }
 113
 114 static void USB_Device_SetAddress(void)
 115 {
 116         uint8_t wValue_LSB = Endpoint_Read_Byte();
 117
 118         Endpoint_ClearSetupReceived();
 119
 120         while (!(Endpoint_IsSetupINReady()));
 121
 122         Endpoint_ClearSetupIN();
 123
 124         while (!(Endpoint_IsSetupINReady()));
 125
 126         UDADDR = ((1 << ADDEN) | (wValue_LSB & 0x7F));
 127
 128         return;
 129 }
 130
 131 static void USB_Device_SetConfiguration(void)
 132 {
 133         uint8_t wValue_LSB        = Endpoint_Read_Byte();
 134         bool    AlreadyConfigured = (USB_ConfigurationNumber != 0);
 135
 136 #if defined(USE_SINGLE_DEVICE_CONFIGURATION)
 137         if (wValue_LSB > 1)
 138 #else
 139         USB_Descriptor_Device_t* DevDescriptorPtr;
 140
 141         if ((USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr) == NO_DESCRIPTOR) ||
 142         #if defined(USE_RAM_DESCRIPTORS)
 143             (wValue_LSB > DevDescriptorPtr->NumberOfConfigurations))
 144         #elif defined (USE_EEPROM_DESCRIPTORS)
 145             (wValue_LSB > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 146         #else
 147             (wValue_LSB > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 148         #endif
 149 #endif
 150         {
 151                 return;
 152         }
 153
 154         Endpoint_ClearSetupReceived();
 155
 156         USB_ConfigurationNumber = wValue_LSB;
 157
 158         Endpoint_ClearSetupIN();
 159
 160         if (!(AlreadyConfigured) && USB_ConfigurationNumber)
 161           RAISE_EVENT(USB_DeviceEnumerationComplete);
 162
 163         RAISE_EVENT(USB_ConfigurationChanged);
 164 }
 165
 166 void USB_Device_GetConfiguration(void)
 167 {
 168         Endpoint_ClearSetupReceived();
 169
 170         Endpoint_Write_Byte(USB_ConfigurationNumber);
 171
 172         Endpoint_ClearSetupIN();
 173
 174         while (!(Endpoint_IsSetupOUTReceived()));
 175         Endpoint_ClearSetupOUT();
 176 }
 177
 178 static void USB_Device_GetDescriptor(void)
 179 {
 180         uint16_t wValue  = Endpoint_Read_Word_LE();
 181         uint16_t wIndex  = Endpoint_Read_Word_LE();
 182         uint16_t wLength = Endpoint_Read_Word_LE();
 183
 184         void*    DescriptorPointer;
 185         uint16_t DescriptorSize;
 186
 187         bool     SendZLP;
 188
 189         if ((DescriptorSize = USB_GetDescriptor(wValue, wIndex, &DescriptorPointer)) == NO_DESCRIPTOR)
 190           return;
 191
 192         Endpoint_ClearSetupReceived();
 193
 194         if (wLength > DescriptorSize)
 195           wLength = DescriptorSize;
 196
 197         while (wLength)
 198         {
 199                 while (!(Endpoint_IsSetupINReady()))
 200                 {
 201                         if (Endpoint_IsSetupOUTReceived())
 202                         {
 203                                 Endpoint_ClearSetupOUT();
 204                                 return;
 205                         }
 206                 }
 207
 208                 while (wLength && (Endpoint_BytesInEndpoint() < USB_ControlEndpointSize))
 209                 {
 210                         #if defined(USE_RAM_DESCRIPTORS)
 211                         Endpoint_Write_Byte(*((uint8_t*)DescriptorPointer++));
 212                         #elif defined (USE_EEPROM_DESCRIPTORS)
 213                         Endpoint_Write_Byte(eeprom_read_byte(DescriptorPointer++));
 214                         #else
 215                         Endpoint_Write_Byte(pgm_read_byte(DescriptorPointer++));
 216                         #endif
 217
 218                         wLength--;
 219                 }
 220
 221                 SendZLP = (Endpoint_BytesInEndpoint() == USB_ControlEndpointSize);
 222                 Endpoint_ClearSetupIN();
 223         }
 224
 225         if (SendZLP)
 226         {
 227                 while (!(Endpoint_IsSetupINReady()));
 228                 Endpoint_ClearSetupIN();
 229         }
 230
 231         while (!(Endpoint_IsSetupOUTReceived()));
 232         Endpoint_ClearSetupOUT();
 233 }
 234
 235 static void USB_Device_GetStatus(const uint8_t bmRequestType)
 236 {
 237         uint8_t CurrentStatus = 0;
 238
 239         Endpoint_Discard_Word();
 240
 241         uint8_t wIndex_LSB = Endpoint_Read_Byte();
 242
 243         switch (bmRequestType)
 244         {
 245                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 246                         if (USB_CurrentlySelfPowered)
 247                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 248
 249                         if (USB_RemoteWakeupEnabled)
 250                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 251
 252                         break;
 253                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 254                         Endpoint_SelectEndpoint(wIndex_LSB);
 255
 256                         CurrentStatus = Endpoint_IsStalled();
 257
 258                         break;
 259         }
 260
 261         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 262         Endpoint_ClearSetupReceived();
 263         Endpoint_Write_Word_LE(CurrentStatus);
 264
 265         Endpoint_ClearSetupIN();
 266
 267         while (!(Endpoint_IsSetupOUTReceived()));
 268         Endpoint_ClearSetupOUT();
 269 }
 270
 271 #if !defined(NO_CLEARSET_FEATURE_REQUEST)
 272 static void USB_Device_ClearSetFeature(const uint8_t bRequest, const uint8_t bmRequestType)
 273 {
 274         uint16_t wValue = Endpoint_Read_Word_LE();
 275         uint16_t wIndex = Endpoint_Read_Word_LE();
 276
 277         switch (bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 278         {
 279                 case REQREC_ENDPOINT:
 280                         if (wValue == FEATURE_ENDPOINT_HALT)
 281                         {
 282                                 uint8_t EndpointIndex = (wIndex & ENDPOINT_EPNUM_MASK);
 283
 284                                 if (EndpointIndex != ENDPOINT_CONTROLEP)
 285                                 {
 286                                         Endpoint_SelectEndpoint(EndpointIndex);
 287
 288                                         if (Endpoint_IsEnabled())
 289                                         {
 290                                                 if (bRequest == REQ_ClearFeature)
 291                                                 {
 292                                                         Endpoint_ClearStall();
 293                                                         Endpoint_ResetFIFO(EndpointIndex);
 294                                                         Endpoint_ResetDataToggle();
 295                                                 }
 296                                                 else
 297                                                 {
 298                                                         Endpoint_StallTransaction();
 299                                                 }
 300                                         }
 301
 302                                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 303                                         Endpoint_ClearSetupReceived();
 304                                         Endpoint_ClearSetupIN();
 305                                 }
 306                         }
 307
 308                         break;
 309         }
 310 }
 311 #endif
 312
 313 #endif