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