csl_usb.h

Go to the documentation of this file.

/*  ============================================================================
 *   Copyright (c) Texas Instruments Inc 2002, 2003, 2004, 2005, 2008
 *
 *   Use of this software is controlled by the terms and conditions found in the
 *   license agreement under which this software has been supplied.
 *  ============================================================================
 */

/* ============================================================================
 * Revision History
 * ================
 * 05-Sep-2008 Created
 * 25-Dec-2008 Added Isochronous Transfer Support
 * ============================================================================
 */

#ifndef _CSL_USB_H_
#define _CSL_USB_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <cslr.h>
#include <csl_error.h>
#include <csl_types.h>
#include <cslr_usb.h>
#include <soc.h>
#include <csl_general.h>


/*****************************************************************************\
          USB MUSB global macro declarations                                  *
\*****************************************************************************/
#define CSL_USB_EP0                                 (0)

#define CSL_USB_EP1                                 (1)

#define CSL_USB_EP2                                 (2)

#define CSL_USB_EP3                                 (3)

#define CSL_USB_EP4                                 (4)

#define CSL_USB_IN_TRANSFER                         (0x80)

#define CSL_USB_OUT_TRANSFER                        (0x00)

#define CSL_USB_MAX_EP0_FIFO_LEN                    (0x0040)

#define CSL_USB_SETUP_PACKET_LEN                    (4)

#define CSL_USB_EP0_PACKET_SIZE                     (0x40)

#define CSL_USB_EP_PACKET_SIZE_FS                   (0x40)

#define CSL_USB_EP_PACKET_SIZE_HS                   (0x200)

#define CSL_USB_EP1_PACKET_SIZE_FS                  (0x40)

#define CSL_USB_EP1_PACKET_SIZE_HS                  (0x200)

#define CSL_USB_EP2_PACKET_SIZE_FS                  (0x40)

#define CSL_USB_EP2_PACKET_SIZE_HS                  (0x200)

#define CSL_USB_EP3_PACKET_SIZE_FS                  (0x40)

#define CSL_USB_EP3_PACKET_SIZE_HS                  (0x200)

#define CSL_USB_EP4_PACKET_SIZE_FS                  (0x40)

#define CSL_USB_EP4_PACKET_SIZE_HS                  (0x200)

#define CSL_USB_FIFO_SIZE                           (512)

#define CSL_USB_IN_EP_FIFO_START                    (8)

#define CSL_USB_OUT_EP_FIFO_START                   (8)

#define CSL_USB_TXRXFIFOSZ_TX_SHIFT                 (0)

#define CSL_USB_TXRXFIFOSZ_RX_SHIFT                 (8)

#define CSL_USB_TX_FIFO_SIZE_8                      (0)

#define CSL_USB_TX_FIFO_SIZE_16                     (1)

#define CSL_USB_TX_FIFO_SIZE_32                     (2)

#define CSL_USB_TX_FIFO_SIZE_64                     (3)

#define CSL_USB_TX_FIFO_SIZE_128                    (4)

#define CSL_USB_TX_FIFO_SIZE_256                    (5)

#define CSL_USB_TX_FIFO_SIZE_512                    (6)

#define CSL_USB_TX_FIFO_SIZE_1024                   (7)

#define CSL_USB_TX_FIFO_SIZE_2048                   (8)

#define CSL_USB_TX_FIFO_SIZE_4096                   (9)

#define CSL_USB_RX_FIFO_SIZE_8               (0 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_16              (1 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_32              (2 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_64              (3 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_128             (4 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_256             (5 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_512             (6 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_1024            (7 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_2048            (8 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_RX_FIFO_SIZE_4096            (9 << CSL_USB_TXRXFIFOSZ_RX_SHIFT)

#define CSL_USB_ENDPOINT_COUNT                      (8)

#define CSL_USB_MAX_OUTEP0BUF_LEN                   (128)

#define CSL_USB_MAX_NUMBER_OF_UI_MSG                (2)

#define CSL_USB_IOFLAG_NONE                         (0x0000)

#define CSL_USB_IOFLAG_NOSHORT                      (0x0001)

#define CSL_USB_IOFLAG_SWAP                         (0x0002)

#define CSL_USB_IOFLAG_LNK                          (0x0004)

