Add USB storage class driver

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1075 42af7a65-404d-4744-a932-0658087f49c3

1 files changed, 2571 insertions, 0 deletions

diff --git a/nuttx/drivers/usbdev/usbdev_scsi.c b/nuttx/drivers/usbdev/usbdev_scsi.c
new file mode 100644
index 000000000..08e7cc1b4
--- /dev/null
+++ b/nuttx/drivers/usbdev/usbdev_scsi.c
@@ -0,0 +1,2571 @@
+/****************************************************************************
+ * drivers/usbdev/usbdev_storage.c
+ *
+ *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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 <nuttx/config.h>
+#include <sys/types.h>
+
+#include <pthread.h>
+#include <string.h>
+#include <errno.h>
+#include <queue.h>
+#include <debug.h>
+
+#include <nuttx/arch.h>
+#include <nuttx/scsi.h>
+#include <nuttx/usb_bulk.h>
+#include <nuttx/usbdev.h>
+#include <nuttx/usbdev_trace.h>
+
+#include "usbdev_storage.h"
+
+/****************************************************************************
+ * Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/* Debug ********************************************************************/
+
+#if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB)
+static void   usbstrg_dumpdata(const char *msg, const ubyte *buf, int buflen);
+#else
+#  define usbstrg_dumpdata(msg, buf, len)
+#endif
+
+/* Utility Support Functions ************************************************/
+
+static uint16 usbstrg_getbe16(ubyte *buf);
+static uint32 usbstrg_getbe32(ubyte *buf);
+static void   usbstrg_putbe16(ubyte * buf, uint16 val);
+static void   usbstrg_putbe32(ubyte *buf, uint32 val);
+#if 0 /* not used */
+static uint16 usbstrg_getle16(ubyte *buf);
+#endif
+static uint32 usbstrg_getle32(ubyte *buf);
+#if 0 /* not used */
+static void   usbstrg_putle16(ubyte * buf, uint16 val);
+#endif
+static void   usbstrg_putle32(ubyte *buf, uint32 val);
+
+/* SCSI Command Processing **************************************************/
+
+static inline int usbstrg_cmdtestunitready(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv,
+                FAR ubyte *buf);
+static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv,
+                FAR ubyte *buf);
+static inline int usbstrg_cmdmodeselect6(FAR struct usbstrg_dev_s *priv);
+static int    usbstrg_modepage(FAR struct usbstrg_dev_s *priv,
+                FAR ubyte *buf, ubyte pcpgcode, int *mdlen);
+static inline int usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv,
+                FAR ubyte *buf);
+static inline int usbstrg_cmdstartstopunit(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdpreventmediumremoval(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdreadcapacity10(FAR struct usbstrg_dev_s *priv,
+                FAR ubyte *buf);
+static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdsynchronizecache10(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdmodeselect10(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdmodesense10(FAR struct usbstrg_dev_s *priv,
+                FAR ubyte *buf);
+static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv);
+static inline int usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, ubyte cdblen,
+                ubyte flags);
+
+/* SCSI Worker Thread *******************************************************/
+
+static int    usbstrg_idlestate(FAR struct usbstrg_dev_s *priv);
+static int    usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv);
+static int    usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv);
+static int    usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv);
+static int    usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv);
+static int    usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv);
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Debug
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbstrg_dumpdata
+ ****************************************************************************/
+
+#if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB)
+static void usbstrg_dumpdata(const char *msg, const ubyte *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: usbstrg_getbe16
+ *
+ * Description:
+ *   Get a 16-bit big-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+static uint16 usbstrg_getbe16(ubyte *buf)
+{
+  return ((uint16)buf[0] << 8) | ((uint16)buf[1]);
+}
+
+/****************************************************************************
+ * Name: usbstrg_getbe32
+ *
+ * Description:
+ *   Get a 32-bit big-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+static uint32 usbstrg_getbe32(ubyte *buf)
+{
+  return ((uint32)buf[0] << 24) | ((uint32)buf[1] << 16) |
+         ((uint32)buf[2] << 8) | ((uint32)buf[3]);
+}
+
+/****************************************************************************
+ * Name: usbstrg_putbe16
+ *
+ * Description:
+ *   Store a 16-bit value in big-endian order to the location specified by
+ *   a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbstrg_putbe16(ubyte * buf, uint16 val)
+{
+  buf[0] = val >> 8;
+  buf[1] = val;
+}
+
+/****************************************************************************
+ * Name: usbstrg_putbe32
+ *
+ * Description:
+ *   Store a 32-bit value in big-endian order to the location specified by
+ *   a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbstrg_putbe32(ubyte *buf, uint32 val)
+{
+  buf[0] = val >> 24;
+  buf[1] = val >> 16;
+  buf[2] = val >> 8;
+  buf[3] = val;
+}
+
+/****************************************************************************
+ * Name: usbstrg_getle16
+ *
+ * Description:
+ *   Get a 16-bit little-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+#if 0 /* not used */
+static uint16 usbstrg_getle16(ubyte *buf)
+{
+  return ((uint16)buf[1] << 8) | ((uint16)buf[0]);
+}
+#endif
+
+/****************************************************************************
+ * Name: usbstrg_getle32
+ *
+ * Description:
+ *   Get a 32-bit little-endian value reference by the byte pointer
+ *
+ ****************************************************************************/
+
+static uint32 usbstrg_getle32(ubyte *buf)
+{
+  return ((uint32)buf[3] << 24) | ((uint32)buf[2] << 16) |
+         ((uint32)buf[1] << 8) | ((uint32)buf[0]);
+}
+
+/****************************************************************************
+ * Name: usbstrg_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 usbstrg_putle16(ubyte * buf, uint16 val)
+{
+  buf[0] = val;
+  buf[1] = val >> 8;
+}
+#endif
+
+/****************************************************************************
+ * Name: usbstrg_putle32
+ *
+ * Description:
+ *   Store a 32-bit value in little-endian order to the location specified by
+ *   a byte pointer
+ *
+ ****************************************************************************/
+
+static void usbstrg_putle32(ubyte *buf, uint32 val)
+{
+  buf[0] = val;
+  buf[1] = val >> 8;
+  buf[2] = val >> 16;
+  buf[3] = val >> 24;
+}
+
+/****************************************************************************
+ * SCSI Worker Thread
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbstrg_cmdtestunitready
+ *
+ * Description:
+ *  Handle the SCSI_CMD_TESTUNITREADY command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdtestunitready(FAR struct usbstrg_dev_s *priv)
+{
+  int ret;
+
+  priv->u.alloclen = 0;
+  ret = usbstrg_setupcmd(priv, 6, USBSTRG_FLAGS_DIRNONE);
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdrequestsense
+ *
+ * Description:
+ *  Handle the SCSI_CMD_REQUESTSENSE command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv,
+                                          FAR ubyte *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 usbstrg_lun_s *lun;
+  uint32 sd;
+  uint32 sdinfo;
+  ubyte  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 = usbstrg_setupcmd(priv, cdblen,
+                         USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_LUNNOTNEEDED|
+                         USBSTRG_FLAGS_UACOKAY|USBSTRG_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 = (ubyte)(sd >> 16);
+      usbstrg_putbe32(response->info, sdinfo);
+      response->len   = SCSIRESP_FIXEDSENSEDATA_SIZEOF - 7;
+      response->code2 = (ubyte)(sd >> 8);
+      response->qual2 = (ubyte)sd;
+
+      priv->nreqbytes = SCSIRESP_FIXEDSENSEDATA_SIZEOF;
+      ret             = OK;
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdread6
+ *
+ * Description:
+ *  Handle the SCSI_CMD_READ6 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct scsicmd_read6_s *read6 = (FAR struct scsicmd_read6_s*)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  int ret;
+
+  priv->u.xfrlen = (uint16)read6->xfrlen;
+  if (priv->u.xfrlen == 0)
+    {
+      priv->u.xfrlen = 256;
+    }
+
+  ret = usbstrg_setupcmd(priv, SCSICMD_READ6_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_BLOCKXFR);
+  if (ret == OK)
+    {
+      /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+      priv->sector = (read6->mslba & SCSICMD_READ6_MSLBAMASK) << 16 | usbstrg_getbe16(read6->lslba);
+
+      /* Verify that a block driver has been bound to the LUN */
+
+      if (!lun->inode)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_TRACEERR_READ6LBARANGE), 0);
+          lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+          ret     = -EINVAL;
+        }
+
+      /* Looks like we are good to go */
+
+      else
+        {
+          usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDREAD6), priv->cdb[0]);
+          priv->thstate = USBSTRG_STATE_CMDREAD;
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdwrite6
+ *
+ * Description:
+ *  Handle the SCSI_CMD_WRITE6 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct scsicmd_write6_s *write6 = (FAR struct scsicmd_write6_s *)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  int ret;
+
+  priv->u.xfrlen = (uint16)write6->xfrlen;
+  if (priv->u.xfrlen == 0)
+    {
+      priv->u.xfrlen = 256;
+    }
+
+  ret = usbstrg_setupcmd(priv, SCSICMD_WRITE6_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE|USBSTRG_FLAGS_BLOCKXFR);
+  if (ret == OK)
+    {
+      /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+      priv->sector = (write6->mslba & SCSICMD_WRITE6_MSLBAMASK) << 16 | usbstrg_getbe16(write6->lslba);
+
+      /* Verify that a block driver has been bound to the LUN */
+
+      if (!lun->inode)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_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(USBSTRG_TRACEERR_WRITE6LBARANGE), 0);
+          lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+          ret     = -EINVAL;
+        }
+
+      /* Looks like we are good to go */
+
+      else
+        {
+          usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDWRITE6), priv->cdb[0]);
+          priv->thstate = USBSTRG_STATE_CMDWRITE;
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdinquiry
+ *
+ * Description:
+ *   Handle SCSI_CMD_INQUIRY command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv,
+                                     FAR ubyte *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 = usbstrg_getbe16(inquiry->alloclen);
+  ret = usbstrg_setupcmd(priv, SCSICMD_INQUIRY_SIZEOF,
+                         USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_LUNNOTNEEDED|USBSTRG_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(USBSTRG_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_USBSTRG_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_vendorstr);
+          DEBUGASSERT(len <= 8);
+          memcpy(response->vendorid, g_vendorstr, len);
+
+          len = strlen(g_productstr);
+          DEBUGASSERT(len <= 16);
+          memcpy(response->productid, g_productstr, len);
+
+          len = strlen(g_serialstr);
+          DEBUGASSERT(len <= 4);
+          memcpy(response->productid, g_serialstr, len);
+        }
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdmodeselect6
+ *
+ * Description:
+ *   Handle SCSI_CMD_MODESELECT6 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdmodeselect6(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct scsicmd_modeselect6_s *modeselect = (FAR struct scsicmd_modeselect6_s *)priv->cdb;
+
+  priv->u.alloclen = modeselect->plen;
+  (void)usbstrg_setupcmd(priv, SCSICMD_MODESELECT6_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE);
+
+  /* Not supported */
+
+  priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+  return -EINVAL;
+}
+
+/****************************************************************************
+ * Name: usbstrg_modepage
+ *
+ * Description:
+ *   Common logic for usbstrg_cmdmodesense6() and usbstrg_cmdmodesense10()
+ *
+ ****************************************************************************/
+
+static int usbstrg_modepage(FAR struct usbstrg_dev_s *priv, FAR ubyte *buf,
+                            ubyte 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(USBSTRG_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(USBSTRG_TRACEERR_MODEPAGEFLAGS), pcpgcode);
+      priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+      return -EINVAL;
+    }
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdmodesense6
+ *
+ * Description:
+ *   Handle SCSI_CMD_MODESENSE6 command
+ *
+ ****************************************************************************/
+
+static int inline usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv,
+                                        FAR ubyte *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 = usbstrg_setupcmd(priv, SCSICMD_MODESENSE6_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST);
+  if (ret == OK)
+    {
+      if ((modesense->flags & ~SCSICMD_MODESENSE6_DBD) != 0 || modesense->subpgcode != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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 lengtth 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 = usbstrg_modepage(priv, &buf[SCSIREP_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 + SCSIREP_MODEPARAMETERHDR6_SIZEOF;
+            }
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdstartstopunit
+ *
+ * Description:
+ *   Handle SCSI_CMD_STARTSTOPUNIT command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdstartstopunit(FAR struct usbstrg_dev_s *priv)
+{
+  int ret;
+
+  priv->u.alloclen = 0;
+  ret = usbstrg_setupcmd(priv, SCSICMD_STARTSTOPUNIT_SIZEOF, USBSTRG_FLAGS_DIRNONE);
+  if (ret == OK)
+    {
+#ifndef CONFIG_USBSTRG_REMOVABLE
+      /* This command is not valid if the media is not removable */
+
+      usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_NOTREMOVABLE), 0);
+      lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+      ret = -EINVAL;
+#endif
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdpreventmediumremoval
+ *
+ * Description:
+ *   Handle SCSI_CMD_PREVENTMEDIAREMOVAL command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdpreventmediumremoval(FAR struct usbstrg_dev_s *priv)
+{
+#ifdef CONFIG_USBSTRG_REMOVABLE
+  FAR struct scsicmd_preventmediumremoval_s *pmr = (FAR struct scsicmd_preventmediumremoval_s *)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+#endif
+  int ret;
+
+  priv->u.alloclen = 0;
+  ret = usbstrg_setupcmd(priv, SCSICMD_PREVENTMEDIUMREMOVAL_SIZEOF, USBSTRG_FLAGS_DIRNONE);
+  if (ret == OK)
+    {
+#ifndef CONFIG_USBSTRG_REMOVABLE
+      lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+      ret = -EINVAL;
+#else
+      if ((pmr->prevent & ~SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT) != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_PREVENTMEDIUMREMOVALPREVENT), 0);
+          lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+          ret = -EINVAL;
+        }
+
+      lun->locked = pmr->prevent & SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT;
+#endif
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdreadcapacity10
+ *
+ * Description:
+ *   Handle SCSI_CMD_READCAPACITY10 command
+ *
+ ****************************************************************************/
+
+static int inline usbstrg_cmdreadcapacity10(FAR struct usbstrg_dev_s *priv,
+                                            FAR ubyte *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 usbstrg_lun_s *lun = priv->lun;
+  uint32 lba;
+  int ret;
+
+  priv->u.alloclen = SCSIRESP_READCAPACITY10_SIZEOF; /* Fake the allocation length */
+  ret = usbstrg_setupcmd(priv, SCSICMD_READCAPACITY10_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST);
+  if (ret == OK)
+    {
+      /* Check the PMI and LBA fields */
+
+      lba = usbstrg_getbe32(rcc->lba);
+
+      if (rcc->pmi > 1 || (rcc->pmi == 0 && lba != 0))
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READCAPACITYFLAGS), 0);
+          lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+          ret = -EINVAL;
+        }
+      else
+        {
+          usbstrg_putbe32(rcr->lba, lun->nsectors - 1);
+          usbstrg_putbe32(&buf[4], lun->sectorsize);
+          priv->nreqbytes = SCSIRESP_READCAPACITY10_SIZEOF;
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdread10
+ *
+ * Description:
+ *   Handle SCSI_CMD_READ10 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv)
+{
+  struct scsicmd_read10_s *read10 = (struct scsicmd_read10_s*)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  int ret;
+
+  priv->u.xfrlen = usbstrg_getbe16(read10->xfrlen);
+  ret = usbstrg_setupcmd(priv, SCSICMD_READ10_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_BLOCKXFR);
+  if (ret == OK)
+    {
+      /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+      priv->sector = usbstrg_getbe32(read10->lba);
+
+      /* Verify that we can support this read command */
+
+      if ((read10->flags & ~(SCSICMD_READ10FLAGS_DPO|SCSICMD_READ10FLAGS_FUA)) != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_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(USBSTRG_TRACEERR_READ10LBARANGE), 0);
+          lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+          ret     = -EINVAL;
+       }
+
+      /* Looks like we are good to go */
+
+      else
+        {
+          usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDREAD10), priv->cdb[0]);
+          priv->thstate = USBSTRG_STATE_CMDREAD;
+        }
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdwrite10
+ *
+ * Description:
+ *   Handle SCSI_CMD_WRITE10 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv)
+{
+  struct scsicmd_write10_s *write10 = (struct scsicmd_write10_s *)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  int ret;
+
+  priv->u.xfrlen = usbstrg_getbe16(write10->xfrlen);
+  ret = usbstrg_setupcmd(priv, SCSICMD_WRITE10_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE|USBSTRG_FLAGS_BLOCKXFR);
+  if (ret == OK)
+    {
+      /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+      priv->sector = usbstrg_getbe32(write10->lba);
+
+      /* Verify that we can support this write command */
+
+      if ((write10->flags & ~(SCSICMD_WRITE10FLAGS_DPO|SCSICMD_WRITE10FLAGS_FUA)) != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_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(USBSTRG_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(USBSTRG_TRACEERR_WRITE10LBARANGE), 0);
+          lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+          ret     = -EINVAL;
+       }
+
+      /* Looks like we are good to go */
+
+      else
+        {
+          usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDWRITE10), priv->cdb[0]);
+          priv->thstate = USBSTRG_STATE_CMDWRITE;
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdverify10
+ *
+ * Description:
+ *   Handle SCSI_CMD_VERIFY10 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct scsicmd_verify10_s *verf = (FAR struct scsicmd_verify10_s *)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  uint32  lba;
+  uint16  blocks;
+  size_t  sector;
+  ssize_t nread;
+  int     ret;
+  int     i;
+
+  priv->u.alloclen = 0;
+  ret = usbstrg_setupcmd(priv, SCSICMD_VERIFY10_SIZEOF, USBSTRG_FLAGS_DIRNONE);
+  if (ret == OK)
+    {
+      /* Verify the starting and ending LBA */
+
+      lba    = usbstrg_getbe32(verf->lba);
+      blocks = usbstrg_getbe16(verf->len);
+
+      if ((verf->flags & ~SCSICMD_VERIFY10_DPO) != 0 || verf->groupno != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10FLAGS), 0);
+          lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+          ret     = -EINVAL;
+        }
+      else if (blocks == 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_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(USBSTRG_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 = USBSTRG_DRVR_READ(lun, priv->iobuffer, sector, 1);
+              if (nread < 0)
+                {
+                  usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10READFAIL), i);
+                  lun->sd     = SCSI_KCQME_UNRRE1;
+                  lun->sdinfo = sector;
+                  ret         = -EIO;
+                  break;
+                }
+            }
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdsynchronizecache10
+ *
+ * Description:
+ *   Handle SCSI_CMD_SYNCHCACHE10 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdsynchronizecache10(FAR struct usbstrg_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(USBSTRG_TRACEERR_SYNCCACHEMEDIANOTPRESENT), 0);
+      priv->lun->sd = SCSI_KCQNR_MEDIANOTPRESENT;
+      ret = -EINVAL;
+    }
+  else
+    {
+      ret = usbstrg_setupcmd(priv, SCSICMD_SYNCHRONIZECACHE10_SIZEOF, USBSTRG_FLAGS_DIRNONE);
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdmodeselect10
+ *
+ * Description:
+ *   Handle SCSI_CMD_MODESELECT10 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdmodeselect10(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct scsicmd_modeselect10_s *modeselect = (FAR struct scsicmd_modeselect10_s *)priv->cdb;
+
+  priv->u.alloclen = usbstrg_getbe16(modeselect->parmlen);
+  (void)usbstrg_setupcmd(priv, SCSICMD_MODESELECT10_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE);
+
+  /* Not supported */
+
+  priv->lun->sd = SCSI_KCQIR_INVALIDCOMMAND;
+  return -EINVAL;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdmodesense10
+ *
+ * Description:
+ *   Handle SCSI_CMD_MODESENSE10 command
+ *
+ ****************************************************************************/
+
+static int inline usbstrg_cmdmodesense10(FAR struct usbstrg_dev_s *priv,
+                                         FAR ubyte *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 = usbstrg_getbe16(modesense->alloclen);
+  ret = usbstrg_setupcmd(priv, SCSICMD_MODESENSE10_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST);
+  if (ret == OK)
+    {
+      if ((modesense->flags & ~SCSICMD_MODESENSE10_DBD) != 0 || modesense->subpgcode != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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, SCSIREP_MODEPARAMETERHDR10_SIZEOF);
+          mph->param = (priv->lun->readonly ? SCSIRESP_MODEPARMHDR_DAPARM_WP : 0x00);
+
+          /* There are no block descriptors, only the following mode page: */
+
+          ret = usbstrg_modepage(priv, &buf[SCSIREP_MODEPARAMETERHDR10_SIZEOF], modesense->pcpgcode, &mdlen);
+          if (ret == OK)
+            {
+               /* Store the mode data length and return the total message size */
+
+              usbstrg_putbe16(mph->mdlen, mdlen - 2);
+              priv->nreqbytes = mdlen + SCSIREP_MODEPARAMETERHDR10_SIZEOF;
+            }
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdread12
+ *
+ * Description:
+ *   Handle SCSI_CMD_READ12 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv)
+{
+  struct scsicmd_read12_s *read12 = (struct scsicmd_read12_s*)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  int ret;
+
+  priv->u.xfrlen = usbstrg_getbe32(read12->xfrlen);
+  ret = usbstrg_setupcmd(priv, SCSICMD_READ12_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_BLOCKXFR);
+  if (ret == OK)
+    {
+      /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+      priv->sector = usbstrg_getbe32(read12->lba);
+
+      /* Verify that we can support this read command */
+
+      if ((read12->flags & ~(SCSICMD_READ12FLAGS_DPO|SCSICMD_READ12FLAGS_FUA)) != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_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(USBSTRG_TRACEERR_READ12LBARANGE), 0);
+          lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+          ret     = -EINVAL;
+        }
+
+      /* Looks like we are good to go */
+
+      else
+        {
+          usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDREAD12), priv->cdb[0]);
+          priv->thstate = USBSTRG_STATE_CMDREAD;
+        }
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdwrite12
+ *
+ * Description:
+ *   Handle SCSI_CMD_WRITE12 command
+ *
+ ****************************************************************************/
+
+static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv)
+{
+  struct scsicmd_write12_s *write12 = (struct scsicmd_write12_s *)priv->cdb;
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  int ret;
+
+  priv->u.xfrlen = usbstrg_getbe32(write12->xfrlen);
+  ret = usbstrg_setupcmd(priv, SCSICMD_WRITE12_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE|USBSTRG_FLAGS_BLOCKXFR);
+  if (ret == OK)
+    {
+      /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */
+
+      priv->sector = usbstrg_getbe32(write12->lba);
+
+      /* Verify that we can support this write command */
+
+      if ((write12->flags & ~(SCSICMD_WRITE12FLAGS_DPO|SCSICMD_WRITE12FLAGS_FUA)) != 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_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(USBSTRG_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(USBSTRG_TRACEERR_WRITE12LBARANGE), 0);
+          lun->sd = SCSI_KCQIR_LBAOUTOFRANGE;
+        }
+
+      /* Looks like we are good to go */
+
+      else
+        {
+          usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDWRITE12), priv->cdb[0]);
+          priv->thstate = USBSTRG_STATE_CMDWRITE;
+          return OK;
+        }
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_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 usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, ubyte cdblen, ubyte flags)
+{
+  FAR struct usbstrg_lun_s *lun;
+  uint32 datlen;
+  ubyte  dir = flags & USBSTRG_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;
+    }
+  else
+    {
+      priv->lun = NULL;
+
+      /* Only a few commands may specify unsupported LUNs */
+
+      if ((flags & USBSTRG_FLAGS_LUNNOTNEEDED) == 0)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDBADLUN), priv->cbwlun);
+          ret = -EINVAL;
+        }
+    }
+
+  /* Extract the direction and data transfer length */
+
+  dir    = flags & USBSTRG_FLAGS_DIRMASK;      /* Expected data direction */
+  datlen = 0;
+  if ((flags & USBSTRG_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 = USBSTRG_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(USBSTRG_TRACEERR_PHASEERROR1), priv->cdb[0]);
+      if ((flags & USBSTRG_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(USBSTRG_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(USBSTRG_TRACEERR_PHASEERROR3), priv->cdb[0]);
+      priv->phaseerror = 1;
+      ret              = -EINVAL;
+    }
+
+  if (lun)
+    {
+      /* Retain the sense data for the REQUEST SENSE command */
+
+      if ((flags & USBSTRG_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 & USBSTRG_FLAGS_UACOKAY) != 0)
+        {
+          /* Command not permitted */
+
+          usbtrace(TRACE_CLSERROR(USBSTRG_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(USBSTRG_TRACEERR_SCSICMDCONTROL), 0);
+      if (lun)
+        {
+          lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA;
+        }
+      ret     = -EINVAL;
+    }
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_idlestate
+ *
+ * Description:
+ *   Called from the worker thread in the USBSTRG_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 USBSTRG_STATE_CMDPARSE and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbstrg_idlestate(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct usbstrg_req_s *privreq;
+  FAR struct usbdev_req_s *req;
+  FAR struct usbstrg_cbw_s *cbw;
+  irqstate_t flags;
+  int ret = -EINVAL;
+
+  /* Take a request from the rdreqlist */
+
+  flags = irqsave();
+  privreq = (FAR struct usbstrg_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 USBSTRG_STATE_IDLE
+   * and we will be called again.
+   */
+
+  if (!privreq)
+    {
+      usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_IDLERDREQLISTEMPTY), 0);
+      return -ENOMEM;
+    }
+
+  req = privreq->req;
+  cbw = (FAR struct usbstrg_cbw_s *)req->buf;
+
+  /* Handle the CBW */
+
+  usbstrg_dumpdata("SCSCI CBW", (ubyte*)cbw, USBSTRG_CBW_SIZEOF - USBSTRG_MAXCDBLEN);
+  usbstrg_dumpdata("      CDB", cbw->cdb, min(cbw->cdblen, USBSTRG_MAXCDBLEN));
+
+  /* Check for properly formatted CBW? */
+
+  if (req->xfrd != USBSTRG_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(USBSTRG_TRACEERR_INVALIDCBWSIGNATURE), 0);
+      EP_STALL(priv->epbulkout);
+      EP_STALL(priv->epbulkin);
+    }
+
+  /* Is the CBW meaningful? */
+
+  else if (cbw->lun >= priv->nluns || (cbw->flags & ~USBSTRG_CBWFLAG_IN) != 0 ||
+           cbw->cdblen < 6 || cbw->cdblen > USBSTRG_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(USBSTRG_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 & USBSTRG_CBWFLAG_IN) != 0)
+        {
+          /* IN: Device-to-host */
+
+          priv->cbwdir = USBSTRG_FLAGS_DIRDEVICE2HOST;
+        }
+      else
+        {
+          /* OUT: Host-to-device */
+
+          priv->cbwdir = USBSTRG_FLAGS_DIRHOST2DEVICE;
+        }
+
+      /* Get the max size of the data response */
+
+      priv->cbwlen = usbstrg_getle32(cbw->datlen);
+      if (priv->cbwlen == 0)
+        {
+          /* No length?  Then no direction either */
+
+          priv->cbwdir = USBSTRG_FLAGS_DIRNONE;
+        }
+
+      /* Extract and save the LUN index and TAG value */
+
+      priv->cbwlun = cbw->lun;
+      priv->cbwtag = usbstrg_getle32(cbw->tag);
+
+      /* Return the read request to the bulk out endpoint for re-filling */
+
+      req           = privreq->req;
+      req->len      = CONFIG_USBSTRG_BULKOUTREQLEN;
+      req->private  = privreq;
+      req->callback = usbstrg_rdcomplete;
+
+      if (EP_SUBMIT(priv->epbulkout, req) != OK)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_IDLERDSUBMIT), (uint16)-ret);
+        }
+
+      /* Change to the CMDPARSE state and return success */
+
+      usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_IDLECMDPARSE), priv->cdb[0]);
+      priv->thstate = USBSTRG_STATE_CMDPARSE;
+      ret = OK;
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdparsestate
+ *
+ * Description:
+ *   Called from the worker thread in the USBSTRG_STATE_CMDPARSE state.
+ *   This state is entered when usbstrg_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 USBSTRG_STATE_CMDPARSE
+ *   state.  Otherwise, when the new CBW is successfully process, this
+ *   function sets priv->thstate to one of USBSTRG_STATE_CMDREAD,
+ *   USBSTRG_STATE_CMDWRITE, or USBSTRG_STATE_CMDFINISH and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct usbstrg_req_s *privreq;
+  FAR ubyte *buf;
+  int ret = -EINVAL;
+
+  usbstrg_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 usbstrg_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 USBSTRG_STATE_CMDPARSE
+   * and we will be called again.
+   */
+
+  if (!privreq)
+    {
+      usbtrace(TRACE_CLSERROR(USBSTRG_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 = usbstrg_cmdtestunitready(priv);
+      break;
+
+ /* case SCSI_CMD_REZEROUNIT:                      * 0x01 Obsolete
+  *                                                * 0x02 Vendor-specific */
+
+    case SCSI_CMD_REQUESTSENSE:                   /* 0x03 Mandatory */
+      ret = usbstrg_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 */
+      return usbstrg_cmdread6(priv);
+      break;
+
+ /*                                                * 0x09 Vendor specific */
+
+    case SCSI_CMD_WRITE6:                         /* 0x0a Optional */
+      return usbstrg_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 = usbstrg_cmdinquiry(priv, buf);
+      break;
+
+ /*                                                * 0x13-0x14 Vendor specific */
+
+    case SCSI_CMD_MODESELECT6:                    /* 0x15 Optional */
+      ret = usbstrg_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 = usbstrg_cmdmodesense6(priv, buf);
+      break;
+
+    case SCSI_CMD_STARTSTOPUNIT:                  /* 0x1b Optional */
+      ret = usbstrg_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 = usbstrg_cmdpreventmediumremoval(priv);
+      break;
+
+ /*                                                * 0x20-22 Vendor specific
+  * case SCSI_CMD_READFORMATCAPACITIES:            * 0x23 Vendor-specific
+  *                                                * 0x24 Vendor specific */
+
+    case SCSI_CMD_READCAPACITY10:                 /* 0x25 Mandatory */
+      ret = usbstrg_cmdreadcapacity10(priv, buf);
+      break;
+
+ /*                                                * 0x26-27 Vendor specific */
+
+    case SCSI_CMD_READ10:                         /* 0x28 Mandatory */
+      return usbstrg_cmdread10(priv);
+      break;
+
+ /*                                                * 0x29 Vendor specific */
+
+    case SCSI_CMD_WRITE10:                        /* 0x2a Optional */
+      return usbstrg_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 = usbstrg_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 = usbstrg_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 = usbstrg_cmdmodeselect10(priv);
+      break;
+
+ /* case SCSI_CMD_RESERVE10:                       * 0x56 Obsolete
+  * case SCSI_CMD_RELEASE10:                       * 0x57 Obsolete */
+
+    case SCSI_CMD_MODESENSE10:                    /* 0x5a Optional */
+      ret = usbstrg_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 */
+      return usbstrg_cmdread12(priv);
+      break;
+
+    case SCSI_CMD_WRITE12:                        /* 0xaa Optional */
+      return usbstrg_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);
+
+  /* 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 == USBSTRG_FLAGS_DIRDEVICE2HOST)
+    {
+      /* The number of bytes in the response cannot exceed the 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(USBSTRG_CLASSSTATE_CMDPARSECMDFINISH), priv->cdb[0]);
+  priv->thstate    = USBSTRG_STATE_CMDFINISH;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdreadstate
+ *
+ * Description:
+ *   Called from the worker thread in the USBSTRG_STATE_CMDREAD state.
+ *   The USBSTRG_STATE_CMDREAD state is entered when usbstrg_cmdparsestate
+ *   obtains a valid SCSI read command. This state is really a continuation
+ *   of the USBSTRG_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 USBSTRG_STATE_CMDREAD
+ *   state.  Otherwise, when the new SCSI read command is fully processed,
+ *   this function sets priv->thstate to USBSTRG_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 usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  FAR struct usbstrg_req_s *privreq;
+  FAR struct usbdev_req_s *req;
+  irqstate_t flags;
+  ssize_t nread;
+  ubyte *src;
+  ubyte *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(USBSTRG_CLASSSTATE_CMDREAD), priv->u.xfrlen);
+
+      /* Is the I/O buffer empty? */
+
+      if (priv->nsectbytes <= 0)
+        {
+          /* Yes.. read the next sector */
+
+          nread = USBSTRG_DRVR_READ(lun, priv->iobuffer, priv->sector, 1);
+          if (nread < 0)
+            {
+              usbtrace(TRACE_CLSERROR(USBSTRG_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 usbstrg_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 USBSTRG_STATE_CMDREAD
+       * and we will be called again.
+       */
+
+      if (!privreq)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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_USBSTRG_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_USBSTRG_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 usbstrg_req_s *)sq_remfirst(&priv->wrreqlist);
+          irqrestore(flags);
+
+          /* And submit the request to the bulk IN endpoint */
+
+          req->len      = priv->nreqbytes;
+          req->private  = privreq;
+          req->callback = usbstrg_wrcomplete;
+
+          ret          = EP_SUBMIT(priv->epbulkin, req);
+          if (ret != OK)
+            {
+              usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDREADSUBMIT), (uint16)-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(USBSTRG_CLASSSTATE_CMDREADCMDFINISH), priv->u.xfrlen);
+  priv->thstate  = USBSTRG_STATE_CMDFINISH;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdwritestate
+ *
+ * Description:
+ *   Called from the worker thread in the USBSTRG_STATE_CMDWRITE state.
+ *   The USBSTRG_STATE_CMDWRITE state is entered when usbstrg_cmdparsestate
+ *   obtains a valid SCSI write command. This state is really a continuation
+ *   of the USBSTRG_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 USBSTRG_STATE_CMDWRITE
+ *   state.  Otherwise, when the new SCSI write command is fully processed,
+ *   this function sets priv->thstate to USBSTRG_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 usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  FAR struct usbstrg_req_s *privreq;
+  FAR struct usbdev_req_s *req;
+  ssize_t nwritten;
+  uint16 xfrd;
+  ubyte *src;
+  ubyte *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(USBSTRG_CLASSSTATE_CMDWRITE), priv->u.xfrlen);
+
+      /* Check if there is a request in the rdreqlist containing additional
+       * data to be written.
+       */
+
+      privreq = (FAR struct usbstrg_req_s *)sq_peek(&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 USBSTRG_STATE_CMDWRITE
+       * and we will be called again.
+       */
+
+      if (!privreq)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_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 = USBSTRG_DRVR_WRITE(lun, priv->iobuffer, priv->sector, 1);
+              if (nwritten < 0)
+                {
+                  usbtrace(TRACE_CLSERROR(USBSTRG_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      = priv->epbulkout->maxpacket;
+      req->private  = privreq;
+      req->callback = usbstrg_rdcomplete;
+
+      ret = EP_SUBMIT(priv->epbulkout, req);
+      if (ret != OK)
+        {
+          usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDWRITERDSUBMIT), (uint16)-ret);
+        }
+
+      /* Did the host decide to stop early? */
+
+      if (xfrd != priv->epbulkout->maxpacket)
+        {
+          priv->shortpacket = 1;
+          goto errout;
+        }
+    }
+
+errout:
+  usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDWRITECMDFINISH), priv->u.xfrlen);
+  priv->thstate  = USBSTRG_STATE_CMDFINISH;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdfinishstate
+ *
+ * Description:
+ *   Called from the worker thread in the USBSTRG_STATE_CMDFINISH state.
+ *   The USBSTRG_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 USBSTRG_STATE_CMDFINISH
+ *   state.  Otherwise, when the command is fully processed, this function
+ *   sets priv->thstate to USBSTRG_STATE_CMDSTATUS and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct usbstrg_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 usbstrg_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 USBSTRG_STATE_CMDREAD
+   * and we will be called again.
+   */
+
+  if (!privreq)
+    {
+      usbtrace(TRACE_CLSERROR(USBSTRG_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 USBSTRG_FLAGS_DIRDEVICE2HOST:
+      if (priv->cbwlen > 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 usbstrg_req_s *)sq_remfirst(&priv->wrreqlist);
+          irqrestore(flags);
+
+          /* Send the write request */
+
+          req           = privreq->req;
+          req->len      = priv->nreqbytes;
+          req->callback = usbstrg_wrcomplete;
+          req->private  = privreq;
+          ret           = EP_SUBMIT(priv->epbulkin, privreq->req);
+          if (ret < 0)
+            {
+              usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHSUBMIT), (uint16)-ret);
+            }
+
+          /* Stall the BULK In endpoint if there is a residue */
+
+          if (priv->residue > 0)
+            {
+              usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHRESIDUE), (uint16)priv->residue);
+              (void)EP_STALL(priv->epbulkin);
+            }
+        }
+      break;
+
+      /* Host-to-device: We have processed all we want of the host data. */
+
+    case USBSTRG_FLAGS_DIRHOST2DEVICE:
+      if (priv->residue > 0)
+        {
+          /* Did the host stop sending unexpectedly early? */
+
+          flags = irqsave();
+          if (priv->shortpacket)
+            {
+              usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHSHORTPKT), (uint16)priv->residue);
+            }
+
+          /* Unprocessed incoming data: STALL and cancel requests. */
+
+          else 
+            {
+              usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINSHSUBMIT), (uint16)priv->residue);
+              EP_STALL(priv->epbulkout);
+           }
+
+           priv->theventset |= USBSTRG_EVENT_ABORTBULKOUT;
+           irqrestore(flags);
+        }
+      break;
+
+    default:
+      usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINSHDIR), priv->cbwdir);
+    case USBSTRG_FLAGS_DIRNONE: /* Nothing to send */
+      break;
+    }
+
+  /* Return to the IDLE state */
+
+  usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDFINISHCMDSTATUS), 0);
+  priv->thstate = USBSTRG_STATE_CMDSTATUS;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: usbstrg_cmdstatusstate
+ *
+ * Description:
+ *   Called from the worker thread in the USBSTRG_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 USBSTRG_STATE_CMDSTATUS
+ *   state.  Otherwise, when the SCSI statis is successfully returned, this
+ *   function sets priv->thstate to USBSTRG_STATE_IDLE and returns OK.
+ *
+ ****************************************************************************/
+
+static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv)
+{
+  FAR struct usbstrg_lun_s *lun = priv->lun;
+  FAR struct usbstrg_req_s *privreq;
+  FAR struct usbdev_req_s *req;
+  FAR struct usbstrg_csw_s *csw;
+  irqstate_t flags;
+  uint32 sd;
+  ubyte status = USBSTRG_CSWSTATUS_PASS;
+  int ret;
+
+  /* Take a request from the wrreqlist */
+
+  flags = irqsave();
+  privreq = (FAR struct usbstrg_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 USBSTRG_STATE_CMDSTATUS
+   * and we will be called again.
+   */
+
+  if (!privreq)
+    {
+      usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDSTATUSRDREQLISTEMPTY), 0);
+      return -ENOMEM;
+    }
+
+  req = privreq->req;
+  csw = (struct usbstrg_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(USBSTRG_TRACEERR_SNDPHERROR), 0);
+      status = USBSTRG_CSWSTATUS_PHASEERROR;
+      sd     = SCSI_KCQIR_INVALIDCOMMAND;
+    }
+  else if (sd != SCSI_KCQ_NOSENSE)
+    {
+      usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SNDCSWFAIL), 0);
+      status = USBSTRG_CSWSTATUS_FAIL;
+    }
+
+  /* Format and submit the CSW */
+
+  csw->signature[0] = 'U';
+  csw->signature[1] = 'S';
+  csw->signature[2] = 'B';
+  csw->signature[3] = 'S';
+  usbstrg_putle32(csw->tag, priv->cbwtag);
+  usbstrg_putle32(csw->residue, priv->residue);
+  csw->status       = status;
+
+  usbstrg_dumpdata("SCSCI CSW", (ubyte*)csw, USBSTRG_CSW_SIZEOF);
+
+  req->len          = USBSTRG_CSW_SIZEOF;
+  req->callback     = usbstrg_wrcomplete;
+  req->private      = privreq;
+  ret               = EP_SUBMIT(priv->epbulkin, req);
+  if (ret < 0)
+    {
+      usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SNDSTATUSSUBMIT), (uint16)-ret);
+      flags = irqsave();
+      (void)sq_addlast((sq_entry_t*)privreq, &priv->wrreqlist);
+      irqrestore(flags);
+    }
+
+  /* Return to the IDLE state */
+
+  usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDSTATUSIDLE), 0);
+  priv->thstate = USBSTRG_STATE_IDLE;
+  return OK;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: usbstrg_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 *usbstrg_workerthread(void *arg)
+{
+  struct usbstrg_dev_s *priv = (struct usbstrg_dev_s *)arg;
+  irqstate_t flags;
+  uint16 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 = USBSTRG_STATE_STARTED;
+  while ((priv->theventset & USBSTRG_EVENT_READY) != 0 &&
+         (priv->theventset & USBSTRG_EVENT_TERMINATEREQUEST) != 0)
+    {
+      pthread_cond_wait(&priv->cond, &priv->mutex);
+    }
+
+  /* Transition to the INITIALIZED/IDLE state */
+
+  priv->thstate    = USBSTRG_STATE_IDLE;
+  eventset         = priv->theventset;
+  priv->theventset = USBSTRG_EVENT_NOEVENTS;
+  pthread_mutex_unlock(&priv->mutex);
+
+  /* Then loop until we are asked to terminate */
+
+  while (eventset != USBSTRG_EVENT_TERMINATEREQUEST)
+    {
+      /* 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 == USBSTRG_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 = USBSTRG_EVENT_NOEVENTS;
+      irqrestore(flags);
+
+      /* Were we awakened by some event that requires immediate action? */
+
+      /* The USBSTRG_EVENT_DISCONNECT is signalled from the disconnect method
+       * after all transfers have been stopped, when the host is disconnected.
+       */
+
+      if ((eventset & USBSTRG_EVENT_DISCONNECT) != 0)
+        {
+#warning LOGIC needed
+        }
+
+      /* Called with the bulk-storage-specific USBSTRG_REQ_MSRESET EP0 setup
+       * received.  We must stop the current operation and reinialize state.
+       */
+
+      if ((eventset & USBSTRG_EVENT_RESET) != 0)
+        {
+#warning LOGIC needed
+          priv->thstate = USBSTRG_STATE_IDLE;
+          usbstrg_deferredresponse(priv, FALSE);
+        }
+
+      /* The USBSTRG_EVENT_CFGCHANGE is signaled when the EP0 setup
+       * logic receives a USB_REQ_SETCONFIGURATION request
+       */
+
+      if ((eventset & USBSTRG_EVENT_CFGCHANGE) != 0)
+        {
+#warning LOGIC needed
+          usbstrg_setconfig(priv, priv->thvalue);
+          priv->thstate = USBSTRG_STATE_IDLE;
+          usbstrg_deferredresponse(priv, FALSE);
+        }
+
+      /* The USBSTRG_EVENT_IFCHANGE is signaled when the EP0 setup
+       * logic receives a USB_REQ_SETINTERFACE request
+       */
+      if ((eventset & USBSTRG_EVENT_IFCHANGE) != 0)
+        {
+#warning LOGIC needed
+          usbstrg_resetconfig(priv);
+          usbstrg_setconfig(priv, priv->thvalue);
+          priv->thstate = USBSTRG_STATE_IDLE;
+          usbstrg_deferredresponse(priv, FALSE);
+        }
+
+      /* Set by the CMDFINISH logic when there is a residue after processing
+       * a host-to-device transfer.  We need to discard all incoming request.
+       */
+
+      if ((eventset & USBSTRG_EVENT_ABORTBULKOUT) != 0)
+        {
+#warning LOGIC needed
+          priv->thstate = USBSTRG_STATE_IDLE;
+        }
+
+      /* All other events are just wakeup calls and are intended only
+       * drive the state maching.  Remember only the terminate request event...
+       * we'll process that at the end of the loop.
+       */
+
+      eventset &= USBSTRG_EVENT_TERMINATEREQUEST;
+
+      /* 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.
+       */
+
+      for (ret = OK; ret == OK; )
+        {
+          switch (priv->thstate)
+            {
+            case USBSTRG_STATE_IDLE:             /* Started and waiting for commands */
+               ret = usbstrg_idlestate(priv);
+               break;
+
+            case USBSTRG_STATE_CMDPARSE:         /* Parsing the received a command */
+               ret = usbstrg_cmdparsestate(priv);
+               break;
+
+            case USBSTRG_STATE_CMDREAD:          /* Continuing to process a SCSI read command */
+               ret = usbstrg_cmdreadstate(priv);
+               break;
+
+            case USBSTRG_STATE_CMDWRITE:         /* Continuing to process a SCSI write command */
+               ret = usbstrg_cmdwritestate(priv);
+               break;
+
+            case USBSTRG_STATE_CMDFINISH:        /* Finish command processing */
+               ret = usbstrg_cmdfinishstate(priv);
+               break;
+
+            case USBSTRG_STATE_CMDSTATUS:        /* Processing the status phase of a command */
+              ret = usbstrg_cmdstatusstate(priv);
+              break;
+
+            case USBSTRG_STATE_NOTSTARTED:       /* Thread has not yet been started */
+            case USBSTRG_STATE_STARTED:          /* Started, but is not yet initialized */
+            case USBSTRG_STATE_TERMINATED:       /* Thread has exitted */
+            default:
+              usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INVALIDSTATE), priv->thstate);
+              priv->thstate = USBSTRG_STATE_IDLE;
+              break;
+            }
+        }
+    }
+
+  /* Transition to the TERMINATED state and exit */
+
+  priv->thstate = USBSTRG_STATE_TERMINATED;
+  return NULL;
+}