Changeset b4b534ac in mainline for uspace/drv/bus/usb/usbmast


Ignore:
Timestamp:
2016-07-22T08:24:47Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f76d2c2
Parents:
5b18137 (diff), 8351f9a4 (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 from lp:~jan.vesely/helenos/usb

Location:
uspace/drv/bus/usb/usbmast
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r5b18137 rb4b534ac  
    4444#include "usbmast.h"
    4545
    46 bool usb_mast_verbose = false;
    4746
    4847#define MASTLOG(format, ...) \
    49         do { \
    50                 if (usb_mast_verbose) { \
    51                         usb_log_debug2("USB cl08: " format, ##__VA_ARGS__); \
    52                 } \
    53         } while (false)
     48        usb_log_debug2("USB cl08: " format, ##__VA_ARGS__)
    5449
    5550/** Send command via bulk-only transport.
    … …  
    6560{
    6661        int rc;
    67         int retval = EOK;
    68         size_t act_size;
    69         usb_pipe_t *bulk_in_pipe = &mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe;
    70         usb_pipe_t *bulk_out_pipe = &mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe;
    71         usb_direction_t ddir;
    72         void *dbuf;
    73         size_t dbuf_size;
    74 
    75         if (cmd->data_out != NULL && cmd->data_in == NULL) {
    76                 ddir = USB_DIRECTION_OUT;
    77                 dbuf = (void *)cmd->data_out;
    78                 dbuf_size = cmd->data_out_size;
    79         } else if (cmd->data_out == NULL && cmd->data_in != NULL) {
     62
     63        if (cmd->data_in && cmd->data_out)
     64                return EINVAL;
     65
     66        usb_pipe_t *bulk_in_pipe = mfun->mdev->bulk_in_pipe;
     67        usb_pipe_t *bulk_out_pipe = mfun->mdev->bulk_out_pipe;
     68
     69        usb_pipe_t *dpipe = bulk_out_pipe;
     70        usb_direction_t ddir = USB_DIRECTION_OUT;
     71        size_t dbuf_size = cmd->data_out_size;
     72
     73        if (cmd->data_in) {
    8074                ddir = USB_DIRECTION_IN;
    81                 dbuf = cmd->data_in;
    8275                dbuf_size = cmd->data_in_size;
    83         } else {
    84                 assert(false);
     76                dpipe = bulk_in_pipe;
    8577        }
    8678
    … …  
    9688            usb_debug_str_buffer((uint8_t *) &cbw, sizeof(cbw), 0),
    9789            str_error(rc));
    98         if (rc != EOK)
    99                 return EIO;
     90        if (rc != EOK) {
     91                usb_log_error("Bulk out write failed: %s\n", str_error(rc));
     92                return EIO;
     93        }
    10094
    10195        MASTLOG("Transferring data.\n");
    102         if (ddir == USB_DIRECTION_IN) {
     96        if (cmd->data_in) {
     97                size_t act_size;
    10398                /* Recieve data from the device. */
    104                 rc = usb_pipe_read(bulk_in_pipe, dbuf, dbuf_size, &act_size);
     99                rc = usb_pipe_read(dpipe, cmd->data_in, cmd->data_in_size,
     100                    &act_size);
    105101                MASTLOG("Received %zu bytes (%s): %s.\n", act_size,
    106                     usb_debug_str_buffer((uint8_t *) dbuf, act_size, 0),
     102                    usb_debug_str_buffer(cmd->data_in, act_size, 0),
    107103                    str_error(rc));
    108         } else {
     104        }
     105        if (cmd->data_out) {
    109106                /* Send data to the device. */
    110                 rc = usb_pipe_write(bulk_out_pipe, dbuf, dbuf_size);
    111                 MASTLOG("Sent %zu bytes (%s): %s.\n", act_size,
    112                     usb_debug_str_buffer((uint8_t *) dbuf, act_size, 0),
     107                rc = usb_pipe_write(dpipe, cmd->data_out, cmd->data_out_size);
     108                MASTLOG("Sent %zu bytes (%s): %s.\n", cmd->data_out_size,
     109                    usb_debug_str_buffer(cmd->data_out, cmd->data_out_size, 0),
    113110                    str_error(rc));
    114111        }
    … …  
    116113        if (rc == ESTALL) {
    117114                /* Clear stall condition and continue below to read CSW. */
    118                 if (ddir == USB_DIRECTION_IN) {
    119                         usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
    120                             &mfun->mdev->usb_dev->pipes[BULK_IN_EP].pipe);
    121                 } else {
    122                         usb_pipe_clear_halt(&mfun->mdev->usb_dev->ctrl_pipe,
    123                             &mfun->mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
    124                 }
     115                usb_pipe_clear_halt(
     116                    usb_device_get_default_pipe(mfun->mdev->usb_dev), dpipe);
    125117        } else if (rc != EOK) {
     118                usb_log_error("Failed to transfer data: %s", str_error(rc));
    126119                return EIO;
    127120        }
    … …  
    136129            str_error(rc));
    137130        if (rc != EOK) {
    138                 MASTLOG("rc != EOK\n");
     131                usb_log_error("Failed to read CSW: %s", str_error(rc));
    139132                return EIO;
    140133        }
    141134
    142135        if (csw_size != sizeof(csw)) {
    143                 MASTLOG("csw_size != sizeof(csw)\n");
     136                usb_log_error("Received CSW of incorrect size.");
    144137                return EIO;
    145138        }
    146139
    147140        if (csw.dCSWTag != tag) {
    148                 MASTLOG("csw.dCSWTag != tag\n");
     141                usb_log_error("Received CSW with incorrect tag. (expected: %"
     142                    PRIX32" received: %"PRIx32, tag, csw.dCSWTag);
    149143                return EIO;
    150144        }
    … …  
    158152                break;
    159153        case cbs_failed:
    160                 MASTLOG("Command failed\n");
    161154                cmd->status = CMDS_FAILED;
     155                usb_log_error("CBS Failed.\n");
    162156                break;
    163157        case cbs_phase_error:
    164                 MASTLOG("Phase error\n");
    165                 retval = EIO;
     158                usb_log_error("CBS phase error.\n");
     159                rc = EIO;
    166160                break;
    167161        default:
    168                 retval = EIO;
    169                 break;
    170         }
    171 
    172         size_t residue = (size_t) uint32_usb2host(csw.dCSWDataResidue);
     162                usb_log_error("CBS other error.\n");
     163                rc = EIO;
     164                break;
     165        }
     166
     167        const size_t residue = uint32_usb2host(csw.dCSWDataResidue);
    173168        if (residue > dbuf_size) {
    174                 MASTLOG("residue > dbuf_size\n");
     169                usb_log_error("Residue > buffer size (%zu > %zu).\n",
     170                    residue, dbuf_size);
    175171                return EIO;
    176172        }
    … …  
    184180         */
    185181
    186         if (ddir == USB_DIRECTION_IN)
     182        if (cmd->data_in)
    187183                cmd->rcvd_size = dbuf_size - residue;
    188184
    189         return retval;
     185        return rc;
    190186}
    191187
    … …  
    197193int usb_massstor_reset(usbmast_dev_t *mdev)
    198194{
    199         return usb_control_request_set(&mdev->usb_dev->ctrl_pipe,
     195        return usb_control_request_set(
     196            usb_device_get_default_pipe(mdev->usb_dev),
    200197            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
    201             0xFF, 0, mdev->usb_dev->interface_no, NULL, 0);
     198            0xFF, 0, usb_device_get_iface_number(mdev->usb_dev), NULL, 0);
    202199}
    203200
    … …  
    215212         */
    216213        usb_massstor_reset(mdev);
    217         usb_pipe_clear_halt(&mdev->usb_dev->ctrl_pipe,
    218             &mdev->usb_dev->pipes[BULK_IN_EP].pipe);
    219         usb_pipe_clear_halt(&mdev->usb_dev->ctrl_pipe,
    220             &mdev->usb_dev->pipes[BULK_OUT_EP].pipe);
     214        usb_pipe_clear_halt(usb_device_get_default_pipe(mdev->usb_dev),
     215            mdev->bulk_in_pipe);
     216        usb_pipe_clear_halt(usb_device_get_default_pipe(mdev->usb_dev),
     217            mdev->bulk_out_pipe);
    221218}
    222219
    … …  
    236233        uint8_t max_lun;
    237234        size_t data_recv_len;
    238         int rc = usb_control_request_get(&mdev->usb_dev->ctrl_pipe,
     235        int rc = usb_control_request_get(
     236            usb_device_get_default_pipe(mdev->usb_dev),
    239237            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_INTERFACE,
    240             0xFE, 0, mdev->usb_dev->interface_no, &max_lun, 1, &data_recv_len);
     238            0xFE, 0, usb_device_get_iface_number(mdev->usb_dev), &max_lun, 1,
     239            &data_recv_len);
    241240        if (rc != EOK) {
    242241                return rc;

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

    r5b18137 rb4b534ac  
    4444#include "usbmast.h"
    4545
    46 #define BULK_IN_EP 0
    47 #define BULK_OUT_EP 1
    48 
    4946typedef enum cmd_status {
    5047        CMDS_GOOD,
    … …  
    6360
    6461        /** Command Descriptor Block */
    65         void *cdb;
     62        const void *cdb;
    6663        /** CDB size in bytes */
    6764        size_t cdb_size;

  • uspace/drv/bus/usb/usbmast/main.c

    r5b18137 rb4b534ac  
    4444#include <usb/classes/massstor.h>
    4545#include <errno.h>
     46#include <io/logctl.h>
    4647#include <str_error.h>
    4748#include "cmdw.h"
    … …  
    5152
    5253#define NAME "usbmast"
    53 
    54 #define GET_BULK_IN(dev) ((dev)->pipes[BULK_IN_EP].pipe)
    55 #define GET_BULK_OUT(dev) ((dev)->pipes[BULK_OUT_EP].pipe)
    5654
    5755static const usb_endpoint_description_t bulk_in_ep = {
    … …  
    112110static int usbmast_device_gone(usb_device_t *dev)
    113111{
    114         usbmast_dev_t *mdev = dev->driver_data;
     112        usbmast_dev_t *mdev = usb_device_data_get(dev);
    115113        assert(mdev);
    116114
    … …  
    152150        unsigned i;
    153151
     152        usb_endpoint_mapping_t *epm_in =
     153            usb_device_get_mapped_ep_desc(dev, &bulk_in_ep);
     154        usb_endpoint_mapping_t *epm_out =
     155            usb_device_get_mapped_ep_desc(dev, &bulk_out_ep);
     156        if (!epm_in || !epm_out || !epm_in->present || !epm_out->present) {
     157                usb_log_error("Required EPs were not mapped.\n");
     158                return ENOENT;
     159        }
     160
    154161        /* Allocate softstate */
    155162        mdev = usb_device_data_alloc(dev, sizeof(usbmast_dev_t));
    … …  
    159166        }
    160167
    161         mdev->ddf_dev = dev->ddf_dev;
    162168        mdev->usb_dev = dev;
    163169
    164         usb_log_info("Initializing mass storage `%s'.\n", ddf_dev_get_name(dev->ddf_dev));
     170        usb_log_info("Initializing mass storage `%s'.\n",
     171            usb_device_get_name(dev));
    165172        usb_log_debug("Bulk in endpoint: %d [%zuB].\n",
    166             dev->pipes[BULK_IN_EP].pipe.endpoint_no,
    167             dev->pipes[BULK_IN_EP].pipe.max_packet_size);
     173            epm_in->pipe.endpoint_no, epm_in->pipe.max_packet_size);
    168174        usb_log_debug("Bulk out endpoint: %d [%zuB].\n",
    169             dev->pipes[BULK_OUT_EP].pipe.endpoint_no,
    170             dev->pipes[BULK_OUT_EP].pipe.max_packet_size);
     175            epm_out->pipe.endpoint_no, epm_out->pipe.max_packet_size);
    171176
    172177        usb_log_debug("Get LUN count...\n");
    … …  
    179184        }
    180185
     186        mdev->bulk_in_pipe = &epm_in->pipe;
     187        mdev->bulk_out_pipe = &epm_out->pipe;
    181188        for (i = 0; i < mdev->lun_count; i++) {
    182189                rc = usbmast_fun_create(mdev, i);
    … …  
    223230        }
    224231
    225         fun = ddf_fun_create(mdev->ddf_dev, fun_exposed, fun_name);
     232        fun = usb_device_ddf_fun_create(mdev->usb_dev, fun_exposed, fun_name);
    226233        if (fun == NULL) {
    227234                usb_log_error("Failed to create DDF function %s.\n", fun_name);
    … …  
    254261        if (rc != EOK) {
    255262                usb_log_warning("Failed to inquire device `%s': %s.\n",
    256                     ddf_dev_get_name(mdev->ddf_dev), str_error(rc));
     263                    usb_device_get_name(mdev->usb_dev), str_error(rc));
    257264                rc = EIO;
    258265                goto error;
    … …  
    261268        usb_log_info("Mass storage `%s' LUN %u: " \
    262269            "%s by %s rev. %s is %s (%s).\n",
    263             ddf_dev_get_name(mdev->ddf_dev),
     270            usb_device_get_name(mdev->usb_dev),
    264271            lun,
    265272            inquiry.product,
    … …  
    274281        if (rc != EOK) {
    275282                usb_log_warning("Failed to read capacity, device `%s': %s.\n",
    276                     ddf_dev_get_name(mdev->ddf_dev), str_error(rc));
     283                    usb_device_get_name(mdev->usb_dev), str_error(rc));
    277284                rc = EIO;
    278285                goto error;
    … …  
    396403{
    397404        log_init(NAME);
    398 
     405        logctl_set_log_level(NAME, LVL_NOTE);
    399406        return usb_driver_main(&usbmast_driver);
    400407}

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

    r5b18137 rb4b534ac  
    6363static void usbmast_dump_sense(scsi_sense_data_t *sense_buf)
    6464{
    65         unsigned sense_key;
    66 
    67         sense_key = sense_buf->flags_key & 0x0f;
     65        const unsigned sense_key = sense_buf->flags_key & 0x0f;
    6866        printf("Got sense data. Sense key: 0x%x (%s), ASC 0x%02x, "
    6967            "ASCQ 0x%02x.\n", sense_key,
    … …  
    7371}
    7472
     73static int usb_massstor_unit_ready(usbmast_fun_t *mfun)
     74{
     75        scsi_cmd_t cmd;
     76        scsi_cdb_test_unit_ready_t cdb;
     77        int rc;
     78
     79        memset(&cdb, 0, sizeof(cdb));
     80        cdb.op_code = SCSI_CMD_TEST_UNIT_READY;
     81
     82        memset(&cmd, 0, sizeof(cmd));
     83        cmd.cdb = &cdb;
     84        cmd.cdb_size = sizeof(cdb);
     85
     86        rc = usb_massstor_cmd(mfun, 0xDEADBEEF, &cmd);
     87
     88        if (rc != EOK) {
     89                usb_log_error("Test Unit Ready failed on device %s: %s.",
     90                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
     91                return rc;
     92        }
     93        /* Ignore command error here. If there's something wrong
     94         * with the device the following commands will fail too.
     95         */
     96        if (cmd.status != CMDS_GOOD)
     97                usb_log_warning("Test Unit Ready command failed on device %s.",
     98                   usb_device_get_name(mfun->mdev->usb_dev));
     99
     100        return EOK;
     101}
     102
    75103/** Run SCSI command.
    76104 *
    … …  
    85113
    86114        do {
     115                rc = usb_massstor_unit_ready(mfun);
     116                if (rc != EOK) {
     117                        usb_log_error("Inquiry transport failed, device %s: %s.\n",
     118                           usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
     119                        return rc;
     120                }
     121
    87122                rc = usb_massstor_cmd(mfun, 0xDEADBEEF, cmd);
    88123                if (rc != EOK) {
    89124                        usb_log_error("Inquiry transport failed, device %s: %s.\n",
    90                            ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     125                           usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    91126                        return rc;
    92127                }
    … …  
    96131
    97132                usb_log_error("SCSI command failed, device %s.\n",
    98                     ddf_dev_get_name(mfun->mdev->ddf_dev));
     133                    usb_device_get_name(mfun->mdev->usb_dev));
    99134
    100135                rc = usbmast_request_sense(mfun, &sense_buf, sizeof(sense_buf));
    … …  
    147182        if (rc != EOK) {
    148183                usb_log_error("Inquiry transport failed, device %s: %s.\n",
    149                    ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     184                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    150185                return rc;
    151186        }
    … …  
    153188        if (cmd.status != CMDS_GOOD) {
    154189                usb_log_error("Inquiry command failed, device %s.\n",
    155                    ddf_dev_get_name(mfun->mdev->ddf_dev));
     190                   usb_device_get_name(mfun->mdev->usb_dev));
    156191                return EIO;
    157192        }
    … …  
    215250        if (rc != EOK || cmd.status != CMDS_GOOD) {
    216251                usb_log_error("Request Sense failed, device %s: %s.\n",
    217                    ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     252                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    218253                return rc;
    219254        }
    … …  
    257292        if (rc != EOK) {
    258293                usb_log_error("Read Capacity (10) transport failed, device %s: %s.\n",
    259                    ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     294                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    260295                return rc;
    261296        }
    … …  
    263298        if (cmd.status != CMDS_GOOD) {
    264299                usb_log_error("Read Capacity (10) command failed, device %s.\n",
    265                    ddf_dev_get_name(mfun->mdev->ddf_dev));
     300                   usb_device_get_name(mfun->mdev->usb_dev));
    266301                return EIO;
    267302        }
    … …  
    314349        if (rc != EOK) {
    315350                usb_log_error("Read (10) transport failed, device %s: %s.\n",
    316                    ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     351                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    317352                return rc;
    318353        }
    … …  
    320355        if (cmd.status != CMDS_GOOD) {
    321356                usb_log_error("Read (10) command failed, device %s.\n",
    322                    ddf_dev_get_name(mfun->mdev->ddf_dev));
     357                   usb_device_get_name(mfun->mdev->usb_dev));
    323358                return EIO;
    324359        }
    … …  
    370405        if (rc != EOK) {
    371406                usb_log_error("Write (10) transport failed, device %s: %s.\n",
    372                    ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     407                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    373408                return rc;
    374409        }
    … …  
    376411        if (cmd.status != CMDS_GOOD) {
    377412                usb_log_error("Write (10) command failed, device %s.\n",
    378                    ddf_dev_get_name(mfun->mdev->ddf_dev));
     413                   usb_device_get_name(mfun->mdev->usb_dev));
    379414                return EIO;
    380415        }
    … …  
    394429int usbmast_sync_cache(usbmast_fun_t *mfun, uint64_t ba, size_t nblocks)
    395430{
    396         scsi_cmd_t cmd;
    397         scsi_cdb_sync_cache_10_t cdb;
    398         int rc;
    399 
    400431        if (ba > UINT32_MAX)
    401432                return ELIMIT;
    … …  
    404435                return ELIMIT;
    405436
    406         memset(&cdb, 0, sizeof(cdb));
    407         cdb.op_code = SCSI_CMD_SYNC_CACHE_10;
    408         cdb.lba = host2uint32_t_be(ba);
    409         cdb.numlb = host2uint16_t_be(nblocks);
    410 
    411         memset(&cmd, 0, sizeof(cmd));
    412         cmd.cdb = &cdb;
    413         cmd.cdb_size = sizeof(cdb);
    414 
    415         rc = usbmast_run_cmd(mfun, &cmd);
     437        const scsi_cdb_sync_cache_10_t cdb = {
     438                .op_code = SCSI_CMD_SYNC_CACHE_10,
     439                .lba = host2uint32_t_be(ba),
     440                .numlb = host2uint16_t_be(nblocks),
     441        };
     442
     443        scsi_cmd_t cmd = {
     444                .cdb = &cdb,
     445                .cdb_size = sizeof(cdb),
     446        };
     447
     448        const int rc = usbmast_run_cmd(mfun, &cmd);
    416449
    417450        if (rc != EOK) {
    418451                usb_log_error("Synchronize Cache (10) transport failed, device %s: %s.\n",
    419                    ddf_dev_get_name(mfun->mdev->ddf_dev), str_error(rc));
     452                   usb_device_get_name(mfun->mdev->usb_dev), str_error(rc));
    420453                return rc;
    421454        }
    … …  
    423456        if (cmd.status != CMDS_GOOD) {
    424457                usb_log_error("Synchronize Cache (10) command failed, device %s.\n",
    425                    ddf_dev_get_name(mfun->mdev->ddf_dev));
     458                   usb_device_get_name(mfun->mdev->usb_dev));
    426459                return EIO;
    427460        }

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

    r5b18137 rb4b534ac  
    4343/** Mass storage device. */
    4444typedef struct usbmast_dev {
    45         /** DDF device */
    46         ddf_dev_t *ddf_dev;
    4745        /** USB device */
    4846        usb_device_t *usb_dev;
    … …  
    5149        /** LUN functions */
    5250        ddf_fun_t **luns;
     51        /** Data read pipe */
     52        usb_pipe_t *bulk_in_pipe;
     53        /** Data write pipe */
     54        usb_pipe_t *bulk_out_pipe;
    5355} usbmast_dev_t;
    5456
Note: See TracChangeset for help on using the changeset viewer.