/* 
* Copyright (C) 2009-2014 Texas Instruments Incorporated - http://www.ti.com/ 
* 
* 
*  Redistribution and use in source and binary forms, with or without 
*  modification, are permitted provided that the following conditions 
*  are met:
*
*    Redistributions of source code must retain the above copyright 
*    notice, this list of conditions and the following disclaimer.
*
*    Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the 
*    documentation and/or other materials provided with the   
*    distribution.
*
*    Neither the name of Texas Instruments Incorporated nor the names of
*    its contributors may be used to endorse or promote products derived
*    from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#ifndef USB_H_
#define USB_H_

/******************************************************************************
 *
 * These macros allow conversion between 0-based endpoint indices and the
 * USB_EP_x values required when calling various USB APIs.
 *
 *****************************************************************************/
#define INDEX_TO_USB_EP(x)      ((x) << 4u)
#define USB_EP_TO_INDEX(x)      ((x) >> 4u)

/******************************************************************************
 *
 * The following are values that can be passed to USBFIFOConfigSet() as the
 * uFIFOSize parameter.
 *
 *****************************************************************************/
#define USB_FIFO_SZ_8           0x00U  /* 8 byte FIFO */
#define USB_FIFO_SZ_16          0x01U  /* 16 byte FIFO */
#define USB_FIFO_SZ_32          0x02U  /* 32 byte FIFO */
#define USB_FIFO_SZ_64          0x03U  /* 64 byte FIFO */
#define USB_FIFO_SZ_128         0x04U  /* 128 byte FIFO */
#define USB_FIFO_SZ_256         0x05U  /* 256 byte FIFO */
#define USB_FIFO_SZ_512         0x06U  /* 512 byte FIFO */
#define USB_FIFO_SZ_1024        0x07U  /* 1024 byte FIFO */


/******************************************************************************
 *
 * This macro allow conversion from a FIFO size label as defined above to
 * a number of bytes
 *
 *****************************************************************************/
#define USB_FIFO_SIZE_DB_FLAG  0x10U
#define USB_FIFO_SZ_TO_BYTES(x) (uint16_t)((uint8_t)8U << (((uint8_t)(x) & (uint8_t)(~(uint8_t)USB_FIFO_SIZE_DB_FLAG)) + \
                                           (uint8_t)(((uint8_t)(x) & (uint8_t)USB_FIFO_SIZE_DB_FLAG) >> 4U)))

                                 
/******************************************************************************
 *
 * The maximum number of independent interfaces that any single device
 * implementation can support.  Independent interfaces means interface
 * descriptors with different bInterfaceNumber values - several interface
 * descriptors offering different alternative settings but the same interface
 * number count as a single interface.
 *
 *****************************************************************************/
#define USB_MAX_INTERFACES_PER_DEVICE 8u


/******************************************************************************
 *
 * Following macro directives can be used for the configuring the USB device.
 * Note that these directives map directly to the hardware bit definitions and
 * cannot be modified to any other value.
 *
 *****************************************************************************/
#define USBD_PWR_BUS_PWR                (0x0000u)   /* Device is bus powered */
#define USBD_PWR_SELF_PWR               (0x0004u)   /* Device is self powered */
#define USBD_DATA_ENDIAN_LITTLE         (0x0000u)   /* Little Endian Data (RM48x) */
#define USBD_DATA_ENDIAN_BIG            (0x0080u)   /* Bit Endian Data */
#define USBD_DMA_ENDIAN_LITTLE          (0x0000u)   /* DMA is Little Endian */
#define USBD_DMA_ENDIAN_BIG             (0x0040u)   /* DMA is Big Endian */

/******************************************************************************
 *
 *  Following macro directives can be used for the configuring the Endpoints
 *  Note that these directives map directly to the hardware bit definitions and
 *  cannot be modified to any other value.
 *
 *****************************************************************************/

#define USBD_EP_DIR_IN                  (0x0010u)        /* IN Endpoint */
#define USBD_EP_DIR_OUT                 (0x0000u)        /* OUT Endpoint */  
#define USB_EP_DEV_IN                   (USBD_EP_DIR_IN) /* IN Endpoint */   
#define USB_EP_DEV_OUT                  (USBD_EP_DIR_OUT)/* OUT Endpoint */
#define USB_TRANS_IN                    (USBD_EP_DIR_IN) /* IN Endpoint */
#define USB_TRANS_OUT                   (USBD_EP_DIR_OUT)/* OUT Endpoint */
#define USB_EP_DIR_IN                   (USBD_EP_DIR_IN)
#define USB_EP_DIR_OUT                  (USBD_EP_DIR_OUT)
#define USB_TRANS_IN_LAST               0u               /* Used to indicate the last transaction
                                                           (NOT USED in this port of USB) */