#define CSL_USB_IOFLAG_CAT                          (0x0008)

#define CSL_USB_IOFLAG_EOLL                         (0x0010)

#define CSL_USB_IOFLAG_NOT                          (0x0020)

#define CSL_USB_EVENT_NONE                          (0x0000)

#define CSL_USB_EVENT_RESET                         (0x0001)

#define CSL_USB_EVENT_SOF                           (0x0002)

#define CSL_USB_EVENT_SUSPEND                       (0x0004)

#define CSL_USB_EVENT_RESUME                        (0x0008)

#define CSL_USB_EVENT_SETUP                         (0x0010)

#define CSL_USB_EVENT_EOT                           (0x0020)

#define CSL_USB_EVENT_STPOW                         (0x0040)

#define CSL_USB_EVENT_PSOF                          (0x0080)

#define CSL_USB_EVENT_HINT                          (0x0100)

#define CSL_USB_EVENT_HERR                          (0x0200)

#define CSL_USB_EVENT_ISO_TX                        (0x0400)

#define CSL_USB_EVENT_ISO_RX                        (0x0800)

#define CSL_USB_EVENT_READ_MEDIA                    (0x1000)

#define CSL_USB_EVENT_WRITE_MEDIA                   (0x2000)

#define CSL_USB_EVENT_HID_REPORT_TX                 (0x4000)

#define CSL_USB_GET_STATUS                          (0x00)

#define CSL_USB_CLEAR_FEATURE                       (0x01)

#define CSL_USB_SET_FEATURE                         (0x03)

#define CSL_USB_SET_ADDRESS                         (0x05)

#define CSL_USB_GET_DESCRIPTOR                      (0x06)

#define CSL_USB_SET_DESCRIPTOR                      (0x07)

#define CSL_USB_GET_CONFIGURATION                   (0x08)

#define CSL_USB_SET_CONFIGURATION                   (0x09)

#define CSL_USB_GET_INTERFACE                       (0x0A)

#define CSL_USB_SET_INTERFACE                       (0x0B)

#define CSL_USB_SYNCH_FRAME                         (0x0C)

#define CSL_USB_GET_MAX_LUN                         (0xFE)

#define CSL_USB_BOT_MSC_RESET                       (0xFF)

#define CSL_USB_REQUEST_TYPE_DEVICE_STATUS          (0x80)
#define CSL_USB_REQUEST_TYPE_INTERFACE_STATUS       (0x81)
#define CSL_USB_REQUEST_TYPE_ENDPOINT_STATUS        (0x82)

#define CSL_USB_SET_CUR                             (0x01)

#define CSL_USB_GET_CUR                             (0x81)

#define CSL_USB_SET_MIN                             (0x02)

#define CSL_USB_GET_MIN                             (0x82)

#define CSL_USB_SET_MAX                             (0x03)

#define CSL_USB_GET_MAX                             (0x83)

#define CSL_USB_SET_RES                             (0x04)

#define CSL_USB_GET_RES                             (0x84)

#define CSL_USB_SET_MEM                             (0x05)

#define CSL_USB_GET_MEM                             (0x85)

#define CSL_USB_GET_STAT                            (0xFF)

#define CSL_USB_GET_REPORT                          (0x01)

#define CSL_USB_GET_IDLE                            (0x02)

#define CSL_USB_GET_PROTOCOL                        (0x03)

#define CSL_USB_SET_REPORT                          (0x09)

#define CSL_USB_SET_IDLE                            (0x0A)

#define CSL_USB_SET_PROTOCOL                        (0x0B)

#define CSL_USB_DEVICE_DESCRIPTOR_TYPE               (0x01)

#define CSL_USB_CONFIGURATION_DESCRIPTOR_TYPE        (0x02)

#define CSL_USB_STRING_DESCRIPTOR_TYPE               (0x03)

#define CSL_USB_INTERFACE_DESCRIPTOR_TYPE            (0x04)

#define CSL_USB_ENDPOINT_DESCRIPTOR_TYPE             (0x05)

#define CSL_USB_DEVICE_QUAL_DESCRIPTOR_TYPE          (0x06)

#define CSL_USB_OTHERSPEED_CFG_DESCRIPTOR_TYPE       (0x07)

