__interrupt
#endif
static void usb_general_interrupt(void)
#endif
{
#ifdef FREERTOS_USED
portBASE_TYPE task_woken = pdFALSE;
#endif
#if USB_HOST_FEATURE == true && USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
U8 i;
#endif
// ---------- DEVICE/HOST events management ------------------------------------
#if USB_DEVICE_FEATURE == true && USB_HOST_FEATURE == true
// ID pin change detection
if (Is_usb_id_transition() && Is_usb_id_interrupt_enabled())
{
g_usb_mode = (Is_usb_id_device()) ? USB_MODE_DEVICE : USB_MODE_HOST;
Usb_ack_id_transition();
if (g_usb_mode != g_old_usb_mode) // Basic debounce
{
// Previously in device mode, check if disconnection was detected
if (g_old_usb_mode == USB_MODE_DEVICE)
{
if (usb_connected)
{
// Device mode disconnection actions
usb_connected = false;
usb_configuration_nb = 0;
Usb_vbus_off_action();
}
}
// Previously in host mode, check if disconnection was detected
else if (Is_host_attached())
{
// Host mode disconnection actions
device_state = DEVICE_UNATTACHED;
Host_device_disconnection_action();
}
//LOG_STR(log_pin_id_changed);
if (Is_usb_id_device() == USB_MODE_DEVICE) { LOG_STR(log_pin_id_changed_to_device); }
else { LOG_STR(log_pin_id_changed_to_host); }
Usb_send_event((Is_usb_device()) ? EVT_USB_DEVICE_FUNCTION :
EVT_USB_HOST_FUNCTION);
Usb_id_transition_action();
// Easier to recover from ID signal de-bounce and ID pin transitions by shutting down the USB and resetting state machine to re-init
#if ID_PIN_CHANGE_SHUTDOWN_USB == ENABLE
Usb_disable();
Usb_disable_otg_pad();
extern void UsbResetStateMachine(void);
UsbResetStateMachine();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
#endif
#if ID_PIN_CHANGE_GENERATE_RESET == ENABLE
Reset_CPU();
#endif
}
}
#endif // End DEVICE/HOST FEATURE MODE
// ---------- DEVICE events management -----------------------------------------
#if USB_DEVICE_FEATURE == true
#if USB_HOST_FEATURE == true
// If both device and host features are enabled, check if device mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
if (Is_usb_device())
#endif
{
// VBus state detection
if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled())
{
Usb_ack_vbus_transition();
if (Is_usb_vbus_high())
{
usb_start_device();
Usb_send_event(EVT_USB_POWERED);
Usb_vbus_on_action();
}
else
{
Usb_unfreeze_clock();
Usb_detach();
usb_connected = false;
usb_configuration_nb = 0;
Usb_send_event(EVT_USB_UNPOWERED);
Usb_vbus_off_action();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
}
}
// Device Start-of-Frame received
if (Is_usb_sof() && Is_usb_sof_interrupt_enabled())
{
Usb_ack_sof();
Usb_sof_action();
}
// Device Suspend event (no more USB activity detected)
if (Is_usb_suspend() && Is_usb_suspend_interrupt_enabled())
{
Usb_ack_suspend();
Usb_enable_wake_up_interrupt();
(void)Is_usb_wake_up_interrupt_enabled();
Usb_freeze_clock();
Usb_send_event(EVT_USB_SUSPEND);
Usb_suspend_action();
}
// Wake-up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_usb_wake_up_interrupt_enabled())
{
Usb_unfreeze_clock();
(void)Is_usb_clock_frozen();
Usb_ack_wake_up();
Usb_disable_wake_up_interrupt();
Usb_wake_up_action();
Usb_send_event(EVT_USB_WAKE_UP);
}
// Resume state bus detection
if (Is_usb_resume() && Is_usb_resume_interrupt_enabled())
{
Usb_disable_wake_up_interrupt();
Usb_ack_resume();
Usb_disable_resume_interrupt();
Usb_resume_action();
Usb_send_event(EVT_USB_RESUME);
}
// USB bus reset detection
if (Is_usb_reset() && Is_usb_reset_interrupt_enabled())
{
Usb_ack_reset();
usb_init_device();
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
}
#endif // End DEVICE FEATURE MODE
// ---------- HOST events management -------------------------------------------
#if USB_HOST_FEATURE == true
#if USB_DEVICE_FEATURE == true
// If both device and host features are enabled, check if host mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
else
#endif
{
// The device has been disconnected
if (Is_host_device_disconnection() && Is_host_device_disconnection_interrupt_enabled())
{
host_disable_all_pipes();
Host_ack_device_disconnection();
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
reset_it_pipe_str();
#endif
device_state = DEVICE_UNATTACHED;
LOG_STR(log_device_disconnected);
Usb_send_event(EVT_HOST_DISCONNECTION);
Host_device_disconnection_action();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
}
// Device connection
if (Is_host_device_connection() && Is_host_device_connection_interrupt_enabled())
{
Host_ack_device_connection();
host_disable_all_pipes();
Host_device_connection_action();
}
// Host Start-of-Frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled())
{
Host_ack_sof();
Usb_send_event(EVT_HOST_SOF);
#if (USB_HIGH_SPEED_SUPPORT==true)
if( Is_usb_full_speed_mode() )
{
private_sof_counter++;
}else{
private_sof_counter_HS++;
if( 0 == (private_sof_counter_HS%8) )
{
private_sof_counter++;
}
}
#else
private_sof_counter++;
#endif
// Delay time-out management for interrupt transfer mode in host mode
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE && TIMEOUT_DELAY_ENABLE == ENABLE
if (private_sof_counter >= 250) // Count 250 ms (SOF @ 1 ms)
{
private_sof_counter = 0;
for (i = 0; i < MAX_PEP_NB; i++)
{
if (it_pipe_str[i].enable &&
++it_pipe_str[i].timeout > TIMEOUT_DELAY && Host_get_pipe_type(i) != TYPE_INTERRUPT)
{
it_pipe_str[i].enable = false;
it_pipe_str[i].status = PIPE_DELAY_TIMEOUT;
Host_reset_pipe(i);
if (!is_any_interrupt_pipe_active() && !g_sav_int_sof_enable) // If no more transfer is armed
{
Host_disable_sof_interrupt();
}
it_pipe_str[i].handler(PIPE_DELAY_TIMEOUT, it_pipe_str[i].nb_byte_processed);
}
}
}
#endif
Host_sof_action();
}
// Host Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled())
{
// CAUTION: HWUP can be cleared only when USB clock is active (not frozen)!
//! @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
Host_disable_hwup_interrupt(); // Wake-up interrupt should be disabled as host is now awoken!
Host_ack_hwup(); // Clear HWUP interrupt flag
Usb_send_event(EVT_HOST_HWUP); // Send software event
Host_hwup_action(); // Map custom action
}
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
// Host pipe interrupts
while ((i = Host_get_interrupt_pipe_number()) < MAX_PEP_NB) usb_pipe_interrupt(i);
#endif
}
#endif // End HOST FEATURE MODE
#ifdef FREERTOS_USED
return task_woken;
#endif
}
ISR(usb_general_interrupt, AVR32_USBB_IRQ_GROUP, USB_INT_LEVEL)
#endif
{
#ifdef FREERTOS_USED
portBASE_TYPE task_woken = pdFALSE;
#endif
uint8_t i;
/* avoid Cppcheck Warning */
UNUSED(i);
// ---------- DEVICE/HOST events management ------------------------------------
#if USB_DEVICE_FEATURE == true && USB_HOST_FEATURE == true
// ID pin change detection
if (Is_usb_id_transition() && Is_usb_id_interrupt_enabled())
{
g_usb_mode = (Is_usb_id_device()) ? USB_MODE_DEVICE : USB_MODE_HOST;
Usb_ack_id_transition();
if (g_usb_mode != g_old_usb_mode) // Basic debounce
{
// Previously in device mode, check if disconnection was detected
if (g_old_usb_mode == USB_MODE_DEVICE)
{
if (usb_connected)
{
// Device mode diconnection actions
usb_connected = false;
usb_configuration_nb = 0;
Usb_vbus_off_action();
}
}
// Previously in host mode, check if disconnection was detected
else if (Is_host_attached())
{
// Host mode diconnection actions
device_state = DEVICE_UNATTACHED;
Host_device_disconnection_action();
}
LOG_STR(log_pin_id_changed);
Usb_send_event((Is_usb_device()) ? EVT_USB_DEVICE_FUNCTION :
EVT_USB_HOST_FUNCTION);
Usb_id_transition_action();
//! @todo ID pin hot state change!!!
// Preliminary management: HARDWARE RESET!!!
#if ID_PIN_CHANGE_GENERATE_RESET == ENABLE
// Hot ID transition generates CPU reset
Usb_disable();
Usb_disable_otg_pad();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#else
#if defined(CPU_RESET_CALLBACK)
CPU_RESET_CALLBACK();
#endif
Reset_CPU();
#endif
#endif
g_old_usb_mode = g_usb_mode; // Store current USB mode, for mode change detection
}
}
#endif // End DEVICE/HOST FEATURE MODE
// ---------- DEVICE events management -----------------------------------------
#if USB_DEVICE_FEATURE == true
#if USB_HOST_FEATURE == true
// If both device and host features are enabled, check if device mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
if (Is_usb_device())
#endif
{
// VBus state detection
if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled())
{
Usb_ack_vbus_transition();
if (Is_usb_vbus_high())
{
usb_start_device();
Usb_send_event(EVT_USB_POWERED);
Usb_vbus_on_action();
}
else
{
Usb_unfreeze_clock();
Usb_detach();
usb_connected = false;
usb_configuration_nb = 0;
Usb_send_event(EVT_USB_UNPOWERED);
Usb_vbus_off_action();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
}
}
// Device Start-of-Frame received
if (Is_usb_sof() && Is_usb_sof_interrupt_enabled())
{
Usb_ack_sof();
Usb_sof_action();
}
// Device Suspend event (no more USB activity detected)
if (Is_usb_suspend() && Is_usb_suspend_interrupt_enabled())
{
Usb_ack_suspend();
Usb_enable_wake_up_interrupt();
(void)Is_usb_wake_up_interrupt_enabled();
Usb_freeze_clock();
Usb_send_event(EVT_USB_SUSPEND);
Usb_suspend_action();
}
// Wake-up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_usb_wake_up_interrupt_enabled())
{
Usb_unfreeze_clock();
(void)Is_usb_clock_frozen();
Usb_ack_wake_up();
Usb_disable_wake_up_interrupt();
Usb_wake_up_action();
Usb_send_event(EVT_USB_WAKE_UP);
}
// Resume state bus detection
if (Is_usb_resume() && Is_usb_resume_interrupt_enabled())
{
Usb_disable_wake_up_interrupt();
Usb_ack_resume();
Usb_disable_resume_interrupt();
Usb_resume_action();
Usb_send_event(EVT_USB_RESUME);
}
// USB bus reset detection
if (Is_usb_reset() && Is_usb_reset_interrupt_enabled())
{
Usb_ack_reset();
usb_init_device();
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
}
#endif // End DEVICE FEATURE MODE
// ---------- HOST events management -------------------------------------------
#if USB_HOST_FEATURE == true
#if USB_DEVICE_FEATURE == true
// If both device and host features are enabled, check if host mode is engaged
// (accessing the USB registers of a non-engaged mode, even with load operations,
// may corrupt USB FIFO data).
else
#endif
{
// The device has been disconnected
if (Is_host_device_disconnection() && Is_host_device_disconnection_interrupt_enabled())
{
host_disable_all_pipes();
Host_ack_device_disconnection();
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
reset_it_pipe_str();
#endif
#ifdef HOST_VBUS_LOW_TIMEOUT
cpu_set_timeout(HOST_VBUS_LOW_TIMEOUT, &timer_vbus_low);
device_state = DEVICE_VBUS_LOW;
#else
device_state = DEVICE_UNATTACHED;
#endif
LOG_STR(log_device_disconnected);
Usb_send_event(EVT_HOST_DISCONNECTION);
Host_device_disconnection_action();
#ifdef FREERTOS_USED
// Release the semaphore in order to start a new device/host task
taskENTER_CRITICAL();
xSemaphoreGiveFromISR(usb_tsk_semphr, &task_woken);
taskEXIT_CRITICAL();
#endif
}
// Device connection
if (Is_host_device_connection() && Is_host_device_connection_interrupt_enabled())
{
Host_ack_device_connection();
host_disable_all_pipes();
Usb_send_event(EVT_HOST_CONNECTION);
Host_device_connection_action();
}
// Host Start-of-Frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled())
{
Host_ack_sof();
Usb_send_event(EVT_HOST_SOF);
private_sof_counter++;
// Delay time-out 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 250 ms (SOF @ 1 ms)
{
private_sof_counter = 0;
for (i = 0; i < MAX_PEP_NB; i++)
{
if (it_pipe_str[i].enable &&
++it_pipe_str[i].timeout > TIMEOUT_DELAY && Host_get_pipe_type(i) != TYPE_INTERRUPT)
{
it_pipe_str[i].enable = false;
it_pipe_str[i].status = PIPE_DELAY_TIMEOUT;
Host_reset_pipe(i);
if (!is_any_interrupt_pipe_active() && !g_sav_int_sof_enable) // If no more transfer is armed
{
Host_disable_sof_interrupt();
}
it_pipe_str[i].handler(PIPE_DELAY_TIMEOUT, it_pipe_str[i].nb_byte_processed);
}
}
}
#endif
Host_sof_action();
}
// Host Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled())
{
// CAUTION: HWUP can be cleared only when USB clock is active (not frozen)!
//! @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
Host_disable_hwup_interrupt(); // Wake-up interrupt should be disabled as host is now awoken!
Host_ack_hwup(); // Clear HWUP interrupt flag
Usb_send_event(EVT_HOST_HWUP); // Send software event
Host_hwup_action(); // Map custom action
}
Host_int_action();
while ((i = Host_get_interrupt_pipe_number()) < MAX_PEP_NB)
{
if (Is_host_in_received(i) && Is_host_in_received_interrupt_enabled(i))
{
Host_freeze_pipe(i);
Host_disable_in_received_interrupt(i);
}
}
#if defined(USB_HIGH_SPEED_SUPPORT) && USB_HIGH_SPEED_SUPPORT == true && \
defined(PIPE_AUDIO_IN)
// Workaround - freeze the IN audio pipe
if (Is_host_in_received(PIPE_AUDIO_IN))
{
extern void workaround_freeze_iso_in(void);
workaround_freeze_iso_in();
}
#endif // USB_HIGH_SPEED_SUPPORT == true
#if USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE
// Host pipe interrupts
while ((i = Host_get_interrupt_pipe_number()) < MAX_PEP_NB) usb_pipe_interrupt(i);
#endif
}
#endif // End HOST FEATURE MODE
#ifdef FREERTOS_USED
return task_woken;
#endif
}
/**
* @brief Entry point of the USB mamnagement
*
* Depending on the USB mode supported (HOST/DEVICE/DUAL_ROLE) the function
* calls the coresponding usb management function.
*
* @param none
*
* @return none
*/
void usb_task(void)
{
// ---- DUAL ROLE DEVICE USB MODE ---------------------------------------------
#if ((USB_DEVICE_FEATURE == ENABLED)&& (USB_HOST_FEATURE == ENABLED))
if(Is_usb_id_device())
{ g_usb_mode=USB_MODE_DEVICE;}
else
{ g_usb_mode=USB_MODE_HOST;}
if( g_old_usb_mode != g_usb_mode )
{
// ID pin hot state change
#if ( ID_PIN_CHANGE_GENERATE_RESET == ENABLE)
// Hot ID transition generates wdt reset
wdtdrv_enable(WDTO_16MS);
while(1);
#else
// Hot ID transition reset USB mode
Usb_ack_id_transition(); // REQUIRED
if (Is_usb_id_host())
{
Usb_disable_resume_interrupt();
Usb_disable_wake_up_interrupt();
Usb_disable_suspend_interrupt();
Usb_disable_reset_interrupt();
Usb_detach();
Usb_disable();
usb_host_task_init();
}
else
{
Host_disable_device_disconnection_interrupt();
Host_disable_sof_interrupt();
Host_disable_sof();
Usb_disable_vbus();
Usb_disable_manual_vbus();
Usb_freeze_clock();
Usb_disable();
usb_device_task_init();
}
#endif
}
// Store current usb mode, for mode change detection
g_old_usb_mode=g_usb_mode;
// Depending on current usb mode, launch the correct usb task (device or host)
switch(g_usb_mode)
{
case USB_MODE_DEVICE:
usb_device_task();
break;
case USB_MODE_HOST:
usb_host_task();
break;
case USB_MODE_UNDEFINED: // No break !
default:
break;
}
// -----------------------------------------------------------------------------
// ---- DEVICE ONLY USB MODE ---------------------------------------------------
#elif ((USB_DEVICE_FEATURE == ENABLED)&& (USB_HOST_FEATURE == DISABLE))
usb_device_task();
// -----------------------------------------------------------------------------
// ---- REDUCED HOST ONLY USB MODE ---------------------------------------------
#elif ((USB_DEVICE_FEATURE == DISABLE)&& (USB_HOST_FEATURE == ENABLED))
usb_host_task();
// -----------------------------------------------------------------------------
//! ---- ERROR, NO MODE ENABLED -------------------------------------------------
#elif ((USB_DEVICE_FEATURE == DISABLE)&& (USB_HOST_FEATURE == DISABLE))
#error at least one of USB_DEVICE_FEATURE or USB_HOST_FEATURE should be enabled
#error otherwise the usb task has nothing to do ...
#endif
// -----------------------------------------------------------------------------
}
__interrupt void usb_general_interrupt()
#endif
{
#if (USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE)
U8 i;
U8 save_pipe_nb;
#endif
// ---------- DEVICE events management -----------------------------------
#if (USB_DEVICE_FEATURE == ENABLED)
// - Device start of frame received
if (Is_usb_sof() && Is_sof_interrupt_enabled())
{
Usb_ack_sof();
Usb_sof_action();
}
#ifdef WA_USB_SUSPEND_PERTUBATION
// - Device Suspend event (no more USB activity detected)
if (Is_usb_suspend() && Is_suspend_interrupt_enabled())
{
usb_suspended=TRUE;
Usb_ack_wake_up(); // clear wake up to detect next event
Usb_send_event(EVT_USB_SUSPEND);
Usb_ack_suspend();
Usb_enable_wake_up_interrupt();
Usb_disable_resume_interrupt();
Usb_freeze_clock();
Stop_pll();
Usb_suspend_action();
}
// - Wake up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_wake_up_interrupt_enabled())
{
if(Is_pll_ready()==FALSE)
{
Pll_start_auto();
Wait_pll_ready();
}
Usb_unfreeze_clock();
Usb_ack_wake_up();
if(usb_suspended)
{
Usb_enable_resume_interrupt();
Usb_enable_reset_interrupt();
while(Is_usb_wake_up())
{
Usb_ack_wake_up();
}
usb_delay_ms(2);
if(Is_usb_sof() || Is_usb_resume() || Is_usb_reset() )
{
Usb_disable_wake_up_interrupt();
Usb_wake_up_action();
Usb_send_event(EVT_USB_WAKE_UP);
Usb_enable_suspend_interrupt();
Usb_enable_resume_interrupt();
Usb_enable_reset_interrupt();
}
else // Workarround to make the USB enter power down mode again (spurious transcient detected on the USB lines)
{
Usb_ack_wake_up(); // clear wake up to detect next event
Usb_send_event(EVT_USB_SUSPEND);
Usb_enable_wake_up_interrupt();
Usb_disable_resume_interrupt();
Usb_freeze_clock();
Stop_pll();
Usb_suspend_action();
}
}
}
// - Resume state bus detection
if (Is_usb_resume() && Is_resume_interrupt_enabled())
{
usb_suspended = FALSE;
Usb_disable_wake_up_interrupt();
Usb_ack_resume();
Usb_disable_resume_interrupt();
Usb_resume_action();
Usb_send_event(EVT_USB_RESUME);
}
#else
// - Device Suspend event (no more USB activity detected)
if (Is_usb_suspend() && Is_suspend_interrupt_enabled())
{
// Remote wake-up handler
if ((remote_wakeup_feature == ENABLED) && (usb_configuration_nb != 0))
{
Usb_disable_suspend_interrupt();
Usb_ack_wake_up();
Usb_enable_wake_up_interrupt();
Stop_pll();
Usb_freeze_clock();
Usb_suspend_action();
// 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_unfreeze_clock();
// 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
{
// No remote wake-up supported
Usb_ack_wake_up(); // clear wake up to detect next event
Usb_send_event(EVT_USB_SUSPEND);
Usb_ack_suspend(); // must be executed last (after Usb_suspend_action()) to allow upstream resume
Usb_enable_wake_up_interrupt();
Usb_freeze_clock();
Stop_pll();
Usb_suspend_action();
}
}
// - Wake up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_wake_up_interrupt_enabled())
{
if(Is_pll_ready()==FALSE)
{
Pll_start_auto();
Wait_pll_ready();
}
Usb_unfreeze_clock();
Usb_ack_wake_up();
Usb_disable_wake_up_interrupt();
Usb_wake_up_action();
Usb_send_event(EVT_USB_WAKE_UP);
Usb_enable_suspend_interrupt();
}
// - Resume state bus detection
if (Is_usb_resume() && Is_resume_interrupt_enabled())
{
Usb_disable_wake_up_interrupt();
Usb_ack_resume();
Usb_disable_resume_interrupt();
Usb_resume_action();
Usb_send_event(EVT_USB_RESUME);
}
#endif
// - USB bus reset detection
if (Is_usb_reset()&& Is_reset_interrupt_enabled())
{
Usb_ack_reset();
usb_init_device();
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
#endif// End DEVICE FEATURE MODE
// ---------- HOST events management -----------------------------------
#if (USB_HOST_FEATURE == ENABLED && USB_DEVICE_FEATURE == ENABLED)
// - ID pin change detection
if(Is_usb_id_transition()&&Is_usb_id_interrupt_enabled())
{
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 to device mode
{
Usb_send_event(EVT_USB_DEVICE_FUNCTION);
}
else // Going to host mode
{
Usb_send_event(EVT_USB_HOST_FUNCTION);
}
Usb_id_transition_action();
LOG_STR_CODE(log_id_change);
#if ( ID_PIN_CHANGE_GENERATE_RESET == ENABLE)
// Hot ID transition generates wdt reset
wdtdrv_enable(WDTO_16MS);
while(1);
#endif
}
}
#endif
#if (USB_HOST_FEATURE == ENABLED)
// - The device has been disconnected
if(Is_device_disconnection() && Is_host_device_disconnection_interrupt_enabled())
{
host_disable_all_pipe();
Host_ack_device_disconnection();
device_state=DEVICE_DISCONNECTED;
Usb_send_event(EVT_HOST_DISCONNECTION);
init_usb_tree();
LOG_STR_CODE(log_device_disconnect);
Host_device_disconnection_action();
}
// - Device connection
if(Is_device_connection() && Is_host_device_connection_interrupt_enabled())
{
Host_ack_device_connection();
host_disable_all_pipe();
Host_device_connection_action();
}
// - Host Start of frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled())
{
Host_ack_sof();
Usb_send_event(EVT_HOST_SOF);
private_sof_counter++;
#if (USB_HUB_SUPPORT==ENABLE)
hub_interrupt_sof++;
#endif
// 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 Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled())
{
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 (not frozen)!
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
Usb_send_event(EVT_HOST_HWUP); // Send software event
Host_hwup_action(); // Map custom action
}
#endif // End HOST FEATURE MODE
}
__interrupt void usb_general_interrupt()
#endif
{
#if (USB_HOST_PIPE_INTERRUPT_TRANSFER == ENABLE)
U8 i;
U8 save_pipe_nb;
#endif
// ---------- DEVICE events management -----------------------------------
#if (USB_DEVICE_FEATURE == ENABLED)
//- VBUS state detection
if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled())
{
Usb_ack_vbus_transition();
if (Is_usb_vbus_high())
{
usb_connected = TRUE;
Usb_vbus_on_action();
Usb_send_event(EVT_USB_POWERED);
Usb_enable_reset_interrupt();
usb_start_device();
Usb_attach();
}
else
{
Usb_vbus_off_action();
usb_connected = FALSE;
usb_configuration_nb = 0;
Usb_send_event(EVT_USB_UNPOWERED);
}
}
// - Device start of frame received
if (Is_usb_sof() && Is_sof_interrupt_enabled())
{
Usb_ack_sof();
Usb_sof_action();
}
// - Device Suspend event (no more USB activity detected)
if (Is_usb_suspend() && Is_suspend_interrupt_enabled())
{
Usb_ack_suspend();
Usb_enable_wake_up_interrupt();
Usb_ack_wake_up(); // clear wake up to detect next event
Usb_freeze_clock();
Usb_send_event(EVT_USB_SUSPEND);
Usb_suspend_action();
}
// - Wake up event (USB activity detected): Used to resume
if (Is_usb_wake_up() && Is_swake_up_interrupt_enabled())
{
Usb_unfreeze_clock();
Usb_ack_wake_up();
Usb_disable_wake_up_interrupt();
Usb_wake_up_action();
Usb_send_event(EVT_USB_WAKE_UP);
}
// - Resume state bus detection
if (Is_usb_resume() && Is_resume_interrupt_enabled())
{
Usb_disable_wake_up_interrupt();
Usb_ack_resume();
Usb_disable_resume_interrupt();
Usb_resume_action();
Usb_send_event(EVT_USB_RESUME);
}
// - USB bus reset detection
if (Is_usb_reset()&& Is_reset_interrupt_enabled())
{
Usb_ack_reset();
usb_init_device();
Usb_reset_action();
Usb_send_event(EVT_USB_RESET);
}
#endif// End DEVICE FEATURE MODE
// ---------- HOST events management -----------------------------------
#if (USB_HOST_FEATURE == ENABLED && USB_DEVICE_FEATURE == ENABLED)
// - ID pin change detection
if(Is_usb_id_transition()&&Is_usb_id_interrupt_enabled())
{
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 to device mode
{
Usb_send_event(EVT_USB_DEVICE_FUNCTION);
}
else // Going to host mode
{
Usb_send_event(EVT_USB_HOST_FUNCTION);
}
Usb_id_transition_action();
LOG_STR_CODE(log_id_change);
#if ( ID_PIN_CHANGE_GENERATE_RESET == ENABLE)
// Hot ID transition generates wdt reset
#ifndef AVRGCC
Wdt_change_16ms(); while(1);
#else
Wdt_change_enable(); while(1);
#endif
#endif
}
}
#endif
#if (USB_HOST_FEATURE == ENABLED)
// - The device has been disconnected
if(Is_device_disconnection() && Is_host_device_disconnection_interrupt_enabled())
{
host_disable_all_pipe();
Host_ack_device_disconnection();
device_state=DEVICE_DISCONNECTED;
Usb_send_event(EVT_HOST_DISCONNECTION);
LOG_STR_CODE(log_device_disconnect);
Host_device_disconnection_action();
}
// - Device connection
if(Is_device_connection() && Is_host_device_connection_interrupt_enabled())
{
Host_ack_device_connection();
host_disable_all_pipe();
Host_device_connection_action();
}
// - Host Start of frame has been sent
if (Is_host_sof() && Is_host_sof_interrupt_enabled())
{
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 Wake-up has been received
if (Is_host_hwup() && Is_host_hwup_interrupt_enabled())
{
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 (not frozen)!
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
Usb_send_event(EVT_HOST_HWUP); // Send software event
Host_hwup_action(); // Map custom action
}
#endif // End HOST FEATURE MODE
}