#define USBD_TXRX_EP_VALID_VALID        (0x8000u)       /* EP is valid & configured */
#define USBD_TXRX_EP_VALID_NOTVALID     (0x0000u)       /* EP is not valid & not configured */
#define USBD_TXRX_EP_ISO_ISO            (0x0800u)       /* EP is of ISO type */
#define USBD_TXRX_EP_ISO_NONISO         (0x0000u)       /* EP is either Bulk/Interrup/Control */
#define USBD_TXRX_EP_DB_ENABLED         (0x4000u)       /* EP has double buffering enabled */
                                                        /* For IN EPs DB should be enabled only in DMA mode */
#define USBD_TXRX_EP_DB_DISABLED        (0x0000u)       /* EP has double buffering disabled */

/******************************************************************************
 *
 *  Following macro directives are to be used for enabling/disabling interrupts
 *  Note that these directives map directly to the hardware bit definitions and
 *  cannot be modified to any other value.
 *
 *****************************************************************************/
#define USBD_INT_EN_SOF_IE                      (0x0080u)   /* Start-of-Frame Interrupt */
#define USBD_INT_EN_EPN_RX_IE                   (0x0020u)   /* Non-EP0 RX Interrupt */
#define USBD_INT_EN_EPN_TX_IE                   (0x0010u)   /* Non-EP0 TX Interrupt */
#define USBD_INT_EN_DS_CHG_IE                   (0x0008u)   /* Device State change interrupt */
#define USBD_INT_EN_EP0_IE                      (0x0001u)   /* EP0 Interrupt */
#define USBD_INT_EN_ALL                         (USBD_IRQ_EN_SOF_IE | \
                                                 USBD_IRQ_EN_EPN_RX_IE | \
                                                 USBD_IRQ_EN_EPN_TX_IE | \
                                                 USBD_IRQ_EN_DS_CHG_IE | \
                                                 USBD_IRQ_EN_EP0_IE)


/******************************************************************************
 *
 *  Following macro directives are to be used for decoding the interrupt source
 *  Note that these directives map directly to the hardware bit definitions and
 *  cannot be modified to any other value.
 *
 *****************************************************************************/
#define USBD_INT_SRC_TXN_DONE                   (0x0400u)   /* non-EP0 TX done interrupt */
#define USBD_INT_SRC_RXN_CNT                    (0x0200u)   /* non-EP0 RX Count */
#define USBD_INT_SRC_RXN_EOT                    (0x0100u)   /* non-EP0 RX end of transfer */
#define USBD_INT_SRC_SOF                        (0x0080u)   /* Start-of-frame interrupt */
#define USBD_INT_SRC_EPN_RX                     (0x0020u)   /* non-EP0 RX interrupt */
#define USBD_INT_SRC_EPN_TX                     (0x0010u)   /* non-EP0 TX interrupt */
#define USBD_INT_SRC_DS_CHG                     (0x0008u)   /* Device State change interrupt */
#define USBD_INT_SRC_SETUP                      (0x0004u)   /* Setup interrupt */
#define USBD_INT_SRC_EP0_RX                     (0x0002u)   /* EP0 RX Interrupt */
#define USBD_INT_SRC_EP0_TX                     (0x0001u)   /* EP0 TX Interrupt */


/******************************************************************************
 *
 * These values are used to indicate which endpoint to access.
 *
 *****************************************************************************/
#define USB_EP_0                0x00000000u  /*  Endpoint 0 */
#define USB_EP_1                0x00000010u  /*  Endpoint 1 */
#define USB_EP_2                0x00000020u  /*  Endpoint 2 */
#define USB_EP_3                0x00000030u  /*  Endpoint 3 */
#define USB_EP_4                0x00000040u  /*  Endpoint 4 */
#define USB_EP_5                0x00000050u  /*  Endpoint 5 */
#define USB_EP_6                0x00000060u  /*  Endpoint 6 */
#define USB_EP_7                0x00000070u  /*  Endpoint 7 */
#define USB_EP_8                0x00000080u  /*  Endpoint 8 */
#define USB_EP_9                0x00000090u  /*  Endpoint 9 */
#define USB_EP_10               0x000000A0u  /*  Endpoint 10 */
#define USB_EP_11               0x000000B0u  /*  Endpoint 11 */
#define USB_EP_12               0x000000C0u  /*  Endpoint 12 */
#define USB_EP_13               0x000000D0u  /*  Endpoint 13 */
#define USB_EP_14               0x000000E0u  /*  Endpoint 14 */
#define USB_EP_15               0x000000F0u  /*  Endpoint 15 */
#define NUM_USB_EP              16u          /*  Number of supported endpoints */


