hw/usb/dev-storage.c

   1 /*
   2  * USB Mass Storage Device emulation
   3  *
   4  * Copyright (c) 2006 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licensed under the LGPL.
   8  */
   9
  10 #include "qemu-common.h"
  11 #include "qemu-option.h"
  12 #include "qemu-config.h"
  13 #include "hw/usb.h"
  14 #include "hw/usb/desc.h"
  15 #include "hw/scsi.h"
  16 #include "console.h"
  17 #include "monitor.h"
  18 #include "sysemu.h"
  19 #include "blockdev.h"
  20
  21 //#define DEBUG_MSD
  22
  23 #ifdef DEBUG_MSD
  24 #define DPRINTF(fmt, ...) \
  25 do { printf("usb-msd: " fmt , ## __VA_ARGS__); } while (0)
  26 #else
  27 #define DPRINTF(fmt, ...) do {} while(0)
  28 #endif
  29
  30 /* USB requests.  */
  31 #define MassStorageReset  0xff
  32 #define GetMaxLun         0xfe
  33
  34 enum USBMSDMode {
  35     USB_MSDM_CBW, /* Command Block.  */
  36     USB_MSDM_DATAOUT, /* Transfer data to device.  */
  37     USB_MSDM_DATAIN, /* Transfer data from device.  */
  38     USB_MSDM_CSW /* Command Status.  */
  39 };
  40
  41 struct usb_msd_csw {
  42     uint32_t sig;
  43     uint32_t tag;
  44     uint32_t residue;
  45     uint8_t status;
  46 };
  47
  48 typedef struct {
  49     USBDevice dev;
  50     enum USBMSDMode mode;
  51     uint32_t scsi_off;
  52     uint32_t scsi_len;
  53     uint32_t data_len;
  54     struct usb_msd_csw csw;
  55     SCSIRequest *req;
  56     SCSIBus bus;
  57     BlockConf conf;
  58     char *serial;
  59     SCSIDevice *scsi_dev;
  60     uint32_t removable;
  61     /* For async completion.  */
  62     USBPacket *packet;
  63 } MSDState;
  64
  65 struct usb_msd_cbw {
  66     uint32_t sig;
  67     uint32_t tag;
  68     uint32_t data_len;
  69     uint8_t flags;
  70     uint8_t lun;
  71     uint8_t cmd_len;
  72     uint8_t cmd[16];
  73 };
  74
  75 enum {
  76     STR_MANUFACTURER = 1,
  77     STR_PRODUCT,
  78     STR_SERIALNUMBER,
  79     STR_CONFIG_FULL,
  80     STR_CONFIG_HIGH,
  81     STR_CONFIG_SUPER,
  82 };
  83
  84 static const USBDescStrings desc_strings = {
  85     [STR_MANUFACTURER] = "QEMU",
  86     [STR_PRODUCT]      = "QEMU USB HARDDRIVE",
  87     [STR_SERIALNUMBER] = "1",
  88     [STR_CONFIG_FULL]  = "Full speed config (usb 1.1)",
  89     [STR_CONFIG_HIGH]  = "High speed config (usb 2.0)",
  90     [STR_CONFIG_SUPER] = "Super speed config (usb 3.0)",
  91 };
  92
  93 static const USBDescIface desc_iface_full = {
  94     .bInterfaceNumber              = 0,
  95     .bNumEndpoints                 = 2,
  96     .bInterfaceClass               = USB_CLASS_MASS_STORAGE,
  97     .bInterfaceSubClass            = 0x06, /* SCSI */
  98     .bInterfaceProtocol            = 0x50, /* Bulk */
  99     .eps = (USBDescEndpoint[]) {
 100         {
 101             .bEndpointAddress      = USB_DIR_IN | 0x01,
 102             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 103             .wMaxPacketSize        = 64,
 104         },{
 105             .bEndpointAddress      = USB_DIR_OUT | 0x02,
 106             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 107             .wMaxPacketSize        = 64,
 108         },
 109     }
 110 };
 111
 112 static const USBDescDevice desc_device_full = {
 113     .bcdUSB                        = 0x0200,
 114     .bMaxPacketSize0               = 8,
 115     .bNumConfigurations            = 1,
 116     .confs = (USBDescConfig[]) {
 117         {
 118             .bNumInterfaces        = 1,
 119             .bConfigurationValue   = 1,
 120             .iConfiguration        = STR_CONFIG_FULL,
 121             .bmAttributes          = 0xc0,
 122             .nif = 1,
 123             .ifs = &desc_iface_full,
 124         },
 125     },
 126 };
 127
 128 static const USBDescIface desc_iface_high = {
 129     .bInterfaceNumber              = 0,
 130     .bNumEndpoints                 = 2,
 131     .bInterfaceClass               = USB_CLASS_MASS_STORAGE,
 132     .bInterfaceSubClass            = 0x06, /* SCSI */
 133     .bInterfaceProtocol            = 0x50, /* Bulk */
 134     .eps = (USBDescEndpoint[]) {
 135         {
 136             .bEndpointAddress      = USB_DIR_IN | 0x01,
 137             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 138             .wMaxPacketSize        = 512,
 139         },{
 140             .bEndpointAddress      = USB_DIR_OUT | 0x02,
 141             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 142             .wMaxPacketSize        = 512,
 143         },
 144     }
 145 };
 146
 147 static const USBDescDevice desc_device_high = {
 148     .bcdUSB                        = 0x0200,
 149     .bMaxPacketSize0               = 64,
 150     .bNumConfigurations            = 1,
 151     .confs = (USBDescConfig[]) {
 152         {
 153             .bNumInterfaces        = 1,
 154             .bConfigurationValue   = 1,
 155             .iConfiguration        = STR_CONFIG_HIGH,
 156             .bmAttributes          = 0xc0,
 157             .nif = 1,
 158             .ifs = &desc_iface_high,
 159         },
 160     },
 161 };
 162
 163 static const USBDescIface desc_iface_super = {
 164     .bInterfaceNumber              = 0,
 165     .bNumEndpoints                 = 2,
 166     .bInterfaceClass               = USB_CLASS_MASS_STORAGE,
 167     .bInterfaceSubClass            = 0x06, /* SCSI */
 168     .bInterfaceProtocol            = 0x50, /* Bulk */
 169     .eps = (USBDescEndpoint[]) {
 170         {
 171             .bEndpointAddress      = USB_DIR_IN | 0x01,
 172             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 173             .wMaxPacketSize        = 1024,
 174             .bMaxBurst             = 15,
 175         },{
 176             .bEndpointAddress      = USB_DIR_OUT | 0x02,
 177             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 178             .wMaxPacketSize        = 1024,
 179             .bMaxBurst             = 15,
 180         },
 181     }
 182 };
 183
 184 static const USBDescDevice desc_device_super = {
 185     .bcdUSB                        = 0x0300,
 186     .bMaxPacketSize0               = 9,
 187     .bNumConfigurations            = 1,
 188     .confs = (USBDescConfig[]) {
 189         {
 190             .bNumInterfaces        = 1,
 191             .bConfigurationValue   = 1,
 192             .iConfiguration        = STR_CONFIG_SUPER,
 193             .bmAttributes          = 0xc0,
 194             .nif = 1,
 195             .ifs = &desc_iface_super,
 196         },
 197     },
 198 };
 199
 200 static const USBDesc desc = {
 201     .id = {
 202         .idVendor          = 0x46f4, /* CRC16() of "QEMU" */
 203         .idProduct         = 0x0001,
 204         .bcdDevice         = 0,
 205         .iManufacturer     = STR_MANUFACTURER,
 206         .iProduct          = STR_PRODUCT,
 207         .iSerialNumber     = STR_SERIALNUMBER,
 208     },
 209     .full  = &desc_device_full,
 210     .high  = &desc_device_high,
 211     .super = &desc_device_super,
 212     .str   = desc_strings,
 213 };
 214
 215 static void usb_msd_copy_data(MSDState *s, USBPacket *p)
 216 {
 217     uint32_t len;
 218     len = p->iov.size - p->result;
 219     if (len > s->scsi_len)
 220         len = s->scsi_len;
 221     usb_packet_copy(p, scsi_req_get_buf(s->req) + s->scsi_off, len);
 222     s->scsi_len -= len;
 223     s->scsi_off += len;
 224     s->data_len -= len;
 225     if (s->scsi_len == 0 || s->data_len == 0) {
 226         scsi_req_continue(s->req);
 227     }
 228 }
 229
 230 static void usb_msd_send_status(MSDState *s, USBPacket *p)
 231 {
 232     int len;
 233
 234     DPRINTF("Command status %d tag 0x%x, len %zd\n",
 235             s->csw.status, le32_to_cpu(s->csw.tag), p->iov.size);
 236
 237     assert(s->csw.sig == cpu_to_le32(0x53425355));
 238     len = MIN(sizeof(s->csw), p->iov.size);
 239     usb_packet_copy(p, &s->csw, len);
 240     memset(&s->csw, 0, sizeof(s->csw));
 241 }
 242
 243 static void usb_msd_packet_complete(MSDState *s)
 244 {
 245     USBPacket *p = s->packet;
 246
 247     /* Set s->packet to NULL before calling usb_packet_complete
 248        because another request may be issued before
 249        usb_packet_complete returns.  */
 250     DPRINTF("Packet complete %p\n", p);
 251     s->packet = NULL;
 252     usb_packet_complete(&s->dev, p);
 253 }
 254
 255 static void usb_msd_transfer_data(SCSIRequest *req, uint32_t len)
 256 {
 257     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 258     USBPacket *p = s->packet;
 259
 260     assert((s->mode == USB_MSDM_DATAOUT) == (req->cmd.mode == SCSI_XFER_TO_DEV));
 261     s->scsi_len = len;
 262     s->scsi_off = 0;
 263     if (p) {
 264         usb_msd_copy_data(s, p);
 265         p = s->packet;
 266         if (p && p->result == p->iov.size) {
 267             usb_msd_packet_complete(s);
 268         }
 269     }
 270 }
 271
 272 static void usb_msd_command_complete(SCSIRequest *req, uint32_t status, size_t resid)
 273 {
 274     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 275     USBPacket *p = s->packet;
 276
 277     DPRINTF("Command complete %d tag 0x%x\n", status, req->tag);
 278
 279     s->csw.sig = cpu_to_le32(0x53425355);
 280     s->csw.tag = cpu_to_le32(req->tag);
 281     s->csw.residue = cpu_to_le32(s->data_len);
 282     s->csw.status = status != 0;
 283
 284     if (s->packet) {
 285         if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) {
 286             /* A deferred packet with no write data remaining must be
 287                the status read packet.  */
 288             usb_msd_send_status(s, p);
 289             s->mode = USB_MSDM_CBW;
 290         } else if (s->mode == USB_MSDM_CSW) {
 291             usb_msd_send_status(s, p);
 292             s->mode = USB_MSDM_CBW;
 293         } else {
 294             if (s->data_len) {
 295                 int len = (p->iov.size - p->result);
 296                 usb_packet_skip(p, len);
 297                 s->data_len -= len;
 298             }
 299             if (s->data_len == 0) {
 300                 s->mode = USB_MSDM_CSW;
 301             }
 302         }
 303         usb_msd_packet_complete(s);
 304     } else if (s->data_len == 0) {
 305         s->mode = USB_MSDM_CSW;
 306     }
 307     scsi_req_unref(req);
 308     s->req = NULL;
 309 }
 310
 311 static void usb_msd_request_cancelled(SCSIRequest *req)
 312 {
 313     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 314
 315     if (req == s->req) {
 316         scsi_req_unref(s->req);
 317         s->req = NULL;
 318         s->scsi_len = 0;
 319     }
 320 }
 321
 322 static void usb_msd_handle_reset(USBDevice *dev)
 323 {
 324     MSDState *s = (MSDState *)dev;
 325
 326     DPRINTF("Reset\n");
 327     if (s->req) {
 328         scsi_req_cancel(s->req);
 329     }
 330     assert(s->req == NULL);
 331
 332     if (s->packet) {
 333         s->packet->result = USB_RET_STALL;
 334         usb_msd_packet_complete(s);
 335     }
 336
 337     s->mode = USB_MSDM_CBW;
 338 }
 339
 340 static int usb_msd_handle_control(USBDevice *dev, USBPacket *p,
 341                int request, int value, int index, int length, uint8_t *data)
 342 {
 343     MSDState *s = (MSDState *)dev;
 344     int ret;
 345
 346     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
 347     if (ret >= 0) {
 348         return ret;
 349     }
 350
 351     ret = 0;
 352     switch (request) {
 353     case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
 354         ret = 0;
 355         break;
 356         /* Class specific requests.  */
 357     case ClassInterfaceOutRequest | MassStorageReset:
 358         /* Reset state ready for the next CBW.  */
 359         s->mode = USB_MSDM_CBW;
 360         ret = 0;
 361         break;
 362     case ClassInterfaceRequest | GetMaxLun:
 363         data[0] = 0;
 364         ret = 1;
 365         break;
 366     default:
 367         ret = USB_RET_STALL;
 368         break;
 369     }
 370     return ret;
 371 }
 372
 373 static void usb_msd_cancel_io(USBDevice *dev, USBPacket *p)
 374 {
 375     MSDState *s = DO_UPCAST(MSDState, dev, dev);
 376
 377     assert(s->packet == p);
 378     s->packet = NULL;
 379
 380     if (s->req) {
 381         scsi_req_cancel(s->req);
 382     }
 383 }
 384
 385 static int usb_msd_handle_data(USBDevice *dev, USBPacket *p)
 386 {
 387     MSDState *s = (MSDState *)dev;
 388     uint32_t tag;
 389     int ret = 0;
 390     struct usb_msd_cbw cbw;
 391     uint8_t devep = p->ep->nr;
 392
 393     switch (p->pid) {
 394     case USB_TOKEN_OUT:
 395         if (devep != 2)
 396             goto fail;
 397
 398         switch (s->mode) {
 399         case USB_MSDM_CBW:
 400             if (p->iov.size != 31) {
 401                 fprintf(stderr, "usb-msd: Bad CBW size");
 402                 goto fail;
 403             }
 404             usb_packet_copy(p, &cbw, 31);
 405             if (le32_to_cpu(cbw.sig) != 0x43425355) {
 406                 fprintf(stderr, "usb-msd: Bad signature %08x\n",
 407                         le32_to_cpu(cbw.sig));
 408                 goto fail;
 409             }
 410             DPRINTF("Command on LUN %d\n", cbw.lun);
 411             if (cbw.lun != 0) {
 412                 fprintf(stderr, "usb-msd: Bad LUN %d\n", cbw.lun);
 413                 goto fail;
 414             }
 415             tag = le32_to_cpu(cbw.tag);
 416             s->data_len = le32_to_cpu(cbw.data_len);
 417             if (s->data_len == 0) {
 418                 s->mode = USB_MSDM_CSW;
 419             } else if (cbw.flags & 0x80) {
 420                 s->mode = USB_MSDM_DATAIN;
 421             } else {
 422                 s->mode = USB_MSDM_DATAOUT;
 423             }
 424             DPRINTF("Command tag 0x%x flags %08x len %d data %d\n",
 425                     tag, cbw.flags, cbw.cmd_len, s->data_len);
 426             assert(le32_to_cpu(s->csw.residue) == 0);
 427             s->scsi_len = 0;
 428             s->req = scsi_req_new(s->scsi_dev, tag, 0, cbw.cmd, NULL);
 429 #ifdef DEBUG_MSD
 430             scsi_req_print(s->req);
 431 #endif
 432             scsi_req_enqueue(s->req);
 433             if (s->req && s->req->cmd.xfer != SCSI_XFER_NONE) {
 434                 scsi_req_continue(s->req);
 435             }
 436             ret = p->result;
 437             break;
 438
 439         case USB_MSDM_DATAOUT:
 440             DPRINTF("Data out %zd/%d\n", p->iov.size, s->data_len);
 441             if (p->iov.size > s->data_len) {
 442                 goto fail;
 443             }
 444
 445             if (s->scsi_len) {
 446                 usb_msd_copy_data(s, p);
 447             }
 448             if (le32_to_cpu(s->csw.residue)) {
 449                 int len = p->iov.size - p->result;
 450                 if (len) {
 451                     usb_packet_skip(p, len);
 452                     s->data_len -= len;
 453                     if (s->data_len == 0) {
 454                         s->mode = USB_MSDM_CSW;
 455                     }
 456                 }
 457             }
 458             if (p->result < p->iov.size) {
 459                 DPRINTF("Deferring packet %p [wait data-out]\n", p);
 460                 s->packet = p;
 461                 ret = USB_RET_ASYNC;
 462             } else {
 463                 ret = p->result;
 464             }
 465             break;
 466
 467         default:
 468             DPRINTF("Unexpected write (len %zd)\n", p->iov.size);
 469             goto fail;
 470         }
 471         break;
 472
 473     case USB_TOKEN_IN:
 474         if (devep != 1)
 475             goto fail;
 476
 477         switch (s->mode) {
 478         case USB_MSDM_DATAOUT:
 479             if (s->data_len != 0 || p->iov.size < 13) {
 480                 goto fail;
 481             }
 482             /* Waiting for SCSI write to complete.  */
 483             s->packet = p;
 484             ret = USB_RET_ASYNC;
 485             break;
 486
 487         case USB_MSDM_CSW:
 488             if (p->iov.size < 13) {
 489                 goto fail;
 490             }
 491
 492             if (s->req) {
 493                 /* still in flight */
 494                 DPRINTF("Deferring packet %p [wait status]\n", p);
 495                 s->packet = p;
 496                 ret = USB_RET_ASYNC;
 497             } else {
 498                 usb_msd_send_status(s, p);
 499                 s->mode = USB_MSDM_CBW;
 500                 ret = 13;
 501             }
 502             break;
 503
 504         case USB_MSDM_DATAIN:
 505             DPRINTF("Data in %zd/%d, scsi_len %d\n",
 506                     p->iov.size, s->data_len, s->scsi_len);
 507             if (s->scsi_len) {
 508                 usb_msd_copy_data(s, p);
 509             }
 510             if (le32_to_cpu(s->csw.residue)) {
 511                 int len = p->iov.size - p->result;
 512                 if (len) {
 513                     usb_packet_skip(p, len);
 514                     s->data_len -= len;
 515                     if (s->data_len == 0) {
 516                         s->mode = USB_MSDM_CSW;
 517                     }
 518                 }
 519             }
 520             if (p->result < p->iov.size) {
 521                 DPRINTF("Deferring packet %p [wait data-in]\n", p);
 522                 s->packet = p;
 523                 ret = USB_RET_ASYNC;
 524             } else {
 525                 ret = p->result;
 526             }
 527             break;
 528
 529         default:
 530             DPRINTF("Unexpected read (len %zd)\n", p->iov.size);
 531             goto fail;
 532         }
 533         break;
 534
 535     default:
 536         DPRINTF("Bad token\n");
 537     fail:
 538         ret = USB_RET_STALL;
 539         break;
 540     }
 541
 542     return ret;
 543 }
 544
 545 static void usb_msd_password_cb(void *opaque, int err)
 546 {
 547     MSDState *s = opaque;
 548
 549     if (!err)
 550         err = usb_device_attach(&s->dev);
 551
 552     if (err)
 553         qdev_unplug(&s->dev.qdev, NULL);
 554 }
 555
 556 static void *usb_msd_load_request(QEMUFile *f, SCSIRequest *req)
 557 {
 558     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 559
 560     /* nothing to load, just store req in our state struct */
 561     assert(s->req == NULL);
 562     scsi_req_ref(req);
 563     s->req = req;
 564     return NULL;
 565 }
 566
 567 static const struct SCSIBusInfo usb_msd_scsi_info = {
 568     .tcq = false,
 569     .max_target = 0,
 570     .max_lun = 0,
 571
 572     .transfer_data = usb_msd_transfer_data,
 573     .complete = usb_msd_command_complete,
 574     .cancel = usb_msd_request_cancelled,
 575     .load_request = usb_msd_load_request,
 576 };
 577
 578 static int usb_msd_initfn(USBDevice *dev)
 579 {
 580     MSDState *s = DO_UPCAST(MSDState, dev, dev);
 581     BlockDriverState *bs = s->conf.bs;
 582
 583     if (!bs) {
 584         error_report("drive property not set");
 585         return -1;
 586     }
 587
 588     blkconf_serial(&s->conf, &s->serial);
 589
 590     /*
 591      * Hack alert: this pretends to be a block device, but it's really
 592      * a SCSI bus that can serve only a single device, which it
 593      * creates automatically.  But first it needs to detach from its
 594      * blockdev, or else scsi_bus_legacy_add_drive() dies when it
 595      * attaches again.
 596      *
 597      * The hack is probably a bad idea.
 598      */
 599     bdrv_detach_dev(bs, &s->dev.qdev);
 600     s->conf.bs = NULL;
 601
 602     if (s->serial) {
 603         usb_desc_set_string(dev, STR_SERIALNUMBER, s->serial);
 604     } else {
 605         usb_desc_create_serial(dev);
 606     }
 607
 608     usb_desc_init(dev);
 609     scsi_bus_new(&s->bus, &s->dev.qdev, &usb_msd_scsi_info);
 610     s->scsi_dev = scsi_bus_legacy_add_drive(&s->bus, bs, 0, !!s->removable,
 611                                             s->conf.bootindex);
 612     if (!s->scsi_dev) {
 613         return -1;
 614     }
 615     s->bus.qbus.allow_hotplug = 0;
 616     usb_msd_handle_reset(dev);
 617
 618     if (bdrv_key_required(bs)) {
 619         if (cur_mon) {
 620             monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb, s);
 621             s->dev.auto_attach = 0;
 622         } else {
 623             autostart = 0;
 624         }
 625     }
 626
 627     return 0;
 628 }
 629
 630 static USBDevice *usb_msd_init(USBBus *bus, const char *filename)
 631 {
 632     static int nr=0;
 633     char id[8];
 634     QemuOpts *opts;
 635     DriveInfo *dinfo;
 636     USBDevice *dev;
 637     const char *p1;
 638     char fmt[32];
 639
 640     /* parse -usbdevice disk: syntax into drive opts */
 641     snprintf(id, sizeof(id), "usb%d", nr++);
 642     opts = qemu_opts_create(qemu_find_opts("drive"), id, 0, NULL);
 643
 644     p1 = strchr(filename, ':');
 645     if (p1++) {
 646         const char *p2;
 647
 648         if (strstart(filename, "format=", &p2)) {
 649             int len = MIN(p1 - p2, sizeof(fmt));
 650             pstrcpy(fmt, len, p2);
 651             qemu_opt_set(opts, "format", fmt);
 652         } else if (*filename != ':') {
 653             printf("unrecognized USB mass-storage option %s\n", filename);
 654             return NULL;
 655         }
 656         filename = p1;
 657     }
 658     if (!*filename) {
 659         printf("block device specification needed\n");
 660         return NULL;
 661     }
 662     qemu_opt_set(opts, "file", filename);
 663     qemu_opt_set(opts, "if", "none");
 664
 665     /* create host drive */
 666     dinfo = drive_init(opts, 0);
 667     if (!dinfo) {
 668         qemu_opts_del(opts);
 669         return NULL;
 670     }
 671
 672     /* create guest device */
 673     dev = usb_create(bus, "usb-storage");
 674     if (!dev) {
 675         return NULL;
 676     }
 677     if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) {
 678         qdev_free(&dev->qdev);
 679         return NULL;
 680     }
 681     if (qdev_init(&dev->qdev) < 0)
 682         return NULL;
 683
 684     return dev;
 685 }
 686
 687 static const VMStateDescription vmstate_usb_msd = {
 688     .name = "usb-storage",
 689     .version_id = 1,
 690     .minimum_version_id = 1,
 691     .fields = (VMStateField []) {
 692         VMSTATE_USB_DEVICE(dev, MSDState),
 693         VMSTATE_UINT32(mode, MSDState),
 694         VMSTATE_UINT32(scsi_len, MSDState),
 695         VMSTATE_UINT32(scsi_off, MSDState),
 696         VMSTATE_UINT32(data_len, MSDState),
 697         VMSTATE_UINT32(csw.sig, MSDState),
 698         VMSTATE_UINT32(csw.tag, MSDState),
 699         VMSTATE_UINT32(csw.residue, MSDState),
 700         VMSTATE_UINT8(csw.status, MSDState),
 701         VMSTATE_END_OF_LIST()
 702     }
 703 };
 704
 705 static Property msd_properties[] = {
 706     DEFINE_BLOCK_PROPERTIES(MSDState, conf),
 707     DEFINE_PROP_STRING("serial", MSDState, serial),
 708     DEFINE_PROP_BIT("removable", MSDState, removable, 0, false),
 709     DEFINE_PROP_END_OF_LIST(),
 710 };
 711
 712 static void usb_msd_class_initfn(ObjectClass *klass, void *data)
 713 {
 714     DeviceClass *dc = DEVICE_CLASS(klass);
 715     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
 716
 717     uc->init           = usb_msd_initfn;
 718     uc->product_desc   = "QEMU USB MSD";
 719     uc->usb_desc       = &desc;
 720     uc->cancel_packet  = usb_msd_cancel_io;
 721     uc->handle_attach  = usb_desc_attach;
 722     uc->handle_reset   = usb_msd_handle_reset;
 723     uc->handle_control = usb_msd_handle_control;
 724     uc->handle_data    = usb_msd_handle_data;
 725     dc->fw_name = "storage";
 726     dc->vmsd = &vmstate_usb_msd;
 727     dc->props = msd_properties;
 728 }
 729
 730 static TypeInfo msd_info = {
 731     .name          = "usb-storage",
 732     .parent        = TYPE_USB_DEVICE,
 733     .instance_size = sizeof(MSDState),
 734     .class_init    = usb_msd_class_initfn,
 735 };
 736
 737 static void usb_msd_register_types(void)
 738 {
 739     type_register_static(&msd_info);
 740     usb_legacy_register("usb-storage", "disk", usb_msd_init);
 741 }
 742
 743 type_init(usb_msd_register_types)