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