Usb_api

Macros
#define	USB_INTEP_RX_SHIFT   16
#define	USB_RX_EPSTATUS_SHIFT   16
#define	EP_OFFSET(Endpoint)   (Endpoint - 0x10)

Functions
static void	_USBIndexWrite (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32IndexedReg, uint32_t ui32Value, uint32_t ui32Size)
static uint32_t	_USBIndexRead (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32IndexedReg, uint32_t ui32Size)
void	USBHostSuspend (uint32_t ui32Base)
void	USBHostReset (uint32_t ui32Base, bool bStart)
void	USBHighSpeed (uint32_t ui32Base, bool bEnable)
void	USBHostResume (uint32_t ui32Base, bool bStart)
uint32_t	USBHostSpeedGet (uint32_t ui32Base)
uint32_t	USBDevSpeedGet (uint32_t ui32Base)
void	USBIntDisableControl (uint32_t ui32Base, uint32_t ui32Flags)
void	USBIntEnableControl (uint32_t ui32Base, uint32_t ui32Flags)
uint32_t	USBIntStatusControl (uint32_t ui32Base)
void	USBIntDisableEndpoint (uint32_t ui32Base, uint32_t ui32Flags)
void	USBIntEnableEndpoint (uint32_t ui32Base, uint32_t ui32Flags)
uint32_t	USBIntStatusEndpoint (uint32_t ui32Base)
static uint32_t	_USBIntNumberGet (uint32_t ui32Base)
void	USBIntRegister (uint32_t ui32Base, void(*pfnHandler)(void))
void	USBIntUnregister (uint32_t ui32Base)
uint32_t	USBEndpointStatus (uint32_t ui32Base, uint32_t ui32Endpoint)
void	USBHostEndpointStatusClear (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBDevEndpointStatusClear (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBHostEndpointDataToggle (uint32_t ui32Base, uint32_t ui32Endpoint, bool bDataToggle, uint32_t ui32Flags)
void	USBEndpointDataToggleClear (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBHostEndpointPing (uint32_t ui32Base, uint32_t ui32Endpoint, bool bEnable)
void	USBDevEndpointStall (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBDevEndpointStallClear (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBDevConnect (uint32_t ui32Base)
void	USBDevDisconnect (uint32_t ui32Base)
void	USBDevAddrSet (uint32_t ui32Base, uint32_t ui32Address)
uint32_t	USBDevAddrGet (uint32_t ui32Base)
void	USBHostEndpointConfig (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32MaxPayload, uint32_t ui32NAKPollInterval, uint32_t ui32TargetEndpoint, uint32_t ui32Flags)
void	USBHostEndpointSpeed (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBDevEndpointConfigSet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32MaxPacketSize, uint32_t ui32Flags)
void	USBDevEndpointConfigGet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t *pui32MaxPacketSize, uint32_t *pui32Flags)
void	USBFIFOConfigSet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32FIFOAddress, uint32_t ui32FIFOSize, uint32_t ui32Flags)
void	USBFIFOConfigGet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t *pui32FIFOAddress, uint32_t *pui32FIFOSize, uint32_t ui32Flags)
void	USBEndpointDMAConfigSet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Config)
void	USBEndpointDMAEnable (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBEndpointDMADisable (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
uint32_t	USBEndpointDataAvail (uint32_t ui32Base, uint32_t ui32Endpoint)
int32_t	USBEndpointDataGet (uint32_t ui32Base, uint32_t ui32Endpoint, uint8_t *pui8Data, uint32_t *pui32Size)
void	USBDevEndpointDataAck (uint32_t ui32Base, uint32_t ui32Endpoint, bool bIsLastPacket)
void	USBHostEndpointDataAck (uint32_t ui32Base, uint32_t ui32Endpoint)
int32_t	USBEndpointDataPut (uint32_t ui32Base, uint32_t ui32Endpoint, uint8_t *pui8Data, uint32_t ui32Size)
int32_t	USBEndpointDataSend (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32TransType)
void	USBFIFOFlush (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBHostRequestIN (uint32_t ui32Base, uint32_t ui32Endpoint)
void	USBHostRequestINClear (uint32_t ui32Base, uint32_t ui32Endpoint)
void	USBHostRequestStatus (uint32_t ui32Base)
void	USBHostAddrSet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Addr, uint32_t ui32Flags)
uint32_t	USBHostAddrGet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBHostHubAddrSet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Addr, uint32_t ui32Flags)
uint32_t	USBHostHubAddrGet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Flags)
void	USBHostPwrConfig (uint32_t ui32Base, uint32_t ui32Flags)
void	USBHostPwrFaultEnable (uint32_t ui32Base)
void	USBHostPwrFaultDisable (uint32_t ui32Base)
void	USBHostPwrEnable (uint32_t ui32Base)
void	USBHostPwrDisable (uint32_t ui32Base)
uint32_t	USBFrameNumberGet (uint32_t ui32Base)
void	USBOTGSessionRequest (uint32_t ui32Base, bool bStart)
uint32_t	USBFIFOAddrGet (uint32_t ui32Base, uint32_t ui32Endpoint)
uint32_t	USBModeGet (uint32_t ui32Base)
void	USBEndpointDMAChannel (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Channel)
void	USBHostMode (uint32_t ui32Base)
void	USBDevMode (uint32_t ui32Base)
void	USBOTGMode (uint32_t ui32Base)
void	USBModeConfig (uint32_t ui32Base, uint32_t ui32Mode)
void	USBPHYPowerOff (uint32_t ui32Base)
void	USBPHYPowerOn (uint32_t ui32Base)
void	USBEndpointPacketCountSet (uint32_t ui32Base, uint32_t ui32Endpoint, uint32_t ui32Count)
uint32_t	USBNumEndpointsGet (uint32_t ui32Base)
uint32_t	USBControllerVersion (uint32_t ui32Base)
void	USBClockEnable (uint32_t ui32Base, uint32_t ui32Div, uint32_t ui32Flags)
void	USBClockDisable (uint32_t ui32Base)

Detailed Description

Macro Definition Documentation

#define EP_OFFSET

(

Endpoint

)

(Endpoint - 0x10)

Definition at line 82 of file usb.c.

Referenced by USBDevEndpointConfigGet(), USBDevEndpointConfigSet(), USBDevEndpointDataAck(), USBDevEndpointStall(), USBDevEndpointStallClear(), USBDevEndpointStatusClear(), USBEndpointDataAvail(), USBEndpointDataGet(), USBEndpointDataToggleClear(), USBEndpointDMAConfigSet(), USBEndpointDMADisable(), USBEndpointDMAEnable(), USBEndpointStatus(), USBFIFOFlush(), USBHostEndpointConfig(), USBHostEndpointDataAck(), USBHostEndpointDataToggle(), USBHostEndpointSpeed(), USBHostEndpointStatusClear(), USBHostRequestIN(), and USBHostRequestINClear().

#define USB_INTEP_RX_SHIFT   16

Definition at line 66 of file usb.c.

Referenced by USBIntDisableEndpoint(), USBIntEnableEndpoint(), and USBIntStatusEndpoint().

#define USB_RX_EPSTATUS_SHIFT   16

Definition at line 74 of file usb.c.

Referenced by USBDevEndpointStatusClear(), USBEndpointStatus(), and USBHostEndpointStatusClear().

Function Documentation

static uint32_t _USBIndexRead ( uint32_t  ui32Base, uint32_t  ui32Endpoint, uint32_t  ui32IndexedReg, uint32_t  ui32Size  )

static

Definition at line 164 of file usb.c.

References ASSERT, HWREGB, HWREGH, USB0_BASE, and USB_O_EPIDX.

Referenced by USBFIFOConfigGet().

{
    uint8_t ui8Index;
    uint8_t ui8Value;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == 0) || (ui32Endpoint == 1) || (ui32Endpoint == 2) ||
           (ui32Endpoint == 3));
    ASSERT((ui32Size == 1) || (ui32Size == 2));

    //
    // Save the old index in case it was in use.
    //
    ui8Index = HWREGB(ui32Base + USB_O_EPIDX);

    //
    // Set the index.
    //
    HWREGB(ui32Base + USB_O_EPIDX) = ui32Endpoint;

    //
    // Determine the size of the register value.
    //
    if(ui32Size == 1)
    {
        //
        // Get the value.
        //
        ui8Value = HWREGB(ui32Base + ui32IndexedReg);
    }
    else
    {
        //
        // Get the value.
        //
        ui8Value = HWREGH(ui32Base + ui32IndexedReg);
    }

    //
    // Restore the old index in case it was in use.
    //
    HWREGB(ui32Base + USB_O_EPIDX) = ui8Index;

    //
    // Return the register's value.
    //
    return(ui8Value);
}

Here is the caller graph for this function:

static void _USBIndexWrite ( uint32_t  ui32Base, uint32_t  ui32Endpoint, uint32_t  ui32IndexedReg, uint32_t  ui32Value, uint32_t  ui32Size  )

static

Definition at line 101 of file usb.c.

References ASSERT, HWREGB, HWREGH, USB0_BASE, and USB_O_EPIDX.

Referenced by USBFIFOConfigSet().

{
    uint32_t ui32Index;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == 0) || (ui32Endpoint == 1) || (ui32Endpoint == 2) ||
           (ui32Endpoint == 3));
    ASSERT((ui32Size == 1) || (ui32Size == 2));

    //
    // Save the old index in case it was in use.
    //
    ui32Index = HWREGB(ui32Base + USB_O_EPIDX);

    //
    // Set the index.
    //
    HWREGB(ui32Base + USB_O_EPIDX) = ui32Endpoint;

    //
    // Determine the size of the register value.
    //
    if(ui32Size == 1)
    {
        //
        // Set the value.
        //
        HWREGB(ui32Base + ui32IndexedReg) = ui32Value;
    }
    else
    {
        //
        // Set the value.
        //
        HWREGH(ui32Base + ui32IndexedReg) = ui32Value;
    }

    //
    // Restore the old index in case it was in use.
    //
    HWREGB(ui32Base + USB_O_EPIDX) = ui32Index;
}

Here is the caller graph for this function:

static uint32_t _USBIntNumberGet ( uint32_t  ui32Base )

static

Returns the interrupt number for a specified USB module.

Parameters

ui32Base

is the base address of the USB module.

This function returns the interrupt number for the USB module with the base address passed in the ui32Base parameter.

Returns

Returns the USB interrupt number or 0 if the interrupt does not exist.

Definition at line 818 of file usb.c.

References CLASS_IS_TM4C123, CLASS_IS_TM4C129, INT_USB0_TM4C123, and INT_USB0_TM4C129.

Referenced by USBIntRegister(), and USBIntUnregister().

{
    uint32_t ui32Int;

    if(CLASS_IS_TM4C123)
    {
        ui32Int = INT_USB0_TM4C123;
    }
    else if(CLASS_IS_TM4C129)
    {
        ui32Int = INT_USB0_TM4C129;
    }
    else
    {
        ui32Int = 0;
    }
    return(ui32Int);
}

Here is the caller graph for this function:

void USBClockDisable

(

uint32_t

ui32Base

)

Disables the clocking of the USB controller's PHY.

Parameters

ui32Base

specifies the USB module base address.

This function disables the USB PHY clock. This function should not be called in applications where the USB controller is used.

Example: Disable the USB PHY clock input.

//! //
//! // Disable clocking of the USB controller's PHY.
//! //
//! USBClockDisable(USB0_BASE);
//! 

\note The ability to configure the USB PHY clock is not available on all
Tiva devices.  Please consult the data sheet for the Tiva device
that you are using to determine if this feature is available.

\return None.  

Definition at line 4346 of file usb.c.

References ASSERT, HWREG, USB0_BASE, and USB_O_CC.

{
    ASSERT(ui32Base == USB0_BASE);

    //
    // Disable the USB clock input.
    //
    HWREG(ui32Base + USB_O_CC) = 0;
}

void USBClockEnable	(	uint32_t	ui32Base,
		uint32_t	ui32Div,
		uint32_t	ui32Flags
	)

Configures and enables the clocking to the USB controller's PHY.

Parameters

ui32Base	specifies the USB module base address.
ui32Div	specifies the divider for the internal USB PHY clock.
ui32Flags	configures the internal USB PHY clock and specifies the clock source for a ULPI-connected PHY.

This function configures and enables the USB PHY clock. In addition, for systems that use a ULPI-connected external PHY, this function configures the source for the PHY clock. The ui32Flags parameter specifies the clock source with the following values:

• USB_CLOCK_INTERNAL uses the internal PLL combined with the ui32Div value to generate the USB clock that is used by the internal USB PHY. In addition, when using an external ULPI-connected USB PHY, the specified clock is output on the USB0CLK pin.
• USB_CLOCK_EXTERNAL specifies that USB0CLK is an input from the ULPI-connected external PHY.

The ui32Div parameter is used to specify a divider for the internal clock if the USB_CLOCK_INTERNAL is specified and is ignored if USB_CLOCK_EXTERNAL is specified. When the USB_CLOCK_INTERNAL is specified, the ui32Div value must be set so that the PLL_VCO/ui32Div results in a 60-MHz clock.

Example: Enable the USB clock with a 480-MHz PLL setting.

//! //
//! // Enable the USB clock using a 480-MHz PLL.
//! // (480-MHz/8 = 60-MHz)
//! //
//! USBClockEnable(USB0_BASE, 8, USB_CLOCK_INTERNAL);
//! 

\note The ability to configure the USB PHY clock is not available on
all Tiva devices.  Please consult the data sheet for the Tiva
device that you are using to determine if this feature is available.

\return None.  

Definition at line 4310 of file usb.c.

References ASSERT, HWREG, USB0_BASE, and USB_O_CC.

{
    ASSERT(ui32Base == USB0_BASE);

    //
    // Configure and enable the USB clock input.
    //
    HWREG(ui32Base + USB_O_CC) = (ui32Div - 1) | ui32Flags;
}

uint32_t USBControllerVersion

(

uint32_t

ui32Base

)

Returns the version of the USB controller.

Parameters

ui32Base

specifies the USB module base address.

This function returns the version number of the USB controller, which can be be used to adjust for slight differences between the USB controllers in the Tiva family. The values that are returned are USB_CONTROLLER_VER_0 and USB_CONTROLLER_VER_1.

Note

The most significant difference between USB_CONTROLLER_VER_0 and USB_CONTROLLER_VER_1 is that USB_CONTROLLER_VER_1 supports the USB controller's own bus master DMA controller, while the USB_CONTROLLER_VER_0 only supports using the uDMA controller with the USB module.

Example: Get the version of the Tiva USB controller.

//! uint32_t ui32Version;
//!
//! //
//! // Retrieve the version of the Tiva USB controller.
//! //
//! ui32Version = USBControllerVersion(USB0_BASE);
//! 

\return This function returns one of the \b USB_CONTROLLER_VER_ values.  

Definition at line 4256 of file usb.c.

References HWREG, USB_O_PP, and USB_PP_TYPE_M.

{
    //
    // Return the type field of the peripheral properties.  This returns
    // zero for all parts that did not have a peripheral property.
    //
    return(HWREG(ui32Base + USB_O_PP) & USB_PP_TYPE_M);
}

uint32_t USBDevAddrGet

(

uint32_t

ui32Base

)

Returns the current device address in device mode.

Parameters

ui32Base

specifies the USB module base address.

This function returns the current device address. This address was set by a call to USBDevAddrSet().

Note

This function must only be called in device mode.

Returns

The current device address.

Definition at line 1585 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, and USB_O_FADDR.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Return the function address.
    //
    return(HWREGB(ui32Base + USB_O_FADDR));
}

void USBDevAddrSet	(	uint32_t	ui32Base,
		uint32_t	ui32Address
	)

Sets the address in device mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Address	is the address to use for a device.

