//*****************************************************************************
//
//! 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 the USB controller for dual mode operation.
//!
//! \param ui32Index specifies the USB controller that is to be initialized for
//! dual mode operation. This parameter must be set to 0.
//!
//! This function initializes the USB controller hardware into a state
//! suitable for dual mode operation. Applications may use this function to
//! ensure that the controller is in a neutral state and able to receive
//! appropriate interrupts before host or device mode is chosen using a call
//! to USBStackModeSet().
//!
//! \return None.
//
//*****************************************************************************
void
USBDualModeInit(uint32_t ui32Index)
{
//
// We only support a single USB controller.
//
ASSERT(ui32Index == 0);
//
// Configure the End point 0.
//
USBHostEndpointConfig(USB0_BASE, USB_EP_0, 64, 0, 0,
(USB_EP_MODE_CTRL | USB_EP_SPEED_FULL |
USB_EP_HOST_OUT));
//
// Enable USB Interrupts.
//
MAP_USBIntEnableControl(USB0_BASE, USB_INTCTRL_RESET |
USB_INTCTRL_DISCONNECT |
USB_INTCTRL_SESSION |
USB_INTCTRL_BABBLE |
USB_INTCTRL_CONNECT |
USB_INTCTRL_RESUME |
USB_INTCTRL_SUSPEND |
USB_INTCTRL_VBUS_ERR);
//
// Enable all endpoint interrupts.
//
MAP_USBIntEnableEndpoint(USB0_BASE, USB_INTEP_ALL);
//
// Initialize the USB tick module.
//
InternalUSBTickInit();
//
// Enable the USB interrupt.
//
OS_INT_ENABLE(g_psDCDInst[0].ui32IntNum);
//
// Turn on session request to enable ID pin checking.
//
USBOTGSessionRequest(USB0_BASE, true);
//
// Initialize the power configuration.
//
USBHostPwrConfig(USB0_BASE, USBHCDPowerConfigGet(ui32Index));
//
// If power enable is automatic then then USBHostPwrEnable() has to be
// called to allow the USB controller to control the power enable pin.
//
if(USBHCDPowerAutomatic(ui32Index))
{
//
// This will not turn on power but instead will allow the USB
// controller to turn on power when needed.
//
USBHostPwrEnable(USB0_BASE);
}
}
//*****************************************************************************
//
//! 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);
}
