//*****************************************************************************
//
//! This function is used to release an instance of the MSC driver.
//!
//! \param pvInstance is an instance pointer that needs to be released.
//!
//! This function will free up any resources in use by the MSC driver instance
//! that is passed in. The \e pvInstance pointer should be a valid value that
//! was returned from a call to USBMSCOpen().
//!
//! \return None.
//
//*****************************************************************************
static void
USBHMSCClose(void *pvInstance)
{
//
// Do nothing if there is not a driver open.
//
if(g_USBHMSCDevice.pDevice == 0)
{
return;
}
//
// Reset the device pointer.
//
g_USBHMSCDevice.pDevice = 0;
//
// Free the Bulk IN pipe.
//
if(g_USBHMSCDevice.ulBulkInPipe != 0)
{
USBHCDPipeFree(g_USBHMSCDevice.ulBulkInPipe);
}
//
// Free the Bulk OUT pipe.
//
if(g_USBHMSCDevice.ulBulkOutPipe != 0)
{
USBHCDPipeFree(g_USBHMSCDevice.ulBulkOutPipe);
}
//
// If the callback exists then call it.
//
if(g_USBHMSCDevice.pfnCallback != 0)
{
g_USBHMSCDevice.pfnCallback((unsigned long)&g_USBHMSCDevice,
MSC_EVENT_CLOSE, 0);
}
}
//*****************************************************************************
//
//! This function is used to open an instance of the MSC driver.
//!
//! \param pDevice is a pointer to the device information structure.
//!
//! This function will attempt to open an instance of the MSC driver based on
//! the information contained in the pDevice structure. This call can fail if
//! there are not sufficient resources to open the device. The function will
//! return a value that should be passed back into USBMSCClose() when the
//! driver is no longer needed.
//!
//! \return The function will return a pointer to a MSC driver instance.
//
//*****************************************************************************
static void *
USBHMSCOpen(tUSBHostDevice *pDevice)
{
long lIdx;
tEndpointDescriptor *pEndpointDescriptor;
tInterfaceDescriptor *pInterface;
//
// Don't allow the device to be opened without closing first.
//
if(g_USBHMSCDevice.pDevice)
{
return(0);
}
//
// Save the device pointer.
//
g_USBHMSCDevice.pDevice = pDevice;
//
// Get the interface descriptor.
//
pInterface = USBDescGetInterface(pDevice->pConfigDescriptor, 0, 0);
//
// Loop through the endpoints of the device.
//
for(lIdx = 0; lIdx < 3; lIdx++)
{
//
// Get the first endpoint descriptor.
//
pEndpointDescriptor =
USBDescGetInterfaceEndpoint(pInterface, lIdx,
pDevice->ulConfigDescriptorSize);
//
// If no more endpoints then break out.
//
if(pEndpointDescriptor == 0)
{
break;
}
//
// See if this is a bulk endpoint.
//
if((pEndpointDescriptor->bmAttributes & USB_EP_ATTR_TYPE_M) ==
USB_EP_ATTR_BULK)
{
//
// See if this is bulk IN or bulk OUT.
//
if(pEndpointDescriptor->bEndpointAddress & USB_EP_DESC_IN)
{
//
// Allocate the USB Pipe for this Bulk IN endpoint.
//
g_USBHMSCDevice.ulBulkInPipe =
USBHCDPipeAllocSize(0, USBHCD_PIPE_BULK_IN_DMA,
pDevice->ulAddress,
pEndpointDescriptor->wMaxPacketSize,
0);
//
// Configure the USB pipe as a Bulk IN endpoint.
//
USBHCDPipeConfig(g_USBHMSCDevice.ulBulkInPipe,
pEndpointDescriptor->wMaxPacketSize,
0,
(pEndpointDescriptor->bEndpointAddress &
USB_EP_DESC_NUM_M));
}
else
{
//
// Allocate the USB Pipe for this Bulk OUT endpoint.
//
g_USBHMSCDevice.ulBulkOutPipe =
USBHCDPipeAllocSize(0, USBHCD_PIPE_BULK_OUT_DMA,
pDevice->ulAddress,
pEndpointDescriptor->wMaxPacketSize,
0);
//
// Configure the USB pipe as a Bulk OUT endpoint.
//
USBHCDPipeConfig(g_USBHMSCDevice.ulBulkOutPipe,
pEndpointDescriptor->wMaxPacketSize,
0,
(pEndpointDescriptor->bEndpointAddress &
USB_EP_DESC_NUM_M));
}
}
}
//
// If the callback exists, call it with an Open event.
//
if(g_USBHMSCDevice.pfnCallback != 0)
{
g_USBHMSCDevice.pfnCallback((unsigned long)&g_USBHMSCDevice,
MSC_EVENT_OPEN, 0);
}
//
// Return the only instance of this device.
//
return(&g_USBHMSCDevice);
}
//*****************************************************************************
//
//! This function is used to open an instance of the MSC driver.
//!
//! \param psDevice is a pointer to the device information structure.
//!
//! This function will attempt to open an instance of the MSC driver based on
//! the information contained in the \e psDevice structure. This call can fail
//! if there are not sufficient resources to open the device. The function
//! returns a value that should be passed back into USBMSCClose() when the
//! driver is no longer needed.
//!
//! \return The function will return a pointer to a MSC driver instance.
//
//*****************************************************************************
static void *
USBHMSCOpen(tUSBHostDevice *psDevice)
{
int32_t i32Idx;
tEndpointDescriptor *psEndpointDescriptor;
tInterfaceDescriptor *psInterface;
//
// Don't allow the device to be opened without closing first.
//
if(g_sUSBHMSCDevice.psDevice)
{
return(0);
}
//
// Save the device pointer.
//
g_sUSBHMSCDevice.psDevice = psDevice;
//
// Get the interface descriptor.
//
psInterface = USBDescGetInterface(psDevice->psConfigDescriptor, 0, 0);
//
// Loop through the endpoints of the device.
//
for(i32Idx = 0; i32Idx < 3; i32Idx++)
{
//
// Get the first endpoint descriptor.
//
psEndpointDescriptor =
USBDescGetInterfaceEndpoint(psInterface, i32Idx,
psDevice->ui32ConfigDescriptorSize);
//
// If no more endpoints then break out.
//
if(psEndpointDescriptor == 0)
{
break;
}
//
// See if this is a bulk endpoint.
//
if((psEndpointDescriptor->bmAttributes & USB_EP_ATTR_TYPE_M) ==
USB_EP_ATTR_BULK)
{
//
// See if this is bulk IN or bulk OUT.
//
if(psEndpointDescriptor->bEndpointAddress & USB_EP_DESC_IN)
{
//
// Allocate the USB Pipe for this Bulk IN endpoint.
//
g_sUSBHMSCDevice.ui32BulkInPipe =
USBHCDPipeAllocSize(0, USBHCD_PIPE_BULK_IN,
psDevice,
readusb16_t(&(psEndpointDescriptor->wMaxPacketSize)),
0);
//
// Configure the USB pipe as a Bulk IN endpoint.
//
USBHCDPipeConfig(g_sUSBHMSCDevice.ui32BulkInPipe,
readusb16_t(&(psEndpointDescriptor->wMaxPacketSize)),
0,
(psEndpointDescriptor->bEndpointAddress &
USB_EP_DESC_NUM_M));
}
else
{
//
// Allocate the USB Pipe for this Bulk OUT endpoint.
//
g_sUSBHMSCDevice.ui32BulkOutPipe =
USBHCDPipeAllocSize(0, USBHCD_PIPE_BULK_OUT,
psDevice,
readusb16_t(&(psEndpointDescriptor->wMaxPacketSize)),
0);
//
// Configure the USB pipe as a Bulk OUT endpoint.
//
USBHCDPipeConfig(g_sUSBHMSCDevice.ui32BulkOutPipe,
readusb16_t(&(psEndpointDescriptor->wMaxPacketSize)),
0,
(psEndpointDescriptor->bEndpointAddress &
USB_EP_DESC_NUM_M));
}
}
}
//
// If the callback exists, call it with an Open event.
//
if(g_sUSBHMSCDevice.pfnCallback != 0)
{
g_sUSBHMSCDevice.pfnCallback(&g_sUSBHMSCDevice, MSC_EVENT_OPEN, 0);
}
g_sUSBHMSCDevice.ui32MaxLUN = 0xffffffff;
//
// Return the only instance of this device.
//
return(&g_sUSBHMSCDevice);
}