Archipelago » qemu

#include "hw.h"

#include "qemu-error.h"

#include "scsi.h"

#include "scsi-defs.h"

#include "qdev.h"

#include "blockdev.h"

#include "trace.h"

static char *scsibus_get_fw_dev_path(DeviceState *dev);

static int scsi_req_parse(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf);

static void scsi_req_dequeue(SCSIRequest *req);

static struct BusInfo scsi_bus_info = {

    .name  = "SCSI",

    .size  = sizeof(SCSIBus),

    .get_fw_dev_path = scsibus_get_fw_dev_path,

    .props = (Property[]) {

        DEFINE_PROP_UINT32("channel", SCSIDevice, channel, 0),

        DEFINE_PROP_UINT32("scsi-id", SCSIDevice, id, -1),

        DEFINE_PROP_UINT32("lun", SCSIDevice, lun, -1),

        DEFINE_PROP_END_OF_LIST(),

    },

};

static int next_scsi_bus;

static int scsi_device_init(SCSIDevice *s)

{

    SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);

    if (sc->init) {

        return sc->init(s);

    }

    return 0;

}

static void scsi_device_destroy(SCSIDevice *s)

{

    SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);

    if (sc->destroy) {

        sc->destroy(s);

    }

}

static SCSIRequest *scsi_device_alloc_req(SCSIDevice *s, uint32_t tag, uint32_t lun,

                                          uint8_t *buf, void *hba_private)

{

    SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);

    if (sc->alloc_req) {

        return sc->alloc_req(s, tag, lun, buf, hba_private);

    }

    return NULL;

}

static void scsi_device_unit_attention_reported(SCSIDevice *s)

{

    SCSIDeviceClass *sc = SCSI_DEVICE_GET_CLASS(s);

    if (sc->unit_attention_reported) {

        sc->unit_attention_reported(s);

    }

}

/* Create a scsi bus, and attach devices to it.  */

void scsi_bus_new(SCSIBus *bus, DeviceState *host, const SCSIBusInfo *info)

{

    qbus_create_inplace(&bus->qbus, &scsi_bus_info, host, NULL);

    bus->busnr = next_scsi_bus++;

    bus->info = info;

    bus->qbus.allow_hotplug = 1;

}

static void scsi_dma_restart_bh(void *opaque)

{

    SCSIDevice *s = opaque;

    SCSIRequest *req, *next;

    qemu_bh_delete(s->bh);

    s->bh = NULL;

    QTAILQ_FOREACH_SAFE(req, &s->requests, next, next) {

        scsi_req_ref(req);

        if (req->retry) {

            req->retry = false;

            switch (req->cmd.mode) {

            case SCSI_XFER_FROM_DEV:

            case SCSI_XFER_TO_DEV:

                scsi_req_continue(req);

                break;

            case SCSI_XFER_NONE:

                scsi_req_dequeue(req);

                scsi_req_enqueue(req);

                break;

            }

        }

        scsi_req_unref(req);

    }

}

void scsi_req_retry(SCSIRequest *req)

{

    /* No need to save a reference, because scsi_dma_restart_bh just

     * looks at the request list.  */

    req->retry = true;

}

static void scsi_dma_restart_cb(void *opaque, int running, RunState state)

{

    SCSIDevice *s = opaque;

    if (!running) {

        return;

    }

    if (!s->bh) {

        s->bh = qemu_bh_new(scsi_dma_restart_bh, s);

        qemu_bh_schedule(s->bh);

    }

}

static int scsi_qdev_init(DeviceState *qdev)

