usbdev_scsi.c

          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;