//*****************************************************************************
//
//! Shut down the bulk device.
//!
//! \param pvInstance is the pointer to the device instance structure as
//! returned by USBDBulkInit().
//!
//! This function terminates device operation for the instance supplied and
//! removes the device from the USB bus. This function should not be called
//! if the bulk device is part of a composite device and instead the
//! USBDCompositeTerm() function should be called for the full composite
//! device.
//!
//! Following this call, the \e pvInstance instance should not me used in any
//! other calls.
//!
//! \return None.
//
//*****************************************************************************
void
USBDBulkTerm(void *pvInstance)
{
tBulkInstance *psInst;
int index;
ASSERT(pvInstance);
//
// Get a pointer to our instance data.
//
psInst = ((tUSBDBulkDevice *)pvInstance)->psPrivateBulkData;
//
// Terminate the requested instance.
//
USB_BASE_TO_INDEX(psInst->ulUSBBase, index);
USBDCDTerm(index);
psInst->ulUSBBase = 0;
psInst->psDevInfo = (tDeviceInfo *)0;
psInst->psConfDescriptor = (tConfigDescriptor *)0;
return;
}
//*****************************************************************************
//
// This function is called by the USB device stack whenever a request for a
// non-standard descriptor is received.
//
// \param pvInstance is the instance data for this request.
// \param pUSBRequest points to the request received.
//
// This call parses the provided request structure and determines which
// descriptor is being requested. Assuming the descriptor can be found, it is
// scheduled for transmission via endpoint zero. If the descriptor cannot be
// found, the endpoint is stalled to indicate an error to the host.
//
//*****************************************************************************
static void
HandleGetDescriptor(void *pvInstance, tUSBRequest *pUSBRequest)
{
unsigned long ulSize;
const tUSBDDFUDevice *psDevice;
tDFUInstance *psInst;
ASSERT(pvInstance != 0);
//
// Which device are we dealing with?
//
psDevice = pvInstance;
//
// Get a pointer to our instance data.
//
psInst = psDevice->psPrivateDFUData;
//
// Which type of class descriptor are we being asked for? We only support
// 1 type - the DFU functional descriptor.
//
if(((pUSBRequest->wValue >> 8) == USB_DFU_FUNC_DESCRIPTOR_TYPE) &&
((pUSBRequest->wValue & 0xFF) == 0))
{
//
// If there is more data to send than the host requested then just
// send the requested amount of data.
//
if((unsigned short)g_pDFUFunctionalDesc[0] > pUSBRequest->wLength)
{
ulSize = (unsigned long)pUSBRequest->wLength;
}
else
{
ulSize = (unsigned long)g_pDFUFunctionalDesc[0];
}
//
// Send the data via endpoint 0.
//
USBDCDSendDataEP0(USB_BASE_TO_INDEX(psInst->ulUSBBase),
g_pDFUFunctionalDesc, ulSize);
}
else
{
//****************************************************************************
//
// This function is called by the USB device stack whenever a non-standard
// request is received.
//
// \param pvInstance
// \param pUSBRequest points to the request received.
//
// This call will be passed on to the device classes if they have a handler
// for this function.
//
// \return None.
//
//****************************************************************************
static void
HandleRequests(void *pvInstance, tUSBRequest *pUSBRequest)
{
unsigned long ulIdx;
const tDeviceInfo *pDeviceInfo;
tUSBDCompositeDevice *psDevice;
//
// Create the device instance pointer.
//
psDevice = (tUSBDCompositeDevice *)pvInstance;
//
// Determine which device this request is intended for. We have to be
// careful here to send this to the callback for the correct device
// depending upon whether it is a request sent to the device, the interface
// or the endpoint.
//
switch(pUSBRequest->bmRequestType & USB_RTYPE_RECIPIENT_M)
{
case USB_RTYPE_INTERFACE:
{
ulIdx = InterfaceToIndex(psDevice, (pUSBRequest->wIndex & 0xFF));
break;
}
case USB_RTYPE_ENDPOINT:
{
ulIdx = EndpointToIndex(psDevice, (pUSBRequest->wIndex & 0x0F),
(pUSBRequest->wIndex & 0x80) ? true : false);
break;
}
//
// Requests sent to the device or any other recipient can't be
// handled here since we have no way of telling where they are
// supposed to be handled. As a result, we just stall them.
//
// If your composite device has some device-specific requests that need
// to be handled at the device (rather than interface or endpoint)
// level, you should add code here to handle them.
//
case USB_RTYPE_DEVICE:
case USB_RTYPE_OTHER:
default:
{
ulIdx = INVALID_DEVICE_INDEX;
break;
}
}
//
// Did we find a device class to pass the request to?
//
if(ulIdx != INVALID_DEVICE_INDEX)
{
//
// Get a pointer to the individual device instance.
//
pDeviceInfo = psDevice->psDevices[ulIdx].psDevice;
//
// Does this device have a RequestHandler callback?
//
if(pDeviceInfo->sCallbacks.pfnRequestHandler)
{
//
// Remember this device index so that we can correctly route any
// data notification callbacks to it.
//
psDevice->psPrivateData->ulEP0Owner = ulIdx;
//
// Yes - call the device to retrieve the descriptor.
//
pDeviceInfo->sCallbacks.pfnRequestHandler(
psDevice->psDevices[ulIdx].pvInstance, pUSBRequest);
}
else
{
//
// Oops - we can't satisfy the request so stall EP0 to indicate
// an error.
//
USBDCDStallEP0(
USB_BASE_TO_INDEX(psDevice->psPrivateData->ulUSBBase));
}
}
else
{
//
// We are unable to satisfy the descriptor request so stall EP0 to
// indicate an error.
//
USBDCDStallEP0(USB_BASE_TO_INDEX(psDevice->psPrivateData->ulUSBBase));
}
}
{
ulSize = (unsigned long)g_pDFUFunctionalDesc[0];
}
//
// Send the data via endpoint 0.
//
USBDCDSendDataEP0(USB_BASE_TO_INDEX(psInst->ulUSBBase),
g_pDFUFunctionalDesc, ulSize);
}
else
{
//
// This was an unknown or invalid request so stall.
//
USBDCDStallEP0(USB_BASE_TO_INDEX(psInst->ulUSBBase));
}
}
//*****************************************************************************
//
// This function is called by the USB device stack whenever a non-standard
// request is received.
//
// \param pvInstance is the instance data for this HID device.
// \param pUSBRequest points to the request received.
//
// This call parses the provided request structure. Assuming the request is
// understood, it is handled and any required response generated. If the
// request cannot be handled by this device class, endpoint zero is stalled to
// indicate an error to the host.