{

    SCSIDevice *dev = SCSI_DEVICE(qdev);

    SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);

    SCSIDevice *d;

    int rc = -1;

    if (dev->channel > bus->info->max_channel) {

        error_report("bad scsi channel id: %d", dev->channel);

        goto err;

    }

    if (dev->id != -1 && dev->id > bus->info->max_target) {

        error_report("bad scsi device id: %d", dev->id);

        goto err;

    }

    if (dev->id == -1) {

        int id = -1;

        if (dev->lun == -1) {

            dev->lun = 0;

        }

        do {

            d = scsi_device_find(bus, dev->channel, ++id, dev->lun);

        } while (d && d->lun == dev->lun && id <= bus->info->max_target);

        if (id > bus->info->max_target) {

            error_report("no free target");

            goto err;

        }

        dev->id = id;

    } else if (dev->lun == -1) {

        int lun = -1;

        do {

            d = scsi_device_find(bus, dev->channel, dev->id, ++lun);

        } while (d && d->lun == lun && lun < bus->info->max_lun);

        if (lun > bus->info->max_lun) {

            error_report("no free lun");

            goto err;

        }

        dev->lun = lun;

    } else {

        d = scsi_device_find(bus, dev->channel, dev->id, dev->lun);

        if (dev->lun == d->lun && dev != d) {

            qdev_free(&d->qdev);

        }

    }

    QTAILQ_INIT(&dev->requests);

    rc = scsi_device_init(dev);

    if (rc == 0) {

        dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,

                                                         dev);

    }

err:

    return rc;

}

static int scsi_qdev_exit(DeviceState *qdev)

{

    SCSIDevice *dev = SCSI_DEVICE(qdev);

    if (dev->vmsentry) {

        qemu_del_vm_change_state_handler(dev->vmsentry);

    }

    scsi_device_destroy(dev);

    return 0;

}

/* handle legacy '-drive if=scsi,...' cmd line args */

SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv,

                                      int unit, bool removable, int bootindex)

{

    const char *driver;

    DeviceState *dev;

    driver = bdrv_is_sg(bdrv) ? "scsi-generic" : "scsi-disk";

    dev = qdev_create(&bus->qbus, driver);

    qdev_prop_set_uint32(dev, "scsi-id", unit);

    if (bootindex >= 0) {

        qdev_prop_set_int32(dev, "bootindex", bootindex);

    }

    if (qdev_prop_exists(dev, "removable")) {

        qdev_prop_set_bit(dev, "removable", removable);

    }

    if (qdev_prop_set_drive(dev, "drive", bdrv) < 0) {

        qdev_free(dev);

        return NULL;

    }

    if (qdev_init(dev) < 0)

        return NULL;

    return SCSI_DEVICE(dev);

}

int scsi_bus_legacy_handle_cmdline(SCSIBus *bus)

{

    Location loc;

    DriveInfo *dinfo;

    int res = 0, unit;

    loc_push_none(&loc);

    for (unit = 0; unit < bus->info->max_target; unit++) {

        dinfo = drive_get(IF_SCSI, bus->busnr, unit);

        if (dinfo == NULL) {

            continue;

        }

        qemu_opts_loc_restore(dinfo->opts);

        if (!scsi_bus_legacy_add_drive(bus, dinfo->bdrv, unit, false, -1)) {

            res = -1;

            break;

        }

    }

    loc_pop(&loc);

    return res;

}

/* SCSIReqOps implementation for invalid commands.  */

static int32_t scsi_invalid_command(SCSIRequest *req, uint8_t *buf)

{

    scsi_req_build_sense(req, SENSE_CODE(INVALID_OPCODE));

    scsi_req_complete(req, CHECK_CONDITION);

    return 0;

}

static const struct SCSIReqOps reqops_invalid_opcode = {

    .size         = sizeof(SCSIRequest),

    .send_command = scsi_invalid_command

};

/* SCSIReqOps implementation for unit attention conditions.  */

static int32_t scsi_unit_attention(SCSIRequest *req, uint8_t *buf)

{

    if (req->dev && req->dev->unit_attention.key == UNIT_ATTENTION) {

        scsi_req_build_sense(req, req->dev->unit_attention);

    } else if (req->bus->unit_attention.key == UNIT_ATTENTION) {

        scsi_req_build_sense(req, req->bus->unit_attention);

    }

    scsi_req_complete(req, CHECK_CONDITION);

    return 0;

}

static const struct SCSIReqOps reqops_unit_attention = {

    .size         = sizeof(SCSIRequest),

    .send_command = scsi_unit_attention

};

