protocol/lufa/LUFA-120730/LUFA/Drivers/USB/Core/HostStandardReq.c

   1 /*\r
   2              LUFA Library\r
   3      Copyright (C) Dean Camera, 2012.\r
   4 \r
   5   dean [at] fourwalledcubicle [dot] com\r
   6            www.lufa-lib.org\r
   7 */\r
   8 \r
   9 /*\r
  10   Copyright 2012  Dean Camera (dean [at] fourwalledcubicle [dot] com)\r
  11 \r
  12   Permission to use, copy, modify, distribute, and sell this\r
  13   software and its documentation for any purpose is hereby granted\r
  14   without fee, provided that the above copyright notice appear in\r
  15   all copies and that both that the copyright notice and this\r
  16   permission notice and warranty disclaimer appear in supporting\r
  17   documentation, and that the name of the author not be used in\r
  18   advertising or publicity pertaining to distribution of the\r
  19   software without specific, written prior permission.\r
  20 \r
  21   The author disclaim all warranties with regard to this\r
  22   software, including all implied warranties of merchantability\r
  23   and fitness.  In no event shall the author be liable for any\r
  24   special, indirect or consequential damages or any damages\r
  25   whatsoever resulting from loss of use, data or profits, whether\r
  26   in an action of contract, negligence or other tortious action,\r
  27   arising out of or in connection with the use or performance of\r
  28   this software.\r
  29 */\r
  30 \r
  31 #define  __INCLUDE_FROM_USB_DRIVER\r
  32 #include "USBMode.h"\r
  33 \r
  34 #if defined(USB_CAN_BE_HOST)\r
  35 \r
  36 #define  __INCLUDE_FROM_HOSTSTDREQ_C\r
  37 #include "HostStandardReq.h"\r
  38 \r
  39 uint8_t USB_Host_ConfigurationNumber;\r
  40 \r
  41 static uint8_t USB_Host_SendControlRequest_PRV(void* const BufferPtr)\r
  42 {\r
  43         uint8_t* DataStream   = (uint8_t*)BufferPtr;\r
  44         uint8_t  ReturnStatus = HOST_SENDCONTROL_Successful;\r
  45         uint16_t DataLen      = USB_ControlRequest.wLength;\r
  46 \r
  47         USB_Host_ResumeBus();\r
  48 \r
  49         if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)\r
  50           return ReturnStatus;\r
  51 \r
  52         Pipe_SetPipeToken(PIPE_TOKEN_SETUP);\r
  53         Pipe_ClearError();\r
  54 \r
  55         Pipe_Unfreeze();\r
  56 \r
  57         #if defined(ARCH_BIG_ENDIAN)\r
  58         Pipe_Write_8(USB_ControlRequest.bmRequestType);\r
  59         Pipe_Write_8(USB_ControlRequest.bRequest);\r
  60         Pipe_Write_16_LE(USB_ControlRequest.wValue);\r
  61         Pipe_Write_16_LE(USB_ControlRequest.wIndex);\r
  62         Pipe_Write_16_LE(USB_ControlRequest.wLength);\r
  63         #else\r
  64         uint8_t* HeaderStream = (uint8_t*)&USB_ControlRequest;\r
  65 \r
  66         for (uint8_t HeaderByte = 0; HeaderByte < sizeof(USB_Request_Header_t); HeaderByte++)\r
  67           Pipe_Write_8(*(HeaderStream++));\r
  68         #endif\r
  69 \r
  70         Pipe_ClearSETUP();\r
  71 \r
  72         if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_SetupSent)) != HOST_SENDCONTROL_Successful)\r
  73           return ReturnStatus;\r
  74 \r
  75         Pipe_Freeze();\r
  76 \r
  77         if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)\r
  78           return ReturnStatus;\r
  79 \r
  80         if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_DIRECTION) == REQDIR_DEVICETOHOST)\r
  81         {\r
  82                 Pipe_SetPipeToken(PIPE_TOKEN_IN);\r
  83 \r
  84                 if (DataStream != NULL)\r
  85                 {\r
  86                         while (DataLen)\r
  87                         {\r
  88                                 Pipe_Unfreeze();\r
  89 \r
  90                                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_InReceived)) != HOST_SENDCONTROL_Successful)\r
  91                                   return ReturnStatus;\r
  92 \r
  93                                 if (!(Pipe_BytesInPipe()))\r
  94                                   DataLen = 0;\r
  95 \r
  96                                 while (Pipe_BytesInPipe() && DataLen)\r
  97                                 {\r
  98                                         *(DataStream++) = Pipe_Read_8();\r
  99                                         DataLen--;\r
 100                                 }\r
 101 \r
 102                                 Pipe_Freeze();\r
 103                                 Pipe_ClearIN();\r
 104                         }\r
 105                 }\r
 106 \r
 107                 Pipe_SetPipeToken(PIPE_TOKEN_OUT);\r
 108                 Pipe_Unfreeze();\r
 109 \r
 110                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)\r
 111                   return ReturnStatus;\r
 112 \r
 113                 Pipe_ClearOUT();\r
 114 \r
 115                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)\r
 116                   return ReturnStatus;\r
 117         }\r
 118         else\r
 119         {\r
 120                 if (DataStream != NULL)\r
 121                 {\r
 122                         Pipe_SetPipeToken(PIPE_TOKEN_OUT);\r
 123                         Pipe_Unfreeze();\r
 124 \r
 125                         while (DataLen)\r
 126                         {\r
 127                                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)\r
 128                                   return ReturnStatus;\r
 129 \r
 130                                 while (DataLen && (Pipe_BytesInPipe() < USB_Host_ControlPipeSize))\r
 131                                 {\r
 132                                         Pipe_Write_8(*(DataStream++));\r
 133                                         DataLen--;\r
 134                                 }\r
 135 \r
 136                                 Pipe_ClearOUT();\r
 137                         }\r
 138 \r
 139                         if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)\r
 140                           return ReturnStatus;\r
 141 \r
 142                         Pipe_Freeze();\r
 143                 }\r
 144 \r
 145                 Pipe_SetPipeToken(PIPE_TOKEN_IN);\r
 146                 Pipe_Unfreeze();\r
 147 \r
 148                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_InReceived)) != HOST_SENDCONTROL_Successful)\r
 149                   return ReturnStatus;\r
 150 \r
 151                 Pipe_ClearIN();\r
 152         }\r
 153         \r
 154         return ReturnStatus;\r
 155 }\r
 156 \r
 157 static uint8_t USB_Host_WaitForIOS(const uint8_t WaitType)\r
 158 {\r
 159         #if (USB_HOST_TIMEOUT_MS < 0xFF)\r
 160         uint8_t  TimeoutCounter = USB_HOST_TIMEOUT_MS;\r
 161         #else\r
 162         uint16_t TimeoutCounter = USB_HOST_TIMEOUT_MS;\r
 163         #endif\r
 164 \r
 165         while (!(((WaitType == USB_HOST_WAITFOR_SetupSent)  && Pipe_IsSETUPSent())  ||\r
 166                  ((WaitType == USB_HOST_WAITFOR_InReceived) && Pipe_IsINReceived()) ||\r
 167                  ((WaitType == USB_HOST_WAITFOR_OutReady)   && Pipe_IsOUTReady())))\r
 168         {\r
 169                 uint8_t ErrorCode;\r
 170 \r
 171                 if ((ErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)\r
 172                   return ErrorCode;\r
 173 \r
 174                 if (!(TimeoutCounter--))\r
 175                   return HOST_SENDCONTROL_SoftwareTimeOut;\r
 176         }\r
 177 \r
 178         return HOST_SENDCONTROL_Successful;\r
 179 }\r
 180 \r
 181 uint8_t USB_Host_SendControlRequest(void* const BufferPtr)\r
 182 {\r
 183         bool BusSuspended    = USB_Host_IsBusSuspended();\r
 184         uint8_t ReturnStatus = USB_Host_SendControlRequest_PRV(BufferPtr);\r
 185 \r
 186         Pipe_Freeze();\r
 187 \r
 188         if (BusSuspended)\r
 189           USB_Host_SuspendBus();\r
 190 \r
 191         Pipe_ResetPipe(PIPE_CONTROLPIPE);\r
 192 \r
 193         return ReturnStatus;\r
 194 }\r
 195 \r
 196 uint8_t USB_Host_SetDeviceConfiguration(const uint8_t ConfigNumber)\r
 197 {\r
 198         uint8_t ErrorCode;\r
 199 \r
 200         USB_ControlRequest = (USB_Request_Header_t)\r
 201                 {\r
 202                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),\r
 203                         .bRequest      = REQ_SetConfiguration,\r
 204                         .wValue        = ConfigNumber,\r
 205                         .wIndex        = 0,\r
 206                         .wLength       = 0,\r
 207                 };\r
 208 \r
 209         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 210 \r
 211         if ((ErrorCode = USB_Host_SendControlRequest(NULL)) == HOST_SENDCONTROL_Successful)\r
 212         {\r
 213                 USB_Host_ConfigurationNumber = ConfigNumber;\r
 214                 USB_HostState                = (ConfigNumber) ? HOST_STATE_Configured : HOST_STATE_Addressed;\r
 215         }\r
 216 \r
 217         return ErrorCode;\r
 218 }\r
 219 \r
 220 uint8_t USB_Host_GetDeviceConfiguration(uint8_t* const ConfigNumber)\r
 221 {\r
 222         USB_ControlRequest = (USB_Request_Header_t)\r
 223                 {\r
 224                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),\r
 225                         .bRequest      = REQ_GetConfiguration,\r
 226                         .wValue        = 0,\r
 227                         .wIndex        = 0,\r
 228                         .wLength       = sizeof(uint8_t),\r
 229                 };\r
 230 \r
 231         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 232 \r
 233         return USB_Host_SendControlRequest(ConfigNumber);\r
 234 }\r
 235 \r
 236 uint8_t USB_Host_GetDescriptor(const uint8_t Type,\r
 237                                const uint8_t Index,\r
 238                                void* const Buffer,\r
 239                                const uint8_t BufferLength)\r
 240 {\r
 241         USB_ControlRequest = (USB_Request_Header_t)\r
 242                 {\r
 243                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),\r
 244                         .bRequest      = REQ_GetDescriptor,\r
 245                         .wValue        = (((uint16_t)Type << 8) | Index),\r
 246                         .wIndex        = 0,\r
 247                         .wLength       = BufferLength,\r
 248                 };\r
 249 \r
 250         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 251 \r
 252         return USB_Host_SendControlRequest(Buffer);\r
 253 }\r
 254 \r
 255 uint8_t USB_Host_GetDeviceStatus(uint8_t* const FeatureStatus)\r
 256 {\r
 257         USB_ControlRequest = (USB_Request_Header_t)\r
 258                 {\r
 259                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),\r
 260                         .bRequest      = REQ_GetStatus,\r
 261                         .wValue        = 0,\r
 262                         .wIndex        = 0,\r
 263                         .wLength       = 0,\r
 264                 };\r
 265 \r
 266         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 267 \r
 268         return USB_Host_SendControlRequest(FeatureStatus);\r
 269 }\r
 270 \r
 271 uint8_t USB_Host_ClearEndpointStall(const uint8_t EndpointAddress)\r
 272 {\r
 273         USB_ControlRequest = (USB_Request_Header_t)\r
 274                 {\r
 275                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT),\r
 276                         .bRequest      = REQ_ClearFeature,\r
 277                         .wValue        = FEATURE_SEL_EndpointHalt,\r
 278                         .wIndex        = EndpointAddress,\r
 279                         .wLength       = 0,\r
 280                 };\r
 281 \r
 282         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 283 \r
 284         return USB_Host_SendControlRequest(NULL);\r
 285 }\r
 286 \r
 287 uint8_t USB_Host_SetInterfaceAltSetting(const uint8_t InterfaceIndex,\r
 288                                         const uint8_t AltSetting)\r
 289 {\r
 290         USB_ControlRequest = (USB_Request_Header_t)\r
 291                 {\r
 292                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),\r
 293                         .bRequest      = REQ_SetInterface,\r
 294                         .wValue        = AltSetting,\r
 295                         .wIndex        = InterfaceIndex,\r
 296                         .wLength       = 0,\r
 297                 };\r
 298 \r
 299         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 300 \r
 301         return USB_Host_SendControlRequest(NULL);\r
 302 }\r
 303 \r
 304 uint8_t USB_Host_GetInterfaceAltSetting(const uint8_t InterfaceIndex,\r
 305                                         uint8_t* const AltSetting)\r
 306 {\r
 307         USB_ControlRequest = (USB_Request_Header_t)\r
 308                 {\r
 309                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),\r
 310                         .bRequest      = REQ_GetInterface,\r
 311                         .wValue        = 0,\r
 312                         .wIndex        = InterfaceIndex,\r
 313                         .wLength       = sizeof(uint8_t),\r
 314                 };\r
 315 \r
 316         Pipe_SelectPipe(PIPE_CONTROLPIPE);\r
 317 \r
 318         return USB_Host_SendControlRequest(AltSetting);\r
 319 }\r
 320 \r
 321 #endif\r
 322 \r