This function configures the device address on the USB bus. This address was likely received via a SET ADDRESS command from the host controller.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 1557 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, and USB_O_FADDR.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Set the function address in the correct location.
    //
    HWREGB(ui32Base + USB_O_FADDR) = (uint8_t)ui32Address;
}

void USBDevConnect

(

uint32_t

ui32Base

)

Connects the USB controller to the bus in device mode.

Parameters

ui32Base

specifies the USB module base address.

This function causes the soft connect feature of the USB controller to be enabled. Call USBDevDisconnect() to remove the USB device from the bus.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 1499 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_O_POWER, and USB_POWER_SOFTCONN.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Enable connection to the USB bus.
    //
    HWREGB(ui32Base + USB_O_POWER) |= USB_POWER_SOFTCONN;
}

void USBDevDisconnect

(

uint32_t

ui32Base

)

Removes the USB controller from the bus in device mode.

Parameters

ui32Base

specifies the USB module base address.

This function causes the soft connect feature of the USB controller to remove the device from the USB bus. A call to USBDevConnect() is needed to reconnect to the bus.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 1528 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_O_POWER, and USB_POWER_SOFTCONN.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Disable connection to the USB bus.
    //
    HWREGB(ui32Base + USB_O_POWER) &= (~USB_POWER_SOFTCONN);
}

void USBDevEndpointConfigGet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t *	pui32MaxPacketSize,
		uint32_t *	pui32Flags
	)

Gets the current configuration for an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
pui32MaxPacketSize	is a pointer which is written with the maximum packet size for this endpoint.
pui32Flags	is a pointer which is written with the current endpoint settings. On entry to the function, this pointer must contain either USB_EP_DEV_IN or USB_EP_DEV_OUT to indicate whether the IN or OUT endpoint is to be queried.

This function returns the basic configuration for an endpoint in device mode. The values returned in *pui32MaxPacketSize and *pui32Flags are equivalent to the ui32MaxPacketSize and ui32Flags previously passed to USBDevEndpointConfigSet() for this endpoint.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 2213 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, HWREGH, USB0_BASE, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_AUTO_CLEAR, USB_EP_AUTO_SET, USB_EP_DEV_IN, USB_EP_DEV_OUT, USB_EP_DMA_MODE_0, USB_EP_DMA_MODE_1, USB_EP_MODE_BULK, USB_EP_MODE_ISOC, USB_O_RXCSRH1, USB_O_RXMAXP1, USB_O_TXCSRH1, USB_O_TXMAXP1, USB_RXCSRH1_AUTOCL, USB_RXCSRH1_DMAEN, USB_RXCSRH1_DMAMOD, USB_RXCSRH1_ISO, USB_TXCSRH1_AUTOSET, USB_TXCSRH1_DMAEN, USB_TXCSRH1_DMAMOD, and USB_TXCSRH1_ISO.

{
    uint32_t ui32Register;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT(pui32MaxPacketSize && pui32Flags);
    ASSERT((ui32Endpoint == USB_EP_1) || (ui32Endpoint == USB_EP_2) ||
           (ui32Endpoint == USB_EP_3) || (ui32Endpoint == USB_EP_4) ||
           (ui32Endpoint == USB_EP_5) || (ui32Endpoint == USB_EP_6) ||
           (ui32Endpoint == USB_EP_7));

    //
    // Determine if a transmit or receive endpoint is being queried.
    //
    if(*pui32Flags & USB_EP_DEV_IN)
    {
        //
        // Clear the flags other than the direction bit.
        //
        *pui32Flags = USB_EP_DEV_IN;

        //
        // Get the maximum packet size.
        //
        *pui32MaxPacketSize = (uint32_t)HWREGH(ui32Base +
                                               EP_OFFSET(ui32Endpoint) +
                                               USB_O_TXMAXP1);

        //
        // Get the current transmit control register value.
        //
        ui32Register = (uint32_t)HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) +
                                        USB_O_TXCSRH1);

        //
        // Are we allowing auto setting of TxPktRdy when max packet size has
        // been loaded into the FIFO?
        //
        if(ui32Register & USB_TXCSRH1_AUTOSET)
        {
            *pui32Flags |= USB_EP_AUTO_SET;
        }

        //
        // Get the DMA mode.
        //
        if(ui32Register & USB_TXCSRH1_DMAEN)
        {
            if(ui32Register & USB_TXCSRH1_DMAMOD)
            {
                *pui32Flags |= USB_EP_DMA_MODE_1;
            }
            else
            {
                *pui32Flags |= USB_EP_DMA_MODE_0;
            }
        }

        //
        // Are we in isochronous mode?
        //
        if(ui32Register & USB_TXCSRH1_ISO)
        {
            *pui32Flags |= USB_EP_MODE_ISOC;
        }
        else
        {
            //
            // The hardware doesn't differentiate between bulk, interrupt
            // and control mode for the endpoint so we just set something
            // that isn't isochronous.  This protocol ensures that anyone
            // modifying the returned flags in preparation for a call to
            // USBDevEndpointConfigSet do not see an unexpected mode change.
            // If they decode the returned mode, however, they may be in for
            // a surprise.
            //
            *pui32Flags |= USB_EP_MODE_BULK;
        }
    }
    else
    {
        //
        // Clear the flags other than the direction bit.
        //
        *pui32Flags = USB_EP_DEV_OUT;

        //
        // Get the MaxPacketSize.
        //
        *pui32MaxPacketSize = (uint32_t)HWREGH(ui32Base +
                                               EP_OFFSET(ui32Endpoint) +
                                               USB_O_RXMAXP1);

        //
        // Get the current receive control register value.
        //
        ui32Register = (uint32_t)HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) +
                                        USB_O_RXCSRH1);

        //
        // Are we allowing auto clearing of RxPktRdy when packet of size max
        // packet has been unloaded from the FIFO?
        //
        if(ui32Register & USB_RXCSRH1_AUTOCL)
        {
            *pui32Flags |= USB_EP_AUTO_CLEAR;
        }

        //
        // Get the DMA mode.
        //
        if(ui32Register & USB_RXCSRH1_DMAEN)
        {
            if(ui32Register & USB_RXCSRH1_DMAMOD)
            {
                *pui32Flags |= USB_EP_DMA_MODE_1;
            }
            else
            {
                *pui32Flags |= USB_EP_DMA_MODE_0;
            }
        }

        //
        // Are we in isochronous mode?
        //
        if(ui32Register & USB_RXCSRH1_ISO)
        {
            *pui32Flags |= USB_EP_MODE_ISOC;
        }
        else
        {
            //
            // The hardware doesn't differentiate between bulk, interrupt
            // and control mode for the endpoint so we just set something
            // that isn't isochronous.  This protocol ensures that anyone
            // modifying the returned flags in preparation for a call to
            // USBDevEndpointConfigSet do not see an unexpected mode change.
            // If they decode the returned mode, however, they may be in for
            // a surprise.
            //
            *pui32Flags |= USB_EP_MODE_BULK;
        }
    }
}

void USBDevEndpointConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32MaxPacketSize,
		uint32_t	ui32Flags
	)

Sets the configuration for an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32MaxPacketSize	is the maximum packet size for this endpoint.
ui32Flags	are used to configure other endpoint settings.

This function sets the basic configuration for an endpoint in device mode. Endpoint zero does not have a dynamic configuration, so this function must not be called for endpoint zero. The ui32Flags parameter determines some of the configuration while the other parameters provide the rest.

The USB_EP_MODE_ flags define what the type is for the specified endpoint.

• USB_EP_MODE_CTRL is a control endpoint.
• USB_EP_MODE_ISOC is an isochronous endpoint.
• USB_EP_MODE_BULK is a bulk endpoint.
• USB_EP_MODE_INT is an interrupt endpoint.

The USB_EP_DMA_MODE_ flags determine the type of DMA access to the endpoint data FIFOs. The choice of the DMA mode depends on how the DMA controller is configured and how it is being used. See the ``Using USB with the uDMA Controller'' or the ''Using the integrated USB DMA Controller'' section for more information on DMA configuration depending on the type of DMA that is supported by the USB controller.

When configuring an IN endpoint, the USB_EP_AUTO_SET bit can be specified to cause the automatic transmission of data on the USB bus as soon as ui32MaxPacketSize bytes of data are written into the FIFO for this endpoint. This option is commonly used with DMA (both on devices with integrated USB DMA as well as those that use uDMA) as no interaction is required to start the transmission of data.

When configuring an OUT endpoint, the USB_EP_AUTO_REQUEST bit is specified to trigger the request for more data once the FIFO has been drained enough to receive ui32MaxPacketSize more bytes of data. Also for OUT endpoints, the USB_EP_AUTO_CLEAR bit can be used to clear the data packet ready flag automatically once the data has been read from the FIFO. If this option is not used, this flag must be manually cleared via a call to USBDevEndpointStatusClear(). Both of these settings can be used to remove the need for extra calls when using the controller with DMA.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 2053 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, HWREGH, USB0_BASE, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_AUTO_CLEAR, USB_EP_AUTO_SET, USB_EP_DEV_IN, USB_EP_DIS_NYET, USB_EP_DMA_MODE_0, USB_EP_DMA_MODE_1, USB_EP_MODE_ISOC, USB_EP_MODE_MASK, USB_O_RXCSRH1, USB_O_RXCSRL1, USB_O_RXMAXP1, USB_O_TXCSRH1, USB_O_TXCSRL1, USB_O_TXMAXP1, USB_RXCSRH1_AUTOCL, USB_RXCSRH1_DISNYET, USB_RXCSRH1_DMAEN, USB_RXCSRH1_DMAMOD, USB_RXCSRH1_ISO, USB_RXCSRL1_CLRDT, USB_TXCSRH1_AUTOSET, USB_TXCSRH1_DMAEN, USB_TXCSRH1_DMAMOD, USB_TXCSRH1_ISO, and USB_TXCSRL1_CLRDT.

{
    uint32_t ui32Register;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_1) || (ui32Endpoint == USB_EP_2) ||
           (ui32Endpoint == USB_EP_3) || (ui32Endpoint == USB_EP_4) ||
           (ui32Endpoint == USB_EP_5) || (ui32Endpoint == USB_EP_6) ||
           (ui32Endpoint == USB_EP_7));

    //
    // Determine if a transmit or receive endpoint is being configured.
    //
    if(ui32Flags & USB_EP_DEV_IN)
    {
        //
        // Set the maximum packet size.
        //
        HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXMAXP1) =
            ui32MaxPacketSize;

        //
        // The transmit control value is zero unless options are enabled.
        //
        ui32Register = 0;

        //
        // Allow auto setting of TxPktRdy when max packet size has been loaded
        // into the FIFO.
        //
        if(ui32Flags & USB_EP_AUTO_SET)
        {
            ui32Register |= USB_TXCSRH1_AUTOSET;
        }

        //
        // Configure the DMA mode.
        //
        if(ui32Flags & USB_EP_DMA_MODE_1)
        {
            ui32Register |= USB_TXCSRH1_DMAEN | USB_TXCSRH1_DMAMOD;
        }
        else if(ui32Flags & USB_EP_DMA_MODE_0)
        {
            ui32Register |= USB_TXCSRH1_DMAEN;
        }

        //
        // Enable isochronous mode if requested.
        //
        if((ui32Flags & USB_EP_MODE_MASK) == USB_EP_MODE_ISOC)
        {
            ui32Register |= USB_TXCSRH1_ISO;
        }

        //
        // Write the transmit control value.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRH1) =
            (uint8_t)ui32Register;

        //
        // Reset the Data toggle to zero.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRL1) =
            USB_TXCSRL1_CLRDT;
    }
    else
    {
        //
        // Set the MaxPacketSize.
        //
        HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXMAXP1) =
            ui32MaxPacketSize;

        //
        // The receive control value is zero unless options are enabled.
        //
        ui32Register = 0;

        //
        // Allow auto clearing of RxPktRdy when packet of size max packet
        // has been unloaded from the FIFO.
        //
        if(ui32Flags & USB_EP_AUTO_CLEAR)
        {
            ui32Register = USB_RXCSRH1_AUTOCL;
        }

        //
        // Configure the DMA mode.
        //
        if(ui32Flags & USB_EP_DMA_MODE_1)
        {
            ui32Register |= USB_RXCSRH1_DMAEN | USB_RXCSRH1_DMAMOD;
        }
        else if(ui32Flags & USB_EP_DMA_MODE_0)
        {
            ui32Register |= USB_RXCSRH1_DMAEN;
        }

        //
        // If requested, disable NYET responses for high-speed bulk and
        // interrupt endpoints.
        //
        if(ui32Flags & USB_EP_DIS_NYET)
        {
            ui32Register |= USB_RXCSRH1_DISNYET;
        }

        //
        // Enable isochronous mode if requested.
        //
        if((ui32Flags & USB_EP_MODE_MASK) == USB_EP_MODE_ISOC)
        {
            ui32Register |= USB_RXCSRH1_ISO;
        }

        //
        // Write the receive control value.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRH1) =
            (uint8_t)ui32Register;

        //
        // Reset the Data toggle to zero.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRL1) =
            USB_RXCSRL1_CLRDT;
    }
}

void USBDevEndpointDataAck	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		bool	bIsLastPacket
	)

Acknowledge that data was read from the specified endpoint's FIFO in device mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
bIsLastPacket	indicates if this packet is the last one.

This function acknowledges that the data was read from the endpoint's FIFO. The bIsLastPacket parameter is set to a true value if this is the last in a series of data packets on endpoint zero. The 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.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 2896 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRL0_DATAEND, USB_CSRL0_RXRDYC, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_RXCSRL1, and USB_RXCSRL1_RXRDY.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Determine which endpoint is being acked.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Clear RxPktRdy, and optionally DataEnd, on endpoint zero.
        //
        HWREGB(ui32Base + USB_O_CSRL0) =
            USB_CSRL0_RXRDYC | (bIsLastPacket ? USB_CSRL0_DATAEND : 0);
    }
    else
    {
        //
        // Clear RxPktRdy on all other endpoints.
        //
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~(USB_RXCSRL1_RXRDY);
    }
}

void USBDevEndpointStall	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Stalls the specified endpoint in device mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies the endpoint to stall.
ui32Flags	specifies whether to stall the IN or OUT endpoint.

This function causes the endpoint number passed in to go into a stall condition. If the ui32Flags parameter is USB_EP_DEV_IN, then the stall is issued on the IN portion of this endpoint. If the ui32Flags parameter is USB_EP_DEV_OUT, then the stall is issued on the OUT portion of this endpoint.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 1369 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRL0_RXRDYC, USB_CSRL0_STALL, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_DEV_IN, USB_EP_DEV_OUT, USB_O_CSRL0, USB_O_RXCSRL1, USB_O_TXCSRL1, USB_RXCSRL1_STALL, and USB_TXCSRL1_STALL.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Flags & ~(USB_EP_DEV_IN | USB_EP_DEV_OUT)) == 0);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Determine how to stall this endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Perform a stall on endpoint zero.
        //
        HWREGB(ui32Base + USB_O_CSRL0) |= USB_CSRL0_STALL | USB_CSRL0_RXRDYC;
    }
    else if(ui32Flags == USB_EP_DEV_IN)
    {
        //
        // Perform a stall on an IN endpoint.
        //
        HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
            USB_TXCSRL1_STALL;
    }
    else
    {
        //
        // Perform a stall on an OUT endpoint.
        //
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
            USB_RXCSRL1_STALL;
    }
}

void USBDevEndpointStallClear	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Clears the stall condition on the specified endpoint in device mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies which endpoint to remove the stall condition.
ui32Flags	specifies whether to remove the stall condition from the IN or the OUT portion of this endpoint.

