em_usb.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef __EM_USB_H
#define __EM_USB_H

#include "em_device.h"
#include "em_assert.h"
#if defined(USB_PRESENT) && (USB_COUNT == 1)
#include "usbconfig.h"
#if defined(USB_DEVICE) || defined(USB_HOST)

#include <string.h>
#include <stddef.h>
#include "em_common.h"

#if defined(USB_USE_PRINTF)
#include <stdio.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __CC_ARM
#pragma anon_unions
#endif

#if defined(USB_HOST)
/***************************************************************************/
/***************************************************************************/
#else
/***************************************************************************/
/***************************************************************************/
#endif

#define SILABS_USB_VID          0x10C4          
/* SETUP request, direction of data stage */
#define USB_SETUP_DIR_OUT       0               
#define USB_SETUP_DIR_IN        1               
#define USB_SETUP_DIR_MASK      0x80            
#define USB_SETUP_DIR_D2H       0x80            
#define USB_SETUP_DIR_H2D       0x00            
/* SETUP request type */
#define USB_SETUP_TYPE_STANDARD       0         
#define USB_SETUP_TYPE_CLASS          1         
#define USB_SETUP_TYPE_VENDOR         2         
#define USB_SETUP_TYPE_STANDARD_MASK  0x00      
#define USB_SETUP_TYPE_CLASS_MASK     0x20      
#define USB_SETUP_TYPE_VENDOR_MASK    0x40      
/* SETUP request recipient */
#define USB_SETUP_RECIPIENT_DEVICE    0         
#define USB_SETUP_RECIPIENT_INTERFACE 1         
#define USB_SETUP_RECIPIENT_ENDPOINT  2         
#define USB_SETUP_RECIPIENT_OTHER     3         
/* SETUP standard request codes for Full Speed devices */
#define GET_STATUS                0             
#define CLEAR_FEATURE             1             
#define SET_FEATURE               3             
#define SET_ADDRESS               5             
#define GET_DESCRIPTOR            6             
#define SET_DESCRIPTOR            7             
#define GET_CONFIGURATION         8             
#define SET_CONFIGURATION         9             
#define GET_INTERFACE             10            
#define SET_INTERFACE             11            
#define SYNCH_FRAME               12            
/* SETUP class request codes */
#define USB_HID_GET_REPORT        0x01          
#define USB_HID_GET_IDLE          0x02          
#define USB_HID_SET_REPORT        0x09          
#define USB_HID_SET_IDLE          0x0A          
#define USB_HID_SET_PROTOCOL      0x0B          
#define USB_CDC_SETLINECODING     0x20          
#define USB_CDC_GETLINECODING     0x21          
#define USB_CDC_SETCTRLLINESTATE  0x22          
#define USB_MSD_BOTRESET          0xFF          
#define USB_MSD_GETMAXLUN         0xFE          
#define USB_AUDIO_GET_CUR         0x81          
#define USB_AUDIO_SET_CUR         0x01          
#define USB_AUDIO_GET_CUR         0x81          
#define USB_AUDIO_SET_MIN         0x02          
#define USB_AUDIO_GET_MIN         0x82          
#define USB_AUDIO_SET_MAX         0x03          
#define USB_AUDIO_GET_MAX         0x83          
#define USB_AUDIO_SET_RES         0x04          
#define USB_AUDIO_GET_RES         0x84          
#define USB_AUDIO_SET_MEM         0x05          
#define USB_AUDIO_GET_MEM         0x85          
#define USB_AUDIO_GET_STAT        0xFF          
/* SETUP command GET/SET_DESCRIPTOR decriptor types */
#define USB_DEVICE_DESCRIPTOR             1     
#define USB_CONFIG_DESCRIPTOR             2     
#define USB_STRING_DESCRIPTOR             3     
#define USB_MAX_STRING_DESCRIPTOR_CHARS   126   
#define USB_INTERFACE_DESCRIPTOR          4     
#define USB_ENDPOINT_DESCRIPTOR           5     
#define USB_DEVICE_QUALIFIER_DESCRIPTOR   6     
#define USB_OTHER_SPEED_CONFIG_DESCRIPTOR 7     
#define USB_INTERFACE_POWER_DESCRIPTOR    8     
#define USB_INTERFACE_ASSOCIATION_DESCRIPTOR 11 
#define USB_HID_DESCRIPTOR                0x21  
#define USB_SMARTCARD_DESCRIPTOR          0x21  
#define USB_HID_REPORT_DESCRIPTOR         0x22  
#define USB_CS_INTERFACE_DESCRIPTOR       0x24  
#define USB_CS_ENDPOINT_DESCRIPTOR        0x25  
#define USB_HUB_DESCRIPTOR                0x29  
#define USB_CA_HEADER_DESCRIPTOR          1     
#define USB_CA_INPUT_TERMINAL_DESCRIPTOR  2     
#define USB_CA_OUTPUT_TERMINAL_DESCRIPTOR 3     
#define USB_CA_MIXER_UNIT_DESCRIPTOR      4     
#define USB_CA_SELECTOR_UNIT_DESCRIPTOR   5     
#define USB_CA_FEATURE_UNIT_DESCRIPTOR    6     
#define USB_CA_PROCESSING_UNIT_DESCRIPTOR 7     
#define USB_CA_EXTENSION_UNIT_DESCRIPTOR  8     
#define USB_CA_EP_GENERAL_DESCRIPTOR      1     
#define USB_CA_AS_GENERAL_DESCRIPTOR      1     
#define USB_CA_FORMAT_TYPE_DESCRIPTOR     2     
#define USB_DEVICE_DESCSIZE               18    
#define USB_CONFIG_DESCSIZE               9     
#define USB_INTERFACE_DESCSIZE            9     
#define USB_ENDPOINT_DESCSIZE             7     
#define USB_DEVICE_QUALIFIER_DESCSIZE     10    
#define USB_OTHER_SPEED_CONFIG_DESCSIZE   9     
#define USB_INTERFACE_ASSOCIATION_DESCSIZE 8    
#define USB_HID_DESCSIZE                  9     
#define USB_SMARTCARD_DESCSIZE            54    
#define USB_CDC_HEADER_FND_DESCSIZE       5     
#define USB_CDC_CALLMNG_FND_DESCSIZE      5     
#define USB_CDC_ACM_FND_DESCSIZE          4     
#define USB_CA_INPUT_TERMINAL_DESCSIZE    12    
#define USB_CA_OUTPUT_TERMINAL_DESCSIZE   9     
#define USB_CA_EP_GENERAL_DESCSIZE        7     
#define USB_CA_AS_GENERAL_DESCSIZE        7     
#define USB_CA_STD_AS_ENDPOINT_DESCSZIE   9     
/* Misc. USB definitions */
#define USB_LS_CTRL_EP_MAXSIZE  8               
#define USB_LS_INTR_EP_MAXSIZE  8               
#define USB_FS_CTRL_EP_MAXSIZE  64              
#define USB_FS_INTR_EP_MAXSIZE  64              
#define USB_FS_BULK_EP_MAXSIZE  64              
#define USB_FS_ISOC_EP_MAXSIZE  1023            
#define USB_EPTYPE_CTRL         0               
#define USB_EPTYPE_ISOC         1               
#define USB_EPTYPE_BULK         2               
#define USB_EPTYPE_INTR         3               
#define USB_EPSYNC_NO           (0 << 2)        
#define USB_EPSYNC_ASYNC        (1 << 2)        
#define USB_EPSYNC_ADAPTIVE     (2 << 2)        
#define USB_EPSYNC_SYNC         (3 << 2)        
#define USB_EP_DIR_IN           0x80            
#define USB_SETUP_PKT_SIZE      8               
#define USB_EPNUM_MASK          0x0F            
#define USB_LANGID_ENUS         0x0409          
#define USB_MAX_DEVICE_ADDRESS  127             
#define CONFIG_DESC_BM_REMOTEWAKEUP 0x20        
#define CONFIG_DESC_BM_SELFPOWERED  0x40        
#define CONFIG_DESC_BM_RESERVED_D7  0x80        
#define CONFIG_DESC_BM_TRANSFERTYPE 0x03        
#define CONFIG_DESC_MAXPOWER_mA(x)  (((x)+1)/2) 
#define DEVICE_IS_SELFPOWERED       0x0001      
#define REMOTE_WAKEUP_ENABLED       0x0002      
#define USB_FEATURE_ENDPOINT_HALT         0     
#define USB_FEATURE_DEVICE_REMOTE_WAKEUP  1     
#define HUB_FEATURE_PORT_RESET            4     
#define HUB_FEATURE_PORT_POWER            8     
#define HUB_FEATURE_C_PORT_CONNECTION     16    
#define HUB_FEATURE_C_PORT_RESET          20    
#define HUB_FEATURE_PORT_INDICATOR        22    
#define USB_CLASS_CDC                     2     
#define USB_CLASS_CDC_DATA                0x0A  
#define USB_CLASS_CDC_ACM                 2     
#define USB_CLASS_CDC_HFN                 0     
#define USB_CLASS_CDC_CMNGFN              1     
#define USB_CLASS_CDC_ACMFN               2     
#define USB_CLASS_CDC_UNIONFN             6     
#define USB_CLASS_HID                     3     
#define USB_CLASS_HID_KEYBOARD            1     
#define USB_CLASS_HID_MOUSE               2     
#define USB_CLASS_HUB                     9     
#define USB_CLASS_MSD                     8     
#define USB_CLASS_MSD_BOT_TRANSPORT       0x50  
#define USB_CLASS_MSD_SCSI_CMDSET         6     
#define USB_CLASS_MSD_CSW_CMDPASSED       0     
#define USB_CLASS_MSD_CSW_CMDFAILED       1     
#define USB_CLASS_MSD_CSW_PHASEERROR      2     
#define USB_CLASS_AUDIO                   1     
#define USB_CLASS_AUDIO_CONTROL           1     
#define USB_CLASS_AUDIO_STREAMING         2     
#define USB_CLASS_AUDIO_MIDISTREAMING     3     
/*** Triplet for the device descriptor of a composite device using IAD descriptors. ***/
#define USB_CLASS_MISCELLANEOUS           0xEF  
#define USB_CLASS_MISC_COMMON_SUBCLASS    2     
#define USB_CLASS_MISC_IAD_PROTOCOL       1     
#define PORT_FULL_SPEED                   1     
#define PORT_LOW_SPEED                    2     
#if defined(__GNUC__)                     /* GCC compilers */
#if defined(__CHAR16_TYPE__)
typedef __CHAR16_TYPE__ char16_t;
#else
typedef unsigned short char16_t;          
#endif

#elif defined(__ICCARM__)                 /* IAR compiler */
#include <uchar.h>

#elif defined(__CC_ARM)                   /* MDK-ARM compiler */
typedef unsigned short char16_t;
#endif

#define STATIC_CONST_STRING_DESC(_name, ...)                    \
SL_PACK_START(1)                                                \
typedef struct                                                  \
{                                                               \
  uint8_t  len;                                                 \
  uint8_t  type;                                                \
  char16_t name[ 1 + sizeof((char16_t[]){__VA_ARGS__}) / 2];    \
} SL_ATTRIBUTE_PACKED _##_name;                                 \
SL_PACK_END()                                                   \
SL_ALIGN(4)                                                     \
SL_PACK_START(1)                                                \
static const _##_name _name SL_ATTRIBUTE_ALIGN(4)=              \
{                                                               \
  .len  = sizeof(_##_name) - 2,                                 \
  .type = USB_STRING_DESCRIPTOR,                                \
  .name = {__VA_ARGS__},                                        \
  .name[((sizeof(_##_name) - 2) / 2) - 1] = '\0'                \
}                                                               \
SL_PACK_END()

#define STATIC_CONST_STRING_DESC_LANGID(_name, x, y)        \
SL_PACK_START(1)                                            \
typedef struct                                              \
{                                                           \
  uint8_t len;                                              \
  uint8_t type;                                             \
  uint8_t name[ 2 ];                                        \
} SL_ATTRIBUTE_PACKED _##_name;                             \
SL_PACK_END()                                               \
SL_ALIGN(4)                                                 \
SL_PACK_START(1)                                            \
static const _##_name _name SL_ATTRIBUTE_ALIGN(4)=          \
{                                                           \
  .len = 4,                                                 \
  .type = USB_STRING_DESCRIPTOR,                            \
  .name = { y, x }                                          \
}                                                           \
SL_PACK_END()

#define UBUF(x, y) SL_ALIGN(4) uint8_t x[((y)+3)&~3] SL_ATTRIBUTE_ALIGN(4)

#define STATIC_UBUF(x, y) SL_ALIGN(4) static uint8_t x[((y)+3)&~3] SL_ATTRIBUTE_ALIGN(4)


typedef enum
{
  /* NOTE: Please keep in sync with table errMsg[] in em_usbhal.c */
  USB_STATUS_OK              = 0,               
  USB_STATUS_REQ_ERR         = -1,              
  USB_STATUS_EP_BUSY         = -2,              
  USB_STATUS_REQ_UNHANDLED   = -3,              
  USB_STATUS_ILLEGAL         = -4,              
  USB_STATUS_EP_STALLED      = -5,              
  USB_STATUS_EP_ABORTED      = -6,              
  USB_STATUS_EP_ERROR        = -7,              
  USB_STATUS_EP_NAK          = -8,              
  USB_STATUS_DEVICE_UNCONFIGURED = -9,          
  USB_STATUS_DEVICE_SUSPENDED    = -10,         
  USB_STATUS_DEVICE_RESET    = -11,             
  USB_STATUS_TIMEOUT         = -12,             
  USB_STATUS_DEVICE_REMOVED  = -13,             
  USB_STATUS_HC_BUSY         = -14,             
  USB_STATUS_DEVICE_MALFUNCTION = -15,          
  USB_STATUS_PORT_OVERCURRENT = -16,            
} USB_Status_TypeDef;
#if defined(USB_DEVICE)
/***************************************************************************/
#define USB_PWRSAVE_MODE_OFF       0 
#define USB_PWRSAVE_MODE_ONSUSPEND 1 
#define USB_PWRSAVE_MODE_ONVBUSOFF 2 
#define USB_PWRSAVE_MODE_ENTEREM2  4 
#define USB_USBC_32kHz_CLK_LFXO    0 
#define USB_USBC_32kHz_CLK_LFRCO   1 
typedef enum
{
  USBD_STATE_NONE       = 0,                    
  USBD_STATE_ATTACHED   = 1,                    
  USBD_STATE_POWERED    = 2,                    
  USBD_STATE_DEFAULT    = 3,                    
  USBD_STATE_ADDRESSED  = 4,                    
  USBD_STATE_CONFIGURED = 5,                    
  USBD_STATE_SUSPENDED  = 6,                    
  USBD_STATE_LASTMARKER = 7,                    
} USBD_State_TypeDef;
#endif /* defined(USB_DEVICE) */

SL_PACK_START(1)
typedef struct
{
  union
  {
    struct
    {
      union
      {
        struct
        {
          uint8_t Recipient : 5;                
          uint8_t Type      : 2;                
          uint8_t Direction : 1;                
        };
        uint8_t bmRequestType;                  
      };
      uint8_t   bRequest;                       
      uint16_t  wValue;                         
      uint16_t  wIndex;                         
      uint16_t  wLength;                        
    };
    uint32_t  dw[2];
  };
} SL_ATTRIBUTE_PACKED USB_Setup_TypeDef;
SL_PACK_END()



SL_PACK_START(1)
typedef struct
{
  uint8_t  bLength;                             
  uint8_t  bDescriptorType;                     
  uint16_t bcdUSB;                              
  uint8_t  bDeviceClass;                        
  uint8_t  bDeviceSubClass;                     
  uint8_t  bDeviceProtocol;                     
  uint8_t  bMaxPacketSize0;                     
  uint16_t idVendor;                            
  uint16_t idProduct;                           
  uint16_t bcdDevice;                           
  uint8_t  iManufacturer;                       
  uint8_t  iProduct;                            
  uint8_t  iSerialNumber;                       
  uint8_t  bNumConfigurations;                  
} SL_ATTRIBUTE_PACKED USB_DeviceDescriptor_TypeDef;
SL_PACK_END()



SL_PACK_START(1)
typedef struct
{
  uint8_t  bLength;                             
  uint8_t  bDescriptorType;                     
  uint16_t wTotalLength;                        
  uint8_t  bNumInterfaces;                      
  uint8_t  bConfigurationValue;                 
  uint8_t  iConfiguration;                      
  uint8_t  bmAttributes;                        
  uint8_t  bMaxPower;                           
} SL_ATTRIBUTE_PACKED USB_ConfigurationDescriptor_TypeDef;
SL_PACK_END()



SL_PACK_START(1)
typedef struct
{
  uint8_t bLength;                              
  uint8_t bDescriptorType;                      
  uint8_t bInterfaceNumber;                     
  uint8_t bAlternateSetting;                    
  uint8_t bNumEndpoints;                        
  uint8_t bInterfaceClass;                      
  uint8_t bInterfaceSubClass;                   
  uint8_t bInterfaceProtocol;                   
  uint8_t iInterface;                           
} SL_ATTRIBUTE_PACKED USB_InterfaceDescriptor_TypeDef;
SL_PACK_END()



SL_PACK_START(1)
typedef struct
{
  uint8_t   bLength;                            
  uint8_t   bDescriptorType;                    
  uint8_t   bEndpointAddress;                   
  uint8_t   bmAttributes;                       
  uint16_t  wMaxPacketSize;                     
  uint8_t   bInterval;                          
} SL_ATTRIBUTE_PACKED USB_EndpointDescriptor_TypeDef;
SL_PACK_END()



SL_PACK_START(1)
typedef struct
{
  uint8_t len;                                  
  uint8_t type;                                 
  char16_t name[];                              
} SL_ATTRIBUTE_PACKED USB_StringDescriptor_TypeDef;
SL_PACK_END()


/*** -------------------- Serial port debug configuration ---------------- ***/

#if defined(DOXY_DOC_ONLY)

/***************************************************************************/
int USB_PUTCHAR(char c);

/***************************************************************************/
void USB_PUTS(const char *p);

/***************************************************************************/
int USB_PRINTF(const char *format, ...);

#endif /* defined(DOXY_DOC_ONLY) */

/* Hardware constraint, do not change. */
#define MAX_NUM_HOSTCHANNELS  14

/* The DMA engine use one FIFO ram word for each host channel. */
#define MAX_HOST_FIFO_SIZE_INWORDS (512-MAX_NUM_HOSTCHANNELS)/*Unit is 4 bytes*/

#if defined (USER_PUTCHAR)
  void USB_Puts(const char *p);
  #define USB_PUTS(s)            USB_Puts(s)
  #define USB_PUTCHAR(c)         USER_PUTCHAR(c)
#else
  #define USB_PUTS(s)
  #define USB_PUTCHAR(c)
#endif

#if defined(USB_USE_PRINTF)
  #define USB_PRINTF                  printf
#else
  #define USB_PRINTF(...)
#endif /* defined(USB_USE_PRINTF) */

#if defined(DEBUG_USB_API)
  #define DEBUG_USB_API_PUTS(s)       USB_PUTS(s)
  #define DEBUG_USB_API_PUTCHAR(c)    USB_PUTCHAR(c)
#else
  #define DEBUG_USB_API_PUTS(s)
  #define DEBUG_USB_API_PUTCHAR(c)
#endif /* defined(DEBUG_USB_API) */

/*** -------------------- Common API definitions ------------------------- ***/

#if defined(USB_HOST)
  #if defined(NUM_APP_TIMERS)
    #define NUM_QTIMERS (NUM_HC_USED + 2 + NUM_APP_TIMERS + 1)
  #else
    #define NUM_QTIMERS (NUM_HC_USED + 2 + 1)
  #endif
  /* + 2 for default ctrl. host ch. 0 & 1, + 1 for host port timer  */
#else
  #if defined(NUM_APP_TIMERS)
    #define NUM_QTIMERS (NUM_APP_TIMERS)
  #else
    #define NUM_QTIMERS 0
  #endif
#endif /* defined(USB_HOST) */

/***************************************************************************/
typedef int (*USB_XferCompleteCb_TypeDef)(USB_Status_TypeDef status, uint32_t xferred, uint32_t remaining);

/***************************************************************************/
typedef void (*USBTIMER_Callback_TypeDef)(void);

char *USB_GetErrorMsgString(            int error);

#if defined(USB_USE_PRINTF)
  void USB_PrintErrorMsgString(         char *pre, int error);
#else
  #define USB_PrintErrorMsgString(      pre, error)
#endif

void  USBTIMER_DelayMs(                 uint32_t msec);
void  USBTIMER_DelayUs(                 uint32_t usec);
void  USBTIMER_Init(                    void);

#if (NUM_QTIMERS > 0)
  void  USBTIMER_Start(                 uint32_t id, uint32_t timeout, USBTIMER_Callback_TypeDef callback);
  void  USBTIMER_Stop(                  uint32_t id);
#endif /* (NUM_QTIMERS > 0) */

#if defined(USB_DEVICE)

/*** -------------------- DEVICE mode API definitions -------------------- ***/

/***************************************************************************/
typedef void (*USBD_UsbResetCb_TypeDef)(void);

/***************************************************************************/
typedef void (*USBD_SofIntCb_TypeDef)(uint16_t sofNr);

/***************************************************************************/
typedef void (*USBD_DeviceStateChangeCb_TypeDef)(USBD_State_TypeDef oldState, USBD_State_TypeDef newState);

/***************************************************************************/
typedef bool (*USBD_IsSelfPoweredCb_TypeDef)(void);

/***************************************************************************/
typedef int (*USBD_SetupCmdCb_TypeDef)(const USB_Setup_TypeDef *setup);

struct USBD_Callbacks_TypeDef;
typedef struct USBD_Callbacks_TypeDef const *USBD_Callbacks_TypeDef_Pointer;
typedef struct
{
  const USB_DeviceDescriptor_TypeDef      *deviceDescriptor;      
  const uint8_t                           *configDescriptor;      
  const void * const                      *stringDescriptors;     
  const uint8_t                           numberOfStrings;        
  const uint8_t                           *bufferingMultiplier;   
  USBD_Callbacks_TypeDef_Pointer          callbacks;              
  const uint32_t                          reserved;               
} USBD_Init_TypeDef;


typedef struct USBD_Callbacks_TypeDef
{
  const USBD_UsbResetCb_TypeDef           usbReset;               
  const USBD_DeviceStateChangeCb_TypeDef  usbStateChange;         
  const USBD_SetupCmdCb_TypeDef           setupCmd;               
  const USBD_IsSelfPoweredCb_TypeDef      isSelfPowered;          
  const USBD_SofIntCb_TypeDef             sofInt;                 
} USBD_Callbacks_TypeDef;


/*** -------------------- DEVICE mode API -------------------------------- ***/

void                USBD_AbortAllTransfers( void);
int                 USBD_AbortTransfer(     int epAddr);
void                USBD_Connect(           void);
void                USBD_Disconnect(        void);
bool                USBD_EpIsBusy(          int epAddr);
USBD_State_TypeDef  USBD_GetUsbState(       void);
const char *        USBD_GetUsbStateName(   USBD_State_TypeDef state);
int                 USBD_Init(              const USBD_Init_TypeDef *p);
int                 USBD_Read(              int epAddr, void *data, int byteCount, USB_XferCompleteCb_TypeDef callback);
int                 USBD_RemoteWakeup(      void);
bool                USBD_SafeToEnterEM2(    void);
int                 USBD_StallEp(           int epAddr);
void                USBD_Stop(              void);
int                 USBD_UnStallEp(         int epAddr);
int                 USBD_Write(             int epAddr, void *data, int byteCount, USB_XferCompleteCb_TypeDef callback);

#endif /* defined(USB_DEVICE) */


#if defined(USB_HOST)
/***************************************************************************/
/*** -------------------- HOST mode API definitions ---------------------- ***/

#define USB_VBUSOVRCUR_PORT_NONE     -1       
#define USB_VBUSOVRCUR_POLARITY_LOW  0        
#define USB_VBUSOVRCUR_POLARITY_HIGH 1        
typedef enum
{
  H_EP_IDLE             = 0,                      
  H_EP_SETUP            = 1,                      
  H_EP_DATA_IN          = 2,                      
  H_EP_DATA_OUT         = 3,                      
  H_EP_STATUS_IN        = 4,                      
  H_EP_STATUS_OUT       = 5,                      
} USBH_EpState_TypeDef;


typedef struct
{
  USB_Setup_TypeDef               setup;          
  uint8_t                         setupErrCnt;    
  USB_EndpointDescriptor_TypeDef  epDesc;         
  struct USBH_Device_TypeDef      *parentDevice;  
  uint8_t                         type;           
  uint16_t                        packetSize;     
  uint8_t                         hcOut;          
  uint8_t                         hcIn;           
  bool                            in;             
  uint8_t                         toggle;         
  USBH_EpState_TypeDef            state;          
  uint8_t                         addr;           
  uint8_t                         *buf;           
  volatile bool                   xferCompleted;  
  USB_Status_TypeDef              xferStatus;     
  USB_XferCompleteCb_TypeDef      xferCompleteCb; 
  uint32_t                        xferred;        
  uint32_t                        remaining;      
  uint32_t                        timeout;        
} USBH_Ep_TypeDef;


typedef struct USBH_Device_TypeDef
{
  USB_DeviceDescriptor_TypeDef          devDesc;  
  USB_ConfigurationDescriptor_TypeDef   confDesc; 
  USB_InterfaceDescriptor_TypeDef       itfDesc;  
  USBH_Ep_TypeDef                       ep0;      
  USBH_Ep_TypeDef                       *ep;      
  int                                   numEp;    
  uint8_t                               addr;     
  uint8_t                               speed;    
} USBH_Device_TypeDef;


typedef struct
{
  uint32_t                  rxFifoSize;     
  uint32_t                  nptxFifoSize;   
  uint32_t                  ptxFifoSize;    
  uint32_t                  reserved;       
} USBH_Init_TypeDef;


/* In DMA mode the total available FIFO space is smaller.       */
/* The DMA controller use one FIFO word pr. channel for status. */
/* The unit in the table is byte.                               */
#define USBH_INIT_DEFAULT                                                    \
{                                                                            \
  MAX_HOST_FIFO_SIZE_INWORDS * 2,/* 1024 bytes Rx FIFO size.             */  \
  MAX_HOST_FIFO_SIZE_INWORDS,    /* 512 bytes non-periodic Tx FIFO size. */  \
  MAX_HOST_FIFO_SIZE_INWORDS,    /* 512 bytes periodic Tx FIFO size.     */  \
  0                              /* Reserved.                            */  \
}

/*** -------------------- HOST mode API ---------------------------------- ***/

int     USBH_AssignHostChannel(            USBH_Ep_TypeDef *ep, uint8_t hcnum);
int     USBH_ControlMsg(                   USBH_Ep_TypeDef *ep, uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, uint16_t wLength, void *data, int timeout, USB_XferCompleteCb_TypeDef callback);
int     USBH_ControlMsgB(                  USBH_Ep_TypeDef *ep, uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, uint16_t wLength, void *data, int timeout);
bool    USBH_DeviceConnected(              void);
int     USBH_GetConfigurationDescriptorB(  USBH_Device_TypeDef *device, void *buf, int len, uint8_t configIndex);
int     USBH_GetDeviceDescriptorB(         USBH_Device_TypeDef *device, void *buf, int len);
uint8_t USBH_GetPortSpeed(                 void);
int     USBH_GetStringB(                   USBH_Device_TypeDef *device, uint8_t *buf, int bufLen, uint8_t stringIndex, uint16_t langID);
int     USBH_Init(                         const USBH_Init_TypeDef *p);
int     USBH_InitDeviceData(               USBH_Device_TypeDef *device, const uint8_t *buf, USBH_Ep_TypeDef *ep, int numEp, uint8_t deviceSpeed);
int     USBH_PortReset(                    void);
int     USBH_PortResume(                   void);
void    USBH_PortSuspend(                  void);
void    USBH_PrintString(                  const char *pre, const USB_StringDescriptor_TypeDef *s, const char *post);

#if defined(USB_USE_PRINTF)
int     USBH_PrintConfigurationDescriptor( const USB_ConfigurationDescriptor_TypeDef *config, int maxLen);
int     USBH_PrintDeviceDescriptor(        const USB_DeviceDescriptor_TypeDef *device);
int     USBH_PrintEndpointDescriptor(      const USB_EndpointDescriptor_TypeDef *endpoint);
int     USBH_PrintInterfaceDescriptor(     const USB_InterfaceDescriptor_TypeDef *interface);
#else
#define USBH_PrintConfigurationDescriptor( config, maxLen)
#define USBH_PrintDeviceDescriptor(        device)
#define USBH_PrintEndpointDescriptor(      endpoint)
#define USBH_PrintInterfaceDescriptor(     interface)
#endif /* defined(USB_USE_PRINTF) */

int                                  USBH_QueryDeviceB(                uint8_t *buf, size_t bufsize, uint8_t deviceSpeed);
USB_ConfigurationDescriptor_TypeDef* USBH_QGetConfigurationDescriptor( const uint8_t *buf, int configIndex);
USB_DeviceDescriptor_TypeDef*        USBH_QGetDeviceDescriptor(        const uint8_t *buf);
USB_EndpointDescriptor_TypeDef*      USBH_QGetEndpointDescriptor(      const uint8_t *buf, int configIndex, int interfaceIndex, int endpointIndex);
USB_InterfaceDescriptor_TypeDef*     USBH_QGetInterfaceDescriptor(     const uint8_t *buf, int configIndex, int interfaceIndex);

int     USBH_Read(                         USBH_Ep_TypeDef *ep, void *data, int byteCount, int timeout, USB_XferCompleteCb_TypeDef callback);
int     USBH_ReadB(                        USBH_Ep_TypeDef *ep, void *data, int byteCount, int timeout);
int     USBH_SetAddressB(                  USBH_Device_TypeDef *device, uint8_t deviceAddress);
int     USBH_SetAltInterfaceB(             USBH_Device_TypeDef *device, uint8_t interfaceIndex, uint8_t alternateSetting);
int     USBH_SetConfigurationB(            USBH_Device_TypeDef *device, uint8_t configValue);
int     USBH_StallEpB(                     USBH_Ep_TypeDef *ep);
void    USBH_Stop(                         void);
int     USBH_UnStallEpB(                   USBH_Ep_TypeDef *ep);
int     USBH_WaitForDeviceConnectionB(     uint8_t *buf, int timeoutInSeconds);
int     USBH_Write(                        USBH_Ep_TypeDef *ep, void *data, int byteCount, int timeout, USB_XferCompleteCb_TypeDef callback);
int     USBH_WriteB(                       USBH_Ep_TypeDef *ep, void *data, int byteCount, int timeout);

#endif /* defined(USB_HOST) */

#ifdef __cplusplus
}
#endif

#endif /* defined(USB_DEVICE) || defined(USB_HOST) */
#endif /* defined(USB_PRESENT) && (USB_COUNT == 1) */
#endif /* __EM_USB_H */