LUFA/Drivers/USB/Core/UC3/Host_UC3.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_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                                 #if defined(NO_AUTO_VBUS_MANAGEMENT)
  84                                 USB_Host_VBUS_Manual_Enable();
  85                                 USB_Host_VBUS_Manual_On();
  86                                 #endif
  87
  88                                 USB_HostState = HOST_STATE_Powered_WaitForConnect;
  89                         }
  90
  91                         break;
  92                 case HOST_STATE_Powered_WaitForConnect:
  93                         if (USB_INT_HasOccurred(USB_INT_DCONNI))
  94                         {
  95                                 USB_INT_Clear(USB_INT_DCONNI);
  96                                 USB_INT_Clear(USB_INT_DDISCI);
  97
  98                                 USB_INT_Clear(USB_INT_VBERRI);
  99                                 USB_INT_Enable(USB_INT_VBERRI);
 100
 101                                 USB_Host_ResumeBus();
 102                                 Pipe_ClearPipes();
 103
 104                                 HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Powered_DoReset);
 105                         }
 106
 107                         break;
 108                 case HOST_STATE_Powered_DoReset:
 109                         USB_Host_ResetDevice();
 110
 111                         HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Powered_ConfigPipe);
 112                         break;
 113                 case HOST_STATE_Powered_ConfigPipe:
 114                         if (!(Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL,
 115                                                                  PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP,
 116                                                                  PIPE_CONTROLPIPE_DEFAULT_SIZE, PIPE_BANK_SINGLE)))
 117                         {
 118                                 ErrorCode    = HOST_ENUMERROR_PipeConfigError;
 119                                 SubErrorCode = 0;
 120                                 break;
 121                         }
 122
 123                         USB_HostState = HOST_STATE_Default;
 124                         break;
 125                 case HOST_STATE_Default:
 126                         USB_ControlRequest = (USB_Request_Header_t)
 127                                 {
 128                                         .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE),
 129                                         .bRequest      = REQ_GetDescriptor,
 130                                         .wValue        = (DTYPE_Device << 8),
 131                                         .wIndex        = 0,
 132                                         .wLength       = 8,
 133                                 };
 134
 135                         uint8_t DataBuffer[8];
 136
 137                         Pipe_SelectPipe(PIPE_CONTROLPIPE);
 138                         if ((SubErrorCode = USB_Host_SendControlRequest(DataBuffer)) != HOST_SENDCONTROL_Successful)
 139                         {
 140                                 ErrorCode = HOST_ENUMERROR_ControlError;
 141                                 break;
 142                         }
 143
 144                         USB_Host_ControlPipeSize = DataBuffer[offsetof(USB_Descriptor_Device_t, Endpoint0Size)];
 145
 146                         USB_Host_ResetDevice();
 147
 148                         HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Default_PostReset);
 149                         break;
 150                 case HOST_STATE_Default_PostReset:
 151                         if (!(Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL,
 152                                                  PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP,
 153                                                  USB_Host_ControlPipeSize, PIPE_BANK_SINGLE)))
 154                         {
 155                                 ErrorCode    = HOST_ENUMERROR_PipeConfigError;
 156                                 SubErrorCode = 0;
 157                                 break;
 158                         }
 159
 160                         USB_ControlRequest = (USB_Request_Header_t)
 161                                 {
 162                                         .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE),
 163                                         .bRequest      = REQ_SetAddress,
 164                                         .wValue        = USB_HOST_DEVICEADDRESS,
 165                                         .wIndex        = 0,
 166                                         .wLength       = 0,
 167                                 };
 168
 169                         if ((SubErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful)
 170                         {
 171                                 ErrorCode = HOST_ENUMERROR_ControlError;
 172                                 break;
 173                         }
 174
 175                         HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Default_PostAddressSet);
 176                         break;
 177                 case HOST_STATE_Default_PostAddressSet:
 178                         USB_Host_SetDeviceAddress(USB_HOST_DEVICEADDRESS);
 179
 180                         USB_HostState = HOST_STATE_Addressed;
 181
 182                         EVENT_USB_Host_DeviceEnumerationComplete();
 183                         break;
 184         }
 185
 186         if ((ErrorCode != HOST_ENUMERROR_NoError) && (USB_HostState != HOST_STATE_Unattached))
 187         {
 188                 EVENT_USB_Host_DeviceEnumerationFailed(ErrorCode, SubErrorCode);
 189
 190                 USB_Host_VBUS_Auto_Off();
 191
 192                 EVENT_USB_Host_DeviceUnattached();
 193
 194                 USB_ResetInterface();
 195         }
 196 }
 197
 198 uint8_t USB_Host_WaitMS(uint8_t MS)
 199 {
 200         bool    BusSuspended = USB_Host_IsBusSuspended();
 201         uint8_t ErrorCode    = HOST_WAITERROR_Successful;
 202         bool    HSOFIEnabled = USB_INT_IsEnabled(USB_INT_HSOFI);
 203
 204         USB_INT_Disable(USB_INT_HSOFI);
 205         USB_INT_Clear(USB_INT_HSOFI);
 206
 207         USB_Host_ResumeBus();
 208
 209         while (MS)
 210         {
 211                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 212                 {
 213                         USB_INT_Clear(USB_INT_HSOFI);
 214                         MS--;
 215                 }
 216
 217                 if ((USB_HostState == HOST_STATE_Unattached) || (USB_CurrentMode != USB_MODE_Host))
 218                 {
 219                         ErrorCode = HOST_WAITERROR_DeviceDisconnect;
 220
 221                         break;
 222                 }
 223
 224                 if (Pipe_IsError())
 225                 {
 226                         Pipe_ClearError();
 227                         ErrorCode = HOST_WAITERROR_PipeError;
 228
 229                         break;
 230                 }
 231
 232                 if (Pipe_IsStalled())
 233                 {
 234                         Pipe_ClearStall();
 235                         ErrorCode = HOST_WAITERROR_SetupStalled;
 236
 237                         break;
 238                 }
 239         }
 240
 241         if (BusSuspended)
 242           USB_Host_SuspendBus();
 243
 244         if (HSOFIEnabled)
 245           USB_INT_Enable(USB_INT_HSOFI);
 246
 247         return ErrorCode;
 248 }
 249
 250 static void USB_Host_ResetDevice(void)
 251 {
 252         bool BusSuspended = USB_Host_IsBusSuspended();
 253
 254         USB_INT_Disable(USB_INT_DDISCI);
 255
 256         USB_Host_ResetBus();
 257         while (!(USB_Host_IsBusResetComplete()));
 258         USB_Host_ResumeBus();
 259
 260         USB_Host_ConfigurationNumber = 0;
 261
 262         bool HSOFIEnabled = USB_INT_IsEnabled(USB_INT_HSOFI);
 263
 264         USB_INT_Disable(USB_INT_HSOFI);
 265         USB_INT_Clear(USB_INT_HSOFI);
 266
 267         for (uint8_t MSRem = 10; MSRem != 0; MSRem--)
 268         {
 269                 /* Workaround for powerless-pull-up devices. After a USB bus reset,
 270                    all disconnection interrupts are suppressed while a USB frame is
 271                    looked for - if it is found within 10ms, the device is still
 272                    present.                                                        */
 273
 274                 if (USB_INT_HasOccurred(USB_INT_HSOFI))
 275                 {
 276                         USB_INT_Clear(USB_INT_HSOFI);
 277                         USB_INT_Clear(USB_INT_DDISCI);
 278                         break;
 279                 }
 280
 281                 Delay_MS(1);
 282         }
 283
 284         if (HSOFIEnabled)
 285           USB_INT_Enable(USB_INT_HSOFI);
 286
 287         if (BusSuspended)
 288           USB_Host_SuspendBus();
 289
 290         USB_INT_Enable(USB_INT_DDISCI);
 291 }
 292
 293 #endif
 294