This function causes the endpoint number passed in to exit the stall condition. If the ui32Flags parameter is USB_EP_DEV_IN, then the stall is cleared on the IN portion of this endpoint. If the ui32Flags parameter is USB_EP_DEV_OUT, then the stall is cleared on the OUT portion of this endpoint.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 1431 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRL0_STALLED, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_DEV_IN, USB_EP_DEV_OUT, USB_O_CSRL0, USB_O_RXCSRL1, USB_O_TXCSRL1, USB_RXCSRL1_CLRDT, USB_RXCSRL1_STALL, USB_RXCSRL1_STALLED, USB_TXCSRL1_CLRDT, USB_TXCSRL1_STALL, and USB_TXCSRL1_STALLED.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));
    ASSERT((ui32Flags & ~(USB_EP_DEV_IN | USB_EP_DEV_OUT)) == 0);

    //
    // Determine how to clear the stall on this endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Clear the stall on endpoint zero.
        //
        HWREGB(ui32Base + USB_O_CSRL0) &= ~USB_CSRL0_STALLED;
    }
    else if(ui32Flags == USB_EP_DEV_IN)
    {
        //
        // Clear the stall on an IN endpoint.
        //
        HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~(USB_TXCSRL1_STALL | USB_TXCSRL1_STALLED);

        //
        // Reset the data toggle.
        //
        HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
            USB_TXCSRL1_CLRDT;
    }
    else
    {
        //
        // Clear the stall on an OUT endpoint.
        //
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~(USB_RXCSRL1_STALL | USB_RXCSRL1_STALLED);

        //
        // Reset the data toggle.
        //
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
            USB_RXCSRL1_CLRDT;
    }
}

void USBDevEndpointStatusClear	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Clears the status bits in this endpoint in device mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	are the status bits that are cleared.

This function clears the status of any bits that are passed in the ui32Flags parameter. The ui32Flags parameter can take the value returned from the USBEndpointStatus() call.

Note

This function must only be called in device mode.

Returns

None.

Definition at line 1089 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRL0_RXRDYC, USB_CSRL0_SETENDC, USB_DEV_EP0_OUT_PKTRDY, USB_DEV_EP0_SENT_STALL, USB_DEV_EP0_SETUP_END, USB_DEV_RX_DATA_ERROR, USB_DEV_RX_OVERRUN, USB_DEV_RX_SENT_STALL, USB_DEV_TX_SENT_STALL, USB_DEV_TX_UNDERRUN, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_RXCSRL1, USB_O_TXCSRL1, and USB_RX_EPSTATUS_SHIFT.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // If this is endpoint 0, then the bits have different meaning and map
    // into the TX memory location.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Set the Serviced RxPktRdy bit to clear the RxPktRdy.
        //
        if(ui32Flags & USB_DEV_EP0_OUT_PKTRDY)
        {
            HWREGB(ui32Base + USB_O_CSRL0) |= USB_CSRL0_RXRDYC;
        }

        //
        // Set the serviced Setup End bit to clear the SetupEnd status.
        //
        if(ui32Flags & USB_DEV_EP0_SETUP_END)
        {
            HWREGB(ui32Base + USB_O_CSRL0) |= USB_CSRL0_SETENDC;
        }

        //
        // Clear the Sent Stall status flag.
        //
        if(ui32Flags & USB_DEV_EP0_SENT_STALL)
        {
            HWREGB(ui32Base + USB_O_CSRL0) &= ~(USB_DEV_EP0_SENT_STALL);
        }
    }
    else
    {
        //
        // Clear out any TX flags that were passed in.  Only
        // USB_DEV_TX_SENT_STALL and USB_DEV_TX_UNDERRUN must be cleared.
        //
        HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~(ui32Flags & (USB_DEV_TX_SENT_STALL | USB_DEV_TX_UNDERRUN));

        //
        // Clear out valid RX flags that were passed in.  Only
        // USB_DEV_RX_SENT_STALL, USB_DEV_RX_DATA_ERROR, and USB_DEV_RX_OVERRUN
        // must be cleared.
        //
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~((ui32Flags & (USB_DEV_RX_SENT_STALL | USB_DEV_RX_DATA_ERROR |
                            USB_DEV_RX_OVERRUN)) >> USB_RX_EPSTATUS_SHIFT);
    }
}

void USBDevMode

(

uint32_t

ui32Base

)

Change the mode of the USB controller to device.

Parameters

ui32Base

specifies the USB module base address.

This function changes the mode of the USB controller to device mode.

Note

This function must only be called on microcontrollers that support OTG operation.

Returns

None.

Definition at line 4028 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_GPCS_DEVMOD, USB_GPCS_DEVMODOTG, and USB_O_GPCS.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Set the USB controller mode to device.
    //
    HWREGB(ui32Base + USB_O_GPCS) = USB_GPCS_DEVMODOTG | USB_GPCS_DEVMOD;
}

uint32_t USBDevSpeedGet

(

uint32_t

ui32Base

)

Returns the current speed of the USB controller in device mode.

Parameters

ui32Base

specifies the USB module base address.

This function returns the operating speed of the connection to the USB host controller. This function returns either USB_HIGH_SPEED or USB_FULL_SPEED to indicate the connection speed in device mode.

Example: Get the USB connection speed.

//! //
//! // Get the connection speed of the USB controller.
//! //
//! USBDevSpeedGet(USB0_BASE);
//! 

\note This function must only be called in device mode.

\return Returns either \b USB_HIGH_SPEED or \b USB_FULL_SPEED.  

Definition at line 474 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_FULL_SPEED, USB_HIGH_SPEED, USB_O_POWER, and USB_POWER_HSMODE.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // If the Full Speed device bit is set, then this is a full speed device.
    //
    if(HWREGB(ui32Base + USB_O_POWER) & USB_POWER_HSMODE)
    {
        return(USB_HIGH_SPEED);
    }

    return(USB_FULL_SPEED);
}

uint32_t USBEndpointDataAvail	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint
	)

Determines the number of bytes of data available in a specified endpoint's FIFO.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.

This function returns the number of bytes of data currently available in the FIFO for the specified receive (OUT) endpoint. It may be used prior to calling USBEndpointDataGet() to determine the size of buffer required to hold the newly-received packet.

Returns

This call returns the number of bytes available in a specified endpoint FIFO.

Definition at line 2730 of file usb.c.

References ASSERT, EP_OFFSET, HWREGH, USB0_BASE, USB_CSRL0_RXRDY, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_COUNT0, USB_O_CSRL0, and USB_O_RXCSRL1.

{
    uint32_t ui32Register;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Get the address of the receive status register to use, based on the
    // endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        ui32Register = USB_O_CSRL0;
    }
    else
    {
        ui32Register = USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint);
    }

    //
    // Is there a packet ready in the FIFO?
    //
    if((HWREGH(ui32Base + ui32Register) & USB_CSRL0_RXRDY) == 0)
    {
        return(0);
    }

    //
    // Return the byte count in the FIFO.
    //
    return(HWREGH(ui32Base + USB_O_COUNT0 + ui32Endpoint));
}

int32_t USBEndpointDataGet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint8_t *	pui8Data,
		uint32_t *	pui32Size
	)

Retrieves data from the specified endpoint's FIFO.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
pui8Data	is a pointer to the data area used to return the data from the FIFO.
pui32Size	is initially the size of the buffer passed into this call via the pui8Data parameter. It is set to the amount of data returned in the buffer.

This function returns the data from the FIFO for the specified endpoint. The pui32Size parameter indicates the size of the buffer passed in the pui32Data parameter. The data in the pui32Size parameter is changed to match the amount of data returned in the pui8Data parameter. If a zero-byte packet is received, this call does not return an error but instead just returns a zero in the pui32Size parameter. The only error case occurs when there is no data packet available.

Returns

This call returns 0, or -1 if no packet was received.

Definition at line 2794 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, HWREGH, USB0_BASE, USB_CSRL0_RXRDY, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_COUNT0, USB_O_CSRL0, USB_O_FIFO0, and USB_O_RXCSRL1.

{
    uint32_t ui32Register, ui32ByteCount, ui32FIFO;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Get the address of the receive status register to use, based on the
    // endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        ui32Register = USB_O_CSRL0;
    }
    else
    {
        ui32Register = USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint);
    }

    //
    // Don't allow reading of data if the RxPktRdy bit is not set.
    //
    if((HWREGH(ui32Base + ui32Register) & USB_CSRL0_RXRDY) == 0)
    {
        //
        // Can't read the data because none is available.
        //
        *pui32Size = 0;

        //
        // Return a failure since there is no data to read.
        //
        return(-1);
    }

    //
    // Get the byte count in the FIFO.
    //
    ui32ByteCount = HWREGH(ui32Base + USB_O_COUNT0 + ui32Endpoint);

    //
    // Determine how many bytes are copied.
    //
    ui32ByteCount = (ui32ByteCount < *pui32Size) ? ui32ByteCount : *pui32Size;

    //
    // Return the number of bytes we are going to read.
    //
    *pui32Size = ui32ByteCount;

    //
    // Calculate the FIFO address.
    //
    ui32FIFO = ui32Base + USB_O_FIFO0 + (ui32Endpoint >> 2);

    //
    // Read the data out of the FIFO.
    //
    for(; ui32ByteCount > 0; ui32ByteCount--)
    {
        //
        // Read a byte at a time from the FIFO.
        //
        *pui8Data++ = HWREGB(ui32FIFO);
    }

    //
    // Success.
    //
    return(0);
}

int32_t USBEndpointDataPut	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint8_t *	pui8Data,
		uint32_t	ui32Size
	)

Puts data into the specified endpoint's FIFO.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
pui8Data	is a pointer to the data area used as the source for the data to put into the FIFO.
ui32Size	is the amount of data to put into the FIFO.

This function puts the data from the pui8Data parameter into the FIFO for this endpoint. If a packet is already pending for transmission, then this call does not put any of the data into the FIFO and returns -1. Care must be taken to not write more data than can fit into the FIFO allocated by the call to USBFIFOConfigSet().

Returns

This call returns 0 on success, or -1 to indicate that the FIFO is in use and cannot be written.

Definition at line 2993 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_CSRL0_TXRDY, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_FIFO0, and USB_TXCSRL1_TXRDY.

{
    uint32_t ui32FIFO;
    uint8_t ui8TxPktRdy;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Get the bit position of TxPktRdy based on the endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        ui8TxPktRdy = USB_CSRL0_TXRDY;
    }
    else
    {
        ui8TxPktRdy = USB_TXCSRL1_TXRDY;
    }

    //
    // Don't allow transmit of data if the TxPktRdy bit is already set.
    //
    if(HWREGB(ui32Base + USB_O_CSRL0 + ui32Endpoint) & ui8TxPktRdy)
    {
        return(-1);
    }

    //
    // Calculate the FIFO address.
    //
    ui32FIFO = ui32Base + USB_O_FIFO0 + (ui32Endpoint >> 2);

    //
    // Write the data to the FIFO.
    //
    for(; ui32Size > 0; ui32Size--)
    {
        HWREGB(ui32FIFO) = *pui8Data++;
    }

    //
    // Success.
    //
    return(0);
}

int32_t USBEndpointDataSend	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32TransType
	)

Starts the transfer of data from an endpoint's FIFO.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32TransType	is set to indicate what type of data is being sent.

This function starts the transfer of data from the FIFO for a specified endpoint. This function is called if the USB_EP_AUTO_SET bit was not enabled for the endpoint. Setting the ui32TransType parameter allows the appropriate signaling on the USB bus for the type of transaction being requested. The ui32TransType parameter must be one of the following:

• USB_TRANS_OUT for OUT transaction on any endpoint in host mode.
• USB_TRANS_IN for IN transaction on any endpoint in device mode.
• USB_TRANS_IN_LAST for the last IN transaction on endpoint zero in a sequence of IN transactions.
• USB_TRANS_SETUP for setup transactions on endpoint zero.
• USB_TRANS_STATUS for status results on endpoint zero.

Returns

This call returns 0 on success, or -1 if a transmission is already in progress.

Definition at line 3074 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_CSRL0_TXRDY, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, and USB_TXCSRL1_TXRDY.

{
    uint32_t ui32TxPktRdy;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Get the bit position of TxPktRdy based on the endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Don't allow transmit of data if the TxPktRdy bit is already set.
        //
        if(HWREGB(ui32Base + USB_O_CSRL0) & USB_CSRL0_TXRDY)
        {
            return(-1);
        }

        ui32TxPktRdy = ui32TransType & 0xff;
    }
    else
    {
        //
        // Don't allow transmit of data if the TxPktRdy bit is already set.
        //
        if(HWREGB(ui32Base + USB_O_CSRL0 + ui32Endpoint) & USB_TXCSRL1_TXRDY)
        {
            return(-1);
        }

        ui32TxPktRdy = (ui32TransType >> 8) & 0xff;
    }

    //
    // Set TxPktRdy in order to send the data.
    //
    HWREGB(ui32Base + USB_O_CSRL0 + ui32Endpoint) = ui32TxPktRdy;

    //
    // Success.
    //
    return(0);
}

void USBEndpointDataToggleClear	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Sets the data toggle on an endpoint to zero.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies the endpoint to reset the data toggle.
ui32Flags	specifies whether to access the IN or OUT endpoint.

This function causes the USB controller to clear the data toggle for an endpoint. This call is not valid for endpoint zero and can be made with host or device controllers.

The ui32Flags parameter must be one of USB_EP_HOST_OUT, USB_EP_HOST_IN, USB_EP_DEV_OUT, or USB_EP_DEV_IN.

Returns

None.

Definition at line 1268 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_DEV_IN, USB_EP_HOST_OUT, USB_O_RXCSRL1, USB_O_TXCSRL1, USB_RXCSRL1_CLRDT, and USB_TXCSRL1_CLRDT.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_1) || (ui32Endpoint == USB_EP_2) ||
           (ui32Endpoint == USB_EP_3) || (ui32Endpoint == USB_EP_4) ||
           (ui32Endpoint == USB_EP_5) || (ui32Endpoint == USB_EP_6) ||
           (ui32Endpoint == USB_EP_7));

    //
    // See if the transmit or receive data toggle must be cleared.
    //
    if(ui32Flags & (USB_EP_HOST_OUT | USB_EP_DEV_IN))
    {
        HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
            USB_TXCSRL1_CLRDT;
    }
    else
    {
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
            USB_RXCSRL1_CLRDT;
    }
}

void USBEndpointDMAChannel	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Channel
	)

Sets the DMA channel to use for a specified endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies which endpoint's FIFO address to return.
ui32Channel	specifies which DMA channel to use for which endpoint.

This function is used to configure which DMA channel to use with a specified endpoint. Receive DMA channels can only be used with receive endpoints and transmit DMA channels can only be used with transmit endpoints. As a result, the 3 receive and 3 transmit DMA channels can be mapped to any endpoint other than 0. The values that are passed into the ui32Channel value are the UDMA_CHANNEL_USBEP* values defined in udma.h.

Note

This function only has an effect on microcontrollers that have the ability to change the DMA channel for an endpoint. Calling this function on other devices has no effect.

Returns

None.

Definition at line 3944 of file usb.c.

References ASSERT, HWREG, UDMA_CHANNEL_USBEP3TX, USB0_BASE, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_DMASEL, and USBEPToIndex.

{
    uint32_t ui32Mask;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_1) || (ui32Endpoint == USB_EP_2) ||
           (ui32Endpoint == USB_EP_3) || (ui32Endpoint == USB_EP_4) ||
           (ui32Endpoint == USB_EP_5) || (ui32Endpoint == USB_EP_6) ||
           (ui32Endpoint == USB_EP_7));
    ASSERT(ui32Channel <= UDMA_CHANNEL_USBEP3TX);

    //
    // The input select mask must be shifted into the correct position
    // based on the channel.
    //
    ui32Mask = 0xf << (ui32Channel * 4);

    //
    // Clear out the current selection for the channel.
    //
    ui32Mask = HWREG(ui32Base + USB_O_DMASEL) & (~ui32Mask);

    //
    // The input select is now shifted into the correct position based on the
    // channel.
    //
    ui32Mask |= (USBEPToIndex(ui32Endpoint)) << (ui32Channel * 4);

    //
    // Write the value out to the register.
    //
    HWREG(ui32Base + USB_O_DMASEL) = ui32Mask;
}

void USBEndpointDMAConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Config
	)

Configure the DMA settings for an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Config	specifies the configuration options for an endpoint.

This function configures the DMA settings for a specified endpoint without changing other options that may already be configured. In order for the DMA transfer to be enabled, the USBEndpointDMAEnable() function must be called before starting the DMA transfer. The configuration options are passed in the ui32Config parameter and can have the values described below.

One of the following values to specify direction:

• USB_EP_HOST_OUT or USB_EP_DEV_IN - This setting is used with DMA transfers from memory to the USB controller.
• USB_EP_HOST_IN or USB_EP_DEV_OUT - This setting is used with DMA transfers from the USB controller to memory.

One of the following values:

• USB_EP_DMA_MODE_0(default) - This setting is typically used for transfers that do not span multiple packets or when interrupts are required for each packet.
• USB_EP_DMA_MODE_1 - This setting is typically used for transfers that span multiple packets and do not require interrupts between packets.

Values only used with USB_EP_HOST_OUT or USB_EP_DEV_IN:

• USB_EP_AUTO_SET - This setting is used to allow transmit DMA transfers to automatically be sent when a full packet is loaded into a FIFO. This is needed with USB_EP_DMA_MODE_1 to ensure that packets go out when the FIFO becomes full and the DMA has more data to send.

Values only used with USB_EP_HOST_IN or USB_EP_DEV_OUT:

• USB_EP_AUTO_CLEAR - This setting is used to allow receive DMA transfers to automatically be acknowledged as they are received. This is needed with USB_EP_DMA_MODE_1 to ensure that packets continue to be received and acknowledged when the FIFO is emptied by the DMA transfer.

Values only used with USB_EP_HOST_IN:

• USB_EP_AUTO_REQUEST - This setting is used to allow receive DMA transfers to automatically request a new IN transaction when the previous transfer has emptied the FIFO. This is typically used in conjunction with USB_EP_AUTO_CLEAR so that receive DMA transfers can continue without interrupting the main processor.

Example: Set endpoint 1 receive endpoint to automatically acknowledge request and automatically generate a new IN request in host mode.

//! //
//! // Configure endpoint 1 for receiving multiple packets using DMA.
//! //
//! USBEndpointDMAConfigSet(USB0_BASE, USB_EP_1, USB_EP_HOST_IN |
//!                                              USB_EP_DMA_MODE_1 |
//!                                              USB_EP_AUTO_CLEAR |
//!                                              USB_EP_AUTO_REQUEST);
//! 

\b Example: Set endpoint 2 transmit endpoint to automatically send each
packet in host mode when spanning multiple packets.

//! //
//! // Configure endpoint 1 for transmitting multiple packets using DMA.
//! //
//! USBEndpointDMAConfigSet(USB0_BASE, USB_EP_2, USB_EP_HOST_OUT |
//!                                              USB_EP_DMA_MODE_1 |
//!                                              USB_EP_AUTO_SET);
//! 

\return None.  

Definition at line 2574 of file usb.c.

References EP_OFFSET, HWREGB, USB_EP_AUTO_CLEAR, USB_EP_AUTO_REQUEST, USB_EP_AUTO_SET, USB_EP_DMA_MODE_1, USB_EP_HOST_OUT, USB_O_RXCSRH1, USB_O_TXCSRH1, USB_RXCSRH1_AUTOCL, USB_RXCSRH1_AUTORQ, USB_RXCSRH1_DMAMOD, USB_TXCSRH1_AUTOSET, and USB_TXCSRH1_DMAMOD.

{
    uint32_t ui32NewConfig;

    if(ui32Config & USB_EP_HOST_OUT)
    {
        //
        // Clear mode and DMA enable.
        //
        ui32NewConfig =
            (HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRH1) &
             ~(USB_TXCSRH1_DMAMOD | USB_TXCSRH1_AUTOSET));

        if(ui32Config & USB_EP_DMA_MODE_1)
        {
            ui32NewConfig |= USB_TXCSRH1_DMAMOD;
        }

        if(ui32Config & USB_EP_AUTO_SET)
        {
            ui32NewConfig |= USB_TXCSRH1_AUTOSET;
        }

        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRH1) =
            ui32NewConfig;
    }
    else
    {
        ui32NewConfig =
            (HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRH1) &
             ~(USB_RXCSRH1_AUTORQ | USB_RXCSRH1_AUTOCL | USB_RXCSRH1_DMAMOD));

        if(ui32Config & USB_EP_DMA_MODE_1)
        {
            ui32NewConfig |= USB_RXCSRH1_DMAMOD;
        }

        if(ui32Config & USB_EP_AUTO_CLEAR)
        {
            ui32NewConfig |= USB_RXCSRH1_AUTOCL;
        }
        if(ui32Config & USB_EP_AUTO_REQUEST)
        {
            ui32NewConfig |= USB_RXCSRH1_AUTORQ;
        }
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRH1) =
            ui32NewConfig;
    }
}

void USBEndpointDMADisable	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Disable DMA on a specified endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	specifies which direction to disable.

This function disables DMA on a specified endpoint to allow non-DMA USB transactions to generate interrupts normally. The ui32Flags parameter must be USB_EP_DEV_IN or USB_EP_DEV_OUT; all other bits are ignored.

Returns

None.

Definition at line 2687 of file usb.c.

References EP_OFFSET, HWREGB, USB_EP_DEV_IN, USB_O_RXCSRH1, USB_O_TXCSRH1, USB_RXCSRH1_DMAEN, and USB_TXCSRH1_DMAEN.

{
    //
    // If this was a request to disable DMA on the IN portion of the endpoint
    // then handle it.
    //
    if(ui32Flags & USB_EP_DEV_IN)
    {
        //
        // Just disable DMA leave the mode setting.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRH1) &=
            ~USB_TXCSRH1_DMAEN;
    }
    else
    {
        //
        // Just disable DMA leave the mode setting.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRH1) &=
            ~USB_RXCSRH1_DMAEN;
    }
}

void USBEndpointDMAEnable	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Enable DMA on a specified endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	specifies which direction and what mode to use when enabling DMA.

This function enables DMA on a specified endpoint and configures the mode according to the values in the ui32Flags parameter. The ui32Flags parameter must have USB_EP_DEV_IN or USB_EP_DEV_OUT set. Once this function is called the only DMA or error interrupts are generated by the USB controller.

Note

If this function is called when an endpoint is configured in DMA mode 0 the USB controller does not generate an interrupt.

Returns

None.

Definition at line 2647 of file usb.c.

References EP_OFFSET, HWREGB, USB_EP_DEV_IN, USB_O_RXCSRH1, USB_O_TXCSRH1, USB_RXCSRH1_DMAEN, and USB_TXCSRH1_DMAEN.

{
    //
    // See if the transmit DMA is being enabled.
    //
    if(ui32Flags & USB_EP_DEV_IN)
    {
        //
        // Enable DMA on the transmit endpoint.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRH1) |=
            USB_TXCSRH1_DMAEN;
    }
    else
    {
        //
        // Enable DMA on the receive endpoint.
        //
        HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRH1) |=
            USB_RXCSRH1_DMAEN;
    }
}

void USBEndpointPacketCountSet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Count
	)

Sets the number of packets to request when transferring multiple bulk packets.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint index to target for this write.
ui32Count	is the number of packets to request.

This function sets the number of consecutive bulk packets to request when transferring multiple bulk packets with DMA.

Note

This feature is not available on all Tiva devices. Please check the data sheet to determine if the USB controller has a DMA controller or if it must use the uDMA controller for DMA transfers.

Returns

None.

Definition at line 4192 of file usb.c.

References HWREG, USB_O_RQPKTCOUNT1, and USBEPToIndex.

{
    HWREG(ui32Base + USB_O_RQPKTCOUNT1 +
          (0x4 * (USBEPToIndex(ui32Endpoint) - 1))) = ui32Count;
}

uint32_t USBEndpointStatus	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint
	)

Returns the current status of an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.

This function returns the status of a specified endpoint. If any of these status bits must be cleared, then the USBDevEndpointStatusClear() or the USBHostEndpointStatusClear() functions must be called.

The following are the status flags for host mode:

• USB_HOST_IN_PID_ERROR - PID error on the specified endpoint.
• USB_HOST_IN_NOT_COMP - The device failed to respond to an IN request.
• USB_HOST_IN_STALL - A stall was received on an IN endpoint.
• USB_HOST_IN_DATA_ERROR - There was a CRC or bit-stuff error on an IN endpoint in Isochronous mode.
• USB_HOST_IN_NAK_TO - NAKs received on this IN endpoint for more than the specified timeout period.
• USB_HOST_IN_ERROR - Failed to communicate with a device using this IN endpoint.
• USB_HOST_IN_FIFO_FULL - This IN endpoint's FIFO is full.
• USB_HOST_IN_PKTRDY - Data packet ready on this IN endpoint.
• USB_HOST_OUT_NAK_TO - NAKs received on this OUT endpoint for more than the specified timeout period.
• USB_HOST_OUT_NOT_COMP - The device failed to respond to an OUT request.
• USB_HOST_OUT_STALL - A stall was received on this OUT endpoint.
• USB_HOST_OUT_ERROR - Failed to communicate with a device using this OUT endpoint.
• USB_HOST_OUT_FIFO_NE - This endpoint's OUT FIFO is not empty.
• USB_HOST_OUT_PKTPEND - The data transfer on this OUT endpoint has not completed.
• USB_HOST_EP0_NAK_TO - NAKs received on endpoint zero for more than the specified timeout period.
• USB_HOST_EP0_ERROR - The device failed to respond to a request on endpoint zero.
• USB_HOST_EP0_IN_STALL - A stall was received on endpoint zero for an IN transaction.
• USB_HOST_EP0_IN_PKTRDY - Data packet ready on endpoint zero for an IN transaction.

The following are the status flags for device mode:

• USB_DEV_OUT_SENT_STALL - A stall was sent on this OUT endpoint.
• USB_DEV_OUT_DATA_ERROR - There was a CRC or bit-stuff error on an OUT endpoint.
• USB_DEV_OUT_OVERRUN - An OUT packet was not loaded due to a full FIFO.
• USB_DEV_OUT_FIFO_FULL - The OUT endpoint's FIFO is full.
• USB_DEV_OUT_PKTRDY - There is a data packet ready in the OUT endpoint's FIFO.
• USB_DEV_IN_NOT_COMP - A larger packet was split up, more data to come.
• USB_DEV_IN_SENT_STALL - A stall was sent on this IN endpoint.
• USB_DEV_IN_UNDERRUN - Data was requested on the IN endpoint and no data was ready.
• USB_DEV_IN_FIFO_NE - The IN endpoint's FIFO is not empty.
• USB_DEV_IN_PKTPEND - The data transfer on this IN endpoint has not completed.
• USB_DEV_EP0_SETUP_END - A control transaction ended before Data End condition was sent.
• USB_DEV_EP0_SENT_STALL - A stall was sent on endpoint zero.
• USB_DEV_EP0_IN_PKTPEND - The data transfer on endpoint zero has not completed.
• USB_DEV_EP0_OUT_PKTRDY - There is a data packet ready in endpoint zero's OUT FIFO.

Returns

The current status flags for the endpoint depending on mode.

Definition at line 994 of file usb.c.

References ASSERT, EP_OFFSET, HWREGH, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_RXCSRL1, USB_O_TXCSRL1, and USB_RX_EPSTATUS_SHIFT.

{
    uint32_t ui32Status;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Get the TX portion of the endpoint status.
    //
    ui32Status = HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRL1);

    //
    // Get the RX portion of the endpoint status.
    //
    ui32Status |=
        ((HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRL1)) <<
         USB_RX_EPSTATUS_SHIFT);

    //
    // Return the endpoint status.
    //
    return(ui32Status);
}

uint32_t USBFIFOAddrGet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint
	)

Returns the absolute FIFO address for a specified endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies which endpoint's FIFO address to return.

This function returns the actual physical address of the FIFO. This address is needed when the USB is going to be used with the uDMA controller and the source or destination address must be set to the physical FIFO address for a specified endpoint. This function can also be used to provide the physical address to manually read data from an endpoints FIFO.

Returns

None.

Definition at line 3843 of file usb.c.

References USB_O_FIFO0.

{
    //
    // Return the FIFO address for this endpoint.
    //
    return(ui32Base + USB_O_FIFO0 + (ui32Endpoint >> 2));
}

void USBFIFOConfigGet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t *	pui32FIFOAddress,
		uint32_t *	pui32FIFOSize,
		uint32_t	ui32Flags
	)

Returns the FIFO configuration for an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
pui32FIFOAddress	is the starting address for the FIFO.
pui32FIFOSize	is the size of the FIFO as specified by one of the USB_FIFO_SZ_ values.
ui32Flags	specifies what information to retrieve from the FIFO configuration.

This function returns the starting address and size of the FIFO for a specified endpoint. Endpoint zero does not have a dynamically configurable FIFO, so this function must not be called for endpoint zero. The ui32Flags parameter specifies whether the endpoint's OUT or IN FIFO must be read. If in host mode, the ui32Flags parameter must be USB_EP_HOST_OUT or USB_EP_HOST_IN, and if in device mode, the ui32Flags parameter must be either USB_EP_DEV_OUT or USB_EP_DEV_IN.

Returns

None.

Definition at line 2456 of file usb.c.

References _USBIndexRead(), ASSERT, USB0_BASE, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_DEV_IN, USB_EP_HOST_OUT, USB_O_RXFIFOADD, USB_O_RXFIFOSZ, USB_O_TXFIFOADD, and USB_O_TXFIFOSZ.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_1) || (ui32Endpoint == USB_EP_2) ||
           (ui32Endpoint == USB_EP_3) || (ui32Endpoint == USB_EP_4) ||
           (ui32Endpoint == USB_EP_5) || (ui32Endpoint == USB_EP_6) ||
           (ui32Endpoint == USB_EP_7));

    //
    // See if the transmit or receive FIFO is being configured.
    //
    if(ui32Flags & (USB_EP_HOST_OUT | USB_EP_DEV_IN))
    {
        //
        // Get the transmit FIFO location and size for this endpoint.
        //
        *pui32FIFOAddress = (_USBIndexRead(ui32Base, ui32Endpoint >> 4,
                                           (uint32_t)USB_O_TXFIFOADD,
                                           2)) << 3;
        *pui32FIFOSize = _USBIndexRead(ui32Base, ui32Endpoint >> 4,
                                       (uint32_t)USB_O_TXFIFOSZ, 1);
    }
    else
    {
        //
        // Get the receive FIFO location and size for this endpoint.
        //
        *pui32FIFOAddress = (_USBIndexRead(ui32Base, ui32Endpoint >> 4,
                                           (uint32_t)USB_O_RXFIFOADD,
                                           2)) << 3;
        *pui32FIFOSize = _USBIndexRead(ui32Base, ui32Endpoint >> 4,
                                       (uint32_t)USB_O_RXFIFOSZ, 1);
    }
}

Here is the call graph for this function:

void USBFIFOConfigSet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32FIFOAddress,
		uint32_t	ui32FIFOSize,
		uint32_t	ui32Flags
	)

Sets the FIFO configuration for an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32FIFOAddress	is the starting address for the FIFO.
ui32FIFOSize	is the size of the FIFO specified by one of the USB_FIFO_SZ_ values.
ui32Flags	specifies what information to set in the FIFO configuration.

This function configures the starting FIFO RAM address and size of the FIFO for a specified endpoint. Endpoint zero does not have a dynamically configurable FIFO, so this function must not be called for endpoint zero. The ui32FIFOSize parameter must be one of the values in the USB_FIFO_SZ_ values.