#define CSL_USB_HID_DESCRIPTOR_TYPE                  (0x21)

#define CSL_USB_HID_REPORT_DESCRIPTOR_TYPE           (0x22)

#define CSL_USB_FEATURE_ENDPOINT_STALL               (0x0000)

#define CSL_USB_FEATURE_REMOTE_WAKEUP                (0x0001)

#define CSL_USB_GBL_INT_SUSPEND                     (1<<0)

#define CSL_USB_GBL_INT_RESUME                      (1<<1)

#define CSL_USB_GBL_INT_RESET                       (1<<2)

#define CSL_USB_GBL_INT_SOF                         (1<<3)

#define CSL_USB_GBL_INT_DEVCONN                     (1<<4)

#define CSL_USB_GBL_INT_DEVDISCONN                  (1<<5)

#define CSL_USB_GBL_INT_SRP                         (1<<6)

#define CSL_USB_GBL_INT_VBUSERR                     (1<<7)

#define CSL_USB_GBL_INT_DRVVBUS                     (1<<8)


#define CSL_USB_RX_INT_EP4                          (1<<12)

#define CSL_USB_RX_INT_EP3                          (1<<11)

#define CSL_USB_RX_INT_EP2                          (1<<10)

#define CSL_USB_RX_INT_EP1                          (1<<9)

#define CSL_USB_TX_INT_EP4                          (1<<4)

#define CSL_USB_TX_INT_EP3                          (1<<3)

#define CSL_USB_TX_INT_EP2                          (1<<2)

#define CSL_USB_TX_INT_EP1                          (1<<1)

#define CSL_USB_TX_RX_INT_EP0                       (1<<0)

#define CSL_USB_DELAY                               (0xFF)

#define CSL_USB_DATA_DELAY                          (0xFFF)

#define CSL_USB_RESUME_DELAY                        (10)

#define CSL_USB_PER_RESTCOUNT                       (0x20)

#define CSL_USB_INTRUSB_INTRUSBE_DEFVAL             (0x7fff)

#define CSL_USB_INTMSKSETR1_DEFVAL                  (0xFFFF)

#define CSL_USB_INTMSKSETR2_DEFVAL                  (0xFFF7)

#define CSL_USB_SYS_CTRL_REG_DEF_VAL                (0x6040)

#define CSL_USB_CLOCKSTOP_REG_DEF_VAL               (0x0)

#define CSL_USB_DMA_SCHED_CTRL1_DEFVAL              (0x0001)

#define CSL_USB_ENTRYLSW_DEFVAL                     (0x0081)

#define CSL_USB_RXGCR1_DEFVAL                       (0x401A)

#define CSL_USB_RXGCR2_DEFVAL                       (0x8100)

#define CSL_USB_LRAM0SIZE_DEFVAL                    (0x200)

#define CSL_USB_QMEMRCTRL1_DEFVAL                   (0x200)

#define CSL_USB_QMEMRCTRL2_DEFVAL                   (0x0000)

#define CSL_USB_16BIT_REG_MASK                      (0xFFFF)

#define CSL_USB_16BIT_REG_SHIFT                     (16)

#if (defined(CHIP_C5505_C5515) || defined(CHIP_C5504_C5514))

#define CSL_USB_PLL_PLLCNTL1_DEFVAL                 (0x8BE8)

#else
#define CSL_USB_PLL_PLLCNTL1_DEFVAL                 (0x82FA)
#endif

#define CSL_USB_PLL_PLLINCNTL_DEFVAL                (0x8000)

#define CSL_USB_PLL_PLLCNTL2_DEFVAL                 (0x0806)

#define CSL_USB_PLL_PLLOUTCNTL_DEFVAL               (0x0000)

#define CSL_USB_PLL_TIMEOUT                         (0xFFFF)

#define CSL_USB_INTMASKEDRL_LSB                     (0)

#define CSL_USB_INTMASKEDRL_MSB                     (12)

#define CSL_USB_INTMASKEDRH_LSB                     (0)

#define CSL_USB_INTMASKEDRH_MSB                     (8)

#define CSL_USB_INTCLRRL_LSB                        (0)

#define CSL_USB_INTCLRRL_MSB                        (12)

#define CSL_USB_INTCLRRH_LSB                        (0)