/* SCSIReqOps implementation for REPORT LUNS and for commands sent to

   an invalid LUN.  */

typedef struct SCSITargetReq SCSITargetReq;

struct SCSITargetReq {

    SCSIRequest req;

    int len;

    uint8_t buf[2056];

};

static void store_lun(uint8_t *outbuf, int lun)

{

    if (lun < 256) {

        outbuf[1] = lun;

        return;

    }

    outbuf[1] = (lun & 255);

    outbuf[0] = (lun >> 8) | 0x40;

}

static bool scsi_target_emulate_report_luns(SCSITargetReq *r)

{

    DeviceState *qdev;

    int i, len, n;

    int channel, id;

    bool found_lun0;

    if (r->req.cmd.xfer < 16) {

        return false;

    }

    if (r->req.cmd.buf[2] > 2) {

        return false;

    }

    channel = r->req.dev->channel;

    id = r->req.dev->id;

    found_lun0 = false;

    n = 0;

    QTAILQ_FOREACH(qdev, &r->req.bus->qbus.children, sibling) {

        SCSIDevice *dev = SCSI_DEVICE(qdev);

        if (dev->channel == channel && dev->id == id) {

            if (dev->lun == 0) {

                found_lun0 = true;

            }

            n += 8;

        }

    }

    if (!found_lun0) {

        n += 8;

    }

    len = MIN(n + 8, r->req.cmd.xfer & ~7);

    if (len > sizeof(r->buf)) {

        /* TODO: > 256 LUNs? */

        return false;

    }

    memset(r->buf, 0, len);

    stl_be_p(&r->buf, n);

    i = found_lun0 ? 8 : 16;

    QTAILQ_FOREACH(qdev, &r->req.bus->qbus.children, sibling) {

        SCSIDevice *dev = SCSI_DEVICE(qdev);

        if (dev->channel == channel && dev->id == id) {

            store_lun(&r->buf[i], dev->lun);

            i += 8;

        }

    }

    assert(i == n + 8);

    r->len = len;

    return true;

}

static bool scsi_target_emulate_inquiry(SCSITargetReq *r)

{

    assert(r->req.dev->lun != r->req.lun);

    if (r->req.cmd.buf[1] & 0x2) {

        /* Command support data - optional, not implemented */

        return false;

    }

    if (r->req.cmd.buf[1] & 0x1) {

        /* Vital product data */

        uint8_t page_code = r->req.cmd.buf[2];

        if (r->req.cmd.xfer < 4) {

            return false;

        }

        r->buf[r->len++] = page_code ; /* this page */

        r->buf[r->len++] = 0x00;

        switch (page_code) {

        case 0x00: /* Supported page codes, mandatory */

        {

            int pages;

            pages = r->len++;

            r->buf[r->len++] = 0x00; /* list of supported pages (this page) */

            r->buf[pages] = r->len - pages - 1; /* number of pages */

            break;

        }

        default:

            return false;

        }

        /* done with EVPD */

        assert(r->len < sizeof(r->buf));

        r->len = MIN(r->req.cmd.xfer, r->len);

        return true;

    }

    /* Standard INQUIRY data */

    if (r->req.cmd.buf[2] != 0) {

        return false;

    }

    /* PAGE CODE == 0 */

    if (r->req.cmd.xfer < 5) {

        return -1;

    }

    r->len = MIN(r->req.cmd.xfer, 36);

    memset(r->buf, 0, r->len);

    if (r->req.lun != 0) {

        r->buf[0] = TYPE_NO_LUN;

    } else {

        r->buf[0] = TYPE_NOT_PRESENT | TYPE_INACTIVE;

        r->buf[2] = 5; /* Version */

        r->buf[3] = 2 | 0x10; /* HiSup, response data format */

        r->buf[4] = r->len - 5; /* Additional Length = (Len - 1) - 4 */

        r->buf[7] = 0x10 | (r->req.bus->info->tcq ? 0x02 : 0); /* Sync, TCQ.  */

        memcpy(&r->buf[8], "QEMU    ", 8);

        memcpy(&r->buf[16], "QEMU TARGET     ", 16);

        strncpy((char *) &r->buf[32], QEMU_VERSION, 4);

    }

    return true;

}

