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/osdep.h"
  11 #include "qapi/error.h"
  12 #include "qemu/error-report.h"
  13 #include "qemu/module.h"
  14 #include "qemu/option.h"
  15 #include "qemu/config-file.h"
  16 #include "hw/usb.h"
  17 #include "hw/usb/msd.h"
  18 #include "desc.h"
  19 #include "hw/qdev-properties.h"
  20 #include "hw/scsi/scsi.h"
  21 #include "migration/vmstate.h"
  22 #include "qemu/cutils.h"
  23 #include "qom/object.h"
  24 #include "trace.h"
  25
  26 /* USB requests.  */
  27 #define MassStorageReset  0xff
  28 #define GetMaxLun         0xfe
  29
  30 struct usb_msd_cbw {
  31     uint32_t sig;
  32     uint32_t tag;
  33     uint32_t data_len;
  34     uint8_t flags;
  35     uint8_t lun;
  36     uint8_t cmd_len;
  37     uint8_t cmd[16];
  38 };
  39
  40 enum {
  41     STR_MANUFACTURER = 1,
  42     STR_PRODUCT,
  43     STR_SERIALNUMBER,
  44     STR_CONFIG_FULL,
  45     STR_CONFIG_HIGH,
  46     STR_CONFIG_SUPER,
  47 };
  48
  49 static const USBDescStrings desc_strings = {
  50     [STR_MANUFACTURER] = "QEMU",
  51     [STR_PRODUCT]      = "QEMU USB HARDDRIVE",
  52     [STR_SERIALNUMBER] = "1",
  53     [STR_CONFIG_FULL]  = "Full speed config (usb 1.1)",
  54     [STR_CONFIG_HIGH]  = "High speed config (usb 2.0)",
  55     [STR_CONFIG_SUPER] = "Super speed config (usb 3.0)",
  56 };
  57
  58 static const USBDescIface desc_iface_full = {
  59     .bInterfaceNumber              = 0,
  60     .bNumEndpoints                 = 2,
  61     .bInterfaceClass               = USB_CLASS_MASS_STORAGE,
  62     .bInterfaceSubClass            = 0x06, /* SCSI */
  63     .bInterfaceProtocol            = 0x50, /* Bulk */
  64     .eps = (USBDescEndpoint[]) {
  65         {
  66             .bEndpointAddress      = USB_DIR_IN | 0x01,
  67             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
  68             .wMaxPacketSize        = 64,
  69         },{
  70             .bEndpointAddress      = USB_DIR_OUT | 0x02,
  71             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
  72             .wMaxPacketSize        = 64,
  73         },
  74     }
  75 };
  76
  77 static const USBDescDevice desc_device_full = {
  78     .bcdUSB                        = 0x0200,
  79     .bMaxPacketSize0               = 8,
  80     .bNumConfigurations            = 1,
  81     .confs = (USBDescConfig[]) {
  82         {
  83             .bNumInterfaces        = 1,
  84             .bConfigurationValue   = 1,
  85             .iConfiguration        = STR_CONFIG_FULL,
  86             .bmAttributes          = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
  87             .nif = 1,
  88             .ifs = &desc_iface_full,
  89         },
  90     },
  91 };
  92
  93 static const USBDescIface desc_iface_high = {
  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        = 512,
 104         },{
 105             .bEndpointAddress      = USB_DIR_OUT | 0x02,
 106             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 107             .wMaxPacketSize        = 512,
 108         },
 109     }
 110 };
 111
 112 static const USBDescDevice desc_device_high = {
 113     .bcdUSB                        = 0x0200,
 114     .bMaxPacketSize0               = 64,
 115     .bNumConfigurations            = 1,
 116     .confs = (USBDescConfig[]) {
 117         {
 118             .bNumInterfaces        = 1,
 119             .bConfigurationValue   = 1,
 120             .iConfiguration        = STR_CONFIG_HIGH,
 121             .bmAttributes          = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
 122             .nif = 1,
 123             .ifs = &desc_iface_high,
 124         },
 125     },
 126 };
 127
 128 static const USBDescIface desc_iface_super = {
 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        = 1024,
 139             .bMaxBurst             = 15,
 140         },{
 141             .bEndpointAddress      = USB_DIR_OUT | 0x02,
 142             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 143             .wMaxPacketSize        = 1024,
 144             .bMaxBurst             = 15,
 145         },
 146     }
 147 };
 148
 149 static const USBDescDevice desc_device_super = {
 150     .bcdUSB                        = 0x0300,
 151     .bMaxPacketSize0               = 9,
 152     .bNumConfigurations            = 1,
 153     .confs = (USBDescConfig[]) {
 154         {
 155             .bNumInterfaces        = 1,
 156             .bConfigurationValue   = 1,
 157             .iConfiguration        = STR_CONFIG_SUPER,
 158             .bmAttributes          = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
 159             .nif = 1,
 160             .ifs = &desc_iface_super,
 161         },
 162     },
 163 };
 164
 165 static const USBDesc desc = {
 166     .id = {
 167         .idVendor          = 0x46f4, /* CRC16() of "QEMU" */
 168         .idProduct         = 0x0001,
 169         .bcdDevice         = 0,
 170         .iManufacturer     = STR_MANUFACTURER,
 171         .iProduct          = STR_PRODUCT,
 172         .iSerialNumber     = STR_SERIALNUMBER,
 173     },
 174     .full  = &desc_device_full,
 175     .high  = &desc_device_high,
 176     .super = &desc_device_super,
 177     .str   = desc_strings,
 178 };
 179
 180 static void usb_msd_copy_data(MSDState *s, USBPacket *p)
 181 {
 182     uint32_t len;
 183     len = p->iov.size - p->actual_length;
 184     if (len > s->scsi_len)
 185         len = s->scsi_len;
 186     usb_packet_copy(p, scsi_req_get_buf(s->req) + s->scsi_off, len);
 187     s->scsi_len -= len;
 188     s->scsi_off += len;
 189     if (len > s->data_len) {
 190         len = s->data_len;
 191     }
 192     s->data_len -= len;
 193     if (s->scsi_len == 0 || s->data_len == 0) {
 194         scsi_req_continue(s->req);
 195     }
 196 }
 197
 198 static void usb_msd_send_status(MSDState *s, USBPacket *p)
 199 {
 200     int len;
 201
 202     trace_usb_msd_send_status(s->csw.status, le32_to_cpu(s->csw.tag),
 203                               p->iov.size);
 204
 205     assert(s->csw.sig == cpu_to_le32(0x53425355));
 206     len = MIN(sizeof(s->csw), p->iov.size);
 207     usb_packet_copy(p, &s->csw, len);
 208     memset(&s->csw, 0, sizeof(s->csw));
 209 }
 210
 211 static void usb_msd_packet_complete(MSDState *s)
 212 {
 213     USBPacket *p = s->packet;
 214
 215     /* Set s->packet to NULL before calling usb_packet_complete
 216        because another request may be issued before
 217        usb_packet_complete returns.  */
 218     trace_usb_msd_packet_complete();
 219     s->packet = NULL;
 220     usb_packet_complete(&s->dev, p);
 221 }
 222
 223 void usb_msd_transfer_data(SCSIRequest *req, uint32_t len)
 224 {
 225     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 226     USBPacket *p = s->packet;
 227
 228     assert((s->mode == USB_MSDM_DATAOUT) == (req->cmd.mode == SCSI_XFER_TO_DEV));
 229     s->scsi_len = len;
 230     s->scsi_off = 0;
 231     if (p) {
 232         usb_msd_copy_data(s, p);
 233         p = s->packet;
 234         if (p && p->actual_length == p->iov.size) {
 235             p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
 236             usb_msd_packet_complete(s);
 237         }
 238     }
 239 }
 240
 241 void usb_msd_command_complete(SCSIRequest *req, size_t resid)
 242 {
 243     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 244     USBPacket *p = s->packet;
 245
 246     trace_usb_msd_cmd_complete(req->status, req->tag);
 247
 248     s->csw.sig = cpu_to_le32(0x53425355);
 249     s->csw.tag = cpu_to_le32(req->tag);
 250     s->csw.residue = cpu_to_le32(s->data_len);
 251     s->csw.status = req->status != 0;
 252
 253     if (s->packet) {
 254         if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) {
 255             /* A deferred packet with no write data remaining must be
 256                the status read packet.  */
 257             usb_msd_send_status(s, p);
 258             s->mode = USB_MSDM_CBW;
 259         } else if (s->mode == USB_MSDM_CSW) {
 260             usb_msd_send_status(s, p);
 261             s->mode = USB_MSDM_CBW;
 262         } else {
 263             if (s->data_len) {
 264                 int len = (p->iov.size - p->actual_length);
 265                 usb_packet_skip(p, len);
 266                 if (len > s->data_len) {
 267                     len = s->data_len;
 268                 }
 269                 s->data_len -= len;
 270             }
 271             if (s->data_len == 0) {
 272                 s->mode = USB_MSDM_CSW;
 273             }
 274         }
 275         p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
 276         usb_msd_packet_complete(s);
 277     } else if (s->data_len == 0) {
 278         s->mode = USB_MSDM_CSW;
 279     }
 280     scsi_req_unref(req);
 281     s->req = NULL;
 282 }
 283
 284 void usb_msd_request_cancelled(SCSIRequest *req)
 285 {
 286     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 287
 288     trace_usb_msd_cmd_cancel(req->tag);
 289
 290     if (req == s->req) {
 291         s->csw.sig = cpu_to_le32(0x53425355);
 292         s->csw.tag = cpu_to_le32(req->tag);
 293         s->csw.status = 1; /* error */
 294
 295         scsi_req_unref(s->req);
 296         s->req = NULL;
 297         s->scsi_len = 0;
 298     }
 299 }
 300
 301 void usb_msd_handle_reset(USBDevice *dev)
 302 {
 303     MSDState *s = (MSDState *)dev;
 304
 305     trace_usb_msd_reset();
 306     if (s->req) {
 307         scsi_req_cancel(s->req);
 308     }
 309     assert(s->req == NULL);
 310
 311     if (s->packet) {
 312         s->packet->status = USB_RET_STALL;
 313         usb_msd_packet_complete(s);
 314     }
 315
 316     memset(&s->csw, 0, sizeof(s->csw));
 317     s->mode = USB_MSDM_CBW;
 318 }
 319
 320 static void usb_msd_handle_control(USBDevice *dev, USBPacket *p,
 321                int request, int value, int index, int length, uint8_t *data)
 322 {
 323     MSDState *s = (MSDState *)dev;
 324     SCSIDevice *scsi_dev;
 325     int ret, maxlun;
 326
 327     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
 328     if (ret >= 0) {
 329         return;
 330     }
 331
 332     switch (request) {
 333     case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
 334         break;
 335         /* Class specific requests.  */
 336     case ClassInterfaceOutRequest | MassStorageReset:
 337         /* Reset state ready for the next CBW.  */
 338         s->mode = USB_MSDM_CBW;
 339         break;
 340     case ClassInterfaceRequest | GetMaxLun:
 341         maxlun = 0;
 342         for (;;) {
 343             scsi_dev = scsi_device_find(&s->bus, 0, 0, maxlun+1);
 344             if (scsi_dev == NULL) {
 345                 break;
 346             }
 347             if (scsi_dev->lun != maxlun+1) {
 348                 break;
 349             }
 350             maxlun++;
 351         }
 352         trace_usb_msd_maxlun(maxlun);
 353         data[0] = maxlun;
 354         p->actual_length = 1;
 355         break;
 356     default:
 357         p->status = USB_RET_STALL;
 358         break;
 359     }
 360 }
 361
 362 static void usb_msd_cancel_io(USBDevice *dev, USBPacket *p)
 363 {
 364     MSDState *s = USB_STORAGE_DEV(dev);
 365
 366     assert(s->packet == p);
 367     s->packet = NULL;
 368
 369     if (s->req) {
 370         scsi_req_cancel(s->req);
 371     }
 372 }
 373
 374 static void usb_msd_handle_data(USBDevice *dev, USBPacket *p)
 375 {
 376     MSDState *s = (MSDState *)dev;
 377     uint32_t tag;
 378     struct usb_msd_cbw cbw;
 379     uint8_t devep = p->ep->nr;
 380     SCSIDevice *scsi_dev;
 381     uint32_t len;
 382
 383     switch (p->pid) {
 384     case USB_TOKEN_OUT:
 385         if (devep != 2)
 386             goto fail;
 387
 388         switch (s->mode) {
 389         case USB_MSDM_CBW:
 390             if (p->iov.size != 31) {
 391                 error_report("usb-msd: Bad CBW size");
 392                 goto fail;
 393             }
 394             usb_packet_copy(p, &cbw, 31);
 395             if (le32_to_cpu(cbw.sig) != 0x43425355) {
 396                 error_report("usb-msd: Bad signature %08x",
 397                              le32_to_cpu(cbw.sig));
 398                 goto fail;
 399             }
 400             scsi_dev = scsi_device_find(&s->bus, 0, 0, cbw.lun);
 401             if (scsi_dev == NULL) {
 402                 error_report("usb-msd: Bad LUN %d", cbw.lun);
 403                 goto fail;
 404             }
 405             tag = le32_to_cpu(cbw.tag);
 406             s->data_len = le32_to_cpu(cbw.data_len);
 407             if (s->data_len == 0) {
 408                 s->mode = USB_MSDM_CSW;
 409             } else if (cbw.flags & 0x80) {
 410                 s->mode = USB_MSDM_DATAIN;
 411             } else {
 412                 s->mode = USB_MSDM_DATAOUT;
 413             }
 414             trace_usb_msd_cmd_submit(cbw.lun, tag, cbw.flags,
 415                                      cbw.cmd_len, s->data_len);
 416             assert(le32_to_cpu(s->csw.residue) == 0);
 417             s->scsi_len = 0;
 418             s->req = scsi_req_new(scsi_dev, tag, cbw.lun, cbw.cmd, NULL);
 419             if (s->commandlog) {
 420                 scsi_req_print(s->req);
 421             }
 422             len = scsi_req_enqueue(s->req);
 423             if (len) {
 424                 scsi_req_continue(s->req);
 425             }
 426             break;
 427
 428         case USB_MSDM_DATAOUT:
 429             trace_usb_msd_data_out(p->iov.size, s->data_len);
 430             if (p->iov.size > s->data_len) {
 431                 goto fail;
 432             }
 433
 434             if (s->scsi_len) {
 435                 usb_msd_copy_data(s, p);
 436             }
 437             if (le32_to_cpu(s->csw.residue)) {
 438                 int len = p->iov.size - p->actual_length;
 439                 if (len) {
 440                     usb_packet_skip(p, len);
 441                     if (len > s->data_len) {
 442                         len = s->data_len;
 443                     }
 444                     s->data_len -= len;
 445                     if (s->data_len == 0) {
 446                         s->mode = USB_MSDM_CSW;
 447                     }
 448                 }
 449             }
 450             if (p->actual_length < p->iov.size) {
 451                 trace_usb_msd_packet_async();
 452                 s->packet = p;
 453                 p->status = USB_RET_ASYNC;
 454             }
 455             break;
 456
 457         default:
 458             goto fail;
 459         }
 460         break;
 461
 462     case USB_TOKEN_IN:
 463         if (devep != 1)
 464             goto fail;
 465
 466         switch (s->mode) {
 467         case USB_MSDM_DATAOUT:
 468             if (s->data_len != 0 || p->iov.size < 13) {
 469                 goto fail;
 470             }
 471             /* Waiting for SCSI write to complete.  */
 472             trace_usb_msd_packet_async();
 473             s->packet = p;
 474             p->status = USB_RET_ASYNC;
 475             break;
 476
 477         case USB_MSDM_CSW:
 478             if (p->iov.size < 13) {
 479                 goto fail;
 480             }
 481
 482             if (s->req) {
 483                 /* still in flight */
 484                 trace_usb_msd_packet_async();
 485                 s->packet = p;
 486                 p->status = USB_RET_ASYNC;
 487             } else {
 488                 usb_msd_send_status(s, p);
 489                 s->mode = USB_MSDM_CBW;
 490             }
 491             break;
 492
 493         case USB_MSDM_DATAIN:
 494             trace_usb_msd_data_in(p->iov.size, s->data_len, s->scsi_len);
 495             if (s->scsi_len) {
 496                 usb_msd_copy_data(s, p);
 497             }
 498             if (le32_to_cpu(s->csw.residue)) {
 499                 int len = p->iov.size - p->actual_length;
 500                 if (len) {
 501                     usb_packet_skip(p, len);
 502                     if (len > s->data_len) {
 503                         len = s->data_len;
 504                     }
 505                     s->data_len -= len;
 506                     if (s->data_len == 0) {
 507                         s->mode = USB_MSDM_CSW;
 508                     }
 509                 }
 510             }
 511             if (p->actual_length < p->iov.size && s->mode == USB_MSDM_DATAIN) {
 512                 trace_usb_msd_packet_async();
 513                 s->packet = p;
 514                 p->status = USB_RET_ASYNC;
 515             }
 516             break;
 517
 518         default:
 519             goto fail;
 520         }
 521         break;
 522
 523     default:
 524     fail:
 525         p->status = USB_RET_STALL;
 526         break;
 527     }
 528 }
 529
 530 void *usb_msd_load_request(QEMUFile *f, SCSIRequest *req)
 531 {
 532     MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
 533
 534     /* nothing to load, just store req in our state struct */
 535     assert(s->req == NULL);
 536     scsi_req_ref(req);
 537     s->req = req;
 538     return NULL;
 539 }
 540
 541 static const VMStateDescription vmstate_usb_msd = {
 542     .name = "usb-storage",
 543     .version_id = 1,
 544     .minimum_version_id = 1,
 545     .fields = (VMStateField[]) {
 546         VMSTATE_USB_DEVICE(dev, MSDState),
 547         VMSTATE_UINT32(mode, MSDState),
 548         VMSTATE_UINT32(scsi_len, MSDState),
 549         VMSTATE_UINT32(scsi_off, MSDState),
 550         VMSTATE_UINT32(data_len, MSDState),
 551         VMSTATE_UINT32(csw.sig, MSDState),
 552         VMSTATE_UINT32(csw.tag, MSDState),
 553         VMSTATE_UINT32(csw.residue, MSDState),
 554         VMSTATE_UINT8(csw.status, MSDState),
 555         VMSTATE_END_OF_LIST()
 556     }
 557 };
 558
 559 static void usb_msd_class_initfn_common(ObjectClass *klass, void *data)
 560 {
 561     DeviceClass *dc = DEVICE_CLASS(klass);
 562     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
 563
 564     uc->product_desc   = "QEMU USB MSD";
 565     uc->usb_desc       = &desc;
 566     uc->cancel_packet  = usb_msd_cancel_io;
 567     uc->handle_attach  = usb_desc_attach;
 568     uc->handle_reset   = usb_msd_handle_reset;
 569     uc->handle_control = usb_msd_handle_control;
 570     uc->handle_data    = usb_msd_handle_data;
 571     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 572     dc->fw_name = "storage";
 573     dc->vmsd = &vmstate_usb_msd;
 574 }
 575
 576 static const TypeInfo usb_storage_dev_type_info = {
 577     .name = TYPE_USB_STORAGE,
 578     .parent = TYPE_USB_DEVICE,
 579     .instance_size = sizeof(MSDState),
 580     .abstract = true,
 581     .class_init = usb_msd_class_initfn_common,
 582 };
 583
 584 static void usb_msd_register_types(void)
 585 {
 586     type_register_static(&usb_storage_dev_type_info);
 587 }
 588
 589 type_init(usb_msd_register_types)