Archipelago » qemu

    uint32_t dma;

    SCSIBus bus;

    SCSIDevice *current_dev;

    uint8_t cmdbuf[TI_BUFSZ];

    uint32_t cmdlen;

    uint32_t do_cmd;

    if (s->current_dev) {

        /* Started a new command before the old one finished.  Cancel it.  */

        s->async_len = 0;

    }

    DPRINTF("do_busid_cmd: busid 0x%x\n", busid);

    lun = busid & 7;

    s->ti_size = datalen;

    if (datalen != 0) {

        s->rregs[ESP_RSTAT] = STAT_TC;

        s->dma_counter = 0;

        if (datalen > 0) {

            s->rregs[ESP_RSTAT] |= STAT_DI;

        } else {

            s->rregs[ESP_RSTAT] |= STAT_DO;

        }

    }

    s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;

    if (s->async_len == 0) {

        if (to_device) {

            // ti_size is negative

        } else {

            /* If there is still data to be read from the device then

               complete the DMA operation immediately.  Otherwise defer

               until the scsi layer has completed.  */

    }

}

{

    if (reason == SCSI_REASON_DONE) {

        DPRINTF("SCSI Command complete\n");

        s->sense = arg;

        s->rregs[ESP_RSTAT] = STAT_ST;

        esp_dma_done(s);

    } else {

        DPRINTF("transfer %d/%d\n", s->dma_left, s->ti_size);

        s->async_len = arg;

        if (s->dma_left) {

            esp_do_dma(s);

        } else if (s->dma_counter != 0 && s->ti_size <= 0) {

#define LSI_TAG_VALID     (1 << 16)

typedef struct lsi_request {

    uint32_t tag;

    uint32_t dma_len;

    uint8_t *dma_buf;

    s->csbc += count;

    s->dnad += count;

    s->dbc -= count;

    }

    /* ??? Set SFBR to first data byte.  */

    if (out) {

        cpu_physical_memory_read(addr, s->current->dma_buf, count);

        s->current->dma_buf = NULL;

        if (out) {

            /* Write the data.  */

        } else {

            /* Request any remaining data.  */

        }

    } else {

        s->current->dma_buf += count;

        return 1;

    }

}

{

    int out;

    out = (s->sstat1 & PHASE_MASK) == PHASE_DO;

            lsi_set_phase(s, PHASE_ST);

        }

        lsi_resume_script(s);

        return;

    }

        (lsi_irq_on_rsl(s) && !(s->scntl1 & LSI_SCNTL1_CON))) {

            return;

    }

    /* host adapter (re)connected */

    s->current->dma_len = arg;

    s->command_complete = 1;

    if (!s->waiting)

    assert(s->current == NULL);

    s->current = qemu_mallocz(sizeof(lsi_request));

    s->current->tag = s->select_tag;

    if (n > 0) {

        lsi_set_phase(s, PHASE_DI);

    } else if (n < 0) {

        lsi_set_phase(s, PHASE_DO);

    }

    if (!s->command_complete) {

    int len;

    uint32_t current_tag;

    SCSIDevice *current_dev;

    int id;

    if (s->current) {

        current_tag = s->current->tag;

    } else {

        current_tag = s->select_tag;

    }

    id = (current_tag >> 8) & 0xf;

    current_dev = s->bus.devs[id];

        case 0x0d:

            /* The ABORT TAG message clears the current I/O process only. */

            DPRINTF("MSG: ABORT TAG tag=0x%x\n", current_tag);

            lsi_disconnect(s);

            break;

        case 0x06:

            }

            /* clear the current I/O process */

            /* As the current implemented devices scsi_disk and scsi_generic

               only support one LUN, we don't need to keep track of LUNs.

            id = current_tag & 0x0000ff00;

            QTAILQ_FOREACH_SAFE(p, &s->queue, next, p_next) {

                if ((p->tag & 0x0000ff00) == id) {

                    QTAILQ_REMOVE(&s->queue, p, next);

                }

            }

    SCSIRequest *req;

    req = qemu_mallocz(size);

    req->bus = scsi_bus_from_device(d);

    req->dev = d;

    req->tag = tag;

    req->lun = lun;

    req->status = -1;

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

    return req;

}

{

}

void scsi_req_dequeue(SCSIRequest *req)

void scsi_req_data(SCSIRequest *req, int len)

{

    trace_scsi_req_data(req->dev->id, req->lun, req->tag, len);

}

void scsi_req_print(SCSIRequest *req)

    assert(req->status != -1);

    scsi_req_ref(req);

    scsi_req_dequeue(req);

    scsi_req_unref(req);

}

static int scsi_handle_rw_error(SCSIDiskReq *r, int error, int type);

static int scsi_disk_emulate_command(SCSIDiskReq *r, uint8_t *outbuf);

        uint32_t lun)

{

    SCSIRequest *req;

    SCSIDiskReq *r;

    req = scsi_req_alloc(sizeof(SCSIDiskReq), &s->qdev, tag, lun);

    r = DO_UPCAST(SCSIDiskReq, req, req);

    r->iov.iov_base = qemu_blockalign(s->bs, SCSI_DMA_BUF_SIZE);

}

static void scsi_free_request(SCSIRequest *req)

    qemu_vfree(r->iov.iov_base);

}

static void scsi_disk_clear_sense(SCSIDiskState *s)

{

    memset(&s->sense, 0, sizeof(s->sense));

}

/* Cancel a pending data transfer.  */

{

    }

}

static void scsi_read_complete(void * opaque, int ret)

}

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);

    uint32_t n;

    }

}

static int scsi_handle_rw_error(SCSIDiskReq *r, int error, int type)

{

    int is_read = (type == SCSI_REQ_STATUS_RETRY_READ);

    }

}

{

    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);

    uint32_t n;

        /* Invoke completion routine to fetch data from host.  */

        scsi_write_complete(r, 0);

    }

    return 0;

}

            switch (status & SCSI_REQ_STATUS_RETRY_TYPE_MASK) {

            case SCSI_REQ_STATUS_RETRY_READ:

                break;

            case SCSI_REQ_STATUS_RETRY_WRITE:

                break;

            case SCSI_REQ_STATUS_RETRY_FLUSH:

                ret = scsi_disk_emulate_command(r, r->iov.iov_base);

}

/* Return a pointer to the data buffer.  */

{

    return (uint8_t *)r->iov.iov_base;

}

   (eg. disk reads), negative for transfers to the device (eg. disk writes),

   and zero if the command does not transfer any data.  */

{

    int32_t len;

    int is_write;

    uint8_t command;

    uint8_t *outbuf;

    int rc;

    command = buf[0];

    outbuf = (uint8_t *)r->iov.iov_base;

    is_write = 0;

    DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun, tag, buf[0]);

    }

#endif

        /* Only LUN 0 supported.  */

        if (command != REQUEST_SENSE && command != INQUIRY)

            goto fail;

    }

    case REZERO_UNIT:

        rc = scsi_disk_emulate_command(r, outbuf);

        if (rc < 0) {

            return 0;

        }

    case READ_10:

    case READ_12:

    case READ_16:

        DPRINTF("Read (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len);

        if (r->req.cmd.lba > s->max_lba)

            goto illegal_lba;

    case WRITE_VERIFY:

    case WRITE_VERIFY_12:

    case WRITE_VERIFY_16:

        DPRINTF("Write %s(sector %" PRId64 ", count %d)\n",

                (command & 0xe) == 0xe ? "And Verify " : "",

                r->req.cmd.lba, len);

        }

        break;

    case WRITE_SAME_16:

        DPRINTF("WRITE SAME(16) (sector %" PRId64 ", count %d)\n",

                r->req.cmd.lba, len);

        DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]);

    fail:

        scsi_command_complete(r, CHECK_CONDITION, ILLEGAL_REQUEST);

        return 0;

    illegal_lba:

        scsi_command_complete(r, CHECK_CONDITION, HARDWARE_ERROR);

        return 0;

    }

    if (r->sector_count == 0 && r->iov.iov_len == 0) {

        if (!r->sector_count)

            r->sector_count = -1;

    }

    return len;

}

            bdrv_aio_cancel(r->req.aiocb);

        }

        scsi_req_dequeue(&r->req);

    }

}

        .qdev.reset   = scsi_disk_reset,

        .init         = scsi_hd_initfn,

        .destroy      = scsi_destroy,

        .free_req     = scsi_free_request,

        .send_command = scsi_send_command,

        .read_data    = scsi_read_data,

        .qdev.reset   = scsi_disk_reset,

        .init         = scsi_cd_initfn,

        .destroy      = scsi_destroy,

        .free_req     = scsi_free_request,

        .send_command = scsi_send_command,

        .read_data    = scsi_read_data,

        .qdev.reset   = scsi_disk_reset,

        .init         = scsi_disk_initfn,

        .destroy      = scsi_destroy,

        .free_req     = scsi_free_request,

        .send_command = scsi_send_command,

        .read_data    = scsi_read_data,

    uint8_t senselen;

};