#define CSL_USB_INTCLRRH_MSB                        (8)

#define CSL_USB_INVALID_MAXPOWER                    (0xFFFF)

#define CSL_USB_WORD_ACCESS                         (0)

#define CSL_USB_HIGHBYTE_ACCESS                     (1)

#define CSL_USB_LOWBYTE_ACCESS                      (2)

#define CSL_USB_MIN(a,b)                            (((a)<(b))?(a):(b))

#define CSL_USB_CHANGE_ACCESSTYPE(byte)                                       \
               CSL_FINS(CSL_SYSCTRL_REGS->USBSCR, SYS_USBSCR_USBBYTEMODE, byte)

#define CSL_USB_BYTESWAP(word)                                                \
                          ((((word) >> 8u) & 0xFFu) | (((word) & 0xFFu) << 8u))

typedef Uint16    CSL_UsbIoFlags;
typedef Uint16    CSL_UsbEventMask;
typedef Uint16    CSL_UsbByteCount;
typedef Uint16    CSL_UsbFrameNum;

typedef void      (*CSL_USB_EVENT_ISR)();
typedef void      (*CSL_USB_APP_CALLBACK)(Uint16 flag);
typedef CSL_Status (*CSL_USB_APP_TRANSFER_CALLBACK)(void *, void *);

/**************************************************************************\
* USB MUSB global typedef declarations                                     *
\**************************************************************************/

typedef enum {
  CSL_USB_OUT_EP0  = 0x00,
  CSL_USB_OUT_EP1  = 0x01,
  CSL_USB_OUT_EP2  = 0x02,
  CSL_USB_OUT_EP3  = 0x03,
  CSL_USB_OUT_EP4  = 0x04,
  CSL_USB_OUT_EP5  = 0x05,
  CSL_USB_OUT_EP6  = 0x06,
  CSL_USB_OUT_EP7  = 0x07,
  CSL_USB_IN_EP0   = 0x08,
  CSL_USB_IN_EP1   = 0x09,
  CSL_USB_IN_EP2   = 0x0A,
  CSL_USB_IN_EP3   = 0x0B,
  CSL_USB_IN_EP4   = 0x0C,
  CSL_USB_IN_EP5   = 0x0D,
  CSL_USB_IN_EP6   = 0x0E,
  CSL_USB_IN_EP7   = 0x0F
} CSL_UsbEpNum;

typedef enum {
    CSL_USB_EP0_IDLE = 0,
    CSL_USB_EP0_STATUS_IN,
    CSL_USB_EP0_TX,
    CSL_USB_EP0_RX
} CSL_UsbEp0State;

typedef enum {
    CSL_USB_DEVICE_DETACH = 0,
    CSL_USB_DEVICE_ATTACH
} CSL_UsbDeviceEvent;

typedef enum {
    CSL_USB_BS_UNKNOWN_SPEED = 0,
    CSL_USB_BS_FULL_SPEED    = (1 << 1),
    CSL_USB_BS_HIGH_SPEED    = (1 << 2)
} CSL_UsbBusSpeed;

typedef enum {
    CSL_USB_MSG_MSC_CTL      = 0,
    CSL_USB_MSG_MSC_BULK_IN,
    CSL_USB_MSG_MSC_BULK_OUT,
    CSL_USB_MSG_ISO_OUT,
    CSL_USB_MSG_ISO_IN,
    CSL_USB_MSG_HID_INT_IN,
    CSL_USB_MSG_MSC_TASK_EXIT
} CSL_UsbMscMsg;

typedef enum {
    CSL_USB_MSG_USBUI_HOSTFEATURE = 0,
    CSL_USB_MSG_USBUI_USBERROR,
    CSL_USB_MSG_USBUI_TASK_EXIT
} CSL_UsbUiMsg;

typedef enum {
    CSL_USB_MSG_DATA = 0,
    CSL_USB_MSG_USB_INT,
    CSL_USB_MSG_RESET_DEVICE,
    CSL_USB_MSG_CONNECT_DEVICE,
    CSL_USB_MSG_DISCONNECT_DEVICE,
    CSL_USB_MSG_STALL_ENDPOINT,
    CSL_USB_MSG_CLEAR_ENDPOINT_STALL,
    CSL_USB_MSG_ABORT_TRANSFER,
    CSL_USB_MSG_SEND_HAND_SHAKE,
    CSL_USB_MSG_MAIN_TASK_EXIT
} CSL_UsbMainMsg;

