Functions | Variables

# usb_task.c File Reference

This file manages the USB task device. More...

`#include "config.h"`
`#include "conf_usb.h"`
`#include "usb_task.h"`
`#include "lib_mcu/usb/usb_drv.h"`
`#include "usb_descriptors.h"`
`#include "lib_mcu/power/power_drv.h"`
`#include "lib_mcu/wdt/wdt_drv.h"`
`#include "lib_mcu/pll/pll_drv.h"`
`#include "modules/usb/device_chap9/usb_device_task.h"`
Include dependency graph for usb_task.c:

Go to the source code of this file.

## Functions
void | usb_task_init (void)
| This function initializes the USB process.
void | usb_task (void)
| Entry point of the USB mamnagement.
__interrupt void | usb_general_interrupt ()
| USB interrupt subroutine.
## Variables
volatile U16 | g_usb_event = 0
| Public : U16 g_usb_event usb_connected is used to store USB events detected upon USB general interrupt subroutine Its value is managed by the following macros (See usb_task.h file) Usb_send_event(x) Usb_ack_event(x) Usb_clear_all_event() Is_usb_event(x) Is_not_usb_event(x)
bit | usb_connected
| Public : (bit) usb_connected usb_connected is set to TRUE when VBUS has been detected usb_connected is set to FALSE otherwise Used with USB_DEVICE_FEATURE == ENABLED only /.
U8 | usb_configuration_nb
| Public : (U8) usb_configuration_nb Store the number of the USB configuration used by the USB device when its value is different from zero, it means the device mode is enumerated Used with USB_DEVICE_FEATURE == ENABLED only /.
U8 | remote_wakeup_feature
| Public : (U8) remote_wakeup_feature Store a host request for remote wake up (set feature received) /.

## Detailed Description

This file manages the USB task device.

This module also contains the general USB interrupt subroutine. This subroutine is used to detect asynchronous USB events. Note:

- The usb_task belongs to the scheduler, the usb_device_task and usb_host do not, they are called from the general usb_task
- See conf_usb.h file for more details about the configuration of this module

- Compiler: IAR EWAVR and GNU GCC for AVR
- Supported devices: ATmega32U4

Author:
  Atmel Corporation: http://www.atmel.com
  Support and FAQ: http://support.atmel.no/

Definition in file usb_task.c.

## Function Documentation

__interrupt void usb_general_interrupt | ( | ) |

USB interrupt subroutine.

This function is called each time a USB interrupt occurs. The following USB DEVICE events are taken in charge:

- Start Of Frame
- Suspend
- Wake-Up
- Resume
- Reset

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

Parameters:

  none |

Returns:
  none

Definition at line 170 of file usb_task.c.

References EVT_USB_RESET, EVT_USB_RESUME, EVT_USB_SUSPEND, EVT_USB_WAKE_UP, FALSE, Is_pll_ready, Is_reset_interrupt_enabled, Is_resume_interrupt_enabled, Is_sof_interrupt_enabled, Is_suspend_interrupt_enabled, Is_usb_reset, Is_usb_resume, Is_usb_sof, Is_usb_suspend, Is_usb_vbus_interrupt_enabled, Is_usb_vbus_transition, Is_usb_wake_up, Is_wake_up_interrupt_enabled, Stop_pll, TRUE, Usb_ack_reset, Usb_ack_resume, Usb_ack_sof, Usb_ack_suspend, Usb_ack_wake_up, Usb_disable_resume_interrupt, Usb_disable_wake_up_interrupt, Usb_enable_reset_interrupt, Usb_enable_resume_interrupt, Usb_enable_suspend_interrupt, Usb_enable_wake_up_interrupt, Usb_freeze_clock, usb_init_device(), Usb_reset_action, Usb_resume_action, Usb_send_event, Usb_sof_action, Usb_suspend_action, usb_suspended, Usb_unfreeze_clock, Usb_wake_up_action, and Wait_pll_ready.

    {
      // - Device start of frame received
       if (Is_usb_sof() && Is_sof_interrupt_enabled())
       {
          Usb_ack_sof();
          Usb_sof_action();
       }
      // - Detection of VBus transition from USB Host
       if (Is_usb_vbus_transition() && Is_usb_vbus_interrupt_enabled())
       {
    #ifdef Usb_vbus_it_action
          Usb_vbus_it_action();
    #endif
       }
      // - 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();
    #ifndef USB_WAKEUP_POOLING
          Usb_enable_wake_up_interrupt();
    #endif
          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)
          {
             #ifdef USE_USB_AUTOBAUD
                usb_autobaud();
             #else
                Pll_start_auto();
             #endif
             Wait_pll_ready();
          }
          Usb_unfreeze_clock();
          Usb_ack_wake_up();
          if(usb_suspended)
          {
    #ifdef WA_USB_SUSPEND_PERTUBATION
             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_ack_suspend();
                Usb_enable_wake_up_interrupt();
                Usb_disable_resume_interrupt();
                Usb_freeze_clock();
                Stop_pll();
                Usb_suspend_action();
             }
    #else
             Usb_enable_resume_interrupt();
             Usb_enable_reset_interrupt();
             Usb_ack_wake_up();
             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();
    #endif
          }
       }
      // - 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);
       }
      // - 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);
       }

    }

Here is the call graph for this function: