tmk_core/protocol/lufa/LUFA-git/LUFA/Drivers/USB/Core/AVR8/Host_AVR8.c

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