LUFA/Drivers/USB/LowLevel/Host.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2010  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 "../HighLevel/USBMode.h"
  33
  34 #if defined(USB_CAN_BE_HOST)
  35
  36 #define  __INCLUDE_FROM_HOST_C
  37 #include "Host.h"
  38
  39 void USB_Host_ProcessNextHostState(void)
  40 {
  41         uint8_t ErrorCode    = HOST_ENUMERROR_NoError;
  42         uint8_t SubErrorCode = HOST_ENUMERROR_NoError;
  43
  44         static uint16_t WaitMSRemaining;
  45         static uint8_t  PostWaitState;
  46
  47         switch (USB_HostState)
  48         {
  49                 case HOST_STATE_WaitForDevice:
  50                         if (WaitMSRemaining)
  51                         {
  52                                 if ((SubErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful)
  53                                 {
  54                                         USB_HostState = PostWaitState;
  55                                         ErrorCode     = HOST_ENUMERROR_WaitStage;
  56                                         break;
  57                                 }
  58
  59                                 if (!(--WaitMSRemaining))
  60                                   USB_HostState = PostWaitState;
  61                         }
  62
  63                         break;
  64                 case HOST_STATE_Powered:
  65                         WaitMSRemaining = HOST_DEVICE_SETTLE_DELAY_MS;
  66
  67                         USB_HostState = HOST_STATE_Powered_WaitForDeviceSettle;
  68                         break;
  69                 case HOST_STATE_Powered_WaitForDeviceSettle:
  70                         if (WaitMSRemaining--)
  71                         {
  72                                 _delay_ms(1);
  73                                 break;
  74                         }
  75                         else
  76                         {
  77                                 USB_Host_VBUS_Manual_Off();
  78
  79                                 USB_OTGPAD_On();
  80                                 USB_Host_VBUS_Auto_Enable();
  81                                 USB_Host_VBUS_Auto_On();
  82
  83                                 USB_HostState = HOST_STATE_Powered_WaitForConnect;
  84                         }
  85
  86                         break;
  87                 case HOST_STATE_Powered_WaitForConnect:
  88                         if (USB_INT_HasOccurred(USB_INT_DCONNI))
  89                         {
  90                                 USB_INT_Clear(USB_INT_DCONNI);
  91                                 USB_INT_Clear(USB_INT_DDISCI);
  92
  93                                 USB_INT_Clear(USB_INT_VBERRI);
  94                                 USB_INT_Enable(USB_INT_VBERRI);
  95
  96                                 USB_Host_ResumeBus();
  97                                 Pipe_ClearPipes();
  98
  99                                 HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Powered_DoReset);
 100                         }
 101
 102                         break;
 103                 case HOST_STATE_Powered_DoReset:
 104                         USB_Host_ResetDevice();
 105
 106                         HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Powered_ConfigPipe);
 107                         break;
 108                 case HOST_STATE_Powered_ConfigPipe:
 109                         Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL,
 110                                                            PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP,
 111                                                            PIPE_CONTROLPIPE_DEFAULT_SIZE, PIPE_BANK_SINGLE);
 112
 113                         if (!(Pipe_IsConfigured()))
 114                         {
 115                                 ErrorCode    = HOST_ENUMERROR_PipeConfigError;
 116                                 SubErrorCode = 0;
 117                                 break;
 118                         }
 119
 120                         USB_HostState = HOST_STATE_Default;
 121                         break;
 122                 case HOST_STATE_Default:
 123                         USB_ControlRequest = (USB_Request_Header_t)
 124                                 {
 125                                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 126                                         .bRequest      = REQ_GetDescriptor,
 127                                         .wValue        = (DTYPE_Device << 8),
 128                                         .wIndex        = 0,
 129                                         .wLength       = 8,
 130                                 };
 131
 132                         uint8_t DataBuffer[8];
 133
 134                         if ((SubErrorCode = USB_Host_SendControlRequest(DataBuffer)) != HOST_SENDCONTROL_Successful)
 135                         {
 136                                 ErrorCode = HOST_ENUMERROR_ControlError;
 137                                 break;
 138                         }
 139
 140                         USB_ControlPipeSize = DataBuffer[offsetof(USB_Descriptor_Device_t, Endpoint0Size)];
 141
 142                         USB_Host_ResetDevice();
 143
 144                         HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Default_PostReset);
 145                         break;
 146                 case HOST_STATE_Default_PostReset:
 147                         Pipe_DisablePipe();
 148                         Pipe_DeallocateMemory();
 149                         Pipe_ResetPipe(PIPE_CONTROLPIPE);
 150
 151                         Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL,
 152                                            PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP,
 153                                            USB_ControlPipeSize, PIPE_BANK_SINGLE);
 154
 155                         if (!(Pipe_IsConfigured()))
 156                         {
 157                                 ErrorCode    = HOST_ENUMERROR_PipeConfigError;
 158                                 SubErrorCode = 0;
 159                                 break;
 160                         }
 161
 162                         USB_ControlRequest = (USB_Request_Header_t)
 163                                 {
 164                                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),
 165                                         .bRequest      = REQ_SetAddress,
 166                                         .wValue        = USB_HOST_DEVICEADDRESS,
 167                                         .wIndex        = 0,
 168                                         .wLength       = 0,
 169                                 };
 170
 171                         if ((SubErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 172                         {
 173                                 ErrorCode = HOST_ENUMERROR_ControlError;
 174                                 break;
 175                         }
 176
 177                         HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Default_PostAddressSet);
 178                         break;
 179                 case HOST_STATE_Default_PostAddressSet:
 180                         USB_Host_SetDeviceAddress(USB_HOST_DEVICEADDRESS);
 181
 182                         EVENT_USB_Host_DeviceEnumerationComplete();
 183                         USB_HostState = HOST_STATE_Addressed;
 184                         break;
 185         }
 186
 187         if ((ErrorCode != HOST_ENUMERROR_NoError) && (USB_HostState != HOST_STATE_Unattached))
 188         {
 189                 EVENT_USB_Host_DeviceEnumerationFailed(ErrorCode, SubErrorCode);
 190
 191                 USB_Host_VBUS_Auto_Off();
 192
 193                 EVENT_USB_Host_DeviceUnattached();
 194
 195                 USB_ResetInterface();
 196         }
 197 }
 198
 199 uint8_t USB_Host_WaitMS(uint8_t MS)
 200 {
 201         bool    BusSuspended = USB_Host_IsBusSuspended();
 202         uint8_t ErrorCode    = HOST_WAITERROR_Successful;
 203
 204         USB_Host_ResumeBus();
 205
 206         while (MS)
 207         {
 208                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 209                 {
 210                         USB_INT_Clear(USB_INT_HSOFI);
 211                         MS--;
 212                 }
 213
 214                 if ((USB_HostState == HOST_STATE_Unattached) || (USB_CurrentMode == USB_MODE_DEVICE))
 215                 {
 216                         ErrorCode = HOST_WAITERROR_DeviceDisconnect;
 217
 218                         break;
 219                 }
 220
 221                 if (Pipe_IsError() == true)
 222                 {
 223                         Pipe_ClearError();
 224                         ErrorCode = HOST_WAITERROR_PipeError;
 225
 226                         break;
 227                 }
 228
 229                 if (Pipe_IsStalled() == true)
 230                 {
 231                         Pipe_ClearStall();
 232                         ErrorCode = HOST_WAITERROR_SetupStalled;
 233
 234                         break;
 235                 }
 236         }
 237
 238         if (BusSuspended)
 239           USB_Host_SuspendBus();
 240
 241         return ErrorCode;
 242 }
 243
 244 static void USB_Host_ResetDevice(void)
 245 {
 246         bool BusSuspended = USB_Host_IsBusSuspended();
 247
 248         USB_INT_Disable(USB_INT_DDISCI);
 249
 250         USB_Host_ResetBus();
 251         while (!(USB_Host_IsBusResetComplete()));
 252
 253         USB_Host_ResumeBus();
 254
 255         USB_INT_Clear(USB_INT_HSOFI);
 256
 257         for (uint8_t MSRem = 10; MSRem != 0; MSRem--)
 258         {
 259                 /* Workaround for powerless-pull-up devices. After a USB bus reset,
 260                    all disconnection interrupts are suppressed while a USB frame is
 261                    looked for - if it is found within 10ms, the device is still
 262                    present.                                                        */
 263
 264                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 265                 {
 266                         USB_INT_Clear(USB_INT_HSOFI);
 267                         USB_INT_Clear(USB_INT_DDISCI);
 268                         break;
 269                 }
 270
 271                 _delay_ms(1);
 272         }
 273
 274         if (BusSuspended)
 275           USB_Host_SuspendBus();
 276
 277         USB_INT_Enable(USB_INT_DDISCI);
 278 }
 279
 280 uint8_t USB_Host_SetDeviceConfiguration(const uint8_t ConfigNumber)
 281 {
 282         USB_ControlRequest = (USB_Request_Header_t)
 283                 {
 284                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),
 285                         .bRequest      = REQ_SetConfiguration,
 286                         .wValue        = ConfigNumber,
 287                         .wIndex        = 0,
 288                         .wLength       = 0,
 289                 };
 290
 291         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 292
 293         return USB_Host_SendControlRequest(NULL);
 294 }
 295
 296 uint8_t USB_Host_GetDeviceDescriptor(void* const DeviceDescriptorPtr)
 297 {
 298         USB_ControlRequest = (USB_Request_Header_t)
 299                 {
 300                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 301                         .bRequest      = REQ_GetDescriptor,
 302                         .wValue        = (DTYPE_Device << 8),
 303                         .wIndex        = 0,
 304                         .wLength       = sizeof(USB_Descriptor_Device_t),
 305                 };
 306
 307         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 308
 309         return USB_Host_SendControlRequest(DeviceDescriptorPtr);
 310 }
 311
 312 uint8_t USB_Host_GetDeviceStringDescriptor(uint8_t Index, void* const Buffer, uint8_t BufferLength)
 313 {
 314         USB_ControlRequest = (USB_Request_Header_t)
 315                 {
 316                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 317                         .bRequest      = REQ_GetDescriptor,
 318                         .wValue        = (DTYPE_String << 8) | Index,
 319                         .wIndex        = 0,
 320                         .wLength       = BufferLength,
 321                 };
 322
 323         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 324
 325         return USB_Host_SendControlRequest(Buffer);
 326 }
 327
 328 uint8_t USB_Host_ClearPipeStall(uint8_t EndpointNum)
 329 {
 330         if (Pipe_GetPipeToken() == PIPE_TOKEN_IN)
 331           EndpointNum |= ENDPOINT_DESCRIPTOR_DIR_IN;
 332
 333         USB_ControlRequest = (USB_Request_Header_t)
 334                 {
 335                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_ENDPOINT),
 336                         .bRequest      = REQ_ClearFeature,
 337                         .wValue        = FEATURE_ENDPOINT_HALT,
 338                         .wIndex        = EndpointNum,
 339                         .wLength       = 0,
 340                 };
 341
 342         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 343
 344         return USB_Host_SendControlRequest(NULL);
 345 }
 346
 347 #endif