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


Ignore:
Timestamp:
2011-07-15T20:22:32Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e6b32a8
Parents:
89d3f3c7
Message:

Use usbmast_fun_t in more parts of the driver.

File:
1 edited

Legend:

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

    r89d3f3c7 r7190bbc  
    4949#include "bo_trans.h"
    5050#include "scsi_ms.h"
     51#include "usbmast.h"
    5152
    5253/** Get string representation for SCSI peripheral device type.
     
    6263/** Perform SCSI Inquiry command on USB mass storage device.
    6364 *
    64  * @param dev           USB device.
    65  * @param inquiry_result Where to store parsed inquiry result.
    66  * @return              Error code.
    67  */
    68 int usbmast_inquiry(usb_device_t *dev, usbmast_inquiry_data_t *inq_res)
     65 * @param mfun          Mass storage function
     66 * @param inquiry_result Where to store parsed inquiry result
     67 * @return              Error code
     68 */
     69int usbmast_inquiry(usbmast_fun_t *mfun, usbmast_inquiry_data_t *inq_res)
    6970{
    7071        scsi_std_inquiry_data_t inq_data;
     
    7778        cdb.alloc_len = host2uint16_t_be(sizeof(inq_data));
    7879
    79         rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     80        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    8081            sizeof(cdb), &inq_data, sizeof(inq_data), &response_len);
    8182
    8283        if (rc != EOK) {
    8384                usb_log_error("Inquiry failed, device %s: %s.\n",
    84                    dev->ddf_dev->name, str_error(rc));
     85                   mfun->usb_dev->ddf_dev->name, str_error(rc));
    8586                return rc;
    8687        }
     
    118119/** Perform SCSI Request Sense command on USB mass storage device.
    119120 *
    120  * @param dev           USB device
     121 * @param mfun          Mass storage function
    121122 * @param buf           Destination buffer
    122123 * @param size          Size of @a buf
     
    124125 * @return              Error code.
    125126 */
    126 int usbmast_request_sense(usb_device_t *dev, void *buf, size_t size)
     127int usbmast_request_sense(usbmast_fun_t *mfun, void *buf, size_t size)
    127128{
    128129        scsi_cdb_request_sense_t cdb;
     
    134135        cdb.alloc_len = min(size, SCSI_SENSE_DATA_MAX_SIZE);
    135136
    136         rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     137        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    137138            sizeof(cdb), buf, size, &data_len);
    138139
    139140        if (rc != EOK) {
    140141                usb_log_error("Request Sense failed, device %s: %s.\n",
    141                    dev->ddf_dev->name, str_error(rc));
     142                   mfun->usb_dev->ddf_dev->name, str_error(rc));
    142143                return rc;
    143144        }
     
    154155/** Perform SCSI Read Capacity command on USB mass storage device.
    155156 *
    156  * @param dev           USB device.
    157  * @param nblocks       Output, number of blocks.
    158  * @param block_size    Output, block size in bytes.
     157 * @param mfun          Mass storage function
     158 * @param nblocks       Output, number of blocks
     159 * @param block_size    Output, block size in bytes
    159160 *
    160161 * @return              Error code.
    161162 */
    162 int usbmast_read_capacity(usb_device_t *dev, uint32_t *nblocks,
     163int usbmast_read_capacity(usbmast_fun_t *mfun, uint32_t *nblocks,
    163164    uint32_t *block_size)
    164165{
     
    171172        cdb.op_code = SCSI_CMD_READ_CAPACITY_10;
    172173
    173         rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     174        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    174175            sizeof(cdb), &data, sizeof(data), &data_len);
    175176
    176177        if (rc != EOK) {
    177178                usb_log_error("Read Capacity (10) failed, device %s: %s.\n",
    178                    dev->ddf_dev->name, str_error(rc));
     179                   mfun->usb_dev->ddf_dev->name, str_error(rc));
    179180                return rc;
    180181        }
     
    194195/** Perform SCSI Read command on USB mass storage device.
    195196 *
    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  */
    203 int usbmast_read(usb_device_t *dev, uint64_t ba, size_t nblocks, size_t bsize,
    204     void *buf)
     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 */
     203int usbmast_read(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks, void *buf)
    205204{
    206205        scsi_cdb_read_12_t cdb;
     
    213212                return ELIMIT;
    214213
    215         if ((uint64_t)nblocks * bsize > UINT32_MAX)
     214        if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
    216215                return ELIMIT;
    217216
     
    221220        cdb.xfer_len = host2uint32_t_be(nblocks);
    222221
    223         rc = usb_massstor_data_in(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    224             sizeof(cdb), buf, nblocks * bsize, &data_len);
     222        rc = usb_massstor_data_in(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     223            sizeof(cdb), buf, nblocks * mfun->block_size, &data_len);
    225224
    226225        if (rc != EOK) {
    227226                usb_log_error("Read (12) failed, device %s: %s.\n",
    228                    dev->ddf_dev->name, str_error(rc));
    229                 return rc;
    230         }
    231 
    232         if (data_len < nblocks * bsize) {
     227                   mfun->usb_dev->ddf_dev->name, str_error(rc));
     228                return rc;
     229        }
     230
     231        if (data_len < nblocks * mfun->block_size) {
    233232                usb_log_error("SCSI Read response too short (%zu).\n",
    234233                    data_len);
     
    241240/** Perform SCSI Write command on USB mass storage device.
    242241 *
    243  * @param dev           USB device
     242 * @param mfun          Mass storage function
    244243 * @param ba            Address of first block
    245244 * @param nblocks       Number of blocks to read
    246  * @param bsize         Block size
    247245 * @param data          Data to write
    248246 *
    249247 * @return              Error code
    250248 */
    251 int usbmast_write(usb_device_t *dev, uint64_t ba, size_t nblocks, size_t bsize,
     249int usbmast_write(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks,
    252250    const void *data)
    253251{
     
    256254        int rc;
    257255
    258         /* XXX Need softstate to store block size. */
    259 
    260256        if (ba > UINT32_MAX)
    261257                return ELIMIT;
    262258
    263         if ((uint64_t)nblocks * bsize > UINT32_MAX)
     259        if ((uint64_t)nblocks * mfun->block_size > UINT32_MAX)
    264260                return ELIMIT;
    265261
     
    269265        cdb.xfer_len = host2uint32_t_be(nblocks);
    270266
    271         rc = usb_massstor_data_out(dev, 0xDEADBEEF, 0, (uint8_t *) &cdb,
    272             sizeof(cdb), data, nblocks * bsize, &sent_len);
     267        rc = usb_massstor_data_out(mfun, 0xDEADBEEF, 0, (uint8_t *) &cdb,
     268            sizeof(cdb), data, nblocks * mfun->block_size, &sent_len);
    273269
    274270        if (rc != EOK) {
    275271                usb_log_error("Write (12) failed, device %s: %s.\n",
    276                    dev->ddf_dev->name, str_error(rc));
    277                 return rc;
    278         }
    279 
    280         if (sent_len < nblocks * bsize) {
     272                   mfun->usb_dev->ddf_dev->name, str_error(rc));
     273                return rc;
     274        }
     275
     276        if (sent_len < nblocks * mfun->block_size) {
    281277                usb_log_error("SCSI Write not all bytes transferred (%zu).\n",
    282278                    sent_len);
Note: See TracChangeset for help on using the changeset viewer.