static int32_t scsi_target_send_command(SCSIRequest *req, uint8_t *buf)

{

    SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req);

    switch (buf[0]) {

    case REPORT_LUNS:

        if (!scsi_target_emulate_report_luns(r)) {

            goto illegal_request;

        }

        break;

    case INQUIRY:

        if (!scsi_target_emulate_inquiry(r)) {

            goto illegal_request;

        }

        break;

    case REQUEST_SENSE:

        if (req->cmd.xfer < 4) {

            goto illegal_request;

        }

        r->len = scsi_device_get_sense(r->req.dev, r->buf,

                                       MIN(req->cmd.xfer, sizeof r->buf),

                                       (req->cmd.buf[1] & 1) == 0);

        if (r->req.dev->sense_is_ua) {

            scsi_device_unit_attention_reported(req->dev);

            r->req.dev->sense_len = 0;

            r->req.dev->sense_is_ua = false;

        }

        break;

    default:

        scsi_req_build_sense(req, SENSE_CODE(LUN_NOT_SUPPORTED));

        scsi_req_complete(req, CHECK_CONDITION);

        return 0;

    illegal_request:

        scsi_req_build_sense(req, SENSE_CODE(INVALID_FIELD));

        scsi_req_complete(req, CHECK_CONDITION);

        return 0;

    }

    if (!r->len) {

        scsi_req_complete(req, GOOD);

    }

    return r->len;

}

static void scsi_target_read_data(SCSIRequest *req)

{

    SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req);

    uint32_t n;

    n = r->len;

    if (n > 0) {

        r->len = 0;

        scsi_req_data(&r->req, n);

    } else {

        scsi_req_complete(&r->req, GOOD);

    }

}

static uint8_t *scsi_target_get_buf(SCSIRequest *req)

{

    SCSITargetReq *r = DO_UPCAST(SCSITargetReq, req, req);

    return r->buf;

}

static const struct SCSIReqOps reqops_target_command = {

    .size         = sizeof(SCSITargetReq),

    .send_command = scsi_target_send_command,

    .read_data    = scsi_target_read_data,

    .get_buf      = scsi_target_get_buf,

};

SCSIRequest *scsi_req_alloc(const SCSIReqOps *reqops, SCSIDevice *d,

                            uint32_t tag, uint32_t lun, void *hba_private)

{

    SCSIRequest *req;

    req = g_malloc0(reqops->size);

    req->refcount = 1;

    req->bus = scsi_bus_from_device(d);

    req->dev = d;

    req->tag = tag;

    req->lun = lun;

    req->hba_private = hba_private;

    req->status = -1;

    req->sense_len = 0;

    req->ops = reqops;

    trace_scsi_req_alloc(req->dev->id, req->lun, req->tag);

    return req;

}

SCSIRequest *scsi_req_new(SCSIDevice *d, uint32_t tag, uint32_t lun,

                          uint8_t *buf, void *hba_private)

