usbdev_scsi.c

/****************************************************************************
 * 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;