//! This function checks if the device class is supported.
//! The function looks in all interfaces declared in the received descriptors if
//! one of them matches an entry of the CLASS/SUB_CLASS/PROTOCOL table.
//! If HOST_AUTO_CFG_ENDPOINT is enabled, a pipe is configured for each endpoint
//! of supported interfaces.
//!
//! @return bool: Status
//!
bool host_check_class(void)
{
uint8_t *descriptor, *conf_end;
uint8_t device_class, device_subclass, device_protocol;
uint8_t c;
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
uint8_t nb_endpoint_to_configure = 0;
uint8_t ep_index = 0;
uint8_t physical_pipe = P_1; // P_1 because physical pipe 0 is reserved for control
uint16_t ep_size;
// By default, the host is configured when returning
Host_set_configured();
#endif
// First, assume no interface is supported
nb_interface_supported = 0;
// Check if configuration descriptor
if (data_stage[OFFSET_FIELD_DESCRIPTOR_TYPE] != CONFIGURATION_DESCRIPTOR) return false;
bmattributes = data_stage[OFFSET_FIELD_BMATTRIBUTES];
maxpower = data_stage[OFFSET_FIELD_MAXPOWER];
conf_end = data_stage +
min(usb_format_usb_to_mcu_data(16, *(uint16_t *)(data_stage + OFFSET_FIELD_TOTAL_LENGTH)),
SIZEOF_DATA_STAGE - OFFSET_FIELD_PROTOCOL);
// Look in all interfaces declared in the configuration
for (descriptor = data_stage + data_stage[OFFSET_DESCRIPTOR_LENGTH]; descriptor < conf_end;
descriptor += descriptor[OFFSET_DESCRIPTOR_LENGTH])
{
// Find next interface descriptor
switch (descriptor[OFFSET_FIELD_DESCRIPTOR_TYPE])
{
case INTERFACE_DESCRIPTOR:
// Check the number of supported interfaces does not exceed the maximum
if (nb_interface_supported >= MAX_INTERFACE_SUPPORTED) return true;
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
// If there are still endpoints to configure although a new interface descriptor has been found
if (nb_endpoint_to_configure)
{
// Mark the host as not configured
Host_clear_configured();
// Reset the number of endpoints to configure
nb_endpoint_to_configure = 0;
}
#endif
// Found an interface descriptor
// Get characteristics of this interface
device_class = descriptor[OFFSET_FIELD_CLASS];
device_subclass = descriptor[OFFSET_FIELD_SUB_CLASS];
device_protocol = descriptor[OFFSET_FIELD_PROTOCOL];
// Look in registered class table for match
for (c = 0; c < REG_CLASS_CNT; c += 3)
{
if (registered_class[c] == device_class && // Class is correct
registered_class[c + 1] == device_subclass && // Subclass is correct
registered_class[c + 2] == device_protocol) // Protocol is correct
{
// Store this interface as supported interface
// Memorize its interface nb
interface_supported[nb_interface_supported].interface_nb = descriptor[OFFSET_FIELD_INTERFACE_NB];
// its alternate setting
interface_supported[nb_interface_supported].altset_nb = descriptor[OFFSET_FIELD_ALT];
// its USB class
interface_supported[nb_interface_supported].uclass = device_class;
// its USB subclass
interface_supported[nb_interface_supported].subclass = device_subclass;
// its USB protocol
interface_supported[nb_interface_supported].protocol = device_protocol;
// the number of endpoints associated with this interface
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
ep_index = 0;
nb_endpoint_to_configure =
#endif
interface_supported[nb_interface_supported].nb_ep = min(descriptor[OFFSET_FIELD_NB_OF_EP], MAX_EP_PER_INTERFACE);
// Update the number of supported interfaces
nb_interface_supported++;
// Class/subclass/protocol is registered, so look for next interface descriptor
break;
}
}
break;
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
case ENDPOINT_DESCRIPTOR:
// If there are still endpoints to configure while there are free pipes
if (physical_pipe < MAX_PEP_NB && nb_endpoint_to_configure)
{
nb_endpoint_to_configure--;
// Reconfigure the new physical pipe to get rid of any previous configuration
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
cpu_irq_disable();
#endif
Host_disable_pipe(physical_pipe);
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
(void)Is_host_pipe_enabled(physical_pipe);
cpu_irq_enable();
#endif
Host_unallocate_memory(physical_pipe);
Host_enable_pipe(physical_pipe);
// Fix HW, set freq at 0 in case of no interrupt endpoint
if( TYPE_INTERRUPT != descriptor[OFFSET_FIELD_EP_TYPE] ) descriptor[OFFSET_FIELD_EP_INTERVAL] = 0;
ep_size = descriptor[OFFSET_FIELD_EP_SIZE] |
descriptor[OFFSET_FIELD_EP_SIZE + 1] << 8;
#if BOARD != EVK1104
if (ep_size <= 64)
{
#endif
// Build the pipe configuration according to the endpoint descriptor fields received
(void)Host_configure_pipe(
physical_pipe, // Pipe nb in USB interface
descriptor[OFFSET_FIELD_EP_INTERVAL], // Interrupt period (for interrupt pipe)
Get_desc_ep_nbr(descriptor[OFFSET_FIELD_EP_ADDR]), // Pipe endpoint number
descriptor[OFFSET_FIELD_EP_TYPE], // Pipe type (isochronous/bulk/interrupt)
Get_pipe_token(descriptor[OFFSET_FIELD_EP_ADDR]), // Pipe token (IN/OUT)
ep_size, // Pipe size
(descriptor[OFFSET_FIELD_EP_TYPE] == TYPE_BULK) ? SINGLE_BANK : DOUBLE_BANK // Number of banks to allocate for pipe
);
// Update endpoint pipe table in supported interface structure
interface_supported[nb_interface_supported - 1].ep_pipe[ep_index++] = physical_pipe++;
}
#if BOARD != EVK1104
else
{
// Build the pipe configuration according to the endpoint descriptor fields received
(void)Host_configure_pipe(
MAX_PEP_NB - 1, // Pipe nb in USB interface
descriptor[OFFSET_FIELD_EP_INTERVAL], // Interrupt period (for interrupt pipe)
Get_desc_ep_nbr(descriptor[OFFSET_FIELD_EP_ADDR]), // Pipe endpoint number
descriptor[OFFSET_FIELD_EP_TYPE], // Pipe type (isochronous/bulk/interrupt)
Get_pipe_token(descriptor[OFFSET_FIELD_EP_ADDR]), // Pipe token (IN/OUT)
ep_size, // Pipe size
(descriptor[OFFSET_FIELD_EP_TYPE] == TYPE_BULK) ? SINGLE_BANK : DOUBLE_BANK // Number of banks to allocate for pipe
);
// Update endpoint pipe table in supported interface structure
interface_supported[nb_interface_supported - 1].ep_pipe[ep_index++] = MAX_PEP_NB - 1;
}
}
#endif
break;
#endif
}
// Call user callback to look more deeply into the configuration descriptor
Host_user_check_class_action(descriptor);
}
#if HOST_AUTO_CFG_ENDPOINT == ENABLE
// If there are still endpoints to configure although all descriptors have been parsed
if (nb_endpoint_to_configure)
{
// Mark the host as not configured
Host_clear_configured();
}
#endif
return (nb_interface_supported > 0);
}
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
}