/******************************************************************************
 *
 * The following are values that can be passed to USBHostEndpointConfig() and
 * USBDevEndpointConfigSet() as the ulFlags parameter.
 *
 *****************************************************************************/
#define USB_EP_AUTO_SET         0x00000001u  /* Auto set feature enabled */
#define USB_EP_AUTO_REQUEST     0x00000002u  /* Auto request feature enabled */
#define USB_EP_AUTO_CLEAR       0x00000004u  /* Auto clear feature enabled */
#define USB_EP_DMA_MODE_0       0x00000008u  /* Enable DMA access using mode 0 */
#define USB_EP_DMA_MODE_1       0x00000010u  /* Enable DMA access using mode 1 */
#define USB_EP_MODE_ISOC        0x00000000u  /* Isochronous endpoint */
#define USB_EP_MODE_BULK        0x00000100u  /* Bulk endpoint */
#define USB_EP_MODE_INT         0x00000200u  /* Interrupt endpoint */
#define USB_EP_MODE_CTRL        0x00000300u  /* Control endpoint */
#define USB_EP_MODE_MASK        0x00000300u  /* Mode Mask */
#define USB_EP_SPEED_LOW        0x00000000u  /* Low Speed */
#define USB_EP_SPEED_FULL       0x00001000u  /* Full Speed */


/******************************************************************************
 *
 * The following are values that are returned from USBEndpointStatus().  The
 * USB_HOST_* values are used when the USB controller is in host mode and the
 * USB_DEV_* values are used when the USB controller is in device mode.
 *
 *****************************************************************************/
#define USB_DEV_EP0_OUT_PKTRDY 0x00000001u  /* Receive data packet ready */
#define USB_DEV_RX_PKT_RDY      0x00010000u  /* Data packet ready */
#define USB_DEV_TX_TXPKTRDY     0x00000001u
#define USB_DEV_TX_FIFO_NE      0x00000002u


/******************************************************************************
 *
 * This value specifies the maximum size of transfers on endpoint 0 as 64
 * bytes.  This value is fixed in hardware as the FIFO size for endpoint 0.
 *
 *****************************************************************************/
#define MAX_PACKET_SIZE_EP0     64u


/******************************************************************************
 *
 * Macros for hardware access, both direct and via the bit-band region.
 *
 *****************************************************************************/
#define HWREG(x)                (*((volatile uint32_t *)(x)))




/******************************************************************************
 *
 *  Initialize the USB Device
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usFlags specifies the bus/self powered and endianness for data & dma.
 *          Should be a combination of the following flags
 *              USBD_PWR_BUS_PWR or USBD_PWR_SELF_PWR
 *              USBD_DATA_ENDIAN_LITTLE or USBD_DATA_ENDIAN_BIG
 *              USBD_DMA_ENDIAN_LITTLE or USBD_DMA_ENDIAN_BIG
 *  \param usFifoPtr specifies the start of the EP0 FIFO.
 * 
 *  This function will initialize the USB Device controller specified by the
 *  \e ulBase parameter.
 * 
 *  \return None
 * 
 *  Note This function does not intiate a device connect (pull ups are
 *  not enabled). Also the EP0 is intialized with FIFO size of 64Bytes.
 * 
 *
 *****************************************************************************/
void USBDevInit(uint32 ulBase, uint16 usFlags, uint16 usFifoPtr);


/******************************************************************************
 *
 *  Initialize the USB Device's EP0
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usSize FIFO size. Supported values are USB_FIFO_SZ_8/USB_FIFO_SZ_16/
 *          USB_FIFO_SZ_32/USB_FIFO_SZ_64.
 *  \param usFifoPtr specifies the start of the EP0 FIFO.
 * 
 *  This function will initialize the USB Device controller specified by the
 *  \e ulBase parameter.  The \e uFlags parameter is not used by this
 *  implementation.
 * 
 *  \return None
 * 
 *
 *****************************************************************************/