typedef enum {
    CSL_USB_CTRL  = 0x00,
    CSL_USB_BULK  = 0x01,
    CSL_USB_INTR  = 0x02,
    CSL_USB_ISO   = 0x03,
    CSL_USB_HPORT = 0x04
} CSL_UsbXferType;

typedef enum {
    /* 1st USB module  - Currently supported mode                            */
    CSL_USB0 = 0x00,
    /* 2nd USB module  - if the DSP support 2 USB module                     */
    CSL_USB1 = 0x01,
    /* 3rd USB module  - if the DSP support 3 USB module                     */
    CSL_USB2 = 0x02
} CSL_UsbDevNum;

typedef enum {
    /* Endpoint0 data dir: Host -> Target                                    */
    CSL_USB_EP0_DATA_OUT = 0x00,
    /* Endpoint0 data dir: Target -> host                                    */
    CSL_USB_EP0_DATA_IN  = 0x01
} CSL_UsbEp0DataDir;

typedef enum {
    /* Status of the operation is FALSE                                      */
    CSL_USB_FALSE = 0,
    /* Status of the operation is TRUE                                       */
    CSL_USB_TRUE
} CSL_UsbBoolean;

typedef enum {
    /* FIFO data is directly accessed by the CPU                             */
    CSL_USB_OPMODE_POLLED = 0,
    /* RX and TX FIFO data is accessed by the CPPI DMA Engine                          */
    CSL_USB_OPMODE_DMA,
    /* TX FIFO data is accessed by the CPPI DMA Engine                          */
    CSL_USB_OPMODE_DMA_TXONLY
} CSL_UsbOpMode;


/**************************************************************************\
* USB MUSB global data structure declarations                              *
\**************************************************************************/

typedef struct CSL_UsbTransfer {
    DWORD             dwFlags;
    DWORD             dwEndpoint;
    PVOID             pvBuffer;
    DWORD             cbBuffer;
    DWORD             cbTransferred;
    DWORD             prevTxferLen;
    Bool              fComplete;
    CSL_UsbIoFlags    ioFlags;
} CSL_UsbTransfer;

typedef CSL_UsbTransfer    *pUsbTransfer;

typedef struct CSL_UsbEpStatus {
    DWORD                dwEndpoint;
    CSL_UsbXferType      xferType;
    DWORD                dwPacketSizeAssigned;
    Bool                 fInitialized;
    DWORD*               pFifoAddr;
    CSL_UsbTransfer      *pTransfer;
    WORD                 wUSBEvents;
    WORD                 dataReadFromFifo;
    CSL_USB_EVENT_ISR    hEventHandler;
    Bool                 fStalled;
    Bool                 fSelected;
} CSL_UsbEpStatus;

typedef CSL_UsbEpStatus  *pUsbEpStatus;

typedef struct CSL_UsbSetupStruct {
    int       newPacket;
    Uint16    bmRequestType;
    Uint16    bRequest;
    Uint16    wValue;
    Uint16    wIndex;
    Uint16    wLength;
} CSL_UsbSetupStruct;

typedef struct CSL_UsbDataStruct {
    Uint16                      bytes;
    Uint16                      *pBuffer;
    struct CSL_UsbDataStruct    *pNextBuffer;
} CSL_UsbDataStruct;

typedef struct CSL_UsbEpObj {
    CSL_UsbEpNum         epNum;
    CSL_UsbXferType      xferType;
    Uint16               maxPktSiz;
    Uint16               eventMask;
    CSL_USB_EVENT_ISR    fxn;
    Uint16               dataFlags;
    Uint16               status;
    Uint16               epDescRegSAddr;
    Uint16               dmaRegSAddr;
    Uint16               totByteCnt;
    Uint16               byteInThisSeg;
    Uint16               *xferBytCnt;
    Uint16               *pBuffer;
    CSL_UsbDataStruct    *pNextBuffer;
    Uint16               eventFlag;
} CSL_UsbEpObj;

typedef CSL_UsbEpObj    *pUsbEpHandle;

