LUFA/Drivers/USB/Core/DeviceStandardReq.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all 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 #define  __INCLUDE_FROM_USB_DRIVER
  32 #include "USBMode.h"
  33
  34 #if defined(USB_CAN_BE_DEVICE)
  35
  36 #define  __INCLUDE_FROM_DEVICESTDREQ_C
  37 #include "DeviceStandardReq.h"
  38
  39 uint8_t USB_Device_ConfigurationNumber;
  40
  41 #if !defined(NO_DEVICE_SELF_POWER)
  42 bool    USB_Device_CurrentlySelfPowered;
  43 #endif
  44
  45 #if !defined(NO_DEVICE_REMOTE_WAKEUP)
  46 bool    USB_Device_RemoteWakeupEnabled;
  47 #endif
  48
  49 void USB_Device_ProcessControlRequest(void)
  50 {
  51         #if defined(ARCH_BIG_ENDIAN)
  52         USB_ControlRequest.bmRequestType = Endpoint_Read_8();
  53         USB_ControlRequest.bRequest      = Endpoint_Read_8();
  54         USB_ControlRequest.wValue        = Endpoint_Read_16_LE();
  55         USB_ControlRequest.wIndex        = Endpoint_Read_16_LE();
  56         USB_ControlRequest.wLength       = Endpoint_Read_16_LE();
  57         #else
  58         uint8_t* RequestHeader = (uint8_t*)&USB_ControlRequest;
  59
  60         for (uint8_t RequestHeaderByte = 0; RequestHeaderByte < sizeof(USB_Request_Header_t); RequestHeaderByte++)
  61           *(RequestHeader++) = Endpoint_Read_8();
  62         #endif
  63
  64         EVENT_USB_Device_ControlRequest();
  65
  66         if (Endpoint_IsSETUPReceived())
  67         {
  68                 uint8_t bmRequestType = USB_ControlRequest.bmRequestType;
  69
  70                 switch (USB_ControlRequest.bRequest)
  71                 {
  72                         case REQ_GetStatus:
  73                                 if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  74                                         (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT)))
  75                                 {
  76                                         USB_Device_GetStatus();
  77                                 }
  78
  79                                 break;
  80                         case REQ_ClearFeature:
  81                         case REQ_SetFeature:
  82                                 if ((bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  83                                         (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT)))
  84                                 {
  85                                         USB_Device_ClearSetFeature();
  86                                 }
  87
  88                                 break;
  89                         case REQ_SetAddress:
  90                                 if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
  91                                   USB_Device_SetAddress();
  92
  93                                 break;
  94                         case REQ_GetDescriptor:
  95                                 if ((bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE)) ||
  96                                         (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE)))
  97                                 {
  98                                         USB_Device_GetDescriptor();
  99                                 }
 100
 101                                 break;
 102                         case REQ_GetConfiguration:
 103                                 if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE))
 104                                   USB_Device_GetConfiguration();
 105
 106                                 break;
 107                         case REQ_SetConfiguration:
 108                                 if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE))
 109                                   USB_Device_SetConfiguration();
 110
 111                                 break;
 112                 }
 113         }
 114
 115         if (Endpoint_IsSETUPReceived())
 116         {
 117                 Endpoint_StallTransaction();
 118                 Endpoint_ClearSETUP();
 119         }
 120 }
 121
 122 static void USB_Device_SetAddress(void)
 123 {
 124         uint8_t    DeviceAddress    = (USB_ControlRequest.wValue & 0x7F);
 125         uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask();
 126         GlobalInterruptDisable();
 127
 128         Endpoint_ClearSETUP();
 129
 130         Endpoint_ClearStatusStage();
 131
 132         while (!(Endpoint_IsINReady()));
 133
 134         USB_Device_SetDeviceAddress(DeviceAddress);
 135         USB_DeviceState = (DeviceAddress) ? DEVICE_STATE_Addressed : DEVICE_STATE_Default;
 136
 137         SetGlobalInterruptMask(CurrentGlobalInt);
 138 }
 139
 140 static void USB_Device_SetConfiguration(void)
 141 {
 142         #if defined(FIXED_NUM_CONFIGURATIONS)
 143         if ((uint8_t)USB_ControlRequest.wValue > FIXED_NUM_CONFIGURATIONS)
 144           return;
 145         #else
 146         USB_Descriptor_Device_t* DevDescriptorPtr;
 147
 148         #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE)
 149                 #if defined(USE_FLASH_DESCRIPTORS)
 150                         #define MemoryAddressSpace  MEMSPACE_FLASH
 151                 #elif defined(USE_EEPROM_DESCRIPTORS)
 152                         #define MemoryAddressSpace  MEMSPACE_EEPROM
 153                 #elif defined(USE_SRAM_DESCRIPTORS)
 154                         #define MemoryAddressSpace  MEMSPACE_SRAM
 155                 #else
 156                         uint8_t MemoryAddressSpace;
 157                 #endif
 158         #endif
 159
 160         if (CALLBACK_USB_GetDescriptor((DTYPE_Device << 8), 0, (void*)&DevDescriptorPtr
 161         #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE) && \
 162             !(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
 163                                        , &MemoryAddressSpace
 164         #endif
 165                                        ) == NO_DESCRIPTOR)
 166         {
 167                 return;
 168         }
 169
 170         #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE)
 171         if (MemoryAddressSpace == MEMSPACE_FLASH)
 172         {
 173                 if (((uint8_t)USB_ControlRequest.wValue > pgm_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 174                   return;
 175         }
 176         else if (MemoryAddressSpace == MEMSPACE_EEPROM)
 177         {
 178                 if (((uint8_t)USB_ControlRequest.wValue > eeprom_read_byte(&DevDescriptorPtr->NumberOfConfigurations)))
 179                   return;
 180         }
 181         else
 182         {
 183                 if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 184                   return;
 185         }
 186         #else
 187         if ((uint8_t)USB_ControlRequest.wValue > DevDescriptorPtr->NumberOfConfigurations)
 188           return;
 189         #endif
 190         #endif
 191
 192         Endpoint_ClearSETUP();
 193
 194         USB_Device_ConfigurationNumber = (uint8_t)USB_ControlRequest.wValue;
 195
 196         Endpoint_ClearStatusStage();
 197
 198         if (USB_Device_ConfigurationNumber)
 199           USB_DeviceState = DEVICE_STATE_Configured;
 200         else
 201           USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered;
 202
 203         EVENT_USB_Device_ConfigurationChanged();
 204 }
 205
 206 static void USB_Device_GetConfiguration(void)
 207 {
 208         Endpoint_ClearSETUP();
 209
 210         Endpoint_Write_8(USB_Device_ConfigurationNumber);
 211         Endpoint_ClearIN();
 212
 213         Endpoint_ClearStatusStage();
 214 }
 215
 216 #if !defined(NO_INTERNAL_SERIAL) && (USE_INTERNAL_SERIAL != NO_DESCRIPTOR)
 217 static void USB_Device_GetInternalSerialDescriptor(void)
 218 {
 219         struct
 220         {
 221                 USB_Descriptor_Header_t Header;
 222                 uint16_t                UnicodeString[INTERNAL_SERIAL_LENGTH_BITS / 4];
 223         } SignatureDescriptor;
 224
 225         SignatureDescriptor.Header.Type = DTYPE_String;
 226         SignatureDescriptor.Header.Size = USB_STRING_LEN(INTERNAL_SERIAL_LENGTH_BITS / 4);
 227
 228         USB_Device_GetSerialString(SignatureDescriptor.UnicodeString);
 229
 230         Endpoint_ClearSETUP();
 231
 232         Endpoint_Write_Control_Stream_LE(&SignatureDescriptor, sizeof(SignatureDescriptor));
 233         Endpoint_ClearOUT();
 234 }
 235 #endif
 236
 237 static void USB_Device_GetDescriptor(void)
 238 {
 239         const void* DescriptorPointer;
 240         uint16_t    DescriptorSize;
 241
 242         #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE) && \
 243             !(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
 244         uint8_t DescriptorAddressSpace;
 245         #endif
 246
 247         #if !defined(NO_INTERNAL_SERIAL) && (USE_INTERNAL_SERIAL != NO_DESCRIPTOR)
 248         if (USB_ControlRequest.wValue == ((DTYPE_String << 8) | USE_INTERNAL_SERIAL))
 249         {
 250                 USB_Device_GetInternalSerialDescriptor();
 251                 return;
 252         }
 253         #endif
 254
 255         if ((DescriptorSize = CALLBACK_USB_GetDescriptor(USB_ControlRequest.wValue, USB_ControlRequest.wIndex,
 256                                                          &DescriptorPointer
 257         #if defined(ARCH_HAS_MULTI_ADDRESS_SPACE) && \
 258             !(defined(USE_FLASH_DESCRIPTORS) || defined(USE_EEPROM_DESCRIPTORS) || defined(USE_RAM_DESCRIPTORS))
 259                                                          , &DescriptorAddressSpace
 260         #endif
 261                                                                                                          )) == NO_DESCRIPTOR)
 262         {
 263                 return;
 264         }
 265
 266         Endpoint_ClearSETUP();
 267
 268         #if defined(USE_RAM_DESCRIPTORS) || !defined(ARCH_HAS_MULTI_ADDRESS_SPACE)
 269         Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 270         #elif defined(USE_EEPROM_DESCRIPTORS)
 271         Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 272         #elif defined(USE_FLASH_DESCRIPTORS)
 273         Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 274         #else
 275         if (DescriptorAddressSpace == MEMSPACE_FLASH)
 276           Endpoint_Write_Control_PStream_LE(DescriptorPointer, DescriptorSize);
 277         else if (DescriptorAddressSpace == MEMSPACE_EEPROM)
 278           Endpoint_Write_Control_EStream_LE(DescriptorPointer, DescriptorSize);
 279         else
 280           Endpoint_Write_Control_Stream_LE(DescriptorPointer, DescriptorSize);
 281         #endif
 282
 283         Endpoint_ClearOUT();
 284 }
 285
 286 static void USB_Device_GetStatus(void)
 287 {
 288         uint8_t CurrentStatus = 0;
 289
 290         switch (USB_ControlRequest.bmRequestType)
 291         {
 292                 #if !defined(NO_DEVICE_SELF_POWER) || !defined(NO_DEVICE_REMOTE_WAKEUP)
 293                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE):
 294                         #if !defined(NO_DEVICE_SELF_POWER)
 295                         if (USB_Device_CurrentlySelfPowered)
 296                           CurrentStatus |= FEATURE_SELFPOWERED_ENABLED;
 297                         #endif
 298
 299                         #if !defined(NO_DEVICE_REMOTE_WAKEUP)
 300                         if (USB_Device_RemoteWakeupEnabled)
 301                           CurrentStatus |= FEATURE_REMOTE_WAKEUP_ENABLED;
 302                         #endif
 303                         break;
 304                 #endif
 305                 #if !defined(CONTROL_ONLY_DEVICE)
 306                 case (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_ENDPOINT):
 307                         Endpoint_SelectEndpoint((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 308
 309                         CurrentStatus = Endpoint_IsStalled();
 310
 311                         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 312
 313                         break;
 314                 #endif
 315                 default:
 316                         return;
 317         }
 318
 319         Endpoint_ClearSETUP();
 320
 321         Endpoint_Write_16_LE(CurrentStatus);
 322         Endpoint_ClearIN();
 323
 324         Endpoint_ClearStatusStage();
 325 }
 326
 327 static void USB_Device_ClearSetFeature(void)
 328 {
 329         switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
 330         {
 331                 #if !defined(NO_DEVICE_REMOTE_WAKEUP)
 332                 case REQREC_DEVICE:
 333                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
 334                           USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
 335                         else
 336                           return;
 337
 338                         break;
 339                 #endif
 340                 #if !defined(CONTROL_ONLY_DEVICE)
 341                 case REQREC_ENDPOINT:
 342                         if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
 343                         {
 344                                 uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
 345
 346                                 if (EndpointIndex == ENDPOINT_CONTROLEP)
 347                                   return;
 348
 349                                 Endpoint_SelectEndpoint(EndpointIndex);
 350
 351                                 if (Endpoint_IsEnabled())
 352                                 {
 353                                         if (USB_ControlRequest.bRequest == REQ_SetFeature)
 354                                         {
 355                                                 Endpoint_StallTransaction();
 356                                         }
 357                                         else
 358                                         {
 359                                                 Endpoint_ClearStall();
 360                                                 Endpoint_ResetEndpoint(EndpointIndex);
 361                                                 Endpoint_ResetDataToggle();
 362                                         }
 363                                 }
 364                         }
 365
 366                         break;
 367                 #endif
 368                 default:
 369                         return;
 370         }
 371
 372         Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
 373
 374         Endpoint_ClearSETUP();
 375
 376         Endpoint_ClearStatusStage();
 377 }
 378
 379 #endif
 380