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