{

    SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, d->qdev.parent_bus);

    SCSIRequest *req;

    SCSICommand cmd;

    if (scsi_req_parse(&cmd, d, buf) != 0) {

        trace_scsi_req_parse_bad(d->id, lun, tag, buf[0]);

        req = scsi_req_alloc(&reqops_invalid_opcode, d, tag, lun, hba_private);

    } else {

        trace_scsi_req_parsed(d->id, lun, tag, buf[0],

                              cmd.mode, cmd.xfer);

        if (cmd.lba != -1) {

            trace_scsi_req_parsed_lba(d->id, lun, tag, buf[0],

                                      cmd.lba);

        }

        if ((d->unit_attention.key == UNIT_ATTENTION ||

             bus->unit_attention.key == UNIT_ATTENTION) &&

            (buf[0] != INQUIRY &&

             buf[0] != REPORT_LUNS &&

             buf[0] != GET_CONFIGURATION &&

             buf[0] != GET_EVENT_STATUS_NOTIFICATION &&

             /*

              * If we already have a pending unit attention condition,

              * report this one before triggering another one.

              */

             !(buf[0] == REQUEST_SENSE && d->sense_is_ua))) {

            req = scsi_req_alloc(&reqops_unit_attention, d, tag, lun,

                                 hba_private);

        } else if (lun != d->lun ||

            buf[0] == REPORT_LUNS ||

            (buf[0] == REQUEST_SENSE && (d->sense_len || cmd.xfer < 4))) {

            req = scsi_req_alloc(&reqops_target_command, d, tag, lun,

                                 hba_private);

        } else {

            req = scsi_device_alloc_req(d, tag, lun, buf, hba_private);

        }

    }

    req->cmd = cmd;

    switch (buf[0]) {

    case INQUIRY:

        trace_scsi_inquiry(d->id, lun, tag, cmd.buf[1], cmd.buf[2]);

        break;

    case TEST_UNIT_READY:

        trace_scsi_test_unit_ready(d->id, lun, tag);

        break;

    case REPORT_LUNS:

        trace_scsi_report_luns(d->id, lun, tag);

        break;

    case REQUEST_SENSE:

        trace_scsi_request_sense(d->id, lun, tag);

        break;

    default:

        break;

    }

    return req;

}

uint8_t *scsi_req_get_buf(SCSIRequest *req)

{

    return req->ops->get_buf(req);

}

static void scsi_clear_unit_attention(SCSIRequest *req)

{

    SCSISense *ua;

    if (req->dev->unit_attention.key != UNIT_ATTENTION &&

        req->bus->unit_attention.key != UNIT_ATTENTION) {

        return;

    }

    /*

     * If an INQUIRY command enters the enabled command state,

     * the device server shall [not] clear any unit attention condition;

     * See also MMC-6, paragraphs 6.5 and 6.6.2.

     */

    if (req->cmd.buf[0] == INQUIRY ||

        req->cmd.buf[0] == GET_CONFIGURATION ||

        req->cmd.buf[0] == GET_EVENT_STATUS_NOTIFICATION) {

        return;

    }

    if (req->dev->unit_attention.key == UNIT_ATTENTION) {

        ua = &req->dev->unit_attention;

    } else {

        ua = &req->bus->unit_attention;

    }

    /*

     * If a REPORT LUNS command enters the enabled command state, [...]

     * the device server shall clear any pending unit attention condition

     * with an additional sense code of REPORTED LUNS DATA HAS CHANGED.

     */

    if (req->cmd.buf[0] == REPORT_LUNS &&

        !(ua->asc == SENSE_CODE(REPORTED_LUNS_CHANGED).asc &&

          ua->ascq == SENSE_CODE(REPORTED_LUNS_CHANGED).ascq)) {

        return;

    }

    *ua = SENSE_CODE(NO_SENSE);

}

int scsi_req_get_sense(SCSIRequest *req, uint8_t *buf, int len)

{

    int ret;

    assert(len >= 14);

    if (!req->sense_len) {

        return 0;

    }

    ret = scsi_build_sense(req->sense, req->sense_len, buf, len, true);

    /*

     * FIXME: clearing unit attention conditions upon autosense should be done

     * only if the UA_INTLCK_CTRL field in the Control mode page is set to 00b

     * (SAM-5, 5.14).

     *

     * We assume UA_INTLCK_CTRL to be 00b for HBAs that support autosense, and

     * 10b for HBAs that do not support it (do not call scsi_req_get_sense).

     * Here we handle unit attention clearing for UA_INTLCK_CTRL == 00b.

     */

    if (req->dev->sense_is_ua) {

        scsi_device_unit_attention_reported(req->dev);

        req->dev->sense_len = 0;

        req->dev->sense_is_ua = false;

    }

    return ret;

}

int scsi_device_get_sense(SCSIDevice *dev, uint8_t *buf, int len, bool fixed)

{

    return scsi_build_sense(dev->sense, dev->sense_len, buf, len, fixed);

}

void scsi_req_build_sense(SCSIRequest *req, SCSISense sense)

