Ignore:
File:
1 edited

Legend:

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

    r2aceec5 r38c9505  
    4646#include <scsi/sbc.h>
    4747#include <scsi/spc.h>
    48 #include "cmdw.h"
    49 #include "bo_trans.h"
     48#include "cmds.h"
     49#include "mast.h"
    5050#include "scsi_ms.h"
    51 #include "usbmast.h"
    5251
    5352/** Get string representation for SCSI peripheral device type.
     
    6362/** Perform SCSI Inquiry command on USB mass storage device.
    6463 *
    65  * @param mfun          Mass storage function
    66  * @param inquiry_result Where to store parsed inquiry result
    67  * @return              Error code
    68  */
    69 int usbmast_inquiry(usbmast_fun_t *mfun, usbmast_inquiry_data_t *inq_res)
     64 * @param dev           USB device.
     65 * @param inquiry_result Where to store parsed inquiry result.
     66 * @return              Error code.
     67 */
     68int usbmast_inquiry(usb_device_t *dev, usbmast_inquiry_data_t *inq_res)
    7069{
    7170        scsi_std_inquiry_data_t inq_data;
     
    7877        cdb.alloc_len = host2uint16_t_be(sizeof(inq_data));
    7978
    80         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
     79        rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    8180            sizeof(cdb), &inq_data, sizeof(inq_data), &response_len);
    8281
    8382        if (rc != EOK) {
    8483                usb_log_error("Inquiry failed, device %s: %s.\n",
    85                    mfun->mdev->ddf_dev->name, str_error(rc));
     84                   dev->ddf_dev->name, str_error(rc));
    8685                return rc;
    8786        }
     
    119118/** Perform SCSI Request Sense command on USB mass storage device.
    120119 *
    121  * @param mfun          Mass storage function
     120 * @param dev           USB device
    122121 * @param buf           Destination buffer
    123122 * @param size          Size of @a buf
     
    125124 * @return              Error code.
    126125 */
    127 int usbmast_request_sense(usbmast_fun_t *mfun, void *buf, size_t size)
     126int usbmast_request_sense(usb_device_t *dev, void *buf, size_t size)
    128127{
    129128        scsi_cdb_request_sense_t cdb;
     
    135134        cdb.alloc_len = min(size, SCSI_SENSE_DATA_MAX_SIZE);
    136135
    137         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
     136        rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    138137            sizeof(cdb), buf, size, &data_len);
    139138
    140139        if (rc != EOK) {
    141140                usb_log_error("Request Sense failed, device %s: %s.\n",
    142                    mfun->mdev->ddf_dev->name, str_error(rc));
     141                   dev->ddf_dev->name, str_error(rc));
    143142                return rc;
    144143        }
     
    155154/** Perform SCSI Read Capacity command on USB mass storage device.
    156155 *
    157  * @param mfun          Mass storage function
    158  * @param nblocks       Output, number of blocks
    159  * @param block_size    Output, block size in bytes
    160  *
    161  * @return              Error code.
    162  */
    163 int usbmast_read_capacity(usbmast_fun_t *mfun, uint32_t *nblocks,
     156 * @param dev           USB device.
     157 * @param nblocks       Output, number of blocks.
     158 * @param block_size    Output, block size in bytes.
     159 *
     160 * @return              Error code.
     161 */
     162int usbmast_read_capacity(usb_device_t *dev, uint32_t *nblocks,
    164163    uint32_t *block_size)
    165164{
     
    172171        cdb.op_code = SCSI_CMD_READ_CAPACITY_10;
    173172
    174         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
     173        rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    175174            sizeof(cdb), &data, sizeof(data), &data_len);
    176175
    177176        if (rc != EOK) {
    178177                usb_log_error("Read Capacity (10) failed, device %s: %s.\n",
    179                    mfun->mdev->ddf_dev->name, str_error(rc));
     178                   dev->ddf_dev->name, str_error(rc));
    180179                return rc;
    181180        }
     
    195194/** Perform SCSI Read command on USB mass storage device.
    196195 *
    197  * @param mfun          Mass storage function
    198  * @param ba            Address of first block
    199  * @param nblocks       Number of blocks to read
    200  *
    201  * @return              Error code
    202  */
    203 int usbmast_read(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, void *buf)
     196 * @param dev           USB device.
     197 * @param ba            Address of first block.
     198 * @param nblocks       Number of blocks to read.
     199 * @param bsize         Block size.
     200 *
     201 * @return              Error code.
     202 */
     203int usbmast_read(usb_device_t *dev, uint64_t ba, size_t nblocks, size_t bsize,
     204    void *buf)
    204205{
    205206        scsi_cdb_read_12_t cdb;
     
    212213                return ELIMIT;
    213214
    214         if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
     215        if ((uint64_t)nblocks * bsize > UINT32_MAX)
    215216                return ELIMIT;
    216217
     
    220221        cdb.xfer_len = host2uint32_t_be(nblocks);
    221222
    222         rc = usb_massstor_data_in(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    223             sizeof(cdb), buf, nblocks * mfun->block_size, &data_len);
     223        rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     224            sizeof(cdb), buf, nblocks * bsize, &data_len);
    224225
    225226        if (rc != EOK) {
    226227                usb_log_error("Read (12) failed, device %s: %s.\n",
    227                    mfun->mdev->ddf_dev->name, str_error(rc));
    228                 return rc;
    229         }
    230 
    231         if (data_len < nblocks * mfun->block_size) {
     228                   dev->ddf_dev->name, str_error(rc));
     229                return rc;
     230        }
     231
     232        if (data_len < nblocks * bsize) {
    232233                usb_log_error("SCSI Read response too short (%zu).\n",
    233234                    data_len);
     
    240241/** Perform SCSI Write command on USB mass storage device.
    241242 *
    242  * @param mfun          Mass storage function
     243 * @param dev           USB device
    243244 * @param ba            Address of first block
    244245 * @param nblocks       Number of blocks to read
     246 * @param bsize         Block size
    245247 * @param data          Data to write
    246248 *
    247249 * @return              Error code
    248250 */
    249 int usbmast_write(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks,
     251int usbmast_write(usb_device_t *dev, uint64_t ba, size_t nblocks, size_t bsize,
    250252    const void *data)
    251253{
     
    254256        int rc;
    255257
     258        /* XXX Need softstate to store block size. */
     259
    256260        if (ba > UINT32_MAX)
    257261                return ELIMIT;
    258262
    259         if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
     263        if ((uint64_t)nblocks * bsize > UINT32_MAX)
    260264                return ELIMIT;
    261265
     
    265269        cdb.xfer_len = host2uint32_t_be(nblocks);
    266270
    267         rc = usb_massstor_data_out(mfun, 0xDEADBEEF, (uint8_t *) &cdb,
    268             sizeof(cdb), data, nblocks * mfun->block_size, &sent_len);
     271        rc = usb_massstor_data_out(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     272            sizeof(cdb), data, nblocks * bsize, &sent_len);
    269273
    270274        if (rc != EOK) {
    271275                usb_log_error("Write (12) failed, device %s: %s.\n",
    272                    mfun->mdev->ddf_dev->name, str_error(rc));
    273                 return rc;
    274         }
    275 
    276         if (sent_len < nblocks * mfun->block_size) {
     276                   dev->ddf_dev->name, str_error(rc));
     277                return rc;
     278        }
     279
     280        if (sent_len < nblocks * bsize) {
    277281                usb_log_error("SCSI Write not all bytes transferred (%zu).\n",
    278282                    sent_len);
Note: See TracChangeset for help on using the changeset viewer.