Revision 0c34459b

b/hw/esp.c
419 419
    } else {
420 420
        DPRINTF("transfer %d/%d\n", s->dma_left, s->ti_size);
421 421
        s->async_len = arg;
422
        s->async_buf = s->current_dev->info->get_buf(req);
422
        s->async_buf = scsi_req_get_buf(req);
423 423
        if (s->dma_left) {
424 424
            esp_do_dma(s);
425 425
        } else if (s->dma_counter != 0 && s->ti_size <= 0) {
b/hw/lsi53c895a.c
569 569
    s->dnad += count;
570 570
    s->dbc -= count;
571 571
     if (s->current->dma_buf == NULL) {
572
        s->current->dma_buf = dev->info->get_buf(s->current->req);
572
        s->current->dma_buf = scsi_req_get_buf(s->current->req);
573 573
    }
574 574
    /* ??? Set SFBR to first data byte.  */
575 575
    if (out) {
b/hw/scsi-bus.c
151 151
    return d->info->alloc_req(d, tag, lun);
152 152
}
153 153

  
154
uint8_t *scsi_req_get_buf(SCSIRequest *req)
155
{
156
    return req->dev->info->get_buf(req);
157
}
158

  
154 159
int32_t scsi_req_enqueue(SCSIRequest *req, uint8_t *buf)
155 160
{
156 161
    int32_t rc;
b/hw/scsi.h
154 154
void scsi_req_continue(SCSIRequest *req);
155 155
void scsi_req_data(SCSIRequest *req, int len);
156 156
void scsi_req_complete(SCSIRequest *req);
157
uint8_t *scsi_req_get_buf(SCSIRequest *req);
157 158
void scsi_req_abort(SCSIRequest *req, int status);
158 159
void scsi_req_cancel(SCSIRequest *req);
159 160
void scsi_device_purge_requests(SCSIDevice *sdev);
b/hw/spapr_vscsi.c
74 74
    union viosrp_iu         iu;
75 75

  
76 76
    /* SCSI request tracking */
77
    SCSIDevice              *sdev;
78 77
    SCSIRequest             *sreq;
79 78
    uint32_t                qtag; /* qemu tag != srp tag */
80 79
    int                     lun;
......
476 475
{
477 476
    VSCSIState *s = DO_UPCAST(VSCSIState, vdev.qdev, sreq->bus->qbus.parent);
478 477
    vscsi_req *req = vscsi_find_req(s, sreq);
479
    SCSIDevice *sdev;
480 478
    uint8_t *buf;
481 479
    int32_t res_in = 0, res_out = 0;
482 480
    int len, rc = 0;
......
487 485
        fprintf(stderr, "VSCSI: Can't find request for tag 0x%x\n", sreq->tag);
488 486
        return;
489 487
    }
490
    sdev = req->sdev;
491 488

  
492 489
    if (req->sensing) {
493 490
        if (reason == SCSI_REASON_DONE) {
......
495 492
            vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);
496 493
            vscsi_put_req(s, req);
497 494
        } else {
498
            uint8_t *buf = sdev->info->get_buf(sreq);
495
            uint8_t *buf = scsi_req_get_buf(sreq);
499 496

  
500 497
            len = MIN(arg, SCSI_SENSE_BUF_SIZE);
501 498
            dprintf("VSCSI: Sense data, %d bytes:\n", len);
......
539 536
     * to write for writes (ie, how much is to be DMA'd)
540 537
     */
541 538
    if (arg) {
542
        buf = sdev->info->get_buf(sreq);
539
        buf = scsi_req_get_buf(sreq);
543 540
        rc = vscsi_srp_transfer_data(s, req, req->writing, buf, arg);
544 541
    }
545 542
    if (rc < 0) {
......
646 643
        } return 1;
647 644
    }
648 645

  
649
    req->sdev = sdev;
650 646
    req->lun = lun;
651 647
    req->sreq = scsi_req_new(sdev, req->qtag, lun);
652 648
    n = scsi_req_enqueue(req->sreq, srp->cmd.cdb);
b/hw/usb-msd.c
247 247
    }
248 248
    assert((s->mode == USB_MSDM_DATAOUT) == (req->cmd.mode == SCSI_XFER_TO_DEV));
249 249
    s->scsi_len = arg;
250
    s->scsi_buf = s->scsi_dev->info->get_buf(req);
250
    s->scsi_buf = scsi_req_get_buf(req);
251 251
    if (p) {
252 252
        usb_msd_copy_data(s);
253 253
        if (s->usb_len == 0) {

Also available in: Unified diff