Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset de3432b in mainline for uspace/drv/bus/usb/usbmast/scsi_ms.c


Ignore:
Timestamp:
2011-07-24T18:09:09Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
1bfae13, 358dc13, eff10e03
Parents:
582fe388
Message:

Allow simpler passing around / processing of SCSI commands by creating
scsi_cmd_t structure which holds input and output arguments of a SCSI
command and is loosely modeled after the SAM-4 Execute Command procedure
call.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/bus/usb/usbmast/scsi_ms.c

    r582fe388 rde3432b  
    8989{
    9090        scsi_std_inquiry_data_t inq_data;
    91         size_t response_len;
     91        scsi_cmd_t cmd;
    9292        scsi_cdb_inquiry_t cdb;
    93         cmd_status_t status;
    9493        int rc;
    9594
     
    9897        cdb.alloc_len = host2uint16_t_be(sizeof(inq_data));
    9998
    100         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    101             sizeof(cdb), &inq_data, sizeof(inq_data), &response_len, &status);
     99        memset(&cmd, 0, sizeof(cmd));
     100        cmd.cdb = &cdb;
     101        cmd.cdb_size = sizeof(cdb);
     102        cmd.data_in = &inq_data;
     103        cmd.data_in_size = sizeof(inq_data);
     104
     105        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
    102106
    103107        if (rc != EOK) {
     
    107111        }
    108112
    109         if (status != CMDS_GOOD) {
     113        if (cmd.status != CMDS_GOOD) {
    110114                usb_log_error("Inquiry command failed, device %s.\n",
    111115                   mfun->mdev->ddf_dev->name);
     
    114118        }
    115119
    116         if (response_len < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
     120        if (cmd.rcvd_size < SCSI_STD_INQUIRY_DATA_MIN_SIZE) {
    117121                usb_log_error("SCSI Inquiry response too short (%zu).\n",
    118                     response_len);
     122                    cmd.rcvd_size);
    119123                return EIO;
    120124        }
     
    154158int usbmast_request_sense(usbmast_fun_t *mfun, void *buf, size_t size)
    155159{
     160        scsi_cmd_t cmd;
    156161        scsi_cdb_request_sense_t cdb;
    157         size_t data_len;
    158         cmd_status_t status;
    159162        int rc;
    160163
     
    163166        cdb.alloc_len = min(size, SCSI_SENSE_DATA_MAX_SIZE);
    164167
    165         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    166             sizeof(cdb), buf, size, &data_len, &status);
    167 
    168         if (rc != EOK || status != CMDS_GOOD) {
     168        memset(&cmd, 0, sizeof(cmd));
     169        cmd.cdb = &cdb;
     170        cmd.cdb_size = sizeof(cdb);
     171        cmd.data_in = buf;
     172        cmd.data_in_size = size;
     173
     174        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
     175
     176        if (rc != EOK || cmd.status != CMDS_GOOD) {
    169177                usb_log_error("Request Sense failed, device %s: %s.\n",
    170178                   mfun->mdev->ddf_dev->name, str_error(rc));
     
    172180        }
    173181
    174         if (data_len < SCSI_SENSE_DATA_MIN_SIZE) {
     182        if (cmd.rcvd_size < SCSI_SENSE_DATA_MIN_SIZE) {
    175183                /* The missing bytes should be considered to be zeroes. */
    176                 memset((uint8_t *)buf + data_len, 0,
    177                     SCSI_SENSE_DATA_MIN_SIZE - data_len);
     184                memset((uint8_t *)buf + cmd.rcvd_size, 0,
     185                    SCSI_SENSE_DATA_MIN_SIZE - cmd.rcvd_size);
    178186        }
    179187
     
    192200    uint32_t *block_size)
    193201{
     202        scsi_cmd_t cmd;
    194203        scsi_cdb_read_capacity_10_t cdb;
    195204        scsi_read_capacity_10_data_t data;
    196         size_t data_len;
    197         cmd_status_t status;
    198205        int rc;
    199206
     
    201208        cdb.op_code = SCSI_CMD_READ_CAPACITY_10;
    202209
    203         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    204             sizeof(cdb), &data, sizeof(data), &data_len, &status);
     210        memset(&cmd, 0, sizeof(cmd));
     211        cmd.cdb = &cdb;
     212        cmd.cdb_size = sizeof(cdb);
     213        cmd.data_in = &data;
     214        cmd.data_in_size = sizeof(data);
     215
     216        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
    205217
    206218        if (rc != EOK) {
     
    210222        }
    211223
    212         if (status != CMDS_GOOD) {
     224        if (cmd.status != CMDS_GOOD) {
    213225                usb_log_error("Read Capacity (10) command failed, device %s.\n",
    214226                   mfun->mdev->ddf_dev->name);
     
    217229        }
    218230
    219         if (data_len < sizeof(data)) {
     231        if (cmd.rcvd_size < sizeof(data)) {
    220232                usb_log_error("SCSI Read Capacity response too short (%zu).\n",
    221                     data_len);
     233                    cmd.rcvd_size);
    222234                return EIO;
    223235        }
     
    239251int usbmast_read(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, void *buf)
    240252{
     253        scsi_cmd_t cmd;
    241254        scsi_cdb_read_12_t cdb;
    242         size_t data_len;
    243         cmd_status_t status;
    244         int rc;
    245 
    246         /* XXX Need softstate to store block size. */
     255        int rc;
    247256
    248257        if (ba > UINT32_MAX)
     
    257266        cdb.xfer_len = host2uint32_t_be(nblocks);
    258267
    259         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    260             sizeof(cdb), buf, nblocks * mfun->block_size, &data_len, &status);
     268        memset(&cmd, 0, sizeof(cmd));
     269        cmd.cdb = &cdb;
     270        cmd.cdb_size = sizeof(cdb);
     271        cmd.data_in = buf;
     272        cmd.data_in_size = nblocks * mfun->block_size;
     273
     274        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
    261275
    262276        if (rc != EOK) {
     
    266280        }
    267281
    268         if (status != CMDS_GOOD) {
     282        if (cmd.status != CMDS_GOOD) {
    269283                usb_log_error("Read (12) command failed, device %s.\n",
    270284                   mfun->mdev->ddf_dev->name);
     
    273287        }
    274288
    275         if (data_len < nblocks * mfun->block_size) {
     289        if (cmd.rcvd_size < nblocks * mfun->block_size) {
    276290                usb_log_error("SCSI Read response too short (%zu).\n",
    277                     data_len);
     291                    cmd.rcvd_size);
    278292                return EIO;
    279293        }
     
    294308    const void *data)
    295309{
     310        scsi_cmd_t cmd;
    296311        scsi_cdb_write_12_t cdb;
    297         size_t sent_len;
    298         cmd_status_t status;
    299312        int rc;
    300313
     
    310323        cdb.xfer_len = host2uint32_t_be(nblocks);
    311324
    312         rc = usb_massstor_data_out(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    313             sizeof(cdb), data, nblocks * mfun->block_size, &sent_len, &status);
     325        memset(&cmd, 0, sizeof(cmd));
     326        cmd.cdb = &cdb;
     327        cmd.cdb_size = sizeof(cdb);
     328        cmd.data_out = data;
     329        cmd.data_out_size = nblocks * mfun->block_size;
     330
     331        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
    314332
    315333        if (rc != EOK) {
     
    319337        }
    320338
    321         if (status != CMDS_GOOD) {
     339        if (cmd.status != CMDS_GOOD) {
    322340                usb_log_error("Write (12) command failed, device %s.\n",
    323341                   mfun->mdev->ddf_dev->name);
     
    326344        }
    327345
    328         if (sent_len < nblocks * mfun->block_size) {
    329                 usb_log_error("SCSI Write not all bytes transferred (%zu).\n",
    330                     sent_len);
    331                 return EIO;
    332         }
    333 
    334346        return EOK;
    335347}
Note: See TracChangeset for help on using the changeset viewer.