{

    trace_scsi_req_build_sense(req->dev->id, req->lun, req->tag,

                               sense.key, sense.asc, sense.ascq);

    memset(req->sense, 0, 18);

    req->sense[0] = 0xf0;

    req->sense[2] = sense.key;

    req->sense[7] = 10;

    req->sense[12] = sense.asc;

    req->sense[13] = sense.ascq;

    req->sense_len = 18;

}

int32_t scsi_req_enqueue(SCSIRequest *req)

{

    int32_t rc;

    assert(!req->enqueued);

    scsi_req_ref(req);

    req->enqueued = true;

    QTAILQ_INSERT_TAIL(&req->dev->requests, req, next);

    scsi_req_ref(req);

    rc = req->ops->send_command(req, req->cmd.buf);

    scsi_req_unref(req);

    return rc;

}

static void scsi_req_dequeue(SCSIRequest *req)

{

    trace_scsi_req_dequeue(req->dev->id, req->lun, req->tag);

    req->retry = false;

    if (req->enqueued) {

        QTAILQ_REMOVE(&req->dev->requests, req, next);

        req->enqueued = false;

        scsi_req_unref(req);

    }

}

static int scsi_get_performance_length(int num_desc, int type, int data_type)

{

    /* MMC-6, paragraph 6.7.  */

    switch (type) {

    case 0:

        if ((data_type & 3) == 0) {

            /* Each descriptor is as in Table 295 - Nominal performance.  */

            return 16 * num_desc + 8;

        } else {

            /* Each descriptor is as in Table 296 - Exceptions.  */

            return 6 * num_desc + 8;

        }

    case 1:

    case 4:

    case 5:

        return 8 * num_desc + 8;

    case 2:

        return 2048 * num_desc + 8;

    case 3:

        return 16 * num_desc + 8;

    default:

        return 8;

    }

}

static int scsi_req_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)

