Changeset 00c2de63 in mainline for uspace/drv

Timestamp:

2011-07-29T14:50:22Z (15 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

b6759f4

Parents:

6c69d19 (diff), 7ae249d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge libposix.

Location:

uspace/drv/bus/usb/usbmast

Files:

• bo_trans.c (modified) (7 diffs)
• bo_trans.h (modified) (1 diff)
• cmdw.h (modified) (1 diff)
• scsi_ms.c (modified) (11 diffs)

uspace/drv/bus/usb/usbmast/bo_trans.c

@@ -58 +58 @@
  * @param tag           Command block wrapper tag (automatically compared
  *                      with answer)
- * @param cmd           Command block
- * @param cmd_size      Command block size in bytes
- * @param ddir          Direction in which data will be transferred
- * @param dbuf          Data send/receive buffer
- * @param dbuf_size     Size of the data buffer
- * @param xferred_size  Number of bytes actually transferred
+ * @param cmd           SCSI command
  *
  * @return              Error code
  */
-static int usb_massstor_cmd(usbmast_fun_t *mfun, uint32_t tag, const void *cmd,
-    size_t cmd_size, usb_direction_t ddir, void *dbuf, size_t dbuf_size,
-    size_t *xferred_size)
+int usb_massstor_cmd(usbmast_fun_t *mfun, uint32_t tag, scsi_cmd_t *cmd)
 {
         int rc;
+        int retval = EOK;
         size_t act_size;
         usb_pipe_t *bulk_in_pipe = mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe;
         usb_pipe_t *bulk_out_pipe = mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe;
+        usb_direction_t ddir;
+        void *dbuf;
+        size_t dbuf_size;
+
+        if (cmd->data_out != NULL && cmd->data_in == NULL) {
+                ddir = USB_DIRECTION_OUT;
+                dbuf = (void *)cmd->data_out;
+                dbuf_size = cmd->data_out_size;
+        } else if (cmd->data_out == NULL && cmd->data_in != NULL) {
+                ddir = USB_DIRECTION_IN;
+                dbuf = cmd->data_in;
+                dbuf_size = cmd->data_in_size;
+        } else {
+                assert(false);
+        }
 
         /* Prepare CBW - command block wrapper */
         usb_massstor_cbw_t cbw;
         usb_massstor_cbw_prepare(&cbw, tag, dbuf_size, ddir, mfun->lun,
-            cmd_size, cmd);
+            cmd->cdb_size, cmd->cdb);
 
         /* Send the CBW. */
+        MASTLOG("Sending CBW.\n");
         rc = usb_pipe_write(bulk_out_pipe, &cbw, sizeof(cbw));
         MASTLOG("CBW '%s' sent: %s.\n",
             usb_debug_str_buffer((uint8_t *) &cbw, sizeof(cbw), 0),
             str_error(rc));
-        if (rc != EOK) {
-                return rc;
-        }
-
+        if (rc != EOK)
+                return EIO;
+
+        MASTLOG("Transferring data.\n");
         if (ddir == USB_DIRECTION_IN) {
                 /* Recieve data from the device. */
@@ -104 +114 @@
         }
 
-        if (rc != EOK) {
-                /*
-                 * XXX If the pipe is stalled, we should clear it
-                 * and read CSW.
-                 */
-                return rc;
+        if (rc == ESTALL) {
+                /* Clear stall condition and continue below to read CSW. */
+                if (ddir == USB_DIRECTION_IN) {
+                        usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
+                            mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe);
+                } else {
+                        usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
+                            mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
+                }
+        } else if (rc != EOK) {
+                return EIO;
         }
 
@@ -115 +130 @@
         usb_massstor_csw_t csw;
         size_t csw_size;
+        MASTLOG("Reading CSW.\n");
         rc = usb_pipe_read(bulk_in_pipe, &csw, sizeof(csw), &csw_size);
         MASTLOG("CSW '%s' received (%zu bytes): %s.\n",
@@ -121 +137 @@
         if (rc != EOK) {
                 MASTLOG("rc != EOK\n");
-                return rc;
+                return EIO;
         }
 
         if (csw_size != sizeof(csw)) {
                 MASTLOG("csw_size != sizeof(csw)\n");
-                return ERANGE;
+                return EIO;
         }
 
         if (csw.dCSWTag != tag) {
                 MASTLOG("csw.dCSWTag != tag\n");
-                return EBADCHECKSUM;
+                return EIO;
         }
 
@@ -137 +153 @@
          * Determine the actual return value from the CSW.
          */
-        if (csw.dCSWStatus != 0) {
-                MASTLOG("csw.dCSWStatus != 0\n");
-                // FIXME: better error code
-                // FIXME: distinguish 0x01 and 0x02
-                return EXDEV;
+        switch (csw.dCSWStatus) {
+        case cbs_passed:
+                cmd->status = CMDS_GOOD;
+                break;
+        case cbs_failed:
+                MASTLOG("Command failed\n");
+                cmd->status = CMDS_FAILED;
+                break;
+        case cbs_phase_error:
+                MASTLOG("Phase error\n");
+                retval = EIO;
+                break;
+        default:
+                retval = EIO;
+                break;
         }
 
@@ -147 +173 @@
         if (residue > dbuf_size) {
                 MASTLOG("residue > dbuf_size\n");
-                return ERANGE;
+                return EIO;
         }
 
@@ -158 +184 @@
          */
 
-        if (xferred_size != NULL)
-                *xferred_size = dbuf_size - residue;
-
-        return EOK;
-}
-
-/** Perform data-in command.
- *
- * @param mfun          Mass storage function
- * @param tag           Command block wrapper tag (automatically compared with
- *                      answer)
- * @param cmd           CDB (Command Descriptor)
- * @param cmd_size      CDB length in bytes
- * @param dbuf          Data receive buffer
- * @param dbuf_size     Data receive buffer size in bytes
- * @param proc_size     Number of bytes actually processed by device
- *
- * @return Error code
- */
-int usb_massstor_data_in(usbmast_fun_t *mfun, uint32_t tag, const void *cmd,
-    size_t cmd_size, void *dbuf, size_t dbuf_size, size_t *proc_size)
-{
-        return usb_massstor_cmd(mfun, tag, cmd, cmd_size, USB_DIRECTION_IN,
-            dbuf, dbuf_size, proc_size);
-}
-
-/** Perform data-out command.
- *
- * @param mfun          Mass storage function
- * @param tag           Command block wrapper tag (automatically compared with
- *                      answer)
- * @param cmd           CDB (Command Descriptor)
- * @param cmd_size      CDB length in bytes
- * @param data          Command data
- * @param data_size     Size of @a data in bytes
- * @param proc_size     Number of bytes actually processed by device
- *
- * @return Error code
- */
-int usb_massstor_data_out(usbmast_fun_t *mfun, uint32_t tag, const void *cmd,
-    size_t cmd_size, const void *data, size_t data_size, size_t *proc_size)
-{
-        return usb_massstor_cmd(mfun, tag, cmd, cmd_size, USB_DIRECTION_OUT,
-            (void *) data, data_size, proc_size);
+        if (ddir == USB_DIRECTION_IN)
+                cmd->rcvd_size = dbuf_size - residue;
+
+        return retval;
 }
 

uspace/drv/bus/usb/usbmast/bo_trans.h

@@ -47 +47 @@
 #define BULK_OUT_EP 1
 
-extern int usb_massstor_data_in(usbmast_fun_t *, uint32_t, const void *,
-    size_t, void *, size_t, size_t *);
-extern int usb_massstor_data_out(usbmast_fun_t *, uint32_t, const void *,
-    size_t, const void *, size_t, size_t *);
+typedef enum cmd_status {
+        CMDS_GOOD,
+        CMDS_FAILED
+} cmd_status_t;
+
+/** SCSI command.
+ *
+ * Contains (a subset of) the input and output arguments of SCSI
+ * Execute Command procedure call (see SAM-4 chapter 5.1)
+ */
+typedef struct {
+        /*
+         * Related to IN fields
+         */
+
+        /** Command Descriptor Block */
+        void *cdb;
+        /** CDB size in bytes */
+        size_t cdb_size;
+
+        /** Outgoing data */
+        const void *data_out;
+        /** Size of outgoing data in bytes */
+        size_t data_out_size;
+
+        /*
+         * Related to OUT fields
+         */
+
+        /** Buffer for incoming data */
+        void *data_in;
+        /** Size of input buffer in bytes */
+        size_t data_in_size;
+
+        /** Number of bytes actually received */
+        size_t rcvd_size;
+
+        /** Status */
+        cmd_status_t status;
+} scsi_cmd_t;
+
+extern int usb_massstor_cmd(usbmast_fun_t *, uint32_t, scsi_cmd_t *);
 extern int usb_massstor_reset(usbmast_dev_t *);
 extern void usb_massstor_reset_recovery(usbmast_dev_t *);

uspace/drv/bus/usb/usbmast/cmdw.h

@@ -57 +57 @@
 } __attribute__((packed)) usb_massstor_csw_t;
 
+enum cmd_block_status {
+        cbs_passed      = 0x00,
+        cbs_failed      = 0x01,
+        cbs_phase_error = 0x02
+};
+
 extern void usb_massstor_cbw_prepare(usb_massstor_cbw_t *, uint32_t, uint32_t,
     usb_direction_t, uint8_t, uint8_t, const uint8_t *);

uspace/drv/bus/usb/usbmast/scsi_ms.c

@@ -61 +61 @@
 }
 