The ui32FIFOAddress value must 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 starts 64 bytes into the USB controller's FIFO memory. The ui32Flags value specifies whether the endpoint's OUT or IN FIFO must be configured. If in host mode, use USB_EP_HOST_OUT or USB_EP_HOST_IN, and if in device mode, use USB_EP_DEV_OUT or USB_EP_DEV_IN.

Returns

None.

Definition at line 2393 of file usb.c.

References _USBIndexWrite(), ASSERT, USB0_BASE, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_DEV_IN, USB_EP_HOST_OUT, USB_O_RXFIFOADD, USB_O_RXFIFOSZ, USB_O_TXFIFOADD, and USB_O_TXFIFOSZ.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_1) || (ui32Endpoint == USB_EP_2) ||
           (ui32Endpoint == USB_EP_3) || (ui32Endpoint == USB_EP_4) ||
           (ui32Endpoint == USB_EP_5) || (ui32Endpoint == USB_EP_6) ||
           (ui32Endpoint == USB_EP_7));

    //
    // See if the transmit or receive FIFO is being configured.
    //
    if(ui32Flags & (USB_EP_HOST_OUT | USB_EP_DEV_IN))
    {
        //
        // Set the transmit FIFO location and size for this endpoint.
        //
        _USBIndexWrite(ui32Base, ui32Endpoint >> 4, USB_O_TXFIFOSZ,
                       ui32FIFOSize, 1);
        _USBIndexWrite(ui32Base, ui32Endpoint >> 4, USB_O_TXFIFOADD,
                       ui32FIFOAddress >> 3, 2);
    }
    else
    {
        //
        // Set the receive FIFO location and size for this endpoint.
        //
        _USBIndexWrite(ui32Base, ui32Endpoint >> 4, USB_O_RXFIFOSZ,
                       ui32FIFOSize, 1);
        _USBIndexWrite(ui32Base, ui32Endpoint >> 4, USB_O_RXFIFOADD,
                       ui32FIFOAddress >> 3, 2);
    }
}

Here is the call graph for this function:

void USBFIFOFlush	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Forces a flush of an endpoint's FIFO.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	specifies if the IN or OUT endpoint is accessed.

This function forces the USB controller to flush out the data in the FIFO. The function can be called with either host or device controllers and requires the ui32Flags parameter be one of USB_EP_HOST_OUT, USB_EP_HOST_IN, USB_EP_DEV_OUT, or USB_EP_DEV_IN.

Returns

None.

Definition at line 3144 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRH0_FLUSH, USB_CSRL0_RXRDY, USB_CSRL0_TXRDY, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_DEV_IN, USB_EP_HOST_OUT, USB_O_CSRH0, USB_O_CSRL0, USB_O_RXCSRL1, USB_O_TXCSRL1, USB_RXCSRL1_FLUSH, USB_RXCSRL1_RXRDY, USB_TXCSRL1_FLUSH, and USB_TXCSRL1_TXRDY.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Endpoint zero has a different register set for FIFO flushing.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Nothing in the FIFO if neither of these bits are set.
        //
        if((HWREGB(ui32Base + USB_O_CSRL0) &
            (USB_CSRL0_RXRDY | USB_CSRL0_TXRDY)) != 0)
        {
            //
            // Hit the Flush FIFO bit.
            //
            HWREGB(ui32Base + USB_O_CSRH0) = USB_CSRH0_FLUSH;
        }
    }
    else
    {
        //
        // Only reset the IN or OUT FIFO.
        //
        if(ui32Flags & (USB_EP_HOST_OUT | USB_EP_DEV_IN))
        {
            //
            // Make sure the FIFO is not empty.
            //
            if(HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) &
               USB_TXCSRL1_TXRDY)
            {
                //
                // Hit the Flush FIFO bit.
                //
                HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
                    USB_TXCSRL1_FLUSH;
            }
        }
        else
        {
            //
            // Make sure that the FIFO is not empty.
            //
            if(HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) &
               USB_RXCSRL1_RXRDY)
            {
                //
                // Hit the Flush FIFO bit.
                //
                HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) |=
                    USB_RXCSRL1_FLUSH;
            }
        }
    }
}

uint32_t USBFrameNumberGet

(

uint32_t

ui32Base

)

Gets the current frame number.

Parameters

ui32Base

specifies the USB module base address.

This function returns the last frame number received.

Returns

The last frame number received.

Definition at line 3777 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, and USB_O_FRAME.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Return the most recent frame number.
    //
    return(HWREGH(ui32Base + USB_O_FRAME));
}

void USBHighSpeed	(	uint32_t	ui32Base,
		bool	bEnable
	)

Enables or disables USB high-speed negotiation.

Parameters

ui32Base	specifies the USB module base address.
bEnable	specifies whether to enable or disable high-speed negotiation.

High-speed negotiations for both host and device mode are enabled when this function is called with the bEnable parameter set to true. In device mode this causes the device to negotiate for high speed when the USB controller receives a reset from the host. In host mode, the USB host enables high-speed negotiations when resetting the connected device. If bEnable is set to false the controller only operates only in full-speed or low-speed.

Example: Enable USB high-speed mode.

//! //
//! // Enable USB high-speed mode.
//! //
//! USBHighSpeed(USB0_BASE, true);
//! 

\note This feature is not available on all Tiva devices and should only be
called when the USB is connected to an external ULPI PHY.  Please
check the data sheet to determine if the USB controller can interface with
a ULPI PHY.

\return None.  

Definition at line 318 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_O_POWER, and USB_POWER_HSENAB.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    if(bEnable)
    {
        //
        // Enable high speed mode negotiations in hosts or device mode.
        //
        HWREGB(ui32Base + USB_O_POWER) |= USB_POWER_HSENAB;
    }
    else
    {
        //
        // Enable high speed mode negotiations in hosts or device mode.
        //
        HWREGB(ui32Base + USB_O_POWER) &= ~USB_POWER_HSENAB;
    }
}

uint32_t USBHostAddrGet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Gets the current functional device address for an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	determines if this is an IN or an OUT endpoint.

This function returns the current functional address that an endpoint is using to communicate with a device. The ui32Flags parameter determines if the IN or OUT endpoint's device address is returned.

Note

This function must only be called in host mode.

Returns

Returns the current function address being used by an endpoint.

Definition at line 3413 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_HOST_OUT, and USB_O_TXFUNCADDR0.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // See if the transmit or receive address is returned.
    //
    if(ui32Flags & USB_EP_HOST_OUT)
    {
        //
        // Return this endpoint's transmit address.
        //
        return(HWREGB(ui32Base + USB_O_TXFUNCADDR0 + (ui32Endpoint >> 1)));
    }
    else
    {
        //
        // Return this endpoint's receive address.
        //
        return(HWREGB(ui32Base + USB_O_TXFUNCADDR0 + 4 + (ui32Endpoint >> 1)));
    }
}

void USBHostAddrSet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Addr,
		uint32_t	ui32Flags
	)

Sets the functional address for the device that is connected to an endpoint in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Addr	is the functional address for the controller to use for this endpoint.
ui32Flags	determines if this is an IN or an OUT endpoint.

This function configures the functional address for a device that is using this endpoint for communication. This ui32Addr parameter is the address of the target device that this endpoint is communicating with. The ui32Flags parameter indicates if the IN or OUT endpoint is set.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3363 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_HOST_OUT, and USB_O_TXFUNCADDR0.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // See if the transmit or receive address is set.
    //
    if(ui32Flags & USB_EP_HOST_OUT)
    {
        //
        // Set the transmit address.
        //
        HWREGB(ui32Base + USB_O_TXFUNCADDR0 + (ui32Endpoint >> 1)) = ui32Addr;
    }
    else
    {
        //
        // Set the receive address.
        //
        HWREGB(ui32Base + USB_O_TXFUNCADDR0 + 4 + (ui32Endpoint >> 1)) =
            ui32Addr;
    }
}

void USBHostEndpointConfig	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32MaxPayload,
		uint32_t	ui32NAKPollInterval,
		uint32_t	ui32TargetEndpoint,
		uint32_t	ui32Flags
	)

Sets the base configuration for a host endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32MaxPayload	is the maximum payload for this endpoint.
ui32NAKPollInterval	is the either the NAK timeout limit or the polling interval, depending on the type of endpoint.
ui32TargetEndpoint	is the endpoint that the host endpoint is targeting.
ui32Flags	are used to configure other endpoint settings.

This function sets the basic configuration for the transmit or receive portion of an endpoint in host mode. The ui32Flags parameter determines some of the configuration while the other parameters provide the rest. The ui32Flags parameter determines whether this is an IN endpoint (USB_EP_HOST_IN or USB_EP_DEV_IN) or an OUT endpoint (USB_EP_HOST_OUT or USB_EP_DEV_OUT), whether this is a Full speed endpoint (USB_EP_SPEED_FULL) or a Low speed endpoint (USB_EP_SPEED_LOW).

The USB_EP_MODE_ flags control the type of the endpoint.

• USB_EP_MODE_CTRL is a control endpoint.
• USB_EP_MODE_ISOC is an isochronous endpoint.
• USB_EP_MODE_BULK is a bulk endpoint.
• USB_EP_MODE_INT is an interrupt endpoint.

The ui32NAKPollInterval parameter has different meanings based on the USB_EP_MODE value and whether or not this call is being made for endpoint zero or another endpoint. For endpoint zero or any Bulk endpoints, this value always indicates the number of frames to allow a device to NAK before considering it a timeout. If this endpoint is an isochronous or interrupt endpoint, this value is the polling interval for this endpoint.

For interrupt endpoints, the polling interval is the number of frames between interrupt IN requests to an endpoint and has a range of 1 to 255. For isochronous endpoints this value represents a polling interval of 2 ^ (ui32NAKPollInterval - 1) frames. When used as a NAK timeout, the ui32NAKPollInterval value specifies 2 ^ (ui32NAKPollInterval - 1) frames before issuing a time out.

There are two special time out values that can be specified when setting the ui32NAKPollInterval value. The first is MAX_NAK_LIMIT, which is the maximum value that can be passed in this variable. The other is DISABLE_NAK_LIMIT, which indicates that there is no limit on the number of NAKs.

The USB_EP_DMA_MODE_ flags determine the type of DMA access to the endpoint data FIFOs. The choice of the DMA mode depends on how the DMA controller is configured and how it is being used. See the ``Using USB with the uDMA Controller'' or the ''Using the integrated USB DMA Controller'' section for more information on DMA configuration depending on the type of DMA that is supported by the USB controller.

When configuring the OUT portion of an endpoint, the USB_EP_AUTO_SET bit is specified to cause the transmission of data on the USB bus to start as soon as the number of bytes specified by ui32MaxPayload has been written into the OUT FIFO for this endpoint.

When configuring the IN portion of an endpoint, the USB_EP_AUTO_REQUEST bit can be specified to trigger the request for more data once the FIFO has been drained enough to fit ui32MaxPayload bytes. The USB_EP_AUTO_CLEAR bit can be used to clear the data packet ready flag automatically once the data has been read from the FIFO. If this option is not used, this flag must be manually cleared via a call to USBDevEndpointStatusClear() or USBHostEndpointStatusClear().

For interrupt endpoints in low or full speed mode, the polling interval (ui32NAKPollInterval) is the number of frames between interrupt IN requests to an endpoint and has a range of 1 to 255. For interrupt endpoints in high speed mode the polling interval is 2 ^ (ui32NAKPollInterval - 1) microframes between interrupt IN requests to an endpoint and has a range of 1 to 16.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 1680 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, HWREGH, MAX_NAK_LIMIT, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_AUTO_CLEAR, USB_EP_AUTO_REQUEST, USB_EP_AUTO_SET, USB_EP_DMA_MODE_0, USB_EP_DMA_MODE_1, USB_EP_HOST_OUT, USB_EP_MODE_BULK, USB_EP_MODE_CTRL, USB_EP_MODE_INT, USB_EP_MODE_ISOC, USB_EP_MODE_MASK, USB_EP_SPEED_FULL, USB_EP_SPEED_HIGH, USB_O_NAKLMT, USB_O_RXCSRH1, USB_O_RXINTERVAL1, USB_O_RXMAXP1, USB_O_RXTYPE1, USB_O_TXCSRH1, USB_O_TXINTERVAL1, USB_O_TXMAXP1, USB_O_TXTYPE1, USB_O_TYPE0, USB_RXCSRH1_AUTOCL, USB_RXCSRH1_AUTORQ, USB_RXCSRH1_DMAEN, USB_RXCSRH1_DMAMOD, USB_TXCSRH1_AUTOSET, USB_TXCSRH1_DMAEN, USB_TXCSRH1_DMAMOD, USB_TXTYPE1_PROTO_BULK, USB_TXTYPE1_PROTO_CTRL, USB_TXTYPE1_PROTO_INT, USB_TXTYPE1_PROTO_ISOC, USB_TXTYPE1_SPEED_FULL, USB_TXTYPE1_SPEED_HIGH, USB_TXTYPE1_SPEED_LOW, USB_TYPE0_SPEED_FULL, USB_TYPE0_SPEED_HIGH, and USB_TYPE0_SPEED_LOW.

{
    uint32_t ui32Register;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));
    ASSERT(ui32NAKPollInterval <= MAX_NAK_LIMIT);

    //
    // Endpoint zero is configured differently than the other endpoints, so see
    // if this is endpoint zero.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Set the NAK timeout.
        //
        HWREGB(ui32Base + USB_O_NAKLMT) = ui32NAKPollInterval;

        //
        // Set the transfer type information.
        //
        //
        // Set the speed of this endpoint.
        //
        if(ui32Flags & USB_EP_SPEED_HIGH)
        {
            HWREGB(ui32Base + USB_O_TYPE0) = USB_TYPE0_SPEED_HIGH;
        }
        else if(ui32Flags & USB_EP_SPEED_FULL)
        {
            HWREGB(ui32Base + USB_O_TYPE0) = USB_TYPE0_SPEED_FULL;
        }
        else
        {
            HWREGB(ui32Base + USB_O_TYPE0) = USB_TYPE0_SPEED_LOW;
        }
    }
    else
    {
        //
        // Start with the target endpoint.
        //
        ui32Register = ui32TargetEndpoint;

        //
        // Set the speed for the device using this endpoint.
        //
        if(ui32Flags & USB_EP_SPEED_HIGH)
        {
            ui32Register |= USB_TXTYPE1_SPEED_HIGH;
        }
        else if(ui32Flags & USB_EP_SPEED_FULL)
        {
            ui32Register |= USB_TXTYPE1_SPEED_FULL;
        }
        else
        {
            ui32Register |= USB_TXTYPE1_SPEED_LOW;
        }

        //
        // Set the protocol for the device using this endpoint.
        //
        switch(ui32Flags & USB_EP_MODE_MASK)
        {
            //
            // The bulk protocol is being used.
            //
            case USB_EP_MODE_BULK:
            {
                ui32Register |= USB_TXTYPE1_PROTO_BULK;
                break;
            }

            //
            // The isochronous protocol is being used.
            //
            case USB_EP_MODE_ISOC:
            {
                ui32Register |= USB_TXTYPE1_PROTO_ISOC;
                break;
            }

            //
            // The interrupt protocol is being used.
            //
            case USB_EP_MODE_INT:
            {
                ui32Register |= USB_TXTYPE1_PROTO_INT;
                break;
            }

            //
            // The control protocol is being used.
            //
            case USB_EP_MODE_CTRL:
            {
                ui32Register |= USB_TXTYPE1_PROTO_CTRL;
                break;
            }
        }

        //
        // See if the transmit or receive endpoint is being configured.
        //
        if(ui32Flags & USB_EP_HOST_OUT)
        {
            //
            // Set the transfer type information.
            //
            HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXTYPE1) =
                ui32Register;

            //
            // Set the NAK timeout or polling interval.
            //
            HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXINTERVAL1) =
                ui32NAKPollInterval;

            //
            // Set the Maximum Payload per transaction.
            //
            HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXMAXP1) =
                ui32MaxPayload;

            //
            // Set the transmit control value to zero.
            //
            ui32Register = 0;

            //
            // Allow auto setting of TxPktRdy when max packet size has been
            // loaded into the FIFO.
            //
            if(ui32Flags & USB_EP_AUTO_SET)
            {
                ui32Register |= USB_TXCSRH1_AUTOSET;
            }

            //
            // Configure the DMA Mode.
            //
            if(ui32Flags & USB_EP_DMA_MODE_1)
            {
                ui32Register |= USB_TXCSRH1_DMAEN | USB_TXCSRH1_DMAMOD;
            }
            else if(ui32Flags & USB_EP_DMA_MODE_0)
            {
                ui32Register |= USB_TXCSRH1_DMAEN;
            }

            //
            // Write out the transmit control value.
            //
            HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXCSRH1) =
                (uint8_t)ui32Register;
        }
        else
        {
            //
            // Set the transfer type information.
            //
            HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXTYPE1) =
                ui32Register;

            //
            // Set the NAK timeout or polling interval.
            //
            HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXINTERVAL1) =
                ui32NAKPollInterval;

            //
            // Set the Maximum Payload per transaction.
            //
            HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXMAXP1) =
                ui32MaxPayload;

            //
            // Set the receive control value to zero.
            //
            ui32Register = 0;

            //
            // Allow auto clearing of RxPktRdy when packet of size max packet
            // has been unloaded from the FIFO.
            //
            if(ui32Flags & USB_EP_AUTO_CLEAR)
            {
                ui32Register |= USB_RXCSRH1_AUTOCL;
            }

            //
            // Allow auto generation of DMA requests.
            //
            if(ui32Flags & USB_EP_AUTO_REQUEST)
            {
                ui32Register |= USB_RXCSRH1_AUTORQ;
            }

            //
            // Configure the DMA Mode.
            //
            if(ui32Flags & USB_EP_DMA_MODE_1)
            {
                ui32Register |= USB_RXCSRH1_DMAEN | USB_RXCSRH1_DMAMOD;
            }
            else if(ui32Flags & USB_EP_DMA_MODE_0)
            {
                ui32Register |= USB_RXCSRH1_DMAEN;
            }

            //
            // Write out the receive control value.
            //
            HWREGB(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXCSRH1) =
                (uint8_t)ui32Register;
        }
    }
}

