//***************************************************************************** // //! 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); }