/**
* @brief Entry point of the USB host management
*
* The aim is to manage the device target connection and enumeration
* depending on the device_state, the function performs the required operations
* to get the device enumerated and configured
* Once the device is operationnal, the device_state value is DEVICE_READY
* This state should be tested by the host task application before performing
* any applicative requests to the device.
*
* @param none
*
* @return none
*
* \image html host_task.gif
*/
void usb_host_task(void)
{
switch (device_state)
{
//------------------------------------------------------
// DEVICE_UNATTACHED state
//
// - Default init state
// - Try to give device power supply
//
case DEVICE_UNATTACHED:
Host_clear_device_supported(); // Reset Device status
Host_clear_configured();
Host_clear_device_ready();
Usb_clear_all_event(); // Clear all software events
new_device_connected=FALSE;
selected_device=0;
#if (USB_HUB_SUPPORT==ENABLE)
nb_hub_present = 0;
#endif
#if (SOFTWARE_VBUS_CTRL==ENABLE)
if( Is_usb_bconnection_error_interrupt()||Is_usb_vbus_error_interrupt())
{
Usb_ack_bconnection_error_interrupt();
Usb_ack_vbus_error_interrupt();
Host_clear_vbus_request();
}
Usb_disable_vbus_pad();
Usb_enable_manual_vbus();
if(Is_usb_srp_interrupt())
{
Usb_ack_srp_interrupt();
Usb_enable_vbus_pad();
Usb_enable_vbus();
device_state=DEVICE_ATTACHED;
}
#else
Usb_enable_vbus(); // Give at least device power supply!!!
if(Is_usb_vbus_high())
{ device_state=DEVICE_ATTACHED; } // If VBUS ok goto to device connection expectation
#endif
break;
//------------------------------------------------------
// DEVICE_ATTACHED state
//
// - Vbus is on
// - Try to detected device connection
//
case DEVICE_ATTACHED :
if (Is_device_connection() || (force_enumeration==TRUE)) // Device pull-up detected
{
Host_ack_device_connection();
Host_clear_device_supported(); // Reset Device status
Host_clear_configured();
Host_clear_device_ready();
Usb_clear_all_event(); // Clear all software events
new_device_connected=FALSE;
force_enumeration=FALSE;
// Now device is connected, enable disconnection interrupt
Host_enable_device_disconnection_interrupt();
Enable_interrupt();
// Reset device status
Host_clear_device_supported();
Host_clear_configured();
Host_clear_device_ready();
Host_enable_sof(); // Start Start Of Frame generation
Host_enable_sof_interrupt(); // SOF will be detected under interrupt
c = 0;
while (c<100) // wait 100ms before USB reset
{
if (Is_usb_event(EVT_HOST_SOF)) { Usb_ack_event(EVT_HOST_SOF); c++; }// Count Start Of frame
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) {goto device_attached_error;}
}
Host_disable_device_disconnection_interrupt();
Host_send_reset(); // First USB reset
Usb_ack_event(EVT_HOST_SOF);
while (Is_host_reset()); // Active wait of end of reset send
Host_ack_reset();
//Workaround for some bugly devices with powerless pull up
//usually low speed where data line rise slowly and can be interpretaded as disconnection
for(c=0;c!=0xFFFF;c++) // Basic Timeout counter
{
if(Is_usb_event(EVT_HOST_SOF)) //If we detect SOF, device is still alive and connected, just clear false disconnect flag
{
if(Is_device_disconnection())
{
Host_ack_device_connection();
Host_ack_device_disconnection();
break;
}
}
}
Host_enable_device_disconnection_interrupt();
// All USB pipes must be reconfigured after a USB reset generation
host_configure_pipe(PIPE_CONTROL, \
TYPE_CONTROL, \
TOKEN_SETUP, \
EP_CONTROL, \
SIZE_64, \
ONE_BANK, \
0 );
c = 0;
while (c<100) // wait 100ms after USB reset
{
if (Is_usb_event(EVT_HOST_SOF)) { Usb_ack_event(EVT_HOST_SOF); c++; }// Count Start Of frame
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) {goto device_attached_error;}
}
device_state = DEVICE_POWERED;
c=0;
}
device_attached_error:
// Device connection error, or vbus pb -> Retry the connection process from the begining
if( Is_usb_bconnection_error_interrupt()||Is_usb_vbus_error_interrupt()||Is_usb_vbus_low())
{
Usb_ack_bconnection_error_interrupt();
Usb_enable_vbus_hw_control();
device_state=DEVICE_UNATTACHED;
Usb_disable_vbus();
Usb_disable_vbus_pad();
Usb_enable_vbus_pad();
Usb_ack_vbus_error_interrupt();
Usb_enable_vbus();
Usb_disable_vbus_hw_control();
Host_disable_sof();
}
break;
//------------------------------------------------------
// DEVICE_POWERED state
//
// - Device connection (attach) as been detected,
// - Wait 100ms and configure default control pipe
//
case DEVICE_POWERED :
LOG_STR_CODE(log_device_connected);
Host_device_connection_action();
if (Is_usb_event(EVT_HOST_SOF))
{
Usb_ack_event(EVT_HOST_SOF);
if (c++ >= 100) // Wait 100ms
{
device_state = DEVICE_DEFAULT;
}
}
break;
//------------------------------------------------------
// DEVICE_DEFAULT state
//
// - Get device descriptor
// - Reconfigure Pipe 0 according to Device EP0
// - Attribute device address
//
case DEVICE_DEFAULT :
// Get first device descriptor
Host_select_device(0);
usb_tree.device[0].ep_ctrl_size=8;
if( CONTROL_GOOD == host_get_device_descriptor_uncomplete())
{
c = 0;
while(c<20) // wait 20ms before USB reset (special buggly devices...)
{
if (Is_usb_event(EVT_HOST_SOF)) { Usb_ack_event(EVT_HOST_SOF); c++; }
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) {break;}
}
Host_disable_device_disconnection_interrupt();
Host_send_reset(); // First USB reset
Usb_ack_event(EVT_HOST_SOF);
while (Is_host_reset()); // Active wait of end of reset send
Host_ack_reset();
//Workaround for some bugly devices with powerless pull up
//usually low speed where data line rise slowly and can be interpretaded as disconnection
for(c=0;c!=0xFFFF;c++) // Basic Timeout counter
{
if(Is_usb_event(EVT_HOST_SOF)) //If we detect SOF, device is still alive and connected, just clear false disconnect flag
{
if(Is_device_disconnection())
{
Host_ack_device_connection();
Host_ack_device_disconnection();
break;
}
}
}
Host_enable_device_disconnection_interrupt();
c = 0;
host_configure_pipe(PIPE_CONTROL, \
TYPE_CONTROL, \
TOKEN_SETUP, \
EP_CONTROL, \
SIZE_64, \
ONE_BANK, \
0 );
while(c<200) // wait 200ms after USB reset
{
if (Is_usb_event(EVT_HOST_SOF)) { Usb_ack_event(EVT_HOST_SOF); c++; }
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) {break;}
}
usb_tree.device[0].ep_ctrl_size=data_stage[OFFSET_FIELD_MAXPACKETSIZE];
// Give an absolute device address
host_set_address(DEVICE_BASE_ADDRESS);
usb_tree.device[0].device_address=DEVICE_BASE_ADDRESS;
device_state = DEVICE_ADDRESSED;
}
else
{ device_state = DEVICE_ERROR; }
break;
//------------------------------------------------------
// DEVICE_BASE_ADDRESSED state
//
// - Check if VID PID is in supported list
//
case DEVICE_ADDRESSED :
if (CONTROL_GOOD == host_get_device_descriptor())
{
// Detect if the device connected belongs to the supported devices table
if (HOST_TRUE == host_check_VID_PID())
{
Host_set_device_supported();
Host_device_supported_action();
device_state = DEVICE_CONFIGURED;
}
else
{
#if (HOST_STRICT_VID_PID_TABLE==ENABLE)
Host_device_not_supported_action();
device_state = DEVICE_ERROR;
#else
device_state = DEVICE_CONFIGURED;
#endif
}
}
else // Can not get device descriptor
{ device_state = DEVICE_ERROR; }
break;
//------------------------------------------------------
// DEVICE_CONFIGURED state
//
// - Configure pipes for the supported interface
// - Send Set_configuration() request
// - Goto full operating mode (device ready)
//
case DEVICE_CONFIGURED :
if (CONTROL_GOOD == host_get_configuration_descriptor())
{
if (HOST_FALSE != host_check_class()) // Class support OK?
{
usb_tree.nb_device++;
#if (HOST_AUTO_CFG_ENDPOINT==ENABLE)
if(host_auto_configure_endpoint())
#else
Host_set_configured(); // Assumes config is OK with user config
if(User_configure_endpoint()) // User call here instead of autoconfig
#endif
{
if (CONTROL_GOOD== host_set_configuration(1)) // Send Set_configuration
{
//host_set_interface(interface_bound,interface_bound_alt_set);
// device and host are now fully configured
// goto DEVICE READY normal operation
device_state = DEVICE_READY;
Host_set_device_ready();
// monitor device disconnection under interrupt
Host_enable_device_disconnection_interrupt();
// If user host application requires SOF interrupt event
// Keep SOF interrupt enable otherwize, disable this interrupt
#if (HOST_CONTINUOUS_SOF_INTERRUPT==DISABLE && USB_HUB_SUPPORT==DISABLE)
Host_disable_sof_interrupt();
#endif
#if (USB_HUB_SUPPORT==ENABLE)
// Check if the connected device is a hub
if(Get_class(0)==HUB_CLASS && Get_subclass(0)==0x00 && Get_protocol(0)==0x00)
{
// Get hub descriptor
if( Get_hub_descriptor()==CONTROL_GOOD)
{
// Power each port of the hub
i=data_stage[NB_PORT_OFFSET];
for(c=1;c<=i;c++)
{
Set_port_feature(PORT_POWER,c);
}
nb_hub_present = 1;
hub_device_address[0]=DEVICE_BASE_ADDRESS;
hub_init(nb_hub_present-1);
}
}
else
{
nb_hub_present = 0;
new_device_connected=TRUE;
}
#else
new_device_connected=TRUE;
#endif
Enable_interrupt();
LOG_STR_CODE(log_device_enumerated);
}
else// Problem during Set_configuration request...
{ device_state = DEVICE_ERROR; }
}
}
else // device class not supported...
{
device_state = DEVICE_ERROR;
LOG_STR_CODE(log_device_unsupported);
Host_device_class_not_supported_action();
}
}
else // Can not get configuration descriptors...
{ device_state = DEVICE_ERROR; }
break;
//------------------------------------------------------
// DEVICE_READY state
//
// - Full std operatinf mode
// - Nothing to do...
//
case DEVICE_READY: // Host full std operating mode!
new_device_connected=FALSE;
#if (USB_HUB_SUPPORT==ENABLE)
f_hub_port_disconnect=FALSE;
// If one hub is present in the USB tree and the period interval
// for the interrupt hub endpoint occurs
if(nb_hub_present && hub_interrupt_sof==0)
{
saved_device=selected_device; // Backup user selected device
for(j=1;j<=nb_hub_present;j++)
{
for(i=0;i<MAX_DEVICE_IN_USB_TREE;i++)
{
if(usb_tree.device[i].device_address==hub_device_address[j-1]) break;
}
Host_select_device(i);
Host_select_pipe(usb_tree.device[i].interface[0].ep[0].pipe_number);
Host_ack_nak_received();
Host_ack_in_received();
Host_unfreeze_pipe();
Host_send_in();
while(1)
{
if(Is_host_nak_received()) break;
if(Is_host_emergency_exit()) break;
if(Is_host_in_received()) break;
}
Host_freeze_pipe();
if(Is_host_nak_received())
{
Host_ack_nak_received();
}
if(Is_host_in_received())
{
if(Is_host_stall()==FALSE)
{
c=Host_read_byte();
}
Host_ack_in_received();
hub_manage_port_change_status(c,j);
}
} // for all hub
Host_select_device(saved_device); // Restore user selected device
#if (USER_PERIODIC_PIPE==ENABLE)
unfreeze_user_periodic_pipe();
#endif
}
#endif
break;
//------------------------------------------------------
// DEVICE_ERROR state
//
// - Error state
// - Do custom action call (probably go to default mode...)
//
case DEVICE_ERROR : // TODO !!!!
#if (HOST_ERROR_RESTART==ENABLE)
device_state=DEVICE_UNATTACHED;
#endif
Host_device_error_action();
break;
//------------------------------------------------------
// DEVICE_SUSPENDED state
//
// - Host application request to suspend the device activity
// - State machine comes here thanks to Host_request_suspend()
//
case DEVICE_SUSPENDED :
if(Is_device_supports_remote_wakeup()) // If the connected device supports remote wake up
{
host_set_feature_remote_wakeup(); // Enable this feature...
}
LOG_STR_CODE(log_going_to_suspend);
c = Is_host_sof_interrupt_enabled(); //Save current sof interrupt enable state
Host_disable_sof_interrupt();
Host_ack_sof();
Host_disable_sof(); // Stop start of frame generation, this generates the suspend state
Host_ack_hwup();
Host_enable_hwup_interrupt(); // Enable host wake-up interrupt
// (this is the unique USB interrupt able to wake up the CPU core from power-down mode)
Usb_freeze_clock();
Stop_pll();
Host_suspend_action(); // Custom action here! (for example go to power-save mode...)
device_state=DEVICE_WAIT_RESUME; // wait for device resume event
break;
//------------------------------------------------------
// DEVICE_WAIT_RESUME state
//
// - Wait in this state till the host receives an upstream resume from the device
// - or the host software request the device to resume
//
case DEVICE_WAIT_RESUME :
if(Is_usb_event(EVT_HOST_HWUP)|| Is_host_request_resume())// Remote wake up has been detected
// or Local resume request has been received
{
if(Is_host_request_resume()) // Not a remote wakeup, but an host application request
{
Host_disable_hwup_interrupt(); // Wake up interrupt should be disable host is now wake up !
// CAUTION HWUP can be cleared only when USB clock is active
Pll_start_auto(); // First Restart the PLL for USB operation
Wait_pll_ready(); // Get sure pll is lock
Usb_unfreeze_clock(); // Enable clock on USB interface
Host_ack_hwup(); // Clear HWUP interrupt flag
}
Host_enable_sof();
Host_send_resume(); // Send down stream resume
while (Is_host_down_stream_resume()==FALSE); // Wait Down stream resume sent
Host_ack_remote_wakeup(); // Ack remote wake-up reception
Host_ack_request_resume(); // Ack software request
Host_ack_down_stream_resume(); // Ack down stream resume sent
Usb_ack_event(EVT_HOST_HWUP); // Ack software event
if(c) { Host_enable_sof_interrupt(); } // Restore SOF interrupt enable state before suspend
device_state=DEVICE_READY; // Come back to full operating mode
LOG_STR_CODE(log_usb_resumed);
}
break;
//------------------------------------------------------
// DEVICE_DISCONNECTED state
//
// - Device disconnection has been detected
// - Run scheduler in this state at least two times to get sure event is detected by all host application tasks
// - Go to DEVICE_DISCONNECTED_ACK state before DEVICE_UNATTACHED, to get sure scheduler calls all app tasks...
//
case DEVICE_DISCONNECTED :
device_state = DEVICE_DISCONNECTED_ACK;
break;
//------------------------------------------------------
// DEVICE_DISCONNECTED_ACK state
//
// - Device disconnection has been detected and managed bu applicatives tasks
// - Go to DEVICE_UNATTACHED state
//
case DEVICE_DISCONNECTED_ACK :
device_state = DEVICE_UNATTACHED;
break;
//------------------------------------------------------
// default state
//
// - Default case: ERROR
// - Goto no device state
//
default :
device_state = DEVICE_UNATTACHED;
break;
}
}
void usb_host_task(void)
#endif
{
#define DEVICE_DEFAULT_MAX_ERROR_COUNT 2
static uint8_t device_default_error_count;
#ifdef HOST_VBUS_LOW_TIMEOUT
extern t_cpu_time timer_vbus_low;
#endif
static bool sav_int_sof_enable;
uint8_t pipe;
#ifdef FREERTOS_USED
portTickType xLastWakeTime;
xLastWakeTime = xTaskGetTickCount();
while (true)
{
vTaskDelayUntil(&xLastWakeTime, configTSK_USB_HST_PERIOD);
#endif // FREERTOS_USED
switch (device_state)
{
#ifdef HOST_VBUS_LOW_TIMEOUT
case DEVICE_VBUS_LOW:
Usb_disable_vbus();
if (cpu_is_timeout(&timer_vbus_low))
usb_host_task_init();
break;
#endif
//------------------------------------------------------
// DEVICE_UNATTACHED state
//
// - Default init state
// - Try to give device power supply
//
case DEVICE_UNATTACHED:
device_default_error_count = 0;
nb_interface_supported = 0;
Host_clear_device_status(); // Reset device status
Usb_clear_all_event(); // Clear all software events
Host_disable_sof();
host_disable_all_pipes();
Usb_enable_vbus(); // Give at least device power supply!
// If VBus OK, wait for device connection
if (Is_usb_vbus_high())
device_state = DEVICE_ATTACHED;
break;
//------------------------------------------------------
// DEVICE_ATTACHED state
//
// - VBus is on
// - Try to detect device connection
//
case DEVICE_ATTACHED:
if (Is_host_device_connection() || Is_usb_event(EVT_HOST_CONNECTION) ) // Device pull-up detected
{
device_attached_retry:
if( Is_usb_event(EVT_HOST_CONNECTION) ) {
Usb_ack_event(EVT_HOST_CONNECTION);
}
Usb_ack_bconnection_error_interrupt();
Usb_ack_vbus_error_interrupt();
Host_ack_device_connection();
Host_clear_device_status(); // Reset device status
cpu_irq_disable();
Host_disable_device_disconnection_interrupt();
Host_send_reset(); // First USB reset
(void)Is_host_sending_reset();
cpu_irq_enable();
Usb_ack_event(EVT_HOST_SOF);
// Active wait for end of reset send
while (Is_host_sending_reset())
{
// The USB macro does not signal the end of reset when a disconnection occurs
if (Is_host_device_disconnection())
{
// Stop sending USB reset
Host_stop_sending_reset();
}
}
Host_ack_reset_sent();
Host_enable_sof(); // Start SOF generation
Host_enable_sof_interrupt(); // SOF will be detected under interrupt
if (!Is_host_device_disconnection())
{
// Workaround for some buggy devices with powerless pull-up
// usually low-speed where data line rises slowly and can be interpreted as disconnection
for (sof_cnt = 0; sof_cnt < 0xFFFF; sof_cnt++) // Basic time-out counter
{
// If we detect SOF, device is still alive and connected, just clear false disconnect flag
if (Is_usb_event(EVT_HOST_SOF) && Is_host_device_disconnection())
{
Host_ack_device_connection();
Host_ack_device_disconnection();
break;
}
}
}
Host_enable_device_disconnection_interrupt();
sof_cnt = 0;
while (sof_cnt < 100) // Wait 100 ms after USB reset
{
if (Is_usb_event(EVT_HOST_SOF)) Usb_ack_event(EVT_HOST_SOF), sof_cnt++; // Count SOFs
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) goto device_attached_error;
}
device_state = DEVICE_POWERED;
LOG_STR(log_device_connected);
Host_device_connection_action();
sof_cnt = 0;
}
device_attached_error:
// Device connection error, or VBus pb -> Retry the connection process from the beginning
if (Is_usb_bconnection_error_interrupt() || Is_usb_vbus_error_interrupt() || Is_usb_vbus_low())
{
if (device_state != DEVICE_VBUS_LOW)
device_state = DEVICE_UNATTACHED;
Usb_ack_bconnection_error_interrupt();
Usb_ack_vbus_error_interrupt();
Host_disable_sof();
}
break;
//------------------------------------------------------
// DEVICE_POWERED state
//
// - Device connection (attach) has been detected,
// - Wait 100 ms and configure default control pipe
//
case DEVICE_POWERED:
if (Is_usb_event(EVT_HOST_SOF))
{
Usb_ack_event(EVT_HOST_SOF);
if (sof_cnt++ >= 100) // Wait 100 ms
{
Host_enable_pipe(P_CONTROL);
(void)Host_configure_pipe(P_CONTROL,
0,
EP_CONTROL,
TYPE_CONTROL,
TOKEN_SETUP,
8,
SINGLE_BANK);
device_state = DEVICE_DEFAULT;
}
}
break;
//------------------------------------------------------
// DEVICE_DEFAULT state
//
// - Get device descriptor
// - Reconfigure control pipe according to device control endpoint
// - Assign device address
//
case DEVICE_DEFAULT:
// Get first device descriptor
if (host_get_device_descriptor_incomplete() == CONTROL_GOOD)
{
sof_cnt = 0;
while (sof_cnt < 20) // Wait 20 ms before USB reset (special buggy devices...)
{
if (Is_usb_event(EVT_HOST_SOF)) Usb_ack_event(EVT_HOST_SOF), sof_cnt++;
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) break;
}
cpu_irq_disable();
Host_disable_device_disconnection_interrupt();
Host_send_reset(); // First USB reset
(void)Is_host_sending_reset();
cpu_irq_enable();
Usb_ack_event(EVT_HOST_SOF);
// Active wait for end of reset send
while (Is_host_sending_reset())
{
// The USB macro does not signal the end of reset when a disconnection occurs
if (Is_host_device_disconnection())
{
// Stop sending USB reset
Host_stop_sending_reset();
}
}
Host_ack_reset_sent();
if (!Is_host_device_disconnection())
{
// Workaround for some buggy devices with powerless pull-up
// usually low-speed where data line rises slowly and can be interpreted as disconnection
for (sof_cnt = 0; sof_cnt < 0xFFFF; sof_cnt++) // Basic time-out counter
{
// If we detect SOF, device is still alive and connected, just clear false disconnect flag
if (Is_usb_event(EVT_HOST_SOF) && Is_host_device_disconnection())
{
Host_ack_device_connection();
Host_ack_device_disconnection();
break;
}
}
}
Host_enable_device_disconnection_interrupt();
sof_cnt = 0;
while (sof_cnt < 200) // Wait 200 ms after USB reset
{
if (Is_usb_event(EVT_HOST_SOF)) Usb_ack_event(EVT_HOST_SOF), sof_cnt++;
if (Is_host_emergency_exit() || Is_usb_bconnection_error_interrupt()) break;
}
Host_disable_pipe(P_CONTROL);
Host_unallocate_memory(P_CONTROL);
Host_enable_pipe(P_CONTROL);
// Reconfigure the control pipe according to the device control endpoint
(void)Host_configure_pipe(P_CONTROL,
0,
EP_CONTROL,
TYPE_CONTROL,
TOKEN_SETUP,
data_stage[OFFSET_FIELD_MAXPACKETSIZE],
SINGLE_BANK);
// Give an absolute device address
if (host_set_address(DEVICE_ADDRESS) == CONTROL_GOOD)
{
for (pipe = 0; pipe < MAX_PEP_NB; pipe++)
Host_configure_address(pipe, DEVICE_ADDRESS);
device_state = DEVICE_ADDRESSED;
}
else if (device_state != DEVICE_VBUS_LOW)
device_state = DEVICE_ERROR;
}
else
{
if (device_state != DEVICE_VBUS_LOW)
{
if (++device_default_error_count > DEVICE_DEFAULT_MAX_ERROR_COUNT)
device_state = DEVICE_ERROR;
else
{
Host_disable_sof();
Host_disable_pipe(P_CONTROL);
Host_unallocate_memory(P_CONTROL);
device_state = DEVICE_ATTACHED;
goto device_attached_retry;
}
}
Usb_ack_bconnection_error_interrupt();
Usb_ack_vbus_error_interrupt();
Host_disable_sof();
}
break;
//------------------------------------------------------
// DEVICE_ADDRESSED state
//
// - Check if VID PID is in supported list
//
case DEVICE_ADDRESSED:
if (host_get_device_descriptor() == CONTROL_GOOD)
{
// Detect if the device connected belongs to the supported devices table
if (host_check_VID_PID())
{
Host_set_device_supported();
Host_device_supported_action();
device_state = DEVICE_CONFIGURED;
}
else
{
#if HOST_STRICT_VID_PID_TABLE == ENABLE
device_state = DEVICE_ERROR;
LOG_STR(log_unsupported_device);
#else
device_state = DEVICE_CONFIGURED;
#endif
Host_device_not_supported_action();
}
}
else if (device_state != DEVICE_VBUS_LOW)
device_state = DEVICE_ERROR; // Can not get device descriptor
break;
//------------------------------------------------------
// DEVICE_CONFIGURED state
//
// - Configure pipes for the supported interface
// - Send Set_configuration() request
// - Go to full operating mode (device ready)
//
case DEVICE_CONFIGURED:
{
uint8_t configuration_index = 0;
if (host_get_configuration_descriptor(configuration_index) == CONTROL_GOOD)
{
if (host_check_class()) // Class support OK?
{
#if HOST_AUTO_CFG_ENDPOINT == DISABLE
User_configure_endpoint(); // User call here instead of autoconfig
Host_set_configured(); // Assumes config is OK with user config
#endif
if (Is_host_configured())
{
if (host_set_configuration(data_stage[OFFSET_FIELD_CONFIGURATION_NB]) == CONTROL_GOOD) // Send Set_configuration
{
// Device and host are now fully configured
// go to DEVICE_READY normal operation
device_state = DEVICE_READY;
// Monitor device disconnection under interrupt
Host_enable_device_disconnection_interrupt();
// If user host application requires SOF interrupt event
// Keep SOF interrupt enabled, otherwise disable this interrupt
#if HOST_CONTINUOUS_SOF_INTERRUPT == DISABLE
cpu_irq_disable();
Host_disable_sof_interrupt();
(void)Is_host_sof_interrupt_enabled();
cpu_irq_enable();
#endif
Host_new_device_connection_action();
cpu_irq_enable();
LOG_STR(log_device_enumerated);
}
else if (device_state != DEVICE_VBUS_LOW)
device_state = DEVICE_ERROR; // Problem during Set_configuration request...
}
}
else // Device class not supported...
{
device_state = DEVICE_UNSUPPORTED;
LOG_STR(log_unsupported_device);
Host_device_class_not_supported_action();
}
}
else if (device_state != DEVICE_VBUS_LOW)
device_state = DEVICE_ERROR; // Can not get configuration descriptors...
}
break;
//------------------------------------------------------
// DEVICE_READY state
//
// - Full standard operating mode
// - Nothing to do...
//
case DEVICE_READY: // Host full standard operating mode!
break;
//------------------------------------------------------
// DEVICE_UNSUPPORTED state
//
case DEVICE_UNSUPPORTED:
break;
//------------------------------------------------------
// DEVICE_ERROR state
//
// - Error state
// - Do custom action call (probably go to default mode...)
//
case DEVICE_ERROR: //! @todo
#if HOST_ERROR_RESTART == ENABLE
device_state = DEVICE_UNATTACHED;
#endif
Host_device_error_action();
break;
//------------------------------------------------------
// DEVICE_SUSPENDED state
//
// - Host application request to suspend the device activity
// - State machine comes here thanks to Host_request_suspend()
//
case DEVICE_SUSPENDED:
if (Is_device_supports_remote_wakeup()) // If the connected device supports remote wake-up
{
host_set_feature_remote_wakeup(); // Enable this feature...
}
LOG_STR(log_usb_suspended);
sav_int_sof_enable = Is_host_sof_interrupt_enabled(); //Save current SOF interrupt enable state
cpu_irq_disable();
Host_disable_sof_interrupt();
(void)Is_host_sof_interrupt_enabled();
cpu_irq_enable();
Host_ack_sof();
Host_disable_sof(); // Stop SOF generation, this generates the suspend state
Host_ack_hwup();
Host_enable_hwup_interrupt(); // Enable host wake-up interrupt
// (this is the unique USB interrupt able to wake up the CPU core from power-down mode)
(void)Is_host_hwup_interrupt_enabled(); // Make sure host wake-up interrupt is enabled
Usb_freeze_clock();
//! @todo Implement this on the silicon version
//Stop_pll();
Host_suspend_action(); // Custom action here! (e.g. go to power-save mode...)
device_state = DEVICE_WAIT_RESUME; // Wait for device resume event
break;
//------------------------------------------------------
// DEVICE_WAIT_RESUME state
//
// Wait in this state till:
// - the host receives an upstream resume from the device
// - or the host software request the device to resume
//
case DEVICE_WAIT_RESUME:
if (Is_usb_event(EVT_HOST_HWUP) || Is_host_request_resume()) // Remote wake-up has been detected
// or local resume request has been received
{
if (Is_host_request_resume()) // Not a remote wake-up, but a host application request
{
// CAUTION: HWUP can be cleared only when USB clock is active
//! @todo Implement this on the silicon version
//Pll_start_auto(); // First Restart the PLL for USB operation
//Wait_pll_ready(); // Make sure PLL is locked
Usb_unfreeze_clock(); // Enable clock on USB interface
(void)Is_usb_clock_frozen(); // Make sure USB interface clock is enabled
cpu_irq_disable();
Host_disable_hwup_interrupt(); // Wake-up interrupt should be disabled as host is now awoken!
(void)Is_host_hwup_interrupt_enabled();
cpu_irq_enable();
Host_ack_hwup(); // Clear HWUP interrupt flag
}
Host_enable_sof();
Host_send_resume(); // Send downstream resume
while (!Is_host_down_stream_resume()); // Wait for downstream resume sent
Host_ack_remote_wakeup(); // Ack remote wake-up reception
Host_ack_request_resume(); // Ack software request
Host_ack_down_stream_resume(); // Ack downstream resume sent
Usb_ack_event(EVT_HOST_HWUP); // Ack software event
if (sav_int_sof_enable) Host_enable_sof_interrupt(); // Restore SOF interrupt enable state before suspend
device_state = DEVICE_READY; // Come back to full operating mode
LOG_STR(log_usb_resumed);
}
break;
//------------------------------------------------------
// default state
//
// - Default case: ERROR
// - Go to DEVICE_UNATTACHED state
//
default:
device_state = DEVICE_UNATTACHED;
break;
}
#ifdef FREERTOS_USED
}
#endif
}
//------------------------------------------------------------------------------
/// USB interrupt subroutine
///
/// This function is called each time a USB interrupt occurs.
/// The following USB DEVICE events are taken in charge:
/// - VBus On / Off
/// - Start Of Frame
/// - Suspend
/// - Wake-Up
/// - Resume
/// - Reset
/// - Start of frame
///
/// The following USB HOST events are taken in charge:
/// - Device connection
/// - Device Disconnection
/// - Start Of Frame
/// - ID pin change
/// - SOF (or Keep alive in low speed) sent
/// - Wake up on USB line detected
///
/// The following USB HOST events are taken in charge:
/// - HNP success (Role Exchange)
/// - HNP failure (HNP Error)
///
/// For each event, the user can launch an action by completing
/// the associate define (See conf_usb.h file to add action upon events)
///
/// Note: Only interrupts events that are enabled are processed
//------------------------------------------------------------------------------
void usb_general_interrupt(void)
{
//TRACE_DEBUG("usb_general_interrupt\n\r");
// ---------- DEVICE events management -----------------------------------
// -----------------------------------------------------------------------
//- VBUS state detection
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled()
&& Is_usb_id_device()) {
Usb_ack_vbus_transition();
if (Is_usb_vbus_high()) {
usb_connected = TRUE;
Usb_vbus_on_action();
Usb_send_event(EVT_USB_POWERED);
//jcb Usb_enable_reset_interrupt();
//usb_start_device();
USBD_Connect();//Usb_attach();
}
else {
TRACE_DEBUG("VBUS low\n\r");
USBD_Disconnect();
Usb_device_stop_hnp();
TRACE_DEBUG("Usb_select_device4\n\r");
Usb_select_device();
Clear_all_user_request();
Usb_vbus_off_action();
usb_connected = FALSE;
usb_configuration_nb = 0;
Usb_send_event(EVT_USB_UNPOWERED);
}
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Device start of frame received
if (Is_usb_sof() && Is_sof_interrupt_enabled()) {
// TRACE_DEBUG_WP("F"); // device
Usb_ack_sof();
Usb_sof_action();
//sof_seen_in_session = TRUE;
otg_last_sof_received = UDFNUML; // store last frame number received
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Device Suspend event (no more USB activity detected)
if (Is_usb_suspend()) { //&& Is_suspend_interrupt_enabled()) {
//TRACE_DEBUG_WP("D\n\r");
// 1st : B-PERIPH mode ?
if (Is_usb_id_device()) {
// HNP Handler
TRACE_DEBUG("HNP Handler\n\r");
//TRACE_DEBUG("device_state = %d\n\r", device_state);
//TRACE_DEBUG("b_uut_device_state = %d\n\r", b_uut_device_state);
if (Is_host_requested_hnp() // "b_hnp_enable" feature received
&& (Is_session_started_with_srp() || Is_user_requested_hnp() )) {
if (otg_device_nb_hnp_retry == 0) {
otg_features_supported &= ~USBFeatureRequest_OTG_B_HNP_ENABLE;
}
else {
Ack_user_request_hnp();
Usb_ack_hnp_error_interrupt();
Usb_ack_role_exchange_interrupt();
Usb_enable_role_exchange_interrupt();
Usb_enable_hnp_error_interrupt();
Usb_device_initiate_hnp();
otg_device_nb_hnp_retry--;
}
}
else
{
// Remote wake-up handler
//TRACE_DEBUG("Remote wake-up handler\n\r");
//TRACE_DEBUG("device_state = %d\n\r", device_state);
//TRACE_DEBUG("b_uut_device_state = %d\n\r", b_uut_device_state);
if ((remote_wakeup_feature == ENABLE) && (usb_configuration_nb != 0))
{
//TRACE_DEBUG("enabled\n\r");
// After that user can execute "Usb_initiate_remote_wake_up()" to initiate a remote wake-up
// Note that the suspend interrupt flag SUSPI must still be set to enable upstream resume
// So the SUSPE enable bit must be cleared to avoid redundant interrupt
// ****************
// Please note also that is Vbus is lost during an upstream resume (Host disconnection),
// the RMWKUP bit (used to initiate remote wake up and that is normally cleared by hardware when sent)
// remains set after the event, so that a good way to handle this feature is :
// Usb_initiate_remote_wake_up();
// while (Is_usb_pending_remote_wake_up())
// {
// if (Is_usb_vbus_low())
// {
// // Emergency action (reset macro, etc.) if Vbus lost during resuming
// break;
// }
// }
// Usb_ack_remote_wake_up_start();
// ****************
}
else {
//TRACE_DEBUG("disabled: %d %d\n\r", usb_configuration_nb, remote_wakeup_feature);
// No remote wake-up supported
Usb_send_event(EVT_USB_SUSPEND);
}
}
}
else
{
//TRACE_DEBUG("ici\n\r");
// A-PERIPH mode (will cause a session end, handled in usb_host_task.c)
Usb_send_event(EVT_USB_SUSPEND);
Usb_suspend_action();
//jcb Usb_ack_suspend();
}
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Wake up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_swake_up_interrupt_enabled()) {
TRACE_DEBUG("W\n\r");
Usb_unfreeze_clock();
Usb_send_event(EVT_USB_WAKE_UP);
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - Resume state bus detection
if (Is_usb_resume() && Is_resume_interrupt_enabled()) {
TRACE_DEBUG("Resume state bus detect\n\r");
Usb_send_event(EVT_USB_RESUME);
}
// -----------------------------------------------------------------------
/// Device
// -----------------------------------------------------------------------
// - USB bus reset detection
if (Is_usb_reset()&& Is_reset_interrupt_enabled()) {
TRACE_DEBUG_WP("B\n\r");
if (Is_usb_id_host()) {
//TRACE_DEBUG_WP("id_host\n\r");
dev_configure_endpoint(EP_CONTROL,
TYPE_CONTROL,
DIRECTION_OUT,
SIZE_64,
ONE_BANK,
NYET_DISABLED);
}
// First initialization is important to be synchronized
// A reset must first have been received
if (device_state == A_PERIPHERAL) {
//TRACE_DEBUG_WP("r A_PERIPHERAL\n\r");
otg_last_sof_received = UDFNUML;
otg_last_sof_stored = UDFNUML;
Usb_ack_sof();
Usb_enable_sof_interrupt();
reset_received = TRUE;
Timer16_set_counter(0);
}
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
// ---------- OTG events management ------------------------------------
// ---------------------------------------------------------------------
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
// - OTG HNP Success detection
if (Is_usb_role_exchange_interrupt() && Is_role_exchange_interrupt_enabled()) {
// TRACE_DEBUG("OTG HNP detect\n\r");
Usb_ack_role_exchange_interrupt();
Host_ack_device_connection();
Host_ack_device_disconnection();
Otg_send_event(EVT_OTG_HNP_SUCCESS);
End_session_with_srp();
Clear_otg_features_from_host();
if (Is_usb_id_host()) {
// HOST (A- or B-) mode
if ((device_state != A_PERIPHERAL) && (device_state != A_END_HNP_WAIT_VFALL)) {
static volatile unsigned int jcb;
// Current mode is A-HOST, device will take the A-PERIPHERAL role
b_uut_device_state = B_PERIPHERAL;
device_state = A_PERIPHERAL;
usb_connected = FALSE;
usb_configuration_nb = 0;
Usb_select_device();
USBD_Connect();//Usb_attach();
Usb_unfreeze_clock();
Usb_disable_role_exchange_interrupt();
Usb_disable_hnp_error_interrupt();
Usb_device_stop_hnp();
Usb_ack_reset();
Timer16_set_counter(0);
Usb_freeze_clock(); // USB clock can be freezed to slow down events and condition detection
//jcb while (Timer16_get_counter_low() != 20);
jcb=0;
while( jcb <100000){ jcb++; }
Usb_unfreeze_clock();
reset_received = FALSE;
Usb_disable_sof_interrupt(); // will be set in the next OTG Timer IT (mandatory)
Usb_enable_suspend_interrupt();
Usb_enable_reset_interrupt();
dev_configure_endpoint(EP_CONTROL,
TYPE_CONTROL,
DIRECTION_OUT,
SIZE_64,
ONE_BANK,
NYET_DISABLED);
}
}
else {
// In B_HOST mode, the HNPREQ bit must not be cleared because it releases the bus in suspend mode (and sof can't start)
if ((b_uut_device_state != B_HOST) && (b_uut_device_state != B_END_HNP_SUSPEND)) {
static volatile unsigned int jcb2;
// Current mode is B-PERIPHERAL, device will go into B-HOST role
End_session_with_srp();
Clear_otg_features_from_host();
b_uut_device_state = B_HOST;
device_state = DEVICE_ATTACHED;
usb_connected = FALSE;
usb_configuration_nb = 0;
TRACE_DEBUG("Select host 3\n\r");
Usb_select_host();
TRACE_DEBUG("Send reset\n\r");
Host_send_reset(); // send the first RESET
while (Host_is_reset());
TRACE_DEBUG("Reset passed\n\r");
jcb2=0;
while( jcb2 <1000000){ jcb2++; }
Host_enable_sof(); // start Host (sof)
Usb_disable_role_exchange_interrupt();
Usb_disable_hnp_error_interrupt();
Clear_all_user_request();
TRACE_DEBUG("Select host 3\n\r");
}
}
}
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
// - OTG HNP Failure detection
if (Is_usb_hnp() && Is_usb_hnp_error_interrupt()&& Is_hnp_error_interrupt_enabled()) {
TRACE_DEBUG("OTG HNP failure\n\r");
Usb_device_stop_hnp();
Usb_disable_role_exchange_interrupt();
Usb_disable_hnp_error_interrupt();
Usb_ack_hnp_error_interrupt();
if (Is_usb_id_device()) {
Otg_send_event(EVT_OTG_HNP_ERROR);
Clear_all_user_request();
}
}
// ---------- HOST events management -----------------------------------
// ---------------------------------------------------------------------
// -----------------------------------------------------------------------
/// Arbitrer
// -----------------------------------------------------------------------
// - ID pin change detection
if(Is_usb_id_transition()&&Is_usb_id_interrupt_enabled()) {
TRACE_DEBUG("ID pin change\n\r");
TRACE_DEBUG("device_state = %d\n\r", device_state);
TRACE_DEBUG("b_uut_device_state = %d\n\r", b_uut_device_state);
Usb_device_stop_hnp();
Clear_all_user_request();
if(Is_usb_id_device()) {
g_usb_mode = USB_MODE_DEVICE;
}
else {
g_usb_mode = USB_MODE_HOST;
}
Usb_ack_id_transition();
if( g_usb_mode != g_old_usb_mode) { // Basic Debounce
if(Is_usb_id_device()) { // Going into device mode
Usb_send_event(EVT_USB_DEVICE_FUNCTION);
b_uut_device_state = B_IDLE;
device_state = DEVICE_UNATTACHED;
id_changed_to_host_event = DISABLE;
}
else { // Going into host mode
b_uut_device_state = B_IDLE;
device_state = DEVICE_UNATTACHED;
Usb_send_event(EVT_USB_HOST_FUNCTION);
id_changed_to_host_event = ENABLE;
}
Usb_id_transition_action();
TRACE_INFO("Pin Id changed\n\r");
}
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - The device has been disconnected
// JCB to be fix
if(Is_device_disconnection() && Is_host_device_disconnection_interrupt_enabled()) {
TRACE_DEBUG("device disconnect\n\r");
host_disable_all_pipe();
Host_ack_device_disconnection();
device_state=DEVICE_DISCONNECTED;
Usb_send_event(EVT_HOST_DISCONNECTION);
TRACE_INFO("Device disconnected\n\r");
Host_device_disconnection_action();
Clear_all_user_request();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - Device connection
if(Is_device_connection() && Is_host_device_connection_interrupt_enabled()) {
TRACE_DEBUG("device connect\n\r");
Host_ack_device_connection();
host_disable_all_pipe();
Host_device_connection_action();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - Host Start of frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled()) {
//TRACE_DEBUG_WP("_"); // host
Host_ack_sof();
Usb_send_event(EVT_HOST_SOF);
private_sof_counter++;
// delay timeout management for interrupt tranfer mode in host mode
#if ((USB_HOST_PIPE_INTERRUPT_TRANSFER==ENABLE) && (TIMEOUT_DELAY_ENABLE==ENABLE))
if (private_sof_counter>=250) { // Count 1/4 sec
private_sof_counter=0;
for(i=0;i<MAX_EP_NB;i++) {
if(it_pipe_str[i].enable==ENABLE) {
save_pipe_nb=Host_get_selected_pipe();
Host_select_pipe(i);
if((++it_pipe_str[i].timeout>TIMEOUT_DELAY) && (Host_get_pipe_type()!=TYPE_INTERRUPT)) {
it_pipe_str[i].enable=DISABLE;
it_pipe_str[i].status=PIPE_DELAY_TIMEOUT;
Host_stop_pipe_interrupt(i);
if (is_any_interrupt_pipe_active()==FALSE) { // If no more transfer is armed
if (g_sav_int_sof_enable==FALSE) {
Host_disable_sof_interrupt();
}
}
it_pipe_str[i].handle(PIPE_DELAY_TIMEOUT,it_pipe_str[i].nb_byte_processed);
}
Host_select_pipe(save_pipe_nb);
}
}
}
#endif // (USB_HOST_PIPE_INTERRUPT_TRANSFER==ENABLE) && (TIMEOUT_DELAY_ENABLE==ENABLE))
Host_sof_action();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// - Host Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled()) {
TRACE_DEBUG("Host wake up\n\r");
Host_disable_hwup_interrupt(); // Wake up interrupt should be disable host is now wake up !
Host_disable_remote_wakeup_interrupt();
// CAUTION HWUP can be cleared only when USB clock is active (not frozen)!
Usb_unfreeze_clock(); // Enable clock on USB interface
Host_enable_sof(); // start sending SOF
Host_ack_hwup(); // Clear HWUP interrupt flag
Host_ack_remote_wakeup();
Usb_send_event(EVT_HOST_HWUP); // Send software event
Usb_send_event(EVT_HOST_REMOTE_WAKEUP);
Host_hwup_action(); // Map custom action
if (Is_usb_hnp()) {
Usb_host_reject_hnp();
Usb_disable_hnp_error_interrupt();
Usb_disable_role_exchange_interrupt();
}
Host_send_resume();
}
// -----------------------------------------------------------------------
/// Host
// -----------------------------------------------------------------------
// Remote Wake Up has been received
if (Is_host_remote_wakeup_interrupt_enabled() && Is_host_remote_wakeup()) {
TRACE_DEBUG("Remote wake up\n\r");
Host_disable_remote_wakeup_interrupt();
Host_disable_hwup_interrupt();
Host_ack_remote_wakeup();
Host_ack_hwup(); // Clear HWUP interrupt flag
Usb_unfreeze_clock(); // Enable clock on USB interface
Host_enable_sof(); // start sending SOF
Usb_send_event(EVT_HOST_REMOTE_WAKEUP);
Usb_send_event(EVT_HOST_HWUP); // Send software event
if (Is_usb_hnp()) {
Usb_host_reject_hnp();
Usb_disable_hnp_error_interrupt();
Usb_disable_role_exchange_interrupt();
}
Host_send_resume();
}
}
