hw/usb/dev-uas.c

   1 /*
   2  * UAS (USB Attached SCSI) emulation
   3  *
   4  * Copyright Red Hat, Inc. 2012
   5  *
   6  * Author: Gerd Hoffmann <kraxel@redhat.com>
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   9  * See the COPYING file in the top-level directory.
  10  */
  11
  12 #include "qemu-common.h"
  13 #include "qemu-option.h"
  14 #include "qemu-config.h"
  15 #include "trace.h"
  16
  17 #include "hw/usb.h"
  18 #include "hw/usb/desc.h"
  19 #include "hw/scsi.h"
  20 #include "hw/scsi-defs.h"
  21
  22 /* --------------------------------------------------------------------- */
  23
  24 #define UAS_UI_COMMAND              0x01
  25 #define UAS_UI_SENSE                0x03
  26 #define UAS_UI_RESPONSE             0x04
  27 #define UAS_UI_TASK_MGMT            0x05
  28 #define UAS_UI_READ_READY           0x06
  29 #define UAS_UI_WRITE_READY          0x07
  30
  31 #define UAS_RC_TMF_COMPLETE         0x00
  32 #define UAS_RC_INVALID_INFO_UNIT    0x02
  33 #define UAS_RC_TMF_NOT_SUPPORTED    0x04
  34 #define UAS_RC_TMF_FAILED           0x05
  35 #define UAS_RC_TMF_SUCCEEDED        0x08
  36 #define UAS_RC_INCORRECT_LUN        0x09
  37 #define UAS_RC_OVERLAPPED_TAG       0x0a
  38
  39 #define UAS_TMF_ABORT_TASK          0x01
  40 #define UAS_TMF_ABORT_TASK_SET      0x02
  41 #define UAS_TMF_CLEAR_TASK_SET      0x04
  42 #define UAS_TMF_LOGICAL_UNIT_RESET  0x08
  43 #define UAS_TMF_I_T_NEXUS_RESET     0x10
  44 #define UAS_TMF_CLEAR_ACA           0x40
  45 #define UAS_TMF_QUERY_TASK          0x80
  46 #define UAS_TMF_QUERY_TASK_SET      0x81
  47 #define UAS_TMF_QUERY_ASYNC_EVENT   0x82
  48
  49 #define UAS_PIPE_ID_COMMAND         0x01
  50 #define UAS_PIPE_ID_STATUS          0x02
  51 #define UAS_PIPE_ID_DATA_IN         0x03
  52 #define UAS_PIPE_ID_DATA_OUT        0x04
  53
  54 typedef struct {
  55     uint8_t    id;
  56     uint8_t    reserved;
  57     uint16_t   tag;
  58 } QEMU_PACKED  uas_ui_header;
  59
  60 typedef struct {
  61     uint8_t    prio_taskattr;   /* 6:3 priority, 2:0 task attribute   */
  62     uint8_t    reserved_1;
  63     uint8_t    add_cdb_length;  /* 7:2 additional adb length (dwords) */
  64     uint8_t    reserved_2;
  65     uint64_t   lun;
  66     uint8_t    cdb[16];
  67     uint8_t    add_cdb[];
  68 } QEMU_PACKED  uas_ui_command;
  69
  70 typedef struct {
  71     uint16_t   status_qualifier;
  72     uint8_t    status;
  73     uint8_t    reserved[7];
  74     uint16_t   sense_length;
  75     uint8_t    sense_data[18];
  76 } QEMU_PACKED  uas_ui_sense;
  77
  78 typedef struct {
  79     uint16_t   add_response_info;
  80     uint8_t    response_code;
  81 } QEMU_PACKED  uas_ui_response;
  82
  83 typedef struct {
  84     uint8_t    function;
  85     uint8_t    reserved;
  86     uint16_t   task_tag;
  87     uint64_t   lun;
  88 } QEMU_PACKED  uas_ui_task_mgmt;
  89
  90 typedef struct {
  91     uas_ui_header  hdr;
  92     union {
  93         uas_ui_command   command;
  94         uas_ui_sense     sense;
  95         uas_ui_task_mgmt task;
  96         uas_ui_response  response;
  97     };
  98 } QEMU_PACKED  uas_ui;
  99
 100 /* --------------------------------------------------------------------- */
 101
 102 typedef struct UASDevice UASDevice;
 103 typedef struct UASRequest UASRequest;
 104 typedef struct UASStatus UASStatus;
 105
 106 struct UASDevice {
 107     USBDevice                 dev;
 108     SCSIBus                   bus;
 109     UASRequest                *datain;
 110     UASRequest                *dataout;
 111     USBPacket                 *status;
 112     QEMUBH                    *status_bh;
 113     QTAILQ_HEAD(, UASStatus)  results;
 114     QTAILQ_HEAD(, UASRequest) requests;
 115 };
 116
 117 struct UASRequest {
 118     uint16_t     tag;
 119     uint64_t     lun;
 120     UASDevice    *uas;
 121     SCSIDevice   *dev;
 122     SCSIRequest  *req;
 123     USBPacket    *data;
 124     bool         data_async;
 125     bool         active;
 126     bool         complete;
 127     uint32_t     buf_off;
 128     uint32_t     buf_size;
 129     uint32_t     data_off;
 130     uint32_t     data_size;
 131     QTAILQ_ENTRY(UASRequest)  next;
 132 };
 133
 134 struct UASStatus {
 135     uas_ui                    status;
 136     uint32_t                  length;
 137     QTAILQ_ENTRY(UASStatus)   next;
 138 };
 139
 140 /* --------------------------------------------------------------------- */
 141
 142 enum {
 143     STR_MANUFACTURER = 1,
 144     STR_PRODUCT,
 145     STR_SERIALNUMBER,
 146     STR_CONFIG_HIGH,
 147 };
 148
 149 static const USBDescStrings desc_strings = {
 150     [STR_MANUFACTURER] = "QEMU",
 151     [STR_PRODUCT]      = "USB Attached SCSI HBA",
 152     [STR_SERIALNUMBER] = "27842",
 153     [STR_CONFIG_HIGH]  = "High speed config (usb 2.0)",
 154 };
 155
 156 static const USBDescIface desc_iface_high = {
 157     .bInterfaceNumber              = 0,
 158     .bNumEndpoints                 = 4,
 159     .bInterfaceClass               = USB_CLASS_MASS_STORAGE,
 160     .bInterfaceSubClass            = 0x06, /* SCSI */
 161     .bInterfaceProtocol            = 0x62, /* UAS  */
 162     .eps = (USBDescEndpoint[]) {
 163         {
 164             .bEndpointAddress      = USB_DIR_OUT | UAS_PIPE_ID_COMMAND,
 165             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 166             .wMaxPacketSize        = 512,
 167             .extra = (uint8_t[]) {
 168                 0x04,  /*  u8  bLength */
 169                 0x24,  /*  u8  bDescriptorType */
 170                 UAS_PIPE_ID_COMMAND,
 171                 0x00,  /*  u8  bReserved */
 172             },
 173         },{
 174             .bEndpointAddress      = USB_DIR_IN | UAS_PIPE_ID_STATUS,
 175             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 176             .wMaxPacketSize        = 512,
 177             .extra = (uint8_t[]) {
 178                 0x04,  /*  u8  bLength */
 179                 0x24,  /*  u8  bDescriptorType */
 180                 UAS_PIPE_ID_STATUS,
 181                 0x00,  /*  u8  bReserved */
 182             },
 183         },{
 184             .bEndpointAddress      = USB_DIR_IN | UAS_PIPE_ID_DATA_IN,
 185             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 186             .wMaxPacketSize        = 512,
 187             .extra = (uint8_t[]) {
 188                 0x04,  /*  u8  bLength */
 189                 0x24,  /*  u8  bDescriptorType */
 190                 UAS_PIPE_ID_DATA_IN,
 191                 0x00,  /*  u8  bReserved */
 192             },
 193         },{
 194             .bEndpointAddress      = USB_DIR_OUT | UAS_PIPE_ID_DATA_OUT,
 195             .bmAttributes          = USB_ENDPOINT_XFER_BULK,
 196             .wMaxPacketSize        = 512,
 197             .extra = (uint8_t[]) {
 198                 0x04,  /*  u8  bLength */
 199                 0x24,  /*  u8  bDescriptorType */
 200                 UAS_PIPE_ID_DATA_OUT,
 201                 0x00,  /*  u8  bReserved */
 202             },
 203         },
 204     }
 205 };
 206
 207 static const USBDescDevice desc_device_high = {
 208     .bcdUSB                        = 0x0200,
 209     .bMaxPacketSize0               = 64,
 210     .bNumConfigurations            = 1,
 211     .confs = (USBDescConfig[]) {
 212         {
 213             .bNumInterfaces        = 1,
 214             .bConfigurationValue   = 1,
 215             .iConfiguration        = STR_CONFIG_HIGH,
 216             .bmAttributes          = 0xc0,
 217             .nif = 1,
 218             .ifs = &desc_iface_high,
 219         },
 220     },
 221 };
 222
 223 static const USBDesc desc = {
 224     .id = {
 225         .idVendor          = 0x46f4, /* CRC16() of "QEMU" */
 226         .idProduct         = 0x0003,
 227         .bcdDevice         = 0,
 228         .iManufacturer     = STR_MANUFACTURER,
 229         .iProduct          = STR_PRODUCT,
 230         .iSerialNumber     = STR_SERIALNUMBER,
 231     },
 232     .high = &desc_device_high,
 233     .str  = desc_strings,
 234 };
 235
 236 /* --------------------------------------------------------------------- */
 237
 238 static UASStatus *usb_uas_alloc_status(uint8_t id, uint16_t tag)
 239 {
 240     UASStatus *st = g_new0(UASStatus, 1);
 241
 242     st->status.hdr.id = id;
 243     st->status.hdr.tag = cpu_to_be16(tag);
 244     st->length = sizeof(uas_ui_header);
 245     return st;
 246 }
 247
 248 static void usb_uas_send_status_bh(void *opaque)
 249 {
 250     UASDevice *uas = opaque;
 251     UASStatus *st = QTAILQ_FIRST(&uas->results);
 252     USBPacket *p = uas->status;
 253
 254     assert(p != NULL);
 255     assert(st != NULL);
 256
 257     uas->status = NULL;
 258     usb_packet_copy(p, &st->status, st->length);
 259     p->result = st->length;
 260     QTAILQ_REMOVE(&uas->results, st, next);
 261     g_free(st);
 262
 263     usb_packet_complete(&uas->dev, p);
 264 }
 265
 266 static void usb_uas_queue_status(UASDevice *uas, UASStatus *st, int length)
 267 {
 268     st->length += length;
 269     QTAILQ_INSERT_TAIL(&uas->results, st, next);
 270     if (uas->status) {
 271         /*
 272          * Just schedule bh make sure any in-flight data transaction
 273          * is finished before completing (sending) the status packet.
 274          */
 275         qemu_bh_schedule(uas->status_bh);
 276     } else {
 277         USBEndpoint *ep = usb_ep_get(&uas->dev, USB_TOKEN_IN,
 278                                      UAS_PIPE_ID_STATUS);
 279         usb_wakeup(ep);
 280     }
 281 }
 282
 283 static void usb_uas_queue_response(UASDevice *uas, uint16_t tag,
 284                                    uint8_t code, uint16_t add_info)
 285 {
 286     UASStatus *st = usb_uas_alloc_status(UAS_UI_RESPONSE, tag);
 287
 288     trace_usb_uas_response(uas->dev.addr, tag, code);
 289     st->status.response.response_code = code;
 290     st->status.response.add_response_info = cpu_to_be16(add_info);
 291     usb_uas_queue_status(uas, st, sizeof(uas_ui_response));
 292 }
 293
 294 static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
 295 {
 296     UASStatus *st = usb_uas_alloc_status(UAS_UI_SENSE, req->tag);
 297     int len, slen = 0;
 298
 299     trace_usb_uas_sense(req->uas->dev.addr, req->tag, status);
 300     st->status.sense.status = status;
 301     st->status.sense.status_qualifier = cpu_to_be16(0);
 302     if (status != GOOD) {
 303         slen = scsi_req_get_sense(req->req, st->status.sense.sense_data,
 304                                   sizeof(st->status.sense.sense_data));
 305         st->status.sense.sense_length = cpu_to_be16(slen);
 306     }
 307     len = sizeof(uas_ui_sense) - sizeof(st->status.sense.sense_data) + slen;
 308     usb_uas_queue_status(req->uas, st, len);
 309 }
 310
 311 static void usb_uas_queue_read_ready(UASRequest *req)
 312 {
 313     UASStatus *st = usb_uas_alloc_status(UAS_UI_READ_READY, req->tag);
 314
 315     trace_usb_uas_read_ready(req->uas->dev.addr, req->tag);
 316     usb_uas_queue_status(req->uas, st, 0);
 317 }
 318
 319 static void usb_uas_queue_write_ready(UASRequest *req)
 320 {
 321     UASStatus *st = usb_uas_alloc_status(UAS_UI_WRITE_READY, req->tag);
 322
 323     trace_usb_uas_write_ready(req->uas->dev.addr, req->tag);
 324     usb_uas_queue_status(req->uas, st, 0);
 325 }
 326
 327 /* --------------------------------------------------------------------- */
 328
 329 static int usb_uas_get_lun(uint64_t lun64)
 330 {
 331     return (lun64 >> 48) & 0xff;
 332 }
 333
 334 static SCSIDevice *usb_uas_get_dev(UASDevice *uas, uint64_t lun64)
 335 {
 336     if ((lun64 >> 56) != 0x00) {
 337         return NULL;
 338     }
 339     return scsi_device_find(&uas->bus, 0, 0, usb_uas_get_lun(lun64));
 340 }
 341
 342 static void usb_uas_complete_data_packet(UASRequest *req)
 343 {
 344     USBPacket *p;
 345
 346     if (!req->data_async) {
 347         return;
 348     }
 349     p = req->data;
 350     req->data = NULL;
 351     req->data_async = false;
 352     usb_packet_complete(&req->uas->dev, p);
 353 }
 354
 355 static void usb_uas_copy_data(UASRequest *req)
 356 {
 357     uint32_t length;
 358
 359     length = MIN(req->buf_size - req->buf_off,
 360                  req->data->iov.size - req->data->result);
 361     trace_usb_uas_xfer_data(req->uas->dev.addr, req->tag, length,
 362                             req->data->result, req->data->iov.size,
 363                             req->buf_off, req->buf_size);
 364     usb_packet_copy(req->data, scsi_req_get_buf(req->req) + req->buf_off,
 365                     length);
 366     req->buf_off += length;
 367     req->data_off += length;
 368
 369     if (req->data->result == req->data->iov.size) {
 370         usb_uas_complete_data_packet(req);
 371     }
 372     if (req->buf_size && req->buf_off == req->buf_size) {
 373         req->buf_off = 0;
 374         req->buf_size = 0;
 375         scsi_req_continue(req->req);
 376     }
 377 }
 378
 379 static void usb_uas_start_next_transfer(UASDevice *uas)
 380 {
 381     UASRequest *req;
 382
 383     QTAILQ_FOREACH(req, &uas->requests, next) {
 384         if (req->active || req->complete) {
 385             continue;
 386         }
 387         if (req->req->cmd.mode == SCSI_XFER_FROM_DEV && uas->datain == NULL) {
 388             uas->datain = req;
 389             usb_uas_queue_read_ready(req);
 390             req->active = true;
 391             return;
 392         }
 393         if (req->req->cmd.mode == SCSI_XFER_TO_DEV && uas->dataout == NULL) {
 394             uas->dataout = req;
 395             usb_uas_queue_write_ready(req);
 396             req->active = true;
 397             return;
 398         }
 399     }
 400 }
 401
 402 static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_ui *ui)
 403 {
 404     UASRequest *req;
 405
 406     req = g_new0(UASRequest, 1);
 407     req->uas = uas;
 408     req->tag = be16_to_cpu(ui->hdr.tag);
 409     req->lun = be64_to_cpu(ui->command.lun);
 410     req->dev = usb_uas_get_dev(req->uas, req->lun);
 411     return req;
 412 }
 413
 414 static void usb_uas_scsi_free_request(SCSIBus *bus, void *priv)
 415 {
 416     UASRequest *req = priv;
 417     UASDevice *uas = req->uas;
 418
 419     if (req == uas->datain) {
 420         uas->datain = NULL;
 421     }
 422     if (req == uas->dataout) {
 423         uas->dataout = NULL;
 424     }
 425     QTAILQ_REMOVE(&uas->requests, req, next);
 426     g_free(req);
 427     usb_uas_start_next_transfer(uas);
 428 }
 429
 430 static UASRequest *usb_uas_find_request(UASDevice *uas, uint16_t tag)
 431 {
 432     UASRequest *req;
 433
 434     QTAILQ_FOREACH(req, &uas->requests, next) {
 435         if (req->tag == tag) {
 436             return req;
 437         }
 438     }
 439     return NULL;
 440 }
 441
 442 static void usb_uas_scsi_transfer_data(SCSIRequest *r, uint32_t len)
 443 {
 444     UASRequest *req = r->hba_private;
 445
 446     trace_usb_uas_scsi_data(req->uas->dev.addr, req->tag, len);
 447     req->buf_off = 0;
 448     req->buf_size = len;
 449     if (req->data) {
 450         usb_uas_copy_data(req);
 451     } else {
 452         usb_uas_start_next_transfer(req->uas);
 453     }
 454 }
 455
 456 static void usb_uas_scsi_command_complete(SCSIRequest *r,
 457                                           uint32_t status, size_t resid)
 458 {
 459     UASRequest *req = r->hba_private;
 460
 461     trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, status, resid);
 462     req->complete = true;
 463     if (req->data) {
 464         usb_uas_complete_data_packet(req);
 465     }
 466     usb_uas_queue_sense(req, status);
 467     scsi_req_unref(req->req);
 468 }
 469
 470 static void usb_uas_scsi_request_cancelled(SCSIRequest *r)
 471 {
 472     UASRequest *req = r->hba_private;
 473
 474     /* FIXME: queue notification to status pipe? */
 475     scsi_req_unref(req->req);
 476 }
 477
 478 static const struct SCSIBusInfo usb_uas_scsi_info = {
 479     .tcq = true,
 480     .max_target = 0,
 481     .max_lun = 255,
 482
 483     .transfer_data = usb_uas_scsi_transfer_data,
 484     .complete = usb_uas_scsi_command_complete,
 485     .cancel = usb_uas_scsi_request_cancelled,
 486     .free_request = usb_uas_scsi_free_request,
 487 };
 488
 489 /* --------------------------------------------------------------------- */
 490
 491 static void usb_uas_handle_reset(USBDevice *dev)
 492 {
 493     UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
 494     UASRequest *req, *nreq;
 495     UASStatus *st, *nst;
 496
 497     trace_usb_uas_reset(dev->addr);
 498     QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
 499         scsi_req_cancel(req->req);
 500     }
 501     QTAILQ_FOREACH_SAFE(st, &uas->results, next, nst) {
 502         QTAILQ_REMOVE(&uas->results, st, next);
 503         g_free(st);
 504     }
 505 }
 506
 507 static int usb_uas_handle_control(USBDevice *dev, USBPacket *p,
 508                int request, int value, int index, int length, uint8_t *data)
 509 {
 510     int ret;
 511
 512     ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
 513     if (ret >= 0) {
 514         return ret;
 515     }
 516     fprintf(stderr, "%s: unhandled control request\n", __func__);
 517     return USB_RET_STALL;
 518 }
 519
 520 static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
 521 {
 522     UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
 523     UASRequest *req, *nreq;
 524
 525     if (uas->status == p) {
 526         uas->status = NULL;
 527         qemu_bh_cancel(uas->status_bh);
 528         return;
 529     }
 530     QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
 531         if (req->data == p) {
 532             req->data = NULL;
 533             return;
 534         }
 535     }
 536     assert(!"canceled usb packet not found");
 537 }
 538
 539 static void usb_uas_command(UASDevice *uas, uas_ui *ui)
 540 {
 541     UASRequest *req;
 542     uint32_t len;
 543
 544     req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
 545     if (req) {
 546         goto overlapped_tag;
 547     }
 548     req = usb_uas_alloc_request(uas, ui);
 549     if (req->dev == NULL) {
 550         goto bad_target;
 551     }
 552
 553     trace_usb_uas_command(uas->dev.addr, req->tag,
 554                           usb_uas_get_lun(req->lun),
 555                           req->lun >> 32, req->lun & 0xffffffff);
 556     QTAILQ_INSERT_TAIL(&uas->requests, req, next);
 557     req->req = scsi_req_new(req->dev, req->tag,
 558                             usb_uas_get_lun(req->lun),
 559                             ui->command.cdb, req);
 560     len = scsi_req_enqueue(req->req);
 561     if (len) {
 562         req->data_size = len;
 563         scsi_req_continue(req->req);
 564     }
 565     return;
 566
 567 overlapped_tag:
 568     usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
 569     return;
 570
 571 bad_target:
 572     /*
 573      * FIXME: Seems to upset linux, is this wrong?
 574      * NOTE: Happens only with no scsi devices at the bus, not sure
 575      *       this is a valid UAS setup in the first place.
 576      */
 577     usb_uas_queue_response(uas, req->tag, UAS_RC_INVALID_INFO_UNIT, 0);
 578     g_free(req);
 579     return;
 580 }
 581
 582 static void usb_uas_task(UASDevice *uas, uas_ui *ui)
 583 {
 584     uint16_t tag = be16_to_cpu(ui->hdr.tag);
 585     uint64_t lun64 = be64_to_cpu(ui->task.lun);
 586     SCSIDevice *dev = usb_uas_get_dev(uas, lun64);
 587     int lun = usb_uas_get_lun(lun64);
 588     UASRequest *req;
 589     uint16_t task_tag;
 590
 591     req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
 592     if (req) {
 593         goto overlapped_tag;
 594     }
 595
 596     switch (ui->task.function) {
 597     case UAS_TMF_ABORT_TASK:
 598         task_tag = be16_to_cpu(ui->task.task_tag);
 599         trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
 600         if (dev == NULL) {
 601             goto bad_target;
 602         }
 603         if (dev->lun != lun) {
 604             goto incorrect_lun;
 605         }
 606         req = usb_uas_find_request(uas, task_tag);
 607         if (req && req->dev == dev) {
 608             scsi_req_cancel(req->req);
 609         }
 610         usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE, 0);
 611         break;
 612
 613     case UAS_TMF_LOGICAL_UNIT_RESET:
 614         trace_usb_uas_tmf_logical_unit_reset(uas->dev.addr, tag, lun);
 615         if (dev == NULL) {
 616             goto bad_target;
 617         }
 618         if (dev->lun != lun) {
 619             goto incorrect_lun;
 620         }
 621         qdev_reset_all(&dev->qdev);
 622         usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE, 0);
 623         break;
 624
 625     default:
 626         trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, ui->task.function);
 627         usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED, 0);
 628         break;
 629     }
 630     return;
 631
 632 overlapped_tag:
 633     usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
 634     return;
 635
 636 bad_target:
 637     /* FIXME: correct?  [see long comment in usb_uas_command()] */
 638     usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT, 0);
 639     return;
 640
 641 incorrect_lun:
 642     usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN, 0);
 643     return;
 644 }
 645
 646 static int usb_uas_handle_data(USBDevice *dev, USBPacket *p)
 647 {
 648     UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
 649     uas_ui ui;
 650     UASStatus *st;
 651     UASRequest *req;
 652     int length, ret = 0;
 653
 654     switch (p->ep->nr) {
 655     case UAS_PIPE_ID_COMMAND:
 656         length = MIN(sizeof(ui), p->iov.size);
 657         usb_packet_copy(p, &ui, length);
 658         switch (ui.hdr.id) {
 659         case UAS_UI_COMMAND:
 660             usb_uas_command(uas, &ui);
 661             ret = length;
 662             break;
 663         case UAS_UI_TASK_MGMT:
 664             usb_uas_task(uas, &ui);
 665             ret = length;
 666             break;
 667         default:
 668             fprintf(stderr, "%s: unknown command ui: id 0x%x\n",
 669                     __func__, ui.hdr.id);
 670             ret = USB_RET_STALL;
 671             break;
 672         }
 673         break;
 674     case UAS_PIPE_ID_STATUS:
 675         st = QTAILQ_FIRST(&uas->results);
 676         if (st == NULL) {
 677             assert(uas->status == NULL);
 678             uas->status = p;
 679             ret = USB_RET_ASYNC;
 680             break;
 681         }
 682         usb_packet_copy(p, &st->status, st->length);
 683         ret = st->length;
 684         QTAILQ_REMOVE(&uas->results, st, next);
 685         g_free(st);
 686         break;
 687     case UAS_PIPE_ID_DATA_IN:
 688     case UAS_PIPE_ID_DATA_OUT:
 689         req = (p->ep->nr == UAS_PIPE_ID_DATA_IN) ? uas->datain : uas->dataout;
 690         if (req == NULL) {
 691             fprintf(stderr, "%s: no inflight request\n", __func__);
 692             ret = USB_RET_STALL;
 693             break;
 694         }
 695         scsi_req_ref(req->req);
 696         req->data = p;
 697         usb_uas_copy_data(req);
 698         if (p->result == p->iov.size || req->complete) {
 699             req->data = NULL;
 700             ret = p->result;
 701         } else {
 702             req->data_async = true;
 703             ret = USB_RET_ASYNC;
 704         }
 705         scsi_req_unref(req->req);
 706         usb_uas_start_next_transfer(uas);
 707         break;
 708     default:
 709         fprintf(stderr, "%s: invalid endpoint %d\n", __func__, p->ep->nr);
 710         ret = USB_RET_STALL;
 711         break;
 712     }
 713     return ret;
 714 }
 715
 716 static void usb_uas_handle_destroy(USBDevice *dev)
 717 {
 718     UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
 719
 720     qemu_bh_delete(uas->status_bh);
 721 }
 722
 723 static int usb_uas_init(USBDevice *dev)
 724 {
 725     UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
 726
 727     usb_desc_create_serial(dev);
 728     usb_desc_init(dev);
 729
 730     QTAILQ_INIT(&uas->results);
 731     QTAILQ_INIT(&uas->requests);
 732     uas->status_bh = qemu_bh_new(usb_uas_send_status_bh, uas);
 733
 734     scsi_bus_new(&uas->bus, &uas->dev.qdev, &usb_uas_scsi_info);
 735
 736     return 0;
 737 }
 738
 739 static const VMStateDescription vmstate_usb_uas = {
 740     .name = "usb-uas",
 741     .unmigratable = 1,
 742     .fields = (VMStateField[]) {
 743         VMSTATE_USB_DEVICE(dev, UASDevice),
 744         VMSTATE_END_OF_LIST()
 745     }
 746 };
 747
 748 static void usb_uas_class_initfn(ObjectClass *klass, void *data)
 749 {
 750     DeviceClass *dc = DEVICE_CLASS(klass);
 751     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
 752
 753     uc->init           = usb_uas_init;
 754     uc->product_desc   = desc_strings[STR_PRODUCT];
 755     uc->usb_desc       = &desc;
 756     uc->cancel_packet  = usb_uas_cancel_io;
 757     uc->handle_attach  = usb_desc_attach;
 758     uc->handle_reset   = usb_uas_handle_reset;
 759     uc->handle_control = usb_uas_handle_control;
 760     uc->handle_data    = usb_uas_handle_data;
 761     uc->handle_destroy = usb_uas_handle_destroy;
 762     dc->fw_name = "storage";
 763     dc->vmsd = &vmstate_usb_uas;
 764 }
 765
 766 static TypeInfo uas_info = {
 767     .name          = "usb-uas",
 768     .parent        = TYPE_USB_DEVICE,
 769     .instance_size = sizeof(UASDevice),
 770     .class_init    = usb_uas_class_initfn,
 771 };
 772
 773 static void usb_uas_register_types(void)
 774 {
 775     type_register_static(&uas_info);
 776 }
 777
 778 type_init(usb_uas_register_types)