typedef struct CSL_UsbContext {
    CSL_UsbOpMode           opMode;
    WORD                    maxCurrent;
    Bool                    fInitialized;
    Bool                    fSetupPktCmd;
    Bool                    fOutPhaseCmd;
    Bool                    fWaitingOnFlagA;
    Bool                    fWaitingOnFlagB;
    Bool                    fWaitingOnEP0BUFAvail;
    Bool                    fWaitingOnEP1InBUFAvail;
    WORD                    *rgbDescriptors;
    WORD                    cbDescriptors;
    DWORD                   dwFlagAEndpointAssigned;
    DWORD                   dwFlagBEndpointAssigned;
    DWORD                   *pFIFOBaseAddress;
    DWORD                   *pInterruptAddr;
    Bool                    fSendHandshake;
    Bool                    fMUSBIsReady;
    WORD                    cbOutEP0Buf;
    WORD                    cbOutEP0DataReceived;
    DWORD                   dwOutEP0Buf[CSL_USB_MAX_OUTEP0BUF_LEN / 4];
    //WORD                    dwOutEP0Buf[CSL_USB_MAX_OUTEP0BUF_LEN / 2];
    Bool                    fEP0BUFAvailable;
    Bool                    fEP1InBUFAvailable;
    WORD                    dwQueuePend1;
    Bool                    fEP3InBUFAvailable;
    WORD                    dwIntSourceL;
    WORD                    dwIntSourceH;
    CSL_UsbBoolean          remoteWkpStat;
    CSL_UsbEpStatus         *pEpStatus;
    CSL_UsbBusSpeed         busSpeed;
    CSL_UsbEp0State         ep0State;
    CSL_UsbDeviceEvent      cableState;
    CSL_UsbSetupStruct      usbSetup;
    CSL_USB_APP_CALLBACK    suspendCallBackFxn;
    CSL_USB_APP_CALLBACK    wakeupCallBackFxn;
    CSL_USB_APP_TRANSFER_CALLBACK    startTransferCallback;
    CSL_USB_APP_TRANSFER_CALLBACK    completeTransferCallback;
    WORD                    dwFIFOStartAddr;
    Uint16                  *deviceDescPtr;
    Uint16                  *deviceQualDescPtr;
    Uint16                  *cfgDescPtr;
    Uint16                  *cfgDescFSPtr;
    Uint16                  *strDescPtr[4];
    Uint16                  devAddr;
    CSL_UsbEpObj             ctrlInEpObj;
    CSL_UsbDevNum            devNum;
    CSL_UsbEpObj             ctrlOutEpObj;
    Uint16                   suspendFlag;
    pUsbEpHandle             hEpObjArray[CSL_USB_ENDPOINT_COUNT];
    Uint16                   curConfigStat;
    Bool                     usbSpeedCfg;
} CSL_UsbContext;

typedef CSL_UsbContext  *pUsbContext;

typedef struct CSL_UsbMsgObj {
    WORD    wMsg;
    WORD    wEndpoint;
} CSL_UsbMsgObj;

typedef struct CSL_UsbConfig {
    CSL_UsbDevNum           devNum;
    CSL_UsbOpMode           opMode;
    Uint16                  maxCurrent;
    CSL_USB_APP_CALLBACK    appSuspendCallBack;
    CSL_USB_APP_CALLBACK    appWakeupCallBack;
    CSL_USB_APP_TRANSFER_CALLBACK    startTransferCallback;
    CSL_USB_APP_TRANSFER_CALLBACK    completeTransferCallback;
} CSL_UsbConfig;


typedef struct CSL_UsbHostPktDescr {
    volatile Uint32    PacketInfoWord0;
    volatile Uint32    PacketInfoWord1;
    volatile Uint32    PacketInfoWord2;
    volatile Uint32    Buffer0InfoWord0;
    volatile Uint32    Buffer0InfoWord1;
    volatile Uint32    LinkingWord;
    volatile Uint32    OriginalBuffer0InfoWord0;
    volatile Uint32    OriginalBuffer0InfoWord1;
} CSL_UsbHostPktDescr;