void USBDevEp0Config(uint32 ulBase, uint16 usSize, uint16 usFifoPtr);


/******************************************************************************
 *
 *  Disable control interrupts on a given USB device controller.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usFlags specifies which control interrupts to disable.
 * 
 *  This function will disable the interrupts for the USB device controller
 *  specified by the \e ulBase parameter.  The \e usFlags parameter specifies
 *  which control interrupts to disable.  The flags passed in the \e usFlags
 *  parameters should be the definitions that start with \b USBD_INT_EN_*
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBIntDisable(uint32 ulBase, uint16 usFlags);


/******************************************************************************
 *
 *  Enable control interrupts on a given USB device controller.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usFlags specifies which control interrupts to enable.
 * 
 *  This function will enable the control interrupts for the USB device controller
 *  specified by the \e ulBase parameter.  The \e usFlags parameter specifies
 *  which control interrupts to enable.  The flags passed in the \e usFlags
 *  parameters should be the definitions that start with \b USBD_INT_EN_* and
 *  not any other \b USB_INT flags.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBIntEnable(uint32 ulBase, uint16 usFlags);


/******************************************************************************
 *
 *  Returns the control interrupt status on a given USB device controller.
 * 
 *  \param ulBase specifies the USB module base address.
 * 
 *  This function will read interrupt status for a USB device controller.
 *  The bit values returned should be compared against the \b USBD_INT_SRC_*
 *  values.
 * 
 *  \return Returns the status of the control interrupts for a USB device controller.
 *
 *****************************************************************************/
uint16 USBIntStatus(uint32 ulBase);


/******************************************************************************
 *
 *  Stalls the specified endpoint in device mode.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint specifies the endpoint to stall.
 *  \param usFlags specifies whether to stall the IN or OUT endpoint.
 * 
 *  This function will cause to endpoint number passed in to go into a stall
 *  condition.  If the \e usFlags parameter is \b USB_EP_DEV_IN then the stall
 *  will be issued on the IN portion of this endpoint.  If the \e usFlags
 *  parameter is \b USB_EP_DEV_OUT then the stall will be issued on the OUT
 *  portion of this endpoint.
 * 
 *  \note This function should only be called in device mode.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevEndpointStall(uint32 ulBase, uint16 usEndpoint, uint16 usFlags);


/******************************************************************************
 *
 *  Clears the stall condition on the specified endpoint in device mode.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint specifies which endpoint to remove the stall condition.
 *  \param usFlags specifies whether to remove the stall condition from the IN
 *  or the OUT portion of this endpoint.
 * 
 *  This function will cause the endpoint number passed in to exit the stall
 *  condition.  If the \e usFlags parameter is \b USB_EP_DEV_IN then the stall
 *  will be cleared on the IN portion of this endpoint.  If the \e usFlags
 *  parameter is \b USB_EP_DEV_OUT then the stall will be cleared on the OUT
 *  portion of this endpoint.
 * 
 *  \note This function should only be called in device mode.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevEndpointStallClear(uint32 ulBase, uint16 usEndpoint, uint16 usFlags);


/******************************************************************************
 *
 *  Connects the USB device controller to the bus in device mode.
 * 
 *  \param ulBase specifies the USB module base address.
 * 
 *  This function will cause the soft connect feature of the USB device controller to
 *  be enabled.  Call USBDisconnect() to remove the USB device from the bus.
 * 
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevConnect(uint32 ulBase);


/******************************************************************************
 *
 *  Removes the USB device controller from the bus in device mode.
 * 
 *  \param ulBase specifies the USB module base address.
 * 
 *  This function will cause the soft disconnect feature of the USB device controller to
 *  remove the device from the USB bus.  A call to USBDevConnect() is needed to
 *  reconnect to the bus.
 * 
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevDisconnect(uint32 ulBase);


/******************************************************************************
 *
 *  Sets the address in device mode.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param ulAddress is the address to use for a device.
 * 
 *  This function will set the device address on the USB bus.  This address was
 *  likely received via a SET ADDRESS command from the host controller.
 * 
 *  \note This function is not available on this controller. This is maintained
 *          for compatibility.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevAddrSet(uint32 ulBase, uint32 ulAddress);


/******************************************************************************
 *
 *  Determine the number of bytes of data available in a given endpoint's FIFO.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 * 
 *  This function will return the number of bytes of data currently available
 *  in the FIFO for the given receive (OUT) endpoint.  It may be used prior to
 *  calling USBEndpointDataGet() to determine the size of buffer required to
 *  hold the newly-received packet.
 * 
 *  \return This call will return the number of bytes available in a given
 *  endpoint FIFO.
 *
 *****************************************************************************/
