//*****************************************************************************
//
//! Initializes bulk device operation for a given USB controller.
//!
//! \param ulIndex is the index of the USB controller which is to be
//! initialized for bulk device operation.
//! \param psDevice points to a structure containing parameters customizing
//! the operation of the bulk device.
//!
//! An application wishing to make use of a USB bulk communication channel
//! must call this function to initialize the USB controller and attach the
//! device to the USB bus. This function performs all required USB
//! initialization.
//!
//! On successful completion, this function will return the \e psDevice pointer
//! passed to it. This must be passed on all future calls to the device driver
//! related to this device.
//!
//! The USBDBulk interface offers packet-based transmit and receive operation.
//! If the application would rather use block based communication with
//! transmit and receive buffers, USB buffers may be used above the bulk
//! transmit and receive channels to offer this functionality.
//!
//! Transmit Operation:
//!
//! Calls to USBDBulkPacketWrite must send no more than 64 bytes of data at a
//! time and may only be made when no other transmission is currently
//! outstanding.
//!
//! Once a packet of data has been acknowledged by the USB host, a
//! USB_EVENT_TX_COMPLETE event is sent to the application callback to inform
//! it that another packet may be transmitted.
//!
//! Receive Operation:
//!
//! An incoming USB data packet will result in a call to the application
//! callback with event USBD_EVENT_RX_AVAILABLE. The application must then
//! call USBDBulkPacketRead(), passing a buffer capable of holding 64 bytes, to
//! retrieve the data and acknowledge reception to the USB host.
//!
//! \note The application must not make any calls to the low level USB Device
//! API if interacting with USB via the USB bulk device class API. Doing so
//! will cause unpredictable (though almost certainly unpleasant) behavior.
//!
//! \return Returns NULL on failure or the psDevice pointer on success.
//
//*****************************************************************************
void *
USBDBulkInit(unsigned int ulIndex, const tUSBDBulkDevice *psDevice)
{
void *pvInstance;
//
// Check parameter validity.
//
ASSERT(ulIndex == 0);
ASSERT(psDevice);
pvInstance = USBDBulkCompositeInit(ulIndex, psDevice);
if(pvInstance)
{
//
// All is well so now pass the descriptors to the lower layer and put
// the bulk device on the bus.
//
USBDCDInit(ulIndex, psDevice->psPrivateBulkData->psDevInfo);
}
//
// Return the pointer to the instance indicating that everything went well.
//
return(pvInstance);
}
//*****************************************************************************
//
//! Initializes bulk device operation for a given USB controller.
//!
//! \param ui32Index is the index of the USB controller which is to be
//! initialized for bulk device operation.
//! \param psBulkDevice points to a structure containing parameters customizing
//! the operation of the bulk device.
//!
//! An application wishing to make use of a USB bulk communication channel
//! must call this function to initialize the USB controller and attach the
//! device to the USB bus. This function performs all required USB
//! initialization.
//!
//! On successful completion, this function will return the \e psBulkDevice
//! pointer passed to it. This must be passed on all future calls to the
//! device driver related to this device.
//!
//! The USBDBulk interface offers packet-based transmit and receive operation.
//! If the application would rather use block based communication with
//! transmit and receive buffers, USB buffers may be used above the bulk
//! transmit and receive channels to offer this functionality.
//!
//! Transmit Operation:
//!
//! Calls to USBDBulkPacketWrite must send no more than 64 bytes of data at a
//! time and may only be made when no other transmission is currently
//! outstanding.
//!
//! Once a packet of data has been acknowledged by the USB host, a
//! \b USB_EVENT_TX_COMPLETE event is sent to the application callback to
//! inform it that another packet may be transmitted.
//!
//! Receive Operation:
//!
//! An incoming USB data packet will result in a call to the application
//! callback with event \b USBD_EVENT_RX_AVAILABLE. The application must then
//! call USBDBulkPacketRead(), passing a buffer capable of holding 64 bytes, to
//! retrieve the data and acknowledge reception to the USB host.
//!
//! \note The application must not make any calls to the low level USB Device
//! API if interacting with USB via the USB bulk device class API. Doing so
//! will cause unpredictable (though almost certainly unpleasant) behavior.
//!
//! \return Returns NULL on failure or void pointer that should be used with
//! the remaining USB bulk class APSs.
//
//*****************************************************************************
void *
USBDBulkInit(uint32_t ui32Index, tUSBDBulkDevice *psBulkDevice)
{
void *pvBulkDevice;
tDeviceDescriptor *psDevDesc;
tConfigDescriptor *psConfigDesc;
//
// Check parameter validity.
//
ASSERT(ui32Index == 0);
ASSERT(psBulkDevice);
pvBulkDevice = USBDBulkCompositeInit(ui32Index, psBulkDevice, 0);
if(pvBulkDevice)
{
//
// Fix up the device descriptor with the client-supplied values.
//
psDevDesc = (tDeviceDescriptor *)g_pui8BulkDeviceDescriptor;
psDevDesc->idVendor = psBulkDevice->ui16VID;
psDevDesc->idProduct = psBulkDevice->ui16PID;
//
// Fix up the configuration descriptor with client-supplied values.
//
psConfigDesc = (tConfigDescriptor *)g_pui8BulkDescriptor;
psConfigDesc->bmAttributes = psBulkDevice->ui8PwrAttributes;
psConfigDesc->bMaxPower = (uint8_t)(psBulkDevice->ui16MaxPowermA / 2);
//
// All is well so now pass the descriptors to the lower layer and put
// the bulk device on the bus.
//
USBDCDInit(ui32Index, &psBulkDevice->sPrivateData.sDevInfo,
(void *)psBulkDevice);
}
//
// Return the pointer to the instance indicating that everything went well.
//
return(pvBulkDevice);
}
/* Initialise the USB bulk device */
void usb_init()
{
/* Zero status variables */
USBConfigured = 0;
USBDataAvail = 0;
/* USB module clock enable */
USB0ModuleClkConfig();
/* Registering the Interrupt Service Routine (ISR) */
IntRegister(SYS_INT_USB0, USB0DeviceIntHandler);
/* Setting the priority for the system interrupt in AINTC - set it high to allow USB to be prempted */
IntPrioritySet(SYS_INT_USB0, 127, AINTC_HOSTINT_ROUTE_IRQ);
/* Enabling the system interrupt in AINTC */
IntSystemEnable(SYS_INT_USB0);
/* Enable the delay timer */
DelayTimerSetup();
/* Initialize the transmit and receive buffers */
USBBufferInit((tUSBBuffer *)&g_sTxBulkBuffer);
USBBufferInit((tUSBBuffer *)&g_sRxBulkBuffer);
USBBufferInit((tUSBBuffer *)&g_sTxCDCBuffer);
USBBufferInit((tUSBBuffer *)&g_sRxCDCBuffer);
/* Register the two instances */
g_psCompDevices[0].pvInstance =
USBDBulkCompositeInit(0, (tUSBDBulkDevice *)&g_sBulkDevice);
g_psCompDevices[1].pvInstance =
USBDCDCCompositeInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
/* Register our device and place it on the bus */
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
g_pucDescriptorData);
}