void USBHostEndpointDataAck	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint
	)

Acknowledge that data was read from the specified endpoint's FIFO in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.

This function acknowledges that the data was read from the endpoint's FIFO. This call is used if processing is required between reading the data and acknowledging that the data has been read.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 2947 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRL0_RXRDY, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_RXCSRL1, and USB_RXCSRL1_RXRDY.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Clear RxPktRdy.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        HWREGB(ui32Base + USB_O_CSRL0) &= ~USB_CSRL0_RXRDY;
    }
    else
    {
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~(USB_RXCSRL1_RXRDY);
    }
}

void USBHostEndpointDataToggle	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		bool	bDataToggle,
		uint32_t	ui32Flags
	)

Sets the value data toggle on an endpoint in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies the endpoint to reset the data toggle.
bDataToggle	specifies whether to set the state to DATA0 or DATA1.
ui32Flags	specifies whether to set the IN or OUT endpoint.

This function is used to force the state of the data toggle in host mode. If the value passed in the bDataToggle parameter is false, then the data toggle is set to the DATA0 state, and if it is true it is set to the DATA1 state. The ui32Flags parameter can be USB_EP_HOST_IN or USB_EP_HOST_OUT to access the desired portion of this endpoint. The ui32Flags parameter is ignored for endpoint zero.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 1173 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_CSRH0_DT, USB_CSRH0_DTWE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_HOST_IN, USB_O_CSRH0, USB_O_RXCSRH1, USB_O_TXCSRH1, USB_RXCSRH1_DT, USB_RXCSRH1_DTWE, USB_TXCSRH1_DT, and USB_TXCSRH1_DTWE.

{
    uint32_t ui32DataToggle;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // The data toggle defaults to DATA0.
    //
    ui32DataToggle = 0;

    //
    // See if the data toggle must be set to DATA1.
    //
    if(bDataToggle)
    {
        //
        // Select the data toggle bit based on the endpoint.
        //
        if(ui32Endpoint == USB_EP_0)
        {
            ui32DataToggle = USB_CSRH0_DT;
        }
        else if(ui32Flags == USB_EP_HOST_IN)
        {
            ui32DataToggle = USB_RXCSRH1_DT;
        }
        else
        {
            ui32DataToggle = USB_TXCSRH1_DT;
        }
    }

    //
    // Set the data toggle based on the endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        //
        // Set the write enable and the bit value for endpoint zero.
        //
        HWREGB(ui32Base + USB_O_CSRH0) =
            ((HWREGB(ui32Base + USB_O_CSRH0) &
              ~(USB_CSRH0_DTWE | USB_CSRH0_DT)) |
             (ui32DataToggle | USB_CSRH0_DTWE));
    }
    else if(ui32Flags == USB_EP_HOST_IN)
    {
        //
        // Set the Write enable and the bit value for an IN endpoint.
        //
        HWREGB(ui32Base + USB_O_RXCSRH1 + EP_OFFSET(ui32Endpoint)) =
            ((HWREGB(ui32Base + USB_O_RXCSRH1 + EP_OFFSET(ui32Endpoint)) &
              ~(USB_RXCSRH1_DTWE | USB_RXCSRH1_DT)) |
             (ui32DataToggle | USB_RXCSRH1_DTWE));
    }
    else
    {
        //
        // Set the Write enable and the bit value for an OUT endpoint.
        //
        HWREGB(ui32Base + USB_O_TXCSRH1 + EP_OFFSET(ui32Endpoint)) =
            ((HWREGB(ui32Base + USB_O_TXCSRH1 + EP_OFFSET(ui32Endpoint)) &
              ~(USB_TXCSRH1_DTWE | USB_TXCSRH1_DT)) |
             (ui32DataToggle | USB_TXCSRH1_DTWE));
    }
}

void USBHostEndpointPing	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		bool	bEnable
	)

Enables or disables ping tokens for an endpoint using high-speed control transfers in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	specifies the endpoint to enable/disable ping tokens.
bEnable	specifies whether enable or disable ping tokens.

This function configures the USB controller to either send or not send ping tokens during the data and status phase of high speed control transfers. The only supported value for ui32Endpoint is USB_EP_0 because all control transfers are handled using this endpoint. If the bEnable is true then ping tokens are enabled, if false then ping tokens are disabled. This must be used if the controller must support communications with devices that do not support ping tokens in high speed mode.

Example: Disable ping transactions in host mode on endpoint 0.

//! //
//! // Disable ping transaction on endpoint 0.
//! //
//! USBHostEndpointPing(USB0_BASE, USB_EP_0, false);
//! 

\note This function must only be called in host mode.

\return None.  

Definition at line 1328 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_CSRH0_DISPING, USB_EP_0, and USB_O_CSRH0.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0));

    //
    // Handle the endpoint 0 case separately.
    //
    if(bEnable)
    {
        HWREGB(USB0_BASE + USB_O_CSRH0) &= ~USB_CSRH0_DISPING;
    }
    else
    {
        HWREGB(USB0_BASE + USB_O_CSRH0) |= USB_CSRH0_DISPING;
    }
}

void USBHostEndpointSpeed	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Changes the speed of the connection for a host endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	are used to configure other endpoint settings.

This function sets the USB speed for an IN or OUT endpoint in host mode. The ui32Flags parameter specifies the speed using one of the following values: USB_EP_SPEED_LOW, USB_EP_SPEED_FULL, or USB_EP_SPEED_HIGH. The ui32Flags parameter also specifies which direction is set by adding the logical OR in either USB_EP_HOST_IN or USB_EP_HOST_OUT. All other flags are ignored. This function is typically only used for endpoint 0, but could be used with other endpoints as well.

Example: Set host transactions on endpoint 0 to full speed..

//! //
//! // Set host endpoint 0 transactions to full speed.
//! //
//! USBHostEndpointSpeed(USB0_BASE, USB_EP_0, USB_EP_SPEED_FULL);
//! 

\note This function must only be called in host mode.

\return None.  

Definition at line 1940 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, HWREGH, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_HOST_OUT, USB_EP_SPEED_FULL, USB_EP_SPEED_HIGH, USB_O_RXTYPE1, USB_O_TXTYPE1, USB_O_TYPE0, USB_RXTYPE1_SPEED_M, USB_TXTYPE1_SPEED_M, USB_TYPE0_SPEED_FULL, USB_TYPE0_SPEED_HIGH, and USB_TYPE0_SPEED_LOW.

{
    uint32_t ui32Reg;
    uint32_t ui32Speed;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Create the register speed value.
    //
    if(ui32Flags & USB_EP_SPEED_HIGH)
    {
        ui32Speed = USB_TYPE0_SPEED_HIGH;
    }
    else if(ui32Flags & USB_EP_SPEED_FULL)
    {
        ui32Speed = USB_TYPE0_SPEED_FULL;
    }
    else
    {
        ui32Speed = USB_TYPE0_SPEED_LOW;
    }

    //
    // Endpoint 0 is handled differently as it is bi-directional.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        HWREGB(ui32Base + USB_O_TYPE0) = ui32Speed;
    }
    else if(ui32Flags & USB_EP_HOST_OUT)
    {
        //
        // Clear the current speed and set the new speed.
        //
        ui32Reg = (HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXTYPE1) &
                   ~(USB_TXTYPE1_SPEED_M));
        ui32Reg |= ui32Speed;

        HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_TXTYPE1) |= ui32Reg;
    }
    else
    {
        //
        // Clear the current speed and set the new speed.
        //
        ui32Reg = (HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXTYPE1) &
                   ~(USB_RXTYPE1_SPEED_M));
        ui32Reg |= ui32Speed;

        HWREGH(ui32Base + EP_OFFSET(ui32Endpoint) + USB_O_RXTYPE1) |= ui32Reg;
    }
}

void USBHostEndpointStatusClear	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Clears the status bits in this endpoint in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	are the status bits that are cleared.

This function clears the status of any bits that are passed in the ui32Flags parameter. The ui32Flags parameter can take the value returned from the USBEndpointStatus() call.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 1043 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_RXCSRL1, USB_O_TXCSRL1, and USB_RX_EPSTATUS_SHIFT.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Clear the specified flags for the endpoint.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        HWREGB(ui32Base + USB_O_CSRL0) &= ~ui32Flags;
    }
    else
    {
        HWREGB(ui32Base + USB_O_TXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~ui32Flags;
        HWREGB(ui32Base + USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint)) &=
            ~(ui32Flags >> USB_RX_EPSTATUS_SHIFT);
    }
}

uint32_t USBHostHubAddrGet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Flags
	)

Gets the current device hub address for this endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Flags	determines if this is an IN or an OUT endpoint.

This function returns the current hub address that an endpoint is using to communicate with a device. The ui32Flags parameter determines if the device address for the IN or OUT endpoint is returned.

Note

This function must only be called in host mode.

Returns

This function returns the current hub address being used by an endpoint.

Definition at line 3539 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_HOST_OUT, and USB_O_TXHUBADDR0.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // See if the hub transmit or receive address is returned.
    //
    if(ui32Flags & USB_EP_HOST_OUT)
    {
        //
        // Return the hub transmit address for this endpoint.
        //
        return(HWREGB(ui32Base + USB_O_TXHUBADDR0 + (ui32Endpoint >> 1)));
    }
    else
    {
        //
        // Return the hub receive address for this endpoint.
        //
        return(HWREGB(ui32Base + USB_O_TXHUBADDR0 + 4 + (ui32Endpoint >> 1)));
    }
}

void USBHostHubAddrSet	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint,
		uint32_t	ui32Addr,
		uint32_t	ui32Flags
	)

Sets the hub address for the device that is connected to an endpoint.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.
ui32Addr	is the hub address and port for the device using this endpoint. The hub address must be defined in bits 0 through 6 with the port number in bits 8 through 14.
ui32Flags	determines if this is an IN or an OUT endpoint.

This function configures the hub address for a device that is using this endpoint for communication. The ui32Flags parameter determines if the device address for the IN or the OUT endpoint is configured by this call and sets the speed of the downstream device. Valid values are one of USB_EP_HOST_OUT or USB_EP_HOST_IN optionally ORed with USB_EP_SPEED_LOW.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3467 of file usb.c.

References ASSERT, HWREGB, HWREGH, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_EP_HOST_OUT, USB_EP_SPEED_FULL, USB_EP_SPEED_HIGH, USB_O_TXHUBADDR0, USB_O_TYPE0, USB_TYPE0_SPEED_FULL, USB_TYPE0_SPEED_HIGH, and USB_TYPE0_SPEED_LOW.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // See if the hub transmit or receive address is being set.
    //
    if(ui32Flags & USB_EP_HOST_OUT)
    {
        //
        // Set the hub transmit address and port number for this endpoint.
        //
        HWREGH(ui32Base + USB_O_TXHUBADDR0 + (ui32Endpoint >> 1)) = ui32Addr;
    }
    else
    {
        //
        // Set the hub receive address and port number for this endpoint.
        //
        HWREGH(ui32Base + USB_O_TXHUBADDR0 + 4 + (ui32Endpoint >> 1)) =
            ui32Addr;
    }

    //
    // Set the speed of communication for endpoint 0.  This configuration is
    // done here because it changes on a transaction-by-transaction basis for
    // EP0.  For other endpoints, this is set in USBHostEndpointConfig().
    //
    if(ui32Endpoint == USB_EP_0)
    {
        if(ui32Flags & USB_EP_SPEED_FULL)
        {
            HWREGB(ui32Base + USB_O_TYPE0) = USB_TYPE0_SPEED_FULL;
        }
        else if(ui32Flags & USB_EP_SPEED_HIGH)
        {
            HWREGB(ui32Base + USB_O_TYPE0) = USB_TYPE0_SPEED_HIGH;
        }
        else
        {
            HWREGB(ui32Base + USB_O_TYPE0) = USB_TYPE0_SPEED_LOW;
        }
    }
}

void USBHostMode

(

uint32_t

ui32Base

)

Change the mode of the USB controller to host.

Parameters

ui32Base

specifies the USB module base address.

This function changes the mode of the USB controller to host mode.

Note

This function must only be called on microcontrollers that support OTG operation.

Returns

None.

Definition at line 3997 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_GPCS_DEVMODOTG, and USB_O_GPCS.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Force mode in OTG parts that support forcing USB controller mode.
    // This bit is not writable in USB controllers that do not support
    // forcing the mode.  Not setting the USB_GPCS_DEVMOD bit makes this a
    // force of host mode.
    //
    HWREGB(ui32Base + USB_O_GPCS) = USB_GPCS_DEVMODOTG;
}

void USBHostPwrConfig	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Sets the configuration for USB power fault.

Parameters

ui32Base	specifies the USB module base address.
ui32Flags	specifies the configuration of the power fault.

This function controls how the USB controller uses its external power control pins (USBnPFLT and USBnEPEN). The flags specify the power fault level sensitivity, the power fault action, and the power enable level and source.

One of the following can be selected as the power fault level sensitivity:

• USB_HOST_PWRFLT_LOW - An external power fault is indicated by the pin being driven low.
• USB_HOST_PWRFLT_HIGH - An external power fault is indicated by the pin being driven high.

One of the following can be selected as the power fault action:

• USB_HOST_PWRFLT_EP_NONE - No automatic action when power fault detected.
• USB_HOST_PWRFLT_EP_TRI - Automatically tri-state the USBnEPEN pin on a power fault.
• USB_HOST_PWRFLT_EP_LOW - Automatically drive USBnEPEN pin low on a power fault.
• USB_HOST_PWRFLT_EP_HIGH - Automatically drive USBnEPEN pin high on a power fault.

One of the following can be selected as the power enable level and source:

• USB_HOST_PWREN_MAN_LOW - USBnEPEN is driven low by the USB controller when USBHostPwrEnable() is called.
• USB_HOST_PWREN_MAN_HIGH - USBnEPEN is driven high by the USB controller when USBHostPwrEnable() is called.
• USB_HOST_PWREN_AUTOLOW - USBnEPEN is driven low by the USB controller automatically if USBOTGSessionRequest() has enabled a session.
• USB_HOST_PWREN_AUTOHIGH - USBnEPEN is driven high by the USB controller automatically if USBOTGSessionRequest() has enabled a session.

When using the VBUS glitch filter, the USB_HOST_PWREN_FILTER can be addded to ignore small, short drops in VBUS level caused by high power consumption. This feature is mainly used to avoid causing VBUS errors caused by devices with high in-rush current.

Note

This function must only be called on microcontrollers that support host mode or OTG operation. The USB_HOST_PWREN_AUTOLOW and USB_HOST_PWREN_AUTOHIGH parameters can only be specified on devices that support OTG operation.

Returns

None.

Definition at line 3628 of file usb.c.

References ASSERT, HWREG, HWREGH, USB0_BASE, USB_EPC_EPEN_M, USB_EPC_PFLTACT_M, USB_EPC_PFLTAEN, USB_EPC_PFLTSEN_HIGH, USB_HOST_PWREN_FILTER, USB_O_EPC, and USB_O_VDC.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Flags & ~(USB_HOST_PWREN_FILTER | USB_EPC_PFLTACT_M |
                          USB_EPC_PFLTAEN | USB_EPC_PFLTSEN_HIGH |
                          USB_EPC_EPEN_M)) == 0);

    //
    // If requested, enable VBUS droop detection on parts that support this
    // feature.
    //
    HWREG(ui32Base + USB_O_VDC) = ui32Flags >> 16;

    //
    // Set the power fault configuration as specified.  This configuration
    // does not change whether fault detection is enabled or not.
    //
    HWREGH(ui32Base + USB_O_EPC) =
        (ui32Flags | (HWREGH(ui32Base + USB_O_EPC) &
                      ~(USB_EPC_PFLTACT_M | USB_EPC_PFLTAEN |
                        USB_EPC_PFLTSEN_HIGH | USB_EPC_EPEN_M)));
}

void USBHostPwrDisable

(

uint32_t

ui32Base

)

Disables the external power pin.

Parameters

ui32Base

specifies the USB module base address.

This function disables the USBnEPEN signal, which disables an external power supply in host mode operation.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3752 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_EPC_EPENDE, and USB_O_EPC.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Disable the external power supply enable signal.
    //
    HWREGH(ui32Base + USB_O_EPC) &= ~USB_EPC_EPENDE;
}

void USBHostPwrEnable

(

uint32_t

ui32Base

)

Enables the external power pin.

Parameters

ui32Base

specifies the USB module base address.

This function enables the USBnEPEN signal, which enables an external power supply in host mode operation.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3724 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_EPC_EPENDE, and USB_O_EPC.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Enable the external power supply enable signal.
    //
    HWREGH(ui32Base + USB_O_EPC) |= USB_EPC_EPENDE;
}

void USBHostPwrFaultDisable

(

uint32_t

ui32Base

)

Disables power fault detection.

Parameters

ui32Base

specifies the USB module base address.

This function disables power fault detection in the USB controller.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3696 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_EPC_PFLTEN, and USB_O_EPC.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Enable power fault input.
    //
    HWREGH(ui32Base + USB_O_EPC) &= ~USB_EPC_PFLTEN;
}

void USBHostPwrFaultEnable

(

uint32_t

ui32Base

)

Enables power fault detection.

Parameters

ui32Base

specifies the USB module base address.

This function enables power fault detection in the USB controller. If the USBnPFLT pin is not in use, this function must not be used.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3669 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_EPC_PFLTEN, and USB_O_EPC.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Enable power fault input.
    //
    HWREGH(ui32Base + USB_O_EPC) |= USB_EPC_PFLTEN;
}

void USBHostRequestIN	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint
	)

Schedules a request for an IN transaction on an endpoint in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.

This function schedules a request for an IN transaction. When the USB device being communicated with responds with the data, the data can be retrieved by calling USBEndpointDataGet() or via a DMA transfer.

Note

This function must only be called in host mode and only for IN endpoints.

Returns

None.

Definition at line 3228 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_RXCSRL1, and USB_RXCSRL1_REQPKT.

{
    uint32_t ui32Register;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Endpoint zero uses a different offset than the other endpoints.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        ui32Register = USB_O_CSRL0;
    }
    else
    {
        ui32Register = USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint);
    }

    //
    // Set the request for an IN transaction.
    //
    HWREGB(ui32Base + ui32Register) = USB_RXCSRL1_REQPKT;
}

void USBHostRequestINClear	(	uint32_t	ui32Base,
		uint32_t	ui32Endpoint
	)

Clears a scheduled IN transaction for an endpoint in host mode.

Parameters

ui32Base	specifies the USB module base address.
ui32Endpoint	is the endpoint to access.

This function clears a previously scheduled IN transaction if it is still pending. This function is used to safely disable any scheduled IN transactions if the endpoint specified by ui32Endpoint is reconfigured for communications with other devices.

Note

This function must only be called in host mode and only for IN endpoints.

Returns

None.

Definition at line 3278 of file usb.c.

References ASSERT, EP_OFFSET, HWREGB, USB0_BASE, USB_EP_0, USB_EP_1, USB_EP_2, USB_EP_3, USB_EP_4, USB_EP_5, USB_EP_6, USB_EP_7, USB_O_CSRL0, USB_O_RXCSRL1, and USB_RXCSRL1_REQPKT.

{
    uint32_t ui32Register;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Endpoint == USB_EP_0) || (ui32Endpoint == USB_EP_1) ||
           (ui32Endpoint == USB_EP_2) || (ui32Endpoint == USB_EP_3) ||
           (ui32Endpoint == USB_EP_4) || (ui32Endpoint == USB_EP_5) ||
           (ui32Endpoint == USB_EP_6) || (ui32Endpoint == USB_EP_7));

    //
    // Endpoint zero uses a different offset than the other endpoints.
    //
    if(ui32Endpoint == USB_EP_0)
    {
        ui32Register = USB_O_CSRL0;
    }
    else
    {
        ui32Register = USB_O_RXCSRL1 + EP_OFFSET(ui32Endpoint);
    }

    //
    // Clear the request for an IN transaction.
    //
    HWREGB(ui32Base + ui32Register) &= ~USB_RXCSRL1_REQPKT;
}

void USBHostRequestStatus

(

uint32_t

ui32Base

)

Issues a request for a status IN transaction on endpoint zero.

Parameters

ui32Base

specifies the USB module base address.

This function is used to cause a request for a status IN transaction from a device on endpoint zero. This function can only be used with endpoint zero as that is the only control endpoint that supports this ability. This function is used to complete the last phase of a control transaction to a device and an interrupt is signaled when the status packet has been received.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 3328 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_CSRL0_REQPKT, USB_CSRL0_STATUS, and USB_O_CSRL0.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Set the request for a status IN transaction.
    //
    HWREGB(ui32Base + USB_O_CSRL0) = USB_CSRL0_REQPKT | USB_CSRL0_STATUS;
}

void USBHostReset	(	uint32_t	ui32Base,
		bool	bStart
	)

Handles the USB bus reset condition.

Parameters

ui32Base	specifies the USB module base address.
bStart	specifies whether to start or stop signaling reset on the USB bus.

When this function is called with the bStart parameter set to true, this function causes the start of a reset condition on the USB bus. The caller must then delay at least 20ms before calling this function again with the bStart parameter set to false.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 264 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_O_POWER, and USB_POWER_RESET.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Send a reset signal to the bus.
    //
    if(bStart)
    {
        HWREGB(ui32Base + USB_O_POWER) |= USB_POWER_RESET;
    }
    else
    {
        HWREGB(ui32Base + USB_O_POWER) &= ~USB_POWER_RESET;
    }
}

void USBHostResume	(	uint32_t	ui32Base,
		bool	bStart
	)

Handles the USB bus resume condition.

Parameters

ui32Base	specifies the USB module base address.
bStart	specifies if the USB controller is entering or leaving the resume signaling state.

When in device mode, this function brings the USB controller out of the suspend state. This call must first be made with the bStart parameter set to true to start resume signaling. The device application must then delay at least 10ms but not more than 15ms before calling this function with the bStart parameter set to false.

When in host mode, this function signals devices to leave the suspend state. This call must first be made with the bStart parameter set to true to start resume signaling. The host application must then delay at least 20ms before calling this function with the bStart parameter set to false. This action causes the controller to complete the resume signaling on the USB bus.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 368 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_O_POWER, and USB_POWER_RESUME.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Send a resume signal to the bus.
    //
    if(bStart)
    {
        HWREGB(ui32Base + USB_O_POWER) |= USB_POWER_RESUME;
    }
    else
    {
        HWREGB(ui32Base + USB_O_POWER) &= ~USB_POWER_RESUME;
    }
}

uint32_t USBHostSpeedGet

(

uint32_t

ui32Base

)

Returns the current speed of the USB device connected.

Parameters

ui32Base

specifies the USB module base address.

This function returns the current speed of the USB bus in host mode.

Example: Get the USB connection speed.

//! //
//! // Get the connection speed of the device connected to the USB controller.
//! //
//! USBHostSpeedGet(USB0_BASE);
//! 

\note This function must only be called in host mode.

\return Returns one of the following: \b USB_LOW_SPEED, \b USB_FULL_SPEED,
\b USB_HIGH_SPEED, or \b USB_UNDEF_SPEED.  

Definition at line 412 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_DEVCTL_FSDEV, USB_DEVCTL_LSDEV, USB_FULL_SPEED, USB_HIGH_SPEED, USB_LOW_SPEED, USB_O_DEVCTL, USB_O_POWER, USB_POWER_HSMODE, and USB_UNDEF_SPEED.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // If the Full Speed device bit is set, then this is a full speed device.
    //
    if(HWREGB(ui32Base + USB_O_POWER) & USB_POWER_HSMODE)
    {
        return(USB_HIGH_SPEED);
    }

    //
    // If the Full Speed device bit is set, then this is a full speed device.
    //
    if(HWREGB(ui32Base + USB_O_DEVCTL) & USB_DEVCTL_FSDEV)
    {
        return(USB_FULL_SPEED);
    }

    //
    // If the Low Speed device bit is set, then this is a low speed device.
    //
    if(HWREGB(ui32Base + USB_O_DEVCTL) & USB_DEVCTL_LSDEV)
    {
        return(USB_LOW_SPEED);
    }

    //
    // The device speed is not known.
    //
    return(USB_UNDEF_SPEED);
}

void USBHostSuspend

(

uint32_t

ui32Base

)

Puts the USB bus in a suspended state.

Parameters

ui32Base

specifies the USB module base address.

When used in host mode, this function puts the USB bus in the suspended state.

Note

This function must only be called in host mode.

Returns

None.

Definition at line 232 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_O_POWER, and USB_POWER_SUSPEND.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Send the suspend signaling to the USB bus.
    //
    HWREGB(ui32Base + USB_O_POWER) |= USB_POWER_SUSPEND;
}

void USBIntDisableControl	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Disables control interrupts on a specified USB controller.

Parameters

ui32Base	specifies the USB module base address.
ui32Flags	specifies which control interrupts to disable.

This function disables the control interrupts for the USB controller specified by the ui32Base parameter. The ui32Flags parameter specifies which control interrupts to disable. The flags passed in the ui32Flags parameters must be the definitions that start with USB_INTCTRL_* and not any other USB_INT flags.

Returns

None.

Definition at line 509 of file usb.c.

References ASSERT, HWREG, HWREGB, USB0_BASE, USB_INTCTRL_ALL, USB_INTCTRL_MODE_DETECT, USB_INTCTRL_POWER_FAULT, USB_INTCTRL_STATUS, USB_O_EPCIM, USB_O_IDVIM, and USB_O_IE.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Flags & ~(USB_INTCTRL_ALL)) == 0);

    //
    // If any general interrupts were disabled then write the general interrupt
    // settings out to the hardware.
    //
    if(ui32Flags & USB_INTCTRL_STATUS)
    {
        HWREGB(ui32Base + USB_O_IE) &= ~(ui32Flags & USB_INTCTRL_STATUS);
    }

    //
    // Disable the power fault interrupt.
    //
    if(ui32Flags & USB_INTCTRL_POWER_FAULT)
    {
        HWREG(ui32Base + USB_O_EPCIM) = 0;
    }

    //
    // Disable the ID pin detect interrupt.
    //
    if(ui32Flags & USB_INTCTRL_MODE_DETECT)
    {
        HWREG(USB0_BASE + USB_O_IDVIM) = 0;
    }
}

void USBIntDisableEndpoint	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Disables endpoint interrupts on a specified USB controller.

Parameters

ui32Base	specifies the USB module base address.
ui32Flags	specifies which endpoint interrupts to disable.

This function disables endpoint interrupts for the USB controller specified by the ui32Base parameter. The ui32Flags parameter specifies which endpoint interrupts to disable. The flags passed in the ui32Flags parameters must be the definitions that start with USB_INTEP_* and not any other USB_INT flags.

Returns

None.

Definition at line 702 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_INTEP_0, USB_INTEP_DEV_IN, USB_INTEP_DEV_OUT, USB_INTEP_HOST_IN, USB_INTEP_HOST_OUT, USB_INTEP_RX_SHIFT, USB_O_RXIE, and USB_O_TXIE.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // If any transmit interrupts were disabled, then write the transmit
    // interrupt settings out to the hardware.
    //
    HWREGH(ui32Base + USB_O_TXIE) &=
        ~(ui32Flags & (USB_INTEP_HOST_OUT | USB_INTEP_DEV_IN | USB_INTEP_0));

    //
    // If any receive interrupts were disabled, then write the receive
    // interrupt settings out to the hardware.
    //
    HWREGH(ui32Base + USB_O_RXIE) &=
        ~((ui32Flags & (USB_INTEP_HOST_IN | USB_INTEP_DEV_OUT)) >>
          USB_INTEP_RX_SHIFT);
}

void USBIntEnableControl	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Enables control interrupts on a specified USB controller.

Parameters

ui32Base	specifies the USB module base address.
ui32Flags	specifies which control interrupts to enable.

This function enables the control interrupts for the USB controller specified by the ui32Base parameter. The ui32Flags parameter specifies which control interrupts to enable. The flags passed in the ui32Flags parameters must be the definitions that start with USB_INTCTRL_* and not any other USB_INT flags.

Returns

None.

Definition at line 560 of file usb.c.

References ASSERT, HWREG, HWREGB, USB0_BASE, USB_EPCIM_PF, USB_IDVIM_ID, USB_INTCTRL_ALL, USB_INTCTRL_MODE_DETECT, USB_INTCTRL_POWER_FAULT, USB_INTCTRL_STATUS, USB_O_EPCIM, USB_O_IDVIM, and USB_O_IE.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);
    ASSERT((ui32Flags & (~USB_INTCTRL_ALL)) == 0);

    //
    // If any general interrupts were enabled, then write the general
    // interrupt settings out to the hardware.
    //
    if(ui32Flags & USB_INTCTRL_STATUS)
    {
        HWREGB(ui32Base + USB_O_IE) |= ui32Flags;
    }

    //
    // Enable the power fault interrupt.
    //
    if(ui32Flags & USB_INTCTRL_POWER_FAULT)
    {
        HWREG(ui32Base + USB_O_EPCIM) = USB_EPCIM_PF;
    }

    //
    // Enable the ID pin detect interrupt.
    //
    if(ui32Flags & USB_INTCTRL_MODE_DETECT)
    {
        HWREG(USB0_BASE + USB_O_IDVIM) = USB_IDVIM_ID;
    }
}