uint16 USBEndpointDataAvail(uint32 ulBase, uint16 usEndpoint);


/******************************************************************************
 *
 *  Retrieves data from the given endpoint's FIFO.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param pucData is a pointer to the data area used to return the data from
 *  the FIFO.
 *  \param pulSize is initially the size of the buffer passed into this call
 *  via the \e pucData parameter.  It will be set to the amount of data
 *  returned in the buffer.
 * 
 *  This function will return the data from the FIFO for the given endpoint.
 *  The \e pulSize parameter should indicate the size of the buffer passed in
 *  the \e pulData parameter.  The data in the \e pulSize parameter will be
 *  changed to match the amount of data returned in the \e pucData parameter.
 *  If a zero byte packet was received this call will not return a error but
 *  will instead just return a zero in the \e pulSize parameter.  The only
 *  error case occurs when there is no data packet available.
 * 
 *  \return This call will return 0, or -1 if no packet was received.
 *
 *****************************************************************************/
sint32 USBEndpointDataGet(
    uint32                     ulBase, 
    uint16                     usEndpoint, 
    uint8 *                    pucData, 
    uint32 *                   pulSize);


/******************************************************************************
 *
 *  Retrieves the setup packet from EP0 Setup FIFO
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param sPkt Pointer to the data area for storing the setup packet.
 *          Atleast 8 bytes should be available.
 *  \param pusPktSize On return this contains the size of the setup packet (8Bytes)
 * 
 *  This function will retrieves the 8Byte long setup packet from the EP0 setup
 *  FIFO.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevGetSetupPacket (uint32 ulBase, uint8 * sPkt, uint16 * pusPktSize);


/******************************************************************************
 *
 *  Acknowledge that data was read from the given endpoint's FIFO in device
 *  mode.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param bIsLastPacket This parameter is not used.
 * 
 *  This function acknowledges that the data was read from the endpoint's FIFO.
 *  The \e bIsLastPacket parameter is set to a \b true value if this is the
 *  last in a series of data packets on endpoint zero.  The \e bIsLastPacket
 *  parameter is not used for endpoints other than endpoint zero.  This call
 *  can be used if processing is required between reading the data and
 *  acknowledging that the data has been read.
 * 
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevEndpointDataAck(uint32 ulBase, uint16 usEndpoint, tBoolean bIsLastPacket);


/******************************************************************************
 *
 *  Puts data into the given endpoint's FIFO.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param pucData is a pointer to the data area used as the source for the
 *  data to put into the FIFO.
 *  \param ulSize is the amount of data to put into the FIFO.
 * 
 *  This function will put the data from the \e pucData parameter into the FIFO
 *  for this endpoint.  If a packet is already pending for transmission then
 *  this call will not put any of the data into the FIFO and will return -1.
 *  Care should be taken to not write more data than can fit into the FIFO
 *  allocated by the call to USBFIFOConfig().
 * 
 *  \return This call will return 0 on success, or -1 to indicate that the FIFO
 *  is in use and cannot be written.
 *
 *****************************************************************************/
uint32 USBEndpointDataPut(
    uint32                     ulBase, 
    uint16                     usEndpoint,
    uint8 *                    pucData, 
    uint32                     ulSize);

/******************************************************************************
 *
 *  Starts the transfer of data from an endpoint's FIFO.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param ulTransType Not used.
 * 
 *  This function will start the transfer of data from the FIFO for a given
 *  endpoint.
 * 
 *  \return This call will return 0 on success, or -1 if a transmission is
 *  already in progress.
 *
 *****************************************************************************/
uint32 USBEndpointDataSend(uint32 ulBase, uint16 usEndpoint, uint32 ulTransType);


/******************************************************************************
 *
 *  Resets the USB Device Controller
 * 
 *  \param void
 * 
 *  \return None.
 *
 *  \note Since the USB Device reset is handled by the host, this is a dummy
 *  function & maintained for compatibility purpose.
 *
 *****************************************************************************/
void USBReset(void);