{

    SCSIRequest *req;

    req = scsi_req_alloc(sizeof(SCSIGenericReq), d, tag, lun);

}

static void scsi_free_request(SCSIRequest *req)

    qemu_free(r->buf);

}

/* Helper function for command completion.  */

static void scsi_command_complete(void *opaque, int ret)

{

}

/* Cancel a pending data transfer.  */

{

    }

}

static int execute_command(BlockDriverState *bdrv,

}

/* Read more data from scsi device into buffer.  */

{

    int ret;

    if (r->len == -1) {

        scsi_command_complete(r, 0);

        return;

/* Write data to a scsi device.  Returns nonzero on failure.

   The transfer may complete asynchronously.  */

{

    int ret;

    if (r->len == 0) {

        r->len = r->buflen;

        scsi_req_data(&r->req, r->len);

}

/* Return a pointer to the data buffer.  */

{

    return r->buf;

}

   (eg. disk reads), negative for transfers to the device (eg. disk writes),

   and zero if the command does not transfer any data.  */

{

    SCSIBus *bus;

    int ret;

    if (cmd[0] != REQUEST_SENSE &&

        s->sensebuf[0] = 0x70;

        s->sensebuf[1] = 0x00;

        s->sensebuf[6] = 0x00;

        s->senselen = 7;

        s->driver_status = SG_ERR_DRIVER_SENSE;

        return 0;

    }

    if (-1 == scsi_req_parse(&r->req, cmd)) {

        BADF("Unsupported command length, command %x\n", cmd[0]);

        scsi_req_dequeue(&r->req);

        ret = execute_command(s->bs, r, SG_DXFER_NONE, scsi_command_complete);

        if (ret == -1) {

            scsi_command_complete(r, -EINVAL);

        }

        return 0;

    }

    r->len = r->req.cmd.xfer;

    if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {

        r->len = 0;

    } else {

    }

}

static int get_blocksize(BlockDriverState *bdrv)

            bdrv_aio_cancel(r->req.aiocb);

        }

        scsi_req_dequeue(&r->req);

    }

}

    .qdev.reset   = scsi_generic_reset,

    .init         = scsi_generic_initfn,

    .destroy      = scsi_destroy,

    .free_req     = scsi_free_request,

    .send_command = scsi_send_command,

    .read_data    = scsi_read_data,

typedef struct SCSIBusOps SCSIBusOps;

typedef struct SCSIDevice SCSIDevice;

typedef struct SCSIDeviceInfo SCSIDeviceInfo;

enum SCSIXferMode {

    SCSI_XFER_NONE,      /*  TEST_UNIT_READY, ...            */

    SCSI_XFER_TO_DEV,    /*  WRITE, MODE_SELECT, ...         */

};

    SCSIBus           *bus;

    SCSIDevice        *dev;

    uint32_t          refcount;

    BlockDriverAIOCB  *aiocb;

    bool enqueued;

    QTAILQ_ENTRY(SCSIRequest) next;

struct SCSIDevice

{

    DeviceInfo qdev;

    scsi_qdev_initfn init;

    void (*destroy)(SCSIDevice *s);

    void (*free_req)(SCSIRequest *req);

};

struct SCSIBusOps {

};

struct SCSIBus {

int scsi_bus_legacy_handle_cmdline(SCSIBus *bus);

SCSIRequest *scsi_req_alloc(size_t size, SCSIDevice *d, uint32_t tag, uint32_t lun);

void scsi_req_free(SCSIRequest *req);

void scsi_req_dequeue(SCSIRequest *req);

SCSIRequest *scsi_req_ref(SCSIRequest *req);

