?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb: split packet result into actual_length + status
[qemu.git] / hw / usb / dev-uas.c
bloba21b2ba62788c2257e134f71ebec320c9247b5f2
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 QTAILQ_REMOVE(&uas->results, st, next);
260 g_free(st);
261
262 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
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 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
353 usb_packet_complete(&req->uas->dev, p);
354 }
355
356 static void usb_uas_copy_data(UASRequest *req)
357 {
358 uint32_t length;
359
360 length = MIN(req->buf_size - req->buf_off,
361 req->data->iov.size - req->data->actual_length);
362 trace_usb_uas_xfer_data(req->uas->dev.addr, req->tag, length,
363 req->data->actual_length, req->data->iov.size,
364 req->buf_off, req->buf_size);
365 usb_packet_copy(req->data, scsi_req_get_buf(req->req) + req->buf_off,
366 length);
367 req->buf_off += length;
368 req->data_off += length;
369
370 if (req->data->actual_length == req->data->iov.size) {
371 usb_uas_complete_data_packet(req);
372 }
373 if (req->buf_size && req->buf_off == req->buf_size) {
374 req->buf_off = 0;
375 req->buf_size = 0;
376 scsi_req_continue(req->req);
377 }
378 }
379
380 static void usb_uas_start_next_transfer(UASDevice *uas)
381 {
382 UASRequest *req;
383
384 QTAILQ_FOREACH(req, &uas->requests, next) {
385 if (req->active || req->complete) {
386 continue;
387 }
388 if (req->req->cmd.mode == SCSI_XFER_FROM_DEV && uas->datain == NULL) {
389 uas->datain = req;
390 usb_uas_queue_read_ready(req);
391 req->active = true;
392 return;
393 }
394 if (req->req->cmd.mode == SCSI_XFER_TO_DEV && uas->dataout == NULL) {
395 uas->dataout = req;
396 usb_uas_queue_write_ready(req);
397 req->active = true;
398 return;
399 }
400 }
401 }
402
403 static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_ui *ui)
404 {
405 UASRequest *req;
406
407 req = g_new0(UASRequest, 1);
408 req->uas = uas;
409 req->tag = be16_to_cpu(ui->hdr.tag);
410 req->lun = be64_to_cpu(ui->command.lun);
411 req->dev = usb_uas_get_dev(req->uas, req->lun);
412 return req;
413 }
414
415 static void usb_uas_scsi_free_request(SCSIBus *bus, void *priv)
416 {
417 UASRequest *req = priv;
418 UASDevice *uas = req->uas;
419
420 if (req == uas->datain) {
421 uas->datain = NULL;
422 }
423 if (req == uas->dataout) {
424 uas->dataout = NULL;
425 }
426 QTAILQ_REMOVE(&uas->requests, req, next);
427 g_free(req);
428 usb_uas_start_next_transfer(uas);
429 }
430
431 static UASRequest *usb_uas_find_request(UASDevice *uas, uint16_t tag)
432 {
433 UASRequest *req;
434
435 QTAILQ_FOREACH(req, &uas->requests, next) {
436 if (req->tag == tag) {
437 return req;
438 }
439 }
440 return NULL;
441 }
442
443 static void usb_uas_scsi_transfer_data(SCSIRequest *r, uint32_t len)
444 {
445 UASRequest *req = r->hba_private;
446
447 trace_usb_uas_scsi_data(req->uas->dev.addr, req->tag, len);
448 req->buf_off = 0;
449 req->buf_size = len;
450 if (req->data) {
451 usb_uas_copy_data(req);
452 } else {
453 usb_uas_start_next_transfer(req->uas);
454 }
455 }
456
457 static void usb_uas_scsi_command_complete(SCSIRequest *r,
458 uint32_t status, size_t resid)
459 {
460 UASRequest *req = r->hba_private;
461
462 trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, status, resid);
463 req->complete = true;
464 if (req->data) {
465 usb_uas_complete_data_packet(req);
466 }
467 usb_uas_queue_sense(req, status);
468 scsi_req_unref(req->req);
469 }
470
471 static void usb_uas_scsi_request_cancelled(SCSIRequest *r)
472 {
473 UASRequest *req = r->hba_private;
474
475 /* FIXME: queue notification to status pipe? */
476 scsi_req_unref(req->req);
477 }
478
479 static const struct SCSIBusInfo usb_uas_scsi_info = {
480 .tcq = true,
481 .max_target = 0,
482 .max_lun = 255,
483
484 .transfer_data = usb_uas_scsi_transfer_data,
485 .complete = usb_uas_scsi_command_complete,
486 .cancel = usb_uas_scsi_request_cancelled,
487 .free_request = usb_uas_scsi_free_request,
488 };
489
490 /* --------------------------------------------------------------------- */
491
492 static void usb_uas_handle_reset(USBDevice *dev)
493 {
494 UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
495 UASRequest *req, *nreq;
496 UASStatus *st, *nst;
497
498 trace_usb_uas_reset(dev->addr);
499 QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
500 scsi_req_cancel(req->req);
501 }
502 QTAILQ_FOREACH_SAFE(st, &uas->results, next, nst) {
503 QTAILQ_REMOVE(&uas->results, st, next);
504 g_free(st);
505 }
506 }
507
508 static void usb_uas_handle_control(USBDevice *dev, USBPacket *p,
509 int request, int value, int index, int length, uint8_t *data)
510 {
511 int ret;
512
513 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
514 if (ret >= 0) {
515 return;
516 }
517 fprintf(stderr, "%s: unhandled control request\n", __func__);
518 p->status = USB_RET_STALL;
519 }
520
521 static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
522 {
523 UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
524 UASRequest *req, *nreq;
525
526 if (uas->status == p) {
527 uas->status = NULL;
528 qemu_bh_cancel(uas->status_bh);
529 return;
530 }
531 QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
532 if (req->data == p) {
533 req->data = NULL;
534 return;
535 }
536 }
537 assert(!"canceled usb packet not found");
538 }
539
540 static void usb_uas_command(UASDevice *uas, uas_ui *ui)
541 {
542 UASRequest *req;
543 uint32_t len;
544
545 req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
546 if (req) {
547 goto overlapped_tag;
548 }
549 req = usb_uas_alloc_request(uas, ui);
550 if (req->dev == NULL) {
551 goto bad_target;
552 }
553
554 trace_usb_uas_command(uas->dev.addr, req->tag,
555 usb_uas_get_lun(req->lun),
556 req->lun >> 32, req->lun & 0xffffffff);
557 QTAILQ_INSERT_TAIL(&uas->requests, req, next);
558 req->req = scsi_req_new(req->dev, req->tag,
559 usb_uas_get_lun(req->lun),
560 ui->command.cdb, req);
561 len = scsi_req_enqueue(req->req);
562 if (len) {
563 req->data_size = len;
564 scsi_req_continue(req->req);
565 }
566 return;
567
568 overlapped_tag:
569 usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG, 0);
570 return;
571
572 bad_target:
573 /*
574 * FIXME: Seems to upset linux, is this wrong?
575 * NOTE: Happens only with no scsi devices at the bus, not sure
576 * this is a valid UAS setup in the first place.
577 */
578 usb_uas_queue_response(uas, req->tag, UAS_RC_INVALID_INFO_UNIT, 0);
579 g_free(req);
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 }
644
645 static void usb_uas_handle_data(USBDevice *dev, USBPacket *p)
646 {
647 UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
648 uas_ui ui;
649 UASStatus *st;
650 UASRequest *req;
651 int length;
652
653 switch (p->ep->nr) {
654 case UAS_PIPE_ID_COMMAND:
655 length = MIN(sizeof(ui), p->iov.size);
656 usb_packet_copy(p, &ui, length);
657 switch (ui.hdr.id) {
658 case UAS_UI_COMMAND:
659 usb_uas_command(uas, &ui);
660 break;
661 case UAS_UI_TASK_MGMT:
662 usb_uas_task(uas, &ui);
663 break;
664 default:
665 fprintf(stderr, "%s: unknown command ui: id 0x%x\n",
666 __func__, ui.hdr.id);
667 p->status = USB_RET_STALL;
668 break;
669 }
670 break;
671 case UAS_PIPE_ID_STATUS:
672 st = QTAILQ_FIRST(&uas->results);
673 if (st == NULL) {
674 assert(uas->status == NULL);
675 uas->status = p;
676 p->status = USB_RET_ASYNC;
677 break;
678 }
679 usb_packet_copy(p, &st->status, st->length);
680 QTAILQ_REMOVE(&uas->results, st, next);
681 g_free(st);
682 break;
683 case UAS_PIPE_ID_DATA_IN:
684 case UAS_PIPE_ID_DATA_OUT:
685 req = (p->ep->nr == UAS_PIPE_ID_DATA_IN) ? uas->datain : uas->dataout;
686 if (req == NULL) {
687 fprintf(stderr, "%s: no inflight request\n", __func__);
688 p->status = USB_RET_STALL;
689 break;
690 }
691 scsi_req_ref(req->req);
692 req->data = p;
693 usb_uas_copy_data(req);
694 if (p->actual_length == p->iov.size || req->complete) {
695 req->data = NULL;
696 } else {
697 req->data_async = true;
698 p->status = USB_RET_ASYNC;
699 }
700 scsi_req_unref(req->req);
701 usb_uas_start_next_transfer(uas);
702 break;
703 default:
704 fprintf(stderr, "%s: invalid endpoint %d\n", __func__, p->ep->nr);
705 p->status = USB_RET_STALL;
706 break;
707 }
708 }
709
710 static void usb_uas_handle_destroy(USBDevice *dev)
711 {
712 UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
713
714 qemu_bh_delete(uas->status_bh);
715 }
716
717 static int usb_uas_init(USBDevice *dev)
718 {
719 UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
720
721 usb_desc_create_serial(dev);
722 usb_desc_init(dev);
723
724 QTAILQ_INIT(&uas->results);
725 QTAILQ_INIT(&uas->requests);
726 uas->status_bh = qemu_bh_new(usb_uas_send_status_bh, uas);
727
728 scsi_bus_new(&uas->bus, &uas->dev.qdev, &usb_uas_scsi_info);
729
730 return 0;
731 }
732
733 static const VMStateDescription vmstate_usb_uas = {
734 .name = "usb-uas",
735 .unmigratable = 1,
736 .fields = (VMStateField[]) {
737 VMSTATE_USB_DEVICE(dev, UASDevice),
738 VMSTATE_END_OF_LIST()
739 }
740 };
741
742 static void usb_uas_class_initfn(ObjectClass *klass, void *data)
743 {
744 DeviceClass *dc = DEVICE_CLASS(klass);
745 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
746
747 uc->init = usb_uas_init;
748 uc->product_desc = desc_strings[STR_PRODUCT];
749 uc->usb_desc = &desc;
750 uc->cancel_packet = usb_uas_cancel_io;
751 uc->handle_attach = usb_desc_attach;
752 uc->handle_reset = usb_uas_handle_reset;
753 uc->handle_control = usb_uas_handle_control;
754 uc->handle_data = usb_uas_handle_data;
755 uc->handle_destroy = usb_uas_handle_destroy;
756 dc->fw_name = "storage";
757 dc->vmsd = &vmstate_usb_uas;
758 }
759
760 static TypeInfo uas_info = {
761 .name = "usb-uas",
762 .parent = TYPE_USB_DEVICE,
763 .instance_size = sizeof(UASDevice),
764 .class_init = usb_uas_class_initfn,
765 };
766
767 static void usb_uas_register_types(void)
768 {
769 type_register_static(&uas_info);
770 }
771
772 type_init(usb_uas_register_types)
QEmu