qemu/hw/scsi/spapr_vscsi.c
<<
>>
Prefs
   1/*
   2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
   3 *
   4 * PAPR Virtual SCSI, aka ibmvscsi
   5 *
   6 * Copyright (c) 2010,2011 Benjamin Herrenschmidt, IBM Corporation.
   7 *
   8 * Permission is hereby granted, free of charge, to any person obtaining a copy
   9 * of this software and associated documentation files (the "Software"), to deal
  10 * in the Software without restriction, including without limitation the rights
  11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 * copies of the Software, and to permit persons to whom the Software is
  13 * furnished to do so, subject to the following conditions:
  14 *
  15 * The above copyright notice and this permission notice shall be included in
  16 * all copies or substantial portions of the Software.
  17 *
  18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24 * THE SOFTWARE.
  25 *
  26 * TODO:
  27 *
  28 *  - Cleanups :-)
  29 *  - Sort out better how to assign devices to VSCSI instances
  30 *  - Fix residual counts
  31 *  - Add indirect descriptors support
  32 *  - Maybe do autosense (PAPR seems to mandate it, linux doesn't care)
  33 */
  34
  35#include "qemu/osdep.h"
  36#include "qemu/module.h"
  37#include "hw/scsi/scsi.h"
  38#include "migration/vmstate.h"
  39#include "scsi/constants.h"
  40#include "srp.h"
  41#include "hw/ppc/spapr.h"
  42#include "hw/ppc/spapr_vio.h"
  43#include "hw/qdev-properties.h"
  44#include "viosrp.h"
  45#include "trace.h"
  46
  47#include <libfdt.h>
  48#include "qom/object.h"
  49
  50/*
  51 * Virtual SCSI device
  52 */
  53
  54/* Random numbers */
  55#define VSCSI_MAX_SECTORS       4096
  56#define VSCSI_REQ_LIMIT         24
  57
  58/* Maximum size of a IU payload */
  59#define SRP_MAX_IU_DATA_LEN     (SRP_MAX_IU_LEN - sizeof(union srp_iu))
  60#define SRP_RSP_SENSE_DATA_LEN  18
  61
  62#define SRP_REPORT_LUNS_WLUN    0xc10100000000000ULL
  63
  64typedef union vscsi_crq {
  65    struct viosrp_crq s;
  66    uint8_t raw[16];
  67} vscsi_crq;
  68
  69typedef struct vscsi_req {
  70    vscsi_crq               crq;
  71    uint8_t                 viosrp_iu_buf[SRP_MAX_IU_LEN];
  72
  73    /* SCSI request tracking */
  74    SCSIRequest             *sreq;
  75    uint32_t                qtag; /* qemu tag != srp tag */
  76    bool                    active;
  77    bool                    writing;
  78    bool                    dma_error;
  79    uint32_t                data_len;
  80    uint32_t                senselen;
  81    uint8_t                 sense[SCSI_SENSE_BUF_SIZE];
  82
  83    /* RDMA related bits */
  84    uint8_t                 dma_fmt;
  85    uint16_t                local_desc;
  86    uint16_t                total_desc;
  87    uint16_t                cdb_offset;
  88    uint16_t                cur_desc_num;
  89    uint16_t                cur_desc_offset;
  90} vscsi_req;
  91
  92#define TYPE_VIO_SPAPR_VSCSI_DEVICE "spapr-vscsi"
  93OBJECT_DECLARE_SIMPLE_TYPE(VSCSIState, VIO_SPAPR_VSCSI_DEVICE)
  94
  95struct VSCSIState {
  96    SpaprVioDevice vdev;
  97    SCSIBus bus;
  98    vscsi_req reqs[VSCSI_REQ_LIMIT];
  99};
 100
 101static union viosrp_iu *req_iu(vscsi_req *req)
 102{
 103    return (union viosrp_iu *)req->viosrp_iu_buf;
 104}
 105
 106static struct vscsi_req *vscsi_get_req(VSCSIState *s)
 107{
 108    vscsi_req *req;
 109    int i;
 110
 111    for (i = 0; i < VSCSI_REQ_LIMIT; i++) {
 112        req = &s->reqs[i];
 113        if (!req->active) {
 114            memset(req, 0, sizeof(*req));
 115            req->qtag = i;
 116            req->active = 1;
 117            return req;
 118        }
 119    }
 120    return NULL;
 121}
 122
 123static struct vscsi_req *vscsi_find_req(VSCSIState *s, uint64_t srp_tag)
 124{
 125    vscsi_req *req;
 126    int i;
 127
 128    for (i = 0; i < VSCSI_REQ_LIMIT; i++) {
 129        req = &s->reqs[i];
 130        if (req_iu(req)->srp.cmd.tag == srp_tag) {
 131            return req;
 132        }
 133    }
 134    return NULL;
 135}
 136
 137static void vscsi_put_req(vscsi_req *req)
 138{
 139    if (req->sreq != NULL) {
 140        scsi_req_unref(req->sreq);
 141    }
 142    req->sreq = NULL;
 143    req->active = 0;
 144}
 145
 146static SCSIDevice *vscsi_device_find(SCSIBus *bus, uint64_t srp_lun, int *lun)
 147{
 148    int channel = 0, id = 0;
 149
 150retry:
 151    switch (srp_lun >> 62) {
 152    case 0:
 153        if ((srp_lun >> 56) != 0) {
 154            channel = (srp_lun >> 56) & 0x3f;
 155            id = (srp_lun >> 48) & 0xff;
 156            srp_lun <<= 16;
 157            goto retry;
 158        }
 159        *lun = (srp_lun >> 48) & 0xff;
 160        break;
 161
 162    case 1:
 163        *lun = (srp_lun >> 48) & 0x3fff;
 164        break;
 165    case 2:
 166        channel = (srp_lun >> 53) & 0x7;
 167        id = (srp_lun >> 56) & 0x3f;
 168        *lun = (srp_lun >> 48) & 0x1f;
 169        break;
 170    case 3:
 171        *lun = -1;
 172        return NULL;
 173    default:
 174        abort();
 175    }
 176
 177    return scsi_device_find(bus, channel, id, *lun);
 178}
 179
 180static int vscsi_send_iu(VSCSIState *s, vscsi_req *req,
 181                         uint64_t length, uint8_t format)
 182{
 183    long rc, rc1;
 184
 185    assert(length <= SRP_MAX_IU_LEN);
 186
 187    /* First copy the SRP */
 188    rc = spapr_vio_dma_write(&s->vdev, req->crq.s.IU_data_ptr,
 189                             &req->viosrp_iu_buf, length);
 190    if (rc) {
 191        fprintf(stderr, "vscsi_send_iu: DMA write failure !\n");
 192    }
 193
 194    req->crq.s.valid = 0x80;
 195    req->crq.s.format = format;
 196    req->crq.s.reserved = 0x00;
 197    req->crq.s.timeout = cpu_to_be16(0x0000);
 198    req->crq.s.IU_length = cpu_to_be16(length);
 199    req->crq.s.IU_data_ptr = req_iu(req)->srp.rsp.tag; /* right byte order */
 200
 201    if (rc == 0) {
 202        req->crq.s.status = VIOSRP_OK;
 203    } else {
 204        req->crq.s.status = VIOSRP_ADAPTER_FAIL;
 205    }
 206
 207    rc1 = spapr_vio_send_crq(&s->vdev, req->crq.raw);
 208    if (rc1) {
 209        fprintf(stderr, "vscsi_send_iu: Error sending response\n");
 210        return rc1;
 211    }
 212
 213    return rc;
 214}
 215
 216static void vscsi_makeup_sense(VSCSIState *s, vscsi_req *req,
 217                               uint8_t key, uint8_t asc, uint8_t ascq)
 218{
 219    req->senselen = SRP_RSP_SENSE_DATA_LEN;
 220
 221    /* Valid bit and 'current errors' */
 222    req->sense[0] = (0x1 << 7 | 0x70);
 223    /* Sense key */
 224    req->sense[2] = key;
 225    /* Additional sense length */
 226    req->sense[7] = 0xa; /* 10 bytes */
 227    /* Additional sense code */
 228    req->sense[12] = asc;
 229    req->sense[13] = ascq;
 230}
 231
 232static int vscsi_send_rsp(VSCSIState *s, vscsi_req *req,
 233                          uint8_t status, int32_t res_in, int32_t res_out)
 234{
 235    union viosrp_iu *iu = req_iu(req);
 236    uint64_t tag = iu->srp.rsp.tag;
 237    int total_len = sizeof(iu->srp.rsp);
 238    uint8_t sol_not = iu->srp.cmd.sol_not;
 239
 240    trace_spapr_vscsi_send_rsp(status, res_in, res_out);
 241
 242    memset(iu, 0, sizeof(struct srp_rsp));
 243    iu->srp.rsp.opcode = SRP_RSP;
 244    iu->srp.rsp.req_lim_delta = cpu_to_be32(1);
 245    iu->srp.rsp.tag = tag;
 246
 247    /* Handle residuals */
 248    if (res_in < 0) {
 249        iu->srp.rsp.flags |= SRP_RSP_FLAG_DIUNDER;
 250        res_in = -res_in;
 251    } else if (res_in) {
 252        iu->srp.rsp.flags |= SRP_RSP_FLAG_DIOVER;
 253    }
 254    if (res_out < 0) {
 255        iu->srp.rsp.flags |= SRP_RSP_FLAG_DOUNDER;
 256        res_out = -res_out;
 257    } else if (res_out) {
 258        iu->srp.rsp.flags |= SRP_RSP_FLAG_DOOVER;
 259    }
 260    iu->srp.rsp.data_in_res_cnt = cpu_to_be32(res_in);
 261    iu->srp.rsp.data_out_res_cnt = cpu_to_be32(res_out);
 262
 263    /* We don't do response data */
 264    /* iu->srp.rsp.flags &= ~SRP_RSP_FLAG_RSPVALID; */
 265    iu->srp.rsp.resp_data_len = cpu_to_be32(0);
 266
 267    /* Handle success vs. failure */
 268    iu->srp.rsp.status = status;
 269    if (status) {
 270        iu->srp.rsp.sol_not = (sol_not & 0x04) >> 2;
 271        if (req->senselen) {
 272            int sense_data_len = MIN(req->senselen, SRP_MAX_IU_DATA_LEN);
 273
 274            iu->srp.rsp.flags |= SRP_RSP_FLAG_SNSVALID;
 275            iu->srp.rsp.sense_data_len = cpu_to_be32(sense_data_len);
 276            memcpy(iu->srp.rsp.data, req->sense, sense_data_len);
 277            total_len += sense_data_len;
 278        }
 279    } else {
 280        iu->srp.rsp.sol_not = (sol_not & 0x02) >> 1;
 281    }
 282
 283    vscsi_send_iu(s, req, total_len, VIOSRP_SRP_FORMAT);
 284    return 0;
 285}
 286
 287static inline struct srp_direct_buf vscsi_swap_desc(struct srp_direct_buf desc)
 288{
 289    desc.va = be64_to_cpu(desc.va);
 290    desc.len = be32_to_cpu(desc.len);
 291    return desc;
 292}
 293
 294static int vscsi_fetch_desc(VSCSIState *s, struct vscsi_req *req,
 295                            unsigned n, unsigned buf_offset,
 296                            struct srp_direct_buf *ret)
 297{
 298    struct srp_cmd *cmd = &req_iu(req)->srp.cmd;
 299
 300    switch (req->dma_fmt) {
 301    case SRP_NO_DATA_DESC: {
 302        trace_spapr_vscsi_fetch_desc_no_data();
 303        return 0;
 304    }
 305    case SRP_DATA_DESC_DIRECT: {
 306        memcpy(ret, cmd->add_data + req->cdb_offset, sizeof(*ret));
 307        assert(req->cur_desc_num == 0);
 308        trace_spapr_vscsi_fetch_desc_direct();
 309        break;
 310    }
 311    case SRP_DATA_DESC_INDIRECT: {
 312        struct srp_indirect_buf *tmp = (struct srp_indirect_buf *)
 313                                       (cmd->add_data + req->cdb_offset);
 314        if (n < req->local_desc) {
 315            *ret = tmp->desc_list[n];
 316            trace_spapr_vscsi_fetch_desc_indirect(req->qtag, n,
 317                                                  req->local_desc);
 318        } else if (n < req->total_desc) {
 319            int rc;
 320            struct srp_direct_buf tbl_desc = vscsi_swap_desc(tmp->table_desc);
 321            unsigned desc_offset = n * sizeof(struct srp_direct_buf);
 322
 323            if (desc_offset >= tbl_desc.len) {
 324                trace_spapr_vscsi_fetch_desc_out_of_range(n, desc_offset);
 325                return -1;
 326            }
 327            rc = spapr_vio_dma_read(&s->vdev, tbl_desc.va + desc_offset,
 328                                    ret, sizeof(struct srp_direct_buf));
 329            if (rc) {
 330                trace_spapr_vscsi_fetch_desc_dma_read_error(rc);
 331                return -1;
 332            }
 333            trace_spapr_vscsi_fetch_desc_indirect_seg_ext(req->qtag, n,
 334                                                          req->total_desc,
 335                                                          tbl_desc.va,
 336                                                          tbl_desc.len);
 337        } else {
 338            trace_spapr_vscsi_fetch_desc_out_of_desc();
 339            return 0;
 340        }
 341        break;
 342    }
 343    default:
 344        fprintf(stderr, "VSCSI:   Unknown format %x\n", req->dma_fmt);
 345        return -1;
 346    }
 347
 348    *ret = vscsi_swap_desc(*ret);
 349    if (buf_offset > ret->len) {
 350        trace_spapr_vscsi_fetch_desc_out_of_desc_boundary(buf_offset,
 351                                                          req->cur_desc_num,
 352                                                          ret->len);
 353        return -1;
 354    }
 355    ret->va += buf_offset;
 356    ret->len -= buf_offset;
 357
 358    trace_spapr_vscsi_fetch_desc_done(req->cur_desc_num, req->cur_desc_offset,
 359                                      ret->va, ret->len);
 360
 361    return ret->len ? 1 : 0;
 362}
 363
 364static int vscsi_srp_direct_data(VSCSIState *s, vscsi_req *req,
 365                                 uint8_t *buf, uint32_t len)
 366{
 367    struct srp_direct_buf md;
 368    uint32_t llen;
 369    int rc = 0;
 370
 371    rc = vscsi_fetch_desc(s, req, req->cur_desc_num, req->cur_desc_offset, &md);
 372    if (rc < 0) {
 373        return -1;
 374    } else if (rc == 0) {
 375        return 0;
 376    }
 377
 378    llen = MIN(len, md.len);
 379    if (llen) {
 380        if (req->writing) { /* writing = to device = reading from memory */
 381            rc = spapr_vio_dma_read(&s->vdev, md.va, buf, llen);
 382        } else {
 383            rc = spapr_vio_dma_write(&s->vdev, md.va, buf, llen);
 384        }
 385    }
 386
 387    if (rc) {
 388        return -1;
 389    }
 390    req->cur_desc_offset += llen;
 391
 392    return llen;
 393}
 394
 395static int vscsi_srp_indirect_data(VSCSIState *s, vscsi_req *req,
 396                                   uint8_t *buf, uint32_t len)
 397{
 398    struct srp_direct_buf md;
 399    int rc = 0;
 400    uint32_t llen, total = 0;
 401
 402    trace_spapr_vscsi_srp_indirect_data(len);
 403
 404    /* While we have data ... */
 405    while (len) {
 406        rc = vscsi_fetch_desc(s, req, req->cur_desc_num, req->cur_desc_offset, &md);
 407        if (rc < 0) {
 408            return -1;
 409        } else if (rc == 0) {
 410            break;
 411        }
 412
 413        /* Perform transfer */
 414        llen = MIN(len, md.len);
 415        if (req->writing) { /* writing = to device = reading from memory */
 416            rc = spapr_vio_dma_read(&s->vdev, md.va, buf, llen);
 417        } else {
 418            rc = spapr_vio_dma_write(&s->vdev, md.va, buf, llen);
 419        }
 420        if (rc) {
 421            trace_spapr_vscsi_srp_indirect_data_rw(req->writing, rc);
 422            break;
 423        }
 424        trace_spapr_vscsi_srp_indirect_data_buf(buf[0], buf[1], buf[2], buf[3]);
 425
 426        len -= llen;
 427        buf += llen;
 428
 429        total += llen;
 430
 431        /* Update current position in the current descriptor */
 432        req->cur_desc_offset += llen;
 433        if (md.len == llen) {
 434            /* Go to the next descriptor if the current one finished */
 435            ++req->cur_desc_num;
 436            req->cur_desc_offset = 0;
 437        }
 438    }
 439
 440    return rc ? -1 : total;
 441}
 442
 443static int vscsi_srp_transfer_data(VSCSIState *s, vscsi_req *req,
 444                                   int writing, uint8_t *buf, uint32_t len)
 445{
 446    int err = 0;
 447
 448    switch (req->dma_fmt) {
 449    case SRP_NO_DATA_DESC:
 450        trace_spapr_vscsi_srp_transfer_data(len);
 451        break;
 452    case SRP_DATA_DESC_DIRECT:
 453        err = vscsi_srp_direct_data(s, req, buf, len);
 454        break;
 455    case SRP_DATA_DESC_INDIRECT:
 456        err = vscsi_srp_indirect_data(s, req, buf, len);
 457        break;
 458    }
 459    return err;
 460}
 461
 462/* Bits from linux srp */
 463static int data_out_desc_size(struct srp_cmd *cmd)
 464{
 465    int size = 0;
 466    uint8_t fmt = cmd->buf_fmt >> 4;
 467
 468    switch (fmt) {
 469    case SRP_NO_DATA_DESC:
 470        break;
 471    case SRP_DATA_DESC_DIRECT:
 472        size = sizeof(struct srp_direct_buf);
 473        break;
 474    case SRP_DATA_DESC_INDIRECT:
 475        size = sizeof(struct srp_indirect_buf) +
 476            sizeof(struct srp_direct_buf)*cmd->data_out_desc_cnt;
 477        break;
 478    default:
 479        break;
 480    }
 481    return size;
 482}
 483
 484static int vscsi_preprocess_desc(vscsi_req *req)
 485{
 486    struct srp_cmd *cmd = &req_iu(req)->srp.cmd;
 487
 488    req->cdb_offset = cmd->add_cdb_len & ~3;
 489
 490    if (req->writing) {
 491        req->dma_fmt = cmd->buf_fmt >> 4;
 492    } else {
 493        req->cdb_offset += data_out_desc_size(cmd);
 494        req->dma_fmt = cmd->buf_fmt & ((1U << 4) - 1);
 495    }
 496
 497    switch (req->dma_fmt) {
 498    case SRP_NO_DATA_DESC:
 499        break;
 500    case SRP_DATA_DESC_DIRECT:
 501        req->total_desc = req->local_desc = 1;
 502        break;
 503    case SRP_DATA_DESC_INDIRECT: {
 504        struct srp_indirect_buf *ind_tmp = (struct srp_indirect_buf *)
 505                (cmd->add_data + req->cdb_offset);
 506
 507        req->total_desc = be32_to_cpu(ind_tmp->table_desc.len) /
 508                          sizeof(struct srp_direct_buf);
 509        req->local_desc = req->writing ? cmd->data_out_desc_cnt :
 510                          cmd->data_in_desc_cnt;
 511        break;
 512    }
 513    default:
 514        fprintf(stderr,
 515                "vscsi_preprocess_desc: Unknown format %x\n", req->dma_fmt);
 516        return -1;
 517    }
 518
 519    return 0;
 520}
 521
 522/* Callback to indicate that the SCSI layer has completed a transfer.  */
 523static void vscsi_transfer_data(SCSIRequest *sreq, uint32_t len)
 524{
 525    VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(sreq->bus->qbus.parent);
 526    vscsi_req *req = sreq->hba_private;
 527    uint8_t *buf;
 528    int rc = 0;
 529
 530    trace_spapr_vscsi_transfer_data(sreq->tag, len, req);
 531    if (req == NULL) {
 532        fprintf(stderr, "VSCSI: Can't find request for tag 0x%x\n", sreq->tag);
 533        return;
 534    }
 535
 536    if (len) {
 537        buf = scsi_req_get_buf(sreq);
 538        rc = vscsi_srp_transfer_data(s, req, req->writing, buf, len);
 539    }
 540    if (rc < 0) {
 541        fprintf(stderr, "VSCSI: RDMA error rc=%d!\n", rc);
 542        req->dma_error = true;
 543        scsi_req_cancel(req->sreq);
 544        return;
 545    }
 546
 547    /* Start next chunk */
 548    req->data_len -= rc;
 549    scsi_req_continue(sreq);
 550}
 551
 552/* Callback to indicate that the SCSI layer has completed a transfer.  */
 553static void vscsi_command_complete(SCSIRequest *sreq, size_t resid)
 554{
 555    VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(sreq->bus->qbus.parent);
 556    vscsi_req *req = sreq->hba_private;
 557    int32_t res_in = 0, res_out = 0;
 558
 559    trace_spapr_vscsi_command_complete(sreq->tag, sreq->status, req);
 560    if (req == NULL) {
 561        fprintf(stderr, "VSCSI: Can't find request for tag 0x%x\n", sreq->tag);
 562        return;
 563    }
 564
 565    if (sreq->status == CHECK_CONDITION) {
 566        req->senselen = scsi_req_get_sense(req->sreq, req->sense,
 567                                           sizeof(req->sense));
 568        trace_spapr_vscsi_command_complete_sense_data1(req->senselen,
 569                req->sense[0], req->sense[1], req->sense[2], req->sense[3],
 570                req->sense[4], req->sense[5], req->sense[6], req->sense[7]);
 571        trace_spapr_vscsi_command_complete_sense_data2(
 572                req->sense[8], req->sense[9], req->sense[10], req->sense[11],
 573                req->sense[12], req->sense[13], req->sense[14], req->sense[15]);
 574    }
 575
 576    trace_spapr_vscsi_command_complete_status(sreq->status);
 577    if (sreq->status == 0) {
 578        /* We handle overflows, not underflows for normal commands,
 579         * but hopefully nobody cares
 580         */
 581        if (req->writing) {
 582            res_out = req->data_len;
 583        } else {
 584            res_in = req->data_len;
 585        }
 586    }
 587    vscsi_send_rsp(s, req, sreq->status, res_in, res_out);
 588    vscsi_put_req(req);
 589}
 590
 591static void vscsi_request_cancelled(SCSIRequest *sreq)
 592{
 593    vscsi_req *req = sreq->hba_private;
 594
 595    if (req->dma_error) {
 596        VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(sreq->bus->qbus.parent);
 597
 598        vscsi_makeup_sense(s, req, HARDWARE_ERROR, 0, 0);
 599        vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);
 600    }
 601    vscsi_put_req(req);
 602}
 603
 604static const VMStateDescription vmstate_spapr_vscsi_req = {
 605    .name = "spapr_vscsi_req",
 606    .version_id = 1,
 607    .minimum_version_id = 1,
 608    .fields = (VMStateField[]) {
 609        VMSTATE_BUFFER(crq.raw, vscsi_req),
 610        VMSTATE_BUFFER(viosrp_iu_buf, vscsi_req),
 611        VMSTATE_UINT32(qtag, vscsi_req),
 612        VMSTATE_BOOL(active, vscsi_req),
 613        VMSTATE_UINT32(data_len, vscsi_req),
 614        VMSTATE_BOOL(writing, vscsi_req),
 615        VMSTATE_UINT32(senselen, vscsi_req),
 616        VMSTATE_BUFFER(sense, vscsi_req),
 617        VMSTATE_UINT8(dma_fmt, vscsi_req),
 618        VMSTATE_UINT16(local_desc, vscsi_req),
 619        VMSTATE_UINT16(total_desc, vscsi_req),
 620        VMSTATE_UINT16(cdb_offset, vscsi_req),
 621      /*Restart SCSI request from the beginning for now */
 622      /*VMSTATE_UINT16(cur_desc_num, vscsi_req),
 623        VMSTATE_UINT16(cur_desc_offset, vscsi_req),*/
 624        VMSTATE_END_OF_LIST()
 625    },
 626};
 627
 628static void vscsi_save_request(QEMUFile *f, SCSIRequest *sreq)
 629{
 630    vscsi_req *req = sreq->hba_private;
 631    assert(req->active);
 632
 633    vmstate_save_state(f, &vmstate_spapr_vscsi_req, req, NULL);
 634
 635    trace_spapr_vscsi_save_request(req->qtag, req->cur_desc_num,
 636                                   req->cur_desc_offset);
 637}
 638
 639static void *vscsi_load_request(QEMUFile *f, SCSIRequest *sreq)
 640{
 641    SCSIBus *bus = sreq->bus;
 642    VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(bus->qbus.parent);
 643    vscsi_req *req;
 644    int rc;
 645
 646    assert(sreq->tag < VSCSI_REQ_LIMIT);
 647    req = &s->reqs[sreq->tag];
 648    assert(!req->active);
 649
 650    memset(req, 0, sizeof(*req));
 651    rc = vmstate_load_state(f, &vmstate_spapr_vscsi_req, req, 1);
 652    if (rc) {
 653        fprintf(stderr, "VSCSI: failed loading request tag#%u\n", sreq->tag);
 654        return NULL;
 655    }
 656    assert(req->active);
 657
 658    req->sreq = scsi_req_ref(sreq);
 659
 660    trace_spapr_vscsi_load_request(req->qtag, req->cur_desc_num,
 661                                   req->cur_desc_offset);
 662
 663    return req;
 664}
 665
 666static void vscsi_process_login(VSCSIState *s, vscsi_req *req)
 667{
 668    union viosrp_iu *iu = req_iu(req);
 669    struct srp_login_rsp *rsp = &iu->srp.login_rsp;
 670    uint64_t tag = iu->srp.rsp.tag;
 671
 672    trace_spapr_vscsi_process_login();
 673
 674    /* TODO handle case that requested size is wrong and
 675     * buffer format is wrong
 676     */
 677    memset(iu, 0, sizeof(struct srp_login_rsp));
 678    rsp->opcode = SRP_LOGIN_RSP;
 679    /* Don't advertise quite as many request as we support to
 680     * keep room for management stuff etc...
 681     */
 682    rsp->req_lim_delta = cpu_to_be32(VSCSI_REQ_LIMIT-2);
 683    rsp->tag = tag;
 684    rsp->max_it_iu_len = cpu_to_be32(SRP_MAX_IU_LEN);
 685    rsp->max_ti_iu_len = cpu_to_be32(SRP_MAX_IU_LEN);
 686    /* direct and indirect */
 687    rsp->buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | SRP_BUF_FORMAT_INDIRECT);
 688
 689    vscsi_send_iu(s, req, sizeof(*rsp), VIOSRP_SRP_FORMAT);
 690}
 691
 692static void vscsi_inquiry_no_target(VSCSIState *s, vscsi_req *req)
 693{
 694    uint8_t *cdb = req_iu(req)->srp.cmd.cdb;
 695    uint8_t resp_data[36];
 696    int rc, len, alen;
 697
 698    /* We don't do EVPD. Also check that page_code is 0 */
 699    if ((cdb[1] & 0x01) || cdb[2] != 0) {
 700        /* Send INVALID FIELD IN CDB */
 701        vscsi_makeup_sense(s, req, ILLEGAL_REQUEST, 0x24, 0);
 702        vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);
 703        return;
 704    }
 705    alen = cdb[3];
 706    alen = (alen << 8) | cdb[4];
 707    len = MIN(alen, 36);
 708
 709    /* Fake up inquiry using PQ=3 */
 710    memset(resp_data, 0, 36);
 711    resp_data[0] = 0x7f;   /* Not capable of supporting a device here */
 712    resp_data[2] = 0x06;   /* SPS-4 */
 713    resp_data[3] = 0x02;   /* Resp data format */
 714    resp_data[4] = 36 - 5; /* Additional length */
 715    resp_data[7] = 0x10;   /* Sync transfers */
 716    memcpy(&resp_data[16], "QEMU EMPTY      ", 16);
 717    memcpy(&resp_data[8], "QEMU    ", 8);
 718
 719    req->writing = 0;
 720    vscsi_preprocess_desc(req);
 721    rc = vscsi_srp_transfer_data(s, req, 0, resp_data, len);
 722    if (rc < 0) {
 723        vscsi_makeup_sense(s, req, HARDWARE_ERROR, 0, 0);
 724        vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);
 725    } else {
 726        vscsi_send_rsp(s, req, 0, 36 - rc, 0);
 727    }
 728}
 729
 730static void vscsi_report_luns(VSCSIState *s, vscsi_req *req)
 731{
 732    BusChild *kid;
 733    int i, len, n, rc;
 734    uint8_t *resp_data;
 735    bool found_lun0;
 736
 737    n = 0;
 738    found_lun0 = false;
 739    QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
 740        SCSIDevice *dev = SCSI_DEVICE(kid->child);
 741
 742        n += 8;
 743        if (dev->channel == 0 && dev->id == 0 && dev->lun == 0) {
 744            found_lun0 = true;
 745        }
 746    }
 747    if (!found_lun0) {
 748        n += 8;
 749    }
 750    len = n+8;
 751
 752    resp_data = g_malloc0(len);
 753    stl_be_p(resp_data, n);
 754    i = found_lun0 ? 8 : 16;
 755    QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
 756        DeviceState *qdev = kid->child;
 757        SCSIDevice *dev = SCSI_DEVICE(qdev);
 758
 759        if (dev->id == 0 && dev->channel == 0) {
 760            resp_data[i] = 0;         /* Use simple LUN for 0 (SAM5 4.7.7.1) */
 761        } else {
 762            resp_data[i] = (2 << 6);  /* Otherwise LUN addressing (4.7.7.4)  */
 763        }
 764        resp_data[i] |= dev->id;
 765        resp_data[i+1] = (dev->channel << 5);
 766        resp_data[i+1] |= dev->lun;
 767        i += 8;
 768    }
 769
 770    vscsi_preprocess_desc(req);
 771    rc = vscsi_srp_transfer_data(s, req, 0, resp_data, len);
 772    g_free(resp_data);
 773    if (rc < 0) {
 774        vscsi_makeup_sense(s, req, HARDWARE_ERROR, 0, 0);
 775        vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);
 776    } else {
 777        vscsi_send_rsp(s, req, 0, len - rc, 0);
 778    }
 779}
 780
 781static int vscsi_queue_cmd(VSCSIState *s, vscsi_req *req)
 782{
 783    union srp_iu *srp = &req_iu(req)->srp;
 784    SCSIDevice *sdev;
 785    int n, lun;
 786    size_t cdb_len = sizeof (srp->cmd.cdb) + (srp->cmd.add_cdb_len & ~3);
 787
 788    if ((srp->cmd.lun == 0 || be64_to_cpu(srp->cmd.lun) == SRP_REPORT_LUNS_WLUN)
 789      && srp->cmd.cdb[0] == REPORT_LUNS) {
 790        vscsi_report_luns(s, req);
 791        return 0;
 792    }
 793
 794    sdev = vscsi_device_find(&s->bus, be64_to_cpu(srp->cmd.lun), &lun);
 795    if (!sdev) {
 796        trace_spapr_vscsi_queue_cmd_no_drive(be64_to_cpu(srp->cmd.lun));
 797        if (srp->cmd.cdb[0] == INQUIRY) {
 798            vscsi_inquiry_no_target(s, req);
 799        } else {
 800            vscsi_makeup_sense(s, req, ILLEGAL_REQUEST, 0x24, 0x00);
 801            vscsi_send_rsp(s, req, CHECK_CONDITION, 0, 0);
 802        } return 1;
 803    }
 804
 805    req->sreq = scsi_req_new(sdev, req->qtag, lun, srp->cmd.cdb, cdb_len, req);
 806    n = scsi_req_enqueue(req->sreq);
 807
 808    trace_spapr_vscsi_queue_cmd(req->qtag, srp->cmd.cdb[0],
 809                                scsi_command_name(srp->cmd.cdb[0]), lun, n);
 810
 811    if (n) {
 812        /* Transfer direction must be set before preprocessing the
 813         * descriptors
 814         */
 815        req->writing = (n < 1);
 816
 817        /* Preprocess RDMA descriptors */
 818        vscsi_preprocess_desc(req);
 819
 820        /* Get transfer direction and initiate transfer */
 821        if (n > 0) {
 822            req->data_len = n;
 823        } else if (n < 0) {
 824            req->data_len = -n;
 825        }
 826        scsi_req_continue(req->sreq);
 827    }
 828    /* Don't touch req here, it may have been recycled already */
 829
 830    return 0;
 831}
 832
 833static int vscsi_process_tsk_mgmt(VSCSIState *s, vscsi_req *req)
 834{
 835    union viosrp_iu *iu = req_iu(req);
 836    vscsi_req *tmpreq;
 837    int i, lun = 0, resp = SRP_TSK_MGMT_COMPLETE;
 838    SCSIDevice *d;
 839    uint64_t tag = iu->srp.rsp.tag;
 840    uint8_t sol_not = iu->srp.cmd.sol_not;
 841
 842    trace_spapr_vscsi_process_tsk_mgmt(iu->srp.tsk_mgmt.tsk_mgmt_func);
 843    d = vscsi_device_find(&s->bus,
 844                          be64_to_cpu(req_iu(req)->srp.tsk_mgmt.lun), &lun);
 845    if (!d) {
 846        resp = SRP_TSK_MGMT_FIELDS_INVALID;
 847    } else {
 848        switch (iu->srp.tsk_mgmt.tsk_mgmt_func) {
 849        case SRP_TSK_ABORT_TASK:
 850            if (d->lun != lun) {
 851                resp = SRP_TSK_MGMT_FIELDS_INVALID;
 852                break;
 853            }
 854
 855            tmpreq = vscsi_find_req(s, req_iu(req)->srp.tsk_mgmt.task_tag);
 856            if (tmpreq && tmpreq->sreq) {
 857                assert(tmpreq->sreq->hba_private);
 858                scsi_req_cancel(tmpreq->sreq);
 859            }
 860            break;
 861
 862        case SRP_TSK_LUN_RESET:
 863            if (d->lun != lun) {
 864                resp = SRP_TSK_MGMT_FIELDS_INVALID;
 865                break;
 866            }
 867
 868            device_cold_reset(&d->qdev);
 869            break;
 870
 871        case SRP_TSK_ABORT_TASK_SET:
 872        case SRP_TSK_CLEAR_TASK_SET:
 873            if (d->lun != lun) {
 874                resp = SRP_TSK_MGMT_FIELDS_INVALID;
 875                break;
 876            }
 877
 878            for (i = 0; i < VSCSI_REQ_LIMIT; i++) {
 879                tmpreq = &s->reqs[i];
 880                if (req_iu(tmpreq)->srp.cmd.lun
 881                        != req_iu(req)->srp.tsk_mgmt.lun) {
 882                    continue;
 883                }
 884                if (!tmpreq->active || !tmpreq->sreq) {
 885                    continue;
 886                }
 887                assert(tmpreq->sreq->hba_private);
 888                scsi_req_cancel(tmpreq->sreq);
 889            }
 890            break;
 891
 892        case SRP_TSK_CLEAR_ACA:
 893            resp = SRP_TSK_MGMT_NOT_SUPPORTED;
 894            break;
 895
 896        default:
 897            resp = SRP_TSK_MGMT_FIELDS_INVALID;
 898            break;
 899        }
 900    }
 901
 902    /* Compose the response here as  */
 903    QEMU_BUILD_BUG_ON(SRP_MAX_IU_DATA_LEN < 4);
 904    memset(iu, 0, sizeof(struct srp_rsp) + 4);
 905    iu->srp.rsp.opcode = SRP_RSP;
 906    iu->srp.rsp.req_lim_delta = cpu_to_be32(1);
 907    iu->srp.rsp.tag = tag;
 908    iu->srp.rsp.flags |= SRP_RSP_FLAG_RSPVALID;
 909    iu->srp.rsp.resp_data_len = cpu_to_be32(4);
 910    if (resp) {
 911        iu->srp.rsp.sol_not = (sol_not & 0x04) >> 2;
 912    } else {
 913        iu->srp.rsp.sol_not = (sol_not & 0x02) >> 1;
 914    }
 915
 916    iu->srp.rsp.status = GOOD;
 917    iu->srp.rsp.data[3] = resp;
 918
 919    vscsi_send_iu(s, req, sizeof(iu->srp.rsp) + 4, VIOSRP_SRP_FORMAT);
 920
 921    return 1;
 922}
 923
 924static int vscsi_handle_srp_req(VSCSIState *s, vscsi_req *req)
 925{
 926    union srp_iu *srp = &req_iu(req)->srp;
 927    int done = 1;
 928    uint8_t opcode = srp->rsp.opcode;
 929
 930    switch (opcode) {
 931    case SRP_LOGIN_REQ:
 932        vscsi_process_login(s, req);
 933        break;
 934    case SRP_TSK_MGMT:
 935        done = vscsi_process_tsk_mgmt(s, req);
 936        break;
 937    case SRP_CMD:
 938        done = vscsi_queue_cmd(s, req);
 939        break;
 940    case SRP_LOGIN_RSP:
 941    case SRP_I_LOGOUT:
 942    case SRP_T_LOGOUT:
 943    case SRP_RSP:
 944    case SRP_CRED_REQ:
 945    case SRP_CRED_RSP:
 946    case SRP_AER_REQ:
 947    case SRP_AER_RSP:
 948        fprintf(stderr, "VSCSI: Unsupported opcode %02x\n", opcode);
 949        break;
 950    default:
 951        fprintf(stderr, "VSCSI: Unknown type %02x\n", opcode);
 952    }
 953
 954    return done;
 955}
 956
 957static int vscsi_send_adapter_info(VSCSIState *s, vscsi_req *req)
 958{
 959    struct viosrp_adapter_info *sinfo;
 960    struct mad_adapter_info_data info;
 961    int rc;
 962
 963    sinfo = &req_iu(req)->mad.adapter_info;
 964
 965#if 0 /* What for ? */
 966    rc = spapr_vio_dma_read(&s->vdev, be64_to_cpu(sinfo->buffer),
 967                            &info, be16_to_cpu(sinfo->common.length));
 968    if (rc) {
 969        fprintf(stderr, "vscsi_send_adapter_info: DMA read failure !\n");
 970    }
 971#endif
 972    memset(&info, 0, sizeof(info));
 973    strcpy(info.srp_version, SRP_VERSION);
 974    memcpy(info.partition_name, "qemu", sizeof("qemu"));
 975    info.partition_number = cpu_to_be32(0);
 976    info.mad_version = cpu_to_be32(1);
 977    info.os_type = cpu_to_be32(2);
 978    info.port_max_txu[0] = cpu_to_be32(VSCSI_MAX_SECTORS << 9);
 979
 980    rc = spapr_vio_dma_write(&s->vdev, be64_to_cpu(sinfo->buffer),
 981                             &info, be16_to_cpu(sinfo->common.length));
 982    if (rc)  {
 983        fprintf(stderr, "vscsi_send_adapter_info: DMA write failure !\n");
 984    }
 985
 986    sinfo->common.status = rc ? cpu_to_be32(1) : 0;
 987
 988    return vscsi_send_iu(s, req, sizeof(*sinfo), VIOSRP_MAD_FORMAT);
 989}
 990
 991static int vscsi_send_capabilities(VSCSIState *s, vscsi_req *req)
 992{
 993    struct viosrp_capabilities *vcap;
 994    struct capabilities cap = { };
 995    uint16_t len, req_len;
 996    uint64_t buffer;
 997    int rc;
 998
 999    vcap = &req_iu(req)->mad.capabilities;
1000    req_len = len = be16_to_cpu(vcap->common.length);
1001    buffer = be64_to_cpu(vcap->buffer);
1002    if (len > sizeof(cap)) {
1003        fprintf(stderr, "vscsi_send_capabilities: capabilities size mismatch !\n");
1004
1005        /*
1006         * Just read and populate the structure that is known.
1007         * Zero rest of the structure.
1008         */
1009        len = sizeof(cap);
1010    }
1011    rc = spapr_vio_dma_read(&s->vdev, buffer, &cap, len);
1012    if (rc)  {
1013        fprintf(stderr, "vscsi_send_capabilities: DMA read failure !\n");
1014    }
1015
1016    /*
1017     * Current implementation does not support any migration or
1018     * reservation capabilities. Construct the response telling the
1019     * guest not to use them.
1020     */
1021    cap.flags = 0;
1022    cap.migration.ecl = 0;
1023    cap.reserve.type = 0;
1024    cap.migration.common.server_support = 0;
1025    cap.reserve.common.server_support = 0;
1026
1027    rc = spapr_vio_dma_write(&s->vdev, buffer, &cap, len);
1028    if (rc)  {
1029        fprintf(stderr, "vscsi_send_capabilities: DMA write failure !\n");
1030    }
1031    if (req_len > len) {
1032        /*
1033         * Being paranoid and lets not worry about the error code
1034         * here. Actual write of the cap is done above.
1035         */
1036        spapr_vio_dma_set(&s->vdev, (buffer + len), 0, (req_len - len));
1037    }
1038    vcap->common.status = rc ? cpu_to_be32(1) : 0;
1039    return vscsi_send_iu(s, req, sizeof(*vcap), VIOSRP_MAD_FORMAT);
1040}
1041
1042static int vscsi_handle_mad_req(VSCSIState *s, vscsi_req *req)
1043{
1044    union mad_iu *mad = &req_iu(req)->mad;
1045    bool request_handled = false;
1046    uint64_t retlen = 0;
1047
1048    switch (be32_to_cpu(mad->empty_iu.common.type)) {
1049    case VIOSRP_EMPTY_IU_TYPE:
1050        fprintf(stderr, "Unsupported EMPTY MAD IU\n");
1051        retlen = sizeof(mad->empty_iu);
1052        break;
1053    case VIOSRP_ERROR_LOG_TYPE:
1054        fprintf(stderr, "Unsupported ERROR LOG MAD IU\n");
1055        retlen = sizeof(mad->error_log);
1056        break;
1057    case VIOSRP_ADAPTER_INFO_TYPE:
1058        vscsi_send_adapter_info(s, req);
1059        request_handled = true;
1060        break;
1061    case VIOSRP_HOST_CONFIG_TYPE:
1062        retlen = sizeof(mad->host_config);
1063        break;
1064    case VIOSRP_CAPABILITIES_TYPE:
1065        vscsi_send_capabilities(s, req);
1066        request_handled = true;
1067        break;
1068    default:
1069        fprintf(stderr, "VSCSI: Unknown MAD type %02x\n",
1070                be32_to_cpu(mad->empty_iu.common.type));
1071        /*
1072         * PAPR+ says that "The length field is set to the length
1073         * of the data structure(s) used in the command".
1074         * As we did not recognize the request type, put zero there.
1075         */
1076        retlen = 0;
1077    }
1078
1079    if (!request_handled) {
1080        mad->empty_iu.common.status = cpu_to_be16(VIOSRP_MAD_NOT_SUPPORTED);
1081        vscsi_send_iu(s, req, retlen, VIOSRP_MAD_FORMAT);
1082    }
1083
1084    return 1;
1085}
1086
1087static void vscsi_got_payload(VSCSIState *s, vscsi_crq *crq)
1088{
1089    vscsi_req *req;
1090    int done;
1091
1092    req = vscsi_get_req(s);
1093    if (req == NULL) {
1094        fprintf(stderr, "VSCSI: Failed to get a request !\n");
1095        return;
1096    }
1097
1098    /* We only support a limited number of descriptors, we know
1099     * the ibmvscsi driver uses up to 10 max, so it should fit
1100     * in our 256 bytes IUs. If not we'll have to increase the size
1101     * of the structure.
1102     */
1103    if (crq->s.IU_length > SRP_MAX_IU_LEN) {
1104        fprintf(stderr, "VSCSI: SRP IU too long (%d bytes) !\n",
1105                crq->s.IU_length);
1106        vscsi_put_req(req);
1107        return;
1108    }
1109
1110    /* XXX Handle failure differently ? */
1111    if (spapr_vio_dma_read(&s->vdev, crq->s.IU_data_ptr, &req->viosrp_iu_buf,
1112                           crq->s.IU_length)) {
1113        fprintf(stderr, "vscsi_got_payload: DMA read failure !\n");
1114        vscsi_put_req(req);
1115        return;
1116    }
1117    memcpy(&req->crq, crq, sizeof(vscsi_crq));
1118
1119    if (crq->s.format == VIOSRP_MAD_FORMAT) {
1120        done = vscsi_handle_mad_req(s, req);
1121    } else {
1122        done = vscsi_handle_srp_req(s, req);
1123    }
1124
1125    if (done) {
1126        vscsi_put_req(req);
1127    }
1128}
1129
1130
1131static int vscsi_do_crq(struct SpaprVioDevice *dev, uint8_t *crq_data)
1132{
1133    VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(dev);
1134    vscsi_crq crq;
1135
1136    memcpy(crq.raw, crq_data, 16);
1137    crq.s.timeout = be16_to_cpu(crq.s.timeout);
1138    crq.s.IU_length = be16_to_cpu(crq.s.IU_length);
1139    crq.s.IU_data_ptr = be64_to_cpu(crq.s.IU_data_ptr);
1140
1141    trace_spapr_vscsi_do_crq(crq.raw[0], crq.raw[1]);
1142
1143    switch (crq.s.valid) {
1144    case 0xc0: /* Init command/response */
1145
1146        /* Respond to initialization request */
1147        if (crq.s.format == 0x01) {
1148            memset(crq.raw, 0, 16);
1149            crq.s.valid = 0xc0;
1150            crq.s.format = 0x02;
1151            spapr_vio_send_crq(dev, crq.raw);
1152        }
1153
1154        /* Note that in hotplug cases, we might get a 0x02
1155         * as a result of us emitting the init request
1156         */
1157
1158        break;
1159    case 0xff: /* Link event */
1160
1161        /* Not handled for now */
1162
1163        break;
1164    case 0x80: /* Payloads */
1165        switch (crq.s.format) {
1166        case VIOSRP_SRP_FORMAT: /* AKA VSCSI request */
1167        case VIOSRP_MAD_FORMAT: /* AKA VSCSI response */
1168            vscsi_got_payload(s, &crq);
1169            break;
1170        case VIOSRP_OS400_FORMAT:
1171        case VIOSRP_AIX_FORMAT:
1172        case VIOSRP_LINUX_FORMAT:
1173        case VIOSRP_INLINE_FORMAT:
1174            fprintf(stderr, "vscsi_do_srq: Unsupported payload format %02x\n",
1175                    crq.s.format);
1176            break;
1177        default:
1178            fprintf(stderr, "vscsi_do_srq: Unknown payload format %02x\n",
1179                    crq.s.format);
1180        }
1181        break;
1182    default:
1183        fprintf(stderr, "vscsi_do_crq: unknown CRQ %02x %02x ...\n",
1184                crq.raw[0], crq.raw[1]);
1185    };
1186
1187    return 0;
1188}
1189
1190static const struct SCSIBusInfo vscsi_scsi_info = {
1191    .tcq = true,
1192    .max_channel = 7, /* logical unit addressing format */
1193    .max_target = 63,
1194    .max_lun = 31,
1195
1196    .transfer_data = vscsi_transfer_data,
1197    .complete = vscsi_command_complete,
1198    .cancel = vscsi_request_cancelled,
1199    .save_request = vscsi_save_request,
1200    .load_request = vscsi_load_request,
1201};
1202
1203static void spapr_vscsi_reset(SpaprVioDevice *dev)
1204{
1205    VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(dev);
1206    int i;
1207
1208    memset(s->reqs, 0, sizeof(s->reqs));
1209    for (i = 0; i < VSCSI_REQ_LIMIT; i++) {
1210        s->reqs[i].qtag = i;
1211    }
1212}
1213
1214static void spapr_vscsi_realize(SpaprVioDevice *dev, Error **errp)
1215{
1216    VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(dev);
1217
1218    dev->crq.SendFunc = vscsi_do_crq;
1219
1220    scsi_bus_init(&s->bus, sizeof(s->bus), DEVICE(dev), &vscsi_scsi_info);
1221
1222    /* ibmvscsi SCSI bus does not allow hotplug. */
1223    qbus_set_hotplug_handler(BUS(&s->bus), NULL);
1224}
1225
1226void spapr_vscsi_create(SpaprVioBus *bus)
1227{
1228    DeviceState *dev;
1229
1230    dev = qdev_new("spapr-vscsi");
1231
1232    qdev_realize_and_unref(dev, &bus->bus, &error_fatal);
1233    scsi_bus_legacy_handle_cmdline(&VIO_SPAPR_VSCSI_DEVICE(dev)->bus);
1234}
1235
1236static int spapr_vscsi_devnode(SpaprVioDevice *dev, void *fdt, int node_off)
1237{
1238    int ret;
1239
1240    ret = fdt_setprop_cell(fdt, node_off, "#address-cells", 2);
1241    if (ret < 0) {
1242        return ret;
1243    }
1244
1245    ret = fdt_setprop_cell(fdt, node_off, "#size-cells", 0);
1246    if (ret < 0) {
1247        return ret;
1248    }
1249
1250    return 0;
1251}
1252
1253static Property spapr_vscsi_properties[] = {
1254    DEFINE_SPAPR_PROPERTIES(VSCSIState, vdev),
1255    DEFINE_PROP_END_OF_LIST(),
1256};
1257
1258static const VMStateDescription vmstate_spapr_vscsi = {
1259    .name = "spapr_vscsi",
1260    .version_id = 1,
1261    .minimum_version_id = 1,
1262    .fields = (VMStateField[]) {
1263        VMSTATE_SPAPR_VIO(vdev, VSCSIState),
1264        /* VSCSI state */
1265        /* ???? */
1266
1267        VMSTATE_END_OF_LIST()
1268    },
1269};
1270
1271static void spapr_vscsi_class_init(ObjectClass *klass, void *data)
1272{
1273    DeviceClass *dc = DEVICE_CLASS(klass);
1274    SpaprVioDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);
1275
1276    k->realize = spapr_vscsi_realize;
1277    k->reset = spapr_vscsi_reset;
1278    k->devnode = spapr_vscsi_devnode;
1279    k->dt_name = "v-scsi";
1280    k->dt_type = "vscsi";
1281    k->dt_compatible = "IBM,v-scsi";
1282    k->signal_mask = 0x00000001;
1283    set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1284    device_class_set_props(dc, spapr_vscsi_properties);
1285    k->rtce_window_size = 0x10000000;
1286    dc->vmsd = &vmstate_spapr_vscsi;
1287}
1288
1289static const TypeInfo spapr_vscsi_info = {
1290    .name          = TYPE_VIO_SPAPR_VSCSI_DEVICE,
1291    .parent        = TYPE_VIO_SPAPR_DEVICE,
1292    .instance_size = sizeof(VSCSIState),
1293    .class_init    = spapr_vscsi_class_init,
1294};
1295
1296static void spapr_vscsi_register_types(void)
1297{
1298    type_register_static(&spapr_vscsi_info);
1299}
1300
1301type_init(spapr_vscsi_register_types)
1302