+static void usbmast_dump_sense(scsi_sense_data_t *sense_buf)
+{
+        unsigned sense_key;
+
+        sense_key = sense_buf->flags_key & 0x0f;
+        printf("Got sense data. Sense key: 0x%x (%s), ASC 0x%02x, "
+            "ASCQ 0x%02x.\n", sense_key,
+            scsi_get_sense_key_str(sense_key),
+            sense_buf->additional_code,
+            sense_buf->additional_cqual);
+}
+
+/** Run SCSI command.
+ *
+ * Run command and repeat in case of unit attention.
+ * XXX This is too simplified.
+ */
+static int usbmast_run_cmd(usbmast_fun_t *mfun, scsi_cmd_t *cmd)
+{
+        uint8_t sense_key;
+        scsi_sense_data_t sense_buf;
+        int rc;
+
+        do {
+                rc = usb_massstor_cmd(mfun, 0xDEADBEEF, cmd);
+                if (rc != EOK) {
+                        usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                           mfun->mdev->ddf_dev->name, str_error(rc));
+                        return rc;
+                }
+
+                if (cmd->status == CMDS_GOOD)
+                        return EOK;
+
+                usb_log_error("SCSI command failed, device %s.\n",
+                    mfun->mdev->ddf_dev->name);
+
+                rc = usbmast_request_sense(mfun, &sense_buf, sizeof(sense_buf));
+                if (rc != EOK) {
+                        usb_log_error("Failed to read sense data.\n");
+                        return EIO;
+                }
+
+                /* Dump sense data to log */
+                usbmast_dump_sense(&sense_buf);
+
+                /* Get sense key */
+                sense_key = sense_buf.flags_key & 0x0f;
+
+                if (sense_key == SCSI_SK_UNIT_ATTENTION) {
+                        printf("Got unit attention. Re-trying command.\n");
+                }
+
+        } while (sense_key == SCSI_SK_UNIT_ATTENTION);
+
+        /* Command status is not good, nevertheless transport succeeded. */
+        return EOK;
+}
+
 /** Perform SCSI Inquiry command on USB mass storage device.
  *
@@ -70 +129 @@
 {
         scsi_std_inquiry_data_t inq_data;
-        size_t response_len;
+        scsi_cmd_t cmd;
         scsi_cdb_inquiry_t cdb;
         int rc;
@@ -78 +137 @@
         cdb.alloc_len = host2uint16_t_be(sizeof(inq_data));
 
-        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
-            sizeof(cdb), &inq_data, sizeof(inq_data), &response_len);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = &inq_data;
+        cmd.data_in_size = sizeof(inq_data);
+
+        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
 
         if (rc != EOK) {
-                usb_log_error("Inquiry failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        if (response_len < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
+                usb_log_error("Inquiry transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Inquiry command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
+                return EIO;
+        }
+
+        if (cmd.rcvd_size < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
                 usb_log_error("SCSI Inquiry response too short (%zu).\n",
-                    response_len);
+                    cmd.rcvd_size);
                 return EIO;
         }
@@ -127 +197 @@
 int usbmast_request_sense(usbmast_fun_t *mfun, void *buf, size_t size)
 {
+        scsi_cmd_t cmd;
         scsi_cdb_request_sense_t cdb;
-        size_t data_len;
         int rc;
 
@@ -135 +205 @@
         cdb.alloc_len = min(size, SCSI_SENSE_DATA_MAX_SIZE);
 
-        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
-            sizeof(cdb), buf, size, &data_len);
-
-        if (rc != EOK) {
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = buf;
+        cmd.data_in_size = size;
+
+        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
+
+        if (rc != EOK || cmd.status != CMDS_GOOD) {
                 usb_log_error("Request Sense failed, device %s: %s.\n",
                    mfun->mdev->ddf_dev->name, str_error(rc));
@@ -144 +219 @@
         }
 
-        if (data_len < SCSI_SENSE_DATA_MIN_SIZE) {
+        if (cmd.rcvd_size < SCSI_SENSE_DATA_MIN_SIZE) {
                 /* The missing bytes should be considered to be zeroes. */
