void USB_Init(void) { USBPortNum = (uint8_t)USB_PORT_SELECTED; USB_IsInitialized = true; HAL_USBInit(); USB_ResetInterface(); }
void USB_ShutDown(void) { USB_ResetInterface(); USB_Detach(); USB_Controller_Disable(); USB_INT_DisableAllInterrupts(); USB_INT_ClearAllInterrupts(); #if defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) UHWCON &= ~(1 << UIMOD); #endif if (!(USB_Options & USB_OPT_MANUAL_PLL)) USB_PLL_Off(); USB_REG_Off(); #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) USB_OTGPAD_Off(); #endif #if defined(USB_CAN_BE_BOTH) UHWCON &= ~(1 << UIDE); #endif USB_IsInitialized = false; #if defined(USB_CAN_BE_BOTH) USB_CurrentMode = USB_MODE_NONE; #endif }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) /* Workaround for AVR8 bootloaders that fail to turn off the OTG pad before running * the loaded application. This causes VBUS detection to fail unless we first force * it off to reset it. */ USB_OTGPAD_Off(); #endif if (!(USB_Options & USB_OPT_REG_DISABLED)) USB_REG_On(); else USB_REG_Off(); if (!(USB_Options & USB_OPT_MANUAL_PLL)) { #if defined(USB_SERIES_4_AVR) PLLFRQ = (1 << PDIV2); #endif } #if defined(USB_CAN_BE_BOTH) if (Mode == USB_MODE_UID) { UHWCON |= (1 << UIDE); USB_INT_Enable(USB_INT_IDTI); USB_CurrentMode = USB_GetUSBModeFromUID(); } else { UHWCON &= ~(1 << UIDE); USB_CurrentMode = Mode; } #endif USB_IsInitialized = true; USB_ResetInterface(); }
void USB_Init(void) { #if defined(USB_MULTI_PORTS) uint8_t i; USB_Memory_Init(USBRAM_BUFFER_SIZE); for(i = 0;i<MAX_USB_CORE;i++) { HAL_USBInit(i); USB_ResetInterface(i); } #else USBPortNum = (uint8_t)USB_PORT_SELECTED; HAL_USBInit(USBPortNum); #if defined(USB_CAN_BE_HOST) USB_Memory_Init(USBRAM_BUFFER_SIZE); #endif USB_ResetInterface(USBPortNum); #endif USB_IsInitialized = true; }
void USB_Init(){ //uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask(); //GlobalInterruptDisable(); NVM.CMD = NVM_CMD_READ_CALIB_ROW_gc; USB.CAL0 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL0)); NVM.CMD = NVM_CMD_READ_CALIB_ROW_gc; USB.CAL1 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL1)); //SetGlobalInterruptMask(CurrentGlobalInt); USB_ResetInterface(); }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif if (!(USB_Options & USB_OPT_REG_DISABLED)) USB_REG_On(); else USB_REG_Off(); if (!(USB_Options & USB_OPT_MANUAL_PLL)) { #if defined(USB_SERIES_4_AVR) PLLFRQ = ((1 << PLLUSB) | (1 << PDIV3) | (1 << PDIV1)); #endif } #if defined(USB_CAN_BE_BOTH) if (Mode == USB_MODE_UID) { UHWCON |= (1 << UIDE); USB_INT_Enable(USB_INT_IDTI); USB_CurrentMode = USB_GetUSBModeFromUID(); } else { UHWCON &= ~(1 << UIDE); USB_CurrentMode = Mode; } #endif USB_IsInitialized = true; USB_ResetInterface(); }
void USB_Init(uint8_t corenum, uint8_t mode) { #if defined(USB_CAN_BE_HOST) if (mode == USB_MODE_Host && Mem_IsInitialized == false) { USB_Memory_Init(USBRAM_BUFFER_SIZE); Mem_IsInitialized = true; } #endif USB_CurrentMode[corenum] = mode; HAL_USBInit(corenum); USB_ResetInterface(corenum, mode); USB_IsInitialized = true; }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask(); GlobalInterruptDisable(); NVM.CMD = NVM_CMD_READ_CALIB_ROW_gc; USB.CAL0 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL0)); USB.CAL1 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL1)); NVM.CMD = NVM_CMD_NO_OPERATION_gc; /* Ugly workaround to ensure an aligned table, since __BIGGEST_ALIGNMENT__ == 1 for the 8-bit AVR-GCC toolchain */ USB.EPPTR = ((intptr_t)&USB_EndpointTable[1] & ~(1 << 0)); USB.CTRLA = (USB_STFRNUM_bm | ((ENDPOINT_TOTAL_ENDPOINTS - 1) << USB_MAXEP_gp)); if ((USB_Options & USB_OPT_BUSEVENT_PRIHIGH) == USB_OPT_BUSEVENT_PRIHIGH) USB.INTCTRLA = (3 << USB_INTLVL_gp); else if ((USB_Options & USB_OPT_BUSEVENT_PRIMED) == USB_OPT_BUSEVENT_PRIMED) USB.INTCTRLA = (2 << USB_INTLVL_gp); else USB.INTCTRLA = (1 << USB_INTLVL_gp); SetGlobalInterruptMask(CurrentGlobalInt); #if defined(USB_CAN_BE_BOTH) USB_CurrentMode = Mode; #endif USB_IsInitialized = true; USB_ResetInterface(); }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif USB_IsInitialized = true; uint_reg_t CurrentGlobalInt = GetGlobalInterruptMask(); GlobalInterruptDisable(); NVM.CMD = NVM_CMD_READ_CALIB_ROW_gc; USB.CAL0 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL0)); NVM.CMD = NVM_CMD_READ_CALIB_ROW_gc; USB.CAL1 = pgm_read_byte(offsetof(NVM_PROD_SIGNATURES_t, USBCAL1)); USB.EPPTR = (intptr_t)&USB_EndpointTable; if ((USB_Options & USB_OPT_BUSEVENT_PRIHIGH) == USB_OPT_BUSEVENT_PRIHIGH) USB.INTCTRLA = (3 << USB_INTLVL_gp); else if ((USB_Options & USB_OPT_BUSEVENT_PRIMED) == USB_OPT_BUSEVENT_PRIMED) USB.INTCTRLA = (2 << USB_INTLVL_gp); else USB.INTCTRLA = (1 << USB_INTLVL_gp); SetGlobalInterruptMask(CurrentGlobalInt); USB_ResetInterface(); }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif #if defined(USB_CAN_BE_BOTH) if (Mode == USB_MODE_UID) { AVR32_USBB.USBCON.uide = true; USB_INT_Enable(USB_INT_IDTI); USB_CurrentMode = USB_GetUSBModeFromUID(); } else { AVR32_USBB.USBCON.uide = false; USB_CurrentMode = Mode; } #else AVR32_USBB.USBCON.uide = false; #endif USB_IsInitialized = true; USB_ResetInterface(); }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif USB_IsInitialized = true; USB_ResetInterface(); }
ISR(USB_GEN_vect, ISR_BLOCK) { #if defined(USB_CAN_BE_DEVICE) #if !defined(NO_SOF_EVENTS) if (USB_INT_HasOccurred(USB_INT_SOFI) && USB_INT_IsEnabled(USB_INT_SOFI)) { USB_INT_Clear(USB_INT_SOFI); EVENT_USB_Device_StartOfFrame(); } #endif #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) if (USB_INT_HasOccurred(USB_INT_VBUSTI) && USB_INT_IsEnabled(USB_INT_VBUSTI)) { USB_INT_Clear(USB_INT_VBUSTI); if (USB_VBUS_GetStatus()) { if (!(USB_Options & USB_OPT_MANUAL_PLL)) { USB_PLL_On(); while (!(USB_PLL_IsReady())); } USB_DeviceState = DEVICE_STATE_Powered; EVENT_USB_Device_Connect(); } else { if (!(USB_Options & USB_OPT_MANUAL_PLL)) USB_PLL_Off(); USB_DeviceState = DEVICE_STATE_Unattached; EVENT_USB_Device_Disconnect(); } } #endif if (USB_INT_HasOccurred(USB_INT_SUSPI) && USB_INT_IsEnabled(USB_INT_SUSPI)) { USB_INT_Disable(USB_INT_SUSPI); USB_INT_Enable(USB_INT_WAKEUPI); USB_CLK_Freeze(); if (!(USB_Options & USB_OPT_MANUAL_PLL)) USB_PLL_Off(); #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT) USB_DeviceState = DEVICE_STATE_Unattached; EVENT_USB_Device_Disconnect(); #else USB_DeviceState = DEVICE_STATE_Suspended; EVENT_USB_Device_Suspend(); #endif } if (USB_INT_HasOccurred(USB_INT_WAKEUPI) && USB_INT_IsEnabled(USB_INT_WAKEUPI)) { if (!(USB_Options & USB_OPT_MANUAL_PLL)) { USB_PLL_On(); while (!(USB_PLL_IsReady())); } USB_CLK_Unfreeze(); USB_INT_Clear(USB_INT_WAKEUPI); USB_INT_Disable(USB_INT_WAKEUPI); USB_INT_Enable(USB_INT_SUSPI); if (USB_Device_ConfigurationNumber) USB_DeviceState = DEVICE_STATE_Configured; else USB_DeviceState = (USB_Device_IsAddressSet()) ? DEVICE_STATE_Configured : DEVICE_STATE_Powered; #if defined(USB_SERIES_2_AVR) && !defined(NO_LIMITED_CONTROLLER_CONNECT) EVENT_USB_Device_Connect(); #else EVENT_USB_Device_WakeUp(); #endif } if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI)) { USB_INT_Clear(USB_INT_EORSTI); USB_DeviceState = DEVICE_STATE_Default; USB_Device_ConfigurationNumber = 0; USB_INT_Clear(USB_INT_SUSPI); USB_INT_Disable(USB_INT_SUSPI); USB_INT_Enable(USB_INT_WAKEUPI); Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL, ENDPOINT_DIR_OUT, USB_Device_ControlEndpointSize, ENDPOINT_BANK_SINGLE); #if defined(INTERRUPT_CONTROL_ENDPOINT) USB_INT_Enable(USB_INT_RXSTPI); #endif EVENT_USB_Device_Reset(); } #endif #if defined(USB_CAN_BE_HOST) #if !defined(NO_SOF_EVENTS) if (USB_INT_HasOccurred(USB_INT_HSOFI) && USB_INT_IsEnabled(USB_INT_HSOFI)) { USB_INT_Clear(USB_INT_HSOFI); EVENT_USB_Host_StartOfFrame(); } #endif if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI)) { USB_INT_Clear(USB_INT_DDISCI); USB_INT_Clear(USB_INT_DCONNI); USB_INT_Disable(USB_INT_DDISCI); EVENT_USB_Host_DeviceUnattached(); USB_ResetInterface(); } if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI)) { USB_INT_Clear(USB_INT_VBERRI); USB_Host_VBUS_Manual_Off(); USB_Host_VBUS_Auto_Off(); EVENT_USB_Host_HostError(HOST_ERROR_VBusVoltageDip); EVENT_USB_Host_DeviceUnattached(); USB_HostState = HOST_STATE_Unattached; } if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI)) { USB_INT_Clear(USB_INT_SRPI); USB_INT_Disable(USB_INT_SRPI); EVENT_USB_Host_DeviceAttached(); USB_INT_Enable(USB_INT_DDISCI); USB_HostState = HOST_STATE_Powered; } if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI)) { USB_INT_Clear(USB_INT_BCERRI); EVENT_USB_Host_DeviceEnumerationFailed(HOST_ENUMERROR_NoDeviceDetected, 0); EVENT_USB_Host_DeviceUnattached(); USB_ResetInterface(); } #endif #if defined(USB_CAN_BE_BOTH) if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI)) { USB_INT_Clear(USB_INT_IDTI); if (USB_DeviceState != DEVICE_STATE_Unattached) EVENT_USB_Device_Disconnect(); if (USB_HostState != HOST_STATE_Unattached) EVENT_USB_Host_DeviceUnattached(); USB_CurrentMode = USB_GetUSBModeFromUID(); USB_ResetInterface(); EVENT_USB_UIDChange(); } #endif }
void USB_Init( #if defined(USB_CAN_BE_BOTH) const uint8_t Mode #endif #if (defined(USB_CAN_BE_BOTH) && !defined(USE_STATIC_OPTIONS)) , #elif (!defined(USB_CAN_BE_BOTH) && defined(USE_STATIC_OPTIONS)) void #endif #if !defined(USE_STATIC_OPTIONS) const uint8_t Options #endif ) { #if defined(USB_CAN_BE_BOTH) USB_CurrentMode = Mode; #endif #if !defined(USE_STATIC_OPTIONS) USB_Options = Options; #endif #if defined(USB_CAN_BE_HOST) USB_ControlPipeSize = PIPE_CONTROLPIPE_DEFAULT_SIZE; #endif #if defined(USB_DEVICE_ONLY) && (defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR)) UHWCON |= (1 << UIMOD); #elif defined(USB_HOST_ONLY) UHWCON &= ~(1 << UIMOD); #elif defined(USB_CAN_BE_BOTH) if (Mode == USB_MODE_UID) { UHWCON |= (1 << UIDE); USB_INT_Clear(USB_INT_IDTI); USB_INT_Enable(USB_INT_IDTI); USB_CurrentMode = USB_GetUSBModeFromUID(); } else if (Mode == USB_MODE_DEVICE) { UHWCON |= (1 << UIMOD); } else if (Mode == USB_MODE_HOST) { UHWCON &= ~(1 << UIMOD); } else { EVENT_USB_InitFailure(USB_INITERROR_NoUSBModeSpecified); return; } #endif USB_ResetInterface(); #if defined(USB_SERIES_4_AVR) || defined(USB_SERIES_6_AVR) || defined(USB_SERIES_7_AVR) USB_OTGPAD_On(); #endif USB_IsInitialized = true; sei(); }
void USB_Host_ProcessNextHostState(void) { uint8_t ErrorCode = HOST_ENUMERROR_NoError; uint8_t SubErrorCode = HOST_ENUMERROR_NoError; static uint16_t WaitMSRemaining; static uint8_t PostWaitState; switch (USB_HostState) { case HOST_STATE_WaitForDevice: if (WaitMSRemaining) { if ((SubErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) { USB_HostState = PostWaitState; ErrorCode = HOST_ENUMERROR_WaitStage; break; } if (!(--WaitMSRemaining)) USB_HostState = PostWaitState; } break; case HOST_STATE_Powered: WaitMSRemaining = HOST_DEVICE_SETTLE_DELAY_MS; USB_HostState = HOST_STATE_Powered_WaitForDeviceSettle; break; case HOST_STATE_Powered_WaitForDeviceSettle: if (WaitMSRemaining--) { _delay_ms(1); break; } else { USB_Host_VBUS_Manual_Off(); USB_OTGPAD_On(); USB_Host_VBUS_Auto_Enable(); USB_Host_VBUS_Auto_On(); USB_HostState = HOST_STATE_Powered_WaitForConnect; } break; case HOST_STATE_Powered_WaitForConnect: if (USB_INT_HasOccurred(USB_INT_DCONNI)) { USB_INT_Clear(USB_INT_DCONNI); USB_INT_Clear(USB_INT_DDISCI); USB_INT_Clear(USB_INT_VBERRI); USB_INT_Enable(USB_INT_VBERRI); USB_Host_ResumeBus(); Pipe_ClearPipes(); HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Powered_DoReset); } break; case HOST_STATE_Powered_DoReset: USB_Host_ResetDevice(); HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Powered_ConfigPipe); break; case HOST_STATE_Powered_ConfigPipe: Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL, PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, PIPE_CONTROLPIPE_DEFAULT_SIZE, PIPE_BANK_SINGLE); if (!(Pipe_IsConfigured())) { ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; break; } USB_HostState = HOST_STATE_Default; break; case HOST_STATE_Default: USB_ControlRequest = (USB_Request_Header_t) { .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE), .bRequest = REQ_GetDescriptor, .wValue = (DTYPE_Device << 8), .wIndex = 0, .wLength = 8, }; uint8_t DataBuffer[8]; if ((SubErrorCode = USB_Host_SendControlRequest(DataBuffer)) != HOST_SENDCONTROL_Successful) { ErrorCode = HOST_ENUMERROR_ControlError; break; } USB_ControlPipeSize = DataBuffer[offsetof(USB_Descriptor_Device_t, Endpoint0Size)]; USB_Host_ResetDevice(); HOST_TASK_NONBLOCK_WAIT(200, HOST_STATE_Default_PostReset); break; case HOST_STATE_Default_PostReset: Pipe_ConfigurePipe(PIPE_CONTROLPIPE, EP_TYPE_CONTROL, PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, USB_ControlPipeSize, PIPE_BANK_SINGLE); if (!(Pipe_IsConfigured())) { ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; break; } USB_ControlRequest = (USB_Request_Header_t) { .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE), .bRequest = REQ_SetAddress, .wValue = USB_HOST_DEVICEADDRESS, .wIndex = 0, .wLength = 0, }; if ((SubErrorCode = USB_Host_SendControlRequest(NULL)) != HOST_SENDCONTROL_Successful) { ErrorCode = HOST_ENUMERROR_ControlError; break; } HOST_TASK_NONBLOCK_WAIT(100, HOST_STATE_Default_PostAddressSet); break; case HOST_STATE_Default_PostAddressSet: USB_Host_SetDeviceAddress(USB_HOST_DEVICEADDRESS); EVENT_USB_Host_DeviceEnumerationComplete(); USB_HostState = HOST_STATE_Addressed; break; } if ((ErrorCode != HOST_ENUMERROR_NoError) && (USB_HostState != HOST_STATE_Unattached)) { EVENT_USB_Host_DeviceEnumerationFailed(ErrorCode, SubErrorCode); USB_Host_VBUS_Auto_Off(); EVENT_USB_Host_DeviceUnattached(); USB_ResetInterface(); } } uint8_t USB_Host_WaitMS(uint8_t MS) { bool BusSuspended = USB_Host_IsBusSuspended(); uint8_t ErrorCode = HOST_WAITERROR_Successful; bool HSOFIEnabled = USB_INT_IsEnabled(USB_INT_HSOFI); USB_INT_Disable(USB_INT_HSOFI); USB_INT_Clear(USB_INT_HSOFI); USB_Host_ResumeBus(); while (MS) { if (USB_INT_HasOccurred(USB_INT_HSOFI)) { USB_INT_Clear(USB_INT_HSOFI); MS--; } if ((USB_HostState == HOST_STATE_Unattached) || (USB_CurrentMode != USB_MODE_Host)) { ErrorCode = HOST_WAITERROR_DeviceDisconnect; break; } if (Pipe_IsError() == true) { Pipe_ClearError(); ErrorCode = HOST_WAITERROR_PipeError; break; } if (Pipe_IsStalled() == true) { Pipe_ClearStall(); ErrorCode = HOST_WAITERROR_SetupStalled; break; } } if (BusSuspended) USB_Host_SuspendBus(); if (HSOFIEnabled) USB_INT_Enable(USB_INT_HSOFI); return ErrorCode; } static void USB_Host_ResetDevice(void) { bool BusSuspended = USB_Host_IsBusSuspended(); USB_INT_Disable(USB_INT_DDISCI); USB_Host_ResetBus(); while (!(USB_Host_IsBusResetComplete())); USB_Host_ResumeBus(); bool HSOFIEnabled = USB_INT_IsEnabled(USB_INT_HSOFI); USB_INT_Disable(USB_INT_HSOFI); USB_INT_Clear(USB_INT_HSOFI); for (uint8_t MSRem = 10; MSRem != 0; MSRem--) { /* Workaround for powerless-pull-up devices. After a USB bus reset, all disconnection interrupts are suppressed while a USB frame is looked for - if it is found within 10ms, the device is still present. */ if (USB_INT_HasOccurred(USB_INT_HSOFI)) { USB_INT_Clear(USB_INT_HSOFI); USB_INT_Clear(USB_INT_DDISCI); break; } _delay_ms(1); } if (HSOFIEnabled) USB_INT_Enable(USB_INT_HSOFI); if (BusSuspended) USB_Host_SuspendBus(); USB_INT_Enable(USB_INT_DDISCI); }
ISR(USB_GEN_vect, ISR_BLOCK) { #if defined(USB_CAN_BE_DEVICE) #if defined(USB_FULL_CONTROLLER) || defined(USB_MODIFIED_FULL_CONTROLLER) if (USB_INT_HasOccurred(USB_INT_VBUS) && USB_INT_IsEnabled(USB_INT_VBUS)) { USB_INT_Clear(USB_INT_VBUS); RAISE_EVENT(USB_VBUSChange); if (USB_VBUS_GetStatus()) { RAISE_EVENT(USB_VBUSConnect); if (USB_IsConnected) RAISE_EVENT(USB_Disconnect); USB_ResetInterface(); USB_IsConnected = true; RAISE_EVENT(USB_Connect); } else { RAISE_EVENT(USB_Disconnect); USB_Detach(); USB_CLK_Freeze(); USB_PLL_Off(); USB_REG_Off(); USB_IsConnected = false; RAISE_EVENT(USB_VBUSDisconnect); USB_INT_Clear(USB_INT_VBUS); } } #endif if (USB_INT_HasOccurred(USB_INT_SUSPEND) && USB_INT_IsEnabled(USB_INT_SUSPEND)) { USB_INT_Clear(USB_INT_SUSPEND); USB_INT_Disable(USB_INT_SUSPEND); USB_INT_Enable(USB_INT_WAKEUP); USB_CLK_Freeze(); if (!(USB_Options & USB_OPT_MANUAL_PLL)) USB_PLL_Off(); USB_IsSuspended = true; RAISE_EVENT(USB_Suspend); #if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT) if (USB_IsConnected) { USB_IsConnected = false; RAISE_EVENT(USB_Disconnect); } #endif } if (USB_INT_HasOccurred(USB_INT_WAKEUP) && USB_INT_IsEnabled(USB_INT_WAKEUP)) { if (!(USB_Options & USB_OPT_MANUAL_PLL)) { USB_PLL_On(); while (!(USB_PLL_IsReady())); } USB_CLK_Unfreeze(); USB_INT_Clear(USB_INT_WAKEUP); USB_INT_Disable(USB_INT_WAKEUP); USB_INT_Enable(USB_INT_SUSPEND); #if defined(USB_LIMITED_CONTROLLER) && !defined(NO_LIMITED_CONTROLLER_CONNECT) if (!(USB_IsConnected)) { USB_IsConnected = true; RAISE_EVENT(USB_Connect); } #endif USB_IsSuspended = false; RAISE_EVENT(USB_WakeUp); } if (USB_INT_HasOccurred(USB_INT_EORSTI) && USB_INT_IsEnabled(USB_INT_EORSTI)) { USB_INT_Clear(USB_INT_EORSTI); USB_ConfigurationNumber = 0; USB_INT_Clear(USB_INT_SUSPEND); USB_INT_Disable(USB_INT_SUSPEND); USB_INT_Enable(USB_INT_WAKEUP); Endpoint_ClearEndpoints(); Endpoint_ConfigureEndpoint(ENDPOINT_CONTROLEP, EP_TYPE_CONTROL, ENDPOINT_DIR_OUT, USB_ControlEndpointSize, ENDPOINT_BANK_SINGLE); RAISE_EVENT(USB_Reset); } #endif #if defined(USB_CAN_BE_HOST) if (USB_INT_HasOccurred(USB_INT_DDISCI) && USB_INT_IsEnabled(USB_INT_DDISCI)) { USB_INT_Clear(USB_INT_DDISCI); USB_INT_Clear(USB_INT_DCONNI); USB_INT_Disable(USB_INT_DDISCI); RAISE_EVENT(USB_DeviceUnattached); RAISE_EVENT(USB_Disconnect); USB_ResetInterface(); } if (USB_INT_HasOccurred(USB_INT_VBERRI) && USB_INT_IsEnabled(USB_INT_VBERRI)) { USB_INT_Clear(USB_INT_VBERRI); USB_Host_VBUS_Manual_Off(); USB_Host_VBUS_Auto_Off(); RAISE_EVENT(USB_HostError, HOST_ERROR_VBusVoltageDip); RAISE_EVENT(USB_DeviceUnattached); USB_HostState = HOST_STATE_Unattached; } if (USB_INT_HasOccurred(USB_INT_SRPI) && USB_INT_IsEnabled(USB_INT_SRPI)) { USB_INT_Clear(USB_INT_SRPI); USB_INT_Disable(USB_INT_SRPI); RAISE_EVENT(USB_DeviceAttached); USB_INT_Enable(USB_INT_DDISCI); USB_HostState = HOST_STATE_Attached; } if (USB_INT_HasOccurred(USB_INT_BCERRI) && USB_INT_IsEnabled(USB_INT_BCERRI)) { USB_INT_Clear(USB_INT_BCERRI); RAISE_EVENT(USB_DeviceEnumerationFailed, HOST_ENUMERROR_NoDeviceDetected, 0); RAISE_EVENT(USB_DeviceUnattached); if (USB_IsConnected) RAISE_EVENT(USB_Disconnect); USB_ResetInterface(); } #endif #if defined(USB_CAN_BE_BOTH) if (USB_INT_HasOccurred(USB_INT_IDTI) && USB_INT_IsEnabled(USB_INT_IDTI)) { USB_INT_Clear(USB_INT_IDTI); if (USB_IsConnected) { if (USB_CurrentMode == USB_MODE_HOST) RAISE_EVENT(USB_DeviceUnattached); else RAISE_EVENT(USB_Disconnect); } RAISE_EVENT(USB_UIDChange); USB_ResetInterface(); } #endif }
void USB_Host_ProcessNextHostState(uint8_t corenum) { uint8_t ErrorCode = HOST_ENUMERROR_NoError; uint8_t SubErrorCode = HOST_ENUMERROR_NoError; static uint16_t WaitMSRemaining; static uint8_t PostWaitState; switch (USB_HostState[corenum]) { case HOST_STATE_WaitForDevice: if (WaitMSRemaining) { if ((SubErrorCode = USB_Host_WaitMS(1)) != HOST_WAITERROR_Successful) { USB_HostState[corenum] = PostWaitState; ErrorCode = HOST_ENUMERROR_WaitStage; break; } if (!(--WaitMSRemaining)) USB_HostState[corenum] = PostWaitState; } break; case HOST_STATE_Powered: WaitMSRemaining = HOST_DEVICE_SETTLE_DELAY_MS; USB_HostState[corenum] = HOST_STATE_Powered_WaitForDeviceSettle; break; case HOST_STATE_Powered_WaitForDeviceSettle: if (WaitMSRemaining--) { Delay_MS(1); break; } else { USB_Host_VBUS_Manual_Off(); USB_OTGPAD_On(); USB_Host_VBUS_Auto_Enable(); USB_Host_VBUS_Auto_On(); USB_HostState[corenum] = HOST_STATE_Powered_WaitForConnect; } break; case HOST_STATE_Powered_WaitForConnect: HOST_TASK_NONBLOCK_WAIT(corenum, 100, HOST_STATE_Powered_DoReset); break; case HOST_STATE_Powered_DoReset: { HCD_USB_SPEED DeviceSpeed; HcdRhPortReset(corenum,1); HcdGetDeviceSpeed(corenum, 1, &DeviceSpeed); // skip checking status USB_Host_SetDeviceSpeed(corenum,DeviceSpeed); HOST_TASK_NONBLOCK_WAIT(corenum, 200, HOST_STATE_Powered_ConfigPipe); } break; case HOST_STATE_Powered_ConfigPipe: if (!Pipe_ConfigurePipe(corenum, PIPE_CONTROLPIPE, EP_TYPE_CONTROL, PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, PIPE_CONTROLPIPE_DEFAULT_SIZE, PIPE_BANK_SINGLE) ) { ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; break; } USB_HostState[corenum] = HOST_STATE_Default; break; case HOST_STATE_Default: { USB_Descriptor_Device_t DevDescriptor; USB_ControlRequest = (USB_Request_Header_t) { .bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_STANDARD | REQREC_DEVICE), .bRequest = REQ_GetDescriptor, .wValue = (DTYPE_Device << 8), .wIndex = 0, .wLength = 8, }; if ((SubErrorCode = USB_Host_SendControlRequest(corenum, &DevDescriptor)) != HOST_SENDCONTROL_Successful) { ErrorCode = HOST_ENUMERROR_ControlError; break; } USB_Host_ControlPipeSize[corenum] = DevDescriptor.Endpoint0Size; Pipe_ClosePipe(corenum, PIPE_CONTROLPIPE); HcdRhPortReset(corenum,1); HOST_TASK_NONBLOCK_WAIT(corenum, 200, HOST_STATE_Default_PostReset); } break; case HOST_STATE_Default_PostReset: if (!Pipe_ConfigurePipe(corenum, PIPE_CONTROLPIPE, EP_TYPE_CONTROL, PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, USB_Host_ControlPipeSize[corenum], PIPE_BANK_SINGLE) ) { ErrorCode = HOST_ENUMERROR_PipeConfigError; SubErrorCode = 0; break; } USB_ControlRequest = (USB_Request_Header_t) { .bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_DEVICE), .bRequest = REQ_SetAddress, .wValue = USB_HOST_DEVICEADDRESS, .wIndex = 0, .wLength = 0, }; if ((SubErrorCode = USB_Host_SendControlRequest(corenum, NULL)) != HOST_SENDCONTROL_Successful) { ErrorCode = HOST_ENUMERROR_ControlError; break; } Pipe_ClosePipe(corenum, PIPE_CONTROLPIPE); HOST_TASK_NONBLOCK_WAIT(corenum, 100, HOST_STATE_Default_PostAddressSet); break; case HOST_STATE_Default_PostAddressSet: Pipe_ConfigurePipe(corenum, PIPE_CONTROLPIPE, EP_TYPE_CONTROL, PIPE_TOKEN_SETUP, ENDPOINT_CONTROLEP, USB_Host_ControlPipeSize[corenum], PIPE_BANK_SINGLE); USB_Host_SetDeviceAddress(USB_HOST_DEVICEADDRESS); USB_HostState[corenum] = HOST_STATE_Addressed; EVENT_USB_Host_DeviceEnumerationComplete(corenum); break; } if ((ErrorCode != HOST_ENUMERROR_NoError) && (USB_HostState[corenum] != HOST_STATE_Unattached)) { EVENT_USB_Host_DeviceEnumerationFailed(corenum, ErrorCode, SubErrorCode); USB_Host_VBUS_Auto_Off(); EVENT_USB_Host_DeviceUnattached(corenum); USB_ResetInterface(corenum); } } uint8_t USB_Host_WaitMS(uint8_t MS) { return HOST_WAITERROR_Successful; } void USB_Host_Enumerate (uint8_t HostId) /* Part of Interrupt Service Routine */ { // CurrentHostID = HostId; // hostselected = HostId; EVENT_USB_Host_DeviceAttached(HostId); USB_HostState[HostId] = HOST_STATE_Powered; } void USB_Host_DeEnumerate(uint8_t HostId) /* Part of Interrupt Service Routine */ { uint8_t i; Pipe_ClosePipe(HostId, PIPE_CONTROLPIPE); // FIXME close only relevant pipes , take long time in ISR for(i = PIPE_CONTROLPIPE+1; i < PIPE_TOTAL_PIPES; i++) { if(PipeInfo[HostId][i].PipeHandle != 0) { Pipe_ClosePipe(HostId, i); } } EVENT_USB_Host_DeviceUnattached(HostId); USB_HostState[HostId] = HOST_STATE_Unattached; }