/******************************************************************************
 *
 *  Sets the FIFO configuration for an endpoint.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param uFIFOAddress is the starting address for the FIFO.
 *  \param uFIFOSize is the size of the FIFO in bytes.
 *  \param uFlags specifies what information to set in the FIFO configuration.
 * 
 *  This function will set the starting FIFO RAM address and size of the FIFO
 *  for a given endpoint.  Endpoint zero does not have a dynamically
 *  configurable FIFO so this function should not be called for endpoint zero.
 *  The \e uFIFOSize parameter should be one of the values in the
 *  \b USB_FIFO_SZ_ values.  If the endpoint is going to use double buffering
 *  it should use the values with the \b _DB at the end of the value.  For
 *  example, use \b USB_FIFO_SZ_16_DB to configure an endpoint to have a 16
 *  byte double buffered FIFO.  If a double buffered FIFO is used, then the
 *  actual size of the FIFO will be twice the size indicated by the
 *  \e uFIFOSize parameter.  This means that the \b USB_FIFO_SZ_16_DB value
 *  will use 32 bytes of the USB controller's FIFO memory.
 * 
 *  The \e uFIFOAddress value should be a multiple of 8 bytes and directly
 *  indicates the starting address in the USB controller's FIFO RAM.  For
 *  example, a value of 64 indicates that the FIFO should start 64 bytes into
 *  the USB controller's FIFO memory.  The \e uFlags value specifies whether
 *  the endpoint's OUT or IN FIFO should be configured.  If in host mode, use
 *  \b USB_EP_HOST_OUT or \b USB_EP_HOST_IN, and if in device mode use
 *  \b USB_EP_DEV_OUT or \b USB_EP_DEV_IN.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBFIFOConfigSet(uint32 ulBase, uint32 usEndpoint, uint32 uFIFOAddress, uint32 uFIFOSize, uint16 uFlags);


/******************************************************************************
 *
 *  Gets the current configuration for an endpoint.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param pulMaxPacketSize is a pointer which will be written with the
 *  maximum packet size for this endpoint.
 *  \param puFlags is a pointer which will be written with the current
 *  endpoint settings. On entry to the function, this pointer must contain
 *  either \b USB_EP_DEV_IN or \b USB_EP_DEV_OUT to indicate whether the IN or
 *  OUT endpoint is to be queried.
 * 
 *  This function will return the basic configuration for an endpoint in device
 *  mode. The values returned in \e *pulMaxPacketSize and \e *puFlags are
 *  equivalent to the \e ulMaxPacketSize and \e uFlags previously passed to
 *  USBDevEndpointConfigSet() for this endpoint.
 * 
 *  \note This function should only be called in device mode.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevEndpointConfigGet(
    uint32                     ulBase, 
    uint16                     usEndpoint, 
    uint32 *                   pulMaxPacketSize, 
    uint32 *                   puFlags);


/******************************************************************************
 *
 *  Sets the configuration for an endpoint.
 * 
 *  \param ulBase specifies the USB module base address.
 *  \param usEndpoint is the endpoint to access.
 *  \param ulMaxPacketSize is the maximum packet size for this endpoint.
 *  \param uFlags are used to configure other endpoint settings.
 * 
 *  This function will set the basic configuration for an endpoint in device
 *  mode.  Endpoint zero does not have a dynamic configuration, so this
 *  function should not be called for endpoint zero.  The \e uFlags parameter
 *  determines some of the configuration while the other parameters provide the
 *  rest.
 * 
 *  The \b USB_EP_MODE_ flags define what the type is for the given endpoint.
 * 
 *  - \b USB_EP_MODE_CTRL is a control endpoint.
 *  - \b USB_EP_MODE_ISOC is an isochronous endpoint.
 *  - \b USB_EP_MODE_BULK is a bulk endpoint.
 *  - \b USB_EP_MODE_INT is an interrupt endpoint.
 * 
 * 
 *  \note This function should only be called in device mode.
 * 
 *  \return None.
 *
 *****************************************************************************/
void USBDevEndpointConfigSet(uint32 ulBase, uint16 usEndpoint, uint32 ulMaxPacketSize, uint32 uFlags);

void USBDevSetDevCfg(uint32 ulBase);
void USBDevClearDevCfg(uint32 ulBase);
uint16 USBDevGetEPnStat(uint32 ulBase);
void USBDevPullEnableDisable(uint32 ulBase, uint32 ulSet);
void USBIntStatusClear (uint16 uFlag);
uint16 USBDevGetDevStat(uint32 ulBase);
void USBDevCfgUnlock(uint32 ulBase);
void USBDevCfgLock(uint32 ulBase);

#endif /*USB_H_*/
 
 
 
 