void USBIntEnableEndpoint	(	uint32_t	ui32Base,
		uint32_t	ui32Flags
	)

Enables endpoint interrupts on a specified USB controller.

Parameters

ui32Base	specifies the USB module base address.
ui32Flags	specifies which endpoint interrupts to enable.

This function enables endpoint interrupts for the USB controller specified by the ui32Base parameter. The ui32Flags parameter specifies which endpoint interrupts to enable. The flags passed in the ui32Flags parameters must be the definitions that start with USB_INTEP_* and not any other USB_INT flags.

Returns

None.

Definition at line 742 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_INTEP_0, USB_INTEP_DEV_IN, USB_INTEP_DEV_OUT, USB_INTEP_HOST_IN, USB_INTEP_HOST_OUT, USB_INTEP_RX_SHIFT, USB_O_RXIE, and USB_O_TXIE.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Enable any transmit endpoint interrupts.
    //
    HWREGH(ui32Base + USB_O_TXIE) |=
        ui32Flags & (USB_INTEP_HOST_OUT | USB_INTEP_DEV_IN | USB_INTEP_0);

    //
    // Enable any receive endpoint interrupts.
    //
    HWREGH(ui32Base + USB_O_RXIE) |=
        ((ui32Flags & (USB_INTEP_HOST_IN | USB_INTEP_DEV_OUT)) >>
         USB_INTEP_RX_SHIFT);
}

void USBIntRegister	(	uint32_t	ui32Base,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for the USB controller.

Parameters

ui32Base	specifies the USB module base address.
pfnHandler	is a pointer to the function to be called when a USB interrupt occurs.

This function registers the handler to be called when a USB interrupt occurs and enables the global USB interrupt in the interrupt controller. The specific desired USB interrupts must be enabled via a separate call to USBIntEnable(). It is the interrupt handler's responsibility to clear the interrupt sources via calls to USBIntStatusControl() and USBIntStatusEndpoint().

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 859 of file usb.c.

References _USBIntNumberGet(), ASSERT, IntEnable(), IntRegister(), and USB0_BASE.

{
    uint32_t ui32Int;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    ui32Int = _USBIntNumberGet(ui32Base);

    ASSERT(ui32Int != 0);

    //
    // Register the interrupt handler.
    //
    IntRegister(ui32Int, pfnHandler);

    //
    // Enable the USB interrupt.
    //
    IntEnable(ui32Int);
}

Here is the call graph for this function:

uint32_t USBIntStatusControl

(

uint32_t

ui32Base

)

Returns the control interrupt status on a specified USB controller.

Parameters

ui32Base

specifies the USB module base address.

This function reads control interrupt status for a USB controller. This call returns the current status for control interrupts only, the endpoint interrupt status is retrieved by calling USBIntStatusEndpoint(). The bit values returned are compared against the USB_INTCTRL_* values.

The following are the meanings of all USB_INCTRL_ flags and the modes for which they are valid. These values apply to any calls to USBIntStatusControl(), USBIntEnableControl(), and USBIntDisableControl(). Some of these flags are only valid in the following modes as indicated in the parentheses: Host, Device, and OTG.

• USB_INTCTRL_ALL - A full mask of all control interrupt sources.
• USB_INTCTRL_VBUS_ERR - A VBUS error has occurred (Host Only).
• USB_INTCTRL_SESSION - Session Start Detected on A-side of cable (OTG Only).
• USB_INTCTRL_SESSION_END - Session End Detected (Device Only)
• USB_INTCTRL_DISCONNECT - Device Disconnect Detected (Host Only)
• USB_INTCTRL_CONNECT - Device Connect Detected (Host Only)
• USB_INTCTRL_SOF - Start of Frame Detected.
• USB_INTCTRL_BABBLE - USB controller detected a device signaling past the end of a frame (Host Only)
• USB_INTCTRL_RESET - Reset signaling detected by device (Device Only)
• USB_INTCTRL_RESUME - Resume signaling detected.
• USB_INTCTRL_SUSPEND - Suspend signaling detected by device (Device Only)
• USB_INTCTRL_MODE_DETECT - OTG cable mode detection has completed (OTG Only)
• USB_INTCTRL_POWER_FAULT - Power Fault detected (Host Only)

Note

This call clears the source of all of the control status interrupts.

Returns

Returns the status of the control interrupts for a USB controller.

Definition at line 635 of file usb.c.

References ASSERT, HWREG, HWREGB, USB0_BASE, USB_EPCISC_PF, USB_IDVRIS_ID, USB_INTCTRL_MODE_DETECT, USB_INTCTRL_POWER_FAULT, USB_O_EPCISC, USB_O_IDVISC, and USB_O_IS.

{
    uint32_t ui32Status;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Get the general interrupt status, these bits go into the upper 8 bits
    // of the returned value.
    //
    ui32Status = HWREGB(ui32Base + USB_O_IS);

    //
    // Add the power fault status.
    //
    if(HWREG(ui32Base + USB_O_EPCISC) & USB_EPCISC_PF)
    {
        //
        // Indicate a power fault was detected.
        //
        ui32Status |= USB_INTCTRL_POWER_FAULT;

        //
        // Clear the power fault interrupt.
        //
        HWREGB(ui32Base + USB_O_EPCISC) |= USB_EPCISC_PF;
    }

    if(HWREG(USB0_BASE + USB_O_IDVISC) & USB_IDVRIS_ID)
    {
        //
        // Indicate an id detection.
        //
        ui32Status |= USB_INTCTRL_MODE_DETECT;

        //
        // Clear the id detection interrupt.
        //
        HWREG(USB0_BASE + USB_O_IDVISC) |= USB_IDVRIS_ID;
    }

    //
    // Return the combined interrupt status.
    //
    return(ui32Status);
}

uint32_t USBIntStatusEndpoint

(

uint32_t

ui32Base

)

Returns the endpoint interrupt status on a specified USB controller.

Parameters

ui32Base

specifies the USB module base address.

This function reads endpoint interrupt status for a USB controller. This call returns the current status for endpoint interrupts only, the control interrupt status is retrieved by calling USBIntStatusControl(). The bit values returned are compared against the USB_INTEP_* values. These values are grouped into classes for USB_INTEP_HOST_* and USB_INTEP_DEV_* values to handle both host and device modes with all endpoints.

Note

This call clears the source of all of the endpoint interrupts.

Returns

Returns the status of the endpoint interrupts for a USB controller.

Definition at line 783 of file usb.c.

References ASSERT, HWREGH, USB0_BASE, USB_INTEP_RX_SHIFT, USB_O_RXIS, and USB_O_TXIS.

{
    uint32_t ui32Status;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Get the transmit interrupt status.
    //
    ui32Status = HWREGH(ui32Base + USB_O_TXIS);
    ui32Status |= (HWREGH(ui32Base + USB_O_RXIS) << USB_INTEP_RX_SHIFT);

    //
    // Return the combined interrupt status.
    //
    return(ui32Status);
}

void USBIntUnregister

(

uint32_t

ui32Base

)

Unregisters an interrupt handler for the USB controller.

Parameters

ui32Base

specifies the USB module base address.

This function unregisters the interrupt handler. This function also disables the USB interrupt in the interrupt controller.

See also

IntRegister() for important information about registering or unregistering interrupt handlers.

Returns

None.

Definition at line 899 of file usb.c.

References _USBIntNumberGet(), ASSERT, IntDisable(), IntUnregister(), and USB0_BASE.

{
    uint32_t ui32Int;

    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    ui32Int = _USBIntNumberGet(ui32Base);

    ASSERT(ui32Int != 0);

    //
    // Disable the USB interrupt.
    //
    IntDisable(ui32Int);

    //
    // Unregister the interrupt handler.
    //
    IntUnregister(ui32Int);
}

Here is the call graph for this function:

void USBModeConfig	(	uint32_t	ui32Base,
		uint32_t	ui32Mode
	)

Change the operating mode of the USB controller.

Parameters

ui32Base	specifies the USB module base address.
ui32Mode	specifies the operating mode of the USB OTG pins.

This function changes the operating modes of the USB controller. When operating in full OTG mode, the USB controller uses the VBUS and ID pins to detect mode and voltage changes. While these pins are primarily used in OTG mode, they can also affect the operation of host and device modes. In device mode, the USB controller can be configured to monitor or ignore VBUS. Monitoring VBUS allows the controller to determine if it has been disconnected from the host. In host mode, the USB controller uses the VBUS pin to detect loss of VBUS caused by excessive power draw due to a drop in the VBUS voltage. This call takes the place of USBHostMode(), USBDevMode(), and USBOTGMode(). The ui32Mode value should be one of the following values:

• USB_MODE_OTG enables operating in full OTG mode, VBUS and ID are used by the controller.
• USB_MODE_HOST enables operating only as a host with no monitoring of VBUS or ID pins.
• USB_MODE_HOST_VBUS enables operating only as a host with monitoring of VBUS pin. This configuration enables detection of VBUS droop while still forcing host mode.
• USB_MODE_DEVICE enables operating only as a device with no monitoring of VBUS or ID pins.
• USB_MODE_DEVICE_VBUS enables operating only as a device with monitoring of VBUS pin. This configuration enables disconnect detection while still forcing device mode.

Note

Some of the options above are not available on some Tiva devices. Please check the data sheet to determine if the USB controller supports a particular mode.

Example: Force device mode but allow monitoring of the USB VBUS pin.

//! //
//! // Force device mode but allow monitoring of VBUS for disconnect.
//! //
//! USBModeConfig(USB_MODE_DEVICE_VBUS);
//! 

\return None.  

Definition at line 4117 of file usb.c.

References ASSERT, HWREG, USB0_BASE, and USB_O_GPCS.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    HWREG(ui32Base + USB_O_GPCS) = ui32Mode;
}

uint32_t USBModeGet

(

uint32_t

ui32Base

)

Returns the current operating mode of the controller.

Parameters

ui32Base

specifies the USB module base address.

This function returns the current operating mode on USB controllers with OTG or Dual mode functionality.

For OTG controllers:

The function returns one of the following values on OTG controllers:

USB_OTG_MODE_ASIDE_HOST indicates that the controller is in host mode on the A-side of the cable.

USB_OTG_MODE_ASIDE_DEV indicates that the controller is in device mode on the A-side of the cable.

USB_OTG_MODE_BSIDE_HOST indicates that the controller is in host mode on the B-side of the cable.

USB_OTG_MODE_BSIDE_DEV indicates that the controller is in device mode on the B-side of the cable. If an OTG session request is started with no cable in place, this mode is the default.

USB_OTG_MODE_NONE indicates that the controller is not attempting to determine its role in the system.

For Dual Mode controllers:

The function returns one of the following values:

USB_DUAL_MODE_HOST indicates that the controller is acting as a host.

USB_DUAL_MODE_DEVICE indicates that the controller acting as a device.

USB_DUAL_MODE_NONE indicates that the controller is not active as either a host or device.

Returns

Returns USB_OTG_MODE_ASIDE_HOST, USB_OTG_MODE_ASIDE_DEV, USB_OTG_MODE_BSIDE_HOST, USB_OTG_MODE_BSIDE_DEV, USB_OTG_MODE_NONE, USB_DUAL_MODE_HOST, USB_DUAL_MODE_DEVICE, or USB_DUAL_MODE_NONE.

Definition at line 3898 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_DEVCTL_DEV, USB_DEVCTL_HOST, USB_DEVCTL_SESSION, USB_DEVCTL_VBUS_M, and USB_O_DEVCTL.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Checks the current mode in the USB_O_DEVCTL and returns the current
    // mode.
    //
    // USB_OTG_MODE_ASIDE_HOST:  USB_DEVCTL_HOST | USB_DEVCTL_SESSION
    // USB_OTG_MODE_ASIDE_DEV:   USB_DEVCTL_SESSION
    // USB_OTG_MODE_BSIDE_HOST:  USB_DEVCTL_DEV | USB_DEVCTL_SESSION |
    //                           USB_DEVCTL_HOST
    // USB_OTG_MODE_BSIDE_DEV:   USB_DEVCTL_DEV | USB_DEVCTL_SESSION
    // USB_OTG_MODE_NONE:        USB_DEVCTL_DEV
    //
    return(HWREGB(ui32Base + USB_O_DEVCTL) &
           (USB_DEVCTL_DEV | USB_DEVCTL_HOST | USB_DEVCTL_SESSION |
            USB_DEVCTL_VBUS_M));
}

uint32_t USBNumEndpointsGet

(

uint32_t

ui32Base

)

Returns the number of USB endpoint pairs on the device.

Parameters

ui32Base

specifies the USB module base address.

This function returns the number of endpoint pairs supported by the USB controller corresponding to the passed base address. The value returned is the number of IN or OUT endpoints available and does not include endpoint 0 (the control endpoint). For example, if 15 is returned, there are 15 IN and 15 OUT endpoints available in addition to endpoint 0.

Returns

Returns the number of IN or OUT endpoints available.

Definition at line 4215 of file usb.c.

References HWREGB, USB_EPINFO_TXEP_M, and USB_O_EPINFO.

{
    //
    // Read the number of endpoints from the hardware.  The number of TX and
    // RX endpoints are always the same.
    //
    return(HWREGB(ui32Base + USB_O_EPINFO) & USB_EPINFO_TXEP_M);
}

void USBOTGMode

(

uint32_t

ui32Base

)

Changes the mode of the USB controller to OTG.

Parameters

ui32Base

specifies the USB module base address.

This function changes the mode of the USB controller to OTG mode. This function is only valid on microcontrollers that have the OTG capabilities.

Returns

None.

Definition at line 4054 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, and USB_O_GPCS.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Disable the override of the USB controller mode when running on an OTG
    // device.
    //
    HWREGB(ui32Base + USB_O_GPCS) = 0;
}

void USBOTGSessionRequest	(	uint32_t	ui32Base,
		bool	bStart
	)

Starts or ends a session.

Parameters

ui32Base	specifies the USB module base address.
bStart	specifies if this call starts or ends a session.

This function is used in OTG mode to start a session request or end a session. If the bStart parameter is set to true, then this function starts a session and if it is false it ends a session.

Returns

None.

Definition at line 3805 of file usb.c.

References ASSERT, HWREGB, USB0_BASE, USB_DEVCTL_SESSION, and USB_O_DEVCTL.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Base == USB0_BASE);

    //
    // Start or end the session as directed.
    //
    if(bStart)
    {
        HWREGB(ui32Base + USB_O_DEVCTL) |= USB_DEVCTL_SESSION;
    }
    else
    {
        HWREGB(ui32Base + USB_O_DEVCTL) &= ~USB_DEVCTL_SESSION;
    }
}

void USBPHYPowerOff

(

uint32_t

ui32Base

)

Powers off the internal USB PHY.

Parameters

ui32Base

specifies the USB module base address.

This function powers off the internal USB PHY, reducing the current consumption of the device. While in the powered-off state, the USB controller is unable to operate.

Returns

None.

Definition at line 4141 of file usb.c.

References HWREGB, USB_O_POWER, and USB_POWER_PWRDNPHY.

{
    //
    // Set the PWRDNPHY bit in the PHY, putting it into its low power mode.
    //
    HWREGB(ui32Base + USB_O_POWER) |= USB_POWER_PWRDNPHY;
}

void USBPHYPowerOn

(

uint32_t

ui32Base

)

Powers on the internal USB PHY.

Parameters

ui32Base

specifies the USB module base address.

This function powers on the internal USB PHY, enabling it return to normal operation. By default, the PHY is powered on, so this function must only be called if USBPHYPowerOff() has previously been called.

Returns

None.

Definition at line 4163 of file usb.c.

References HWREGB, USB_O_POWER, and USB_POWER_PWRDNPHY.

{
    //
    // Clear the PWRDNPHY bit in the PHY, putting it into normal operating
    // mode.
    //
    HWREGB(ui32Base + USB_O_POWER) &= ~USB_POWER_PWRDNPHY;
}