{

    switch (buf[0] >> 5) {

    case 0:

        cmd->xfer = buf[4];

        cmd->len = 6;

        /* length 0 means 256 blocks */

        if (cmd->xfer == 0) {

            cmd->xfer = 256;

        }

        break;

    case 1:

    case 2:

        cmd->xfer = lduw_be_p(&buf[7]);

        cmd->len = 10;

        break;

    case 4:

        cmd->xfer = ldl_be_p(&buf[10]) & 0xffffffffULL;

        cmd->len = 16;

        break;

    case 5:

        cmd->xfer = ldl_be_p(&buf[6]) & 0xffffffffULL;

        cmd->len = 12;

        break;

    default:

        return -1;

    }

    switch (buf[0]) {

    case TEST_UNIT_READY:

    case REWIND:

    case START_STOP:

    case SET_CAPACITY:

    case WRITE_FILEMARKS:

    case WRITE_FILEMARKS_16:

    case SPACE:

    case RESERVE:

    case RELEASE:

    case ERASE:

    case ALLOW_MEDIUM_REMOVAL:

    case VERIFY_10:

    case SEEK_10:

    case SYNCHRONIZE_CACHE:

    case SYNCHRONIZE_CACHE_16:

    case LOCATE_16:

    case LOCK_UNLOCK_CACHE:

    case LOAD_UNLOAD:

    case SET_CD_SPEED:

    case SET_LIMITS:

    case WRITE_LONG_10:

    case MOVE_MEDIUM:

    case UPDATE_BLOCK:

    case RESERVE_TRACK:

    case SET_READ_AHEAD:

    case PRE_FETCH:

    case PRE_FETCH_16:

    case ALLOW_OVERWRITE:

        cmd->xfer = 0;

        break;

    case MODE_SENSE:

        break;

    case WRITE_SAME_10:

        cmd->xfer = 1;

        break;

    case READ_CAPACITY_10:

        cmd->xfer = 8;

        break;

    case READ_BLOCK_LIMITS:

        cmd->xfer = 6;

        break;

    case SEND_VOLUME_TAG:

        /* GPCMD_SET_STREAMING from multimedia commands.  */

        if (dev->type == TYPE_ROM) {

            cmd->xfer = buf[10] | (buf[9] << 8);

        } else {

            cmd->xfer = buf[9] | (buf[8] << 8);

        }

        break;

    case WRITE_10:

    case WRITE_VERIFY_10:

    case WRITE_6:

    case WRITE_12:

    case WRITE_VERIFY_12:

    case WRITE_16:

    case WRITE_VERIFY_16:

        cmd->xfer *= dev->blocksize;

        break;

    case READ_10:

    case READ_6:

    case READ_REVERSE:

    case RECOVER_BUFFERED_DATA:

    case READ_12:

    case READ_16:

        cmd->xfer *= dev->blocksize;

        break;

    case FORMAT_UNIT:

        /* MMC mandates the parameter list to be 12-bytes long.  Parameters

         * for block devices are restricted to the header right now.  */

        if (dev->type == TYPE_ROM && (buf[1] & 16)) {

            cmd->xfer = 12;

        } else {

            cmd->xfer = (buf[1] & 16) == 0 ? 0 : (buf[1] & 32 ? 8 : 4);

        }

        break;

    case INQUIRY:

    case RECEIVE_DIAGNOSTIC:

    case SEND_DIAGNOSTIC:

        cmd->xfer = buf[4] | (buf[3] << 8);

        break;

    case READ_CD:

    case READ_BUFFER:

    case WRITE_BUFFER:

    case SEND_CUE_SHEET:

        cmd->xfer = buf[8] | (buf[7] << 8) | (buf[6] << 16);

        break;

    case PERSISTENT_RESERVE_OUT:

        cmd->xfer = ldl_be_p(&buf[5]) & 0xffffffffULL;

        break;

    case ERASE_12:

        if (dev->type == TYPE_ROM) {

            /* MMC command GET PERFORMANCE.  */

            cmd->xfer = scsi_get_performance_length(buf[9] | (buf[8] << 8),

                                                    buf[10], buf[1] & 0x1f);

        }

        break;

    case MECHANISM_STATUS:

    case READ_DVD_STRUCTURE:

    case SEND_DVD_STRUCTURE:

    case MAINTENANCE_OUT:

    case MAINTENANCE_IN:

        if (dev->type == TYPE_ROM) {

            /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */

            cmd->xfer = buf[9] | (buf[8] << 8);

        }

        break;

    }

    return 0;

}

static int scsi_req_stream_length(SCSICommand *cmd, SCSIDevice *dev, uint8_t *buf)

{

    switch (buf[0]) {

    /* stream commands */

    case ERASE_12:

    case ERASE_16:

        cmd->xfer = 0;

        break;

    case READ_6:

    case READ_REVERSE:

    case RECOVER_BUFFERED_DATA:

    case WRITE_6:

        cmd->len = 6;

        cmd->xfer = buf[4] | (buf[3] << 8) | (buf[2] << 16);

        if (buf[1] & 0x01) { /* fixed */

            cmd->xfer *= dev->blocksize;

        }

        break;

    case REWIND:

    case START_STOP:

        cmd->len = 6;

        cmd->xfer = 0;

        break;

    case SPACE_16:

        cmd->xfer = buf[13] | (buf[12] << 8);

        break;

    case READ_POSITION:

        cmd->xfer = buf[8] | (buf[7] << 8);

        break;

    case FORMAT_UNIT:

        cmd->xfer = buf[4] | (buf[3] << 8);

        break;

    /* generic commands */

    default:

        return scsi_req_length(cmd, dev, buf);

    }

    return 0;

}

static void scsi_cmd_xfer_mode(SCSICommand *cmd)

{

    switch (cmd->buf[0]) {

    case WRITE_6:

    case WRITE_10:

    case WRITE_VERIFY_10:

    case WRITE_12:

    case WRITE_VERIFY_12:

    case WRITE_16:

    case WRITE_VERIFY_16:

    case COPY:

    case COPY_VERIFY:

    case COMPARE:

    case CHANGE_DEFINITION:

    case LOG_SELECT:

    case MODE_SELECT:

    case MODE_SELECT_10: