LUFA/Drivers/USB/Core/HostStandardReq.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2013.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2013  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 disclaims 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_HOST)
  35
  36 #define  __INCLUDE_FROM_HOSTSTDREQ_C
  37 #include "HostStandardReq.h"
  38
  39 uint8_t USB_Host_ConfigurationNumber;
  40
  41 static uint8_t USB_Host_SendControlRequest_PRV(void* const BufferPtr)
  42 {
  43         uint8_t* DataStream   = (uint8_t*)BufferPtr;
  44         uint8_t  ReturnStatus = HOST_SENDCONTROL_Successful;
  45         uint16_t DataLen      = USB_ControlRequest.wLength;
  46
  47         USB_Host_ResumeBus();
  48
  49         if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)
  50           return ReturnStatus;
  51
  52         Pipe_SetPipeToken(PIPE_TOKEN_SETUP);
  53         Pipe_ClearError();
  54
  55         Pipe_Unfreeze();
  56
  57         #if defined(ARCH_BIG_ENDIAN)
  58         Pipe_Write_8(USB_ControlRequest.bmRequestType);
  59         Pipe_Write_8(USB_ControlRequest.bRequest);
  60         Pipe_Write_16_LE(USB_ControlRequest.wValue);
  61         Pipe_Write_16_LE(USB_ControlRequest.wIndex);
  62         Pipe_Write_16_LE(USB_ControlRequest.wLength);
  63         #else
  64         uint8_t* HeaderStream = (uint8_t*)&USB_ControlRequest;
  65
  66         for (uint8_t HeaderByte = 0; HeaderByte < sizeof(USB_Request_Header_t); HeaderByte++)
  67           Pipe_Write_8(*(HeaderStream++));
  68         #endif
  69
  70         Pipe_ClearSETUP();
  71
  72         if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_SetupSent)) != HOST_SENDCONTROL_Successful)
  73           return ReturnStatus;
  74
  75         Pipe_Freeze();
  76
  77         if ((ReturnStatus = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)
  78           return ReturnStatus;
  79
  80         if ((USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_DIRECTION) == REQDIR_DEVICETOHOST)
  81         {
  82                 Pipe_SetPipeToken(PIPE_TOKEN_IN);
  83
  84                 if (DataStream != NULL)
  85                 {
  86                         while (DataLen)
  87                         {
  88                                 Pipe_Unfreeze();
  89
  90                                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_InReceived)) != HOST_SENDCONTROL_Successful)
  91                                   return ReturnStatus;
  92
  93                                 if (!(Pipe_BytesInPipe()))
  94                                   DataLen = 0;
  95
  96                                 while (Pipe_BytesInPipe() && DataLen)
  97                                 {
  98                                         *(DataStream++) = Pipe_Read_8();
  99                                         DataLen--;
 100                                 }
 101
 102                                 Pipe_Freeze();
 103                                 Pipe_ClearIN();
 104                         }
 105                 }
 106
 107                 Pipe_SetPipeToken(PIPE_TOKEN_OUT);
 108                 Pipe_Unfreeze();
 109
 110                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)
 111                   return ReturnStatus;
 112
 113                 Pipe_ClearOUT();
 114
 115                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)
 116                   return ReturnStatus;
 117         }
 118         else
 119         {
 120                 if (DataStream != NULL)
 121                 {
 122                         Pipe_SetPipeToken(PIPE_TOKEN_OUT);
 123                         Pipe_Unfreeze();
 124
 125                         while (DataLen)
 126                         {
 127                                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)
 128                                   return ReturnStatus;
 129
 130                                 while (DataLen && (Pipe_BytesInPipe() < USB_Host_ControlPipeSize))
 131                                 {
 132                                         Pipe_Write_8(*(DataStream++));
 133                                         DataLen--;
 134                                 }
 135
 136                                 Pipe_ClearOUT();
 137                         }
 138
 139                         if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_OutReady)) != HOST_SENDCONTROL_Successful)
 140                           return ReturnStatus;
 141
 142                         Pipe_Freeze();
 143                 }
 144
 145                 Pipe_SetPipeToken(PIPE_TOKEN_IN);
 146                 Pipe_Unfreeze();
 147
 148                 if ((ReturnStatus = USB_Host_WaitForIOS(USB_HOST_WAITFOR_InReceived)) != HOST_SENDCONTROL_Successful)
 149                   return ReturnStatus;
 150
 151                 Pipe_ClearIN();
 152         }
 153
 154         return ReturnStatus;
 155 }
 156
 157 static uint8_t USB_Host_WaitForIOS(const uint8_t WaitType)
 158 {
 159         #if (USB_HOST_TIMEOUT_MS < 0xFF)
 160         uint8_t  TimeoutCounter = USB_HOST_TIMEOUT_MS;
 161         #else
 162         uint16_t TimeoutCounter = USB_HOST_TIMEOUT_MS;
 163         #endif
 164
 165         while (!(((WaitType == USB_HOST_WAITFOR_SetupSent)  && Pipe_IsSETUPSent())  ||
 166                  ((WaitType == USB_HOST_WAITFOR_InReceived) && Pipe_IsINReceived()) ||
 167                  ((WaitType == USB_HOST_WAITFOR_OutReady)   && Pipe_IsOUTReady())))
 168         {
 169                 uint8_t ErrorCode;
 170
 171                 if ((ErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)
 172                   return ErrorCode;
 173
 174                 if (!(TimeoutCounter--))
 175                   return HOST_SENDCONTROL_SoftwareTimeOut;
 176         }
 177
 178         return HOST_SENDCONTROL_Successful;
 179 }
 180
 181 uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
 182 {
 183         bool BusSuspended    = USB_Host_IsBusSuspended();
 184         uint8_t ReturnStatus = USB_Host_SendControlRequest_PRV(BufferPtr);
 185
 186         Pipe_Freeze();
 187
 188         if (BusSuspended)
 189           USB_Host_SuspendBus();
 190
 191         Pipe_ResetPipe(PIPE_CONTROLPIPE);
 192
 193         return ReturnStatus;
 194 }
 195
 196 uint8_t USB_Host_SetDeviceConfiguration(const uint8_t ConfigNumber)
 197 {
 198         uint8_t ErrorCode;
 199
 200         USB_ControlRequest = (USB_Request_Header_t)
 201                 {
 202                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),
 203                         .bRequest      = REQ_SetConfiguration,
 204                         .wValue        = ConfigNumber,
 205                         .wIndex        = 0,
 206                         .wLength       = 0,
 207                 };
 208
 209         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 210
 211         if ((ErrorCode = USB_Host_SendControlRequest(NULL)) == HOST_SENDCONTROL_Successful)
 212         {
 213                 USB_Host_ConfigurationNumber = ConfigNumber;
 214                 USB_HostState                = (ConfigNumber) ? HOST_STATE_Configured : HOST_STATE_Addressed;
 215         }
 216
 217         return ErrorCode;
 218 }
 219
 220 uint8_t USB_Host_GetDeviceConfiguration(uint8_t* const ConfigNumber)
 221 {
 222         USB_ControlRequest = (USB_Request_Header_t)
 223                 {
 224                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 225                         .bRequest      = REQ_GetConfiguration,
 226                         .wValue        = 0,
 227                         .wIndex        = 0,
 228                         .wLength       = sizeof(uint8_t),
 229                 };
 230
 231         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 232
 233         return USB_Host_SendControlRequest(ConfigNumber);
 234 }
 235
 236 uint8_t USB_Host_GetDescriptor(const uint8_t Type,
 237                                const uint8_t Index,
 238                                void* const Buffer,
 239                                const uint8_t BufferLength)
 240 {
 241         USB_ControlRequest = (USB_Request_Header_t)
 242                 {
 243                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 244                         .bRequest      = REQ_GetDescriptor,
 245                         .wValue        = (((uint16_t)Type << 8) | Index),
 246                         .wIndex        = 0,
 247                         .wLength       = BufferLength,
 248                 };
 249
 250         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 251
 252         return USB_Host_SendControlRequest(Buffer);
 253 }
 254
 255 uint8_t USB_Host_GetDeviceStatus(uint8_t* const FeatureStatus)
 256 {
 257         USB_ControlRequest = (USB_Request_Header_t)
 258                 {
 259                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 260                         .bRequest      = REQ_GetStatus,
 261                         .wValue        = 0,
 262                         .wIndex        = 0,
 263                         .wLength       = 0,
 264                 };
 265
 266         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 267
 268         return USB_Host_SendControlRequest(FeatureStatus);
 269 }
 270
 271 uint8_t USB_Host_ClearEndpointStall(const uint8_t EndpointAddress)
 272 {
 273         USB_ControlRequest = (USB_Request_Header_t)
 274                 {
 275                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT),
 276                         .bRequest      = REQ_ClearFeature,
 277                         .wValue        = FEATURE_SEL_EndpointHalt,
 278                         .wIndex        = EndpointAddress,
 279                         .wLength       = 0,
 280                 };
 281
 282         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 283
 284         return USB_Host_SendControlRequest(NULL);
 285 }
 286
 287 uint8_t USB_Host_SetInterfaceAltSetting(const uint8_t InterfaceIndex,
 288                                         const uint8_t AltSetting)
 289 {
 290         USB_ControlRequest = (USB_Request_Header_t)
 291                 {
 292                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE),
 293                         .bRequest      = REQ_SetInterface,
 294                         .wValue        = AltSetting,
 295                         .wIndex        = InterfaceIndex,
 296                         .wLength       = 0,
 297                 };
 298
 299         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 300
 301         return USB_Host_SendControlRequest(NULL);
 302 }
 303
 304 uint8_t USB_Host_GetInterfaceAltSetting(const uint8_t InterfaceIndex,
 305                                         uint8_t* const AltSetting)
 306 {
 307         USB_ControlRequest = (USB_Request_Header_t)
 308                 {
 309                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_INTERFACE),
 310                         .bRequest      = REQ_GetInterface,
 311                         .wValue        = 0,
 312                         .wIndex        = InterfaceIndex,
 313                         .wLength       = sizeof(uint8_t),
 314                 };
 315
 316         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 317
 318         return USB_Host_SendControlRequest(AltSetting);
 319 }
 320
 321 #endif
 322