-                memset((uint8_t *)buf + data_len, 0,
-                    SCSI_SENSE_DATA_MIN_SIZE - data_len);
+                memset((uint8_t *)buf + cmd.rcvd_size, 0,
+                    SCSI_SENSE_DATA_MIN_SIZE - cmd.rcvd_size);
         }
 
@@ -164 +239 @@
     uint32_t *block_size)
 {
+        scsi_cmd_t cmd;
         scsi_cdb_read_capacity_10_t cdb;
         scsi_read_capacity_10_data_t data;
-        size_t data_len;
         int rc;
 
@@ -172 +247 @@
         cdb.op_code = SCSI_CMD_READ_CAPACITY_10;
 
-        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
-            sizeof(cdb), &data, sizeof(data), &data_len);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = &data;
+        cmd.data_in_size = sizeof(data);
+
+        rc = usbmast_run_cmd(mfun, &cmd);
 
         if (rc != EOK) {
-                usb_log_error("Read Capacity (10) failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        if (data_len < sizeof(data)) {
+                usb_log_error("Read Capacity (10) transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Read Capacity (10) command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
+                return EIO;
+        }
+
+        if (cmd.rcvd_size < sizeof(data)) {
                 usb_log_error("SCSI Read Capacity response too short (%zu).\n",
-                    data_len);
+                    cmd.rcvd_size);
                 return EIO;
         }
@@ -203 +289 @@
 int usbmast_read(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, void *buf)
 {
-        scsi_cdb_read_12_t cdb;
-        size_t data_len;
-        int rc;
-
-        /* XXX Need softstate to store block size. */
+        scsi_cmd_t cmd;
+        scsi_cdb_read_10_t cdb;
+        int rc;
 
         if (ba > UINT32_MAX)
                 return ELIMIT;
 
-        if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
+        if (nblocks > UINT16_MAX)
                 return ELIMIT;
 
         memset(&cdb, 0, sizeof(cdb));
-        cdb.op_code = SCSI_CMD_READ_12;
+        cdb.op_code = SCSI_CMD_READ_10;
         cdb.lba = host2uint32_t_be(ba);
-        cdb.xfer_len = host2uint32_t_be(nblocks);
-
-        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
-            sizeof(cdb), buf, nblocks * mfun->block_size, &data_len);
+        cdb.xfer_len = host2uint16_t_be(nblocks);
+
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_in = buf;
+        cmd.data_in_size = nblocks * mfun->block_size;
+
+        rc = usbmast_run_cmd(mfun, &cmd);
 
         if (rc != EOK) {
-                usb_log_error("Read (12) failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        if (data_len < nblocks * mfun->block_size) {
+                usb_log_error("Read (10) transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Read (10) command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
+                return EIO;
+        }
+
+        if (cmd.rcvd_size < nblocks * mfun->block_size) {
                 usb_log_error("SCSI Read response too short (%zu).\n",
-                    data_len);
+                    cmd.rcvd_size);
                 return EIO;
         }
@@ -250 +345 @@
     const void *data)
 {
-        scsi_cdb_write_12_t cdb;
-        size_t sent_len;
+        scsi_cmd_t cmd;
+        scsi_cdb_write_10_t cdb;
         int rc;
 
@@ -257 +352 @@
                 return ELIMIT;
 
-        if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
+        if (nblocks > UINT16_MAX)
                 return ELIMIT;
 
         memset(&cdb, 0, sizeof(cdb));
-        cdb.op_code = SCSI_CMD_WRITE_12;
+        cdb.op_code = SCSI_CMD_WRITE_10;
         cdb.lba = host2uint32_t_be(ba);
-        cdb.xfer_len = host2uint32_t_be(nblocks);
-
-        rc = usb_massstor_data_out(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
-            sizeof(cdb), data, nblocks * mfun->block_size, &sent_len);
+        cdb.xfer_len = host2uint16_t_be(nblocks);
+
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cdb = &cdb;
+        cmd.cdb_size = sizeof(cdb);
+        cmd.data_out = data;
+        cmd.data_out_size = nblocks * mfun->block_size;
+
+        rc = usbmast_run_cmd(mfun, &cmd);
 
         if (rc != EOK) {
-                usb_log_error("Write (12) failed, device %s: %s.\n",
-                   mfun->mdev->ddf_dev->name, str_error(rc));
-                return rc;
-        }
-
-        if (sent_len < nblocks * mfun->block_size) {
-                usb_log_error("SCSI Write not all bytes transferred (%zu).\n",
-                    sent_len);
+                usb_log_error("Write (10) transport failed, device %s: %s.\n",
+                   mfun->mdev->ddf_dev->name, str_error(rc));
+                return rc;
+        }
+
+        if (cmd.status != CMDS_GOOD) {
+                usb_log_error("Write (10) command failed, device %s.\n",
+                   mfun->mdev->ddf_dev->name);
                 return EIO;
         }