From 40ff317c5b2da14dfec26a313a3355977c1290e5 Mon Sep 17 00:00:00 2001
From: patacongo
Date: Thu, 26 Jan 2012 14:24:15 +0000
Subject: More clean up of namespace
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4338 42af7a65-404d-4744-a932-0658087f49c3
---
nuttx/Documentation/NuttxPortingGuide.html | 6 +-
.../arm/src/stm32/chip/stm32f40xxx_memorymap.h | 2 +-
nuttx/drivers/usbdev/Make.defs | 2 +-
nuttx/drivers/usbdev/composite.h | 2 +-
nuttx/drivers/usbdev/msc.c | 1694 -------------
nuttx/drivers/usbdev/msc.h | 689 -----
nuttx/drivers/usbdev/msc_descriptors.c | 435 ----
nuttx/drivers/usbdev/msc_scsi.c | 2664 --------------------
nuttx/drivers/usbdev/usbmsc.c | 1694 +++++++++++++
nuttx/drivers/usbdev/usbmsc.h | 689 +++++
nuttx/drivers/usbdev/usbmsc_descriptors.c | 435 ++++
nuttx/drivers/usbdev/usbmsc_scsi.c | 2664 ++++++++++++++++++++
12 files changed, 5488 insertions(+), 5488 deletions(-)
delete mode 100644 nuttx/drivers/usbdev/msc.c
delete mode 100644 nuttx/drivers/usbdev/msc.h
delete mode 100644 nuttx/drivers/usbdev/msc_descriptors.c
delete mode 100644 nuttx/drivers/usbdev/msc_scsi.c
create mode 100644 nuttx/drivers/usbdev/usbmsc.c
create mode 100644 nuttx/drivers/usbdev/usbmsc.h
create mode 100644 nuttx/drivers/usbdev/usbmsc_descriptors.c
create mode 100644 nuttx/drivers/usbdev/usbmsc_scsi.c
diff --git a/nuttx/Documentation/NuttxPortingGuide.html b/nuttx/Documentation/NuttxPortingGuide.html
index fb0a1b4a8..676e6a2e8 100644
--- a/nuttx/Documentation/NuttxPortingGuide.html
+++ b/nuttx/Documentation/NuttxPortingGuide.html
@@ -3080,7 +3080,7 @@ extern void up_ledoff(int led);
Examples:
- drivers/usbdev/usbdev_serial.c
and drivers/usbdev/usbdev_storage.c
+ drivers/usbdev/pl2303.c
and drivers/usbdev/usbmsc.c
@@ -3100,8 +3100,8 @@ extern void up_ledoff(int led);
Examples:
- The function usbdev_serialinitialize()
in the file drivers/usbdev/usbdev_serial.c
and
- the function
in the file drivers/usbdev/usbdev_storage.c
+ The function usbdev_serialinitialize()
in the file drivers/usbdev/pl2303.c
and
+ the function
in the file drivers/usbdev/usbmsc.c
diff --git a/nuttx/arch/arm/src/stm32/chip/stm32f40xxx_memorymap.h b/nuttx/arch/arm/src/stm32/chip/stm32f40xxx_memorymap.h
index c755c075b..5e7d80c00 100644
--- a/nuttx/arch/arm/src/stm32/chip/stm32f40xxx_memorymap.h
+++ b/nuttx/arch/arm/src/stm32/chip/stm32f40xxx_memorymap.h
@@ -127,7 +127,7 @@
#define STM32_UART5_BASE 0x40005000 /* 0x40005000-0x400053ff: UART5 */
#define STM32_I2C1_BASE 0x40005400 /* 0x40005400-0x400057ff: I2C1 */
#define STM32_I2C2_BASE 0x40005800 /* 0x40005800-0x40005Bff: I2C2 */
-#define STM32_I2C3_BASE 0x40005C00 /* 0x40005c00-0x40005fff: I2C3 */
+#define STM32_I2C3_BASE 0x40005c00 /* 0x40005c00-0x40005fff: I2C3 */
#define STM32_CAN1_BASE 0x40006400 /* 0x40006400-0x400067ff: bxCAN1 */
#define STM32_CAN2_BASE 0x40006800 /* 0x40006800-0x40006bff: bxCAN2 */
#define STM32_PWR_BASE 0x40007000 /* 0x40007000-0x400073ff: Power control PWR */
diff --git a/nuttx/drivers/usbdev/Make.defs b/nuttx/drivers/usbdev/Make.defs
index d5b56683e..445cf7817 100644
--- a/nuttx/drivers/usbdev/Make.defs
+++ b/nuttx/drivers/usbdev/Make.defs
@@ -46,7 +46,7 @@ ifeq ($(CONFIG_CDCACM),y)
endif
ifeq ($(CONFIG_USBMSC),y)
- CSRCS += msc.c msc_descriptors.c msc_scsi.c
+ CSRCS += usbmsc.c usbmsc_descriptors.c usbmsc_scsi.c
endif
ifeq ($(CONFIG_USBDEV_COMPOSITE),y)
diff --git a/nuttx/drivers/usbdev/composite.h b/nuttx/drivers/usbdev/composite.h
index 18ac7d53e..114754ec4 100644
--- a/nuttx/drivers/usbdev/composite.h
+++ b/nuttx/drivers/usbdev/composite.h
@@ -56,7 +56,7 @@
#endif
#ifdef CONFIG_USBMSC_COMPOSITE
-# include "msc.h"
+# include "usbmsc.h"
#endif
/****************************************************************************
diff --git a/nuttx/drivers/usbdev/msc.c b/nuttx/drivers/usbdev/msc.c
deleted file mode 100644
index a040128d8..000000000
--- a/nuttx/drivers/usbdev/msc.c
+++ /dev/null
@@ -1,1694 +0,0 @@
-/****************************************************************************
- * drivers/usbdev/msc.c
- *
- * Copyright (C) 2008-2012 Gregory Nutt. All rights reserved.
- * Author: Gregory Nutt
- *
- * Mass storage class device. Bulk-only with SCSI subclass.
- *
- * References:
- * "Universal Serial Bus Mass Storage Class, Specification Overview,"
- * Revision 1.2, USB Implementer's Forum, June 23, 2003.
- *
- * "Universal Serial Bus Mass Storage Class, Bulk-Only Transport,"
- * Revision 1.0, USB Implementer's Forum, September 31, 1999.
- *
- * "SCSI Primary Commands - 3 (SPC-3)," American National Standard
- * for Information Technology, May 4, 2005
- *
- * "SCSI Primary Commands - 4 (SPC-4)," American National Standard
- * for Information Technology, July 19, 2008
- *
- * "SCSI Block Commands -2 (SBC-2)," American National Standard
- * for Information Technology, November 13, 2004
- *
- * "SCSI Multimedia Commands - 3 (MMC-3)," American National Standard
- * for Information Technology, November 12, 2001
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- * used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include "msc.h"
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/* The internal version of the class driver */
-
-struct usbmsc_driver_s
-{
- struct usbdevclass_driver_s drvr;
- FAR struct usbmsc_dev_s *dev;
-};
-
-/* This is what is allocated */
-
-struct usbmsc_alloc_s
-{
- struct usbmsc_dev_s dev;
- struct usbmsc_driver_s drvr;
-};
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/* Class Driver Support *****************************************************/
-
-static void usbmsc_ep0incomplete(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req);
-static struct usbdev_req_s *usbmsc_allocreq(FAR struct usbdev_ep_s *ep,
- uint16_t len);
-static void usbmsc_freereq(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req);
-
-/* Class Driver Operations (most at interrupt level) ************************/
-
-static int usbmsc_bind(FAR struct usbdev_s *dev,
- FAR struct usbdevclass_driver_s *driver);
-static void usbmsc_unbind(FAR struct usbdev_s *dev);
-static int usbmsc_setup(FAR struct usbdev_s *dev,
- FAR const struct usb_ctrlreq_s *ctrl);
-static void usbmsc_disconnect(FAR struct usbdev_s *dev);
-
-/* Initialization/Uninitialization ******************************************/
-
-static void usbmsc_lununinitialize(struct usbmsc_lun_s *lun);
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
-/* Driver operations ********************************************************/
-
-static struct usbdevclass_driverops_s g_driverops =
-{
- usbmsc_bind, /* bind */
- usbmsc_unbind, /* unbind */
- usbmsc_setup, /* setup */
- usbmsc_disconnect, /* disconnect */
- NULL, /* suspend */
- NULL /* resume */
-};
-
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Class Driver Support
- ****************************************************************************/
-/****************************************************************************
- * Name: usbmsc_ep0incomplete
- *
- * Description:
- * Handle completion of EP0 control operations
- *
- ****************************************************************************/
-
-static void usbmsc_ep0incomplete(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req)
-{
- if (req->result || req->xfrd != req->len)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_REQRESULT),
- (uint16_t)-req->result);
- }
-}
-
-/****************************************************************************
- * Name: usbmsc_allocreq
- *
- * Description:
- * Allocate a request instance along with its buffer
- *
- ****************************************************************************/
-
-static struct usbdev_req_s *usbmsc_allocreq(FAR struct usbdev_ep_s *ep,
- uint16_t len)
-{
- FAR struct usbdev_req_s *req;
-
- req = EP_ALLOCREQ(ep);
- if (req != NULL)
- {
- req->len = len;
- req->buf = EP_ALLOCBUFFER(ep, len);
- if (!req->buf)
- {
- EP_FREEREQ(ep, req);
- req = NULL;
- }
- }
- return req;
-}
-
-/****************************************************************************
- * Name: usbmsc_freereq
- *
- * Description:
- * Free a request instance along with its buffer
- *
- ****************************************************************************/
-
-static void usbmsc_freereq(FAR struct usbdev_ep_s *ep, struct usbdev_req_s *req)
-{
- if (ep != NULL && req != NULL)
- {
- if (req->buf != NULL)
- {
- EP_FREEBUFFER(ep, req->buf);
- }
- EP_FREEREQ(ep, req);
- }
-}
-
-/****************************************************************************
- * Class Driver Interfaces
- ****************************************************************************/
-/****************************************************************************
- * Name: usbmsc_bind
- *
- * Description:
- * Invoked when the driver is bound to a USB device driver
- *
- ****************************************************************************/
-
-static int usbmsc_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver)
-{
- FAR struct usbmsc_dev_s *priv = ((struct usbmsc_driver_s*)driver)->dev;
- FAR struct usbmsc_req_s *reqcontainer;
- irqstate_t flags;
- int ret = OK;
- int i;
-
- usbtrace(TRACE_CLASSBIND, 0);
-
- /* Bind the structures */
-
- priv->usbdev = dev;
- dev->ep0->priv = priv;
-
- /* The configured EP0 size should match the reported EP0 size. We could
- * easily adapt to the reported EP0 size, but then we could not use the
- * const, canned descriptors.
- */
-
- DEBUGASSERT(CONFIG_USBMSC_EP0MAXPACKET == dev->ep0->maxpacket);
-
- /* Preallocate control request */
-
- priv->ctrlreq = usbmsc_allocreq(dev->ep0, USBMSC_MXDESCLEN);
- if (priv->ctrlreq == NULL)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCCTRLREQ), 0);
- ret = -ENOMEM;
- goto errout;
- }
- priv->ctrlreq->callback = usbmsc_ep0incomplete;
-
- /* Pre-allocate all endpoints... the endpoints will not be functional
- * until the SET CONFIGURATION request is processed in usbmsc_setconfig.
- * This is done here because there may be calls to kmalloc and the SET
- * CONFIGURATION processing probably occurrs within interrupt handling
- * logic where kmalloc calls will fail.
- */
-
- /* Pre-allocate the IN bulk endpoint */
-
- priv->epbulkin = DEV_ALLOCEP(dev, USBMSC_EPINBULK_ADDR, true, USB_EP_ATTR_XFER_BULK);
- if (!priv->epbulkin)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKINALLOCFAIL), 0);
- ret = -ENODEV;
- goto errout;
- }
- priv->epbulkin->priv = priv;
-
- /* Pre-allocate the OUT bulk endpoint */
-
- priv->epbulkout = DEV_ALLOCEP(dev, USBMSC_EPOUTBULK_ADDR, false, USB_EP_ATTR_XFER_BULK);
- if (!priv->epbulkout)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKOUTALLOCFAIL), 0);
- ret = -ENODEV;
- goto errout;
- }
- priv->epbulkout->priv = priv;
-
- /* Pre-allocate read requests */
-
- for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++)
- {
- reqcontainer = &priv->rdreqs[i];
- reqcontainer->req = usbmsc_allocreq(priv->epbulkout, CONFIG_USBMSC_BULKOUTREQLEN);
- if (reqcontainer->req == NULL)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDALLOCREQ),
- (uint16_t)-ret);
- ret = -ENOMEM;
- goto errout;
- }
- reqcontainer->req->priv = reqcontainer;
- reqcontainer->req->callback = usbmsc_rdcomplete;
- }
-
- /* Pre-allocate write request containers and put in a free list */
-
- for (i = 0; i < CONFIG_USBMSC_NWRREQS; i++)
- {
- reqcontainer = &priv->wrreqs[i];
- reqcontainer->req = usbmsc_allocreq(priv->epbulkin, CONFIG_USBMSC_BULKINREQLEN);
- if (reqcontainer->req == NULL)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRALLOCREQ),
- (uint16_t)-ret);
- ret = -ENOMEM;
- goto errout;
- }
- reqcontainer->req->priv = reqcontainer;
- reqcontainer->req->callback = usbmsc_wrcomplete;
-
- flags = irqsave();
- sq_addlast((sq_entry_t*)reqcontainer, &priv->wrreqlist);
- irqrestore(flags);
- }
-
- /* Report if we are selfpowered (unless we are part of a composite device) */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-#ifdef CONFIG_USBDEV_SELFPOWERED
- DEV_SETSELFPOWERED(dev);
-#endif
-
- /* And pull-up the data line for the soft connect function (unless we are
- * part of a composite device)
- */
-
- DEV_CONNECT(dev);
-#endif
- return OK;
-
-errout:
- usbmsc_unbind(dev);
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_unbind
- *
- * Description:
- * Invoked when the driver is unbound from a USB device driver
- *
- ****************************************************************************/
-
-static void usbmsc_unbind(FAR struct usbdev_s *dev)
-{
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_req_s *reqcontainer;
- irqstate_t flags;
- int i;
-
- usbtrace(TRACE_CLASSUNBIND, 0);
-
-#ifdef CONFIG_DEBUG
- if (!dev || !dev->ep0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDINVALIDARGS), 0);
- return;
- }
-#endif
-
- /* Extract reference to private data */
-
- priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv;
-
-#ifdef CONFIG_DEBUG
- if (!priv)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND1), 0);
- return;
- }
-#endif
-
- /* The worker thread should have already been stopped by the
- * driver un-initialize logic.
- */
-
- DEBUGASSERT(priv->thstate == USBMSC_STATE_TERMINATED);
-
- /* Make sure that we are not already unbound */
-
- if (priv != NULL)
- {
- /* Make sure that the endpoints have been unconfigured. If
- * we were terminated gracefully, then the configuration should
- * already have been reset. If not, then calling usbmsc_resetconfig
- * should cause the endpoints to immediately terminate all
- * transfers and return the requests to us (with result == -ESHUTDOWN)
- */
-
- usbmsc_resetconfig(priv);
- up_mdelay(50);
-
- /* Free the pre-allocated control request */
-
- if (priv->ctrlreq != NULL)
- {
- usbmsc_freereq(dev->ep0, priv->ctrlreq);
- priv->ctrlreq = NULL;
- }
-
- /* Free pre-allocated read requests (which should all have
- * been returned to the free list at this time -- we don't check)
- */
-
- for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++)
- {
- reqcontainer = &priv->rdreqs[i];
- if (reqcontainer->req)
- {
- usbmsc_freereq(priv->epbulkout, reqcontainer->req);
- reqcontainer->req = NULL;
- }
- }
-
- /* Free the bulk OUT endpoint */
-
- if (priv->epbulkout)
- {
- DEV_FREEEP(dev, priv->epbulkout);
- priv->epbulkout = NULL;
- }
-
- /* Free write requests that are not in use (which should be all
- * of them
- */
-
- flags = irqsave();
- while (!sq_empty(&priv->wrreqlist))
- {
- reqcontainer = (struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
- if (reqcontainer->req != NULL)
- {
- usbmsc_freereq(priv->epbulkin, reqcontainer->req);
- }
- }
-
- /* Free the bulk IN endpoint */
-
- if (priv->epbulkin)
- {
- DEV_FREEEP(dev, priv->epbulkin);
- priv->epbulkin = NULL;
- }
-
- irqrestore(flags);
- }
-}
-
-/****************************************************************************
- * Name: usbmsc_setup
- *
- * Description:
- * Invoked for ep0 control requests. This function probably executes
- * in the context of an interrupt handler.
- *
- ****************************************************************************/
-
-static int usbmsc_setup(FAR struct usbdev_s *dev,
- FAR const struct usb_ctrlreq_s *ctrl)
-{
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbdev_req_s *ctrlreq;
- uint16_t value;
- uint16_t index;
- uint16_t len;
- int ret = -EOPNOTSUPP;
-
-#ifdef CONFIG_DEBUG
- if (!dev || !dev->ep0 || !ctrl)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SETUPINVALIDARGS), 0);
- return -EIO;
- }
-#endif
-
- /* Extract reference to private data */
-
- usbtrace(TRACE_CLASSSETUP, ctrl->req);
- priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv;
-
-#ifdef CONFIG_DEBUG
- if (!priv || !priv->ctrlreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND2), 0);
- return -ENODEV;
- }
-#endif
- ctrlreq = priv->ctrlreq;
-
- /* Extract the little-endian 16-bit values to host order */
-
- value = GETUINT16(ctrl->value);
- index = GETUINT16(ctrl->index);
- len = GETUINT16(ctrl->len);
-
- uvdbg("type=%02x req=%02x value=%04x index=%04x len=%04x\n",
- ctrl->type, ctrl->req, value, index, len);
-
- if ((ctrl->type & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
- {
- /**********************************************************************
- * Standard Requests
- **********************************************************************/
-
- switch (ctrl->req)
- {
- case USB_REQ_GETDESCRIPTOR:
- {
- /* The value field specifies the descriptor type in the MS byte and the
- * descriptor index in the LS byte (order is little endian)
- */
-
- switch (ctrl->value[1])
- {
- /* If the mass storage device is used in as part of a composite
- * device, then the device descriptor is is provided by logic
- * in the composite device implementation.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- case USB_DESC_TYPE_DEVICE:
- {
- ret = USB_SIZEOF_DEVDESC;
- memcpy(ctrlreq->buf, usbmsc_getdevdesc(), ret);
- }
- break;
-#endif
-
- /* If the mass storage device is used in as part of a composite device,
- * then the device qualifier descriptor is provided by logic in the
- * composite device implementation.
- */
-
-#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
- case USB_DESC_TYPE_DEVICEQUALIFIER:
- {
- ret = USB_SIZEOF_QUALDESC;
- memcpy(ctrlreq->buf, usbmsc_getqualdesc(), ret);
- }
- break;
-
- case USB_DESC_TYPE_OTHERSPEEDCONFIG:
-#endif
-
- /* If the mass storage device is used in as part of a composite device,
- * then the configuration descriptor is provided by logic in the
- * composite device implementation.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- case USB_DESC_TYPE_CONFIG:
- {
-#ifdef CONFIG_USBDEV_DUALSPEED
- ret = usbmsc_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->value[1]);
-#else
- ret = usbmsc_mkcfgdesc(ctrlreq->buf);
-#endif
- }
- break;
-#endif
-
- /* If the mass storage device is used in as part of a composite device,
- * then the language string descriptor is provided by logic in the
- * composite device implementation.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- case USB_DESC_TYPE_STRING:
- {
- /* index == language code. */
-
- ret = usbmsc_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf);
- }
- break;
-#endif
-
- default:
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_GETUNKNOWNDESC), value);
- }
- break;
- }
- }
- break;
-
- case USB_REQ_SETCONFIGURATION:
- {
- if (ctrl->type == 0)
- {
- /* Signal the worker thread to instantiate the new configuration */
-
- priv->theventset |= USBMSC_EVENT_CFGCHANGE;
- priv->thvalue = value;
- pthread_cond_signal(&priv->cond);
-
- /* Return here... the response will be provided later by the
- * worker thread.
- */
-
- return OK;
- }
- }
- break;
-
- /* If the mass storage device is used in as part of a composite device,
- * then the overall composite class configuration is managed by logic
- * in the composite device implementation.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- case USB_REQ_GETCONFIGURATION:
- {
- if (ctrl->type == USB_DIR_IN)
- {
- ctrlreq->buf[0] = priv->config;
- ret = 1;
- }
- }
- break;
-#endif
-
- case USB_REQ_SETINTERFACE:
- {
- if (ctrl->type == USB_REQ_RECIPIENT_INTERFACE)
- {
- if (priv->config == USBMSC_CONFIGID &&
- index == USBMSC_INTERFACEID &&
- value == USBMSC_ALTINTERFACEID)
- {
- /* Signal to instantiate the interface change */
-
- priv->theventset |= USBMSC_EVENT_IFCHANGE;
- pthread_cond_signal(&priv->cond);
-
- /* Return here... the response will be provided later by the
- * worker thread.
- */
-
- return OK;
- }
- }
- }
- break;
-
- case USB_REQ_GETINTERFACE:
- {
- if (ctrl->type == (USB_DIR_IN|USB_REQ_RECIPIENT_INTERFACE) &&
- priv->config == USBMSC_CONFIGIDNONE)
- {
- if (index != USBMSC_INTERFACEID)
- {
- ret = -EDOM;
- }
- else
- {
- ctrlreq->buf[0] = USBMSC_ALTINTERFACEID;
- ret = 1;
- }
- }
- }
- break;
-
- default:
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNSUPPORTEDSTDREQ), ctrl->req);
- break;
- }
- }
- else
- {
- /**********************************************************************
- * Bulk-Only Mass Storage Class Requests
- **********************************************************************/
-
- /* Verify that we are configured */
-
- if (!priv->config)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOTCONFIGURED), 0);
- return ret;
- }
-
- switch (ctrl->req)
- {
- case USBMSC_REQ_MSRESET: /* Reset mass storage device and interface */
- {
- if (ctrl->type == USBMSC_TYPE_SETUPOUT && value == 0 && len == 0)
- {
- /* Only one interface is supported */
-
- if (index != USBMSC_INTERFACEID)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MSRESETNDX), index);
- ret = -EDOM;
- }
- else
- {
- /* Signal to stop the current operation and reinitialize state */
-
- priv->theventset |= USBMSC_EVENT_RESET;
- pthread_cond_signal(&priv->cond);
-
- /* Return here... the response will be provided later by the
- * worker thread.
- */
-
- return OK;
- }
- }
- }
- break;
-
- case USBMSC_REQ_GETMAXLUN: /* Return number LUNs supported */
- {
- if (ctrl->type == USBMSC_TYPE_SETUPIN && value == 0 && len == 1)
- {
- /* Only one interface is supported */
-
- if (index != USBMSC_INTERFACEID)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_GETMAXLUNNDX), index);
- ret = -EDOM;
- }
- else
- {
- ctrlreq->buf[0] = priv->nluns - 1;
- ret = 1;
- }
- }
- }
- break;
-
- default:
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BADREQUEST), index);
- break;
- }
- }
-
- /* Respond to the setup command if data was returned. On an error return
- * value (ret < 0), the USB driver will stall EP0.
- */
-
- if (ret >= 0)
- {
- ctrlreq->len = MIN(len, ret);
- ctrlreq->flags = USBDEV_REQFLAGS_NULLPKT;
- ret = EP_SUBMIT(dev->ep0, ctrlreq);
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPRESPQ), (uint16_t)-ret);
-#if 0 /* Not necessary */
- ctrlreq->result = OK;
- usbmsc_ep0incomplete(dev->ep0, ctrlreq);
-#endif
- }
- }
-
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_disconnect
- *
- * Description:
- * Invoked after all transfers have been stopped, when the host is
- * disconnected. This function is probably called from the context of an
- * interrupt handler.
- *
- ****************************************************************************/
-
-static void usbmsc_disconnect(FAR struct usbdev_s *dev)
-{
- struct usbmsc_dev_s *priv;
- irqstate_t flags;
-
- usbtrace(TRACE_CLASSDISCONNECT, 0);
-
-#ifdef CONFIG_DEBUG
- if (!dev || !dev->ep0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DISCONNECTINVALIDARGS), 0);
- return;
- }
-#endif
-
- /* Extract reference to private data */
-
- priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv;
-
-#ifdef CONFIG_DEBUG
- if (!priv)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND3), 0);
- return;
- }
-#endif
-
- /* Reset the configuration */
-
- flags = irqsave();
- usbmsc_resetconfig(priv);
-
- /* Signal the worker thread */
-
- priv->theventset |= USBMSC_EVENT_DISCONNECT;
- pthread_cond_signal(&priv->cond);
- irqrestore(flags);
-
- /* Perform the soft connect function so that we will we can be
- * re-enumerated (unless we are part of a composite device)
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- DEV_CONNECT(dev);
-#endif
-}
-
-/****************************************************************************
- * Initialization/Un-Initialization
- ****************************************************************************/
-/****************************************************************************
- * Name: usbmsc_lununinitialize
- ****************************************************************************/
-
-static void usbmsc_lununinitialize(struct usbmsc_lun_s *lun)
-{
- /* Has a block driver has been bound to the LUN? */
-
- if (lun->inode)
- {
- /* Close the block driver */
-
- (void)close_blockdriver(lun->inode);
- }
-
- memset(lun, 0, sizeof(struct usbmsc_lun_s *));
-}
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-/****************************************************************************
- * Internal Interfaces
- ****************************************************************************/
-
-/****************************************************************************
- * Name: usbmsc_setconfig
- *
- * Description:
- * Set the device configuration by allocating and configuring endpoints and
- * by allocating and queuing read and write requests.
- *
- ****************************************************************************/
-
-int usbmsc_setconfig(FAR struct usbmsc_dev_s *priv, uint8_t config)
-{
- FAR struct usbmsc_req_s *privreq;
- FAR struct usbdev_req_s *req;
-#ifdef CONFIG_USBDEV_DUALSPEED
- FAR const struct usb_epdesc_s *epdesc;
- bool hispeed = (priv->usbdev->speed == USB_SPEED_HIGH);
- uint16_t bulkmxpacket;
-#endif
- int i;
- int ret = 0;
-
-#if CONFIG_DEBUG
- if (priv == NULL)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SETCONFIGINVALIDARGS), 0);
- return -EIO;
- }
-#endif
-
- if (config == priv->config)
- {
- /* Already configured -- Do nothing */
-
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALREADYCONFIGURED), 0);
- return OK;
- }
-
- /* Discard the previous configuration data */
-
- usbmsc_resetconfig(priv);
-
- /* Was this a request to simply discard the current configuration? */
-
- if (config == USBMSC_CONFIGIDNONE)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CONFIGNONE), 0);
- return OK;
- }
-
- /* We only accept one configuration */
-
- if (config != USBMSC_CONFIGID)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CONFIGIDBAD), 0);
- return -EINVAL;
- }
-
- /* Configure the IN bulk endpoint */
-
-#ifdef CONFIG_USBDEV_DUALSPEED
- bulkmxpacket = USBMSC_BULKMAXPACKET(hispeed);
- epdesc = USBMSC_EPBULKINDESC(hispeed);
- ret = EP_CONFIGURE(priv->epbulkin, epdesc, false);
-#else
- ret = EP_CONFIGURE(priv->epbulkin,
- usbmsc_getepdesc(USBMSC_EPFSBULKIN), false);
-#endif
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKINCONFIGFAIL), 0);
- goto errout;
- }
-
- priv->epbulkin->priv = priv;
-
- /* Configure the OUT bulk endpoint */
-
-#ifdef CONFIG_USBDEV_DUALSPEED
- epdesc = USBMSC_EPBULKOUTDESC(hispeed);
- ret = EP_CONFIGURE(priv->epbulkout, epdesc, true);
-#else
- ret = EP_CONFIGURE(priv->epbulkout,
- usbmsc_getepdesc(USBMSC_EPFSBULKOUT), true);
-#endif
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKOUTCONFIGFAIL), 0);
- goto errout;
- }
-
- priv->epbulkout->priv = priv;
-
- /* Queue read requests in the bulk OUT endpoint */
-
- for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++)
- {
- privreq = &priv->rdreqs[i];
- req = privreq->req;
- req->len = CONFIG_USBMSC_BULKOUTREQLEN;
- req->priv = privreq;
- req->callback = usbmsc_rdcomplete;
- ret = EP_SUBMIT(priv->epbulkout, req);
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDSUBMIT), (uint16_t)-ret);
- goto errout;
- }
- }
-
- priv->config = config;
- return OK;
-
-errout:
- usbmsc_resetconfig(priv);
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_resetconfig
- *
- * Description:
- * Mark the device as not configured and disable all endpoints.
- *
- ****************************************************************************/
-
-void usbmsc_resetconfig(FAR struct usbmsc_dev_s *priv)
-{
- /* Are we configured? */
-
- if (priv->config != USBMSC_CONFIGIDNONE)
- {
- /* Yes.. but not anymore */
-
- priv->config = USBMSC_CONFIGIDNONE;
-
- /* Disable endpoints. This should force completion of all pending
- * transfers.
- */
-
- EP_DISABLE(priv->epbulkin);
- EP_DISABLE(priv->epbulkout);
- }
-}
-
-/****************************************************************************
- * Name: usbmsc_wrcomplete
- *
- * Description:
- * Handle completion of write request. This function probably executes
- * in the context of an interrupt handler.
- *
- ****************************************************************************/
-
-void usbmsc_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req)
-{
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_req_s *privreq;
- irqstate_t flags;
-
- /* Sanity check */
-
-#ifdef CONFIG_DEBUG
- if (!ep || !ep->priv || !req || !req->priv)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRCOMPLETEINVALIDARGS), 0);
- return;
- }
-#endif
-
- /* Extract references to private data */
-
- priv = (FAR struct usbmsc_dev_s*)ep->priv;
- privreq = (FAR struct usbmsc_req_s *)req->priv;
-
- /* Return the write request to the free list */
-
- flags = irqsave();
- sq_addlast((sq_entry_t*)privreq, &priv->wrreqlist);
- irqrestore(flags);
-
- /* Process the received data unless this is some unusual condition */
-
- switch (req->result)
- {
- case OK: /* Normal completion */
- usbtrace(TRACE_CLASSWRCOMPLETE, req->xfrd);
- break;
-
- case -ESHUTDOWN: /* Disconnection */
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRSHUTDOWN), 0);
- break;
-
- default: /* Some other error occurred */
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRUNEXPECTED),
- (uint16_t)-req->result);
- break;
- };
-
- /* Inform the worker thread that a write request has been returned */
-
- priv->theventset |= USBMSC_EVENT_WRCOMPLETE;
- pthread_cond_signal(&priv->cond);
-}
-
-/****************************************************************************
- * Name: usbmsc_rdcomplete
- *
- * Description:
- * Handle completion of read request on the bulk OUT endpoint. This
- * is handled like the receipt of serial data on the "UART"
- *
- ****************************************************************************/
-
-void usbmsc_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req)
-{
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_req_s *privreq;
- irqstate_t flags;
- int ret;
-
- /* Sanity check */
-
-#ifdef CONFIG_DEBUG
- if (!ep || !ep->priv || !req || !req->priv)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDCOMPLETEINVALIDARGS), 0);
- return;
- }
-#endif
-
- /* Extract references to private data */
-
- priv = (FAR struct usbmsc_dev_s*)ep->priv;
- privreq = (FAR struct usbmsc_req_s *)req->priv;
-
- /* Process the received data unless this is some unusual condition */
-
- switch (req->result)
- {
- case 0: /* Normal completion */
- {
- usbtrace(TRACE_CLASSRDCOMPLETE, req->xfrd);
-
- /* Add the filled read request from the rdreqlist */
-
- flags = irqsave();
- sq_addlast((sq_entry_t*)privreq, &priv->rdreqlist);
- irqrestore(flags);
-
- /* Signal the worker thread that there is received data to be processed */
-
- priv->theventset |= USBMSC_EVENT_RDCOMPLETE;
- pthread_cond_signal(&priv->cond);
- }
- break;
-
- case -ESHUTDOWN: /* Disconnection */
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDSHUTDOWN), 0);
-
- /* Drop the read request... it will be cleaned up later */
- }
- break;
-
- default: /* Some other error occurred */
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDUNEXPECTED),
- (uint16_t)-req->result);
-
- /* Return the read request to the bulk out endpoint for re-filling */
-
- req = privreq->req;
- req->priv = privreq;
- req->callback = usbmsc_rdcomplete;
-
- ret = EP_SUBMIT(priv->epbulkout, req);
- if (ret != OK)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDCOMPLETERDSUBMIT),
- (uint16_t)-ret);
- }
- }
- break;
- }
-}
-
-/****************************************************************************
- * Name: usbmsc_deferredresponse
- *
- * Description:
- * Some EP0 setup request cannot be responded to immediately becuase they
- * require some asynchronous action from the SCSI worker thread. This
- * function is provided for the SCSI thread to make that deferred response.
- * The specific requests that require this deferred response are:
- *
- * 1. USB_REQ_SETCONFIGURATION,
- * 2. USB_REQ_SETINTERFACE, or
- * 3. USBMSC_REQ_MSRESET
- *
- * In all cases, the success reponse is a zero-length packet; the failure
- * response is an EP0 stall.
- *
- * Input parameters:
- * priv - Private state structure for this USB storage instance
- * stall - true is the action failed and a stall is required
- *
- ****************************************************************************/
-
-void usbmsc_deferredresponse(FAR struct usbmsc_dev_s *priv, bool failed)
-{
- FAR struct usbdev_s *dev;
- FAR struct usbdev_req_s *ctrlreq;
- int ret;
-
-#ifdef CONFIG_DEBUG
- if (!priv || !priv->usbdev || !priv->ctrlreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEFERREDRESPINVALIDARGS), 0);
- return;
- }
-#endif
-
- dev = priv->usbdev;
- ctrlreq = priv->ctrlreq;
-
- /* If no error occurs, respond to the deferred setup command with a null
- * packet.
- */
-
- if (!failed)
- {
- ctrlreq->len = 0;
- ctrlreq->flags = USBDEV_REQFLAGS_NULLPKT;
- ret = EP_SUBMIT(dev->ep0, ctrlreq);
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEFERREDRESPSUBMIT),
- (uint16_t)-ret);
-#if 0 /* Not necessary */
- ctrlreq->result = OK;
- usbmsc_ep0incomplete(dev->ep0, ctrlreq);
-#endif
- }
- }
- else
- {
- /* On a failure, the USB driver will stall. */
-
- usbtrace(TRACE_DEVERROR(USBMSC_TRACEERR_DEFERREDRESPSTALLED), 0);
- EP_STALL(dev->ep0);
- }
-}
-
-/****************************************************************************
- * User Interfaces
- ****************************************************************************/
-/****************************************************************************
- * Name: usbmsc_configure
- *
- * Description:
- * One-time initialization of the USB storage driver. The initialization
- * sequence is as follows:
- *
- * 1. Call usbmsc_configure to perform one-time initialization specifying
- * the number of luns.
- * 2. Call usbmsc_bindlun to configure each supported LUN
- * 3. Call usbmsc_exportluns when all LUNs are configured
- *
- * Input Parameters:
- * nluns - the number of LUNs that will be registered
- * handle - Location to return a handle that is used in other API calls.
- *
- * Returned Value:
- * 0 on success; a negated errno on failure
- *
- ****************************************************************************/
-
-int usbmsc_configure(unsigned int nluns, void **handle)
-{
- FAR struct usbmsc_alloc_s *alloc;
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_driver_s *drvr;
- int ret;
-
-#ifdef CONFIG_DEBUG
- if (nluns > 15)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_TOOMANYLUNS), 0);
- return -EDOM;
- }
-#endif
-
- /* Allocate the structures needed */
-
- alloc = (FAR struct usbmsc_alloc_s*)kmalloc(sizeof(struct usbmsc_alloc_s));
- if (!alloc)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCDEVSTRUCT), 0);
- return -ENOMEM;
- }
-
- /* Initialize the USB storage driver structure */
-
- priv = &alloc->dev;
- memset(priv, 0, sizeof(struct usbmsc_dev_s));
-
- pthread_mutex_init(&priv->mutex, NULL);
- pthread_cond_init(&priv->cond, NULL);
- sq_init(&priv->wrreqlist);
-
- priv->nluns = nluns;
-
- /* Allocate the LUN table */
-
- priv->luntab = (struct usbmsc_lun_s*)kmalloc(priv->nluns*sizeof(struct usbmsc_lun_s));
- if (!priv->luntab)
- {
- ret = -ENOMEM;
- goto errout;
- }
- memset(priv->luntab, 0, priv->nluns * sizeof(struct usbmsc_lun_s));
-
- /* Initialize the USB class driver structure */
-
- drvr = &alloc->drvr;
-#ifdef CONFIG_USBDEV_DUALSPEED
- drvr->drvr.speed = USB_SPEED_HIGH;
-#else
- drvr->drvr.speed = USB_SPEED_FULL;
-#endif
- drvr->drvr.ops = &g_driverops;
- drvr->dev = priv;
-
- /* Return the handle and success */
-
- *handle = (FAR void*)alloc;
- return OK;
-
-errout:
- usbmsc_uninitialize(alloc);
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_bindlun
- *
- * Description:
- * Bind the block driver specified by drvrpath to a USB storage LUN.
- *
- * Input Parameters:
- * handle - The handle returned by a previous call to usbmsc_configure().
- * drvrpath - the full path to the block driver
- * startsector - A sector offset into the block driver to the start of the
- * partition on drvrpath (0 if no partitions)
- * nsectors - The number of sectors in the partition (if 0, all sectors
- * to the end of the media will be exported).
- * lunno - the LUN to bind to
- *
- * Returned Value:
- * 0 on success; a negated errno on failure.
- *
- ****************************************************************************/
-
-int usbmsc_bindlun(FAR void *handle, FAR const char *drvrpath,
- unsigned int lunno, off_t startsector, size_t nsectors,
- bool readonly)
-{
- FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_lun_s *lun;
- FAR struct inode *inode;
- struct geometry geo;
- int ret;
-
-#ifdef CONFIG_DEBUG
- if (!alloc || !drvrpath || startsector < 0 || nsectors < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINLUNINVALIDARGS1), 0);
- return -EINVAL;
- }
-#endif
-
- priv = &alloc->dev;
-
-#ifdef CONFIG_DEBUG
- if (!priv->luntab)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INTERNALCONFUSION1), 0);
- return -EIO;
- }
-
- if (lunno > priv->nluns)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS2), 0);
- return -EINVAL;
- }
-#endif
-
- lun = &priv->luntab[lunno];
-
-#ifdef CONFIG_DEBUG
- if (lun->inode != NULL)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_LUNALREADYBOUND), 0);
- return -EBUSY;
- }
-#endif
-
- /* Open the block driver */
-
- ret = open_blockdriver(drvrpath, 0, &inode);
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BLKDRVEOPEN), 0);
- return ret;
- }
-
- /* Get the drive geometry */
-
- if (!inode || !inode->u.i_bops || !inode->u.i_bops->geometry ||
- inode->u.i_bops->geometry(inode, &geo) != OK || !geo.geo_available)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOGEOMETRY), 0);
- return -ENODEV;
- }
-
- /* Verify that the partition parameters are valid */
-
- if (startsector >= geo.geo_nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS3), 0);
- return -EDOM;
- }
- else if (nsectors == 0)
- {
- nsectors = geo.geo_nsectors - startsector;
- }
- else if (startsector + nsectors >= geo.geo_nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS4), 0);
- return -EDOM;
- }
-
- /* Initialize the LUN structure */
-
- memset(lun, 0, sizeof(struct usbmsc_lun_s *));
-
- /* Allocate an I/O buffer big enough to hold one hardware sector. SCSI commands
- * are processed one at a time so all LUNs may share a single I/O buffer. The
- * I/O buffer will be allocated so that is it as large as the largest block
- * device sector size
- */
-
- if (!priv->iobuffer)
- {
- priv->iobuffer = (uint8_t*)kmalloc(geo.geo_sectorsize);
- if (!priv->iobuffer)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCIOBUFFER), geo.geo_sectorsize);
- return -ENOMEM;
- }
- priv->iosize = geo.geo_sectorsize;
- }
- else if (priv->iosize < geo.geo_sectorsize)
- {
- void *tmp;
- tmp = (uint8_t*)realloc(priv->iobuffer, geo.geo_sectorsize);
- if (!tmp)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_REALLOCIOBUFFER), geo.geo_sectorsize);
- return -ENOMEM;
- }
-
- priv->iobuffer = (uint8_t*)tmp;
- priv->iosize = geo.geo_sectorsize;
- }
-
- lun->inode = inode;
- lun->startsector = startsector;
- lun->nsectors = nsectors;
- lun->sectorsize = geo.geo_sectorsize;
-
- /* If the driver does not support the write method, then this is read-only */
-
- if (!inode->u.i_bops->write)
- {
- lun->readonly = true;
- }
- return OK;
-}
-
-/****************************************************************************
- * Name: usbmsc_unbindlun
- *
- * Description:
- * Un-bind the block driver for the specified LUN
- *
- * Input Parameters:
- * handle - The handle returned by a previous call to usbmsc_configure().
- * lun - the LUN to unbind from
- *
- * Returned Value:
- * 0 on success; a negated errno on failure.
- *
- ****************************************************************************/
-
-int usbmsc_unbindlun(FAR void *handle, unsigned int lunno)
-{
- FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_lun_s *lun;
- int ret;
-
-#ifdef CONFIG_DEBUG
- if (!alloc)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDLUNINVALIDARGS1), 0);
- return -EINVAL;
- }
-#endif
-
- priv = &alloc->dev;
-
-#ifdef CONFIG_DEBUG
- if (!priv->luntab)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INTERNALCONFUSION2), 0);
- return -EIO;
- }
-
- if (lunno > priv->nluns)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDLUNINVALIDARGS2), 0);
- return -EINVAL;
- }
-#endif
-
- lun = &priv->luntab[lunno];
- pthread_mutex_lock(&priv->mutex);
-
-#ifdef CONFIG_DEBUG
- if (lun->inode == NULL)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_LUNNOTBOUND), 0);
- ret = -EBUSY;
- }
- else
-#endif
- {
- /* Close the block driver */
-
- usbmsc_lununinitialize(lun);
- ret = OK;
- }
-
- pthread_mutex_unlock(&priv->mutex);
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_exportluns
- *
- * Description:
- * After all of the LUNs have been bound, this function may be called
- * in order to export those LUNs in the USB storage device.
- *
- * Input Parameters:
- * handle - The handle returned by a previous call to usbmsc_configure().
- *
- * Returned Value:
- * 0 on success; a negated errno on failure
- *
- ****************************************************************************/
-
-int usbmsc_exportluns(FAR void *handle)
-{
- FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
- FAR struct usbmsc_dev_s *priv;
- FAR struct usbmsc_driver_s *drvr;
- irqstate_t flags;
-#ifdef SDCC
- pthread_attr_t attr;
-#endif
- int ret;
-
-#ifdef CONFIG_DEBUG
- if (!alloc)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EXPORTLUNSINVALIDARGS), 0);
- return -ENXIO;
- }
-#endif
-
- priv = &alloc->dev;
- drvr = &alloc->drvr;
-
- /* Start the worker thread */
-
- pthread_mutex_lock(&priv->mutex);
- priv->thstate = USBMSC_STATE_NOTSTARTED;
- priv->theventset = USBMSC_EVENT_NOEVENTS;
-
-#ifdef SDCC
- (void)pthread_attr_init(&attr);
- ret = pthread_create(&priv->thread, &attr, usbmsc_workerthread, (pthread_addr_t)priv);
-#else
- ret = pthread_create(&priv->thread, NULL, usbmsc_workerthread, (pthread_addr_t)priv);
-#endif
- if (ret != OK)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_THREADCREATE), (uint16_t)-ret);
- goto errout_with_mutex;
- }
-
- /* Register the USB storage class driver (unless we are part of a composite device) */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- ret = usbdev_register(&drvr->drvr);
- if (ret != OK)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEVREGISTER), (uint16_t)-ret);
- goto errout_with_mutex;
- }
-#endif
-
- /* Signal to start the thread */
-
- flags = irqsave();
- priv->theventset |= USBMSC_EVENT_READY;
- pthread_cond_signal(&priv->cond);
- irqrestore(flags);
-
-errout_with_mutex:
- pthread_mutex_unlock(&priv->mutex);
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_uninitialize
- *
- * Description:
- * Un-initialize the USB storage class driver
- *
- * Input Parameters:
- * handle - The handle returned by a previous call to usbmsc_configure().
- *
- * Returned Value:
- * None
- *
- ****************************************************************************/
-
-void usbmsc_uninitialize(FAR void *handle)
-{
- FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
- FAR struct usbmsc_dev_s *priv;
- irqstate_t flags;
-#ifdef SDCC
- pthread_addr_t result1, result2;
- pthread_attr_t attr;
-#endif
- void *value;
- int ret;
- int i;
-
-#ifdef CONFIG_DEBUG
- if (!handle)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNINITIALIZEINVALIDARGS), 0);
- return;
- }
-#endif
- priv = &alloc->dev;
-
- /* If the thread hasn't already exitted, tell it to exit now */
-
- if (priv->thstate != USBMSC_STATE_NOTSTARTED)
- {
- /* The thread was started.. Is it still running? */
-
- pthread_mutex_lock(&priv->mutex);
- if (priv->thstate != USBMSC_STATE_TERMINATED)
- {
- /* Yes.. Ask the thread to stop */
-
- flags = irqsave();
- priv->theventset |= USBMSC_EVENT_TERMINATEREQUEST;
- pthread_cond_signal(&priv->cond);
- irqrestore(flags);
- }
- pthread_mutex_unlock(&priv->mutex);
-
- /* Wait for the thread to exit. This is necessary even if the
- * thread has already exitted in order to collect the join
- * garbage
- */
-
- ret = pthread_join(priv->thread, &value);
- }
- priv->thread = 0;
-
- /* Unregister the driver (unless we are a part of a composite device */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- usbdev_unregister(&alloc->drvr.drvr);
-#endif
-
- /* Uninitialize and release the LUNs */
-
- for (i = 0; i < priv->nluns; ++i)
- {
- usbmsc_lununinitialize(&priv->luntab[i]);
- }
- kfree(priv->luntab);
-
- /* Release the I/O buffer */
-
- if (priv->iobuffer)
- {
- kfree(priv->iobuffer);
- }
-
- /* Uninitialize and release the driver structure */
-
- pthread_mutex_destroy(&priv->mutex);
- pthread_cond_destroy(&priv->cond);
-
- kfree(priv);
-}
diff --git a/nuttx/drivers/usbdev/msc.h b/nuttx/drivers/usbdev/msc.h
deleted file mode 100644
index 587649cac..000000000
--- a/nuttx/drivers/usbdev/msc.h
+++ /dev/null
@@ -1,689 +0,0 @@
-/****************************************************************************
- * drivers/usbdev/msc.h
- *
- * Copyright (C) 2008-2012 Gregory Nutt. All rights reserved.
- * Author: Gregory Nutt
- *
- * Mass storage class device. Bulk-only with SCSI subclass.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- * used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-#ifndef __DRIVERS_USBDEV_MSC_H
-#define __DRIVERS_USBDEV_MSC_H
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include
-
-#include
-#include
-#include
-#include
-#include
-
-#include
-#include
-#include
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-/* Configuration ************************************************************/
-/* If the USB mass storage device is configured as part of a composite device
- * then both CONFIG_USBDEV_COMPOSITE and CONFIG_USBMSC_COMPOSITE must be
- * defined.
- */
-
-#ifndef CONFIG_USBDEV_COMPOSITE
-# undef CONFIG_USBMSC_COMPOSITE
-#endif
-
-#if defined(CONFIG_USBMSC_COMPOSITE) && !defined(CONFIG_USBMSC_STRBASE)
-# define CONFIG_USBMSC_STRBASE (4)
-#endif
-
-/* Interface IDs. If the mass storage driver is built as a component of a
- * composite device, then the interface IDs may need to be offset.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-# undef CONFIG_USBMSC_IFNOBASE
-# define CONFIG_USBMSC_IFNOBASE 0
-#endif
-
-#ifndef CONFIG_USBMSC_IFNOBASE
-# define CONFIG_USBMSC_IFNOBASE 0
-#endif
-
-/* Number of requests in the write queue */
-
-#ifndef CONFIG_USBMSC_NWRREQS
-# define CONFIG_USBMSC_NWRREQS 4
-#endif
-
-/* Number of requests in the read queue */
-
-#ifndef CONFIG_USBMSC_NRDREQS
-# define CONFIG_USBMSC_NRDREQS 4
-#endif
-
-/* Logical endpoint numbers / max packet sizes */
-
-#ifndef CONFIG_USBMSC_EPBULKOUT
-# warning "EPBULKOUT not defined in the configuration"
-# define CONFIG_USBMSC_EPBULKOUT 2
-#endif
-
-#ifndef CONFIG_USBMSC_EPBULKIN
-# warning "EPBULKIN not defined in the configuration"
-# define CONFIG_USBMSC_EPBULKIN 3
-#endif
-
-/* Packet and request buffer sizes */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-# ifndef CONFIG_USBMSC_EP0MAXPACKET
-# define CONFIG_USBMSC_EP0MAXPACKET 64
-# endif
-#endif
-
-#ifndef CONFIG_USBMSC_BULKINREQLEN
-# ifdef CONFIG_USBDEV_DUALSPEED
-# define CONFIG_USBMSC_BULKINREQLEN 512
-# else
-# define CONFIG_USBMSC_BULKINREQLEN 64
-# endif
-#else
-# ifdef CONFIG_USBDEV_DUALSPEED
-# if CONFIG_USBMSC_BULKINREQLEN < 512
-# warning "Bulk in buffer size smaller than max packet"
-# undef CONFIG_USBMSC_BULKINREQLEN
-# define CONFIG_USBMSC_BULKINREQLEN 512
-# endif
-# else
-# if CONFIG_USBMSC_BULKINREQLEN < 64
-# warning "Bulk in buffer size smaller than max packet"
-# undef CONFIG_USBMSC_BULKINREQLEN
-# define CONFIG_USBMSC_BULKINREQLEN 64
-# endif
-# endif
-#endif
-
-#ifndef CONFIG_USBMSC_BULKOUTREQLEN
-# ifdef CONFIG_USBDEV_DUALSPEED
-# define CONFIG_USBMSC_BULKOUTREQLEN 512
-# else
-# define CONFIG_USBMSC_BULKOUTREQLEN 64
-# endif
-#else
-# ifdef CONFIG_USBDEV_DUALSPEED
-# if CONFIG_USBMSC_BULKOUTREQLEN < 512
-# warning "Bulk in buffer size smaller than max packet"
-# undef CONFIG_USBMSC_BULKOUTREQLEN
-# define CONFIG_USBMSC_BULKOUTREQLEN 512
-# endif
-# else
-# if CONFIG_USBMSC_BULKOUTREQLEN < 64
-# warning "Bulk in buffer size smaller than max packet"
-# undef CONFIG_USBMSC_BULKOUTREQLEN
-# define CONFIG_USBMSC_BULKOUTREQLEN 64
-# endif
-# endif
-#endif
-
-/* Vendor and product IDs and strings */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-# ifndef CONFIG_USBMSC_VENDORID
-# warning "CONFIG_USBMSC_VENDORID not defined"
-# define CONFIG_USBMSC_VENDORID 0x584e
-# endif
-
-# ifndef CONFIG_USBMSC_PRODUCTID
-# warning "CONFIG_USBMSC_PRODUCTID not defined"
-# define CONFIG_USBMSC_PRODUCTID 0x5342
-# endif
-
-# ifndef CONFIG_USBMSC_VERSIONNO
-# define CONFIG_USBMSC_VERSIONNO (0x0399)
-# endif
-
-# ifndef CONFIG_USBMSC_VENDORSTR
-# warning "No Vendor string specified"
-# define CONFIG_USBMSC_VENDORSTR "NuttX"
-# endif
-
-# ifndef CONFIG_USBMSC_PRODUCTSTR
-# warning "No Product string specified"
-# define CONFIG_USBMSC_PRODUCTSTR "USBdev Storage"
-# endif
-
-# undef CONFIG_USBMSC_SERIALSTR
-# define CONFIG_USBMSC_SERIALSTR "0101"
-#endif
-
-#undef CONFIG_USBMSC_CONFIGSTR
-#define CONFIG_USBMSC_CONFIGSTR "Bulk"
-
-/* Debug -- must be consistent with include/debug.h */
-
-#ifdef CONFIG_CPP_HAVE_VARARGS
-# ifdef CONFIG_DEBUG
-# ifdef CONFIG_ARCH_LOWPUTC
-# define dbgprintf(format, arg...) lib_lowprintf(format, ##arg)
-# else
-# define dbgprintf(format, arg...) lib_rawprintf(format, ##arg)
-# endif
-# else
-# define dbgprintf(x...)
-# endif
-#else
-# ifdef CONFIG_DEBUG
-# ifdef CONFIG_ARCH_LOWPUTC
-# define dbgprintf lib_lowprintf
-# else
-# define dbgprintf lib_rawprintf
-# endif
-# else
-# define dbgprintf (void)
-# endif
-#endif
-
-/* Packet and request buffer sizes */
-
-#ifndef CONFIG_USBMSC_EP0MAXPACKET
-# define CONFIG_USBMSC_EP0MAXPACKET 64
-#endif
-
-/* USB Controller */
-
-#ifndef CONFIG_USBDEV_SELFPOWERED
-# define SELFPOWERED USB_CONFIG_ATT_SELFPOWER
-#else
-# define SELFPOWERED (0)
-#endif
-
-#ifndef CONFIG_USBDEV_REMOTEWAKEUP
-# define REMOTEWAKEUP USB_CONFIG_ATTR_WAKEUP
-#else
-# define REMOTEWAKEUP (0)
-#endif
-
-#ifndef CONFIG_USBDEV_MAXPOWER
-# define CONFIG_USBDEV_MAXPOWER 100
-#endif
-
-/* Current state of the worker thread */
-
-#define USBMSC_STATE_NOTSTARTED (0) /* Thread has not yet been started */
-#define USBMSC_STATE_STARTED (1) /* Started, but is not yet initialized */
-#define USBMSC_STATE_IDLE (2) /* Started and waiting for commands */
-#define USBMSC_STATE_CMDPARSE (3) /* Processing a received command */
-#define USBMSC_STATE_CMDREAD (4) /* Processing a SCSI read command */
-#define USBMSC_STATE_CMDWRITE (5) /* Processing a SCSI write command */
-#define USBMSC_STATE_CMDFINISH (6) /* Finish command processing */
-#define USBMSC_STATE_CMDSTATUS (7) /* Processing the final status of the command */
-#define USBMSC_STATE_TERMINATED (8) /* Thread has exitted */
-
-/* Event communicated to worker thread */
-
-#define USBMSC_EVENT_NOEVENTS (0) /* There are no outstanding events */
-#define USBMSC_EVENT_READY (1 << 0) /* Initialization is complete */
-#define USBMSC_EVENT_RDCOMPLETE (1 << 1) /* A read has completed there is data to be processed */
-#define USBMSC_EVENT_WRCOMPLETE (1 << 2) /* A write has completed and a request is available */
-#define USBMSC_EVENT_TERMINATEREQUEST (1 << 3) /* Shutdown requested */
-#define USBMSC_EVENT_DISCONNECT (1 << 4) /* USB disconnect received */
-#define USBMSC_EVENT_RESET (1 << 5) /* USB storage setup reset received */
-#define USBMSC_EVENT_CFGCHANGE (1 << 6) /* USB setup configuration change received */
-#define USBMSC_EVENT_IFCHANGE (1 << 7) /* USB setup interface change received */
-#define USBMSC_EVENT_ABORTBULKOUT (1 << 8) /* SCSI receive failure */
-
-/* SCSI command flags (passed to usbmsc_setupcmd()) */
-
-#define USBMSC_FLAGS_DIRMASK (0x03) /* Bits 0-1: Data direction */
-#define USBMSC_FLAGS_DIRNONE (0x00) /* No data to send */
-#define USBMSC_FLAGS_DIRHOST2DEVICE (0x01) /* Host-to-device */
-#define USBMSC_FLAGS_DIRDEVICE2HOST (0x02) /* Device-to-host */
-#define USBMSC_FLAGS_BLOCKXFR (0x04) /* Bit 2: Command is a block transfer request */
-#define USBMSC_FLAGS_LUNNOTNEEDED (0x08) /* Bit 3: Command does not require a valid LUN */
-#define USBMSC_FLAGS_UACOKAY (0x10) /* Bit 4: Command OK if unit attention condition */
-#define USBMSC_FLAGS_RETAINSENSEDATA (0x20) /* Bit 5: Do not clear sense data */
-
-/* Descriptors **************************************************************/
-
-/* Big enough to hold our biggest descriptor */
-
-#define USBMSC_MXDESCLEN (64)
-
-/* String language */
-
-#define USBMSC_STR_LANGUAGE (0x0409) /* en-us */
-
-/* Descriptor strings */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-# define USBMSC_MANUFACTURERSTRID (1)
-# define USBMSC_PRODUCTSTRID (2)
-# define USBMSC_SERIALSTRID (3)
-# define USBMSC_CONFIGSTRID (4)
-# define USBMSC_INTERFACESTRID USBMSC_CONFIGSTRID
-
-# undef CONFIG_USBMSC_STRBASE
-# define CONFIG_USBMSC_STRBASE (4)
-#else
-# define USBMSC_INTERFACESTRID (CONFIG_USBMSC_STRBASE+1)
-#endif
-#define USBMSC_LASTSTRID USBMSC_INTERFACESTRID
-
-#define USBMSC_NCONFIGS (1) /* Number of configurations supported */
-
-/* Configuration Descriptor */
-
-#define USBMSC_NINTERFACES (1) /* Number of interfaces in the configuration */
-#define USBMSC_INTERFACEID (CONFIG_USBMSC_IFNOBASE+0)
-#define USBMSC_ALTINTERFACEID USBMSC_INTERFACEID
-
-#define USBMSC_CONFIGIDNONE (0) /* Config ID means to return to address mode */
-#define USBMSC_CONFIGID (1) /* The only supported configuration ID */
-
-/* Interface description */
-
-#define USBMSC_NENDPOINTS (2) /* Number of endpoints in the interface */
-
-/* Endpoint configuration */
-
-#define USBMSC_EPOUTBULK_ADDR (CONFIG_USBMSC_EPBULKOUT)
-#define USBMSC_EPOUTBULK_ATTR (USB_EP_ATTR_XFER_BULK)
-
-#define USBMSC_EPINBULK_ADDR (USB_DIR_IN|CONFIG_USBMSC_EPBULKIN)
-#define USBMSC_EPINBULK_ATTR (USB_EP_ATTR_XFER_BULK)
-
-#define USBMSC_HSBULKMAXPACKET (512)
-#define USBMSC_HSBULKMXPKTSHIFT (9)
-#define USBMSC_HSBULKMXPKTMASK (0x000001ff)
-#define USBMSC_FSBULKMAXPACKET (64)
-#define USBMSC_FSBULKMXPKTSHIFT (6)
-#define USBMSC_FSBULKMXPKTMASK (0x0000003f)
-
-/* Macros for dual speed vs. full speed only operation */
-
-#ifdef CONFIG_USBDEV_DUALSPEED
-# define USBMSC_EPBULKINDESC(hs) \
- usbmsc_getepdesc((hs) ? USBMSC_EPHSBULKIN : USBMSC_EPFSBULKIN)
-# define USBMSC_EPBULKOUTDESC(hs) \
- usbmsc_getepdesc((hs) ? USBMSC_EPHSBULKOUT : USBMSC_EPFSBULKOUT)
-# define USBMSC_BULKMAXPACKET(hs) \
- ((hs) ? USBMSC_HSBULKMAXPACKET : USBMSC_FSBULKMAXPACKET)
-# define USBMSC_BULKMXPKTSHIFT(d) \
- (((d)->speed==USB_SPEED_HIGH) ? USBMSC_HSBULKMXPKTSHIFT : USBMSC_FSBULKMXPKTSHIFT)
-# define USBMSC_BULKMXPKTMASK(d) \
- (((d)->speed==USB_SPEED_HIGH) ? USBMSC_HSBULKMXPKTMASK : USBMSC_FSBULKMXPKTMASK)
-#else
-# define USBMSC_EPBULKINDESC(d) usbmsc_getepdesc(USBMSC_EPFSBULKIN)
-# define USBMSC_EPBULKOUTDESC(d) usbmsc_getepdesc(USBMSC_EPFSBULKOUT)
-# define USBMSC_BULKMAXPACKET(hs) USBMSC_FSBULKMAXPACKET
-# define USBMSC_BULKMXPKTSHIFT(d) USBMSC_FSBULKMXPKTSHIFT
-# define USBMSC_BULKMXPKTMASK(d) USBMSC_FSBULKMXPKTMASK
-#endif
-
-/* Configuration descriptor size */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-
-/* Number of individual descriptors in the configuration descriptor:
- * (1) Configuration descriptor + (1) interface descriptor + (2) interface
- * descriptors.
- */
-
-# define USBMSC_CFGGROUP_SIZE (4)
-
-/* The size of the config descriptor: (9 + 9 + 2*7) = 32 */
-
-# define SIZEOF_USBMSC_CFGDESC \
- (USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC)
-#else
-
-/* Number of individual descriptors in the configuration descriptor:
- * (1) interface descriptor + (2) interface descriptors.
- */
-
-# define USBMSC_CFGGROUP_SIZE (3)
-
-/* The size of the config descriptor: (9 + 2*7) = 23 */
-
-# define SIZEOF_USBMSC_CFGDESC (USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC)
-#endif
-
-/* Block driver helpers *****************************************************/
-
-#define USBMSC_DRVR_READ(l,b,s,n) ((l)->inode->u.i_bops->read((l)->inode,b,s,n))
-#define USBMSC_DRVR_WRITE(l,b,s,n) ((l)->inode->u.i_bops->write((l)->inode,b,s,n))
-#define USBMSC_DRVR_GEOMETRY(l,g) ((l)->inode->u.i_bops->geometry((l)->inode,g))
-
-/* Everpresent MIN/MAX macros ***********************************************/
-
-#ifndef MIN
-# define MIN(a,b) ((a) < (b) ? (a) : (b))
-#endif
-
-#ifndef MAX
-# define MAX(a,b) ((a) > (b) ? (a) : (b))
-#endif
-
-/****************************************************************************
- * Public Types
- ****************************************************************************/
-/* Endpoint descriptors */
-
-enum usbmsc_epdesc_e
-{
- USBMSC_EPFSBULKOUT = 0, /* Full speed bulk OUT endpoint descriptor */
- USBMSC_EPFSBULKIN /* Full speed bulk IN endpoint descriptor */
-#ifdef CONFIG_USBDEV_DUALSPEED
- ,
- USBMSC_EPHSBULKOUT, /* High speed bulk OUT endpoint descriptor */
- USBMSC_EPHSBULKIN /* High speed bulk IN endpoint descriptor */
-#endif
-};
-
-/* Container to support a list of requests */
-
-struct usbmsc_req_s
-{
- FAR struct usbmsc_req_s *flink; /* Implements a singly linked list */
- FAR struct usbdev_req_s *req; /* The contained request */
-};
-
-/* This structure describes one LUN: */
-
-struct usbmsc_lun_s
-{
- struct inode *inode; /* Inode structure of open'ed block driver */
- uint8_t readonly:1; /* Media is read-only */
- uint8_t locked:1; /* Media removal is prevented */
- uint16_t sectorsize; /* The size of one sector */
- uint32_t sd; /* Sense data */
- uint32_t sdinfo; /* Sense data information */
- uint32_t uad; /* Unit needs attention data */
- off_t startsector; /* Sector offset to start of partition */
- size_t nsectors; /* Number of sectors in the partition */
-};
-
-/* Describes the overall state of the driver */
-
-struct usbmsc_dev_s
-{
- FAR struct usbdev_s *usbdev; /* usbdev driver pointer (Non-null if registered) */
-
- /* Worker thread interface */
-
- pthread_t thread; /* The worker thread */
- pthread_mutex_t mutex; /* Mutually exclusive access to resources*/
- pthread_cond_t cond; /* Used to signal worker thread */
- volatile uint8_t thstate; /* State of the worker thread */
- volatile uint16_t theventset; /* Set of pending events signaled to worker thread */
- volatile uint8_t thvalue; /* Value passed with the event (must persist) */
-
- /* Storage class configuration and state */
-
- uint8_t nluns:4; /* Number of LUNs */
- uint8_t config; /* Configuration number */
-
- /* Endpoints */
-
- FAR struct usbdev_ep_s *epbulkin; /* Bulk IN endpoint structure */
- FAR struct usbdev_ep_s *epbulkout; /* Bulk OUT endpoint structure */
- FAR struct usbdev_req_s *ctrlreq; /* Control request (for ep0 setup responses) */
-
- /* SCSI command processing */
-
- struct usbmsc_lun_s *lun; /* Currently selected LUN */
- struct usbmsc_lun_s *luntab; /* Allocated table of all LUNs */
- uint8_t cdb[USBMSC_MAXCDBLEN]; /* Command data (cdb[]) from CBW */
- uint8_t phaseerror:1; /* Need to send phase sensing status */
- uint8_t shortpacket:1; /* Host transmission stopped unexpectedly */
- uint8_t cbwdir:2; /* Direction from CBW. See USBMSC_FLAGS_DIR* definitions */
- uint8_t cdblen; /* Length of cdb[] from CBW */
- uint8_t cbwlun; /* LUN from the CBW */
- uint16_t nsectbytes; /* Bytes buffered in iobuffer[] */
- uint16_t nreqbytes; /* Bytes buffered in head write requests */
- uint16_t iosize; /* Size of iobuffer[] */
- uint32_t cbwlen; /* Length of data from CBW */
- uint32_t cbwtag; /* Tag from the CBW */
- union
- {
- uint32_t xfrlen; /* Read/Write: Sectors remaining to be transferred */
- uint32_t alloclen; /* Other device-to-host: Host allocation length */
- } u;
- uint32_t sector; /* Current sector (relative to lun->startsector) */
- uint32_t residue; /* Untransferred amount reported in the CSW */
- uint8_t *iobuffer; /* Buffer for data transfers */
-
- /* Write request list */
-
- struct sq_queue_s wrreqlist; /* List of empty write request containers */
- struct sq_queue_s rdreqlist; /* List of filled read request containers */
-
- /* Pre-allocated write request containers. The write requests will
- * be linked in a free list (wrreqlist), and used to send requests to
- * EPBULKIN; Read requests will be queued in the EBULKOUT.
- */
-
- struct usbmsc_req_s wrreqs[CONFIG_USBMSC_NWRREQS];
- struct usbmsc_req_s rdreqs[CONFIG_USBMSC_NRDREQS];
-};
-
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-
-#undef EXTERN
-#if defined(__cplusplus)
-# define EXTERN extern "C"
-extern "C"
-{
-#else
-# define EXTERN extern
-#endif
-
-/* String *******************************************************************/
-
-/* Mass storage class vendor/product/serial number strings */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-EXTERN const char g_mscvendorstr[];
-EXTERN const char g_mscproductstr[];
-EXTERN const char g_mscserialstr[];
-
-/* If we are using a composite device, then vendor/product/serial number strings
- * are provided by the composite device logic.
- */
-
-#else
-EXTERN const char g_compvendorstr[];
-EXTERN const char g_compproductstr[];
-EXTERN const char g_compserialstr[];
-
-#define g_mscvendorstr g_compvendorstr
-#define g_mscproductstr g_compproductstr
-#define g_mscserialstr g_compserialstr
-#endif
-/************************************************************************************
- * Public Function Prototypes
- ************************************************************************************/
-
-/************************************************************************************
- * Name: usbmsc_mkstrdesc
- *
- * Description:
- * Construct a string descriptor
- *
- ************************************************************************************/
-
-struct usb_strdesc_s;
-int usbmsc_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc);
-
-/************************************************************************************
- * Name: usbmsc_getepdesc
- *
- * Description:
- * Return a pointer to the raw device descriptor
- *
- ************************************************************************************/
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-FAR const struct usb_devdesc_s *usbmsc_getdevdesc(void);
-#endif
-
-/************************************************************************************
- * Name: usbmsc_getepdesc
- *
- * Description:
- * Return a pointer to the raw endpoint descriptor (used for configuring endpoints)
- *
- ************************************************************************************/
-
-struct usb_epdesc_s;
-FAR const struct usb_epdesc_s *usbmsc_getepdesc(enum usbmsc_epdesc_e epid);
-
-/************************************************************************************
- * Name: usbmsc_mkcfgdesc
- *
- * Description:
- * Construct the configuration descriptor
- *
- ************************************************************************************/
-
-#ifdef CONFIG_USBDEV_DUALSPEED
-int16_t usbmsc_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type);
-#else
-int16_t usbmsc_mkcfgdesc(FAR uint8_t *buf);
-#endif
-
-/************************************************************************************
- * Name: usbmsc_getqualdesc
- *
- * Description:
- * Return a pointer to the raw qual descriptor
- *
- ************************************************************************************/
-
-#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
-FAR const struct usb_qualdesc_s *usbmsc_getqualdesc(void);
-#endif
-
-/****************************************************************************
- * Name: usbmsc_workerthread
- *
- * Description:
- * This is the main function of the USB storage worker thread. It loops
- * until USB-related events occur, then processes those events accordingly
- *
- ****************************************************************************/
-
-EXTERN void *usbmsc_workerthread(void *arg);
-
-/****************************************************************************
- * Name: usbmsc_setconfig
- *
- * Description:
- * Set the device configuration by allocating and configuring endpoints and
- * by allocating and queue read and write requests.
- *
- ****************************************************************************/
-
-EXTERN int usbmsc_setconfig(FAR struct usbmsc_dev_s *priv, uint8_t config);
-
-/****************************************************************************
- * Name: usbmsc_resetconfig
- *
- * Description:
- * Mark the device as not configured and disable all endpoints.
- *
- ****************************************************************************/
-
-EXTERN void usbmsc_resetconfig(FAR struct usbmsc_dev_s *priv);
-
-/****************************************************************************
- * Name: usbmsc_wrcomplete
- *
- * Description:
- * Handle completion of write request. This function probably executes
- * in the context of an interrupt handler.
- *
- ****************************************************************************/
-
-EXTERN void usbmsc_wrcomplete(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req);
-
-/****************************************************************************
- * Name: usbmsc_rdcomplete
- *
- * Description:
- * Handle completion of read request on the bulk OUT endpoint. This
- * is handled like the receipt of serial data on the "UART"
- *
- ****************************************************************************/
-
-EXTERN void usbmsc_rdcomplete(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req);
-
-/****************************************************************************
- * Name: usbmsc_deferredresponse
- *
- * Description:
- * Some EP0 setup request cannot be responded to immediately becuase they
- * require some asynchronous action from the SCSI worker thread. This
- * function is provided for the SCSI thread to make that deferred response.
- * The specific requests that require this deferred response are:
- *
- * 1. USB_REQ_SETCONFIGURATION,
- * 2. USB_REQ_SETINTERFACE, or
- * 3. USBMSC_REQ_MSRESET
- *
- * In all cases, the success reponse is a zero-length packet; the failure
- * response is an EP0 stall.
- *
- * Input parameters:
- * priv - Private state structure for this USB storage instance
- * stall - true is the action failed and a stall is required
- *
- ****************************************************************************/
-
-EXTERN void usbmsc_deferredresponse(FAR struct usbmsc_dev_s *priv, bool failed);
-
-#undef EXTERN
-#if defined(__cplusplus)
-}
-#endif
-
-#endif /* #define __DRIVERS_USBDEV_MSC_H */
diff --git a/nuttx/drivers/usbdev/msc_descriptors.c b/nuttx/drivers/usbdev/msc_descriptors.c
deleted file mode 100644
index 0c86eaba9..000000000
--- a/nuttx/drivers/usbdev/msc_descriptors.c
+++ /dev/null
@@ -1,435 +0,0 @@
-/****************************************************************************
- * drivers/usbdev/msc_descriptors.c
- *
- * Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
- * Author: Gregory Nutt
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- * used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include
-
-#include
-#include
-#include
-#include
-#include
-
-#include
-#include
-
-#include "msc.h"
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-/* Descriptors **************************************************************/
-/* Device descriptor. If the USB mass storage device is configured as part
- * of a composite device, then the device descriptor will be provided by the
- * composite device logic.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-static const struct usb_devdesc_s g_devdesc =
-{
- USB_SIZEOF_DEVDESC, /* len */
- USB_DESC_TYPE_DEVICE, /* type */
- {LSBYTE(0x0200), MSBYTE(0x0200)}, /* usb */
- USB_CLASS_PER_INTERFACE, /* class */
- 0, /* subclass */
- 0, /* protocol */
- CONFIG_USBMSC_EP0MAXPACKET, /* maxpacketsize */
- { /* vendor */
- LSBYTE(CONFIG_USBMSC_VENDORID),
- MSBYTE(CONFIG_USBMSC_VENDORID)
- },
- { /* product */
- LSBYTE(CONFIG_USBMSC_PRODUCTID),
- MSBYTE(CONFIG_USBMSC_PRODUCTID) },
- { /* device */
- LSBYTE(CONFIG_USBMSC_VERSIONNO),
- MSBYTE(CONFIG_USBMSC_VERSIONNO)
- },
- USBMSC_MANUFACTURERSTRID, /* imfgr */
- USBMSC_PRODUCTSTRID, /* iproduct */
- USBMSC_SERIALSTRID, /* serno */
- USBMSC_NCONFIGS /* nconfigs */
-};
-#endif
-
-/* Configuration descriptor If the USB mass storage device is configured as part
- * of a composite device, then the configuration descriptor will be provided by the
- * composite device logic.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-static const struct usb_cfgdesc_s g_cfgdesc =
-{
- USB_SIZEOF_CFGDESC, /* len */
- USB_DESC_TYPE_CONFIG, /* type */
- {0, 0}, /* totallen -- to be provided */
- USBMSC_NINTERFACES, /* ninterfaces */
- USBMSC_CONFIGID, /* cfgvalue */
- USBMSC_CONFIGSTRID, /* icfg */
- USB_CONFIG_ATTR_ONE|SELFPOWERED|REMOTEWAKEUP, /* attr */
- (CONFIG_USBDEV_MAXPOWER + 1) / 2 /* mxpower */
-};
-#endif
-
-/* Single interface descriptor */
-
-static const struct usb_ifdesc_s g_ifdesc =
-{
- USB_SIZEOF_IFDESC, /* len */
- USB_DESC_TYPE_INTERFACE, /* type */
- USBMSC_INTERFACEID, /* ifno */
- USBMSC_ALTINTERFACEID, /* alt */
- USBMSC_NENDPOINTS, /* neps */
- USB_CLASS_MASS_STORAGE, /* class */
- USBMSC_SUBCLASS_SCSI, /* subclass */
- USBMSC_PROTO_BULKONLY, /* protocol */
- USBMSC_INTERFACESTRID /* iif */
-};
-
-/* Endpoint descriptors */
-
-static const struct usb_epdesc_s g_fsepbulkoutdesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBMSC_EPOUTBULK_ADDR, /* addr */
- USBMSC_EPOUTBULK_ATTR, /* attr */
- { /* maxpacket */
- LSBYTE(USBMSC_FSBULKMAXPACKET),
- MSBYTE(USBMSC_FSBULKMAXPACKET)
- },
- 0 /* interval */
-};
-
-static const struct usb_epdesc_s g_fsepbulkindesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBMSC_EPINBULK_ADDR, /* addr */
- USBMSC_EPINBULK_ATTR, /* attr */
- { /* maxpacket */
- LSBYTE(USBMSC_FSBULKMAXPACKET),
- MSBYTE(USBMSC_FSBULKMAXPACKET)
- },
- 0 /* interval */
-};
-
-#ifdef CONFIG_USBDEV_DUALSPEED
-#ifndef CONFIG_USBMSC_COMPOSITE
-static const struct usb_qualdesc_s g_qualdesc =
-{
- USB_SIZEOF_QUALDESC, /* len */
- USB_DESC_TYPE_DEVICEQUALIFIER, /* type */
- { /* usb */
- LSBYTE(0x0200),
- MSBYTE(0x0200)
- },
- USB_CLASS_PER_INTERFACE, /* class */
- 0, /* subclass */
- 0, /* protocol */
- CONFIG_USBMSC_EP0MAXPACKET, /* mxpacketsize */
- USBMSC_NCONFIGS, /* nconfigs */
- 0, /* reserved */
-};
-#endif
-
-static const struct usb_epdesc_s g_hsepbulkoutdesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBMSC_EPOUTBULK_ADDR, /* addr */
- USBMSC_EPOUTBULK_ATTR, /* attr */
- { /* maxpacket */
- LSBYTE(USBMSC_HSBULKMAXPACKET),
- MSBYTE(USBMSC_HSBULKMAXPACKET)
- },
- 0 /* interval */
-};
-
-static const struct usb_epdesc_s g_hsepbulkindesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBMSC_EPINBULK_ADDR, /* addr */
- USBMSC_EPINBULK_ATTR, /* attr */
- { /* maxpacket */
- LSBYTE(USBMSC_HSBULKMAXPACKET),
- MSBYTE(USBMSC_HSBULKMAXPACKET)
- },
- 0 /* interval */
-};
-#endif
-
-/****************************************************************************
- * Public Data
- ****************************************************************************/
-/* Strings ******************************************************************/
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-const char g_mscvendorstr[] = CONFIG_USBMSC_VENDORSTR;
-const char g_mscproductstr[] = CONFIG_USBMSC_PRODUCTSTR;
-const char g_mscserialstr[] = CONFIG_USBMSC_SERIALSTR;
-#endif
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: usbmsc_mkstrdesc
- *
- * Description:
- * Construct a string descriptor
- *
- ****************************************************************************/
-
-int usbmsc_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
-{
- const char *str;
- int len;
- int ndata;
- int i;
-
- switch (id)
- {
-#ifndef CONFIG_USBMSC_COMPOSITE
- case 0:
- {
- /* Descriptor 0 is the language id */
-
- strdesc->len = 4;
- strdesc->type = USB_DESC_TYPE_STRING;
- strdesc->data[0] = LSBYTE(USBMSC_STR_LANGUAGE);
- strdesc->data[1] = MSBYTE(USBMSC_STR_LANGUAGE);
- return 4;
- }
-
- case USBMSC_MANUFACTURERSTRID:
- str = g_mscvendorstr;
- break;
-
- case USBMSC_PRODUCTSTRID:
- str = g_mscproductstr;
- break;
-
- case USBMSC_SERIALSTRID:
- str = g_mscserialstr;
- break;
-#endif
-
- /* case USBMSC_CONFIGSTRID: */
- case USBMSC_INTERFACESTRID:
- str = CONFIG_USBMSC_CONFIGSTR;
- break;
-
- default:
- return -EINVAL;
- }
-
- /* The string is utf16-le. The poor man's utf-8 to utf16-le
- * conversion below will only handle 7-bit en-us ascii
- */
-
- len = strlen(str);
- for (i = 0, ndata = 0; i < len; i++, ndata += 2)
- {
- strdesc->data[ndata] = str[i];
- strdesc->data[ndata+1] = 0;
- }
-
- strdesc->len = ndata+2;
- strdesc->type = USB_DESC_TYPE_STRING;
- return strdesc->len;
-}
-
-/****************************************************************************
- * Name: usbmsc_getepdesc
- *
- * Description:
- * Return a pointer to the raw device descriptor
- *
- ****************************************************************************/
-
-#ifndef CONFIG_USBMSC_COMPOSITE
-FAR const struct usb_devdesc_s *usbmsc_getdevdesc(void)
-{
- return &g_devdesc;
-}
-#endif
-
-/****************************************************************************
- * Name: usbmsc_getepdesc
- *
- * Description:
- * Return a pointer to the raw endpoint descriptor (used for configuring
- * endpoints)
- *
- ****************************************************************************/
-
-FAR const struct usb_epdesc_s *usbmsc_getepdesc(enum usbmsc_epdesc_e epid)
-{
- switch (epid)
- {
- case USBMSC_EPFSBULKOUT: /* Full speed bulk OUT endpoint descriptor */
- return &g_fsepbulkoutdesc;
-
- case USBMSC_EPFSBULKIN: /* Full speed bulk IN endpoint descriptor */
- return &g_fsepbulkindesc;
-
-#ifdef CONFIG_USBDEV_DUALSPEED
- case USBMSC_EPHSBULKOUT: /* High speed bulk OUT endpoint descriptor */
- return &g_hsepbulkoutdesc;
-
- case USBMSC_EPHSBULKIN: /* High speed bulk IN endpoint descriptor */
- return &g_hsepbulkindesc;
-#endif
- default:
- return NULL;
- }
-};
-
-/****************************************************************************
- * Name: usbmsc_mkcfgdesc
- *
- * Description:
- * Construct the configuration descriptor
- *
- ****************************************************************************/
-
-#ifdef CONFIG_USBDEV_DUALSPEED
-int16_t usbmsc_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type)
-#else
-int16_t usbmsc_mkcfgdesc(uint8_t *buf)
-#endif
-{
-#ifndef CONFIG_USBMSC_COMPOSITE
- FAR struct usb_cfgdesc_s *cfgdesc = (struct usb_cfgdesc_s*)buf;
-#endif
-#ifdef CONFIG_USBDEV_DUALSPEED
- FAR const struct usb_epdesc_s *epdesc;
- bool hispeed = (speed == USB_SPEED_HIGH);
- uint16_t bulkmxpacket;
-#endif
- uint16_t totallen;
-
- /* This is the total length of the configuration (not necessarily the
- * size that we will be sending now.
- */
-
- totallen = USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + USBMSC_NENDPOINTS * USB_SIZEOF_EPDESC;
-
- /* Configuration descriptor -- Copy the canned descriptor and fill in the
- * type (we'll also need to update the size below). If the USB mass storage
- * device is configured as part of a composite device, then the configuration
- * descriptor will be provided by the composite device logic.
- */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- memcpy(cfgdesc, &g_cfgdesc, USB_SIZEOF_CFGDESC);
- buf += USB_SIZEOF_CFGDESC;
-#endif
-
- /* Copy the canned interface descriptor */
-
- memcpy(buf, &g_ifdesc, USB_SIZEOF_IFDESC);
- buf += USB_SIZEOF_IFDESC;
-
- /* Make the two endpoint configurations */
-
-#ifdef CONFIG_USBDEV_DUALSPEED
- /* Check for switches between high and full speed */
-
- hispeed = (speed == USB_SPEED_HIGH);
- if (type == USB_DESC_TYPE_OTHERSPEEDCONFIG)
- {
- hispeed = !hispeed;
- }
-
- bulkmxpacket = USBMSC_BULKMAXPACKET(hispeed);
- epdesc = USBMSC_EPBULKINDESC(hispeed);
- memcpy(buf, epdesc, USB_SIZEOF_EPDESC);
- buf += USB_SIZEOF_EPDESC;
-
- epdesc = USBMSC_EPBULKOUTDESC(hispeed);
- memcpy(buf, epdesc, USB_SIZEOF_EPDESC);
-#else
- memcpy(buf, &g_fsepbulkoutdesc, USB_SIZEOF_EPDESC);
- buf += USB_SIZEOF_EPDESC;
- memcpy(buf, &g_fsepbulkindesc, USB_SIZEOF_EPDESC);
-#endif
-
- /* Finally, fill in the total size of the configuration descriptor */
-
-#ifndef CONFIG_USBMSC_COMPOSITE
- cfgdesc->totallen[0] = LSBYTE(totallen);
- cfgdesc->totallen[1] = MSBYTE(totallen);
-#endif
- return totallen;
-}
-
-/****************************************************************************
- * Name: usbmsc_getqualdesc
- *
- * Description:
- * Return a pointer to the raw qual descriptor
- *
- ****************************************************************************/
-
-#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
-FAR const struct usb_qualdesc_s *usbmsc_getqualdesc(void)
-{
- return &g_qualdesc;
-}
-#endif
-
diff --git a/nuttx/drivers/usbdev/msc_scsi.c b/nuttx/drivers/usbdev/msc_scsi.c
deleted file mode 100644
index 0af86011f..000000000
--- a/nuttx/drivers/usbdev/msc_scsi.c
+++ /dev/null
@@ -1,2664 +0,0 @@
-/****************************************************************************
- * drivers/usbdev/msc_scsi.c
- *
- * Copyright (C) 2008-2010, 2012 Gregory Nutt. All rights reserved.
- * Author: Gregory Nutt
- *
- * Mass storage class device. Bulk-only with SCSI subclass.
- *
- * References:
- * "Universal Serial Bus Mass Storage Class, Specification Overview,"
- * Revision 1.2, USB Implementer's Forum, June 23, 2003.
- *
- * "Universal Serial Bus Mass Storage Class, Bulk-Only Transport,"
- * Revision 1.0, USB Implementer's Forum, September 31, 1999.
- *
- * "SCSI Primary Commands - 3 (SPC-3)," American National Standard
- * for Information Technology, May 4, 2005
- *
- * "SCSI Primary Commands - 4 (SPC-4)," American National Standard
- * for Information Technology, July 19, 2008
- *
- * "SCSI Block Commands -2 (SBC-2)," American National Standard
- * for Information Technology, November 13, 2004
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * 3. Neither the name NuttX nor the names of its contributors may be
- * used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
- * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- ****************************************************************************/
-
-/****************************************************************************
- * Included Files
- ****************************************************************************/
-
-#include
-
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-#include
-
-#include
-#include
-#include
-#include
-#include
-
-#include "msc.h"
-
-/****************************************************************************
- * Pre-processor Definitions
- ****************************************************************************/
-
-/* Configuration ************************************************************/
-
-/* Race condition workaround found by David Hewson. This race condition
- * "seems to relate to stalling the endpoint when a short response is
- * generated which causes a residue to exist when the CSW would be returned.
- * I think there's two issues here. The first being if the transfer which
- * had just been queued before the stall had not completed then it wouldn’t
- * then complete once the endpoint was stalled? The second is that the
- * subsequent transfer for the CSW would be dropped on the floor (by the
- * epsubmit() function) if the end point was still stalled as the control
- * transfer to resume it hadn't occurred."
- */
-
-#define CONFIG_USBMSC_RACEWAR 1
-
-/****************************************************************************
- * Private Types
- ****************************************************************************/
-
-/****************************************************************************
- * Private Function Prototypes
- ****************************************************************************/
-
-/* Debug ********************************************************************/
-
-#if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB)
-static void usbmsc_dumpdata(const char *msg, const uint8_t *buf,
- int buflen);
-#else
-# define usbmsc_dumpdata(msg, buf, len)
-#endif
-
-/* Utility Support Functions ************************************************/
-
-static uint16_t usbmsc_getbe16(uint8_t *buf);
-static uint32_t usbmsc_getbe32(uint8_t *buf);
-static void usbmsc_putbe16(uint8_t * buf, uint16_t val);
-static void usbmsc_putbe24(uint8_t *buf, uint32_t val);
-static void usbmsc_putbe32(uint8_t *buf, uint32_t val);
-#if 0 /* not used */
-static uint16_t usbmsc_getle16(uint8_t *buf);
-#endif
-static uint32_t usbmsc_getle32(uint8_t *buf);
-#if 0 /* not used */
-static void usbmsc_putle16(uint8_t * buf, uint16_t val);
-#endif
-static void usbmsc_putle32(uint8_t *buf, uint32_t val);
-
-/* SCSI Command Processing **************************************************/
-
-static inline int usbmsc_cmdtestunitready(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdrequestsense(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf);
-static inline int usbmsc_cmdread6(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdwrite6(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdinquiry(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf);
-static inline int usbmsc_cmdmodeselect6(FAR struct usbmsc_dev_s *priv);
-static int usbmsc_modepage(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf, uint8_t pcpgcode, int *mdlen);
-static inline int usbmsc_cmdmodesense6(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf);
-static inline int usbmsc_cmdstartstopunit(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdpreventmediumremoval(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdreadformatcapacity(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf);
-static inline int usbmsc_cmdreadcapacity10(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf);
-static inline int usbmsc_cmdread10(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdwrite10(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdverify10(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdsynchronizecache10(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdmodeselect10(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdmodesense10(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf);
-static inline int usbmsc_cmdread12(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_cmdwrite12(FAR struct usbmsc_dev_s *priv);
-static inline int usbmsc_setupcmd(FAR struct usbmsc_dev_s *priv,
- uint8_t cdblen, uint8_t flags);
-
-/* SCSI Worker Thread *******************************************************/
-
-static int usbmsc_idlestate(FAR struct usbmsc_dev_s *priv);
-static int usbmsc_cmdparsestate(FAR struct usbmsc_dev_s *priv);
-static int usbmsc_cmdreadstate(FAR struct usbmsc_dev_s *priv);
-static int usbmsc_cmdwritestate(FAR struct usbmsc_dev_s *priv);
-static int usbmsc_cmdfinishstate(FAR struct usbmsc_dev_s *priv);
-static int usbmsc_cmdstatusstate(FAR struct usbmsc_dev_s *priv);
-
-/****************************************************************************
- * Private Data
- ****************************************************************************/
-
-/****************************************************************************
- * Private Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Debug
- ****************************************************************************/
-
-/****************************************************************************
- * Name: usbmsc_dumpdata
- ****************************************************************************/
-
-#if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB)
-static void usbmsc_dumpdata(const char *msg, const uint8_t *buf, int buflen)
-{
- int i;
-
- dbgprintf("%s:", msg);
- for (i = 0; i < buflen; i++)
- {
- dbgprintf(" %02x", buf[i]);
- }
- dbgprintf("\n");
-}
-#endif
-
-/****************************************************************************
- * Utility Support Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: usbmsc_getbe16
- *
- * Description:
- * Get a 16-bit big-endian value reference by the byte pointer
- *
- ****************************************************************************/
-
-static uint16_t usbmsc_getbe16(uint8_t *buf)
-{
- return ((uint16_t)buf[0] << 8) | ((uint16_t)buf[1]);
-}
-
-/****************************************************************************
- * Name: usbmsc_getbe32
- *
- * Description:
- * Get a 32-bit big-endian value reference by the byte pointer
- *
- ****************************************************************************/
-
-static uint32_t usbmsc_getbe32(uint8_t *buf)
-{
- return ((uint32_t)buf[0] << 24) | ((uint32_t)buf[1] << 16) |
- ((uint32_t)buf[2] << 8) | ((uint32_t)buf[3]);
-}
-
-/****************************************************************************
- * Name: usbmsc_putbe16
- *
- * Description:
- * Store a 16-bit value in big-endian order to the location specified by
- * a byte pointer
- *
- ****************************************************************************/
-
-static void usbmsc_putbe16(uint8_t * buf, uint16_t val)
-{
- buf[0] = val >> 8;
- buf[1] = val;
-}
-
-/****************************************************************************
- * Name: usbmsc_putbe24
- *
- * Description:
- * Store a 32-bit value in big-endian order to the location specified by
- * a byte pointer
- *
- ****************************************************************************/
-
-static void usbmsc_putbe24(uint8_t *buf, uint32_t val)
-{
- buf[0] = val >> 16;
- buf[1] = val >> 8;
- buf[2] = val;
-}
-
-/****************************************************************************
- * Name: usbmsc_putbe32
- *
- * Description:
- * Store a 32-bit value in big-endian order to the location specified by
- * a byte pointer
- *
- ****************************************************************************/
-
-static void usbmsc_putbe32(uint8_t *buf, uint32_t val)
-{
- buf[0] = val >> 24;
- buf[1] = val >> 16;
- buf[2] = val >> 8;
- buf[3] = val;
-}
-
-/****************************************************************************
- * Name: usbmsc_getle16
- *
- * Description:
- * Get a 16-bit little-endian value reference by the byte pointer
- *
- ****************************************************************************/
-
-#if 0 /* not used */
-static uint16_t usbmsc_getle16(uint8_t *buf)
-{
- return ((uint16_t)buf[1] << 8) | ((uint16_t)buf[0]);
-}
-#endif
-
-/****************************************************************************
- * Name: usbmsc_getle32
- *
- * Description:
- * Get a 32-bit little-endian value reference by the byte pointer
- *
- ****************************************************************************/
-
-static uint32_t usbmsc_getle32(uint8_t *buf)
-{
- return ((uint32_t)buf[3] << 24) | ((uint32_t)buf[2] << 16) |
- ((uint32_t)buf[1] << 8) | ((uint32_t)buf[0]);
-}
-
-/****************************************************************************
- * Name: usbmsc_putle16
- *
- * Description:
- * Store a 16-bit value in little-endian order to the location specified by
- * a byte pointer
- *
- ****************************************************************************/
-
-#if 0 /* not used */
-static void usbmsc_putle16(uint8_t * buf, uint16_t val)
-{
- buf[0] = val;
- buf[1] = val >> 8;
-}
-#endif
-
-/****************************************************************************
- * Name: usbmsc_putle32
- *
- * Description:
- * Store a 32-bit value in little-endian order to the location specified by
- * a byte pointer
- *
- ****************************************************************************/
-
-static void usbmsc_putle32(uint8_t *buf, uint32_t val)
-{
- buf[0] = val;
- buf[1] = val >> 8;
- buf[2] = val >> 16;
- buf[3] = val >> 24;
-}
-
-/****************************************************************************
- * SCSI Worker Thread
- ****************************************************************************/
-
-/****************************************************************************
- * Name: usbmsc_cmdtestunitready
- *
- * Description:
- * Handle the SCSI_CMD_TESTUNITREADY command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdtestunitready(FAR struct usbmsc_dev_s *priv)
-{
- int ret;
-
- priv->u.alloclen = 0;
- ret = usbmsc_setupcmd(priv, 6, USBMSC_FLAGS_DIRNONE);
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdrequestsense
- *
- * Description:
- * Handle the SCSI_CMD_REQUESTSENSE command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdrequestsense(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf)
-{
- FAR struct scsicmd_requestsense_s *request = (FAR struct scsicmd_requestsense_s *)priv->cdb;
- FAR struct scsiresp_fixedsensedata_s *response = (FAR struct scsiresp_fixedsensedata_s *)buf;
- FAR struct usbmsc_lun_s *lun;
- uint32_t sd;
- uint32_t sdinfo;
- uint8_t cdblen;
- int ret;
-
- /* Extract the host allocation length */
-
- priv->u.alloclen = request->alloclen;
-
- /* Get the expected length of the command (with hack for MS-Windows 12-byte
- * REQUEST SENSE command.
- */
-
- cdblen = SCSICMD_REQUESTSENSE_SIZEOF;
- if (cdblen != priv->cdblen)
- {
- /* Try MS-Windows REQUEST SENSE with cbw->cdblen == 12 */
-
- cdblen = SCSICMD_REQUESTSENSE_MSSIZEOF;
- }
-
- ret = usbmsc_setupcmd(priv, cdblen,
- USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_LUNNOTNEEDED|
- USBMSC_FLAGS_UACOKAY|USBMSC_FLAGS_RETAINSENSEDATA);
- if (ret == OK)
- {
- lun = priv->lun;
- if (!lun)
- {
- sd = SCSI_KCQIR_INVALIDLUN;
- sdinfo = 0;
- }
- else
- {
- /* Get the saved sense data from the LUN structure */
-
- sd = lun->sd;
- sdinfo = lun->sdinfo;
-
- /* Discard the sense data */
-
- lun->sd = SCSI_KCQ_NOSENSE;
- lun->sdinfo = 0;
- }
-
- /* Create the fixed sense data response */
-
- memset(response, 0, SCSIRESP_FIXEDSENSEDATA_SIZEOF);
-
- response->code = SCSIRESP_SENSEDATA_RESPVALID|SCSIRESP_SENSEDATA_CURRENTFIXED;
- response->flags = (uint8_t)(sd >> 16);
- usbmsc_putbe32(response->info, sdinfo);
- response->len = SCSIRESP_FIXEDSENSEDATA_SIZEOF - 7;
- response->code2 = (uint8_t)(sd >> 8);
- response->qual2 = (uint8_t)sd;
-
- priv->nreqbytes = SCSIRESP_FIXEDSENSEDATA_SIZEOF;
- ret = OK;
- }
-
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdread6
- *
- * Description:
- * Handle the SCSI_CMD_READ6 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdread6(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct scsicmd_read6_s *read6 = (FAR struct scsicmd_read6_s*)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.xfrlen = (uint16_t)read6->xfrlen;
- if (priv->u.xfrlen == 0)
- {
- priv->u.xfrlen = 256;
- }
-
- ret = usbmsc_setupcmd(priv, SCSICMD_READ6_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR);
- if (ret == OK)
- {
- /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
-
- priv->sector = (uint32_t)(read6->mslba & SCSICMD_READ6_MSLBAMASK) << 16 | (uint32_t)usbmsc_getbe16(read6->lslba);
-
- /* Verify that a block driver has been bound to the LUN */
-
- if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ6MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Verify that sector lies in the range supported by the block driver */
-
- else if (priv->sector >= lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ6LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- ret = -EINVAL;
- }
-
- /* Looks like we are good to go */
-
- else
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD6), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDREAD;
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdwrite6
- *
- * Description:
- * Handle the SCSI_CMD_WRITE6 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdwrite6(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct scsicmd_write6_s *write6 = (FAR struct scsicmd_write6_s *)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.xfrlen = (uint16_t)write6->xfrlen;
- if (priv->u.xfrlen == 0)
- {
- priv->u.xfrlen = 256;
- }
-
- ret = usbmsc_setupcmd(priv, SCSICMD_WRITE6_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR);
- if (ret == OK)
- {
- /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
-
- priv->sector = (uint32_t)(write6->mslba & SCSICMD_WRITE6_MSLBAMASK) << 16 | (uint32_t)usbmsc_getbe16(write6->lslba);
-
- /* Verify that a block driver has been bound to the LUN */
-
- if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Check for attempts to write to a read-only device */
-
- else if (lun->readonly)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6READONLY), 0);
- lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED;
- ret = -EINVAL;
- }
-
- /* Verify that sector lies in the range supported by the block driver */
-
- else if (priv->sector >= lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- ret = -EINVAL;
- }
-
- /* Looks like we are good to go */
-
- else
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE6), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDWRITE;
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdinquiry
- *
- * Description:
- * Handle SCSI_CMD_INQUIRY command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdinquiry(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf)
-{
- FAR struct scscicmd_inquiry_s *inquiry = (FAR struct scscicmd_inquiry_s *)priv->cdb;
- FAR struct scsiresp_inquiry_s *response = (FAR struct scsiresp_inquiry_s *)buf;
- int len;
- int ret;
-
- priv->u.alloclen = usbmsc_getbe16(inquiry->alloclen);
- ret = usbmsc_setupcmd(priv, SCSICMD_INQUIRY_SIZEOF,
- USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_LUNNOTNEEDED|USBMSC_FLAGS_UACOKAY);
- if (ret == OK)
- {
- if (!priv->lun)
- {
- response->qualtype = SCSIRESP_INQUIRYPQ_NOTCAPABLE|SCSIRESP_INQUIRYPD_UNKNOWN;
- }
- else if ((inquiry->flags != 0) || (inquiry->pagecode != 0))
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INQUIRYFLAGS), 0);
- priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
- else
- {
- memset(response, 0, SCSIRESP_INQUIRY_SIZEOF);
- priv->nreqbytes = SCSIRESP_INQUIRY_SIZEOF;
-
-#ifdef CONFIG_USBMSC_REMOVABLE
- response->flags1 = SCSIRESP_INQUIRYFLAGS1_RMB;
-#endif
- response->version = 2; /* SCSI-2 */
- response->flags2 = 2; /* SCSI-2 INQUIRY response data format */
- response->len = SCSIRESP_INQUIRY_SIZEOF - 5;
-
- /* Strings */
-
- memset(response->vendorid, ' ', 8+16+4);
-
- len = strlen(g_mscvendorstr);
- DEBUGASSERT(len <= 8);
- memcpy(response->vendorid, g_mscvendorstr, len);
-
- len = strlen(g_mscproductstr);
- DEBUGASSERT(len <= 16);
- memcpy(response->productid, g_mscproductstr, len);
-
- len = strlen(g_mscserialstr);
- DEBUGASSERT(len <= 4);
- memcpy(response->productid, g_mscserialstr, len);
- }
- }
-
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdmodeselect6
- *
- * Description:
- * Handle SCSI_CMD_MODESELECT6 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdmodeselect6(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct scsicmd_modeselect6_s *modeselect = (FAR struct scsicmd_modeselect6_s *)priv->cdb;
-
- priv->u.alloclen = modeselect->plen;
- (void)usbmsc_setupcmd(priv, SCSICMD_MODESELECT6_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE);
-
- /* Not supported */
-
- priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
- return -EINVAL;
-}
-
-/****************************************************************************
- * Name: usbmsc_modepage
- *
- * Description:
- * Common logic for usbmsc_cmdmodesense6() and usbmsc_cmdmodesense10()
- *
- ****************************************************************************/
-
-static int usbmsc_modepage(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf,
- uint8_t pcpgcode, int *mdlen)
-{
- FAR struct scsiresp_cachingmodepage_s *cmp = (FAR struct scsiresp_cachingmodepage_s *)buf;
-
- /* Saving parms not supported */
-
- if ((pcpgcode & SCSICMD_MODESENSE_PCMASK) == SCSICMD_MODESENSE_PCSAVED)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PCSAVED), 0);
- priv->lun->sd = SCSI_KCQIR_SAVINGPARMSNOTSUPPORTED;
- return -EINVAL;
- }
-
- /* Only the caching mode page is supported: */
-
- if ((pcpgcode & SCSICMD_MODESENSE_PGCODEMASK) == SCSIRESP_MODESENSE_PGCCODE_CACHING ||
- (pcpgcode & SCSICMD_MODESENSE_PGCODEMASK) == SCSIRESP_MODESENSE_PGCCODE_RETURNALL)
- {
- memset(cmp, 0, 12);
- cmp->pgcode = SCSIRESP_MODESENSE_PGCCODE_CACHING;
- cmp->len = 10; /* n-2 */
-
- /* None of the fields are changeable */
-
- if (((pcpgcode & SCSICMD_MODESENSE_PCMASK) != SCSICMD_MODESENSE_PCCHANGEABLE))
- {
- cmp->flags1 = SCSIRESP_CACHINGMODEPG_WCE; /* Write cache enable */
- cmp->dpflen[0] = 0xff; /* Disable prefetch transfer length = 0xffffffff */
- cmp->dpflen[1] = 0xff;
- cmp->maxpf[0] = 0xff; /* Maximum pre-fetch = 0xffffffff */
- cmp->maxpf[1] = 0xff;
- cmp->maxpfc[0] = 0xff; /* Maximum pref-fetch ceiling = 0xffffffff */
- cmp->maxpfc[1] = 0xff;
- }
-
- /* Return the mode data length */
-
- *mdlen = 12; /* Only the first 12-bytes of caching mode page sent */
- return OK;
- }
- else
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODEPAGEFLAGS), pcpgcode);
- priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- return -EINVAL;
- }
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdmodesense6
- *
- * Description:
- * Handle SCSI_CMD_MODESENSE6 command
- *
- ****************************************************************************/
-
-static int inline usbmsc_cmdmodesense6(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf)
-{
- FAR struct scsicmd_modesense6_s *modesense = (FAR struct scsicmd_modesense6_s *)priv->cdb;
- FAR struct scsiresp_modeparameterhdr6_s *mph = (FAR struct scsiresp_modeparameterhdr6_s *)buf;
- int mdlen;
- int ret;
-
- priv->u.alloclen = modesense->alloclen;
- ret = usbmsc_setupcmd(priv, SCSICMD_MODESENSE6_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
- if (ret == OK)
- {
- if ((modesense->flags & ~SCSICMD_MODESENSE6_DBD) != 0 || modesense->subpgcode != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODESENSE6FLAGS), 0);
- priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
- else
- {
- /* The response consists of:
- *
- * (1) A MODESENSE6-specific mode parameter header,
- * (2) A variable length list of block descriptors, and
- * (3) A variable length list of mode page formats
- */
-
- mph->type = 0; /* Medium type */
- mph->param = (priv->lun->readonly ? SCSIRESP_MODEPARMHDR_DAPARM_WP : 0x00);
- mph->bdlen = 0; /* Block descriptor length */
-
- /* There are no block descriptors, only the following mode page: */
-
- ret = usbmsc_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR6_SIZEOF], modesense->pcpgcode, &mdlen);
- if (ret == OK)
- {
- /* Store the mode data length and return the total message size */
-
- mph->mdlen = mdlen - 1;
- priv->nreqbytes = mdlen + SCSIRESP_MODEPARAMETERHDR6_SIZEOF;
- }
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdstartstopunit
- *
- * Description:
- * Handle SCSI_CMD_STARTSTOPUNIT command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdstartstopunit(FAR struct usbmsc_dev_s *priv)
-{
- int ret;
-
- priv->u.alloclen = 0;
- ret = usbmsc_setupcmd(priv, SCSICMD_STARTSTOPUNIT_SIZEOF, USBMSC_FLAGS_DIRNONE);
- if (ret == OK)
- {
-#ifndef CONFIG_USBMSC_REMOVABLE
- /* This command is not valid if the media is not removable */
-
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOTREMOVABLE), 0);
- lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
- ret = -EINVAL;
-#endif
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdpreventmediumremoval
- *
- * Description:
- * Handle SCSI_CMD_PREVENTMEDIAREMOVAL command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdpreventmediumremoval(FAR struct usbmsc_dev_s *priv)
-{
-#ifdef CONFIG_USBMSC_REMOVABLE
- FAR struct scsicmd_preventmediumremoval_s *pmr = (FAR struct scsicmd_preventmediumremoval_s *)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
-#endif
- int ret;
-
- priv->u.alloclen = 0;
- ret = usbmsc_setupcmd(priv, SCSICMD_PREVENTMEDIUMREMOVAL_SIZEOF, USBMSC_FLAGS_DIRNONE);
- if (ret == OK)
- {
-#ifndef CONFIG_USBMSC_REMOVABLE
- lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
- ret = -EINVAL;
-#else
- if ((pmr->prevent & ~SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT) != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PREVENTMEDIUMREMOVALPREVENT), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
-
- lun->locked = pmr->prevent & SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT;
-#endif
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdreadformatcapacity
- *
- * Description:
- * Handle SCSI_CMD_READFORMATCAPACITIES command (MMC)
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdreadformatcapacity(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf)
-{
- FAR struct scsicmd_readformatcapcacities_s *rfc = (FAR struct scsicmd_readformatcapcacities_s *)priv->cdb;
- FAR struct scsiresp_readformatcapacities_s *hdr;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.alloclen = usbmsc_getbe16(rfc->alloclen);
- ret = usbmsc_setupcmd(priv, SCSICMD_READFORMATCAPACITIES_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
- if (ret == OK)
- {
- hdr = (FAR struct scsiresp_readformatcapacities_s *)buf;
- memset(hdr, 0, SCSIRESP_READFORMATCAPACITIES_SIZEOF);
- hdr->listlen = SCSIRESP_CURRCAPACITYDESC_SIZEOF;
-
- /* Only the Current/Maximum Capacity Descriptor follows the header */
-
- usbmsc_putbe32(hdr->nblocks, lun->nsectors);
- hdr->type = SCIRESP_RDFMTCAPACITIES_FORMATED;
- usbmsc_putbe24(hdr->blocklen, lun->sectorsize);
- priv->nreqbytes = SCSIRESP_READFORMATCAPACITIES_SIZEOF;
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdreadcapacity10
- *
- * Description:
- * Handle SCSI_CMD_READCAPACITY10 command
- *
- ****************************************************************************/
-
-static int inline usbmsc_cmdreadcapacity10(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf)
-{
- FAR struct scsicmd_readcapacity10_s *rcc = (FAR struct scsicmd_readcapacity10_s *)priv->cdb;
- FAR struct scsiresp_readcapacity10_s *rcr = (FAR struct scsiresp_readcapacity10_s *)buf;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- uint32_t lba;
- int ret;
-
- priv->u.alloclen = SCSIRESP_READCAPACITY10_SIZEOF; /* Fake the allocation length */
- ret = usbmsc_setupcmd(priv, SCSICMD_READCAPACITY10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
- if (ret == OK)
- {
- /* Check the PMI and LBA fields */
-
- lba = usbmsc_getbe32(rcc->lba);
-
- if (rcc->pmi > 1 || (rcc->pmi == 0 && lba != 0))
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READCAPACITYFLAGS), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
- else
- {
- usbmsc_putbe32(rcr->lba, lun->nsectors - 1);
- usbmsc_putbe32(&buf[4], lun->sectorsize);
- priv->nreqbytes = SCSIRESP_READCAPACITY10_SIZEOF;
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdread10
- *
- * Description:
- * Handle SCSI_CMD_READ10 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdread10(FAR struct usbmsc_dev_s *priv)
-{
- struct scsicmd_read10_s *read10 = (struct scsicmd_read10_s*)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.xfrlen = usbmsc_getbe16(read10->xfrlen);
- ret = usbmsc_setupcmd(priv, SCSICMD_READ10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR);
- if (ret == OK)
- {
- /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
-
- priv->sector = usbmsc_getbe32(read10->lba);
-
- /* Verify that we can support this read command */
-
- if ((read10->flags & ~(SCSICMD_READ10FLAGS_DPO|SCSICMD_READ10FLAGS_FUA)) != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10FLAGS), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
-
- /* Verify that a block driver has been bound to the LUN */
-
- else if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Verify that LBA lies in the range supported by the block driver */
-
- else if (priv->sector >= lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- ret = -EINVAL;
- }
-
- /* Looks like we are good to go */
-
- else
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD10), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDREAD;
- }
- }
-
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdwrite10
- *
- * Description:
- * Handle SCSI_CMD_WRITE10 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdwrite10(FAR struct usbmsc_dev_s *priv)
-{
- struct scsicmd_write10_s *write10 = (struct scsicmd_write10_s *)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.xfrlen = usbmsc_getbe16(write10->xfrlen);
- ret = usbmsc_setupcmd(priv, SCSICMD_WRITE10_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR);
- if (ret == OK)
- {
- /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
-
- priv->sector = usbmsc_getbe32(write10->lba);
-
- /* Verify that we can support this write command */
-
- if ((write10->flags & ~(SCSICMD_WRITE10FLAGS_DPO|SCSICMD_WRITE10FLAGS_FUA)) != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10FLAGS), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
-
- /* Verify that a block driver has been bound to the LUN */
-
- else if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Check for attempts to write to a read-only device */
-
- else if (lun->readonly)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10READONLY), 0);
- lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED;
- ret = -EINVAL;
- }
-
- /* Verify that LBA lies in the range supported by the block driver */
-
- else if (priv->sector >= lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- ret = -EINVAL;
- }
-
- /* Looks like we are good to go */
-
- else
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE10), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDWRITE;
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdverify10
- *
- * Description:
- * Handle SCSI_CMD_VERIFY10 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdverify10(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct scsicmd_verify10_s *verf = (FAR struct scsicmd_verify10_s *)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- uint32_t lba;
- uint16_t blocks;
- size_t sector;
- ssize_t nread;
- int ret;
- int i;
-
- priv->u.alloclen = 0;
- ret = usbmsc_setupcmd(priv, SCSICMD_VERIFY10_SIZEOF, USBMSC_FLAGS_DIRNONE);
- if (ret == OK)
- {
- /* Verify the starting and ending LBA */
-
- lba = usbmsc_getbe32(verf->lba);
- blocks = usbmsc_getbe16(verf->len);
-
- if ((verf->flags & ~SCSICMD_VERIFY10_DPO) != 0 || verf->groupno != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10FLAGS), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
- else if (blocks == 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10NOBLOCKS), 0);
- ret = -EIO; /* No reply */
- }
-
- /* Verify that a block driver has been bound to the LUN */
-
- else if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Verify that LBA lies in the range supported by the block driver */
-
- else if (lba >= lun->nsectors || lba + blocks > lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- ret = -EINVAL;
- }
- else
- {
- /* Try to read the requested blocks */
-
- for (i = 0, sector = lba + lun->startsector; i < blocks; i++, sector++)
- {
- nread = USBMSC_DRVR_READ(lun, priv->iobuffer, sector, 1);
- if (nread < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10READFAIL), i);
- lun->sd = SCSI_KCQME_UNRRE1;
- lun->sdinfo = sector;
- ret = -EIO;
- break;
- }
- }
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdsynchronizecache10
- *
- * Description:
- * Handle SCSI_CMD_SYNCHCACHE10 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdsynchronizecache10(FAR struct usbmsc_dev_s *priv)
-{
- int ret;
-
- priv->u.alloclen = 0;
-
- /* Verify that we have the LUN structure and the block driver has been bound */
-
- if (!priv->lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SYNCCACHEMEDIANOTPRESENT), 0);
- priv->lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
- else
- {
- ret = usbmsc_setupcmd(priv, SCSICMD_SYNCHRONIZECACHE10_SIZEOF, USBMSC_FLAGS_DIRNONE);
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdmodeselect10
- *
- * Description:
- * Handle SCSI_CMD_MODESELECT10 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdmodeselect10(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct scsicmd_modeselect10_s *modeselect = (FAR struct scsicmd_modeselect10_s *)priv->cdb;
-
- priv->u.alloclen = usbmsc_getbe16(modeselect->parmlen);
- (void)usbmsc_setupcmd(priv, SCSICMD_MODESELECT10_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE);
-
- /* Not supported */
-
- priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
- return -EINVAL;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdmodesense10
- *
- * Description:
- * Handle SCSI_CMD_MODESENSE10 command
- *
- ****************************************************************************/
-
-static int inline usbmsc_cmdmodesense10(FAR struct usbmsc_dev_s *priv,
- FAR uint8_t *buf)
-{
- FAR struct scsicmd_modesense10_s *modesense = (FAR struct scsicmd_modesense10_s *)priv->cdb;
- FAR struct scsiresp_modeparameterhdr10_s *mph = (FAR struct scsiresp_modeparameterhdr10_s *)buf;
- int mdlen;
- int ret;
-
- priv->u.alloclen = usbmsc_getbe16(modesense->alloclen);
- ret = usbmsc_setupcmd(priv, SCSICMD_MODESENSE10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
- if (ret == OK)
- {
- if ((modesense->flags & ~SCSICMD_MODESENSE10_DBD) != 0 || modesense->subpgcode != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODESENSE10FLAGS), 0);
- priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
- else
- {
- /* The response consists of:
- *
- * (1) A MODESENSE6-specific mode parameter header,
- * (2) A variable length list of block descriptors, and
- * (3) A variable lengtth list of mode page formats
- */
-
- memset(mph, 0, SCSIRESP_MODEPARAMETERHDR10_SIZEOF);
- mph->param = (priv->lun->readonly ? SCSIRESP_MODEPARMHDR_DAPARM_WP : 0x00);
-
- /* There are no block descriptors, only the following mode page: */
-
- ret = usbmsc_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR10_SIZEOF], modesense->pcpgcode, &mdlen);
- if (ret == OK)
- {
- /* Store the mode data length and return the total message size */
-
- usbmsc_putbe16(mph->mdlen, mdlen - 2);
- priv->nreqbytes = mdlen + SCSIRESP_MODEPARAMETERHDR10_SIZEOF;
- }
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdread12
- *
- * Description:
- * Handle SCSI_CMD_READ12 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdread12(FAR struct usbmsc_dev_s *priv)
-{
- struct scsicmd_read12_s *read12 = (struct scsicmd_read12_s*)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.xfrlen = usbmsc_getbe32(read12->xfrlen);
- ret = usbmsc_setupcmd(priv, SCSICMD_READ12_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR);
- if (ret == OK)
- {
- /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
-
- priv->sector = usbmsc_getbe32(read12->lba);
-
- /* Verify that we can support this read command */
-
- if ((read12->flags & ~(SCSICMD_READ12FLAGS_DPO|SCSICMD_READ12FLAGS_FUA)) != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12FLAGS), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- ret = -EINVAL;
- }
-
- /* Verify that a block driver has been bound to the LUN */
-
- else if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Verify that LBA lies in the range supported by the block driver */
-
- else if (priv->sector >= lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- ret = -EINVAL;
- }
-
- /* Looks like we are good to go */
-
- else
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD12), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDREAD;
- }
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdwrite12
- *
- * Description:
- * Handle SCSI_CMD_WRITE12 command
- *
- ****************************************************************************/
-
-static inline int usbmsc_cmdwrite12(FAR struct usbmsc_dev_s *priv)
-{
- struct scsicmd_write12_s *write12 = (struct scsicmd_write12_s *)priv->cdb;
- FAR struct usbmsc_lun_s *lun = priv->lun;
- int ret;
-
- priv->u.xfrlen = usbmsc_getbe32(write12->xfrlen);
- ret = usbmsc_setupcmd(priv, SCSICMD_WRITE12_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR);
- if (ret == OK)
- {
- /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
-
- priv->sector = usbmsc_getbe32(write12->lba);
-
- /* Verify that we can support this write command */
-
- if ((write12->flags & ~(SCSICMD_WRITE12FLAGS_DPO|SCSICMD_WRITE12FLAGS_FUA)) != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12FLAGS), 0);
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- }
-
- /* Verify that a block driver has been bound to the LUN */
-
- else if (!lun->inode)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12MEDIANOTPRESENT), 0);
- lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
- ret = -EINVAL;
- }
-
- /* Check for attempts to write to a read-only device */
-
- else if (lun->readonly)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12READONLY), 0);
- lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED;
- }
-
- /* Verify that LBA lies in the range supported by the block driver */
-
- else if (priv->sector >= lun->nsectors)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12LBARANGE), 0);
- lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
- }
-
- /* Looks like we are good to go */
-
- else
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE12), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDWRITE;
- return OK;
- }
- }
-
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_setupcmd
- *
- * Description:
- * Called after each SCSI command is identified in order to perform setup
- * and verification operations that are common to all SCSI commands. This
- * function performs the following common setup operations:
- *
- * 1. Determine the direction of the response
- * 2. Verify lengths
- * 3. Setup and verify the LUN
- *
- * Includes special logic for INQUIRY and REQUESTSENSE commands
- *
- ****************************************************************************/
-
-static int inline usbmsc_setupcmd(FAR struct usbmsc_dev_s *priv, uint8_t cdblen, uint8_t flags)
-{
- FAR struct usbmsc_lun_s *lun = NULL;
- uint32_t datlen;
- uint8_t dir = flags & USBMSC_FLAGS_DIRMASK;
- int ret = OK;
-
- /* Verify the LUN and set up the current LUN reference in the
- * device structure
- */
-
- if (priv->cbwlun < priv->nluns)
- {
- /* LUN number is valid in a valid range, but the LUN is not necessarily
- * bound to a block driver. That will be checked as necessary in each
- * individual command.
- */
-
- lun = &priv->luntab[priv->cbwlun];
- priv->lun = lun;
- }
-
- /* Only a few commands may specify unsupported LUNs */
-
- else if ((flags & USBMSC_FLAGS_LUNNOTNEEDED) == 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDBADLUN), priv->cbwlun);
- ret = -EINVAL;
- }
-
- /* Extract the direction and data transfer length */
-
- dir = flags & USBMSC_FLAGS_DIRMASK; /* Expected data direction */
- datlen = 0;
- if ((flags & USBMSC_FLAGS_BLOCKXFR) == 0)
- {
- /* Non-block transfer. Data length: Host allocation to receive data
- * (only for device-to-host transfers. At present, alloclen is set
- * to zero for all host-to-device, non-block transfers.
- */
-
- datlen = priv->u.alloclen;
- }
- else if (lun)
- {
- /* Block transfer: Calculate the total size of all sectors to be transferred */
-
- datlen = priv->u.alloclen * lun->sectorsize;
- }
-
- /* Check the data direction. This was set up at the end of the
- * IDLE state when the CBW was parsed, but if there is no data,
- * then the direction is none.
- */
-
- if (datlen == 0)
- {
- /* No data.. then direction is none */
-
- dir = USBMSC_FLAGS_DIRNONE;
- }
-
- /* Compare the expected data length in the command to the data length
- * in the CBW.
- */
-
- else if (priv->cbwlen < datlen)
- {
- /* Clip to the length in the CBW and declare a phase error */
-
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR1), priv->cdb[0]);
- if ((flags & USBMSC_FLAGS_BLOCKXFR) != 0)
- {
- priv->u.alloclen = priv->cbwlen;
- }
- else
- {
- priv->u.xfrlen = priv->cbwlen / lun->sectorsize;
- }
-
- priv->phaseerror = 1;
- }
-
- /* Initialize the residue */
-
- priv->residue = priv->cbwlen;
-
- /* Conflicting data directions is a phase error */
-
- if (priv->cbwdir != dir && datlen > 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR2), priv->cdb[0]);
- priv->phaseerror = 1;
- ret = -EINVAL;
- }
-
- /* Compare the length of data in the cdb[] with the expected length
- * of the command.
- */
-
- if (cdblen != priv->cdblen)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR3), priv->cdb[0]);
- priv->phaseerror = 1;
- ret = -EINVAL;
- }
-
- if (lun)
- {
- /* Retain the sense data for the REQUEST SENSE command */
-
- if ((flags & USBMSC_FLAGS_RETAINSENSEDATA) == 0)
- {
- /* Discard the sense data */
-
- lun->sd = SCSI_KCQ_NOSENSE;
- lun->sdinfo = 0;
- }
-
- /* If a unit attention condition exists, then only a restricted set of
- * commands is permitted.
- */
-
- if (lun->uad != SCSI_KCQ_NOSENSE && (flags & USBMSC_FLAGS_UACOKAY) != 0)
- {
- /* Command not permitted */
-
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDUNEVIOLATION), priv->cbwlun);
- lun->sd = lun->uad;
- lun->uad = SCSI_KCQ_NOSENSE;
- ret = -EINVAL;
- }
- }
-
- /* The final, 1-byte field of every SCSI command is the Control field which
- * must be zero
- */
-
- if (priv->cdb[cdblen-1] != 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SCSICMDCONTROL), 0);
- if (lun)
- {
- lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
- }
- ret = -EINVAL;
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_idlestate
- *
- * Description:
- * Called from the worker thread in the USBMSC_STATE_IDLE state. Checks
- * for the receipt of a bulk CBW.
- *
- * Returned value:
- * If no new, valid CBW is available, this function returns a negated errno.
- * Otherwise, when a new CBW is successfully parsed, this function sets
- * priv->thstate to USBMSC_STATE_CMDPARSE and returns OK.
- *
- ****************************************************************************/
-
-static int usbmsc_idlestate(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct usbmsc_req_s *privreq;
- FAR struct usbdev_req_s *req;
- FAR struct usbmsc_cbw_s *cbw;
- irqstate_t flags;
- int ret = -EINVAL;
-
- /* Take a request from the rdreqlist */
-
- flags = irqsave();
- privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->rdreqlist);
- irqrestore(flags);
-
- /* Has anything been received? If not, just return an error.
- * This will cause us to remain in the IDLE state. When a USB request is
- * received, the worker thread will be awakened in the USBMSC_STATE_IDLE
- * and we will be called again.
- */
-
- if (!privreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_IDLERDREQLISTEMPTY), 0);
- return -ENOMEM;
- }
-
- req = privreq->req;
- cbw = (FAR struct usbmsc_cbw_s *)req->buf;
-
- /* Handle the CBW */
-
- usbmsc_dumpdata("SCSCI CBW", (uint8_t*)cbw, USBMSC_CBW_SIZEOF - USBMSC_MAXCDBLEN);
- usbmsc_dumpdata(" CDB", cbw->cdb, MIN(cbw->cdblen, USBMSC_MAXCDBLEN));
-
- /* Check for properly formatted CBW? */
-
- if (req->xfrd != USBMSC_CBW_SIZEOF ||
- cbw->signature[0] != 'U' ||
- cbw->signature[1] != 'S' ||
- cbw->signature[2] != 'B' ||
- cbw->signature[3] != 'C')
- {
- /* CBS BAD: Stall the bulk endpoints. If the CBW is bad we must stall the
- * bulk IN endpoint and either (1) stall the bulk OUT endpoint, or
- * (2) discard data from the endpoint.
- */
-
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDCBWSIGNATURE), 0);
- EP_STALL(priv->epbulkout);
- EP_STALL(priv->epbulkin);
- }
-
- /* Is the CBW meaningful? */
-
- else if (cbw->lun >= priv->nluns || (cbw->flags & ~USBMSC_CBWFLAG_IN) != 0 ||
- cbw->cdblen < 6 || cbw->cdblen > USBMSC_MAXCDBLEN)
- {
- /* CBS BAD: Stall the bulk endpoints. If the CBW is bad we must stall the
- * bulk IN endpoint and either (1) stall the bulk OUT endpoint, or
- * (2) discard data from the endpoint.
- */
-
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDCBWCONTENT), 0);
- EP_STALL(priv->epbulkout);
- EP_STALL(priv->epbulkin);
- }
-
- /* Save the information from the CBW */
-
- else
- {
- /* Extract the CDB and copy the whole CBD[] for later use */
-
- priv->cdblen = cbw->cdblen;
- memcpy(priv->cdb, cbw->cdb, priv->cdblen);
-
- /* Extract the data direction */
-
- if ((cbw->flags & USBMSC_CBWFLAG_IN) != 0)
- {
- /* IN: Device-to-host */
-
- priv->cbwdir = USBMSC_FLAGS_DIRDEVICE2HOST;
- }
- else
- {
- /* OUT: Host-to-device */
-
- priv->cbwdir = USBMSC_FLAGS_DIRHOST2DEVICE;
- }
-
- /* Get the max size of the data response */
-
- priv->cbwlen = usbmsc_getle32(cbw->datlen);
- if (priv->cbwlen == 0)
- {
- /* No length? Then no direction either */
-
- priv->cbwdir = USBMSC_FLAGS_DIRNONE;
- }
-
- /* Extract and save the LUN index and TAG value */
-
- priv->cbwlun = cbw->lun;
- priv->cbwtag = usbmsc_getle32(cbw->tag);
-
- /* Return the read request to the bulk out endpoint for re-filling */
-
- req = privreq->req;
- req->len = CONFIG_USBMSC_BULKOUTREQLEN;
- req->priv = privreq;
- req->callback = usbmsc_rdcomplete;
-
- if (EP_SUBMIT(priv->epbulkout, req) != OK)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_IDLERDSUBMIT), (uint16_t)-ret);
- }
-
- /* Change to the CMDPARSE state and return success */
-
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_IDLECMDPARSE), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDPARSE;
- ret = OK;
- }
-
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdparsestate
- *
- * Description:
- * Called from the worker thread in the USBMSC_STATE_CMDPARSE state.
- * This state is entered when usbmsc_idlestate obtains a valid CBW
- * containing SCSI commands. This function processes those SCSI commands.
- *
- * Returned value:
- * If no write request is available or certain other errors occur, this
- * function returns a negated errno and stays in the USBMSC_STATE_CMDPARSE
- * state. Otherwise, when the new CBW is successfully process, this
- * function sets priv->thstate to one of USBMSC_STATE_CMDREAD,
- * USBMSC_STATE_CMDWRITE, or USBMSC_STATE_CMDFINISH and returns OK.
- *
- ****************************************************************************/
-
-static int usbmsc_cmdparsestate(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct usbmsc_req_s *privreq;
- FAR uint8_t *buf;
- int ret = -EINVAL;
-
- usbmsc_dumpdata("SCSCI CDB", priv->cdb, priv->cdblen);
-
- /* Check if there is a request in the wrreqlist that we will be able to
- * use for data or status.
- */
-
- privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist);
-
- /* If there no request structures available, then just return an error.
- * This will cause us to remain in the CMDPARSE state. When a request is
- * returned, the worker thread will be awakened in the USBMSC_STATE_CMDPARSE
- * and we will be called again.
- */
-
- if (!privreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDPARSEWRREQLISTEMPTY), 0);
- return -ENOMEM;
- }
- DEBUGASSERT(privreq->req && privreq->req->buf);
- buf = privreq->req->buf;
-
- /* Assume that no errors will be encountered */
-
- priv->phaseerror = 0;
- priv->shortpacket = 0;
-
- /* No data is buffered */
-
- priv->nsectbytes = 0;
- priv->nreqbytes = 0;
-
- /* Get exclusive access to the block driver */
-
- pthread_mutex_lock(&priv->mutex);
- switch (priv->cdb[0])
- {
- case SCSI_CMD_TESTUNITREADY: /* 0x00 Mandatory */
- ret = usbmsc_cmdtestunitready(priv);
- break;
-
- /* case SCSI_CMD_REZEROUNIT: * 0x01 Obsolete
- * * 0x02 Vendor-specific */
-
- case SCSI_CMD_REQUESTSENSE: /* 0x03 Mandatory */
- ret = usbmsc_cmdrequestsense(priv, buf);
- break;
-
- /* case SCSI_CMD_FORMAT_UNIT: * 0x04 Mandatory, but not implemented
- * * 0x05 Vendor specific
- * * 0x06 Vendor specific
- * case SCSI_CMD_REASSIGNBLOCKS: * 0x07 Optional */
-
- case SCSI_CMD_READ6: /* 0x08 Mandatory */
- ret = usbmsc_cmdread6(priv);
- break;
-
- /* * 0x09 Vendor specific */
-
- case SCSI_CMD_WRITE6: /* 0x0a Optional */
- ret = usbmsc_cmdwrite6(priv);
- break;
-
- /* case SCSI_CMD_SEEK6: * 0x0b Obsolete
- * * 0x0c-0x10 Vendor specific
- * case SCSI_CMD_SPACE6: * 0x11 Vendor specific */
-
- case SCSI_CMD_INQUIRY: /* 0x12 Mandatory */
- ret = usbmsc_cmdinquiry(priv, buf);
- break;
-
- /* * 0x13-0x14 Vendor specific */
-
- case SCSI_CMD_MODESELECT6: /* 0x15 Optional */
- ret = usbmsc_cmdmodeselect6(priv);
- break;
-
- /* case SCSI_CMD_RESERVE6: * 0x16 Obsolete
- * case SCSI_CMD_RELEASE6: * 0x17 Obsolete
- * case SCSI_CMD_COPY: * 0x18 Obsolete
- * * 0x19 Vendor specific */
-
- case SCSI_CMD_MODESENSE6: /* 0x1a Optional */
- ret = usbmsc_cmdmodesense6(priv, buf);
- break;
-
- case SCSI_CMD_STARTSTOPUNIT: /* 0x1b Optional */
- ret = usbmsc_cmdstartstopunit(priv);
- break;
-
- /* case SCSI_CMD_RECEIVEDIAGNOSTICRESULTS: * 0x1c Optional
- * case SCSI_CMD_SENDDIAGNOSTIC: * 0x1d Mandatory, but not implemented */
-
- case SCSI_CMD_PREVENTMEDIAREMOVAL: /* 0x1e Optional */
- ret = usbmsc_cmdpreventmediumremoval(priv);
- break;
-
- /* * 0x20-22 Vendor specific */
- case SCSI_CMD_READFORMATCAPACITIES: /* 0x23 Vendor-specific (defined in MMC spec) */
- ret = usbmsc_cmdreadformatcapacity(priv, buf);
- break;
- /* * 0x24 Vendor specific */
-
- case SCSI_CMD_READCAPACITY10: /* 0x25 Mandatory */
- ret = usbmsc_cmdreadcapacity10(priv, buf);
- break;
-
- /* * 0x26-27 Vendor specific */
- case SCSI_CMD_READ10: /* 0x28 Mandatory */
- ret = usbmsc_cmdread10(priv);
- break;
-
- /* * 0x29 Vendor specific */
-
- case SCSI_CMD_WRITE10: /* 0x2a Optional */
- ret = usbmsc_cmdwrite10(priv);
- break;
-
- /* case SCSI_CMD_SEEK10: * 0x2b Obsolete
- * * 0x2c-2d Vendor specific
- * case SCSI_CMD_WRITEANDVERIFY: * 0x2e Optional */
-
- case SCSI_CMD_VERIFY10: /* 0x2f Optional, but needed my MS Windows */
- ret = usbmsc_cmdverify10(priv);
- break;
-
- /* case SCSI_CMD_SEARCHDATAHIGH: * 0x30 Obsolete
- * case SCSI_CMD_SEARCHDATAEQUAL: * 0x31 Obsolete
- * case SCSI_CMD_SEARCHDATALOW: * 0x32 Obsolete
- * case SCSI_CMD_SETLIMITS10: * 0x33 Obsolete
- * case SCSI_CMD_PREFETCH10: * 0x34 Optional */
-
- case SCSI_CMD_SYNCHCACHE10: /* 0x35 Optional */
- ret = usbmsc_cmdsynchronizecache10(priv);
- break;
-
- /* case SCSI_CMD_LOCKCACHE: * 0x36 Obsolete
- * case SCSI_CMD_READDEFECTDATA10: * 0x37 Optional
- * case SCSI_CMD_COMPARE: * 0x39 Obsolete
- * case SCSI_CMD_COPYANDVERIFY: * 0x3a Obsolete
- * case SCSI_CMD_WRITEBUFFER: * 0x3b Optional
- * case SCSI_CMD_READBUFFER: * 0x3c Optional
- * case SCSI_CMD_READLONG10: * 0x3e Optional
- * case SCSI_CMD_WRITELONG10: * 0x3f Optional
- * case SCSI_CMD_CHANGEDEFINITION: * 0x40 Obsolete
- * case SCSI_CMD_WRITESAME10: * 0x41 Optional
- * case SCSI_CMD_LOGSELECT: * 0x4c Optional
- * case SCSI_CMD_LOGSENSE: * 0x4d Optional
- * case SCSI_CMD_XDWRITE10: * 0x50 Optional
- * case SCSI_CMD_XPWRITE10: * 0x51 Optional
- * case SCSI_CMD_XDREAD10: * 0x52 Optional */
-
- case SCSI_CMD_MODESELECT10: /* 0x55 Optional */
- ret = usbmsc_cmdmodeselect10(priv);
- break;
-
- /* case SCSI_CMD_RESERVE10: * 0x56 Obsolete
- * case SCSI_CMD_RELEASE10: * 0x57 Obsolete */
-
- case SCSI_CMD_MODESENSE10: /* 0x5a Optional */
- ret = usbmsc_cmdmodesense10(priv, buf);
- break;
-
- /* case SCSI_CMD_PERSISTENTRESERVEIN: * 0x5e Optional
- * case SCSI_CMD_PERSISTENTRESERVEOUT: * 0x5f Optional
- * case SCSI_CMD_32: * 0x7f Optional
- * case SCSI_CMD_XDWRITEEXTENDED: * 0x80 Obsolete
- * case SCSI_CMD_REBUILD: * 0x81 Obsolete
- * case SCSI_CMD_REGENERATE: * 0x82 Obsolete
- * case SCSI_CMD_EXTENDEDCOPY: * 0x83 Optional
- * case SCSI_CMD_COPYRESULTS: * 0x84 Optional
- * case SCSI_CMD_ACCESSCONTROLIN: * 0x86 Optional
- * case SCSI_CMD_ACCESSCONTROLOUT: * 0x87 Optional
- * case SCSI_CMD_READ16: * 0x88 Optional
- * case SCSI_CMD_WRITE16: * 0x8a Optional
- * case SCSI_CMD_READATTRIBUTE: * 0x8c Optional
- * case SCSI_CMD_WRITEATTRIBUTE: * 0x8d Optional
- * case SCSI_CMD_WRITEANDVERIFY16: * 0x8e Optional
- * case SCSI_CMD_SYNCHCACHE16: * 0x91 Optional
- * case SCSI_CMD_LOCKUNLOCKACACHE: * 0x92 Optional
- * case SCSI_CMD_WRITESAME16: * 0x93 Optional
- * case SCSI_CMD_READCAPACITY16: * 0x9e Optional
- * case SCSI_CMD_READLONG16: * 0x9e Optional
- * case SCSI_CMD_WRITELONG16 * 0x9f Optional
- * case SCSI_CMD_REPORTLUNS: * 0xa0 Mandatory, but not implemented
- * case SCSI_CMD_MAINTENANCEIN: * 0xa3 Optional (SCCS==0)
- * case SCSI_CMD_MAINTENANCEOUT: * 0xa4 Optional (SCCS==0)
- * case SCSI_CMD_MOVEMEDIUM: * 0xa5 ?
- * case SCSI_CMD_MOVEMEDIUMATTACHED: * 0xa7 Optional (MCHNGR==0) */
-
- case SCSI_CMD_READ12: /* 0xa8 Optional */
- ret = usbmsc_cmdread12(priv);
- break;
-
- case SCSI_CMD_WRITE12: /* 0xaa Optional */
- ret = usbmsc_cmdwrite12(priv);
- break;
-
- /* case SCSI_CMD_READMEDIASERIALNUMBER: * 0xab Optional
- * case SCSI_CMD_WRITEANDVERIFY12: * 0xae Optional
- * case SCSI_CMD_VERIFY12: * 0xaf Optional
- * case SCSI_CMD_SETLIMITS12 * 0xb3 Obsolete
- * case SCSI_CMD_READELEMENTSTATUS: * 0xb4 Optional (MCHNGR==0)
- * case SCSI_CMD_READDEFECTDATA12: * 0xb7 Optional
- * case SCSI_CMD_REDUNDANCYGROUPIN: * 0xba Optional
- * case SCSI_CMD_REDUNDANCYGROUPOUT: * 0xbb Optional
- * case SCSI_CMD_SPAREIN: * 0xbc Optional (SCCS==0)
- * case SCSI_CMD_SPAREOUT: * 0xbd Optional (SCCS==0)
- * case SCSI_CMD_VOLUMESETIN: * 0xbe Optional (SCCS==0)
- * case SCSI_CMD_VOLUMESETOUT: * 0xbe Optional (SCCS==0)
- * * 0xc0-0xff Vendor specific */
-
- default:
- priv->u.alloclen = 0;
- if (ret == OK)
- {
- priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
- ret = -EINVAL;
- }
- break;
- }
- pthread_mutex_unlock(&priv->mutex);
-
- /* Is a response required? (Not for read6/10/12 and write6/10/12). */
-
- if (priv->thstate == USBMSC_STATE_CMDPARSE)
- {
- /* All commands come through this path (EXCEPT read6/10/12 and write6/10/12).
- * For all other commands, the following setup is expected for the response
- * based on data direction:
- *
- * For direction NONE:
- * 1. priv->u.alloclen == 0
- * 2. priv->nreqbytes == 0
- *
- * For direction = device-to-host:
- * 1. priv->u.alloclen == allocation length; space set aside by the
- * host to receive the device data. The size of the response
- * cannot exceed this value.
- * 2. response data is in the request currently at the head of
- * the priv->wrreqlist queue. priv->nreqbytes is set to the length
- * of data in the response.
- *
- * For direction host-to-device
- * At present, there are no supported commands that should have host-to-device
- * transfers (except write6/10/12 and that command logic does not take this
- * path. The 'residue' is left at the full host-to-device data size.
- *
- * For all:
- * ret set to <0 if an error occurred in parsing the commands.
- */
-
- /* For from device-to-hose operations, the residue is the expected size
- * (the initial value of 'residue') minus the amount actually returned
- * in the response:
- */
-
- if (priv->cbwdir == USBMSC_FLAGS_DIRDEVICE2HOST)
- {
- /* The number of bytes in the response cannot exceed the host
- * 'allocation length' in the command.
- */
-
- if (priv->nreqbytes > priv->u.alloclen)
- {
- priv->nreqbytes = priv->u.alloclen;
- }
-
- /* The residue is then the number of bytes that were not sent */
-
- priv->residue -= priv->nreqbytes;
- }
-
- /* On return, we need the following:
- *
- * 1. Setup for CMDFINISH state if appropriate
- * 2. priv->thstate set to either CMDPARSE if no buffer was available or
- * CMDFINISH to send the response
- * 3. Return OK to continue; <0 to wait for the next event
- */
-
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDFINISH), priv->cdb[0]);
- priv->thstate = USBMSC_STATE_CMDFINISH;
- ret = OK;
- }
- return ret;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdreadstate
- *
- * Description:
- * Called from the worker thread in the USBMSC_STATE_CMDREAD state.
- * The USBMSC_STATE_CMDREAD state is entered when usbmsc_cmdparsestate
- * obtains a valid SCSI read command. This state is really a continuation
- * of the USBMSC_STATE_CMDPARSE state that handles extended SCSI read
- * command handling.
- *
- * Returned value:
- * If no USBDEV write request is available or certain other errors occur, this
- * function returns a negated errno and stays in the USBMSC_STATE_CMDREAD
- * state. Otherwise, when the new SCSI read command is fully processed,
- * this function sets priv->thstate to USBMSC_STATE_CMDFINISH and returns OK.
- *
- * State variables:
- * xfrlen - holds the number of sectors read to be read.
- * sector - holds the sector number of the next sector to be read
- * nsectbytes - holds the number of bytes buffered for the current sector
- * nreqbytes - holds the number of bytes currently buffered in the request
- * at the head of the wrreqlist.
- *
- ****************************************************************************/
-
-static int usbmsc_cmdreadstate(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct usbmsc_lun_s *lun = priv->lun;
- FAR struct usbmsc_req_s *privreq;
- FAR struct usbdev_req_s *req;
- irqstate_t flags;
- ssize_t nread;
- uint8_t *src;
- uint8_t *dest;
- int nbytes;
- int ret;
-
- /* Loop transferring data until either (1) all of the data has been
- * transferred, or (2) we have used up all of the write requests that we have
- * available.
- */
-
- while (priv->u.xfrlen > 0 || priv->nsectbytes > 0)
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDREAD), priv->u.xfrlen);
-
- /* Is the I/O buffer empty? */
-
- if (priv->nsectbytes <= 0)
- {
- /* Yes.. read the next sector */
-
- nread = USBMSC_DRVR_READ(lun, priv->iobuffer, priv->sector, 1);
- if (nread < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADREADFAIL), -nread);
- lun->sd = SCSI_KCQME_UNRRE1;
- lun->sdinfo = priv->sector;
- break;
- }
-
- priv->nsectbytes = lun->sectorsize;
- priv->u.xfrlen--;
- priv->sector++;
- }
-
- /* Check if there is a request in the wrreqlist that we will be able to
- * use for data transfer.
- */
-
- privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist);
-
- /* If there no request structures available, then just return an error.
- * This will cause us to remain in the CMDREAD state. When a request is
- * returned, the worker thread will be awakened in the USBMSC_STATE_CMDREAD
- * and we will be called again.
- */
-
- if (!privreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADWRRQEMPTY), 0);
- priv->nreqbytes = 0;
- return -ENOMEM;
- }
- req = privreq->req;
-
- /* Transfer all of the data that will (1) fit into the request buffer, OR (2)
- * all of the data available in the sector buffer.
- */
-
- src = &priv->iobuffer[lun->sectorsize - priv->nsectbytes];
- dest = &req->buf[priv->nreqbytes];
-
- nbytes = MIN(CONFIG_USBMSC_BULKINREQLEN - priv->nreqbytes, priv->nsectbytes);
-
- /* Copy the data from the sector buffer to the USB request and update counts */
-
- memcpy(dest, src, nbytes);
- priv->nreqbytes += nbytes;
- priv->nsectbytes -= nbytes;
-
- /* If (1) the request buffer is full OR (2) this is the final request full of data,
- * then submit the request
- */
-
- if (priv->nreqbytes >= CONFIG_USBMSC_BULKINREQLEN ||
- (priv->u.xfrlen <= 0 && priv->nsectbytes <= 0))
- {
- /* Remove the request that we just filled from wrreqlist (we've already checked
- * that is it not NULL
- */
-
- flags = irqsave();
- privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
- irqrestore(flags);
-
- /* And submit the request to the bulk IN endpoint */
-
- req->len = priv->nreqbytes;
- req->priv = privreq;
- req->callback = usbmsc_wrcomplete;
- req->flags = 0;
-
- ret = EP_SUBMIT(priv->epbulkin, req);
- if (ret != OK)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADSUBMIT), (uint16_t)-ret);
- lun->sd = SCSI_KCQME_UNRRE1;
- lun->sdinfo = priv->sector;
- break;
- }
-
- /* Assume success... residue should probably really be decremented in
- * wrcomplete when we know that the transfer completed successfully.
- */
-
- priv->residue -= priv->nreqbytes;
- priv->nreqbytes = 0;
- }
- }
-
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDREADCMDFINISH), priv->u.xfrlen);
- priv->thstate = USBMSC_STATE_CMDFINISH;
- return OK;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdwritestate
- *
- * Description:
- * Called from the worker thread in the USBMSC_STATE_CMDWRITE state.
- * The USBMSC_STATE_CMDWRITE state is entered when usbmsc_cmdparsestate
- * obtains a valid SCSI write command. This state is really a continuation
- * of the USBMSC_STATE_CMDPARSE state that handles extended SCSI write
- * command handling.
- *
- * Returned value:
- * If no USBDEV write request is available or certain other errors occur, this
- * function returns a negated errno and stays in the USBMSC_STATE_CMDWRITE
- * state. Otherwise, when the new SCSI write command is fully processed,
- * this function sets priv->thstate to USBMSC_STATE_CMDFINISH and returns OK.
- *
- * State variables:
- * xfrlen - holds the number of sectors read to be written.
- * sector - holds the sector number of the next sector to write
- * nsectbytes - holds the number of bytes buffered for the current sector
- * nreqbytes - holds the number of untransferred bytes currently in the
- * request at the head of the rdreqlist.
- *
- ****************************************************************************/
-
-static int usbmsc_cmdwritestate(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct usbmsc_lun_s *lun = priv->lun;
- FAR struct usbmsc_req_s *privreq;
- FAR struct usbdev_req_s *req;
- ssize_t nwritten;
- uint16_t xfrd;
- uint8_t *src;
- uint8_t *dest;
- int nbytes;
- int ret;
-
- /* Loop transferring data until either (1) all of the data has been
- * transferred, or (2) we have written all of the data in the available
- * read requests.
- */
-
- while (priv->u.xfrlen > 0)
- {
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDWRITE), priv->u.xfrlen);
-
- /* Check if there is a request in the rdreqlist containing additional
- * data to be written.
- */
-
- privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->rdreqlist);
-
- /* If there no request data available, then just return an error.
- * This will cause us to remain in the CMDWRITE state. When a filled request is
- * received, the worker thread will be awakened in the USBMSC_STATE_CMDWRITE
- * and we will be called again.
- */
-
- if (!privreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITERDRQEMPTY), 0);
- priv->nreqbytes = 0;
- return -ENOMEM;
- }
-
- req = privreq->req;
- xfrd = req->xfrd;
- priv->nreqbytes = xfrd;
-
- /* Now loop until all of the data in the read request has been tranferred
- * to the block driver OR all of the request data has been transferred.
- */
-
- while (priv->nreqbytes > 0 && priv->u.xfrlen > 0)
- {
- /* Copy the data received in the read request into the sector I/O buffer */
-
- src = &req->buf[xfrd - priv->nreqbytes];
- dest = &priv->iobuffer[priv->nsectbytes];
-
- nbytes = MIN(lun->sectorsize - priv->nsectbytes, priv->nreqbytes);
-
- /* Copy the data from the sector buffer to the USB request and update counts */
-
- memcpy(dest, src, nbytes);
- priv->nsectbytes += nbytes;
- priv->nreqbytes -= nbytes;
-
- /* Is the I/O buffer full? */
-
- if (priv->nsectbytes >= lun->sectorsize)
- {
- /* Yes.. Write the next sector */
-
- nwritten = USBMSC_DRVR_WRITE(lun, priv->iobuffer, priv->sector, 1);
- if (nwritten < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITEWRITEFAIL), -nwritten);
- lun->sd = SCSI_KCQME_WRITEFAULTAUTOREALLOCFAILED;
- lun->sdinfo = priv->sector;
- goto errout;
- }
-
- priv->nsectbytes = 0;
- priv->residue -= lun->sectorsize;
- priv->u.xfrlen--;
- priv->sector++;
- }
- }
-
- /* In either case, we are finished with this read request and can return it
- * to the endpoint. Then we will go back to the top of the top and attempt
- * to get the next read request.
- */
-
- req->len = CONFIG_USBMSC_BULKOUTREQLEN;
- req->priv = privreq;
- req->callback = usbmsc_rdcomplete;
-
- ret = EP_SUBMIT(priv->epbulkout, req);
- if (ret != OK)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITERDSUBMIT), (uint16_t)-ret);
- }
-
- /* Did the host decide to stop early? */
-
- if (xfrd != CONFIG_USBMSC_BULKOUTREQLEN)
- {
- priv->shortpacket = 1;
- goto errout;
- }
- }
-
-errout:
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDWRITECMDFINISH), priv->u.xfrlen);
- priv->thstate = USBMSC_STATE_CMDFINISH;
- return OK;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdfinishstate
- *
- * Description:
- * Called from the worker thread in the USBMSC_STATE_CMDFINISH state.
- * The USBMSC_STATE_CMDFINISH state is entered when processing of a
- * command has finished but before status has been returned.
- *
- * Returned value:
- * If no USBDEV write request is available or certain other errors occur, this
- * function returns a negated errno and stays in the USBMSC_STATE_CMDFINISH
- * state. Otherwise, when the command is fully processed, this function
- * sets priv->thstate to USBMSC_STATE_CMDSTATUS and returns OK.
- *
- ****************************************************************************/
-
-static int usbmsc_cmdfinishstate(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct usbmsc_req_s *privreq;
- irqstate_t flags;
- int ret = OK;
-
- /* Check if there is a request in the wrreqlist that we will be able to
- * use for data transfer.
- */
-
- privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist);
-
- /* If there no request structures available, then just return an error.
- * This will cause us to remain in the CMDREAD state. When a request is
- * returned, the worker thread will be awakened in the USBMSC_STATE_CMDREAD
- * and we will be called again.
- */
-
- if (!privreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHRQEMPTY), 0);
- return -ENOMEM;
- }
-
- /* Finish the final stages of the reply */
-
- switch (priv->cbwdir)
- {
- /* Device-to-host: All but the last data buffer has been sent */
-
- case USBMSC_FLAGS_DIRDEVICE2HOST:
- if (priv->cbwlen > 0)
- {
- /* On most commands (the exception is outgoing, write commands),
- * the data has not not yet been sent.
- */
-
- if (priv->nreqbytes > 0)
- {
- struct usbdev_req_s *req;
-
- /* Take a request from the wrreqlist (we've already checked
- * that is it not NULL)
- */
-
- flags = irqsave();
- privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
- irqrestore(flags);
-
- /* Send the write request */
-
- req = privreq->req;
- req->len = priv->nreqbytes;
- req->callback = usbmsc_wrcomplete;
- req->priv = privreq;
- req->flags = USBDEV_REQFLAGS_NULLPKT;
-
- ret = EP_SUBMIT(priv->epbulkin, privreq->req);
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHSUBMIT), (uint16_t)-ret);
- }
- }
-
- /* Stall the BULK In endpoint if there is a residue */
-
- if (priv->residue > 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHRESIDUE), (uint16_t)priv->residue);
-
-#ifdef CONFIG_USBMSC_RACEWAR
- /* (See description of the workaround at the top of the file).
- * First, wait for the transfer to complete, then stall the endpoint
- */
-
- usleep (100000);
- (void)EP_STALL(priv->epbulkin);
-
- /* now wait for stall to go away .... */
-
- usleep (100000);
-#else
- (void)EP_STALL(priv->epbulkin);
-#endif
- }
- }
- break;
-
- /* Host-to-device: We have processed all we want of the host data. */
-
- case USBMSC_FLAGS_DIRHOST2DEVICE:
- if (priv->residue > 0)
- {
- /* Did the host stop sending unexpectedly early? */
-
- flags = irqsave();
- if (priv->shortpacket)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHSHORTPKT), (uint16_t)priv->residue);
- }
-
- /* Unprocessed incoming data: STALL and cancel requests. */
-
- else
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINSHSUBMIT), (uint16_t)priv->residue);
- EP_STALL(priv->epbulkout);
- }
-
- priv->theventset |= USBMSC_EVENT_ABORTBULKOUT;
- irqrestore(flags);
- }
- break;
-
- default:
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINSHDIR), priv->cbwdir);
- case USBMSC_FLAGS_DIRNONE: /* Nothing to send */
- break;
- }
-
- /* Return to the IDLE state */
-
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDFINISHCMDSTATUS), 0);
- priv->thstate = USBMSC_STATE_CMDSTATUS;
- return OK;
-}
-
-/****************************************************************************
- * Name: usbmsc_cmdstatusstate
- *
- * Description:
- * Called from the worker thread in the USBMSC_STATE_CMDSTATUS state.
- * That state is after a CBW has been fully processed. This function sends
- * the concluding CSW.
- *
- * Returned value:
- * If no write request is available or certain other errors occur, this
- * function returns a negated errno and stays in the USBMSC_STATE_CMDSTATUS
- * state. Otherwise, when the SCSI statis is successfully returned, this
- * function sets priv->thstate to USBMSC_STATE_IDLE and returns OK.
- *
- ****************************************************************************/
-
-static int usbmsc_cmdstatusstate(FAR struct usbmsc_dev_s *priv)
-{
- FAR struct usbmsc_lun_s *lun = priv->lun;
- FAR struct usbmsc_req_s *privreq;
- FAR struct usbdev_req_s *req;
- FAR struct usbmsc_csw_s *csw;
- irqstate_t flags;
- uint32_t sd;
- uint8_t status = USBMSC_CSWSTATUS_PASS;
- int ret;
-
- /* Take a request from the wrreqlist */
-
- flags = irqsave();
- privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
- irqrestore(flags);
-
- /* If there no request structures available, then just return an error.
- * This will cause us to remain in the CMDSTATUS status. When a request is
- * returned, the worker thread will be awakened in the USBMSC_STATE_CMDSTATUS
- * and we will be called again.
- */
-
- if (!privreq)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDSTATUSRDREQLISTEMPTY), 0);
- return -ENOMEM;
- }
-
- req = privreq->req;
- csw = (struct usbmsc_csw_s*)req->buf;
-
- /* Extract the sense data from the LUN structure */
-
- if (lun)
- {
- sd = lun->sd;
- }
- else
- {
- sd = SCSI_KCQIR_INVALIDLUN;
- }
-
- /* Determine the CSW status: PASS, PHASEERROR, or FAIL */
-
- if (priv->phaseerror)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDPHERROR), 0);
- status = USBMSC_CSWSTATUS_PHASEERROR;
- sd = SCSI_KCQIR_INVALIDCOMMAND;
- }
- else if (sd != SCSI_KCQ_NOSENSE)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDCSWFAIL), 0);
- status = USBMSC_CSWSTATUS_FAIL;
- }
-
- /* Format and submit the CSW */
-
- csw->signature[0] = 'U';
- csw->signature[1] = 'S';
- csw->signature[2] = 'B';
- csw->signature[3] = 'S';
- usbmsc_putle32(csw->tag, priv->cbwtag);
- usbmsc_putle32(csw->residue, priv->residue);
- csw->status = status;
-
- usbmsc_dumpdata("SCSCI CSW", (uint8_t*)csw, USBMSC_CSW_SIZEOF);
-
- req->len = USBMSC_CSW_SIZEOF;
- req->callback = usbmsc_wrcomplete;
- req->priv = privreq;
- req->flags = USBDEV_REQFLAGS_NULLPKT;
-
- ret = EP_SUBMIT(priv->epbulkin, req);
- if (ret < 0)
- {
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDSTATUSSUBMIT), (uint16_t)-ret);
- flags = irqsave();
- (void)sq_addlast((sq_entry_t*)privreq, &priv->wrreqlist);
- irqrestore(flags);
- }
-
- /* Return to the IDLE state */
-
- usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDSTATUSIDLE), 0);
- priv->thstate = USBMSC_STATE_IDLE;
- return OK;
-}
-
-/****************************************************************************
- * Public Functions
- ****************************************************************************/
-
-/****************************************************************************
- * Name: usbmsc_workerthread
- *
- * Description:
- * This is the main function of the USB storage worker thread. It loops
- * until USB-related events occur, then processes those events accordingly
- *
- ****************************************************************************/
-
-void *usbmsc_workerthread(void *arg)
-{
- struct usbmsc_dev_s *priv = (struct usbmsc_dev_s *)arg;
- irqstate_t flags;
- uint16_t eventset;
- int ret;
-
- /* This thread is started before the USB storage class is fully initialized.
- * wait here until we are told to begin. Start in the NOTINITIALIZED state
- */
-
- pthread_mutex_lock(&priv->mutex);
- priv->thstate = USBMSC_STATE_STARTED;
- while ((priv->theventset & USBMSC_EVENT_READY) != 0 &&
- (priv->theventset & USBMSC_EVENT_TERMINATEREQUEST) != 0)
- {
- pthread_cond_wait(&priv->cond, &priv->mutex);
- }
-
- /* Transition to the INITIALIZED/IDLE state */
-
- priv->thstate = USBMSC_STATE_IDLE;
- eventset = priv->theventset;
- priv->theventset = USBMSC_EVENT_NOEVENTS;
- pthread_mutex_unlock(&priv->mutex);
-
- /* Then loop until we are asked to terminate */
-
- while ((eventset & USBMSC_EVENT_TERMINATEREQUEST) == 0)
- {
- /* Wait for some interesting event. Note that we must both take the
- * lock (to eliminate race conditions with other threads) and disable
- * interrupts (to eliminate race conditions with USB interrupt handling.
- */
-
- pthread_mutex_lock(&priv->mutex);
- flags = irqsave();
- if (priv->theventset == USBMSC_EVENT_NOEVENTS)
- {
- pthread_cond_wait(&priv->cond, &priv->mutex);
- }
-
- /* Sample any events before re-enabling interrupts. Any events that
- * occur after re-enabling interrupts will have to be handled in the
- * next time through the loop.
- */
-
- eventset = priv->theventset;
- priv->theventset = USBMSC_EVENT_NOEVENTS;
- pthread_mutex_unlock(&priv->mutex);
-
- /* Were we awakened by some event that requires immediate action?
- *
- * - The USBMSC_EVENT_DISCONNECT is signalled from the disconnect method
- * after all transfers have been stopped, when the host is disconnected.
- *
- * - The CUSBMSC_EVENT_RESET is signalled when the bulk-storage-specific
- * USBMSC_REQ_MSRESET EP0 setup received. We must stop the current
- * operation and reinialize state.
- *
- * - The USBMSC_EVENT_CFGCHANGE is signaled when the EP0 setup logic
- * receives a valid USB_REQ_SETCONFIGURATION request
- *
- * - The USBMSC_EVENT_IFCHANGE is signaled when the EP0 setup logic
- * receives a valid USB_REQ_SETINTERFACE request
- *
- * - The USBMSC_EVENT_ABORTBULKOUT event is signalled by the CMDFINISH
- * logic when there is a residue after processing a host-to-device
- * transfer. We need to discard all incoming request.
- *
- * All other events are just wakeup calls and are intended only
- * drive the state machine.
- */
-
- if ((eventset & (USBMSC_EVENT_DISCONNECT|USBMSC_EVENT_RESET|USBMSC_EVENT_CFGCHANGE|
- USBMSC_EVENT_IFCHANGE|USBMSC_EVENT_ABORTBULKOUT)) != 0)
- {
- /* These events require that the current configuration be reset */
-
- if ((eventset & USBMSC_EVENT_IFCHANGE) != 0)
- {
- usbmsc_resetconfig(priv);
- }
-
- /* These events require that a new configuration be established */
-
- if ((eventset & (USBMSC_EVENT_CFGCHANGE|USBMSC_EVENT_IFCHANGE)) != 0)
- {
- usbmsc_setconfig(priv, priv->thvalue);
- }
-
- /* These events required that we send a deferred EP0 setup response */
-
- if ((eventset & (USBMSC_EVENT_RESET|USBMSC_EVENT_CFGCHANGE|USBMSC_EVENT_IFCHANGE)) != 0)
- {
- usbmsc_deferredresponse(priv, false);
- }
-
- /* For all of these events... terminate any transactions in progress */
-
- priv->thstate = USBMSC_STATE_IDLE;
- }
- irqrestore(flags);
-
- /* Loop processing each SCSI command state. Each state handling
- * function will do the following:
- *
- * - If it must block for an event, it will return a negated errno value
- * - If it completes the processing for that state, it will (1) set
- * the next appropriate state value and (2) return OK.
- *
- * So the following will loop until we must block for an event in
- * a particular state. When we are awakened by an event (above) we
- * will resume processing in the same state.
- */
-
- do
- {
- switch (priv->thstate)
- {
- case USBMSC_STATE_IDLE: /* Started and waiting for commands */
- ret = usbmsc_idlestate(priv);
- break;
-
- case USBMSC_STATE_CMDPARSE: /* Parsing the received a command */
- ret = usbmsc_cmdparsestate(priv);
- break;
-
- case USBMSC_STATE_CMDREAD: /* Continuing to process a SCSI read command */
- ret = usbmsc_cmdreadstate(priv);
- break;
-
- case USBMSC_STATE_CMDWRITE: /* Continuing to process a SCSI write command */
- ret = usbmsc_cmdwritestate(priv);
- break;
-
- case USBMSC_STATE_CMDFINISH: /* Finish command processing */
- ret = usbmsc_cmdfinishstate(priv);
- break;
-
- case USBMSC_STATE_CMDSTATUS: /* Processing the status phase of a command */
- ret = usbmsc_cmdstatusstate(priv);
- break;
-
- case USBMSC_STATE_NOTSTARTED: /* Thread has not yet been started */
- case USBMSC_STATE_STARTED: /* Started, but is not yet initialized */
- case USBMSC_STATE_TERMINATED: /* Thread has exitted */
- default:
- usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDSTATE), priv->thstate);
- priv->thstate = USBMSC_STATE_IDLE;
- ret = OK;
- break;
- }
- }
- while (ret == OK);
- }
-
- /* Transition to the TERMINATED state and exit */
-
- priv->thstate = USBMSC_STATE_TERMINATED;
- return NULL;
-}
diff --git a/nuttx/drivers/usbdev/usbmsc.c b/nuttx/drivers/usbdev/usbmsc.c
new file mode 100644
index 000000000..e99342abc
--- /dev/null
+++ b/nuttx/drivers/usbdev/usbmsc.c
@@ -0,0 +1,1694 @@
+/****************************************************************************
+ * drivers/usbdev/usbmsc.c
+ *
+ * Copyright (C) 2008-2012 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt
+ *
+ * Mass storage class device. Bulk-only with SCSI subclass.
+ *
+ * References:
+ * "Universal Serial Bus Mass Storage Class, Specification Overview,"
+ * Revision 1.2, USB Implementer's Forum, June 23, 2003.
+ *
+ * "Universal Serial Bus Mass Storage Class, Bulk-Only Transport,"
+ * Revision 1.0, USB Implementer's Forum, September 31, 1999.
+ *
+ * "SCSI Primary Commands - 3 (SPC-3)," American National Standard
+ * for Information Technology, May 4, 2005
+ *
+ * "SCSI Primary Commands - 4 (SPC-4)," American National Standard
+ * for Information Technology, July 19, 2008
+ *
+ * "SCSI Block Commands -2 (SBC-2)," American National Standard
+ * for Information Technology, November 13, 2004
+ *
+ * "SCSI Multimedia Commands - 3 (MMC-3)," American National Standard
+ * for Information Technology, November 12, 2001
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "usbmsc.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* The internal version of the class driver */
+
+struct usbmsc_driver_s
+{
+ struct usbdevclass_driver_s drvr;
+ FAR struct usbmsc_dev_s *dev;
+};
+
+/* This is what is allocated */
+
+struct usbmsc_alloc_s
+{
+ struct usbmsc_dev_s dev;
+ struct usbmsc_driver_s drvr;
+};
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/* Class Driver Support *****************************************************/
+
+static void usbmsc_ep0incomplete(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req);
+static struct usbdev_req_s *usbmsc_allocreq(FAR struct usbdev_ep_s *ep,
+ uint16_t len);
+static void usbmsc_freereq(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req);
+
+/* Class Driver Operations (most at interrupt level) ************************/
+
+static int usbmsc_bind(FAR struct usbdev_s *dev,
+ FAR struct usbdevclass_driver_s *driver);
+static void usbmsc_unbind(FAR struct usbdev_s *dev);
+static int usbmsc_setup(FAR struct usbdev_s *dev,
+ FAR const struct usb_ctrlreq_s *ctrl);
+static void usbmsc_disconnect(FAR struct usbdev_s *dev);
+
+/* Initialization/Uninitialization ******************************************/
+
+static void usbmsc_lununinitialize(struct usbmsc_lun_s *lun);
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/* Driver operations ********************************************************/
+
+static struct usbdevclass_driverops_s g_driverops =
+{
+ usbmsc_bind, /* bind */
+ usbmsc_unbind, /* unbind */
+ usbmsc_setup, /* setup */
+ usbmsc_disconnect, /* disconnect */
+ NULL, /* suspend */
+ NULL /* resume */
+};
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Class Driver Support
+ ****************************************************************************/
+/****************************************************************************
+ * Name: usbmsc_ep0incomplete
+ *
+ * Description:
+ * Handle completion of EP0 control operations
+ *
+ ****************************************************************************/
+
+static void usbmsc_ep0incomplete(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req)
+{
+ if (req->result || req->xfrd != req->len)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_REQRESULT),
+ (uint16_t)-req->result);
+ }
+}
+
+/****************************************************************************
+ * Name: usbmsc_allocreq
+ *
+ * Description:
+ * Allocate a request instance along with its buffer
+ *
+ ****************************************************************************/
+
+static struct usbdev_req_s *usbmsc_allocreq(FAR struct usbdev_ep_s *ep,
+ uint16_t len)
+{
+ FAR struct usbdev_req_s *req;
+
+ req = EP_ALLOCREQ(ep);
+ if (req != NULL)
+ {
+ req->len = len;
+ req->buf = EP_ALLOCBUFFER(ep, len);
+ if (!req->buf)
+ {
+ EP_FREEREQ(ep, req);
+ req = NULL;
+ }
+ }
+ return req;
+}
+
+/****************************************************************************
+ * Name: usbmsc_freereq
+ *
+ * Description:
+ * Free a request instance along with its buffer
+ *
+ ****************************************************************************/
+
+static void usbmsc_freereq(FAR struct usbdev_ep_s *ep, struct usbdev_req_s *req)
+{
+ if (ep != NULL && req != NULL)
+ {
+ if (req->buf != NULL)
+ {
+ EP_FREEBUFFER(ep, req->buf);
+ }
+ EP_FREEREQ(ep, req);
+ }
+}
+
+/****************************************************************************
+ * Class Driver Interfaces
+ ****************************************************************************/
+/****************************************************************************
+ * Name: usbmsc_bind
+ *
+ * Description:
+ * Invoked when the driver is bound to a USB device driver
+ *
+ ****************************************************************************/
+
+static int usbmsc_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver)
+{
+ FAR struct usbmsc_dev_s *priv = ((struct usbmsc_driver_s*)driver)->dev;
+ FAR struct usbmsc_req_s *reqcontainer;
+ irqstate_t flags;
+ int ret = OK;
+ int i;
+
+ usbtrace(TRACE_CLASSBIND, 0);
+
+ /* Bind the structures */
+
+ priv->usbdev = dev;
+ dev->ep0->priv = priv;
+
+ /* The configured EP0 size should match the reported EP0 size. We could
+ * easily adapt to the reported EP0 size, but then we could not use the
+ * const, canned descriptors.
+ */
+
+ DEBUGASSERT(CONFIG_USBMSC_EP0MAXPACKET == dev->ep0->maxpacket);
+
+ /* Preallocate control request */
+
+ priv->ctrlreq = usbmsc_allocreq(dev->ep0, USBMSC_MXDESCLEN);
+ if (priv->ctrlreq == NULL)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCCTRLREQ), 0);
+ ret = -ENOMEM;
+ goto errout;
+ }
+ priv->ctrlreq->callback = usbmsc_ep0incomplete;
+
+ /* Pre-allocate all endpoints... the endpoints will not be functional
+ * until the SET CONFIGURATION request is processed in usbmsc_setconfig.
+ * This is done here because there may be calls to kmalloc and the SET
+ * CONFIGURATION processing probably occurrs within interrupt handling
+ * logic where kmalloc calls will fail.
+ */
+
+ /* Pre-allocate the IN bulk endpoint */
+
+ priv->epbulkin = DEV_ALLOCEP(dev, USBMSC_EPINBULK_ADDR, true, USB_EP_ATTR_XFER_BULK);
+ if (!priv->epbulkin)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKINALLOCFAIL), 0);
+ ret = -ENODEV;
+ goto errout;
+ }
+ priv->epbulkin->priv = priv;
+
+ /* Pre-allocate the OUT bulk endpoint */
+
+ priv->epbulkout = DEV_ALLOCEP(dev, USBMSC_EPOUTBULK_ADDR, false, USB_EP_ATTR_XFER_BULK);
+ if (!priv->epbulkout)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKOUTALLOCFAIL), 0);
+ ret = -ENODEV;
+ goto errout;
+ }
+ priv->epbulkout->priv = priv;
+
+ /* Pre-allocate read requests */
+
+ for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++)
+ {
+ reqcontainer = &priv->rdreqs[i];
+ reqcontainer->req = usbmsc_allocreq(priv->epbulkout, CONFIG_USBMSC_BULKOUTREQLEN);
+ if (reqcontainer->req == NULL)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDALLOCREQ),
+ (uint16_t)-ret);
+ ret = -ENOMEM;
+ goto errout;
+ }
+ reqcontainer->req->priv = reqcontainer;
+ reqcontainer->req->callback = usbmsc_rdcomplete;
+ }
+
+ /* Pre-allocate write request containers and put in a free list */
+
+ for (i = 0; i < CONFIG_USBMSC_NWRREQS; i++)
+ {
+ reqcontainer = &priv->wrreqs[i];
+ reqcontainer->req = usbmsc_allocreq(priv->epbulkin, CONFIG_USBMSC_BULKINREQLEN);
+ if (reqcontainer->req == NULL)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRALLOCREQ),
+ (uint16_t)-ret);
+ ret = -ENOMEM;
+ goto errout;
+ }
+ reqcontainer->req->priv = reqcontainer;
+ reqcontainer->req->callback = usbmsc_wrcomplete;
+
+ flags = irqsave();
+ sq_addlast((sq_entry_t*)reqcontainer, &priv->wrreqlist);
+ irqrestore(flags);
+ }
+
+ /* Report if we are selfpowered (unless we are part of a composite device) */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+#ifdef CONFIG_USBDEV_SELFPOWERED
+ DEV_SETSELFPOWERED(dev);
+#endif
+
+ /* And pull-up the data line for the soft connect function (unless we are
+ * part of a composite device)
+ */
+
+ DEV_CONNECT(dev);
+#endif
+ return OK;
+
+errout:
+ usbmsc_unbind(dev);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_unbind
+ *
+ * Description:
+ * Invoked when the driver is unbound from a USB device driver
+ *
+ ****************************************************************************/
+
+static void usbmsc_unbind(FAR struct usbdev_s *dev)
+{
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_req_s *reqcontainer;
+ irqstate_t flags;
+ int i;
+
+ usbtrace(TRACE_CLASSUNBIND, 0);
+
+#ifdef CONFIG_DEBUG
+ if (!dev || !dev->ep0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDINVALIDARGS), 0);
+ return;
+ }
+#endif
+
+ /* Extract reference to private data */
+
+ priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv;
+
+#ifdef CONFIG_DEBUG
+ if (!priv)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND1), 0);
+ return;
+ }
+#endif
+
+ /* The worker thread should have already been stopped by the
+ * driver un-initialize logic.
+ */
+
+ DEBUGASSERT(priv->thstate == USBMSC_STATE_TERMINATED);
+
+ /* Make sure that we are not already unbound */
+
+ if (priv != NULL)
+ {
+ /* Make sure that the endpoints have been unconfigured. If
+ * we were terminated gracefully, then the configuration should
+ * already have been reset. If not, then calling usbmsc_resetconfig
+ * should cause the endpoints to immediately terminate all
+ * transfers and return the requests to us (with result == -ESHUTDOWN)
+ */
+
+ usbmsc_resetconfig(priv);
+ up_mdelay(50);
+
+ /* Free the pre-allocated control request */
+
+ if (priv->ctrlreq != NULL)
+ {
+ usbmsc_freereq(dev->ep0, priv->ctrlreq);
+ priv->ctrlreq = NULL;
+ }
+
+ /* Free pre-allocated read requests (which should all have
+ * been returned to the free list at this time -- we don't check)
+ */
+
+ for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++)
+ {
+ reqcontainer = &priv->rdreqs[i];
+ if (reqcontainer->req)
+ {
+ usbmsc_freereq(priv->epbulkout, reqcontainer->req);
+ reqcontainer->req = NULL;
+ }
+ }
+
+ /* Free the bulk OUT endpoint */
+
+ if (priv->epbulkout)
+ {
+ DEV_FREEEP(dev, priv->epbulkout);
+ priv->epbulkout = NULL;
+ }
+
+ /* Free write requests that are not in use (which should be all
+ * of them
+ */
+
+ flags = irqsave();
+ while (!sq_empty(&priv->wrreqlist))
+ {
+ reqcontainer = (struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
+ if (reqcontainer->req != NULL)
+ {
+ usbmsc_freereq(priv->epbulkin, reqcontainer->req);
+ }
+ }
+
+ /* Free the bulk IN endpoint */
+
+ if (priv->epbulkin)
+ {
+ DEV_FREEEP(dev, priv->epbulkin);
+ priv->epbulkin = NULL;
+ }
+
+ irqrestore(flags);
+ }
+}
+
+/****************************************************************************
+ * Name: usbmsc_setup
+ *
+ * Description:
+ * Invoked for ep0 control requests. This function probably executes
+ * in the context of an interrupt handler.
+ *
+ ****************************************************************************/
+
+static int usbmsc_setup(FAR struct usbdev_s *dev,
+ FAR const struct usb_ctrlreq_s *ctrl)
+{
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbdev_req_s *ctrlreq;
+ uint16_t value;
+ uint16_t index;
+ uint16_t len;
+ int ret = -EOPNOTSUPP;
+
+#ifdef CONFIG_DEBUG
+ if (!dev || !dev->ep0 || !ctrl)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SETUPINVALIDARGS), 0);
+ return -EIO;
+ }
+#endif
+
+ /* Extract reference to private data */
+
+ usbtrace(TRACE_CLASSSETUP, ctrl->req);
+ priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv;
+
+#ifdef CONFIG_DEBUG
+ if (!priv || !priv->ctrlreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND2), 0);
+ return -ENODEV;
+ }
+#endif
+ ctrlreq = priv->ctrlreq;
+
+ /* Extract the little-endian 16-bit values to host order */
+
+ value = GETUINT16(ctrl->value);
+ index = GETUINT16(ctrl->index);
+ len = GETUINT16(ctrl->len);
+
+ uvdbg("type=%02x req=%02x value=%04x index=%04x len=%04x\n",
+ ctrl->type, ctrl->req, value, index, len);
+
+ if ((ctrl->type & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
+ {
+ /**********************************************************************
+ * Standard Requests
+ **********************************************************************/
+
+ switch (ctrl->req)
+ {
+ case USB_REQ_GETDESCRIPTOR:
+ {
+ /* The value field specifies the descriptor type in the MS byte and the
+ * descriptor index in the LS byte (order is little endian)
+ */
+
+ switch (ctrl->value[1])
+ {
+ /* If the mass storage device is used in as part of a composite
+ * device, then the device descriptor is is provided by logic
+ * in the composite device implementation.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ case USB_DESC_TYPE_DEVICE:
+ {
+ ret = USB_SIZEOF_DEVDESC;
+ memcpy(ctrlreq->buf, usbmsc_getdevdesc(), ret);
+ }
+ break;
+#endif
+
+ /* If the mass storage device is used in as part of a composite device,
+ * then the device qualifier descriptor is provided by logic in the
+ * composite device implementation.
+ */
+
+#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
+ case USB_DESC_TYPE_DEVICEQUALIFIER:
+ {
+ ret = USB_SIZEOF_QUALDESC;
+ memcpy(ctrlreq->buf, usbmsc_getqualdesc(), ret);
+ }
+ break;
+
+ case USB_DESC_TYPE_OTHERSPEEDCONFIG:
+#endif
+
+ /* If the mass storage device is used in as part of a composite device,
+ * then the configuration descriptor is provided by logic in the
+ * composite device implementation.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ case USB_DESC_TYPE_CONFIG:
+ {
+#ifdef CONFIG_USBDEV_DUALSPEED
+ ret = usbmsc_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->value[1]);
+#else
+ ret = usbmsc_mkcfgdesc(ctrlreq->buf);
+#endif
+ }
+ break;
+#endif
+
+ /* If the mass storage device is used in as part of a composite device,
+ * then the language string descriptor is provided by logic in the
+ * composite device implementation.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ case USB_DESC_TYPE_STRING:
+ {
+ /* index == language code. */
+
+ ret = usbmsc_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf);
+ }
+ break;
+#endif
+
+ default:
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_GETUNKNOWNDESC), value);
+ }
+ break;
+ }
+ }
+ break;
+
+ case USB_REQ_SETCONFIGURATION:
+ {
+ if (ctrl->type == 0)
+ {
+ /* Signal the worker thread to instantiate the new configuration */
+
+ priv->theventset |= USBMSC_EVENT_CFGCHANGE;
+ priv->thvalue = value;
+ pthread_cond_signal(&priv->cond);
+
+ /* Return here... the response will be provided later by the
+ * worker thread.
+ */
+
+ return OK;
+ }
+ }
+ break;
+
+ /* If the mass storage device is used in as part of a composite device,
+ * then the overall composite class configuration is managed by logic
+ * in the composite device implementation.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ case USB_REQ_GETCONFIGURATION:
+ {
+ if (ctrl->type == USB_DIR_IN)
+ {
+ ctrlreq->buf[0] = priv->config;
+ ret = 1;
+ }
+ }
+ break;
+#endif
+
+ case USB_REQ_SETINTERFACE:
+ {
+ if (ctrl->type == USB_REQ_RECIPIENT_INTERFACE)
+ {
+ if (priv->config == USBMSC_CONFIGID &&
+ index == USBMSC_INTERFACEID &&
+ value == USBMSC_ALTINTERFACEID)
+ {
+ /* Signal to instantiate the interface change */
+
+ priv->theventset |= USBMSC_EVENT_IFCHANGE;
+ pthread_cond_signal(&priv->cond);
+
+ /* Return here... the response will be provided later by the
+ * worker thread.
+ */
+
+ return OK;
+ }
+ }
+ }
+ break;
+
+ case USB_REQ_GETINTERFACE:
+ {
+ if (ctrl->type == (USB_DIR_IN|USB_REQ_RECIPIENT_INTERFACE) &&
+ priv->config == USBMSC_CONFIGIDNONE)
+ {
+ if (index != USBMSC_INTERFACEID)
+ {
+ ret = -EDOM;
+ }
+ else
+ {
+ ctrlreq->buf[0] = USBMSC_ALTINTERFACEID;
+ ret = 1;
+ }
+ }
+ }
+ break;
+
+ default:
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNSUPPORTEDSTDREQ), ctrl->req);
+ break;
+ }
+ }
+ else
+ {
+ /**********************************************************************
+ * Bulk-Only Mass Storage Class Requests
+ **********************************************************************/
+
+ /* Verify that we are configured */
+
+ if (!priv->config)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOTCONFIGURED), 0);
+ return ret;
+ }
+
+ switch (ctrl->req)
+ {
+ case USBMSC_REQ_MSRESET: /* Reset mass storage device and interface */
+ {
+ if (ctrl->type == USBMSC_TYPE_SETUPOUT && value == 0 && len == 0)
+ {
+ /* Only one interface is supported */
+
+ if (index != USBMSC_INTERFACEID)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MSRESETNDX), index);
+ ret = -EDOM;
+ }
+ else
+ {
+ /* Signal to stop the current operation and reinitialize state */
+
+ priv->theventset |= USBMSC_EVENT_RESET;
+ pthread_cond_signal(&priv->cond);
+
+ /* Return here... the response will be provided later by the
+ * worker thread.
+ */
+
+ return OK;
+ }
+ }
+ }
+ break;
+
+ case USBMSC_REQ_GETMAXLUN: /* Return number LUNs supported */
+ {
+ if (ctrl->type == USBMSC_TYPE_SETUPIN && value == 0 && len == 1)
+ {
+ /* Only one interface is supported */
+
+ if (index != USBMSC_INTERFACEID)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_GETMAXLUNNDX), index);
+ ret = -EDOM;
+ }
+ else
+ {
+ ctrlreq->buf[0] = priv->nluns - 1;
+ ret = 1;
+ }
+ }
+ }
+ break;
+
+ default:
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BADREQUEST), index);
+ break;
+ }
+ }
+
+ /* Respond to the setup command if data was returned. On an error return
+ * value (ret < 0), the USB driver will stall EP0.
+ */
+
+ if (ret >= 0)
+ {
+ ctrlreq->len = MIN(len, ret);
+ ctrlreq->flags = USBDEV_REQFLAGS_NULLPKT;
+ ret = EP_SUBMIT(dev->ep0, ctrlreq);
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPRESPQ), (uint16_t)-ret);
+#if 0 /* Not necessary */
+ ctrlreq->result = OK;
+ usbmsc_ep0incomplete(dev->ep0, ctrlreq);
+#endif
+ }
+ }
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_disconnect
+ *
+ * Description:
+ * Invoked after all transfers have been stopped, when the host is
+ * disconnected. This function is probably called from the context of an
+ * interrupt handler.
+ *
+ ****************************************************************************/
+
+static void usbmsc_disconnect(FAR struct usbdev_s *dev)
+{
+ struct usbmsc_dev_s *priv;
+ irqstate_t flags;
+
+ usbtrace(TRACE_CLASSDISCONNECT, 0);
+
+#ifdef CONFIG_DEBUG
+ if (!dev || !dev->ep0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DISCONNECTINVALIDARGS), 0);
+ return;
+ }
+#endif
+
+ /* Extract reference to private data */
+
+ priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv;
+
+#ifdef CONFIG_DEBUG
+ if (!priv)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND3), 0);
+ return;
+ }
+#endif
+
+ /* Reset the configuration */
+
+ flags = irqsave();
+ usbmsc_resetconfig(priv);
+
+ /* Signal the worker thread */
+
+ priv->theventset |= USBMSC_EVENT_DISCONNECT;
+ pthread_cond_signal(&priv->cond);
+ irqrestore(flags);
+
+ /* Perform the soft connect function so that we will we can be
+ * re-enumerated (unless we are part of a composite device)
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ DEV_CONNECT(dev);
+#endif
+}
+
+/****************************************************************************
+ * Initialization/Un-Initialization
+ ****************************************************************************/
+/****************************************************************************
+ * Name: usbmsc_lununinitialize
+ ****************************************************************************/
+
+static void usbmsc_lununinitialize(struct usbmsc_lun_s *lun)
+{
+ /* Has a block driver has been bound to the LUN? */
+
+ if (lun->inode)
+ {
+ /* Close the block driver */
+
+ (void)close_blockdriver(lun->inode);
+ }
+
+ memset(lun, 0, sizeof(struct usbmsc_lun_s *));
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+/****************************************************************************
+ * Internal Interfaces
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbmsc_setconfig
+ *
+ * Description:
+ * Set the device configuration by allocating and configuring endpoints and
+ * by allocating and queuing read and write requests.
+ *
+ ****************************************************************************/
+
+int usbmsc_setconfig(FAR struct usbmsc_dev_s *priv, uint8_t config)
+{
+ FAR struct usbmsc_req_s *privreq;
+ FAR struct usbdev_req_s *req;
+#ifdef CONFIG_USBDEV_DUALSPEED
+ FAR const struct usb_epdesc_s *epdesc;
+ bool hispeed = (priv->usbdev->speed == USB_SPEED_HIGH);
+ uint16_t bulkmxpacket;
+#endif
+ int i;
+ int ret = 0;
+
+#if CONFIG_DEBUG
+ if (priv == NULL)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SETCONFIGINVALIDARGS), 0);
+ return -EIO;
+ }
+#endif
+
+ if (config == priv->config)
+ {
+ /* Already configured -- Do nothing */
+
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALREADYCONFIGURED), 0);
+ return OK;
+ }
+
+ /* Discard the previous configuration data */
+
+ usbmsc_resetconfig(priv);
+
+ /* Was this a request to simply discard the current configuration? */
+
+ if (config == USBMSC_CONFIGIDNONE)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CONFIGNONE), 0);
+ return OK;
+ }
+
+ /* We only accept one configuration */
+
+ if (config != USBMSC_CONFIGID)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CONFIGIDBAD), 0);
+ return -EINVAL;
+ }
+
+ /* Configure the IN bulk endpoint */
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+ bulkmxpacket = USBMSC_BULKMAXPACKET(hispeed);
+ epdesc = USBMSC_EPBULKINDESC(hispeed);
+ ret = EP_CONFIGURE(priv->epbulkin, epdesc, false);
+#else
+ ret = EP_CONFIGURE(priv->epbulkin,
+ usbmsc_getepdesc(USBMSC_EPFSBULKIN), false);
+#endif
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKINCONFIGFAIL), 0);
+ goto errout;
+ }
+
+ priv->epbulkin->priv = priv;
+
+ /* Configure the OUT bulk endpoint */
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+ epdesc = USBMSC_EPBULKOUTDESC(hispeed);
+ ret = EP_CONFIGURE(priv->epbulkout, epdesc, true);
+#else
+ ret = EP_CONFIGURE(priv->epbulkout,
+ usbmsc_getepdesc(USBMSC_EPFSBULKOUT), true);
+#endif
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKOUTCONFIGFAIL), 0);
+ goto errout;
+ }
+
+ priv->epbulkout->priv = priv;
+
+ /* Queue read requests in the bulk OUT endpoint */
+
+ for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++)
+ {
+ privreq = &priv->rdreqs[i];
+ req = privreq->req;
+ req->len = CONFIG_USBMSC_BULKOUTREQLEN;
+ req->priv = privreq;
+ req->callback = usbmsc_rdcomplete;
+ ret = EP_SUBMIT(priv->epbulkout, req);
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDSUBMIT), (uint16_t)-ret);
+ goto errout;
+ }
+ }
+
+ priv->config = config;
+ return OK;
+
+errout:
+ usbmsc_resetconfig(priv);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_resetconfig
+ *
+ * Description:
+ * Mark the device as not configured and disable all endpoints.
+ *
+ ****************************************************************************/
+
+void usbmsc_resetconfig(FAR struct usbmsc_dev_s *priv)
+{
+ /* Are we configured? */
+
+ if (priv->config != USBMSC_CONFIGIDNONE)
+ {
+ /* Yes.. but not anymore */
+
+ priv->config = USBMSC_CONFIGIDNONE;
+
+ /* Disable endpoints. This should force completion of all pending
+ * transfers.
+ */
+
+ EP_DISABLE(priv->epbulkin);
+ EP_DISABLE(priv->epbulkout);
+ }
+}
+
+/****************************************************************************
+ * Name: usbmsc_wrcomplete
+ *
+ * Description:
+ * Handle completion of write request. This function probably executes
+ * in the context of an interrupt handler.
+ *
+ ****************************************************************************/
+
+void usbmsc_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req)
+{
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_req_s *privreq;
+ irqstate_t flags;
+
+ /* Sanity check */
+
+#ifdef CONFIG_DEBUG
+ if (!ep || !ep->priv || !req || !req->priv)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRCOMPLETEINVALIDARGS), 0);
+ return;
+ }
+#endif
+
+ /* Extract references to private data */
+
+ priv = (FAR struct usbmsc_dev_s*)ep->priv;
+ privreq = (FAR struct usbmsc_req_s *)req->priv;
+
+ /* Return the write request to the free list */
+
+ flags = irqsave();
+ sq_addlast((sq_entry_t*)privreq, &priv->wrreqlist);
+ irqrestore(flags);
+
+ /* Process the received data unless this is some unusual condition */
+
+ switch (req->result)
+ {
+ case OK: /* Normal completion */
+ usbtrace(TRACE_CLASSWRCOMPLETE, req->xfrd);
+ break;
+
+ case -ESHUTDOWN: /* Disconnection */
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRSHUTDOWN), 0);
+ break;
+
+ default: /* Some other error occurred */
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRUNEXPECTED),
+ (uint16_t)-req->result);
+ break;
+ };
+
+ /* Inform the worker thread that a write request has been returned */
+
+ priv->theventset |= USBMSC_EVENT_WRCOMPLETE;
+ pthread_cond_signal(&priv->cond);
+}
+
+/****************************************************************************
+ * Name: usbmsc_rdcomplete
+ *
+ * Description:
+ * Handle completion of read request on the bulk OUT endpoint. This
+ * is handled like the receipt of serial data on the "UART"
+ *
+ ****************************************************************************/
+
+void usbmsc_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req)
+{
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_req_s *privreq;
+ irqstate_t flags;
+ int ret;
+
+ /* Sanity check */
+
+#ifdef CONFIG_DEBUG
+ if (!ep || !ep->priv || !req || !req->priv)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDCOMPLETEINVALIDARGS), 0);
+ return;
+ }
+#endif
+
+ /* Extract references to private data */
+
+ priv = (FAR struct usbmsc_dev_s*)ep->priv;
+ privreq = (FAR struct usbmsc_req_s *)req->priv;
+
+ /* Process the received data unless this is some unusual condition */
+
+ switch (req->result)
+ {
+ case 0: /* Normal completion */
+ {
+ usbtrace(TRACE_CLASSRDCOMPLETE, req->xfrd);
+
+ /* Add the filled read request from the rdreqlist */
+
+ flags = irqsave();
+ sq_addlast((sq_entry_t*)privreq, &priv->rdreqlist);
+ irqrestore(flags);
+
+ /* Signal the worker thread that there is received data to be processed */
+
+ priv->theventset |= USBMSC_EVENT_RDCOMPLETE;
+ pthread_cond_signal(&priv->cond);
+ }
+ break;
+
+ case -ESHUTDOWN: /* Disconnection */
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDSHUTDOWN), 0);
+
+ /* Drop the read request... it will be cleaned up later */
+ }
+ break;
+
+ default: /* Some other error occurred */
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDUNEXPECTED),
+ (uint16_t)-req->result);
+
+ /* Return the read request to the bulk out endpoint for re-filling */
+
+ req = privreq->req;
+ req->priv = privreq;
+ req->callback = usbmsc_rdcomplete;
+
+ ret = EP_SUBMIT(priv->epbulkout, req);
+ if (ret != OK)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDCOMPLETERDSUBMIT),
+ (uint16_t)-ret);
+ }
+ }
+ break;
+ }
+}
+
+/****************************************************************************
+ * Name: usbmsc_deferredresponse
+ *
+ * Description:
+ * Some EP0 setup request cannot be responded to immediately becuase they
+ * require some asynchronous action from the SCSI worker thread. This
+ * function is provided for the SCSI thread to make that deferred response.
+ * The specific requests that require this deferred response are:
+ *
+ * 1. USB_REQ_SETCONFIGURATION,
+ * 2. USB_REQ_SETINTERFACE, or
+ * 3. USBMSC_REQ_MSRESET
+ *
+ * In all cases, the success reponse is a zero-length packet; the failure
+ * response is an EP0 stall.
+ *
+ * Input parameters:
+ * priv - Private state structure for this USB storage instance
+ * stall - true is the action failed and a stall is required
+ *
+ ****************************************************************************/
+
+void usbmsc_deferredresponse(FAR struct usbmsc_dev_s *priv, bool failed)
+{
+ FAR struct usbdev_s *dev;
+ FAR struct usbdev_req_s *ctrlreq;
+ int ret;
+
+#ifdef CONFIG_DEBUG
+ if (!priv || !priv->usbdev || !priv->ctrlreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEFERREDRESPINVALIDARGS), 0);
+ return;
+ }
+#endif
+
+ dev = priv->usbdev;
+ ctrlreq = priv->ctrlreq;
+
+ /* If no error occurs, respond to the deferred setup command with a null
+ * packet.
+ */
+
+ if (!failed)
+ {
+ ctrlreq->len = 0;
+ ctrlreq->flags = USBDEV_REQFLAGS_NULLPKT;
+ ret = EP_SUBMIT(dev->ep0, ctrlreq);
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEFERREDRESPSUBMIT),
+ (uint16_t)-ret);
+#if 0 /* Not necessary */
+ ctrlreq->result = OK;
+ usbmsc_ep0incomplete(dev->ep0, ctrlreq);
+#endif
+ }
+ }
+ else
+ {
+ /* On a failure, the USB driver will stall. */
+
+ usbtrace(TRACE_DEVERROR(USBMSC_TRACEERR_DEFERREDRESPSTALLED), 0);
+ EP_STALL(dev->ep0);
+ }
+}
+
+/****************************************************************************
+ * User Interfaces
+ ****************************************************************************/
+/****************************************************************************
+ * Name: usbmsc_configure
+ *
+ * Description:
+ * One-time initialization of the USB storage driver. The initialization
+ * sequence is as follows:
+ *
+ * 1. Call usbmsc_configure to perform one-time initialization specifying
+ * the number of luns.
+ * 2. Call usbmsc_bindlun to configure each supported LUN
+ * 3. Call usbmsc_exportluns when all LUNs are configured
+ *
+ * Input Parameters:
+ * nluns - the number of LUNs that will be registered
+ * handle - Location to return a handle that is used in other API calls.
+ *
+ * Returned Value:
+ * 0 on success; a negated errno on failure
+ *
+ ****************************************************************************/
+
+int usbmsc_configure(unsigned int nluns, void **handle)
+{
+ FAR struct usbmsc_alloc_s *alloc;
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_driver_s *drvr;
+ int ret;
+
+#ifdef CONFIG_DEBUG
+ if (nluns > 15)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_TOOMANYLUNS), 0);
+ return -EDOM;
+ }
+#endif
+
+ /* Allocate the structures needed */
+
+ alloc = (FAR struct usbmsc_alloc_s*)kmalloc(sizeof(struct usbmsc_alloc_s));
+ if (!alloc)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCDEVSTRUCT), 0);
+ return -ENOMEM;
+ }
+
+ /* Initialize the USB storage driver structure */
+
+ priv = &alloc->dev;
+ memset(priv, 0, sizeof(struct usbmsc_dev_s));
+
+ pthread_mutex_init(&priv->mutex, NULL);
+ pthread_cond_init(&priv->cond, NULL);
+ sq_init(&priv->wrreqlist);
+
+ priv->nluns = nluns;
+
+ /* Allocate the LUN table */
+
+ priv->luntab = (struct usbmsc_lun_s*)kmalloc(priv->nluns*sizeof(struct usbmsc_lun_s));
+ if (!priv->luntab)
+ {
+ ret = -ENOMEM;
+ goto errout;
+ }
+ memset(priv->luntab, 0, priv->nluns * sizeof(struct usbmsc_lun_s));
+
+ /* Initialize the USB class driver structure */
+
+ drvr = &alloc->drvr;
+#ifdef CONFIG_USBDEV_DUALSPEED
+ drvr->drvr.speed = USB_SPEED_HIGH;
+#else
+ drvr->drvr.speed = USB_SPEED_FULL;
+#endif
+ drvr->drvr.ops = &g_driverops;
+ drvr->dev = priv;
+
+ /* Return the handle and success */
+
+ *handle = (FAR void*)alloc;
+ return OK;
+
+errout:
+ usbmsc_uninitialize(alloc);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_bindlun
+ *
+ * Description:
+ * Bind the block driver specified by drvrpath to a USB storage LUN.
+ *
+ * Input Parameters:
+ * handle - The handle returned by a previous call to usbmsc_configure().
+ * drvrpath - the full path to the block driver
+ * startsector - A sector offset into the block driver to the start of the
+ * partition on drvrpath (0 if no partitions)
+ * nsectors - The number of sectors in the partition (if 0, all sectors
+ * to the end of the media will be exported).
+ * lunno - the LUN to bind to
+ *
+ * Returned Value:
+ * 0 on success; a negated errno on failure.
+ *
+ ****************************************************************************/
+
+int usbmsc_bindlun(FAR void *handle, FAR const char *drvrpath,
+ unsigned int lunno, off_t startsector, size_t nsectors,
+ bool readonly)
+{
+ FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_lun_s *lun;
+ FAR struct inode *inode;
+ struct geometry geo;
+ int ret;
+
+#ifdef CONFIG_DEBUG
+ if (!alloc || !drvrpath || startsector < 0 || nsectors < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINLUNINVALIDARGS1), 0);
+ return -EINVAL;
+ }
+#endif
+
+ priv = &alloc->dev;
+
+#ifdef CONFIG_DEBUG
+ if (!priv->luntab)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INTERNALCONFUSION1), 0);
+ return -EIO;
+ }
+
+ if (lunno > priv->nluns)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS2), 0);
+ return -EINVAL;
+ }
+#endif
+
+ lun = &priv->luntab[lunno];
+
+#ifdef CONFIG_DEBUG
+ if (lun->inode != NULL)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_LUNALREADYBOUND), 0);
+ return -EBUSY;
+ }
+#endif
+
+ /* Open the block driver */
+
+ ret = open_blockdriver(drvrpath, 0, &inode);
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BLKDRVEOPEN), 0);
+ return ret;
+ }
+
+ /* Get the drive geometry */
+
+ if (!inode || !inode->u.i_bops || !inode->u.i_bops->geometry ||
+ inode->u.i_bops->geometry(inode, &geo) != OK || !geo.geo_available)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOGEOMETRY), 0);
+ return -ENODEV;
+ }
+
+ /* Verify that the partition parameters are valid */
+
+ if (startsector >= geo.geo_nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS3), 0);
+ return -EDOM;
+ }
+ else if (nsectors == 0)
+ {
+ nsectors = geo.geo_nsectors - startsector;
+ }
+ else if (startsector + nsectors >= geo.geo_nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS4), 0);
+ return -EDOM;
+ }
+
+ /* Initialize the LUN structure */
+
+ memset(lun, 0, sizeof(struct usbmsc_lun_s *));
+
+ /* Allocate an I/O buffer big enough to hold one hardware sector. SCSI commands
+ * are processed one at a time so all LUNs may share a single I/O buffer. The
+ * I/O buffer will be allocated so that is it as large as the largest block
+ * device sector size
+ */
+
+ if (!priv->iobuffer)
+ {
+ priv->iobuffer = (uint8_t*)kmalloc(geo.geo_sectorsize);
+ if (!priv->iobuffer)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCIOBUFFER), geo.geo_sectorsize);
+ return -ENOMEM;
+ }
+ priv->iosize = geo.geo_sectorsize;
+ }
+ else if (priv->iosize < geo.geo_sectorsize)
+ {
+ void *tmp;
+ tmp = (uint8_t*)realloc(priv->iobuffer, geo.geo_sectorsize);
+ if (!tmp)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_REALLOCIOBUFFER), geo.geo_sectorsize);
+ return -ENOMEM;
+ }
+
+ priv->iobuffer = (uint8_t*)tmp;
+ priv->iosize = geo.geo_sectorsize;
+ }
+
+ lun->inode = inode;
+ lun->startsector = startsector;
+ lun->nsectors = nsectors;
+ lun->sectorsize = geo.geo_sectorsize;
+
+ /* If the driver does not support the write method, then this is read-only */
+
+ if (!inode->u.i_bops->write)
+ {
+ lun->readonly = true;
+ }
+ return OK;
+}
+
+/****************************************************************************
+ * Name: usbmsc_unbindlun
+ *
+ * Description:
+ * Un-bind the block driver for the specified LUN
+ *
+ * Input Parameters:
+ * handle - The handle returned by a previous call to usbmsc_configure().
+ * lun - the LUN to unbind from
+ *
+ * Returned Value:
+ * 0 on success; a negated errno on failure.
+ *
+ ****************************************************************************/
+
+int usbmsc_unbindlun(FAR void *handle, unsigned int lunno)
+{
+ FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_lun_s *lun;
+ int ret;
+
+#ifdef CONFIG_DEBUG
+ if (!alloc)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDLUNINVALIDARGS1), 0);
+ return -EINVAL;
+ }
+#endif
+
+ priv = &alloc->dev;
+
+#ifdef CONFIG_DEBUG
+ if (!priv->luntab)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INTERNALCONFUSION2), 0);
+ return -EIO;
+ }
+
+ if (lunno > priv->nluns)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDLUNINVALIDARGS2), 0);
+ return -EINVAL;
+ }
+#endif
+
+ lun = &priv->luntab[lunno];
+ pthread_mutex_lock(&priv->mutex);
+
+#ifdef CONFIG_DEBUG
+ if (lun->inode == NULL)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_LUNNOTBOUND), 0);
+ ret = -EBUSY;
+ }
+ else
+#endif
+ {
+ /* Close the block driver */
+
+ usbmsc_lununinitialize(lun);
+ ret = OK;
+ }
+
+ pthread_mutex_unlock(&priv->mutex);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_exportluns
+ *
+ * Description:
+ * After all of the LUNs have been bound, this function may be called
+ * in order to export those LUNs in the USB storage device.
+ *
+ * Input Parameters:
+ * handle - The handle returned by a previous call to usbmsc_configure().
+ *
+ * Returned Value:
+ * 0 on success; a negated errno on failure
+ *
+ ****************************************************************************/
+
+int usbmsc_exportluns(FAR void *handle)
+{
+ FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
+ FAR struct usbmsc_dev_s *priv;
+ FAR struct usbmsc_driver_s *drvr;
+ irqstate_t flags;
+#ifdef SDCC
+ pthread_attr_t attr;
+#endif
+ int ret;
+
+#ifdef CONFIG_DEBUG
+ if (!alloc)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EXPORTLUNSINVALIDARGS), 0);
+ return -ENXIO;
+ }
+#endif
+
+ priv = &alloc->dev;
+ drvr = &alloc->drvr;
+
+ /* Start the worker thread */
+
+ pthread_mutex_lock(&priv->mutex);
+ priv->thstate = USBMSC_STATE_NOTSTARTED;
+ priv->theventset = USBMSC_EVENT_NOEVENTS;
+
+#ifdef SDCC
+ (void)pthread_attr_init(&attr);
+ ret = pthread_create(&priv->thread, &attr, usbmsc_workerthread, (pthread_addr_t)priv);
+#else
+ ret = pthread_create(&priv->thread, NULL, usbmsc_workerthread, (pthread_addr_t)priv);
+#endif
+ if (ret != OK)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_THREADCREATE), (uint16_t)-ret);
+ goto errout_with_mutex;
+ }
+
+ /* Register the USB storage class driver (unless we are part of a composite device) */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ ret = usbdev_register(&drvr->drvr);
+ if (ret != OK)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEVREGISTER), (uint16_t)-ret);
+ goto errout_with_mutex;
+ }
+#endif
+
+ /* Signal to start the thread */
+
+ flags = irqsave();
+ priv->theventset |= USBMSC_EVENT_READY;
+ pthread_cond_signal(&priv->cond);
+ irqrestore(flags);
+
+errout_with_mutex:
+ pthread_mutex_unlock(&priv->mutex);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_uninitialize
+ *
+ * Description:
+ * Un-initialize the USB storage class driver
+ *
+ * Input Parameters:
+ * handle - The handle returned by a previous call to usbmsc_configure().
+ *
+ * Returned Value:
+ * None
+ *
+ ****************************************************************************/
+
+void usbmsc_uninitialize(FAR void *handle)
+{
+ FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle;
+ FAR struct usbmsc_dev_s *priv;
+ irqstate_t flags;
+#ifdef SDCC
+ pthread_addr_t result1, result2;
+ pthread_attr_t attr;
+#endif
+ void *value;
+ int ret;
+ int i;
+
+#ifdef CONFIG_DEBUG
+ if (!handle)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNINITIALIZEINVALIDARGS), 0);
+ return;
+ }
+#endif
+ priv = &alloc->dev;
+
+ /* If the thread hasn't already exitted, tell it to exit now */
+
+ if (priv->thstate != USBMSC_STATE_NOTSTARTED)
+ {
+ /* The thread was started.. Is it still running? */
+
+ pthread_mutex_lock(&priv->mutex);
+ if (priv->thstate != USBMSC_STATE_TERMINATED)
+ {
+ /* Yes.. Ask the thread to stop */
+
+ flags = irqsave();
+ priv->theventset |= USBMSC_EVENT_TERMINATEREQUEST;
+ pthread_cond_signal(&priv->cond);
+ irqrestore(flags);
+ }
+ pthread_mutex_unlock(&priv->mutex);
+
+ /* Wait for the thread to exit. This is necessary even if the
+ * thread has already exitted in order to collect the join
+ * garbage
+ */
+
+ ret = pthread_join(priv->thread, &value);
+ }
+ priv->thread = 0;
+
+ /* Unregister the driver (unless we are a part of a composite device */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ usbdev_unregister(&alloc->drvr.drvr);
+#endif
+
+ /* Uninitialize and release the LUNs */
+
+ for (i = 0; i < priv->nluns; ++i)
+ {
+ usbmsc_lununinitialize(&priv->luntab[i]);
+ }
+ kfree(priv->luntab);
+
+ /* Release the I/O buffer */
+
+ if (priv->iobuffer)
+ {
+ kfree(priv->iobuffer);
+ }
+
+ /* Uninitialize and release the driver structure */
+
+ pthread_mutex_destroy(&priv->mutex);
+ pthread_cond_destroy(&priv->cond);
+
+ kfree(priv);
+}
diff --git a/nuttx/drivers/usbdev/usbmsc.h b/nuttx/drivers/usbdev/usbmsc.h
new file mode 100644
index 000000000..910aef8bd
--- /dev/null
+++ b/nuttx/drivers/usbdev/usbmsc.h
@@ -0,0 +1,689 @@
+/****************************************************************************
+ * drivers/usbdev/usbmsc.h
+ *
+ * Copyright (C) 2008-2012 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt
+ *
+ * Mass storage class device. Bulk-only with SCSI subclass.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __DRIVERS_USBDEV_USBMSC_H
+#define __DRIVERS_USBDEV_USBMSC_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+/* Configuration ************************************************************/
+/* If the USB mass storage device is configured as part of a composite device
+ * then both CONFIG_USBDEV_COMPOSITE and CONFIG_USBMSC_COMPOSITE must be
+ * defined.
+ */
+
+#ifndef CONFIG_USBDEV_COMPOSITE
+# undef CONFIG_USBMSC_COMPOSITE
+#endif
+
+#if defined(CONFIG_USBMSC_COMPOSITE) && !defined(CONFIG_USBMSC_STRBASE)
+# define CONFIG_USBMSC_STRBASE (4)
+#endif
+
+/* Interface IDs. If the mass storage driver is built as a component of a
+ * composite device, then the interface IDs may need to be offset.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+# undef CONFIG_USBMSC_IFNOBASE
+# define CONFIG_USBMSC_IFNOBASE 0
+#endif
+
+#ifndef CONFIG_USBMSC_IFNOBASE
+# define CONFIG_USBMSC_IFNOBASE 0
+#endif
+
+/* Number of requests in the write queue */
+
+#ifndef CONFIG_USBMSC_NWRREQS
+# define CONFIG_USBMSC_NWRREQS 4
+#endif
+
+/* Number of requests in the read queue */
+
+#ifndef CONFIG_USBMSC_NRDREQS
+# define CONFIG_USBMSC_NRDREQS 4
+#endif
+
+/* Logical endpoint numbers / max packet sizes */
+
+#ifndef CONFIG_USBMSC_EPBULKOUT
+# warning "EPBULKOUT not defined in the configuration"
+# define CONFIG_USBMSC_EPBULKOUT 2
+#endif
+
+#ifndef CONFIG_USBMSC_EPBULKIN
+# warning "EPBULKIN not defined in the configuration"
+# define CONFIG_USBMSC_EPBULKIN 3
+#endif
+
+/* Packet and request buffer sizes */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+# ifndef CONFIG_USBMSC_EP0MAXPACKET
+# define CONFIG_USBMSC_EP0MAXPACKET 64
+# endif
+#endif
+
+#ifndef CONFIG_USBMSC_BULKINREQLEN
+# ifdef CONFIG_USBDEV_DUALSPEED
+# define CONFIG_USBMSC_BULKINREQLEN 512
+# else
+# define CONFIG_USBMSC_BULKINREQLEN 64
+# endif
+#else
+# ifdef CONFIG_USBDEV_DUALSPEED
+# if CONFIG_USBMSC_BULKINREQLEN < 512
+# warning "Bulk in buffer size smaller than max packet"
+# undef CONFIG_USBMSC_BULKINREQLEN
+# define CONFIG_USBMSC_BULKINREQLEN 512
+# endif
+# else
+# if CONFIG_USBMSC_BULKINREQLEN < 64
+# warning "Bulk in buffer size smaller than max packet"
+# undef CONFIG_USBMSC_BULKINREQLEN
+# define CONFIG_USBMSC_BULKINREQLEN 64
+# endif
+# endif
+#endif
+
+#ifndef CONFIG_USBMSC_BULKOUTREQLEN
+# ifdef CONFIG_USBDEV_DUALSPEED
+# define CONFIG_USBMSC_BULKOUTREQLEN 512
+# else
+# define CONFIG_USBMSC_BULKOUTREQLEN 64
+# endif
+#else
+# ifdef CONFIG_USBDEV_DUALSPEED
+# if CONFIG_USBMSC_BULKOUTREQLEN < 512
+# warning "Bulk in buffer size smaller than max packet"
+# undef CONFIG_USBMSC_BULKOUTREQLEN
+# define CONFIG_USBMSC_BULKOUTREQLEN 512
+# endif
+# else
+# if CONFIG_USBMSC_BULKOUTREQLEN < 64
+# warning "Bulk in buffer size smaller than max packet"
+# undef CONFIG_USBMSC_BULKOUTREQLEN
+# define CONFIG_USBMSC_BULKOUTREQLEN 64
+# endif
+# endif
+#endif
+
+/* Vendor and product IDs and strings */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+# ifndef CONFIG_USBMSC_VENDORID
+# warning "CONFIG_USBMSC_VENDORID not defined"
+# define CONFIG_USBMSC_VENDORID 0x584e
+# endif
+
+# ifndef CONFIG_USBMSC_PRODUCTID
+# warning "CONFIG_USBMSC_PRODUCTID not defined"
+# define CONFIG_USBMSC_PRODUCTID 0x5342
+# endif
+
+# ifndef CONFIG_USBMSC_VERSIONNO
+# define CONFIG_USBMSC_VERSIONNO (0x0399)
+# endif
+
+# ifndef CONFIG_USBMSC_VENDORSTR
+# warning "No Vendor string specified"
+# define CONFIG_USBMSC_VENDORSTR "NuttX"
+# endif
+
+# ifndef CONFIG_USBMSC_PRODUCTSTR
+# warning "No Product string specified"
+# define CONFIG_USBMSC_PRODUCTSTR "USBdev Storage"
+# endif
+
+# undef CONFIG_USBMSC_SERIALSTR
+# define CONFIG_USBMSC_SERIALSTR "0101"
+#endif
+
+#undef CONFIG_USBMSC_CONFIGSTR
+#define CONFIG_USBMSC_CONFIGSTR "Bulk"
+
+/* Debug -- must be consistent with include/debug.h */
+
+#ifdef CONFIG_CPP_HAVE_VARARGS
+# ifdef CONFIG_DEBUG
+# ifdef CONFIG_ARCH_LOWPUTC
+# define dbgprintf(format, arg...) lib_lowprintf(format, ##arg)
+# else
+# define dbgprintf(format, arg...) lib_rawprintf(format, ##arg)
+# endif
+# else
+# define dbgprintf(x...)
+# endif
+#else
+# ifdef CONFIG_DEBUG
+# ifdef CONFIG_ARCH_LOWPUTC
+# define dbgprintf lib_lowprintf
+# else
+# define dbgprintf lib_rawprintf
+# endif
+# else
+# define dbgprintf (void)
+# endif
+#endif
+
+/* Packet and request buffer sizes */
+
+#ifndef CONFIG_USBMSC_EP0MAXPACKET
+# define CONFIG_USBMSC_EP0MAXPACKET 64
+#endif
+
+/* USB Controller */
+
+#ifndef CONFIG_USBDEV_SELFPOWERED
+# define SELFPOWERED USB_CONFIG_ATT_SELFPOWER
+#else
+# define SELFPOWERED (0)
+#endif
+
+#ifndef CONFIG_USBDEV_REMOTEWAKEUP
+# define REMOTEWAKEUP USB_CONFIG_ATTR_WAKEUP
+#else
+# define REMOTEWAKEUP (0)
+#endif
+
+#ifndef CONFIG_USBDEV_MAXPOWER
+# define CONFIG_USBDEV_MAXPOWER 100
+#endif
+
+/* Current state of the worker thread */
+
+#define USBMSC_STATE_NOTSTARTED (0) /* Thread has not yet been started */
+#define USBMSC_STATE_STARTED (1) /* Started, but is not yet initialized */
+#define USBMSC_STATE_IDLE (2) /* Started and waiting for commands */
+#define USBMSC_STATE_CMDPARSE (3) /* Processing a received command */
+#define USBMSC_STATE_CMDREAD (4) /* Processing a SCSI read command */
+#define USBMSC_STATE_CMDWRITE (5) /* Processing a SCSI write command */
+#define USBMSC_STATE_CMDFINISH (6) /* Finish command processing */
+#define USBMSC_STATE_CMDSTATUS (7) /* Processing the final status of the command */
+#define USBMSC_STATE_TERMINATED (8) /* Thread has exitted */
+
+/* Event communicated to worker thread */
+
+#define USBMSC_EVENT_NOEVENTS (0) /* There are no outstanding events */
+#define USBMSC_EVENT_READY (1 << 0) /* Initialization is complete */
+#define USBMSC_EVENT_RDCOMPLETE (1 << 1) /* A read has completed there is data to be processed */
+#define USBMSC_EVENT_WRCOMPLETE (1 << 2) /* A write has completed and a request is available */
+#define USBMSC_EVENT_TERMINATEREQUEST (1 << 3) /* Shutdown requested */
+#define USBMSC_EVENT_DISCONNECT (1 << 4) /* USB disconnect received */
+#define USBMSC_EVENT_RESET (1 << 5) /* USB storage setup reset received */
+#define USBMSC_EVENT_CFGCHANGE (1 << 6) /* USB setup configuration change received */
+#define USBMSC_EVENT_IFCHANGE (1 << 7) /* USB setup interface change received */
+#define USBMSC_EVENT_ABORTBULKOUT (1 << 8) /* SCSI receive failure */
+
+/* SCSI command flags (passed to usbmsc_setupcmd()) */
+
+#define USBMSC_FLAGS_DIRMASK (0x03) /* Bits 0-1: Data direction */
+#define USBMSC_FLAGS_DIRNONE (0x00) /* No data to send */
+#define USBMSC_FLAGS_DIRHOST2DEVICE (0x01) /* Host-to-device */
+#define USBMSC_FLAGS_DIRDEVICE2HOST (0x02) /* Device-to-host */
+#define USBMSC_FLAGS_BLOCKXFR (0x04) /* Bit 2: Command is a block transfer request */
+#define USBMSC_FLAGS_LUNNOTNEEDED (0x08) /* Bit 3: Command does not require a valid LUN */
+#define USBMSC_FLAGS_UACOKAY (0x10) /* Bit 4: Command OK if unit attention condition */
+#define USBMSC_FLAGS_RETAINSENSEDATA (0x20) /* Bit 5: Do not clear sense data */
+
+/* Descriptors **************************************************************/
+
+/* Big enough to hold our biggest descriptor */
+
+#define USBMSC_MXDESCLEN (64)
+
+/* String language */
+
+#define USBMSC_STR_LANGUAGE (0x0409) /* en-us */
+
+/* Descriptor strings */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+# define USBMSC_MANUFACTURERSTRID (1)
+# define USBMSC_PRODUCTSTRID (2)
+# define USBMSC_SERIALSTRID (3)
+# define USBMSC_CONFIGSTRID (4)
+# define USBMSC_INTERFACESTRID USBMSC_CONFIGSTRID
+
+# undef CONFIG_USBMSC_STRBASE
+# define CONFIG_USBMSC_STRBASE (4)
+#else
+# define USBMSC_INTERFACESTRID (CONFIG_USBMSC_STRBASE+1)
+#endif
+#define USBMSC_LASTSTRID USBMSC_INTERFACESTRID
+
+#define USBMSC_NCONFIGS (1) /* Number of configurations supported */
+
+/* Configuration Descriptor */
+
+#define USBMSC_NINTERFACES (1) /* Number of interfaces in the configuration */
+#define USBMSC_INTERFACEID (CONFIG_USBMSC_IFNOBASE+0)
+#define USBMSC_ALTINTERFACEID USBMSC_INTERFACEID
+
+#define USBMSC_CONFIGIDNONE (0) /* Config ID means to return to address mode */
+#define USBMSC_CONFIGID (1) /* The only supported configuration ID */
+
+/* Interface description */
+
+#define USBMSC_NENDPOINTS (2) /* Number of endpoints in the interface */
+
+/* Endpoint configuration */
+
+#define USBMSC_EPOUTBULK_ADDR (CONFIG_USBMSC_EPBULKOUT)
+#define USBMSC_EPOUTBULK_ATTR (USB_EP_ATTR_XFER_BULK)
+
+#define USBMSC_EPINBULK_ADDR (USB_DIR_IN|CONFIG_USBMSC_EPBULKIN)
+#define USBMSC_EPINBULK_ATTR (USB_EP_ATTR_XFER_BULK)
+
+#define USBMSC_HSBULKMAXPACKET (512)
+#define USBMSC_HSBULKMXPKTSHIFT (9)
+#define USBMSC_HSBULKMXPKTMASK (0x000001ff)
+#define USBMSC_FSBULKMAXPACKET (64)
+#define USBMSC_FSBULKMXPKTSHIFT (6)
+#define USBMSC_FSBULKMXPKTMASK (0x0000003f)
+
+/* Macros for dual speed vs. full speed only operation */
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+# define USBMSC_EPBULKINDESC(hs) \
+ usbmsc_getepdesc((hs) ? USBMSC_EPHSBULKIN : USBMSC_EPFSBULKIN)
+# define USBMSC_EPBULKOUTDESC(hs) \
+ usbmsc_getepdesc((hs) ? USBMSC_EPHSBULKOUT : USBMSC_EPFSBULKOUT)
+# define USBMSC_BULKMAXPACKET(hs) \
+ ((hs) ? USBMSC_HSBULKMAXPACKET : USBMSC_FSBULKMAXPACKET)
+# define USBMSC_BULKMXPKTSHIFT(d) \
+ (((d)->speed==USB_SPEED_HIGH) ? USBMSC_HSBULKMXPKTSHIFT : USBMSC_FSBULKMXPKTSHIFT)
+# define USBMSC_BULKMXPKTMASK(d) \
+ (((d)->speed==USB_SPEED_HIGH) ? USBMSC_HSBULKMXPKTMASK : USBMSC_FSBULKMXPKTMASK)
+#else
+# define USBMSC_EPBULKINDESC(d) usbmsc_getepdesc(USBMSC_EPFSBULKIN)
+# define USBMSC_EPBULKOUTDESC(d) usbmsc_getepdesc(USBMSC_EPFSBULKOUT)
+# define USBMSC_BULKMAXPACKET(hs) USBMSC_FSBULKMAXPACKET
+# define USBMSC_BULKMXPKTSHIFT(d) USBMSC_FSBULKMXPKTSHIFT
+# define USBMSC_BULKMXPKTMASK(d) USBMSC_FSBULKMXPKTMASK
+#endif
+
+/* Configuration descriptor size */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+
+/* Number of individual descriptors in the configuration descriptor:
+ * (1) Configuration descriptor + (1) interface descriptor + (2) interface
+ * descriptors.
+ */
+
+# define USBMSC_CFGGROUP_SIZE (4)
+
+/* The size of the config descriptor: (9 + 9 + 2*7) = 32 */
+
+# define SIZEOF_USBMSC_CFGDESC \
+ (USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC)
+#else
+
+/* Number of individual descriptors in the configuration descriptor:
+ * (1) interface descriptor + (2) interface descriptors.
+ */
+
+# define USBMSC_CFGGROUP_SIZE (3)
+
+/* The size of the config descriptor: (9 + 2*7) = 23 */
+
+# define SIZEOF_USBMSC_CFGDESC (USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC)
+#endif
+
+/* Block driver helpers *****************************************************/
+
+#define USBMSC_DRVR_READ(l,b,s,n) ((l)->inode->u.i_bops->read((l)->inode,b,s,n))
+#define USBMSC_DRVR_WRITE(l,b,s,n) ((l)->inode->u.i_bops->write((l)->inode,b,s,n))
+#define USBMSC_DRVR_GEOMETRY(l,g) ((l)->inode->u.i_bops->geometry((l)->inode,g))
+
+/* Everpresent MIN/MAX macros ***********************************************/
+
+#ifndef MIN
+# define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+#ifndef MAX
+# define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+/* Endpoint descriptors */
+
+enum usbmsc_epdesc_e
+{
+ USBMSC_EPFSBULKOUT = 0, /* Full speed bulk OUT endpoint descriptor */
+ USBMSC_EPFSBULKIN /* Full speed bulk IN endpoint descriptor */
+#ifdef CONFIG_USBDEV_DUALSPEED
+ ,
+ USBMSC_EPHSBULKOUT, /* High speed bulk OUT endpoint descriptor */
+ USBMSC_EPHSBULKIN /* High speed bulk IN endpoint descriptor */
+#endif
+};
+
+/* Container to support a list of requests */
+
+struct usbmsc_req_s
+{
+ FAR struct usbmsc_req_s *flink; /* Implements a singly linked list */
+ FAR struct usbdev_req_s *req; /* The contained request */
+};
+
+/* This structure describes one LUN: */
+
+struct usbmsc_lun_s
+{
+ struct inode *inode; /* Inode structure of open'ed block driver */
+ uint8_t readonly:1; /* Media is read-only */
+ uint8_t locked:1; /* Media removal is prevented */
+ uint16_t sectorsize; /* The size of one sector */
+ uint32_t sd; /* Sense data */
+ uint32_t sdinfo; /* Sense data information */
+ uint32_t uad; /* Unit needs attention data */
+ off_t startsector; /* Sector offset to start of partition */
+ size_t nsectors; /* Number of sectors in the partition */
+};
+
+/* Describes the overall state of the driver */
+
+struct usbmsc_dev_s
+{
+ FAR struct usbdev_s *usbdev; /* usbdev driver pointer (Non-null if registered) */
+
+ /* Worker thread interface */
+
+ pthread_t thread; /* The worker thread */
+ pthread_mutex_t mutex; /* Mutually exclusive access to resources*/
+ pthread_cond_t cond; /* Used to signal worker thread */
+ volatile uint8_t thstate; /* State of the worker thread */
+ volatile uint16_t theventset; /* Set of pending events signaled to worker thread */
+ volatile uint8_t thvalue; /* Value passed with the event (must persist) */
+
+ /* Storage class configuration and state */
+
+ uint8_t nluns:4; /* Number of LUNs */
+ uint8_t config; /* Configuration number */
+
+ /* Endpoints */
+
+ FAR struct usbdev_ep_s *epbulkin; /* Bulk IN endpoint structure */
+ FAR struct usbdev_ep_s *epbulkout; /* Bulk OUT endpoint structure */
+ FAR struct usbdev_req_s *ctrlreq; /* Control request (for ep0 setup responses) */
+
+ /* SCSI command processing */
+
+ struct usbmsc_lun_s *lun; /* Currently selected LUN */
+ struct usbmsc_lun_s *luntab; /* Allocated table of all LUNs */
+ uint8_t cdb[USBMSC_MAXCDBLEN]; /* Command data (cdb[]) from CBW */
+ uint8_t phaseerror:1; /* Need to send phase sensing status */
+ uint8_t shortpacket:1; /* Host transmission stopped unexpectedly */
+ uint8_t cbwdir:2; /* Direction from CBW. See USBMSC_FLAGS_DIR* definitions */
+ uint8_t cdblen; /* Length of cdb[] from CBW */
+ uint8_t cbwlun; /* LUN from the CBW */
+ uint16_t nsectbytes; /* Bytes buffered in iobuffer[] */
+ uint16_t nreqbytes; /* Bytes buffered in head write requests */
+ uint16_t iosize; /* Size of iobuffer[] */
+ uint32_t cbwlen; /* Length of data from CBW */
+ uint32_t cbwtag; /* Tag from the CBW */
+ union
+ {
+ uint32_t xfrlen; /* Read/Write: Sectors remaining to be transferred */
+ uint32_t alloclen; /* Other device-to-host: Host allocation length */
+ } u;
+ uint32_t sector; /* Current sector (relative to lun->startsector) */
+ uint32_t residue; /* Untransferred amount reported in the CSW */
+ uint8_t *iobuffer; /* Buffer for data transfers */
+
+ /* Write request list */
+
+ struct sq_queue_s wrreqlist; /* List of empty write request containers */
+ struct sq_queue_s rdreqlist; /* List of filled read request containers */
+
+ /* Pre-allocated write request containers. The write requests will
+ * be linked in a free list (wrreqlist), and used to send requests to
+ * EPBULKIN; Read requests will be queued in the EBULKOUT.
+ */
+
+ struct usbmsc_req_s wrreqs[CONFIG_USBMSC_NWRREQS];
+ struct usbmsc_req_s rdreqs[CONFIG_USBMSC_NRDREQS];
+};
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+#undef EXTERN
+#if defined(__cplusplus)
+# define EXTERN extern "C"
+extern "C"
+{
+#else
+# define EXTERN extern
+#endif
+
+/* String *******************************************************************/
+
+/* Mass storage class vendor/product/serial number strings */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+EXTERN const char g_mscvendorstr[];
+EXTERN const char g_mscproductstr[];
+EXTERN const char g_mscserialstr[];
+
+/* If we are using a composite device, then vendor/product/serial number strings
+ * are provided by the composite device logic.
+ */
+
+#else
+EXTERN const char g_compvendorstr[];
+EXTERN const char g_compproductstr[];
+EXTERN const char g_compserialstr[];
+
+#define g_mscvendorstr g_compvendorstr
+#define g_mscproductstr g_compproductstr
+#define g_mscserialstr g_compserialstr
+#endif
+/************************************************************************************
+ * Public Function Prototypes
+ ************************************************************************************/
+
+/************************************************************************************
+ * Name: usbmsc_mkstrdesc
+ *
+ * Description:
+ * Construct a string descriptor
+ *
+ ************************************************************************************/
+
+struct usb_strdesc_s;
+int usbmsc_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc);
+
+/************************************************************************************
+ * Name: usbmsc_getepdesc
+ *
+ * Description:
+ * Return a pointer to the raw device descriptor
+ *
+ ************************************************************************************/
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+FAR const struct usb_devdesc_s *usbmsc_getdevdesc(void);
+#endif
+
+/************************************************************************************
+ * Name: usbmsc_getepdesc
+ *
+ * Description:
+ * Return a pointer to the raw endpoint descriptor (used for configuring endpoints)
+ *
+ ************************************************************************************/
+
+struct usb_epdesc_s;
+FAR const struct usb_epdesc_s *usbmsc_getepdesc(enum usbmsc_epdesc_e epid);
+
+/************************************************************************************
+ * Name: usbmsc_mkcfgdesc
+ *
+ * Description:
+ * Construct the configuration descriptor
+ *
+ ************************************************************************************/
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+int16_t usbmsc_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type);
+#else
+int16_t usbmsc_mkcfgdesc(FAR uint8_t *buf);
+#endif
+
+/************************************************************************************
+ * Name: usbmsc_getqualdesc
+ *
+ * Description:
+ * Return a pointer to the raw qual descriptor
+ *
+ ************************************************************************************/
+
+#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
+FAR const struct usb_qualdesc_s *usbmsc_getqualdesc(void);
+#endif
+
+/****************************************************************************
+ * Name: usbmsc_workerthread
+ *
+ * Description:
+ * This is the main function of the USB storage worker thread. It loops
+ * until USB-related events occur, then processes those events accordingly
+ *
+ ****************************************************************************/
+
+EXTERN void *usbmsc_workerthread(void *arg);
+
+/****************************************************************************
+ * Name: usbmsc_setconfig
+ *
+ * Description:
+ * Set the device configuration by allocating and configuring endpoints and
+ * by allocating and queue read and write requests.
+ *
+ ****************************************************************************/
+
+EXTERN int usbmsc_setconfig(FAR struct usbmsc_dev_s *priv, uint8_t config);
+
+/****************************************************************************
+ * Name: usbmsc_resetconfig
+ *
+ * Description:
+ * Mark the device as not configured and disable all endpoints.
+ *
+ ****************************************************************************/
+
+EXTERN void usbmsc_resetconfig(FAR struct usbmsc_dev_s *priv);
+
+/****************************************************************************
+ * Name: usbmsc_wrcomplete
+ *
+ * Description:
+ * Handle completion of write request. This function probably executes
+ * in the context of an interrupt handler.
+ *
+ ****************************************************************************/
+
+EXTERN void usbmsc_wrcomplete(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req);
+
+/****************************************************************************
+ * Name: usbmsc_rdcomplete
+ *
+ * Description:
+ * Handle completion of read request on the bulk OUT endpoint. This
+ * is handled like the receipt of serial data on the "UART"
+ *
+ ****************************************************************************/
+
+EXTERN void usbmsc_rdcomplete(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req);
+
+/****************************************************************************
+ * Name: usbmsc_deferredresponse
+ *
+ * Description:
+ * Some EP0 setup request cannot be responded to immediately becuase they
+ * require some asynchronous action from the SCSI worker thread. This
+ * function is provided for the SCSI thread to make that deferred response.
+ * The specific requests that require this deferred response are:
+ *
+ * 1. USB_REQ_SETCONFIGURATION,
+ * 2. USB_REQ_SETINTERFACE, or
+ * 3. USBMSC_REQ_MSRESET
+ *
+ * In all cases, the success reponse is a zero-length packet; the failure
+ * response is an EP0 stall.
+ *
+ * Input parameters:
+ * priv - Private state structure for this USB storage instance
+ * stall - true is the action failed and a stall is required
+ *
+ ****************************************************************************/
+
+EXTERN void usbmsc_deferredresponse(FAR struct usbmsc_dev_s *priv, bool failed);
+
+#undef EXTERN
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* #define __DRIVERS_USBDEV_USBMSC_H */
diff --git a/nuttx/drivers/usbdev/usbmsc_descriptors.c b/nuttx/drivers/usbdev/usbmsc_descriptors.c
new file mode 100644
index 000000000..30a48f1bf
--- /dev/null
+++ b/nuttx/drivers/usbdev/usbmsc_descriptors.c
@@ -0,0 +1,435 @@
+/****************************************************************************
+ * drivers/usbdev/usbmsc_descriptors.c
+ *
+ * Copyright (C) 2011-2012 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+#include "usbmsc.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+/* Descriptors **************************************************************/
+/* Device descriptor. If the USB mass storage device is configured as part
+ * of a composite device, then the device descriptor will be provided by the
+ * composite device logic.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+static const struct usb_devdesc_s g_devdesc =
+{
+ USB_SIZEOF_DEVDESC, /* len */
+ USB_DESC_TYPE_DEVICE, /* type */
+ {LSBYTE(0x0200), MSBYTE(0x0200)}, /* usb */
+ USB_CLASS_PER_INTERFACE, /* class */
+ 0, /* subclass */
+ 0, /* protocol */
+ CONFIG_USBMSC_EP0MAXPACKET, /* maxpacketsize */
+ { /* vendor */
+ LSBYTE(CONFIG_USBMSC_VENDORID),
+ MSBYTE(CONFIG_USBMSC_VENDORID)
+ },
+ { /* product */
+ LSBYTE(CONFIG_USBMSC_PRODUCTID),
+ MSBYTE(CONFIG_USBMSC_PRODUCTID) },
+ { /* device */
+ LSBYTE(CONFIG_USBMSC_VERSIONNO),
+ MSBYTE(CONFIG_USBMSC_VERSIONNO)
+ },
+ USBMSC_MANUFACTURERSTRID, /* imfgr */
+ USBMSC_PRODUCTSTRID, /* iproduct */
+ USBMSC_SERIALSTRID, /* serno */
+ USBMSC_NCONFIGS /* nconfigs */
+};
+#endif
+
+/* Configuration descriptor If the USB mass storage device is configured as part
+ * of a composite device, then the configuration descriptor will be provided by the
+ * composite device logic.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+static const struct usb_cfgdesc_s g_cfgdesc =
+{
+ USB_SIZEOF_CFGDESC, /* len */
+ USB_DESC_TYPE_CONFIG, /* type */
+ {0, 0}, /* totallen -- to be provided */
+ USBMSC_NINTERFACES, /* ninterfaces */
+ USBMSC_CONFIGID, /* cfgvalue */
+ USBMSC_CONFIGSTRID, /* icfg */
+ USB_CONFIG_ATTR_ONE|SELFPOWERED|REMOTEWAKEUP, /* attr */
+ (CONFIG_USBDEV_MAXPOWER + 1) / 2 /* mxpower */
+};
+#endif
+
+/* Single interface descriptor */
+
+static const struct usb_ifdesc_s g_ifdesc =
+{
+ USB_SIZEOF_IFDESC, /* len */
+ USB_DESC_TYPE_INTERFACE, /* type */
+ USBMSC_INTERFACEID, /* ifno */
+ USBMSC_ALTINTERFACEID, /* alt */
+ USBMSC_NENDPOINTS, /* neps */
+ USB_CLASS_MASS_STORAGE, /* class */
+ USBMSC_SUBCLASS_SCSI, /* subclass */
+ USBMSC_PROTO_BULKONLY, /* protocol */
+ USBMSC_INTERFACESTRID /* iif */
+};
+
+/* Endpoint descriptors */
+
+static const struct usb_epdesc_s g_fsepbulkoutdesc =
+{
+ USB_SIZEOF_EPDESC, /* len */
+ USB_DESC_TYPE_ENDPOINT, /* type */
+ USBMSC_EPOUTBULK_ADDR, /* addr */
+ USBMSC_EPOUTBULK_ATTR, /* attr */
+ { /* maxpacket */
+ LSBYTE(USBMSC_FSBULKMAXPACKET),
+ MSBYTE(USBMSC_FSBULKMAXPACKET)
+ },
+ 0 /* interval */
+};
+
+static const struct usb_epdesc_s g_fsepbulkindesc =
+{
+ USB_SIZEOF_EPDESC, /* len */
+ USB_DESC_TYPE_ENDPOINT, /* type */
+ USBMSC_EPINBULK_ADDR, /* addr */
+ USBMSC_EPINBULK_ATTR, /* attr */
+ { /* maxpacket */
+ LSBYTE(USBMSC_FSBULKMAXPACKET),
+ MSBYTE(USBMSC_FSBULKMAXPACKET)
+ },
+ 0 /* interval */
+};
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+#ifndef CONFIG_USBMSC_COMPOSITE
+static const struct usb_qualdesc_s g_qualdesc =
+{
+ USB_SIZEOF_QUALDESC, /* len */
+ USB_DESC_TYPE_DEVICEQUALIFIER, /* type */
+ { /* usb */
+ LSBYTE(0x0200),
+ MSBYTE(0x0200)
+ },
+ USB_CLASS_PER_INTERFACE, /* class */
+ 0, /* subclass */
+ 0, /* protocol */
+ CONFIG_USBMSC_EP0MAXPACKET, /* mxpacketsize */
+ USBMSC_NCONFIGS, /* nconfigs */
+ 0, /* reserved */
+};
+#endif
+
+static const struct usb_epdesc_s g_hsepbulkoutdesc =
+{
+ USB_SIZEOF_EPDESC, /* len */
+ USB_DESC_TYPE_ENDPOINT, /* type */
+ USBMSC_EPOUTBULK_ADDR, /* addr */
+ USBMSC_EPOUTBULK_ATTR, /* attr */
+ { /* maxpacket */
+ LSBYTE(USBMSC_HSBULKMAXPACKET),
+ MSBYTE(USBMSC_HSBULKMAXPACKET)
+ },
+ 0 /* interval */
+};
+
+static const struct usb_epdesc_s g_hsepbulkindesc =
+{
+ USB_SIZEOF_EPDESC, /* len */
+ USB_DESC_TYPE_ENDPOINT, /* type */
+ USBMSC_EPINBULK_ADDR, /* addr */
+ USBMSC_EPINBULK_ATTR, /* attr */
+ { /* maxpacket */
+ LSBYTE(USBMSC_HSBULKMAXPACKET),
+ MSBYTE(USBMSC_HSBULKMAXPACKET)
+ },
+ 0 /* interval */
+};
+#endif
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+/* Strings ******************************************************************/
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+const char g_mscvendorstr[] = CONFIG_USBMSC_VENDORSTR;
+const char g_mscproductstr[] = CONFIG_USBMSC_PRODUCTSTR;
+const char g_mscserialstr[] = CONFIG_USBMSC_SERIALSTR;
+#endif
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbmsc_mkstrdesc
+ *
+ * Description:
+ * Construct a string descriptor
+ *
+ ****************************************************************************/
+
+int usbmsc_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
+{
+ const char *str;
+ int len;
+ int ndata;
+ int i;
+
+ switch (id)
+ {
+#ifndef CONFIG_USBMSC_COMPOSITE
+ case 0:
+ {
+ /* Descriptor 0 is the language id */
+
+ strdesc->len = 4;
+ strdesc->type = USB_DESC_TYPE_STRING;
+ strdesc->data[0] = LSBYTE(USBMSC_STR_LANGUAGE);
+ strdesc->data[1] = MSBYTE(USBMSC_STR_LANGUAGE);
+ return 4;
+ }
+
+ case USBMSC_MANUFACTURERSTRID:
+ str = g_mscvendorstr;
+ break;
+
+ case USBMSC_PRODUCTSTRID:
+ str = g_mscproductstr;
+ break;
+
+ case USBMSC_SERIALSTRID:
+ str = g_mscserialstr;
+ break;
+#endif
+
+ /* case USBMSC_CONFIGSTRID: */
+ case USBMSC_INTERFACESTRID:
+ str = CONFIG_USBMSC_CONFIGSTR;
+ break;
+
+ default:
+ return -EINVAL;
+ }
+
+ /* The string is utf16-le. The poor man's utf-8 to utf16-le
+ * conversion below will only handle 7-bit en-us ascii
+ */
+
+ len = strlen(str);
+ for (i = 0, ndata = 0; i < len; i++, ndata += 2)
+ {
+ strdesc->data[ndata] = str[i];
+ strdesc->data[ndata+1] = 0;
+ }
+
+ strdesc->len = ndata+2;
+ strdesc->type = USB_DESC_TYPE_STRING;
+ return strdesc->len;
+}
+
+/****************************************************************************
+ * Name: usbmsc_getepdesc
+ *
+ * Description:
+ * Return a pointer to the raw device descriptor
+ *
+ ****************************************************************************/
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+FAR const struct usb_devdesc_s *usbmsc_getdevdesc(void)
+{
+ return &g_devdesc;
+}
+#endif
+
+/****************************************************************************
+ * Name: usbmsc_getepdesc
+ *
+ * Description:
+ * Return a pointer to the raw endpoint descriptor (used for configuring
+ * endpoints)
+ *
+ ****************************************************************************/
+
+FAR const struct usb_epdesc_s *usbmsc_getepdesc(enum usbmsc_epdesc_e epid)
+{
+ switch (epid)
+ {
+ case USBMSC_EPFSBULKOUT: /* Full speed bulk OUT endpoint descriptor */
+ return &g_fsepbulkoutdesc;
+
+ case USBMSC_EPFSBULKIN: /* Full speed bulk IN endpoint descriptor */
+ return &g_fsepbulkindesc;
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+ case USBMSC_EPHSBULKOUT: /* High speed bulk OUT endpoint descriptor */
+ return &g_hsepbulkoutdesc;
+
+ case USBMSC_EPHSBULKIN: /* High speed bulk IN endpoint descriptor */
+ return &g_hsepbulkindesc;
+#endif
+ default:
+ return NULL;
+ }
+};
+
+/****************************************************************************
+ * Name: usbmsc_mkcfgdesc
+ *
+ * Description:
+ * Construct the configuration descriptor
+ *
+ ****************************************************************************/
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+int16_t usbmsc_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type)
+#else
+int16_t usbmsc_mkcfgdesc(uint8_t *buf)
+#endif
+{
+#ifndef CONFIG_USBMSC_COMPOSITE
+ FAR struct usb_cfgdesc_s *cfgdesc = (struct usb_cfgdesc_s*)buf;
+#endif
+#ifdef CONFIG_USBDEV_DUALSPEED
+ FAR const struct usb_epdesc_s *epdesc;
+ bool hispeed = (speed == USB_SPEED_HIGH);
+ uint16_t bulkmxpacket;
+#endif
+ uint16_t totallen;
+
+ /* This is the total length of the configuration (not necessarily the
+ * size that we will be sending now.
+ */
+
+ totallen = USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + USBMSC_NENDPOINTS * USB_SIZEOF_EPDESC;
+
+ /* Configuration descriptor -- Copy the canned descriptor and fill in the
+ * type (we'll also need to update the size below). If the USB mass storage
+ * device is configured as part of a composite device, then the configuration
+ * descriptor will be provided by the composite device logic.
+ */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ memcpy(cfgdesc, &g_cfgdesc, USB_SIZEOF_CFGDESC);
+ buf += USB_SIZEOF_CFGDESC;
+#endif
+
+ /* Copy the canned interface descriptor */
+
+ memcpy(buf, &g_ifdesc, USB_SIZEOF_IFDESC);
+ buf += USB_SIZEOF_IFDESC;
+
+ /* Make the two endpoint configurations */
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+ /* Check for switches between high and full speed */
+
+ hispeed = (speed == USB_SPEED_HIGH);
+ if (type == USB_DESC_TYPE_OTHERSPEEDCONFIG)
+ {
+ hispeed = !hispeed;
+ }
+
+ bulkmxpacket = USBMSC_BULKMAXPACKET(hispeed);
+ epdesc = USBMSC_EPBULKINDESC(hispeed);
+ memcpy(buf, epdesc, USB_SIZEOF_EPDESC);
+ buf += USB_SIZEOF_EPDESC;
+
+ epdesc = USBMSC_EPBULKOUTDESC(hispeed);
+ memcpy(buf, epdesc, USB_SIZEOF_EPDESC);
+#else
+ memcpy(buf, &g_fsepbulkoutdesc, USB_SIZEOF_EPDESC);
+ buf += USB_SIZEOF_EPDESC;
+ memcpy(buf, &g_fsepbulkindesc, USB_SIZEOF_EPDESC);
+#endif
+
+ /* Finally, fill in the total size of the configuration descriptor */
+
+#ifndef CONFIG_USBMSC_COMPOSITE
+ cfgdesc->totallen[0] = LSBYTE(totallen);
+ cfgdesc->totallen[1] = MSBYTE(totallen);
+#endif
+ return totallen;
+}
+
+/****************************************************************************
+ * Name: usbmsc_getqualdesc
+ *
+ * Description:
+ * Return a pointer to the raw qual descriptor
+ *
+ ****************************************************************************/
+
+#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
+FAR const struct usb_qualdesc_s *usbmsc_getqualdesc(void)
+{
+ return &g_qualdesc;
+}
+#endif
+
diff --git a/nuttx/drivers/usbdev/usbmsc_scsi.c b/nuttx/drivers/usbdev/usbmsc_scsi.c
new file mode 100644
index 000000000..799f81ea6
--- /dev/null
+++ b/nuttx/drivers/usbdev/usbmsc_scsi.c
@@ -0,0 +1,2664 @@
+/****************************************************************************
+ * drivers/usbdev/usbmsc_scsi.c
+ *
+ * Copyright (C) 2008-2010, 2012 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt
+ *
+ * Mass storage class device. Bulk-only with SCSI subclass.
+ *
+ * References:
+ * "Universal Serial Bus Mass Storage Class, Specification Overview,"
+ * Revision 1.2, USB Implementer's Forum, June 23, 2003.
+ *
+ * "Universal Serial Bus Mass Storage Class, Bulk-Only Transport,"
+ * Revision 1.0, USB Implementer's Forum, September 31, 1999.
+ *
+ * "SCSI Primary Commands - 3 (SPC-3)," American National Standard
+ * for Information Technology, May 4, 2005
+ *
+ * "SCSI Primary Commands - 4 (SPC-4)," American National Standard
+ * for Information Technology, July 19, 2008
+ *
+ * "SCSI Block Commands -2 (SBC-2)," American National Standard
+ * for Information Technology, November 13, 2004
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include "usbmsc.h"
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/* Configuration ************************************************************/
+
+/* Race condition workaround found by David Hewson. This race condition
+ * "seems to relate to stalling the endpoint when a short response is
+ * generated which causes a residue to exist when the CSW would be returned.
+ * I think there's two issues here. The first being if the transfer which
+ * had just been queued before the stall had not completed then it wouldn’t
+ * then complete once the endpoint was stalled? The second is that the
+ * subsequent transfer for the CSW would be dropped on the floor (by the
+ * epsubmit() function) if the end point was still stalled as the control
+ * transfer to resume it hadn't occurred."
+ */
+
+#define CONFIG_USBMSC_RACEWAR 1
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/* Debug ********************************************************************/
+
+#if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB)
+static void usbmsc_dumpdata(const char *msg, const uint8_t *buf,
+ int buflen);
+#else
+# define usbmsc_dumpdata(msg, buf, len)
+#endif
+
+/* Utility Support Functions ************************************************/
+
+static uint16_t usbmsc_getbe16(uint8_t *buf);
+static uint32_t usbmsc_getbe32(uint8_t *buf);
+static void usbmsc_putbe16(uint8_t * buf, uint16_t val);
+static void usbmsc_putbe24(uint8_t *buf, uint32_t val);
+static void usbmsc_putbe32(uint8_t *buf, uint32_t val);
+#if 0 /* not used */
+static uint16_t usbmsc_getle16(uint8_t *buf);
+#endif
+static uint32_t usbmsc_getle32(uint8_t *buf);
+#if 0 /* not used */
+static void usbmsc_putle16(uint8_t * buf, uint16_t val);
+#endif
+static void usbmsc_putle32(uint8_t *buf, uint32_t val);
+
+/* SCSI Command Processing **************************************************/
+
+static inline int usbmsc_cmdtestunitready(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdrequestsense(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf);
+static inline int usbmsc_cmdread6(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdwrite6(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdinquiry(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf);
+static inline int usbmsc_cmdmodeselect6(FAR struct usbmsc_dev_s *priv);
+static int usbmsc_modepage(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf, uint8_t pcpgcode, int *mdlen);
+static inline int usbmsc_cmdmodesense6(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf);
+static inline int usbmsc_cmdstartstopunit(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdpreventmediumremoval(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdreadformatcapacity(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf);
+static inline int usbmsc_cmdreadcapacity10(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf);
+static inline int usbmsc_cmdread10(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdwrite10(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdverify10(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdsynchronizecache10(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdmodeselect10(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdmodesense10(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf);
+static inline int usbmsc_cmdread12(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_cmdwrite12(FAR struct usbmsc_dev_s *priv);
+static inline int usbmsc_setupcmd(FAR struct usbmsc_dev_s *priv,
+ uint8_t cdblen, uint8_t flags);
+
+/* SCSI Worker Thread *******************************************************/
+
+static int usbmsc_idlestate(FAR struct usbmsc_dev_s *priv);
+static int usbmsc_cmdparsestate(FAR struct usbmsc_dev_s *priv);
+static int usbmsc_cmdreadstate(FAR struct usbmsc_dev_s *priv);
+static int usbmsc_cmdwritestate(FAR struct usbmsc_dev_s *priv);
+static int usbmsc_cmdfinishstate(FAR struct usbmsc_dev_s *priv);
+static int usbmsc_cmdstatusstate(FAR struct usbmsc_dev_s *priv);
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Debug
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbmsc_dumpdata
+ ****************************************************************************/
+
+#if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB)
+static void usbmsc_dumpdata(const char *msg, const uint8_t *buf, int buflen)
+{
+ int i;
+
+ dbgprintf("%s:", msg);
+ for (i = 0; i < buflen; i++)
+ {
+ dbgprintf(" %02x", buf[i]);
+ }
+ dbgprintf("\n");
+}
+#endif
+
+/****************************************************************************
+ * Utility Support Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbmsc_getbe16
+ *
+ * Description:
+ * Get a 16-bit big-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+static uint16_t usbmsc_getbe16(uint8_t *buf)
+{
+ return ((uint16_t)buf[0] << 8) | ((uint16_t)buf[1]);
+}
+
+/****************************************************************************
+ * Name: usbmsc_getbe32
+ *
+ * Description:
+ * Get a 32-bit big-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+static uint32_t usbmsc_getbe32(uint8_t *buf)
+{
+ return ((uint32_t)buf[0] << 24) | ((uint32_t)buf[1] << 16) |
+ ((uint32_t)buf[2] << 8) | ((uint32_t)buf[3]);
+}
+
+/****************************************************************************
+ * Name: usbmsc_putbe16
+ *
+ * Description:
+ * Store a 16-bit value in big-endian order to the location specified by
+ * a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbmsc_putbe16(uint8_t * buf, uint16_t val)
+{
+ buf[0] = val >> 8;
+ buf[1] = val;
+}
+
+/****************************************************************************
+ * Name: usbmsc_putbe24
+ *
+ * Description:
+ * Store a 32-bit value in big-endian order to the location specified by
+ * a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbmsc_putbe24(uint8_t *buf, uint32_t val)
+{
+ buf[0] = val >> 16;
+ buf[1] = val >> 8;
+ buf[2] = val;
+}
+
+/****************************************************************************
+ * Name: usbmsc_putbe32
+ *
+ * Description:
+ * Store a 32-bit value in big-endian order to the location specified by
+ * a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbmsc_putbe32(uint8_t *buf, uint32_t val)
+{
+ buf[0] = val >> 24;
+ buf[1] = val >> 16;
+ buf[2] = val >> 8;
+ buf[3] = val;
+}
+
+/****************************************************************************
+ * Name: usbmsc_getle16
+ *
+ * Description:
+ * Get a 16-bit little-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+#if 0 /* not used */
+static uint16_t usbmsc_getle16(uint8_t *buf)
+{
+ return ((uint16_t)buf[1] << 8) | ((uint16_t)buf[0]);
+}
+#endif
+
+/****************************************************************************
+ * Name: usbmsc_getle32
+ *
+ * Description:
+ * Get a 32-bit little-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+static uint32_t usbmsc_getle32(uint8_t *buf)
+{
+ return ((uint32_t)buf[3] << 24) | ((uint32_t)buf[2] << 16) |
+ ((uint32_t)buf[1] << 8) | ((uint32_t)buf[0]);
+}
+
+/****************************************************************************
+ * Name: usbmsc_putle16
+ *
+ * Description:
+ * Store a 16-bit value in little-endian order to the location specified by
+ * a byte pointer
+ *
+ ****************************************************************************/
+
+#if 0 /* not used */
+static void usbmsc_putle16(uint8_t * buf, uint16_t val)
+{
+ buf[0] = val;
+ buf[1] = val >> 8;
+}
+#endif
+
+/****************************************************************************
+ * Name: usbmsc_putle32
+ *
+ * Description:
+ * Store a 32-bit value in little-endian order to the location specified by
+ * a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbmsc_putle32(uint8_t *buf, uint32_t val)
+{
+ buf[0] = val;
+ buf[1] = val >> 8;
+ buf[2] = val >> 16;
+ buf[3] = val >> 24;
+}
+
+/****************************************************************************
+ * SCSI Worker Thread
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbmsc_cmdtestunitready
+ *
+ * Description:
+ * Handle the SCSI_CMD_TESTUNITREADY command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdtestunitready(FAR struct usbmsc_dev_s *priv)
+{
+ int ret;
+
+ priv->u.alloclen = 0;
+ ret = usbmsc_setupcmd(priv, 6, USBMSC_FLAGS_DIRNONE);
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdrequestsense
+ *
+ * Description:
+ * Handle the SCSI_CMD_REQUESTSENSE command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdrequestsense(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf)
+{
+ FAR struct scsicmd_requestsense_s *request = (FAR struct scsicmd_requestsense_s *)priv->cdb;
+ FAR struct scsiresp_fixedsensedata_s *response = (FAR struct scsiresp_fixedsensedata_s *)buf;
+ FAR struct usbmsc_lun_s *lun;
+ uint32_t sd;
+ uint32_t sdinfo;
+ uint8_t cdblen;
+ int ret;
+
+ /* Extract the host allocation length */
+
+ priv->u.alloclen = request->alloclen;
+
+ /* Get the expected length of the command (with hack for MS-Windows 12-byte
+ * REQUEST SENSE command.
+ */
+
+ cdblen = SCSICMD_REQUESTSENSE_SIZEOF;
+ if (cdblen != priv->cdblen)
+ {
+ /* Try MS-Windows REQUEST SENSE with cbw->cdblen == 12 */
+
+ cdblen = SCSICMD_REQUESTSENSE_MSSIZEOF;
+ }
+
+ ret = usbmsc_setupcmd(priv, cdblen,
+ USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_LUNNOTNEEDED|
+ USBMSC_FLAGS_UACOKAY|USBMSC_FLAGS_RETAINSENSEDATA);
+ if (ret == OK)
+ {
+ lun = priv->lun;
+ if (!lun)
+ {
+ sd = SCSI_KCQIR_INVALIDLUN;
+ sdinfo = 0;
+ }
+ else
+ {
+ /* Get the saved sense data from the LUN structure */
+
+ sd = lun->sd;
+ sdinfo = lun->sdinfo;
+
+ /* Discard the sense data */
+
+ lun->sd = SCSI_KCQ_NOSENSE;
+ lun->sdinfo = 0;
+ }
+
+ /* Create the fixed sense data response */
+
+ memset(response, 0, SCSIRESP_FIXEDSENSEDATA_SIZEOF);
+
+ response->code = SCSIRESP_SENSEDATA_RESPVALID|SCSIRESP_SENSEDATA_CURRENTFIXED;
+ response->flags = (uint8_t)(sd >> 16);
+ usbmsc_putbe32(response->info, sdinfo);
+ response->len = SCSIRESP_FIXEDSENSEDATA_SIZEOF - 7;
+ response->code2 = (uint8_t)(sd >> 8);
+ response->qual2 = (uint8_t)sd;
+
+ priv->nreqbytes = SCSIRESP_FIXEDSENSEDATA_SIZEOF;
+ ret = OK;
+ }
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdread6
+ *
+ * Description:
+ * Handle the SCSI_CMD_READ6 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdread6(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct scsicmd_read6_s *read6 = (FAR struct scsicmd_read6_s*)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.xfrlen = (uint16_t)read6->xfrlen;
+ if (priv->u.xfrlen == 0)
+ {
+ priv->u.xfrlen = 256;
+ }
+
+ ret = usbmsc_setupcmd(priv, SCSICMD_READ6_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR);
+ if (ret == OK)
+ {
+ /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+ priv->sector = (uint32_t)(read6->mslba & SCSICMD_READ6_MSLBAMASK) << 16 | (uint32_t)usbmsc_getbe16(read6->lslba);
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ6MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Verify that sector lies in the range supported by the block driver */
+
+ else if (priv->sector >= lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ6LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ ret = -EINVAL;
+ }
+
+ /* Looks like we are good to go */
+
+ else
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD6), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDREAD;
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdwrite6
+ *
+ * Description:
+ * Handle the SCSI_CMD_WRITE6 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdwrite6(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct scsicmd_write6_s *write6 = (FAR struct scsicmd_write6_s *)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.xfrlen = (uint16_t)write6->xfrlen;
+ if (priv->u.xfrlen == 0)
+ {
+ priv->u.xfrlen = 256;
+ }
+
+ ret = usbmsc_setupcmd(priv, SCSICMD_WRITE6_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR);
+ if (ret == OK)
+ {
+ /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+ priv->sector = (uint32_t)(write6->mslba & SCSICMD_WRITE6_MSLBAMASK) << 16 | (uint32_t)usbmsc_getbe16(write6->lslba);
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Check for attempts to write to a read-only device */
+
+ else if (lun->readonly)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6READONLY), 0);
+ lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED;
+ ret = -EINVAL;
+ }
+
+ /* Verify that sector lies in the range supported by the block driver */
+
+ else if (priv->sector >= lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ ret = -EINVAL;
+ }
+
+ /* Looks like we are good to go */
+
+ else
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE6), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDWRITE;
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdinquiry
+ *
+ * Description:
+ * Handle SCSI_CMD_INQUIRY command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdinquiry(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf)
+{
+ FAR struct scscicmd_inquiry_s *inquiry = (FAR struct scscicmd_inquiry_s *)priv->cdb;
+ FAR struct scsiresp_inquiry_s *response = (FAR struct scsiresp_inquiry_s *)buf;
+ int len;
+ int ret;
+
+ priv->u.alloclen = usbmsc_getbe16(inquiry->alloclen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_INQUIRY_SIZEOF,
+ USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_LUNNOTNEEDED|USBMSC_FLAGS_UACOKAY);
+ if (ret == OK)
+ {
+ if (!priv->lun)
+ {
+ response->qualtype = SCSIRESP_INQUIRYPQ_NOTCAPABLE|SCSIRESP_INQUIRYPD_UNKNOWN;
+ }
+ else if ((inquiry->flags != 0) || (inquiry->pagecode != 0))
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INQUIRYFLAGS), 0);
+ priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+ else
+ {
+ memset(response, 0, SCSIRESP_INQUIRY_SIZEOF);
+ priv->nreqbytes = SCSIRESP_INQUIRY_SIZEOF;
+
+#ifdef CONFIG_USBMSC_REMOVABLE
+ response->flags1 = SCSIRESP_INQUIRYFLAGS1_RMB;
+#endif
+ response->version = 2; /* SCSI-2 */
+ response->flags2 = 2; /* SCSI-2 INQUIRY response data format */
+ response->len = SCSIRESP_INQUIRY_SIZEOF - 5;
+
+ /* Strings */
+
+ memset(response->vendorid, ' ', 8+16+4);
+
+ len = strlen(g_mscvendorstr);
+ DEBUGASSERT(len <= 8);
+ memcpy(response->vendorid, g_mscvendorstr, len);
+
+ len = strlen(g_mscproductstr);
+ DEBUGASSERT(len <= 16);
+ memcpy(response->productid, g_mscproductstr, len);
+
+ len = strlen(g_mscserialstr);
+ DEBUGASSERT(len <= 4);
+ memcpy(response->productid, g_mscserialstr, len);
+ }
+ }
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdmodeselect6
+ *
+ * Description:
+ * Handle SCSI_CMD_MODESELECT6 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdmodeselect6(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct scsicmd_modeselect6_s *modeselect = (FAR struct scsicmd_modeselect6_s *)priv->cdb;
+
+ priv->u.alloclen = modeselect->plen;
+ (void)usbmsc_setupcmd(priv, SCSICMD_MODESELECT6_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE);
+
+ /* Not supported */
+
+ priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+ return -EINVAL;
+}
+
+/****************************************************************************
+ * Name: usbmsc_modepage
+ *
+ * Description:
+ * Common logic for usbmsc_cmdmodesense6() and usbmsc_cmdmodesense10()
+ *
+ ****************************************************************************/
+
+static int usbmsc_modepage(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf,
+ uint8_t pcpgcode, int *mdlen)
+{
+ FAR struct scsiresp_cachingmodepage_s *cmp = (FAR struct scsiresp_cachingmodepage_s *)buf;
+
+ /* Saving parms not supported */
+
+ if ((pcpgcode & SCSICMD_MODESENSE_PCMASK) == SCSICMD_MODESENSE_PCSAVED)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PCSAVED), 0);
+ priv->lun->sd = SCSI_KCQIR_SAVINGPARMSNOTSUPPORTED;
+ return -EINVAL;
+ }
+
+ /* Only the caching mode page is supported: */
+
+ if ((pcpgcode & SCSICMD_MODESENSE_PGCODEMASK) == SCSIRESP_MODESENSE_PGCCODE_CACHING ||
+ (pcpgcode & SCSICMD_MODESENSE_PGCODEMASK) == SCSIRESP_MODESENSE_PGCCODE_RETURNALL)
+ {
+ memset(cmp, 0, 12);
+ cmp->pgcode = SCSIRESP_MODESENSE_PGCCODE_CACHING;
+ cmp->len = 10; /* n-2 */
+
+ /* None of the fields are changeable */
+
+ if (((pcpgcode & SCSICMD_MODESENSE_PCMASK) != SCSICMD_MODESENSE_PCCHANGEABLE))
+ {
+ cmp->flags1 = SCSIRESP_CACHINGMODEPG_WCE; /* Write cache enable */
+ cmp->dpflen[0] = 0xff; /* Disable prefetch transfer length = 0xffffffff */
+ cmp->dpflen[1] = 0xff;
+ cmp->maxpf[0] = 0xff; /* Maximum pre-fetch = 0xffffffff */
+ cmp->maxpf[1] = 0xff;
+ cmp->maxpfc[0] = 0xff; /* Maximum pref-fetch ceiling = 0xffffffff */
+ cmp->maxpfc[1] = 0xff;
+ }
+
+ /* Return the mode data length */
+
+ *mdlen = 12; /* Only the first 12-bytes of caching mode page sent */
+ return OK;
+ }
+ else
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODEPAGEFLAGS), pcpgcode);
+ priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ return -EINVAL;
+ }
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdmodesense6
+ *
+ * Description:
+ * Handle SCSI_CMD_MODESENSE6 command
+ *
+ ****************************************************************************/
+
+static int inline usbmsc_cmdmodesense6(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf)
+{
+ FAR struct scsicmd_modesense6_s *modesense = (FAR struct scsicmd_modesense6_s *)priv->cdb;
+ FAR struct scsiresp_modeparameterhdr6_s *mph = (FAR struct scsiresp_modeparameterhdr6_s *)buf;
+ int mdlen;
+ int ret;
+
+ priv->u.alloclen = modesense->alloclen;
+ ret = usbmsc_setupcmd(priv, SCSICMD_MODESENSE6_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
+ if (ret == OK)
+ {
+ if ((modesense->flags & ~SCSICMD_MODESENSE6_DBD) != 0 || modesense->subpgcode != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODESENSE6FLAGS), 0);
+ priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+ else
+ {
+ /* The response consists of:
+ *
+ * (1) A MODESENSE6-specific mode parameter header,
+ * (2) A variable length list of block descriptors, and
+ * (3) A variable length list of mode page formats
+ */
+
+ mph->type = 0; /* Medium type */
+ mph->param = (priv->lun->readonly ? SCSIRESP_MODEPARMHDR_DAPARM_WP : 0x00);
+ mph->bdlen = 0; /* Block descriptor length */
+
+ /* There are no block descriptors, only the following mode page: */
+
+ ret = usbmsc_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR6_SIZEOF], modesense->pcpgcode, &mdlen);
+ if (ret == OK)
+ {
+ /* Store the mode data length and return the total message size */
+
+ mph->mdlen = mdlen - 1;
+ priv->nreqbytes = mdlen + SCSIRESP_MODEPARAMETERHDR6_SIZEOF;
+ }
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdstartstopunit
+ *
+ * Description:
+ * Handle SCSI_CMD_STARTSTOPUNIT command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdstartstopunit(FAR struct usbmsc_dev_s *priv)
+{
+ int ret;
+
+ priv->u.alloclen = 0;
+ ret = usbmsc_setupcmd(priv, SCSICMD_STARTSTOPUNIT_SIZEOF, USBMSC_FLAGS_DIRNONE);
+ if (ret == OK)
+ {
+#ifndef CONFIG_USBMSC_REMOVABLE
+ /* This command is not valid if the media is not removable */
+
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOTREMOVABLE), 0);
+ lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+ ret = -EINVAL;
+#endif
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdpreventmediumremoval
+ *
+ * Description:
+ * Handle SCSI_CMD_PREVENTMEDIAREMOVAL command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdpreventmediumremoval(FAR struct usbmsc_dev_s *priv)
+{
+#ifdef CONFIG_USBMSC_REMOVABLE
+ FAR struct scsicmd_preventmediumremoval_s *pmr = (FAR struct scsicmd_preventmediumremoval_s *)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+#endif
+ int ret;
+
+ priv->u.alloclen = 0;
+ ret = usbmsc_setupcmd(priv, SCSICMD_PREVENTMEDIUMREMOVAL_SIZEOF, USBMSC_FLAGS_DIRNONE);
+ if (ret == OK)
+ {
+#ifndef CONFIG_USBMSC_REMOVABLE
+ lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+ ret = -EINVAL;
+#else
+ if ((pmr->prevent & ~SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT) != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PREVENTMEDIUMREMOVALPREVENT), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+
+ lun->locked = pmr->prevent & SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT;
+#endif
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdreadformatcapacity
+ *
+ * Description:
+ * Handle SCSI_CMD_READFORMATCAPACITIES command (MMC)
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdreadformatcapacity(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf)
+{
+ FAR struct scsicmd_readformatcapcacities_s *rfc = (FAR struct scsicmd_readformatcapcacities_s *)priv->cdb;
+ FAR struct scsiresp_readformatcapacities_s *hdr;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.alloclen = usbmsc_getbe16(rfc->alloclen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_READFORMATCAPACITIES_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
+ if (ret == OK)
+ {
+ hdr = (FAR struct scsiresp_readformatcapacities_s *)buf;
+ memset(hdr, 0, SCSIRESP_READFORMATCAPACITIES_SIZEOF);
+ hdr->listlen = SCSIRESP_CURRCAPACITYDESC_SIZEOF;
+
+ /* Only the Current/Maximum Capacity Descriptor follows the header */
+
+ usbmsc_putbe32(hdr->nblocks, lun->nsectors);
+ hdr->type = SCIRESP_RDFMTCAPACITIES_FORMATED;
+ usbmsc_putbe24(hdr->blocklen, lun->sectorsize);
+ priv->nreqbytes = SCSIRESP_READFORMATCAPACITIES_SIZEOF;
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdreadcapacity10
+ *
+ * Description:
+ * Handle SCSI_CMD_READCAPACITY10 command
+ *
+ ****************************************************************************/
+
+static int inline usbmsc_cmdreadcapacity10(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf)
+{
+ FAR struct scsicmd_readcapacity10_s *rcc = (FAR struct scsicmd_readcapacity10_s *)priv->cdb;
+ FAR struct scsiresp_readcapacity10_s *rcr = (FAR struct scsiresp_readcapacity10_s *)buf;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ uint32_t lba;
+ int ret;
+
+ priv->u.alloclen = SCSIRESP_READCAPACITY10_SIZEOF; /* Fake the allocation length */
+ ret = usbmsc_setupcmd(priv, SCSICMD_READCAPACITY10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
+ if (ret == OK)
+ {
+ /* Check the PMI and LBA fields */
+
+ lba = usbmsc_getbe32(rcc->lba);
+
+ if (rcc->pmi > 1 || (rcc->pmi == 0 && lba != 0))
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READCAPACITYFLAGS), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+ else
+ {
+ usbmsc_putbe32(rcr->lba, lun->nsectors - 1);
+ usbmsc_putbe32(&buf[4], lun->sectorsize);
+ priv->nreqbytes = SCSIRESP_READCAPACITY10_SIZEOF;
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdread10
+ *
+ * Description:
+ * Handle SCSI_CMD_READ10 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdread10(FAR struct usbmsc_dev_s *priv)
+{
+ struct scsicmd_read10_s *read10 = (struct scsicmd_read10_s*)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.xfrlen = usbmsc_getbe16(read10->xfrlen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_READ10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR);
+ if (ret == OK)
+ {
+ /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+ priv->sector = usbmsc_getbe32(read10->lba);
+
+ /* Verify that we can support this read command */
+
+ if ((read10->flags & ~(SCSICMD_READ10FLAGS_DPO|SCSICMD_READ10FLAGS_FUA)) != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10FLAGS), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ else if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Verify that LBA lies in the range supported by the block driver */
+
+ else if (priv->sector >= lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ ret = -EINVAL;
+ }
+
+ /* Looks like we are good to go */
+
+ else
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD10), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDREAD;
+ }
+ }
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdwrite10
+ *
+ * Description:
+ * Handle SCSI_CMD_WRITE10 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdwrite10(FAR struct usbmsc_dev_s *priv)
+{
+ struct scsicmd_write10_s *write10 = (struct scsicmd_write10_s *)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.xfrlen = usbmsc_getbe16(write10->xfrlen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_WRITE10_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR);
+ if (ret == OK)
+ {
+ /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+ priv->sector = usbmsc_getbe32(write10->lba);
+
+ /* Verify that we can support this write command */
+
+ if ((write10->flags & ~(SCSICMD_WRITE10FLAGS_DPO|SCSICMD_WRITE10FLAGS_FUA)) != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10FLAGS), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ else if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Check for attempts to write to a read-only device */
+
+ else if (lun->readonly)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10READONLY), 0);
+ lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED;
+ ret = -EINVAL;
+ }
+
+ /* Verify that LBA lies in the range supported by the block driver */
+
+ else if (priv->sector >= lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ ret = -EINVAL;
+ }
+
+ /* Looks like we are good to go */
+
+ else
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE10), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDWRITE;
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdverify10
+ *
+ * Description:
+ * Handle SCSI_CMD_VERIFY10 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdverify10(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct scsicmd_verify10_s *verf = (FAR struct scsicmd_verify10_s *)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ uint32_t lba;
+ uint16_t blocks;
+ size_t sector;
+ ssize_t nread;
+ int ret;
+ int i;
+
+ priv->u.alloclen = 0;
+ ret = usbmsc_setupcmd(priv, SCSICMD_VERIFY10_SIZEOF, USBMSC_FLAGS_DIRNONE);
+ if (ret == OK)
+ {
+ /* Verify the starting and ending LBA */
+
+ lba = usbmsc_getbe32(verf->lba);
+ blocks = usbmsc_getbe16(verf->len);
+
+ if ((verf->flags & ~SCSICMD_VERIFY10_DPO) != 0 || verf->groupno != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10FLAGS), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+ else if (blocks == 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10NOBLOCKS), 0);
+ ret = -EIO; /* No reply */
+ }
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ else if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Verify that LBA lies in the range supported by the block driver */
+
+ else if (lba >= lun->nsectors || lba + blocks > lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ ret = -EINVAL;
+ }
+ else
+ {
+ /* Try to read the requested blocks */
+
+ for (i = 0, sector = lba + lun->startsector; i < blocks; i++, sector++)
+ {
+ nread = USBMSC_DRVR_READ(lun, priv->iobuffer, sector, 1);
+ if (nread < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10READFAIL), i);
+ lun->sd = SCSI_KCQME_UNRRE1;
+ lun->sdinfo = sector;
+ ret = -EIO;
+ break;
+ }
+ }
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdsynchronizecache10
+ *
+ * Description:
+ * Handle SCSI_CMD_SYNCHCACHE10 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdsynchronizecache10(FAR struct usbmsc_dev_s *priv)
+{
+ int ret;
+
+ priv->u.alloclen = 0;
+
+ /* Verify that we have the LUN structure and the block driver has been bound */
+
+ if (!priv->lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SYNCCACHEMEDIANOTPRESENT), 0);
+ priv->lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+ else
+ {
+ ret = usbmsc_setupcmd(priv, SCSICMD_SYNCHRONIZECACHE10_SIZEOF, USBMSC_FLAGS_DIRNONE);
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdmodeselect10
+ *
+ * Description:
+ * Handle SCSI_CMD_MODESELECT10 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdmodeselect10(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct scsicmd_modeselect10_s *modeselect = (FAR struct scsicmd_modeselect10_s *)priv->cdb;
+
+ priv->u.alloclen = usbmsc_getbe16(modeselect->parmlen);
+ (void)usbmsc_setupcmd(priv, SCSICMD_MODESELECT10_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE);
+
+ /* Not supported */
+
+ priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+ return -EINVAL;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdmodesense10
+ *
+ * Description:
+ * Handle SCSI_CMD_MODESENSE10 command
+ *
+ ****************************************************************************/
+
+static int inline usbmsc_cmdmodesense10(FAR struct usbmsc_dev_s *priv,
+ FAR uint8_t *buf)
+{
+ FAR struct scsicmd_modesense10_s *modesense = (FAR struct scsicmd_modesense10_s *)priv->cdb;
+ FAR struct scsiresp_modeparameterhdr10_s *mph = (FAR struct scsiresp_modeparameterhdr10_s *)buf;
+ int mdlen;
+ int ret;
+
+ priv->u.alloclen = usbmsc_getbe16(modesense->alloclen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_MODESENSE10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST);
+ if (ret == OK)
+ {
+ if ((modesense->flags & ~SCSICMD_MODESENSE10_DBD) != 0 || modesense->subpgcode != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODESENSE10FLAGS), 0);
+ priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+ else
+ {
+ /* The response consists of:
+ *
+ * (1) A MODESENSE6-specific mode parameter header,
+ * (2) A variable length list of block descriptors, and
+ * (3) A variable lengtth list of mode page formats
+ */
+
+ memset(mph, 0, SCSIRESP_MODEPARAMETERHDR10_SIZEOF);
+ mph->param = (priv->lun->readonly ? SCSIRESP_MODEPARMHDR_DAPARM_WP : 0x00);
+
+ /* There are no block descriptors, only the following mode page: */
+
+ ret = usbmsc_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR10_SIZEOF], modesense->pcpgcode, &mdlen);
+ if (ret == OK)
+ {
+ /* Store the mode data length and return the total message size */
+
+ usbmsc_putbe16(mph->mdlen, mdlen - 2);
+ priv->nreqbytes = mdlen + SCSIRESP_MODEPARAMETERHDR10_SIZEOF;
+ }
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdread12
+ *
+ * Description:
+ * Handle SCSI_CMD_READ12 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdread12(FAR struct usbmsc_dev_s *priv)
+{
+ struct scsicmd_read12_s *read12 = (struct scsicmd_read12_s*)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.xfrlen = usbmsc_getbe32(read12->xfrlen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_READ12_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR);
+ if (ret == OK)
+ {
+ /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+ priv->sector = usbmsc_getbe32(read12->lba);
+
+ /* Verify that we can support this read command */
+
+ if ((read12->flags & ~(SCSICMD_READ12FLAGS_DPO|SCSICMD_READ12FLAGS_FUA)) != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12FLAGS), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ ret = -EINVAL;
+ }
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ else if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Verify that LBA lies in the range supported by the block driver */
+
+ else if (priv->sector >= lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ ret = -EINVAL;
+ }
+
+ /* Looks like we are good to go */
+
+ else
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD12), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDREAD;
+ }
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdwrite12
+ *
+ * Description:
+ * Handle SCSI_CMD_WRITE12 command
+ *
+ ****************************************************************************/
+
+static inline int usbmsc_cmdwrite12(FAR struct usbmsc_dev_s *priv)
+{
+ struct scsicmd_write12_s *write12 = (struct scsicmd_write12_s *)priv->cdb;
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ int ret;
+
+ priv->u.xfrlen = usbmsc_getbe32(write12->xfrlen);
+ ret = usbmsc_setupcmd(priv, SCSICMD_WRITE12_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR);
+ if (ret == OK)
+ {
+ /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+ priv->sector = usbmsc_getbe32(write12->lba);
+
+ /* Verify that we can support this write command */
+
+ if ((write12->flags & ~(SCSICMD_WRITE12FLAGS_DPO|SCSICMD_WRITE12FLAGS_FUA)) != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12FLAGS), 0);
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ }
+
+ /* Verify that a block driver has been bound to the LUN */
+
+ else if (!lun->inode)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12MEDIANOTPRESENT), 0);
+ lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+ ret = -EINVAL;
+ }
+
+ /* Check for attempts to write to a read-only device */
+
+ else if (lun->readonly)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12READONLY), 0);
+ lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED;
+ }
+
+ /* Verify that LBA lies in the range supported by the block driver */
+
+ else if (priv->sector >= lun->nsectors)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12LBARANGE), 0);
+ lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+ }
+
+ /* Looks like we are good to go */
+
+ else
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE12), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDWRITE;
+ return OK;
+ }
+ }
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_setupcmd
+ *
+ * Description:
+ * Called after each SCSI command is identified in order to perform setup
+ * and verification operations that are common to all SCSI commands. This
+ * function performs the following common setup operations:
+ *
+ * 1. Determine the direction of the response
+ * 2. Verify lengths
+ * 3. Setup and verify the LUN
+ *
+ * Includes special logic for INQUIRY and REQUESTSENSE commands
+ *
+ ****************************************************************************/
+
+static int inline usbmsc_setupcmd(FAR struct usbmsc_dev_s *priv, uint8_t cdblen, uint8_t flags)
+{
+ FAR struct usbmsc_lun_s *lun = NULL;
+ uint32_t datlen;
+ uint8_t dir = flags & USBMSC_FLAGS_DIRMASK;
+ int ret = OK;
+
+ /* Verify the LUN and set up the current LUN reference in the
+ * device structure
+ */
+
+ if (priv->cbwlun < priv->nluns)
+ {
+ /* LUN number is valid in a valid range, but the LUN is not necessarily
+ * bound to a block driver. That will be checked as necessary in each
+ * individual command.
+ */
+
+ lun = &priv->luntab[priv->cbwlun];
+ priv->lun = lun;
+ }
+
+ /* Only a few commands may specify unsupported LUNs */
+
+ else if ((flags & USBMSC_FLAGS_LUNNOTNEEDED) == 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDBADLUN), priv->cbwlun);
+ ret = -EINVAL;
+ }
+
+ /* Extract the direction and data transfer length */
+
+ dir = flags & USBMSC_FLAGS_DIRMASK; /* Expected data direction */
+ datlen = 0;
+ if ((flags & USBMSC_FLAGS_BLOCKXFR) == 0)
+ {
+ /* Non-block transfer. Data length: Host allocation to receive data
+ * (only for device-to-host transfers. At present, alloclen is set
+ * to zero for all host-to-device, non-block transfers.
+ */
+
+ datlen = priv->u.alloclen;
+ }
+ else if (lun)
+ {
+ /* Block transfer: Calculate the total size of all sectors to be transferred */
+
+ datlen = priv->u.alloclen * lun->sectorsize;
+ }
+
+ /* Check the data direction. This was set up at the end of the
+ * IDLE state when the CBW was parsed, but if there is no data,
+ * then the direction is none.
+ */
+
+ if (datlen == 0)
+ {
+ /* No data.. then direction is none */
+
+ dir = USBMSC_FLAGS_DIRNONE;
+ }
+
+ /* Compare the expected data length in the command to the data length
+ * in the CBW.
+ */
+
+ else if (priv->cbwlen < datlen)
+ {
+ /* Clip to the length in the CBW and declare a phase error */
+
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR1), priv->cdb[0]);
+ if ((flags & USBMSC_FLAGS_BLOCKXFR) != 0)
+ {
+ priv->u.alloclen = priv->cbwlen;
+ }
+ else
+ {
+ priv->u.xfrlen = priv->cbwlen / lun->sectorsize;
+ }
+
+ priv->phaseerror = 1;
+ }
+
+ /* Initialize the residue */
+
+ priv->residue = priv->cbwlen;
+
+ /* Conflicting data directions is a phase error */
+
+ if (priv->cbwdir != dir && datlen > 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR2), priv->cdb[0]);
+ priv->phaseerror = 1;
+ ret = -EINVAL;
+ }
+
+ /* Compare the length of data in the cdb[] with the expected length
+ * of the command.
+ */
+
+ if (cdblen != priv->cdblen)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR3), priv->cdb[0]);
+ priv->phaseerror = 1;
+ ret = -EINVAL;
+ }
+
+ if (lun)
+ {
+ /* Retain the sense data for the REQUEST SENSE command */
+
+ if ((flags & USBMSC_FLAGS_RETAINSENSEDATA) == 0)
+ {
+ /* Discard the sense data */
+
+ lun->sd = SCSI_KCQ_NOSENSE;
+ lun->sdinfo = 0;
+ }
+
+ /* If a unit attention condition exists, then only a restricted set of
+ * commands is permitted.
+ */
+
+ if (lun->uad != SCSI_KCQ_NOSENSE && (flags & USBMSC_FLAGS_UACOKAY) != 0)
+ {
+ /* Command not permitted */
+
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDUNEVIOLATION), priv->cbwlun);
+ lun->sd = lun->uad;
+ lun->uad = SCSI_KCQ_NOSENSE;
+ ret = -EINVAL;
+ }
+ }
+
+ /* The final, 1-byte field of every SCSI command is the Control field which
+ * must be zero
+ */
+
+ if (priv->cdb[cdblen-1] != 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SCSICMDCONTROL), 0);
+ if (lun)
+ {
+ lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+ }
+ ret = -EINVAL;
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_idlestate
+ *
+ * Description:
+ * Called from the worker thread in the USBMSC_STATE_IDLE state. Checks
+ * for the receipt of a bulk CBW.
+ *
+ * Returned value:
+ * If no new, valid CBW is available, this function returns a negated errno.
+ * Otherwise, when a new CBW is successfully parsed, this function sets
+ * priv->thstate to USBMSC_STATE_CMDPARSE and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbmsc_idlestate(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct usbmsc_req_s *privreq;
+ FAR struct usbdev_req_s *req;
+ FAR struct usbmsc_cbw_s *cbw;
+ irqstate_t flags;
+ int ret = -EINVAL;
+
+ /* Take a request from the rdreqlist */
+
+ flags = irqsave();
+ privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->rdreqlist);
+ irqrestore(flags);
+
+ /* Has anything been received? If not, just return an error.
+ * This will cause us to remain in the IDLE state. When a USB request is
+ * received, the worker thread will be awakened in the USBMSC_STATE_IDLE
+ * and we will be called again.
+ */
+
+ if (!privreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_IDLERDREQLISTEMPTY), 0);
+ return -ENOMEM;
+ }
+
+ req = privreq->req;
+ cbw = (FAR struct usbmsc_cbw_s *)req->buf;
+
+ /* Handle the CBW */
+
+ usbmsc_dumpdata("SCSCI CBW", (uint8_t*)cbw, USBMSC_CBW_SIZEOF - USBMSC_MAXCDBLEN);
+ usbmsc_dumpdata(" CDB", cbw->cdb, MIN(cbw->cdblen, USBMSC_MAXCDBLEN));
+
+ /* Check for properly formatted CBW? */
+
+ if (req->xfrd != USBMSC_CBW_SIZEOF ||
+ cbw->signature[0] != 'U' ||
+ cbw->signature[1] != 'S' ||
+ cbw->signature[2] != 'B' ||
+ cbw->signature[3] != 'C')
+ {
+ /* CBS BAD: Stall the bulk endpoints. If the CBW is bad we must stall the
+ * bulk IN endpoint and either (1) stall the bulk OUT endpoint, or
+ * (2) discard data from the endpoint.
+ */
+
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDCBWSIGNATURE), 0);
+ EP_STALL(priv->epbulkout);
+ EP_STALL(priv->epbulkin);
+ }
+
+ /* Is the CBW meaningful? */
+
+ else if (cbw->lun >= priv->nluns || (cbw->flags & ~USBMSC_CBWFLAG_IN) != 0 ||
+ cbw->cdblen < 6 || cbw->cdblen > USBMSC_MAXCDBLEN)
+ {
+ /* CBS BAD: Stall the bulk endpoints. If the CBW is bad we must stall the
+ * bulk IN endpoint and either (1) stall the bulk OUT endpoint, or
+ * (2) discard data from the endpoint.
+ */
+
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDCBWCONTENT), 0);
+ EP_STALL(priv->epbulkout);
+ EP_STALL(priv->epbulkin);
+ }
+
+ /* Save the information from the CBW */
+
+ else
+ {
+ /* Extract the CDB and copy the whole CBD[] for later use */
+
+ priv->cdblen = cbw->cdblen;
+ memcpy(priv->cdb, cbw->cdb, priv->cdblen);
+
+ /* Extract the data direction */
+
+ if ((cbw->flags & USBMSC_CBWFLAG_IN) != 0)
+ {
+ /* IN: Device-to-host */
+
+ priv->cbwdir = USBMSC_FLAGS_DIRDEVICE2HOST;
+ }
+ else
+ {
+ /* OUT: Host-to-device */
+
+ priv->cbwdir = USBMSC_FLAGS_DIRHOST2DEVICE;
+ }
+
+ /* Get the max size of the data response */
+
+ priv->cbwlen = usbmsc_getle32(cbw->datlen);
+ if (priv->cbwlen == 0)
+ {
+ /* No length? Then no direction either */
+
+ priv->cbwdir = USBMSC_FLAGS_DIRNONE;
+ }
+
+ /* Extract and save the LUN index and TAG value */
+
+ priv->cbwlun = cbw->lun;
+ priv->cbwtag = usbmsc_getle32(cbw->tag);
+
+ /* Return the read request to the bulk out endpoint for re-filling */
+
+ req = privreq->req;
+ req->len = CONFIG_USBMSC_BULKOUTREQLEN;
+ req->priv = privreq;
+ req->callback = usbmsc_rdcomplete;
+
+ if (EP_SUBMIT(priv->epbulkout, req) != OK)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_IDLERDSUBMIT), (uint16_t)-ret);
+ }
+
+ /* Change to the CMDPARSE state and return success */
+
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_IDLECMDPARSE), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDPARSE;
+ ret = OK;
+ }
+
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdparsestate
+ *
+ * Description:
+ * Called from the worker thread in the USBMSC_STATE_CMDPARSE state.
+ * This state is entered when usbmsc_idlestate obtains a valid CBW
+ * containing SCSI commands. This function processes those SCSI commands.
+ *
+ * Returned value:
+ * If no write request is available or certain other errors occur, this
+ * function returns a negated errno and stays in the USBMSC_STATE_CMDPARSE
+ * state. Otherwise, when the new CBW is successfully process, this
+ * function sets priv->thstate to one of USBMSC_STATE_CMDREAD,
+ * USBMSC_STATE_CMDWRITE, or USBMSC_STATE_CMDFINISH and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbmsc_cmdparsestate(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct usbmsc_req_s *privreq;
+ FAR uint8_t *buf;
+ int ret = -EINVAL;
+
+ usbmsc_dumpdata("SCSCI CDB", priv->cdb, priv->cdblen);
+
+ /* Check if there is a request in the wrreqlist that we will be able to
+ * use for data or status.
+ */
+
+ privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist);
+
+ /* If there no request structures available, then just return an error.
+ * This will cause us to remain in the CMDPARSE state. When a request is
+ * returned, the worker thread will be awakened in the USBMSC_STATE_CMDPARSE
+ * and we will be called again.
+ */
+
+ if (!privreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDPARSEWRREQLISTEMPTY), 0);
+ return -ENOMEM;
+ }
+ DEBUGASSERT(privreq->req && privreq->req->buf);
+ buf = privreq->req->buf;
+
+ /* Assume that no errors will be encountered */
+
+ priv->phaseerror = 0;
+ priv->shortpacket = 0;
+
+ /* No data is buffered */
+
+ priv->nsectbytes = 0;
+ priv->nreqbytes = 0;
+
+ /* Get exclusive access to the block driver */
+
+ pthread_mutex_lock(&priv->mutex);
+ switch (priv->cdb[0])
+ {
+ case SCSI_CMD_TESTUNITREADY: /* 0x00 Mandatory */
+ ret = usbmsc_cmdtestunitready(priv);
+ break;
+
+ /* case SCSI_CMD_REZEROUNIT: * 0x01 Obsolete
+ * * 0x02 Vendor-specific */
+
+ case SCSI_CMD_REQUESTSENSE: /* 0x03 Mandatory */
+ ret = usbmsc_cmdrequestsense(priv, buf);
+ break;
+
+ /* case SCSI_CMD_FORMAT_UNIT: * 0x04 Mandatory, but not implemented
+ * * 0x05 Vendor specific
+ * * 0x06 Vendor specific
+ * case SCSI_CMD_REASSIGNBLOCKS: * 0x07 Optional */
+
+ case SCSI_CMD_READ6: /* 0x08 Mandatory */
+ ret = usbmsc_cmdread6(priv);
+ break;
+
+ /* * 0x09 Vendor specific */
+
+ case SCSI_CMD_WRITE6: /* 0x0a Optional */
+ ret = usbmsc_cmdwrite6(priv);
+ break;
+
+ /* case SCSI_CMD_SEEK6: * 0x0b Obsolete
+ * * 0x0c-0x10 Vendor specific
+ * case SCSI_CMD_SPACE6: * 0x11 Vendor specific */
+
+ case SCSI_CMD_INQUIRY: /* 0x12 Mandatory */
+ ret = usbmsc_cmdinquiry(priv, buf);
+ break;
+
+ /* * 0x13-0x14 Vendor specific */
+
+ case SCSI_CMD_MODESELECT6: /* 0x15 Optional */
+ ret = usbmsc_cmdmodeselect6(priv);
+ break;
+
+ /* case SCSI_CMD_RESERVE6: * 0x16 Obsolete
+ * case SCSI_CMD_RELEASE6: * 0x17 Obsolete
+ * case SCSI_CMD_COPY: * 0x18 Obsolete
+ * * 0x19 Vendor specific */
+
+ case SCSI_CMD_MODESENSE6: /* 0x1a Optional */
+ ret = usbmsc_cmdmodesense6(priv, buf);
+ break;
+
+ case SCSI_CMD_STARTSTOPUNIT: /* 0x1b Optional */
+ ret = usbmsc_cmdstartstopunit(priv);
+ break;
+
+ /* case SCSI_CMD_RECEIVEDIAGNOSTICRESULTS: * 0x1c Optional
+ * case SCSI_CMD_SENDDIAGNOSTIC: * 0x1d Mandatory, but not implemented */
+
+ case SCSI_CMD_PREVENTMEDIAREMOVAL: /* 0x1e Optional */
+ ret = usbmsc_cmdpreventmediumremoval(priv);
+ break;
+
+ /* * 0x20-22 Vendor specific */
+ case SCSI_CMD_READFORMATCAPACITIES: /* 0x23 Vendor-specific (defined in MMC spec) */
+ ret = usbmsc_cmdreadformatcapacity(priv, buf);
+ break;
+ /* * 0x24 Vendor specific */
+
+ case SCSI_CMD_READCAPACITY10: /* 0x25 Mandatory */
+ ret = usbmsc_cmdreadcapacity10(priv, buf);
+ break;
+
+ /* * 0x26-27 Vendor specific */
+ case SCSI_CMD_READ10: /* 0x28 Mandatory */
+ ret = usbmsc_cmdread10(priv);
+ break;
+
+ /* * 0x29 Vendor specific */
+
+ case SCSI_CMD_WRITE10: /* 0x2a Optional */
+ ret = usbmsc_cmdwrite10(priv);
+ break;
+
+ /* case SCSI_CMD_SEEK10: * 0x2b Obsolete
+ * * 0x2c-2d Vendor specific
+ * case SCSI_CMD_WRITEANDVERIFY: * 0x2e Optional */
+
+ case SCSI_CMD_VERIFY10: /* 0x2f Optional, but needed my MS Windows */
+ ret = usbmsc_cmdverify10(priv);
+ break;
+
+ /* case SCSI_CMD_SEARCHDATAHIGH: * 0x30 Obsolete
+ * case SCSI_CMD_SEARCHDATAEQUAL: * 0x31 Obsolete
+ * case SCSI_CMD_SEARCHDATALOW: * 0x32 Obsolete
+ * case SCSI_CMD_SETLIMITS10: * 0x33 Obsolete
+ * case SCSI_CMD_PREFETCH10: * 0x34 Optional */
+
+ case SCSI_CMD_SYNCHCACHE10: /* 0x35 Optional */
+ ret = usbmsc_cmdsynchronizecache10(priv);
+ break;
+
+ /* case SCSI_CMD_LOCKCACHE: * 0x36 Obsolete
+ * case SCSI_CMD_READDEFECTDATA10: * 0x37 Optional
+ * case SCSI_CMD_COMPARE: * 0x39 Obsolete
+ * case SCSI_CMD_COPYANDVERIFY: * 0x3a Obsolete
+ * case SCSI_CMD_WRITEBUFFER: * 0x3b Optional
+ * case SCSI_CMD_READBUFFER: * 0x3c Optional
+ * case SCSI_CMD_READLONG10: * 0x3e Optional
+ * case SCSI_CMD_WRITELONG10: * 0x3f Optional
+ * case SCSI_CMD_CHANGEDEFINITION: * 0x40 Obsolete
+ * case SCSI_CMD_WRITESAME10: * 0x41 Optional
+ * case SCSI_CMD_LOGSELECT: * 0x4c Optional
+ * case SCSI_CMD_LOGSENSE: * 0x4d Optional
+ * case SCSI_CMD_XDWRITE10: * 0x50 Optional
+ * case SCSI_CMD_XPWRITE10: * 0x51 Optional
+ * case SCSI_CMD_XDREAD10: * 0x52 Optional */
+
+ case SCSI_CMD_MODESELECT10: /* 0x55 Optional */
+ ret = usbmsc_cmdmodeselect10(priv);
+ break;
+
+ /* case SCSI_CMD_RESERVE10: * 0x56 Obsolete
+ * case SCSI_CMD_RELEASE10: * 0x57 Obsolete */
+
+ case SCSI_CMD_MODESENSE10: /* 0x5a Optional */
+ ret = usbmsc_cmdmodesense10(priv, buf);
+ break;
+
+ /* case SCSI_CMD_PERSISTENTRESERVEIN: * 0x5e Optional
+ * case SCSI_CMD_PERSISTENTRESERVEOUT: * 0x5f Optional
+ * case SCSI_CMD_32: * 0x7f Optional
+ * case SCSI_CMD_XDWRITEEXTENDED: * 0x80 Obsolete
+ * case SCSI_CMD_REBUILD: * 0x81 Obsolete
+ * case SCSI_CMD_REGENERATE: * 0x82 Obsolete
+ * case SCSI_CMD_EXTENDEDCOPY: * 0x83 Optional
+ * case SCSI_CMD_COPYRESULTS: * 0x84 Optional
+ * case SCSI_CMD_ACCESSCONTROLIN: * 0x86 Optional
+ * case SCSI_CMD_ACCESSCONTROLOUT: * 0x87 Optional
+ * case SCSI_CMD_READ16: * 0x88 Optional
+ * case SCSI_CMD_WRITE16: * 0x8a Optional
+ * case SCSI_CMD_READATTRIBUTE: * 0x8c Optional
+ * case SCSI_CMD_WRITEATTRIBUTE: * 0x8d Optional
+ * case SCSI_CMD_WRITEANDVERIFY16: * 0x8e Optional
+ * case SCSI_CMD_SYNCHCACHE16: * 0x91 Optional
+ * case SCSI_CMD_LOCKUNLOCKACACHE: * 0x92 Optional
+ * case SCSI_CMD_WRITESAME16: * 0x93 Optional
+ * case SCSI_CMD_READCAPACITY16: * 0x9e Optional
+ * case SCSI_CMD_READLONG16: * 0x9e Optional
+ * case SCSI_CMD_WRITELONG16 * 0x9f Optional
+ * case SCSI_CMD_REPORTLUNS: * 0xa0 Mandatory, but not implemented
+ * case SCSI_CMD_MAINTENANCEIN: * 0xa3 Optional (SCCS==0)
+ * case SCSI_CMD_MAINTENANCEOUT: * 0xa4 Optional (SCCS==0)
+ * case SCSI_CMD_MOVEMEDIUM: * 0xa5 ?
+ * case SCSI_CMD_MOVEMEDIUMATTACHED: * 0xa7 Optional (MCHNGR==0) */
+
+ case SCSI_CMD_READ12: /* 0xa8 Optional */
+ ret = usbmsc_cmdread12(priv);
+ break;
+
+ case SCSI_CMD_WRITE12: /* 0xaa Optional */
+ ret = usbmsc_cmdwrite12(priv);
+ break;
+
+ /* case SCSI_CMD_READMEDIASERIALNUMBER: * 0xab Optional
+ * case SCSI_CMD_WRITEANDVERIFY12: * 0xae Optional
+ * case SCSI_CMD_VERIFY12: * 0xaf Optional
+ * case SCSI_CMD_SETLIMITS12 * 0xb3 Obsolete
+ * case SCSI_CMD_READELEMENTSTATUS: * 0xb4 Optional (MCHNGR==0)
+ * case SCSI_CMD_READDEFECTDATA12: * 0xb7 Optional
+ * case SCSI_CMD_REDUNDANCYGROUPIN: * 0xba Optional
+ * case SCSI_CMD_REDUNDANCYGROUPOUT: * 0xbb Optional
+ * case SCSI_CMD_SPAREIN: * 0xbc Optional (SCCS==0)
+ * case SCSI_CMD_SPAREOUT: * 0xbd Optional (SCCS==0)
+ * case SCSI_CMD_VOLUMESETIN: * 0xbe Optional (SCCS==0)
+ * case SCSI_CMD_VOLUMESETOUT: * 0xbe Optional (SCCS==0)
+ * * 0xc0-0xff Vendor specific */
+
+ default:
+ priv->u.alloclen = 0;
+ if (ret == OK)
+ {
+ priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+ ret = -EINVAL;
+ }
+ break;
+ }
+ pthread_mutex_unlock(&priv->mutex);
+
+ /* Is a response required? (Not for read6/10/12 and write6/10/12). */
+
+ if (priv->thstate == USBMSC_STATE_CMDPARSE)
+ {
+ /* All commands come through this path (EXCEPT read6/10/12 and write6/10/12).
+ * For all other commands, the following setup is expected for the response
+ * based on data direction:
+ *
+ * For direction NONE:
+ * 1. priv->u.alloclen == 0
+ * 2. priv->nreqbytes == 0
+ *
+ * For direction = device-to-host:
+ * 1. priv->u.alloclen == allocation length; space set aside by the
+ * host to receive the device data. The size of the response
+ * cannot exceed this value.
+ * 2. response data is in the request currently at the head of
+ * the priv->wrreqlist queue. priv->nreqbytes is set to the length
+ * of data in the response.
+ *
+ * For direction host-to-device
+ * At present, there are no supported commands that should have host-to-device
+ * transfers (except write6/10/12 and that command logic does not take this
+ * path. The 'residue' is left at the full host-to-device data size.
+ *
+ * For all:
+ * ret set to <0 if an error occurred in parsing the commands.
+ */
+
+ /* For from device-to-hose operations, the residue is the expected size
+ * (the initial value of 'residue') minus the amount actually returned
+ * in the response:
+ */
+
+ if (priv->cbwdir == USBMSC_FLAGS_DIRDEVICE2HOST)
+ {
+ /* The number of bytes in the response cannot exceed the host
+ * 'allocation length' in the command.
+ */
+
+ if (priv->nreqbytes > priv->u.alloclen)
+ {
+ priv->nreqbytes = priv->u.alloclen;
+ }
+
+ /* The residue is then the number of bytes that were not sent */
+
+ priv->residue -= priv->nreqbytes;
+ }
+
+ /* On return, we need the following:
+ *
+ * 1. Setup for CMDFINISH state if appropriate
+ * 2. priv->thstate set to either CMDPARSE if no buffer was available or
+ * CMDFINISH to send the response
+ * 3. Return OK to continue; <0 to wait for the next event
+ */
+
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDFINISH), priv->cdb[0]);
+ priv->thstate = USBMSC_STATE_CMDFINISH;
+ ret = OK;
+ }
+ return ret;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdreadstate
+ *
+ * Description:
+ * Called from the worker thread in the USBMSC_STATE_CMDREAD state.
+ * The USBMSC_STATE_CMDREAD state is entered when usbmsc_cmdparsestate
+ * obtains a valid SCSI read command. This state is really a continuation
+ * of the USBMSC_STATE_CMDPARSE state that handles extended SCSI read
+ * command handling.
+ *
+ * Returned value:
+ * If no USBDEV write request is available or certain other errors occur, this
+ * function returns a negated errno and stays in the USBMSC_STATE_CMDREAD
+ * state. Otherwise, when the new SCSI read command is fully processed,
+ * this function sets priv->thstate to USBMSC_STATE_CMDFINISH and returns OK.
+ *
+ * State variables:
+ * xfrlen - holds the number of sectors read to be read.
+ * sector - holds the sector number of the next sector to be read
+ * nsectbytes - holds the number of bytes buffered for the current sector
+ * nreqbytes - holds the number of bytes currently buffered in the request
+ * at the head of the wrreqlist.
+ *
+ ****************************************************************************/
+
+static int usbmsc_cmdreadstate(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ FAR struct usbmsc_req_s *privreq;
+ FAR struct usbdev_req_s *req;
+ irqstate_t flags;
+ ssize_t nread;
+ uint8_t *src;
+ uint8_t *dest;
+ int nbytes;
+ int ret;
+
+ /* Loop transferring data until either (1) all of the data has been
+ * transferred, or (2) we have used up all of the write requests that we have
+ * available.
+ */
+
+ while (priv->u.xfrlen > 0 || priv->nsectbytes > 0)
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDREAD), priv->u.xfrlen);
+
+ /* Is the I/O buffer empty? */
+
+ if (priv->nsectbytes <= 0)
+ {
+ /* Yes.. read the next sector */
+
+ nread = USBMSC_DRVR_READ(lun, priv->iobuffer, priv->sector, 1);
+ if (nread < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADREADFAIL), -nread);
+ lun->sd = SCSI_KCQME_UNRRE1;
+ lun->sdinfo = priv->sector;
+ break;
+ }
+
+ priv->nsectbytes = lun->sectorsize;
+ priv->u.xfrlen--;
+ priv->sector++;
+ }
+
+ /* Check if there is a request in the wrreqlist that we will be able to
+ * use for data transfer.
+ */
+
+ privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist);
+
+ /* If there no request structures available, then just return an error.
+ * This will cause us to remain in the CMDREAD state. When a request is
+ * returned, the worker thread will be awakened in the USBMSC_STATE_CMDREAD
+ * and we will be called again.
+ */
+
+ if (!privreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADWRRQEMPTY), 0);
+ priv->nreqbytes = 0;
+ return -ENOMEM;
+ }
+ req = privreq->req;
+
+ /* Transfer all of the data that will (1) fit into the request buffer, OR (2)
+ * all of the data available in the sector buffer.
+ */
+
+ src = &priv->iobuffer[lun->sectorsize - priv->nsectbytes];
+ dest = &req->buf[priv->nreqbytes];
+
+ nbytes = MIN(CONFIG_USBMSC_BULKINREQLEN - priv->nreqbytes, priv->nsectbytes);
+
+ /* Copy the data from the sector buffer to the USB request and update counts */
+
+ memcpy(dest, src, nbytes);
+ priv->nreqbytes += nbytes;
+ priv->nsectbytes -= nbytes;
+
+ /* If (1) the request buffer is full OR (2) this is the final request full of data,
+ * then submit the request
+ */
+
+ if (priv->nreqbytes >= CONFIG_USBMSC_BULKINREQLEN ||
+ (priv->u.xfrlen <= 0 && priv->nsectbytes <= 0))
+ {
+ /* Remove the request that we just filled from wrreqlist (we've already checked
+ * that is it not NULL
+ */
+
+ flags = irqsave();
+ privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
+ irqrestore(flags);
+
+ /* And submit the request to the bulk IN endpoint */
+
+ req->len = priv->nreqbytes;
+ req->priv = privreq;
+ req->callback = usbmsc_wrcomplete;
+ req->flags = 0;
+
+ ret = EP_SUBMIT(priv->epbulkin, req);
+ if (ret != OK)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADSUBMIT), (uint16_t)-ret);
+ lun->sd = SCSI_KCQME_UNRRE1;
+ lun->sdinfo = priv->sector;
+ break;
+ }
+
+ /* Assume success... residue should probably really be decremented in
+ * wrcomplete when we know that the transfer completed successfully.
+ */
+
+ priv->residue -= priv->nreqbytes;
+ priv->nreqbytes = 0;
+ }
+ }
+
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDREADCMDFINISH), priv->u.xfrlen);
+ priv->thstate = USBMSC_STATE_CMDFINISH;
+ return OK;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdwritestate
+ *
+ * Description:
+ * Called from the worker thread in the USBMSC_STATE_CMDWRITE state.
+ * The USBMSC_STATE_CMDWRITE state is entered when usbmsc_cmdparsestate
+ * obtains a valid SCSI write command. This state is really a continuation
+ * of the USBMSC_STATE_CMDPARSE state that handles extended SCSI write
+ * command handling.
+ *
+ * Returned value:
+ * If no USBDEV write request is available or certain other errors occur, this
+ * function returns a negated errno and stays in the USBMSC_STATE_CMDWRITE
+ * state. Otherwise, when the new SCSI write command is fully processed,
+ * this function sets priv->thstate to USBMSC_STATE_CMDFINISH and returns OK.
+ *
+ * State variables:
+ * xfrlen - holds the number of sectors read to be written.
+ * sector - holds the sector number of the next sector to write
+ * nsectbytes - holds the number of bytes buffered for the current sector
+ * nreqbytes - holds the number of untransferred bytes currently in the
+ * request at the head of the rdreqlist.
+ *
+ ****************************************************************************/
+
+static int usbmsc_cmdwritestate(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ FAR struct usbmsc_req_s *privreq;
+ FAR struct usbdev_req_s *req;
+ ssize_t nwritten;
+ uint16_t xfrd;
+ uint8_t *src;
+ uint8_t *dest;
+ int nbytes;
+ int ret;
+
+ /* Loop transferring data until either (1) all of the data has been
+ * transferred, or (2) we have written all of the data in the available
+ * read requests.
+ */
+
+ while (priv->u.xfrlen > 0)
+ {
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDWRITE), priv->u.xfrlen);
+
+ /* Check if there is a request in the rdreqlist containing additional
+ * data to be written.
+ */
+
+ privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->rdreqlist);
+
+ /* If there no request data available, then just return an error.
+ * This will cause us to remain in the CMDWRITE state. When a filled request is
+ * received, the worker thread will be awakened in the USBMSC_STATE_CMDWRITE
+ * and we will be called again.
+ */
+
+ if (!privreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITERDRQEMPTY), 0);
+ priv->nreqbytes = 0;
+ return -ENOMEM;
+ }
+
+ req = privreq->req;
+ xfrd = req->xfrd;
+ priv->nreqbytes = xfrd;
+
+ /* Now loop until all of the data in the read request has been tranferred
+ * to the block driver OR all of the request data has been transferred.
+ */
+
+ while (priv->nreqbytes > 0 && priv->u.xfrlen > 0)
+ {
+ /* Copy the data received in the read request into the sector I/O buffer */
+
+ src = &req->buf[xfrd - priv->nreqbytes];
+ dest = &priv->iobuffer[priv->nsectbytes];
+
+ nbytes = MIN(lun->sectorsize - priv->nsectbytes, priv->nreqbytes);
+
+ /* Copy the data from the sector buffer to the USB request and update counts */
+
+ memcpy(dest, src, nbytes);
+ priv->nsectbytes += nbytes;
+ priv->nreqbytes -= nbytes;
+
+ /* Is the I/O buffer full? */
+
+ if (priv->nsectbytes >= lun->sectorsize)
+ {
+ /* Yes.. Write the next sector */
+
+ nwritten = USBMSC_DRVR_WRITE(lun, priv->iobuffer, priv->sector, 1);
+ if (nwritten < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITEWRITEFAIL), -nwritten);
+ lun->sd = SCSI_KCQME_WRITEFAULTAUTOREALLOCFAILED;
+ lun->sdinfo = priv->sector;
+ goto errout;
+ }
+
+ priv->nsectbytes = 0;
+ priv->residue -= lun->sectorsize;
+ priv->u.xfrlen--;
+ priv->sector++;
+ }
+ }
+
+ /* In either case, we are finished with this read request and can return it
+ * to the endpoint. Then we will go back to the top of the top and attempt
+ * to get the next read request.
+ */
+
+ req->len = CONFIG_USBMSC_BULKOUTREQLEN;
+ req->priv = privreq;
+ req->callback = usbmsc_rdcomplete;
+
+ ret = EP_SUBMIT(priv->epbulkout, req);
+ if (ret != OK)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITERDSUBMIT), (uint16_t)-ret);
+ }
+
+ /* Did the host decide to stop early? */
+
+ if (xfrd != CONFIG_USBMSC_BULKOUTREQLEN)
+ {
+ priv->shortpacket = 1;
+ goto errout;
+ }
+ }
+
+errout:
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDWRITECMDFINISH), priv->u.xfrlen);
+ priv->thstate = USBMSC_STATE_CMDFINISH;
+ return OK;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdfinishstate
+ *
+ * Description:
+ * Called from the worker thread in the USBMSC_STATE_CMDFINISH state.
+ * The USBMSC_STATE_CMDFINISH state is entered when processing of a
+ * command has finished but before status has been returned.
+ *
+ * Returned value:
+ * If no USBDEV write request is available or certain other errors occur, this
+ * function returns a negated errno and stays in the USBMSC_STATE_CMDFINISH
+ * state. Otherwise, when the command is fully processed, this function
+ * sets priv->thstate to USBMSC_STATE_CMDSTATUS and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbmsc_cmdfinishstate(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct usbmsc_req_s *privreq;
+ irqstate_t flags;
+ int ret = OK;
+
+ /* Check if there is a request in the wrreqlist that we will be able to
+ * use for data transfer.
+ */
+
+ privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist);
+
+ /* If there no request structures available, then just return an error.
+ * This will cause us to remain in the CMDREAD state. When a request is
+ * returned, the worker thread will be awakened in the USBMSC_STATE_CMDREAD
+ * and we will be called again.
+ */
+
+ if (!privreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHRQEMPTY), 0);
+ return -ENOMEM;
+ }
+
+ /* Finish the final stages of the reply */
+
+ switch (priv->cbwdir)
+ {
+ /* Device-to-host: All but the last data buffer has been sent */
+
+ case USBMSC_FLAGS_DIRDEVICE2HOST:
+ if (priv->cbwlen > 0)
+ {
+ /* On most commands (the exception is outgoing, write commands),
+ * the data has not not yet been sent.
+ */
+
+ if (priv->nreqbytes > 0)
+ {
+ struct usbdev_req_s *req;
+
+ /* Take a request from the wrreqlist (we've already checked
+ * that is it not NULL)
+ */
+
+ flags = irqsave();
+ privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
+ irqrestore(flags);
+
+ /* Send the write request */
+
+ req = privreq->req;
+ req->len = priv->nreqbytes;
+ req->callback = usbmsc_wrcomplete;
+ req->priv = privreq;
+ req->flags = USBDEV_REQFLAGS_NULLPKT;
+
+ ret = EP_SUBMIT(priv->epbulkin, privreq->req);
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHSUBMIT), (uint16_t)-ret);
+ }
+ }
+
+ /* Stall the BULK In endpoint if there is a residue */
+
+ if (priv->residue > 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHRESIDUE), (uint16_t)priv->residue);
+
+#ifdef CONFIG_USBMSC_RACEWAR
+ /* (See description of the workaround at the top of the file).
+ * First, wait for the transfer to complete, then stall the endpoint
+ */
+
+ usleep (100000);
+ (void)EP_STALL(priv->epbulkin);
+
+ /* now wait for stall to go away .... */
+
+ usleep (100000);
+#else
+ (void)EP_STALL(priv->epbulkin);
+#endif
+ }
+ }
+ break;
+
+ /* Host-to-device: We have processed all we want of the host data. */
+
+ case USBMSC_FLAGS_DIRHOST2DEVICE:
+ if (priv->residue > 0)
+ {
+ /* Did the host stop sending unexpectedly early? */
+
+ flags = irqsave();
+ if (priv->shortpacket)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHSHORTPKT), (uint16_t)priv->residue);
+ }
+
+ /* Unprocessed incoming data: STALL and cancel requests. */
+
+ else
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINSHSUBMIT), (uint16_t)priv->residue);
+ EP_STALL(priv->epbulkout);
+ }
+
+ priv->theventset |= USBMSC_EVENT_ABORTBULKOUT;
+ irqrestore(flags);
+ }
+ break;
+
+ default:
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINSHDIR), priv->cbwdir);
+ case USBMSC_FLAGS_DIRNONE: /* Nothing to send */
+ break;
+ }
+
+ /* Return to the IDLE state */
+
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDFINISHCMDSTATUS), 0);
+ priv->thstate = USBMSC_STATE_CMDSTATUS;
+ return OK;
+}
+
+/****************************************************************************
+ * Name: usbmsc_cmdstatusstate
+ *
+ * Description:
+ * Called from the worker thread in the USBMSC_STATE_CMDSTATUS state.
+ * That state is after a CBW has been fully processed. This function sends
+ * the concluding CSW.
+ *
+ * Returned value:
+ * If no write request is available or certain other errors occur, this
+ * function returns a negated errno and stays in the USBMSC_STATE_CMDSTATUS
+ * state. Otherwise, when the SCSI statis is successfully returned, this
+ * function sets priv->thstate to USBMSC_STATE_IDLE and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbmsc_cmdstatusstate(FAR struct usbmsc_dev_s *priv)
+{
+ FAR struct usbmsc_lun_s *lun = priv->lun;
+ FAR struct usbmsc_req_s *privreq;
+ FAR struct usbdev_req_s *req;
+ FAR struct usbmsc_csw_s *csw;
+ irqstate_t flags;
+ uint32_t sd;
+ uint8_t status = USBMSC_CSWSTATUS_PASS;
+ int ret;
+
+ /* Take a request from the wrreqlist */
+
+ flags = irqsave();
+ privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist);
+ irqrestore(flags);
+
+ /* If there no request structures available, then just return an error.
+ * This will cause us to remain in the CMDSTATUS status. When a request is
+ * returned, the worker thread will be awakened in the USBMSC_STATE_CMDSTATUS
+ * and we will be called again.
+ */
+
+ if (!privreq)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDSTATUSRDREQLISTEMPTY), 0);
+ return -ENOMEM;
+ }
+
+ req = privreq->req;
+ csw = (struct usbmsc_csw_s*)req->buf;
+
+ /* Extract the sense data from the LUN structure */
+
+ if (lun)
+ {
+ sd = lun->sd;
+ }
+ else
+ {
+ sd = SCSI_KCQIR_INVALIDLUN;
+ }
+
+ /* Determine the CSW status: PASS, PHASEERROR, or FAIL */
+
+ if (priv->phaseerror)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDPHERROR), 0);
+ status = USBMSC_CSWSTATUS_PHASEERROR;
+ sd = SCSI_KCQIR_INVALIDCOMMAND;
+ }
+ else if (sd != SCSI_KCQ_NOSENSE)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDCSWFAIL), 0);
+ status = USBMSC_CSWSTATUS_FAIL;
+ }
+
+ /* Format and submit the CSW */
+
+ csw->signature[0] = 'U';
+ csw->signature[1] = 'S';
+ csw->signature[2] = 'B';
+ csw->signature[3] = 'S';
+ usbmsc_putle32(csw->tag, priv->cbwtag);
+ usbmsc_putle32(csw->residue, priv->residue);
+ csw->status = status;
+
+ usbmsc_dumpdata("SCSCI CSW", (uint8_t*)csw, USBMSC_CSW_SIZEOF);
+
+ req->len = USBMSC_CSW_SIZEOF;
+ req->callback = usbmsc_wrcomplete;
+ req->priv = privreq;
+ req->flags = USBDEV_REQFLAGS_NULLPKT;
+
+ ret = EP_SUBMIT(priv->epbulkin, req);
+ if (ret < 0)
+ {
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDSTATUSSUBMIT), (uint16_t)-ret);
+ flags = irqsave();
+ (void)sq_addlast((sq_entry_t*)privreq, &priv->wrreqlist);
+ irqrestore(flags);
+ }
+
+ /* Return to the IDLE state */
+
+ usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDSTATUSIDLE), 0);
+ priv->thstate = USBMSC_STATE_IDLE;
+ return OK;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbmsc_workerthread
+ *
+ * Description:
+ * This is the main function of the USB storage worker thread. It loops
+ * until USB-related events occur, then processes those events accordingly
+ *
+ ****************************************************************************/
+
+void *usbmsc_workerthread(void *arg)
+{
+ struct usbmsc_dev_s *priv = (struct usbmsc_dev_s *)arg;
+ irqstate_t flags;
+ uint16_t eventset;
+ int ret;
+
+ /* This thread is started before the USB storage class is fully initialized.
+ * wait here until we are told to begin. Start in the NOTINITIALIZED state
+ */
+
+ pthread_mutex_lock(&priv->mutex);
+ priv->thstate = USBMSC_STATE_STARTED;
+ while ((priv->theventset & USBMSC_EVENT_READY) != 0 &&
+ (priv->theventset & USBMSC_EVENT_TERMINATEREQUEST) != 0)
+ {
+ pthread_cond_wait(&priv->cond, &priv->mutex);
+ }
+
+ /* Transition to the INITIALIZED/IDLE state */
+
+ priv->thstate = USBMSC_STATE_IDLE;
+ eventset = priv->theventset;
+ priv->theventset = USBMSC_EVENT_NOEVENTS;
+ pthread_mutex_unlock(&priv->mutex);
+
+ /* Then loop until we are asked to terminate */
+
+ while ((eventset & USBMSC_EVENT_TERMINATEREQUEST) == 0)
+ {
+ /* Wait for some interesting event. Note that we must both take the
+ * lock (to eliminate race conditions with other threads) and disable
+ * interrupts (to eliminate race conditions with USB interrupt handling.
+ */
+
+ pthread_mutex_lock(&priv->mutex);
+ flags = irqsave();
+ if (priv->theventset == USBMSC_EVENT_NOEVENTS)
+ {
+ pthread_cond_wait(&priv->cond, &priv->mutex);
+ }
+
+ /* Sample any events before re-enabling interrupts. Any events that
+ * occur after re-enabling interrupts will have to be handled in the
+ * next time through the loop.
+ */
+
+ eventset = priv->theventset;
+ priv->theventset = USBMSC_EVENT_NOEVENTS;
+ pthread_mutex_unlock(&priv->mutex);
+
+ /* Were we awakened by some event that requires immediate action?
+ *
+ * - The USBMSC_EVENT_DISCONNECT is signalled from the disconnect method
+ * after all transfers have been stopped, when the host is disconnected.
+ *
+ * - The CUSBMSC_EVENT_RESET is signalled when the bulk-storage-specific
+ * USBMSC_REQ_MSRESET EP0 setup received. We must stop the current
+ * operation and reinialize state.
+ *
+ * - The USBMSC_EVENT_CFGCHANGE is signaled when the EP0 setup logic
+ * receives a valid USB_REQ_SETCONFIGURATION request
+ *
+ * - The USBMSC_EVENT_IFCHANGE is signaled when the EP0 setup logic
+ * receives a valid USB_REQ_SETINTERFACE request
+ *
+ * - The USBMSC_EVENT_ABORTBULKOUT event is signalled by the CMDFINISH
+ * logic when there is a residue after processing a host-to-device
+ * transfer. We need to discard all incoming request.
+ *
+ * All other events are just wakeup calls and are intended only
+ * drive the state machine.
+ */
+
+ if ((eventset & (USBMSC_EVENT_DISCONNECT|USBMSC_EVENT_RESET|USBMSC_EVENT_CFGCHANGE|
+ USBMSC_EVENT_IFCHANGE|USBMSC_EVENT_ABORTBULKOUT)) != 0)
+ {
+ /* These events require that the current configuration be reset */
+
+ if ((eventset & USBMSC_EVENT_IFCHANGE) != 0)
+ {
+ usbmsc_resetconfig(priv);
+ }
+
+ /* These events require that a new configuration be established */
+
+ if ((eventset & (USBMSC_EVENT_CFGCHANGE|USBMSC_EVENT_IFCHANGE)) != 0)
+ {
+ usbmsc_setconfig(priv, priv->thvalue);
+ }
+
+ /* These events required that we send a deferred EP0 setup response */
+
+ if ((eventset & (USBMSC_EVENT_RESET|USBMSC_EVENT_CFGCHANGE|USBMSC_EVENT_IFCHANGE)) != 0)
+ {
+ usbmsc_deferredresponse(priv, false);
+ }
+
+ /* For all of these events... terminate any transactions in progress */
+
+ priv->thstate = USBMSC_STATE_IDLE;
+ }
+ irqrestore(flags);
+
+ /* Loop processing each SCSI command state. Each state handling
+ * function will do the following:
+ *
+ * - If it must block for an event, it will return a negated errno value
+ * - If it completes the processing for that state, it will (1) set
+ * the next appropriate state value and (2) return OK.
+ *
+ * So the following will loop until we must block for an event in
+ * a particular state. When we are awakened by an event (above) we
+ * will resume processing in the same state.
+ */
+
+ do
+ {
+ switch (priv->thstate)
+ {
+ case USBMSC_STATE_IDLE: /* Started and waiting for commands */
+ ret = usbmsc_idlestate(priv);
+ break;
+
+ case USBMSC_STATE_CMDPARSE: /* Parsing the received a command */
+ ret = usbmsc_cmdparsestate(priv);
+ break;
+
+ case USBMSC_STATE_CMDREAD: /* Continuing to process a SCSI read command */
+ ret = usbmsc_cmdreadstate(priv);
+ break;
+
+ case USBMSC_STATE_CMDWRITE: /* Continuing to process a SCSI write command */
+ ret = usbmsc_cmdwritestate(priv);
+ break;
+
+ case USBMSC_STATE_CMDFINISH: /* Finish command processing */
+ ret = usbmsc_cmdfinishstate(priv);
+ break;
+
+ case USBMSC_STATE_CMDSTATUS: /* Processing the status phase of a command */
+ ret = usbmsc_cmdstatusstate(priv);
+ break;
+
+ case USBMSC_STATE_NOTSTARTED: /* Thread has not yet been started */
+ case USBMSC_STATE_STARTED: /* Started, but is not yet initialized */
+ case USBMSC_STATE_TERMINATED: /* Thread has exitted */
+ default:
+ usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDSTATE), priv->thstate);
+ priv->thstate = USBMSC_STATE_IDLE;
+ ret = OK;
+ break;
+ }
+ }
+ while (ret == OK);
+ }
+
+ /* Transition to the TERMINATED state and exit */
+
+ priv->thstate = USBMSC_STATE_TERMINATED;
+ return NULL;
+}
--
cgit v1.2.3