#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) << 4)
#define USB_EP_TO_INDEX(x)      ((x) >> 4)

//*****************************************************************************
//
// The following are values that can be passed to USBFIFOConfigSet() as the
// uFIFOSize parameter.
//
//*****************************************************************************
#define USB_FIFO_SZ_8           0x00000000  // 8 byte FIFO
#define USB_FIFO_SZ_16          0x00000001  // 16 byte FIFO
#define USB_FIFO_SZ_32          0x00000002  // 32 byte FIFO
#define USB_FIFO_SZ_64          0x00000003  // 64 byte FIFO
#define USB_FIFO_SZ_128         0x00000004  // 128 byte FIFO
#define USB_FIFO_SZ_256         0x00000005  // 256 byte FIFO
#define USB_FIFO_SZ_512         0x00000006  // 512 byte FIFO
#define USB_FIFO_SZ_1024        0x00000007  // 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  0x00000010
#define USB_FIFO_SZ_TO_BYTES(x) ((8 << ((x) & ~ USB_FIFO_SIZE_DB_FLAG)) * \
                                 (((x) & USB_FIFO_SIZE_DB_FLAG) ? 2 : 1))

								 
//*****************************************************************************
//
//! 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 8


//*****************************************************************************
//
//! 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				0				//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                0x00000000  // Endpoint 0
#define USB_EP_1                0x00000010  // Endpoint 1
#define USB_EP_2                0x00000020  // Endpoint 2
#define USB_EP_3                0x00000030  // Endpoint 3
#define USB_EP_4                0x00000040  // Endpoint 4
#define USB_EP_5                0x00000050  // Endpoint 5
#define USB_EP_6                0x00000060  // Endpoint 6
#define USB_EP_7                0x00000070  // Endpoint 7
#define USB_EP_8                0x00000080  // Endpoint 8
#define USB_EP_9                0x00000090  // Endpoint 9
#define USB_EP_10               0x000000A0  // Endpoint 10
#define USB_EP_11               0x000000B0  // Endpoint 11
#define USB_EP_12               0x000000C0  // Endpoint 12
#define USB_EP_13               0x000000D0  // Endpoint 13
#define USB_EP_14               0x000000E0  // Endpoint 14
#define USB_EP_15               0x000000F0  // Endpoint 15
#define NUM_USB_EP              16          // 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     64


//*****************************************************************************
//
// Macros for hardware access, both direct and via the bit-band region.
//
//*****************************************************************************
#define HWREG(x) 				(*((volatile unsigned int *)(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_t ulBase, uint16_t usFlags, uint16_t 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_t ulBase, uint16_t usSize, uint16_t 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_t ulBase, uint16_t 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_t ulBase, uint16_t 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_t USBIntStatus(uint32_t 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_t ulBase, uint16_t usEndpoint, uint16_t 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_t ulBase, uint16_t usEndpoint, uint16_t 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_t 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_t 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_t ulBase, uint32_t 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_t USBEndpointDataAvail(uint32_t ulBase, uint16_t 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.
//
//*****************************************************************************
uint32_t USBEndpointDataGet(uint32_t ulBase, uint16_t usEndpoint, uint8_t *pucData, uint32_t *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_t ulBase, uint8_t * sPkt, uint16_t * 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_t ulBase, uint16_t usEndpoint, uint8_t 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_t USBEndpointDataPut(uint32_t ulBase, uint16_t usEndpoint,uint8_t *pucData, uint32_t 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_t USBEndpointDataSend(uint32_t ulBase, uint16_t usEndpoint, uint32_t ulTransType);


//*****************************************************************************
//
//! Resets the USB Device Controller
//!
//! \param None.
//!
//! \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_t ulBase, uint32_t usEndpoint, uint32_t uFIFOAddress, uint32_t uFIFOSize, uint16_t 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_t ulBase, uint16_t usEndpoint, uint32_t*pulMaxPacketSize, uint32_t*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_t ulBase, uint16_t usEndpoint, uint32_t ulMaxPacketSize, uint16_t uFlags);

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

#endif /*USB_H_*/