    /* SCSI request tracking */

    SCSIDevice              *sdev;

    uint32_t                qtag; /* qemu tag != srp tag */

    int                     lun;

    int                     active;

static void vscsi_put_req(VSCSIState *s, vscsi_req *req)

{

    req->active = 0;

}

{

    if (tag >= VSCSI_REQ_LIMIT || !s->reqs[tag].active) {

        return NULL;

    }

    cdb[4] = 96;

    cdb[5] = 0;

    req->sensing = 1;

    dprintf("VSCSI: Queued request sense tag 0x%x\n", req->qtag);

    if (n < 0) {

        fprintf(stderr, "VSCSI: REQUEST_SENSE wants write data !?!?!?\n");

        vscsi_makeup_sense(s, req, HARDWARE_ERROR, 0, 0);

        vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);

        vscsi_put_req(s, req);

    } else if (n == 0) {

        return;

    }

}

/* Callback to indicate that the SCSI layer has completed a transfer.  */

{

    SCSIDevice *sdev;

    uint8_t *buf;

    int32_t res_in = 0, res_out = 0;

    int len, rc = 0;

    dprintf("VSCSI: SCSI cmd complete, r=0x%x tag=0x%x arg=0x%x, req=%p\n",

    if (req == NULL) {

        return;

    }

    sdev = req->sdev;

            vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);

            vscsi_put_req(s, req);

        } else {

            len = MIN(arg, SCSI_SENSE_BUF_SIZE);

            dprintf("VSCSI: Sense data, %d bytes:\n", len);

                    buf[12], buf[13], buf[14], buf[15]);

            memcpy(req->sense, buf, len);

            req->senselen = len;

        }

        return;

    }

     * to write for writes (ie, how much is to be DMA'd)

     */

    if (arg) {

        rc = vscsi_srp_transfer_data(s, req, req->writing, buf, arg);

    }

    if (rc < 0) {

        fprintf(stderr, "VSCSI: RDMA error rc=%d!\n", rc);

        vscsi_makeup_sense(s, req, HARDWARE_ERROR, 0, 0);

        vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);

        vscsi_put_req(s, req);

    /* Start next chunk */

    req->data_len -= rc;

    if (req->writing) {

    } else {

    }

}

    req->sdev = sdev;

    req->lun = lun;

    dprintf("VSCSI: Queued command tag 0x%x CMD 0x%x ID %d LUN %d ret: %d\n",

            req->qtag, srp->cmd.cdb[0], id, lun, n);

    /* Get transfer direction and initiate transfer */

    if (n > 0) {

        req->data_len = n;

    } else if (n < 0) {

        req->data_len = -n;

    }

    /* Don't touch req here, it may have been recycled already */

    uint32_t data_len;

    uint32_t residue;

    uint32_t tag;

    SCSIBus bus;

    BlockConf conf;

    SCSIDevice *scsi_dev;

    s->data_len -= len;

    if (s->scsi_len == 0 || s->data_len == 0) {

        if (s->mode == USB_MSDM_DATAIN) {

        } else if (s->mode == USB_MSDM_DATAOUT) {

        }

    }

}

    memcpy(p->data, &csw, len);

}

{

    USBPacket *p = s->packet;

    }

    if (reason == SCSI_REASON_DONE) {

        DPRINTF("Command complete %d\n", arg);

        } else if (s->data_len == 0) {

            s->mode = USB_MSDM_CSW;

        }

        return;

    }

    s->scsi_len = arg;

    if (p) {

        usb_msd_copy_data(s);

        if (s->usb_len == 0) {

static void usb_msd_cancel_io(USBPacket *p, void *opaque)

{

    MSDState *s = opaque;

    s->packet = NULL;

    s->scsi_len = 0;

}

                    s->tag, cbw.flags, cbw.cmd_len, s->data_len);

            s->residue = 0;

            s->scsi_len = 0;

            /* ??? Should check that USB and SCSI data transfer

               directions match.  */

            if (s->residue == 0) {

                if (s->mode == USB_MSDM_DATAIN) {

                } else if (s->mode == USB_MSDM_DATAOUT) {

                }

            }

            ret = len;