typedef struct CSL_UsbHostBufDescr {
    volatile Uint32    Reserved0;
    volatile Uint32    Reserved1;
    volatile Uint32    PacketInfoWord2;
    volatile Uint32    Buffer0InfoWord0;
    volatile Uint32    Buffer0InfoWord1;
    volatile Uint32    LinkingWord;
    volatile Uint32    OriginalBuffer0InfoWord0;
    volatile Uint32    OriginalBuffer0InfoWord1;
} CSL_UsbHostBufDescr;

/**************************************************************************\
* USB MUSB function declarations                                            *
\**************************************************************************/

CSL_Status USB_init(CSL_UsbConfig    *usbConfig);

CSL_Status USB_resetDev(CSL_UsbDevNum    devNum);

CSL_Status USB_initEndptObj(CSL_UsbDevNum        devNum,
                            pUsbEpHandle         hEp,
                            CSL_UsbEpNum         epNum,
                            CSL_UsbXferType      xferType,
                            Uint16               maxPktSize,
                            Uint16               evMask,
                            CSL_USB_EVENT_ISR    fxn);

CSL_UsbEventMask USB_getEvents(pUsbEpHandle    hEp,
                               CSL_Status      *status);

CSL_UsbEventMask USB_peekEvents(pUsbEpHandle    hEp,
                                CSL_Status      *status);

CSL_Status USB_getSetupPacket(CSL_UsbDevNum         devNum,
                              CSL_UsbSetupStruct    *usbSetup,
                              Bool                  readFromFifo);

CSL_Status USB_postTransaction(pUsbEpHandle      hEp,
                               Uint16            byteCnt,
                               void              *data,
                               CSL_UsbIoFlags    flags);

CSL_UsbBoolean USB_isTransactionDone(pUsbEpHandle    hEp,
                                     CSL_Status      *status);

CSL_UsbByteCount USB_bytesRemaining(pUsbEpHandle    hEp,
                                    CSL_Status      *status);

CSL_Status USB_stallEndpt(pUsbEpHandle  hEp);

CSL_Status USB_clearEndptStall(pUsbEpHandle  hEp);

CSL_UsbBoolean USB_getEndptStall(pUsbEpHandle    hEp,
                                 CSL_Status      *status);

pUsbEpHandle USB_epNumToHandle(CSL_UsbDevNum    devNum,
                               Uint16           endpt);

CSL_Status USB_abortTransaction(pUsbEpHandle    hEp);

CSL_Status USB_abortAllTransaction(CSL_UsbDevNum    devNum);

CSL_Status USB_connectDev(CSL_UsbDevNum    devNum);

CSL_Status USB_disconnectDev(CSL_UsbDevNum    devNum);

CSL_Status USB_setRemoteWakeup(CSL_UsbDevNum     devNum,
                               CSL_UsbBoolean    rmtWkpStat);

CSL_UsbBoolean USB_getRemoteWakeupStat(CSL_UsbDevNum    devNum);

CSL_Status USB_issueRemoteWakeup(CSL_UsbDevNum    devNum,
                                 Bool             resumeBitVal);

CSL_Status USB_setDevAddr(CSL_UsbDevNum    devNum,
                          Uint16            addr);

CSL_UsbFrameNum USB_getFrameNo(CSL_UsbDevNum    devNum);

CSL_Status USB_suspendDevice(CSL_UsbDevNum    devNum);

CSL_Status USB_selfwakeup(CSL_UsbDevNum    devNum,
                          Uint32           wakeupDelay);

void USB_initPLL(void);

CSL_Status USB_setParams(CSL_UsbDevNum    devNum,
                         pUsbEpHandle     hEpObj[],
                         Uint16           pSofTmrCnt);

WORD USB_getMaxPower(CSL_UsbDevNum    devNum);

void USB_setFullSpeedMode(Uint16    ep0DataSize);

Uint16 USB_getDataCountReadFromFifo (pUsbEpHandle    hEp);

// determine the fifo size according to the transfer type and the maximum packet size
Uint16 USB_findFifoSize(Uint16 maxPktSize, CSL_UsbXferType xferType);

// processing all the EP0 events for enumeration
// call the CDC event handler for further processing
CSL_Status USB_coreEventProcessEp0(pUsbContext pContext);

#ifdef __cplusplus
}
#endif

#endif    //_CSL_USB_H_