//! //! @brief This function initializes the USB device controller //! //! This function enables the USB controller and init the USB interrupts. //! The aim is to allow the USB connection detection in order to send //! the appropriate USB event to the operating mode manager. //! Start device function is executed once VBUS connection has been detected //! either by the VBUS change interrupt either by the VBUS high level //! //! @param none //! //! @return none //! void usb_start_device (void) { Pll_start_auto(); Wait_pll_ready(); Usb_unfreeze_clock(); usb_init_device(); // configure the USB controller EP0 Usb_attach(); Usb_enable_suspend_interrupt(); Usb_enable_reset_interrupt(); #if (USB_OTG_FEATURE == ENABLED) Usb_enable_id_interrupt(); #endif }
/*! \brief Release a system mutex. * * \param xSemaphore A handle to the semaphore being released. * * \return pdTRUE if the semaphore was released. pdFALSE if an error occurred. */ portBASE_TYPE x_supervisor_SemaphoreGive( xSemaphoreHandle xSemaphore ) { #ifdef USB_ENABLE #if USB_DEVICE_FEATURE == true if( ( 0 != u8IsMaintenanceRequired ) && ( false == bOutOfMaintenance ) ) { // If we have to enter in the maintenance mode, do not release the mutex. // => this mutex is now the property of the supervisor. u8IsMaintenanceRequired++; // If all mutexes have been acquired, switch to maintenance mode. if( ( SUPERVISOR_MAINTENANCE_NBMUTEX_TOTAKE +1 ) == u8IsMaintenanceRequired ) { fat_cache_flush(); // Flush the FAT cache. nav_reset(); // Reset all file system navigators. We will mount // the com1shell default drive when we'll leave the // maintenance mode. // Switch to maintenance mode. xSemaphoreGive( xUSBMutex ); // If the USB clock is frozen, unfreeze it so that we can write in the // USB registers. The USB clock is frozen if a "Device Suspend" event // occurred (no more USB activity detected) (cf. usb_general_interrupt()). if(true == Is_usb_clock_frozen()) { Usb_unfreeze_clock(); } // If it is not already detached, physically detach the USB device. if(false == Is_usb_detached()) { Usb_detach(); } vTaskDelay(500); // Wait 500ms Usb_attach(); // Reconnect the device. bIsInMaintenance = true; u8IsMaintenanceRequired = 0; TRACE_COM2( "Entering maintenance mode"); #ifdef MMILCD_ENABLE vMMI_SetUserMenuMode( eUserMenuWaitHost, pdTRUE ); #endif } return( pdTRUE ); } else #endif #endif return( xSemaphoreGive( xSemaphore ) ); }
/** * @brief This function initializes the USB controller in host mode and * the associated variables. * * This function enables the USB controller for host mode operation. * * @param none * * @return none * */ void usb_host_task_init(void) { Pll_start_auto(); Wait_pll_ready(); Usb_disable(); Usb_enable(); Usb_unfreeze_clock(); Usb_attach(); Usb_enable_uvcon_pin(); Usb_select_host(); Usb_disable_vbus_hw_control(); // Force Vbus generation without timeout Host_enable_device_disconnection_interrupt(); device_state=DEVICE_UNATTACHED; init_usb_tree(); }
/*! * \brief The switch-to-maintenance-mode command: initiate the process to \n * switch to maintenance mode. * Format: maintain * * \note This function must be of the type pfShellCmd defined by the shell module. * * \param xModId Input. The module that is calling this function. * \param FsNavId Ignored. * \param ac Ignored. * \param av Ignored. * \param ppcStringReply Input/Output. The response string. * If Input is NULL, no response string will be output. * Else a malloc for the response string is performed here; * the caller must free this string. * * \return the status of the command execution. */ eExecStatus e_supervisor_switch_to_maintenance_mode( eModId xModId, signed short FsNavId, int ac, signed portCHAR *av[], signed portCHAR **ppcStringReply ) { if( NULL != ppcStringReply ) *ppcStringReply = NULL; #ifdef USB_ENABLE #if USB_DEVICE_FEATURE == true if( ( false == bIsInMaintenance ) && ( 0 == u8IsMaintenanceRequired ) ) { // We're not in maintenance mode. // Initiate the process of switching to maintenance mode. if( 0 == u8IsMaintenanceRequired ) u8IsMaintenanceRequired++; // Take all maintenance mutex except the USB mutex. if( true == x_supervisor_SemaphoreTake( xLOGMutex, 0 ) ) u8IsMaintenanceRequired++; #if NW_INTEGRATED_IN_CONTROL_PANEL if( true == x_supervisor_SemaphoreTake( xWEBMutex, 0 ) ) u8IsMaintenanceRequired++; #endif if( true == x_supervisor_SemaphoreTake( xSHELLFSMutex, 0 ) ) u8IsMaintenanceRequired++; if( true == x_supervisor_SemaphoreTake( xCFGMutex, 0 ) ) u8IsMaintenanceRequired++; // If all mutexes have been acquired, switch to maintenance mode. if( ( SUPERVISOR_MAINTENANCE_NBMUTEX_TOTAKE +1 ) == u8IsMaintenanceRequired ) { fat_cache_flush(); // flush the FAT cache. nav_reset(); // Reset all file system navigators. We will mount // the com1shell default drive when we'll leave the // maintenance mode. // Switch to maintenance mode. xSemaphoreGive( xUSBMutex ); // If the USB clock is frozen, unfreeze it so that we can write in the // USB registers. if(true == Is_usb_clock_frozen()) { Usb_unfreeze_clock(); } // If it is not akready detached, physically detach the USB device. if(false == Is_usb_detached()) { Usb_detach(); } vTaskDelay(500); // Wait 500ms Usb_attach(); // Reconnect the device. bIsInMaintenance = true; u8IsMaintenanceRequired = 0; TRACE_COM2( "Entering maintenance mode"); #ifdef MMILCD_ENABLE vMMI_SetUserMenuMode( eUserMenuWaitHost, pdTRUE ); #endif } // ELSE: we'll switch to maintenance mode in x_supervisor_SemaphoreGive() // (when the mutex(es) that we couldn't get will be released). } else { NAKED_TRACE_COM2( "Won't go to maintenance mode:"CRLF"bIsInMaintenance=%d u8CurrentUsbRole=%d u8IsMaintenanceRequired=%d", bIsInMaintenance, u8CurrentUsbRole, u8IsMaintenanceRequired ); } #endif #endif return( SHELL_EXECSTATUS_OK ); }
//! @brief Entry point of the USB device mamagement //! //! This function is the entry point of the USB management. Each USB //! event is checked here in order to launch the appropriate action. //! If a Setup request occurs on the Default Control Endpoint, //! the usb_process_request() function is call in the usb_standard_request.c file //! //! @param none //! //! @return none void usb_device_task(void) { #if (USB_OTG_FEATURE == ENABLED) // Check if a reset has been received if(Is_usb_event(EVT_USB_RESET)) { Usb_ack_event(EVT_USB_RESET); Usb_reset_endpoint(0); usb_configuration_nb=0; otg_b_device_state = B_IDLE; Clear_otg_features_from_host(); } // When OTG mode enabled, B-Device is managed thanks to its state machine switch (otg_b_device_state) { //------------------------------------------------------ // B_IDLE state // // - waits for Vbus to rise // - initiate SRP if asked by user // case B_IDLE: if (Is_usb_vbus_high()) { // Vbus rise usb_connected = TRUE; remote_wakeup_feature = DISABLED; usb_start_device(); Usb_vbus_on_action(); Usb_attach(); otg_b_device_state = B_PERIPHERAL; Ack_user_request_srp(); Clear_otg_features_from_host(); remote_wakeup_feature = DISABLED; End_session_with_srp(); if (Is_srp_sent_and_waiting_answer() && (sof_seen_in_session == TRUE)) { Ack_srp_sent_and_answer(); Otg_print_new_failure_message(OTGMSG_A_RESPONDED,OTG_TEMPO_2SEC); } Usb_enable_sof_interrupt(); } else { if (Is_user_requested_srp() && Is_usb_id_device()) { // User has requested a SRP Ack_user_request_srp(); if (!Is_srp_sent_and_waiting_answer()) { Pll_start_auto(); // reinit device mode Wait_pll_ready(); Usb_disable(); Usb_enable_uid_pin(); Usb_enable(); Usb_unfreeze_clock(); Usb_select_device(); Usb_attach(); otg_b_device_state = B_SRP_INIT; Usb_device_initiate_srp(); // hardware waits for initial condition (SE0, Session End level) sof_seen_in_session = FALSE; } } if ((Is_srp_sent_and_waiting_answer()) && (Is_tb_srp_counter_overflow())) { // SRP failed because A-Device did not respond End_session_with_srp(); Ack_srp_sent_and_answer(); Otg_print_new_failure_message(OTGMSG_SRP_A_NO_RESP,OTG_TEMPO_3SEC); } } break; //------------------------------------------------------ // B_SRP_INIT // // - a SRP has been initiated // - B-Device waits it is finished to initialize variables // case B_SRP_INIT: if (!Is_usb_device_initiating_srp()) { otg_b_device_state = B_IDLE; // SRP initiated, return to Idle state (wait for Vbus to rise) Srp_sent_and_waiting_answer(); Init_tb_srp_counter(); Start_session_with_srp(); Otg_print_new_event_message(OTGMSG_SRP_STARTED,TB_SRP_FAIL_MIN); } break; //------------------------------------------------------ // B_PERIPHERAL : the main state of OTG Peripheral // // - all events are interrupt-handled // - but they are saved and this function can execute alternate actions // - also handle user requests (disconnect) // // ====================================================================================== case B_PERIPHERAL: if (Is_otg_event(EVT_OTG_DEVICE_CONNECTED)) { Otg_ack_event(EVT_OTG_DEVICE_CONNECTED); // set on a SetConfiguration descriptor reception Otg_print_new_event_message(OTGMSG_CONNECTED_TO_A,OTG_TEMPO_4SEC); } if (Is_usb_event(EVT_USB_SUSPEND)) // SUSPEND state { // Suspend and HNP operations are handled in the interrupt functions } if (Is_srp_sent_and_waiting_answer() && (sof_seen_in_session == TRUE)) { Ack_srp_sent_and_answer(); Otg_print_new_failure_message(OTGMSG_A_RESPONDED,OTG_TEMPO_2SEC); } if ((Is_srp_sent_and_waiting_answer()) && (Is_tb_srp_counter_overflow())) { // SRP failed because A-Device did not respond End_session_with_srp(); Ack_srp_sent_and_answer(); Otg_print_new_failure_message(OTGMSG_SRP_A_NO_RESP,OTG_TEMPO_3SEC); } if (Is_usb_event(EVT_USB_RESUME) && !Is_usb_pending_remote_wake_up()) // RESUME signal detected { Usb_ack_event(EVT_USB_RESUME); Usb_ack_event(EVT_USB_SUSPEND); Usb_ack_remote_wake_up_start(); } if (Is_usb_event(EVT_USB_UNPOWERED)) { Usb_ack_event(EVT_USB_UNPOWERED); Clear_all_user_request(); otg_b_device_state = B_IDLE; } if(Is_usb_event(EVT_USB_RESET)) { Usb_ack_event(EVT_USB_RESET); Usb_reset_endpoint(0); usb_configuration_nb=0; Clear_otg_features_from_host(); } if (Is_otg_event(EVT_OTG_HNP_ERROR)) { Otg_ack_event(EVT_OTG_HNP_ERROR); Otg_print_new_failure_message(OTGMSG_DEVICE_NO_RESP,OTG_TEMPO_4SEC); PORTC &= ~0x10; } if (Is_user_requested_disc()) { Ack_user_request_disc(); if (Is_usb_id_device()) { Usb_detach(); Usb_freeze_clock(); while (Is_usb_vbus_high()); // wait for Vbus to be under Va_vbus_valid otg_b_device_state = B_IDLE; usb_configuration_nb = 0; usb_connected = FALSE; Clear_all_user_request(); } } break; //------------------------------------------------------ // B_HOST // // - state entered after an HNP success // - handle user requests (disconnection, suspend, hnp) // - call the "host_task()" for Host level handlers // // ====================================================================================== case B_HOST: if (Is_otg_event(EVT_OTG_DEV_UNSUPPORTED)) { Otg_ack_event(EVT_OTG_DEV_UNSUPPORTED); Clear_all_user_request(); otg_b_device_state = B_IDLE; device_state = DEVICE_UNATTACHED; } if (Is_user_requested_disc() || Is_user_requested_suspend() || Is_user_requested_hnp()) { Ack_user_request_disc(); // suspend and hnp requests cleared in B_END_HNP_SUSPEND stage Host_disable_sof(); // go into suspend mode Usb_host_reject_hnp(); otg_b_device_state = B_END_HNP_SUSPEND; Usb_ack_suspend(); Usb_enable_suspend_interrupt(); } if (Is_usb_event(EVT_USB_UNPOWERED)) { Usb_ack_event(EVT_USB_UNPOWERED); Usb_freeze_clock(); otg_b_device_state = B_IDLE; device_state = DEVICE_UNATTACHED; } usb_host_task(); // call the host task break; //------------------------------------------------------ // B_END_HNP_SUSPEND // // - device enters this state after being B_HOST, on a user request to stop bus activity (suspend, disconnect or hnp request) // - macro is reset to peripheral mode // // ====================================================================================== case B_END_HNP_SUSPEND: if (Is_usb_event(EVT_USB_SUSPEND)) { Usb_ack_event(EVT_USB_SUSPEND); Usb_device_stop_hnp(); Usb_select_device(); device_state = DEVICE_UNATTACHED; if (Is_user_requested_hnp() || Is_user_requested_suspend()) { otg_b_device_state = B_PERIPHERAL; Ack_user_request_suspend(); Ack_user_request_hnp(); } else { otg_b_device_state = B_IDLE; Usb_detach(); Usb_freeze_clock(); } } break; default: otg_b_device_state = B_IDLE; Clear_all_user_request(); device_state = DEVICE_UNATTACHED; break; } #else // Non-OTG exclusives Device operations // VBUS state detection if (Is_usb_vbus_high()&& (usb_connected==FALSE)) { usb_connected = TRUE; remote_wakeup_feature = DISABLED; Usb_vbus_on_action(); Usb_send_event(EVT_USB_POWERED); usb_start_device(); } if (Is_usb_vbus_low()&& (usb_connected==TRUE)) { usb_connected = FALSE; usb_configuration_nb = 0; Usb_send_event(EVT_USB_UNPOWERED); Usb_detach(); Usb_freeze_clock(); Usb_vbus_off_action(); } if(Is_usb_event(EVT_USB_RESET)) { Usb_ack_event(EVT_USB_RESET); Usb_reset_endpoint(0); usb_configuration_nb=0; } #endif // ======================================= // Common Standard Device Control Requests // ======================================= // - device enumeration process // - device control commands and features Usb_select_endpoint(EP_CONTROL); if (Is_usb_receive_setup()) { usb_process_request(); } }
/** \brief Process incomming char on debug port */ void menu_process(char c) { static enum menustate_enum /* Defines an enumeration type */ { normal, channel } menustate = normal; static char channel_string[3]; static uint8_t channel_string_i = 0; int tempchannel; if (menustate == channel) { switch(c) { case '\r': case '\n': channel_string[channel_string_i] = 0; //Will return zero in event of error... tempchannel = atoi(channel_string); //Bounds check only if user had real input if ( ((channel_string_i) && (tempchannel < 11)) || (tempchannel > 26)) { PRINTF_P(PSTR("\n\rInvalid input\n\r")); } //If valid input, change it if (tempchannel) { radio_set_operating_channel(tempchannel); eeprom_write_byte(9, tempchannel); //Write channel eeprom_write_byte(10, ~tempchannel); //Bit inverse as check } menustate = normal; break; case '\b': if (channel_string_i) channel_string_i--; break; default: if (channel_string_i > 1) { menustate = normal; PRINTF_P(PSTR("\n\rInput too long!\n\r")); break; } channel_string[channel_string_i] = c; channel_string_i++; } } else { uint8_t i; switch(c) { case '\r': case '\n': break; case 'h': case '?': menu_print(); break; case 's': PRINTF_P(PSTR("Jackdaw now in sniffer mode\n\r")); usbstick_mode.sendToRf = 0; usbstick_mode.translate = 0; break; case 'n': PRINTF_P(PSTR("Jackdaw now in network mode\n\r")); usbstick_mode.sendToRf = 1; usbstick_mode.translate = 1; break; case '6': if (usbstick_mode.sicslowpan) { PRINTF_P(PSTR("Jackdaw does not perform 6lowpan translation\n\r")); usbstick_mode.sicslowpan = 0; } else { PRINTF_P(PSTR("Jackdaw now performs 6lowpan translations\n\r")); usbstick_mode.sicslowpan = 1; } break; case 'r': if (usbstick_mode.raw) { PRINTF_P(PSTR("Jackdaw does not capture raw frames\n\r")); usbstick_mode.raw = 0; } else { PRINTF_P(PSTR("Jackdaw now captures raw frames\n\r")); usbstick_mode.raw = 1; } break; case 'c': PRINTF_P(PSTR("Select 802.15.4 Channel in range 11-26 [%d]: "), radio_get_operating_channel()); menustate = channel; channel_string_i = 0; break; case 'm': PRINTF_P(PSTR("Currently Jackdaw:\n\r * Will ")); if (usbstick_mode.sendToRf == 0) { PRINTF_P(PSTR("not "));} PRINTF_P(PSTR("send data over RF\n\r * Will ")); if (usbstick_mode.translate == 0) { PRINTF_P(PSTR("not "));} PRINTF_P(PSTR("change link-local addresses inside IP messages\n\r * Will ")); if (usbstick_mode.sicslowpan == 0) { PRINTF_P(PSTR("not "));} PRINTF_P(PSTR("decompress 6lowpan headers\n\r * Will ")); if (usbstick_mode.raw == 0) { PRINTF_P(PSTR("not "));} PRINTF_P(PSTR("Output raw 802.15.4 frames\n\r ")); PRINTF_P(PSTR(" * Operates on channel %d\n\r"), radio_get_operating_channel()); break; case 'u': //Mass storage mode usb_mode = mass_storage; //No more serial port stdout = NULL; //RNDIS is over rndis_state = rndis_uninitialized; Leds_off(); //Deatch USB Usb_detach(); //Wait a few seconds for(i = 0; i < 50; i++) _delay_ms(100); //Attach USB Usb_attach(); break; default: PRINTF_P(PSTR("%c is not a valid option! h for menu\n\r"), c); break; } } return; }
static void usb_eth_setup_timeout_fallback_check() { extern uint8_t fingerPresent; /* Device is Enumerated but RNDIS not loading. We might have a system that does not support IAD (winXP). If so count the timeout then switch to just network interface. */ static uint16_t iad_fail_timeout, rndis_fail_timeout; if (usb_mode == rndis_debug) { //If we have timed out, detach if (iad_fail_timeout == IAD_TIMEOUT_DETACH) { //Failed - BUT we are using "reverse logic", hence we force device //into this mode. This is used to allow Windows Vista have time to //install the drivers if (fingerPresent && (rndis_state != rndis_data_initialized) && Is_device_enumerated() ) { iad_fail_timeout = 0; } else { stdout = NULL; Usb_detach(); doInit = 1; //Also mark system as needing intilizing } //Then wait a few before re-attaching } else if (iad_fail_timeout == IAD_TIMEOUT_ATTACH) { if (fingerPresent) { usb_mode = mass_storage; } else { usb_mode = rndis_only; } Usb_attach(); } //Increment timeout when device is not initializing, OR we have already detached, //OR the user had their finger on the device, indicating a reverse of logic if ( ( (rndis_state != rndis_data_initialized) && Is_device_enumerated() ) || (iad_fail_timeout > IAD_TIMEOUT_DETACH) || (fingerPresent) ) { iad_fail_timeout++; } else { iad_fail_timeout = 0; } } //usb_mode == rndis_debug /* Device is Enumerated but RNDIS STIL not loading. We just have RNDIS interface, so obviously no drivers on target. Just go ahead and mount ourselves as mass storage... */ if (usb_mode == rndis_only) { //If we have timed out, detach if (rndis_fail_timeout == RNDIS_TIMEOUT_DETACH) { Usb_detach(); //Then wait a few before re-attaching } else if (rndis_fail_timeout == RNDIS_TIMEOUT_ATTACH) { usb_mode = mass_storage; Usb_attach(); } //Increment timeout when device is not initializing, OR we are already //counting to detach if ( ( (rndis_state != rndis_data_initialized)) || (rndis_fail_timeout > RNDIS_TIMEOUT_DETACH) ) { rndis_fail_timeout++; } else { rndis_fail_timeout = 0; } }//usb_mode == rnids_only }
__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 }