//***************************************************************************** // //! 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. //! \param psCompEntry is the composite device entry to initialize when //! creating a composite device. //! //! This call is very similar to USBDBulkInit() except that it is used for //! initializing an instance of the bulk device for use in a composite device. //! When this bulk device is part of a composite device, then the //! \e psCompEntry should point to the composite device entry to initialize. //! This is part of the array that is passed to the USBDCompositeInit() //! function. //! //! \return Returns zero on failure or a non-zero value that should be //! used with the remaining USB Bulk APIs. // //***************************************************************************** void * USBDBulkCompositeInit(uint32_t ui32Index, tUSBDBulkDevice *psBulkDevice, tCompositeEntry *psCompEntry) { tBulkInstance *psInst; // // Check parameter validity. // ASSERT(ui32Index == 0); ASSERT(psBulkDevice); ASSERT(psBulkDevice->ppui8StringDescriptors); ASSERT(psBulkDevice->pfnRxCallback); ASSERT(psBulkDevice->pfnTxCallback); // // Initialize the workspace in the passed instance structure. // psInst = &psBulkDevice->sPrivateData; // // Initialize the composite entry that is used by the composite device // class. // if(psCompEntry != 0) { psCompEntry->psDevInfo = &psInst->sDevInfo; psCompEntry->pvInstance = (void *)psBulkDevice; } // // Initialize the device information structure. // psInst->sDevInfo.psCallbacks = &g_sBulkHandlers; psInst->sDevInfo.pui8DeviceDescriptor = g_pui8BulkDeviceDescriptor; psInst->sDevInfo.ppsConfigDescriptors = g_ppBulkConfigDescriptors; psInst->sDevInfo.ppui8StringDescriptors = 0; psInst->sDevInfo.ui32NumStringDescriptors = 0; // // Set the basic state information for the class. // psInst->ui32USBBase = USB0_BASE; psInst->iBulkRxState = eBulkStateUnconfigured; psInst->iBulkTxState = eBulkStateUnconfigured; psInst->ui16DeferredOpFlags = 0; psInst->bConnected = false; // // Initialize the device info structure for the Bulk device. // USBDCDDeviceInfoInit(0, &psInst->sDevInfo); // // Set the default endpoint and interface assignments. // psInst->ui8INEndpoint = DATA_IN_ENDPOINT; psInst->ui8OUTEndpoint = DATA_OUT_ENDPOINT; psInst->ui8Interface = 0; // // Plug in the client's string stable to the device information // structure. // psInst->sDevInfo.ppui8StringDescriptors = psBulkDevice->ppui8StringDescriptors; psInst->sDevInfo.ui32NumStringDescriptors = psBulkDevice->ui32NumStringDescriptors; // // Initialize the USB tick module, this will prevent it from being // initialized later in the call to USBDCDInit(); // InternalUSBTickInit(); // // Register our tick handler (this must be done after USBDCDInit). // InternalUSBRegisterTickHandler(BulkTickHandler, (void *)psBulkDevice); // // Return the pointer to the instance indicating that everything went well. // return((void *)psBulkDevice); }
//***************************************************************************** // //! 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. //! //! This call is very similar to USBDBulkInit() except that it is used for //! initializing an instance of the bulk device for use in a composite device. //! //! \return Returns zero on failure or a non-zero value that should be //! used with the remaining USB HID Bulk APIs. // //***************************************************************************** void * USBDBulkCompositeInit(unsigned long ulIndex, const tUSBDBulkDevice *psDevice) { tBulkInstance *psInst; tDeviceDescriptor *psDevDesc; // // Check parameter validity. // ASSERT(ulIndex == 0); ASSERT(psDevice); ASSERT(psDevice->ppStringDescriptors); ASSERT(psDevice->psPrivateBulkData); ASSERT(psDevice->pfnRxCallback); ASSERT(psDevice->pfnTxCallback); // // Initialize the workspace in the passed instance structure. // psInst = psDevice->psPrivateBulkData; psInst->psConfDescriptor = (tConfigDescriptor *)g_pBulkDescriptor; psInst->psDevInfo = &g_sBulkDeviceInfo; psInst->ulUSBBase = USB0_BASE; psInst->eBulkRxState = BULK_STATE_UNCONFIGURED; psInst->eBulkTxState = BULK_STATE_UNCONFIGURED; psInst->usDeferredOpFlags = 0; psInst->bConnected = false; // // Set the default endpoint and interface assignments. // psInst->ucINEndpoint = DATA_IN_ENDPOINT; psInst->ucOUTEndpoint = DATA_OUT_ENDPOINT; psInst->ucInterface = 0; // // Fix up the device descriptor with the client-supplied values. // psDevDesc = (tDeviceDescriptor *)psInst->psDevInfo->pDeviceDescriptor; psDevDesc->idVendor = psDevice->usVID; psDevDesc->idProduct = psDevice->usPID; // // Fix up the configuration descriptor with client-supplied values. // psInst->psConfDescriptor->bmAttributes = psDevice->ucPwrAttributes; psInst->psConfDescriptor->bMaxPower = (unsigned char)(psDevice->usMaxPowermA / 2); // // Plug in the client's string stable to the device information // structure. // psInst->psDevInfo->ppStringDescriptors = psDevice->ppStringDescriptors; psInst->psDevInfo->ulNumStringDescriptors = psDevice->ulNumStringDescriptors; // // Set the device instance. // psInst->psDevInfo->pvInstance = (void *)psDevice; // // Initialize the USB tick module, this will prevent it from being // initialized later in the call to USBDCDInit(); // InternalUSBTickInit(); // // Register our tick handler (this must be done after USBDCDInit). // InternalUSBRegisterTickHandler(USB_TICK_HANDLER_DEVICE, BulkTickHandler, (void *)psDevice); // // Return the pointer to the instance indicating that everything went well. // return((void *)psDevice); }