1
2
3
4
5
6
7
8
9
10
11
12#include "qemu/osdep.h"
13#include "qemu/option.h"
14#include "qemu/config-file.h"
15#include "trace.h"
16#include "qemu/error-report.h"
17#include "qemu/main-loop.h"
18#include "qemu/module.h"
19#include "qemu/log.h"
20
21#include "hw/usb.h"
22#include "migration/vmstate.h"
23#include "desc.h"
24#include "hw/qdev-properties.h"
25#include "hw/scsi/scsi.h"
26#include "scsi/constants.h"
27#include "qom/object.h"
28
29
30
31#define UAS_UI_COMMAND 0x01
32#define UAS_UI_SENSE 0x03
33#define UAS_UI_RESPONSE 0x04
34#define UAS_UI_TASK_MGMT 0x05
35#define UAS_UI_READ_READY 0x06
36#define UAS_UI_WRITE_READY 0x07
37
38#define UAS_RC_TMF_COMPLETE 0x00
39#define UAS_RC_INVALID_INFO_UNIT 0x02
40#define UAS_RC_TMF_NOT_SUPPORTED 0x04
41#define UAS_RC_TMF_FAILED 0x05
42#define UAS_RC_TMF_SUCCEEDED 0x08
43#define UAS_RC_INCORRECT_LUN 0x09
44#define UAS_RC_OVERLAPPED_TAG 0x0a
45
46#define UAS_TMF_ABORT_TASK 0x01
47#define UAS_TMF_ABORT_TASK_SET 0x02
48#define UAS_TMF_CLEAR_TASK_SET 0x04
49#define UAS_TMF_LOGICAL_UNIT_RESET 0x08
50#define UAS_TMF_I_T_NEXUS_RESET 0x10
51#define UAS_TMF_CLEAR_ACA 0x40
52#define UAS_TMF_QUERY_TASK 0x80
53#define UAS_TMF_QUERY_TASK_SET 0x81
54#define UAS_TMF_QUERY_ASYNC_EVENT 0x82
55
56#define UAS_PIPE_ID_COMMAND 0x01
57#define UAS_PIPE_ID_STATUS 0x02
58#define UAS_PIPE_ID_DATA_IN 0x03
59#define UAS_PIPE_ID_DATA_OUT 0x04
60
61typedef struct {
62 uint8_t id;
63 uint8_t reserved;
64 uint16_t tag;
65} QEMU_PACKED uas_iu_header;
66
67typedef struct {
68 uint8_t prio_taskattr;
69 uint8_t reserved_1;
70 uint8_t add_cdb_length;
71 uint8_t reserved_2;
72 uint64_t lun;
73 uint8_t cdb[16];
74 uint8_t add_cdb[1];
75} QEMU_PACKED uas_iu_command;
76
77typedef struct {
78 uint16_t status_qualifier;
79 uint8_t status;
80 uint8_t reserved[7];
81 uint16_t sense_length;
82 uint8_t sense_data[18];
83} QEMU_PACKED uas_iu_sense;
84
85typedef struct {
86 uint8_t add_response_info[3];
87 uint8_t response_code;
88} QEMU_PACKED uas_iu_response;
89
90typedef struct {
91 uint8_t function;
92 uint8_t reserved;
93 uint16_t task_tag;
94 uint64_t lun;
95} QEMU_PACKED uas_iu_task_mgmt;
96
97typedef struct {
98 uas_iu_header hdr;
99 union {
100 uas_iu_command command;
101 uas_iu_sense sense;
102 uas_iu_task_mgmt task;
103 uas_iu_response response;
104 };
105} QEMU_PACKED uas_iu;
106
107
108
109#define UAS_STREAM_BM_ATTR 4
110#define UAS_MAX_STREAMS (1 << UAS_STREAM_BM_ATTR)
111
112typedef struct UASDevice UASDevice;
113typedef struct UASRequest UASRequest;
114typedef struct UASStatus UASStatus;
115
116struct UASDevice {
117 USBDevice dev;
118 SCSIBus bus;
119 QEMUBH *status_bh;
120 QTAILQ_HEAD(, UASStatus) results;
121 QTAILQ_HEAD(, UASRequest) requests;
122
123
124 uint32_t requestlog;
125
126
127 USBPacket *status2;
128 UASRequest *datain2;
129 UASRequest *dataout2;
130
131
132 USBPacket *data3[UAS_MAX_STREAMS + 1];
133 USBPacket *status3[UAS_MAX_STREAMS + 1];
134};
135
136#define TYPE_USB_UAS "usb-uas"
137OBJECT_DECLARE_SIMPLE_TYPE(UASDevice, USB_UAS)
138
139struct UASRequest {
140 uint16_t tag;
141 uint64_t lun;
142 UASDevice *uas;
143 SCSIDevice *dev;
144 SCSIRequest *req;
145 USBPacket *data;
146 bool data_async;
147 bool active;
148 bool complete;
149 uint32_t buf_off;
150 uint32_t buf_size;
151 uint32_t data_off;
152 uint32_t data_size;
153 QTAILQ_ENTRY(UASRequest) next;
154};
155
156struct UASStatus {
157 uint32_t stream;
158 uas_iu status;
159 uint32_t length;
160 QTAILQ_ENTRY(UASStatus) next;
161};
162
163
164
165enum {
166 STR_MANUFACTURER = 1,
167 STR_PRODUCT,
168 STR_SERIALNUMBER,
169 STR_CONFIG_HIGH,
170 STR_CONFIG_SUPER,
171};
172
173static const USBDescStrings desc_strings = {
174 [STR_MANUFACTURER] = "QEMU",
175 [STR_PRODUCT] = "USB Attached SCSI HBA",
176 [STR_SERIALNUMBER] = "27842",
177 [STR_CONFIG_HIGH] = "High speed config (usb 2.0)",
178 [STR_CONFIG_SUPER] = "Super speed config (usb 3.0)",
179};
180
181static const USBDescIface desc_iface_high = {
182 .bInterfaceNumber = 0,
183 .bNumEndpoints = 4,
184 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
185 .bInterfaceSubClass = 0x06,
186 .bInterfaceProtocol = 0x62,
187 .eps = (USBDescEndpoint[]) {
188 {
189 .bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_COMMAND,
190 .bmAttributes = USB_ENDPOINT_XFER_BULK,
191 .wMaxPacketSize = 512,
192 .extra = (uint8_t[]) {
193 0x04,
194 0x24,
195 UAS_PIPE_ID_COMMAND,
196 0x00,
197 },
198 },{
199 .bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_STATUS,
200 .bmAttributes = USB_ENDPOINT_XFER_BULK,
201 .wMaxPacketSize = 512,
202 .extra = (uint8_t[]) {
203 0x04,
204 0x24,
205 UAS_PIPE_ID_STATUS,
206 0x00,
207 },
208 },{
209 .bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_DATA_IN,
210 .bmAttributes = USB_ENDPOINT_XFER_BULK,
211 .wMaxPacketSize = 512,
212 .extra = (uint8_t[]) {
213 0x04,
214 0x24,
215 UAS_PIPE_ID_DATA_IN,
216 0x00,
217 },
218 },{
219 .bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_DATA_OUT,
220 .bmAttributes = USB_ENDPOINT_XFER_BULK,
221 .wMaxPacketSize = 512,
222 .extra = (uint8_t[]) {
223 0x04,
224 0x24,
225 UAS_PIPE_ID_DATA_OUT,
226 0x00,
227 },
228 },
229 }
230};
231
232static const USBDescIface desc_iface_super = {
233 .bInterfaceNumber = 0,
234 .bNumEndpoints = 4,
235 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
236 .bInterfaceSubClass = 0x06,
237 .bInterfaceProtocol = 0x62,
238 .eps = (USBDescEndpoint[]) {
239 {
240 .bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_COMMAND,
241 .bmAttributes = USB_ENDPOINT_XFER_BULK,
242 .wMaxPacketSize = 1024,
243 .bMaxBurst = 15,
244 .extra = (uint8_t[]) {
245 0x04,
246 0x24,
247 UAS_PIPE_ID_COMMAND,
248 0x00,
249 },
250 },{
251 .bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_STATUS,
252 .bmAttributes = USB_ENDPOINT_XFER_BULK,
253 .wMaxPacketSize = 1024,
254 .bMaxBurst = 15,
255 .bmAttributes_super = UAS_STREAM_BM_ATTR,
256 .extra = (uint8_t[]) {
257 0x04,
258 0x24,
259 UAS_PIPE_ID_STATUS,
260 0x00,
261 },
262 },{
263 .bEndpointAddress = USB_DIR_IN | UAS_PIPE_ID_DATA_IN,
264 .bmAttributes = USB_ENDPOINT_XFER_BULK,
265 .wMaxPacketSize = 1024,
266 .bMaxBurst = 15,
267 .bmAttributes_super = UAS_STREAM_BM_ATTR,
268 .extra = (uint8_t[]) {
269 0x04,
270 0x24,
271 UAS_PIPE_ID_DATA_IN,
272 0x00,
273 },
274 },{
275 .bEndpointAddress = USB_DIR_OUT | UAS_PIPE_ID_DATA_OUT,
276 .bmAttributes = USB_ENDPOINT_XFER_BULK,
277 .wMaxPacketSize = 1024,
278 .bMaxBurst = 15,
279 .bmAttributes_super = UAS_STREAM_BM_ATTR,
280 .extra = (uint8_t[]) {
281 0x04,
282 0x24,
283 UAS_PIPE_ID_DATA_OUT,
284 0x00,
285 },
286 },
287 }
288};
289
290static const USBDescDevice desc_device_high = {
291 .bcdUSB = 0x0200,
292 .bMaxPacketSize0 = 64,
293 .bNumConfigurations = 1,
294 .confs = (USBDescConfig[]) {
295 {
296 .bNumInterfaces = 1,
297 .bConfigurationValue = 1,
298 .iConfiguration = STR_CONFIG_HIGH,
299 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
300 .nif = 1,
301 .ifs = &desc_iface_high,
302 },
303 },
304};
305
306static const USBDescDevice desc_device_super = {
307 .bcdUSB = 0x0300,
308 .bMaxPacketSize0 = 9,
309 .bNumConfigurations = 1,
310 .confs = (USBDescConfig[]) {
311 {
312 .bNumInterfaces = 1,
313 .bConfigurationValue = 1,
314 .iConfiguration = STR_CONFIG_SUPER,
315 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
316 .nif = 1,
317 .ifs = &desc_iface_super,
318 },
319 },
320};
321
322static const USBDesc desc = {
323 .id = {
324 .idVendor = 0x46f4,
325 .idProduct = 0x0003,
326 .bcdDevice = 0,
327 .iManufacturer = STR_MANUFACTURER,
328 .iProduct = STR_PRODUCT,
329 .iSerialNumber = STR_SERIALNUMBER,
330 },
331 .high = &desc_device_high,
332 .super = &desc_device_super,
333 .str = desc_strings,
334};
335
336
337
338static bool uas_using_streams(UASDevice *uas)
339{
340 return uas->dev.speed == USB_SPEED_SUPER;
341}
342
343
344
345static UASStatus *usb_uas_alloc_status(UASDevice *uas, uint8_t id, uint16_t tag)
346{
347 UASStatus *st = g_new0(UASStatus, 1);
348
349 st->status.hdr.id = id;
350 st->status.hdr.tag = cpu_to_be16(tag);
351 st->length = sizeof(uas_iu_header);
352 if (uas_using_streams(uas)) {
353 st->stream = tag;
354 }
355 return st;
356}
357
358static void usb_uas_send_status_bh(void *opaque)
359{
360 UASDevice *uas = opaque;
361 UASStatus *st;
362 USBPacket *p;
363
364 while ((st = QTAILQ_FIRST(&uas->results)) != NULL) {
365 if (uas_using_streams(uas)) {
366 p = uas->status3[st->stream];
367 uas->status3[st->stream] = NULL;
368 } else {
369 p = uas->status2;
370 uas->status2 = NULL;
371 }
372 if (p == NULL) {
373 break;
374 }
375
376 usb_packet_copy(p, &st->status, st->length);
377 QTAILQ_REMOVE(&uas->results, st, next);
378 g_free(st);
379
380 p->status = USB_RET_SUCCESS;
381 usb_packet_complete(&uas->dev, p);
382 }
383}
384
385static void usb_uas_queue_status(UASDevice *uas, UASStatus *st, int length)
386{
387 USBPacket *p = uas_using_streams(uas) ?
388 uas->status3[st->stream] : uas->status2;
389
390 st->length += length;
391 QTAILQ_INSERT_TAIL(&uas->results, st, next);
392 if (p) {
393
394
395
396
397 qemu_bh_schedule(uas->status_bh);
398 } else {
399 USBEndpoint *ep = usb_ep_get(&uas->dev, USB_TOKEN_IN,
400 UAS_PIPE_ID_STATUS);
401 usb_wakeup(ep, st->stream);
402 }
403}
404
405static void usb_uas_queue_response(UASDevice *uas, uint16_t tag, uint8_t code)
406{
407 UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_RESPONSE, tag);
408
409 trace_usb_uas_response(uas->dev.addr, tag, code);
410 st->status.response.response_code = code;
411 usb_uas_queue_status(uas, st, sizeof(uas_iu_response));
412}
413
414static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
415{
416 UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_SENSE, req->tag);
417 int len, slen = 0;
418
419 trace_usb_uas_sense(req->uas->dev.addr, req->tag, status);
420 st->status.sense.status = status;
421 st->status.sense.status_qualifier = cpu_to_be16(0);
422 if (status != GOOD) {
423 slen = scsi_req_get_sense(req->req, st->status.sense.sense_data,
424 sizeof(st->status.sense.sense_data));
425 st->status.sense.sense_length = cpu_to_be16(slen);
426 }
427 len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
428 usb_uas_queue_status(req->uas, st, len);
429}
430
431static void usb_uas_queue_fake_sense(UASDevice *uas, uint16_t tag,
432 struct SCSISense sense)
433{
434 UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_SENSE, tag);
435 int len, slen = 0;
436
437 st->status.sense.status = CHECK_CONDITION;
438 st->status.sense.status_qualifier = cpu_to_be16(0);
439 st->status.sense.sense_data[0] = 0x70;
440 st->status.sense.sense_data[2] = sense.key;
441 st->status.sense.sense_data[7] = 10;
442 st->status.sense.sense_data[12] = sense.asc;
443 st->status.sense.sense_data[13] = sense.ascq;
444 slen = 18;
445 len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
446 usb_uas_queue_status(uas, st, len);
447}
448
449static void usb_uas_queue_read_ready(UASRequest *req)
450{
451 UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_READ_READY,
452 req->tag);
453
454 trace_usb_uas_read_ready(req->uas->dev.addr, req->tag);
455 usb_uas_queue_status(req->uas, st, 0);
456}
457
458static void usb_uas_queue_write_ready(UASRequest *req)
459{
460 UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_WRITE_READY,
461 req->tag);
462
463 trace_usb_uas_write_ready(req->uas->dev.addr, req->tag);
464 usb_uas_queue_status(req->uas, st, 0);
465}
466
467
468
469static int usb_uas_get_lun(uint64_t lun64)
470{
471 return (lun64 >> 48) & 0xff;
472}
473
474static SCSIDevice *usb_uas_get_dev(UASDevice *uas, uint64_t lun64)
475{
476 if ((lun64 >> 56) != 0x00) {
477 return NULL;
478 }
479 return scsi_device_find(&uas->bus, 0, 0, usb_uas_get_lun(lun64));
480}
481
482static void usb_uas_complete_data_packet(UASRequest *req)
483{
484 USBPacket *p;
485
486 if (!req->data_async) {
487 return;
488 }
489 p = req->data;
490 req->data = NULL;
491 req->data_async = false;
492 p->status = USB_RET_SUCCESS;
493 usb_packet_complete(&req->uas->dev, p);
494}
495
496static void usb_uas_copy_data(UASRequest *req)
497{
498 uint32_t length;
499
500 length = MIN(req->buf_size - req->buf_off,
501 req->data->iov.size - req->data->actual_length);
502 trace_usb_uas_xfer_data(req->uas->dev.addr, req->tag, length,
503 req->data->actual_length, req->data->iov.size,
504 req->buf_off, req->buf_size);
505 usb_packet_copy(req->data, scsi_req_get_buf(req->req) + req->buf_off,
506 length);
507 req->buf_off += length;
508 req->data_off += length;
509
510 if (req->data->actual_length == req->data->iov.size) {
511 usb_uas_complete_data_packet(req);
512 }
513 if (req->buf_size && req->buf_off == req->buf_size) {
514 req->buf_off = 0;
515 req->buf_size = 0;
516 scsi_req_continue(req->req);
517 }
518}
519
520static void usb_uas_start_next_transfer(UASDevice *uas)
521{
522 UASRequest *req;
523
524 if (uas_using_streams(uas)) {
525 return;
526 }
527
528 QTAILQ_FOREACH(req, &uas->requests, next) {
529 if (req->active || req->complete) {
530 continue;
531 }
532 if (req->req->cmd.mode == SCSI_XFER_FROM_DEV && uas->datain2 == NULL) {
533 uas->datain2 = req;
534 usb_uas_queue_read_ready(req);
535 req->active = true;
536 return;
537 }
538 if (req->req->cmd.mode == SCSI_XFER_TO_DEV && uas->dataout2 == NULL) {
539 uas->dataout2 = req;
540 usb_uas_queue_write_ready(req);
541 req->active = true;
542 return;
543 }
544 }
545}
546
547static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_iu *iu)
548{
549 UASRequest *req;
550
551 req = g_new0(UASRequest, 1);
552 req->uas = uas;
553 req->tag = be16_to_cpu(iu->hdr.tag);
554 req->lun = be64_to_cpu(iu->command.lun);
555 req->dev = usb_uas_get_dev(req->uas, req->lun);
556 return req;
557}
558
559static void usb_uas_scsi_free_request(SCSIBus *bus, void *priv)
560{
561 UASRequest *req = priv;
562 UASDevice *uas = req->uas;
563
564 if (req == uas->datain2) {
565 uas->datain2 = NULL;
566 }
567 if (req == uas->dataout2) {
568 uas->dataout2 = NULL;
569 }
570 QTAILQ_REMOVE(&uas->requests, req, next);
571 g_free(req);
572 usb_uas_start_next_transfer(uas);
573}
574
575static UASRequest *usb_uas_find_request(UASDevice *uas, uint16_t tag)
576{
577 UASRequest *req;
578
579 QTAILQ_FOREACH(req, &uas->requests, next) {
580 if (req->tag == tag) {
581 return req;
582 }
583 }
584 return NULL;
585}
586
587static void usb_uas_scsi_transfer_data(SCSIRequest *r, uint32_t len)
588{
589 UASRequest *req = r->hba_private;
590
591 trace_usb_uas_scsi_data(req->uas->dev.addr, req->tag, len);
592 req->buf_off = 0;
593 req->buf_size = len;
594 if (req->data) {
595 usb_uas_copy_data(req);
596 } else {
597 usb_uas_start_next_transfer(req->uas);
598 }
599}
600
601static void usb_uas_scsi_command_complete(SCSIRequest *r, size_t resid)
602{
603 UASRequest *req = r->hba_private;
604
605 trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, r->status, resid);
606 req->complete = true;
607 if (req->data) {
608 usb_uas_complete_data_packet(req);
609 }
610 usb_uas_queue_sense(req, r->status);
611 scsi_req_unref(req->req);
612}
613
614static void usb_uas_scsi_request_cancelled(SCSIRequest *r)
615{
616 UASRequest *req = r->hba_private;
617
618
619 scsi_req_unref(req->req);
620}
621
622static const struct SCSIBusInfo usb_uas_scsi_info = {
623 .tcq = true,
624 .max_target = 0,
625 .max_lun = 255,
626
627 .transfer_data = usb_uas_scsi_transfer_data,
628 .complete = usb_uas_scsi_command_complete,
629 .cancel = usb_uas_scsi_request_cancelled,
630 .free_request = usb_uas_scsi_free_request,
631};
632
633
634
635static void usb_uas_handle_reset(USBDevice *dev)
636{
637 UASDevice *uas = USB_UAS(dev);
638 UASRequest *req, *nreq;
639 UASStatus *st, *nst;
640
641 trace_usb_uas_reset(dev->addr);
642 QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
643 scsi_req_cancel(req->req);
644 }
645 QTAILQ_FOREACH_SAFE(st, &uas->results, next, nst) {
646 QTAILQ_REMOVE(&uas->results, st, next);
647 g_free(st);
648 }
649}
650
651static void usb_uas_handle_control(USBDevice *dev, USBPacket *p,
652 int request, int value, int index, int length, uint8_t *data)
653{
654 int ret;
655
656 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
657 if (ret >= 0) {
658 return;
659 }
660 error_report("%s: unhandled control request (req 0x%x, val 0x%x, idx 0x%x",
661 __func__, request, value, index);
662 p->status = USB_RET_STALL;
663}
664
665static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
666{
667 UASDevice *uas = USB_UAS(dev);
668 UASRequest *req, *nreq;
669 int i;
670
671 if (uas->status2 == p) {
672 uas->status2 = NULL;
673 qemu_bh_cancel(uas->status_bh);
674 return;
675 }
676 if (uas_using_streams(uas)) {
677 for (i = 0; i <= UAS_MAX_STREAMS; i++) {
678 if (uas->status3[i] == p) {
679 uas->status3[i] = NULL;
680 return;
681 }
682 if (uas->data3[i] == p) {
683 uas->data3[i] = NULL;
684 return;
685 }
686 }
687 }
688 QTAILQ_FOREACH_SAFE(req, &uas->requests, next, nreq) {
689 if (req->data == p) {
690 req->data = NULL;
691 return;
692 }
693 }
694 assert(!"canceled usb packet not found");
695}
696
697static void usb_uas_command(UASDevice *uas, uas_iu *iu)
698{
699 UASRequest *req;
700 uint32_t len;
701 uint16_t tag = be16_to_cpu(iu->hdr.tag);
702 size_t cdb_len = sizeof(iu->command.cdb) + iu->command.add_cdb_length;
703
704 if (iu->command.add_cdb_length > 0) {
705 qemu_log_mask(LOG_UNIMP, "additional adb length not yet supported\n");
706 goto unsupported_len;
707 }
708
709 if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
710 goto invalid_tag;
711 }
712 req = usb_uas_find_request(uas, tag);
713 if (req) {
714 goto overlapped_tag;
715 }
716 req = usb_uas_alloc_request(uas, iu);
717 if (req->dev == NULL) {
718 goto bad_target;
719 }
720
721 trace_usb_uas_command(uas->dev.addr, req->tag,
722 usb_uas_get_lun(req->lun),
723 req->lun >> 32, req->lun & 0xffffffff);
724 QTAILQ_INSERT_TAIL(&uas->requests, req, next);
725 if (uas_using_streams(uas) && uas->data3[req->tag] != NULL) {
726 req->data = uas->data3[req->tag];
727 req->data_async = true;
728 uas->data3[req->tag] = NULL;
729 }
730
731 req->req = scsi_req_new(req->dev, req->tag,
732 usb_uas_get_lun(req->lun),
733 iu->command.cdb, cdb_len, req);
734 if (uas->requestlog) {
735 scsi_req_print(req->req);
736 }
737 len = scsi_req_enqueue(req->req);
738 if (len) {
739 req->data_size = len;
740 scsi_req_continue(req->req);
741 }
742 return;
743
744unsupported_len:
745 usb_uas_queue_fake_sense(uas, tag, sense_code_INVALID_PARAM_VALUE);
746 return;
747
748invalid_tag:
749 usb_uas_queue_fake_sense(uas, tag, sense_code_INVALID_TAG);
750 return;
751
752overlapped_tag:
753 usb_uas_queue_fake_sense(uas, tag, sense_code_OVERLAPPED_COMMANDS);
754 return;
755
756bad_target:
757 usb_uas_queue_fake_sense(uas, tag, sense_code_LUN_NOT_SUPPORTED);
758 g_free(req);
759}
760
761static void usb_uas_task(UASDevice *uas, uas_iu *iu)
762{
763 uint16_t tag = be16_to_cpu(iu->hdr.tag);
764 uint64_t lun64 = be64_to_cpu(iu->task.lun);
765 SCSIDevice *dev = usb_uas_get_dev(uas, lun64);
766 int lun = usb_uas_get_lun(lun64);
767 UASRequest *req;
768 uint16_t task_tag;
769
770 if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
771 goto invalid_tag;
772 }
773 req = usb_uas_find_request(uas, be16_to_cpu(iu->hdr.tag));
774 if (req) {
775 goto overlapped_tag;
776 }
777 if (dev == NULL) {
778 goto incorrect_lun;
779 }
780
781 switch (iu->task.function) {
782 case UAS_TMF_ABORT_TASK:
783 task_tag = be16_to_cpu(iu->task.task_tag);
784 trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
785 req = usb_uas_find_request(uas, task_tag);
786 if (req && req->dev == dev) {
787 scsi_req_cancel(req->req);
788 }
789 usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
790 break;
791
792 case UAS_TMF_LOGICAL_UNIT_RESET:
793 trace_usb_uas_tmf_logical_unit_reset(uas->dev.addr, tag, lun);
794 qdev_reset_all(&dev->qdev);
795 usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
796 break;
797
798 default:
799 trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, iu->task.function);
800 usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED);
801 break;
802 }
803 return;
804
805invalid_tag:
806 usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT);
807 return;
808
809overlapped_tag:
810 usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG);
811 return;
812
813incorrect_lun:
814 usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN);
815}
816
817static void usb_uas_handle_data(USBDevice *dev, USBPacket *p)
818{
819 UASDevice *uas = USB_UAS(dev);
820 uas_iu iu;
821 UASStatus *st;
822 UASRequest *req;
823 int length;
824
825 switch (p->ep->nr) {
826 case UAS_PIPE_ID_COMMAND:
827 length = MIN(sizeof(iu), p->iov.size);
828 usb_packet_copy(p, &iu, length);
829 switch (iu.hdr.id) {
830 case UAS_UI_COMMAND:
831 usb_uas_command(uas, &iu);
832 break;
833 case UAS_UI_TASK_MGMT:
834 usb_uas_task(uas, &iu);
835 break;
836 default:
837 error_report("%s: unknown command iu: id 0x%x",
838 __func__, iu.hdr.id);
839 p->status = USB_RET_STALL;
840 break;
841 }
842 break;
843 case UAS_PIPE_ID_STATUS:
844 if (p->stream > UAS_MAX_STREAMS) {
845 goto err_stream;
846 }
847 if (p->stream) {
848 QTAILQ_FOREACH(st, &uas->results, next) {
849 if (st->stream == p->stream) {
850 break;
851 }
852 }
853 if (st == NULL) {
854 assert(uas->status3[p->stream] == NULL);
855 uas->status3[p->stream] = p;
856 p->status = USB_RET_ASYNC;
857 break;
858 }
859 } else {
860 st = QTAILQ_FIRST(&uas->results);
861 if (st == NULL) {
862 assert(uas->status2 == NULL);
863 uas->status2 = p;
864 p->status = USB_RET_ASYNC;
865 break;
866 }
867 }
868 usb_packet_copy(p, &st->status, st->length);
869 QTAILQ_REMOVE(&uas->results, st, next);
870 g_free(st);
871 break;
872 case UAS_PIPE_ID_DATA_IN:
873 case UAS_PIPE_ID_DATA_OUT:
874 if (p->stream > UAS_MAX_STREAMS) {
875 goto err_stream;
876 }
877 if (p->stream) {
878 req = usb_uas_find_request(uas, p->stream);
879 } else {
880 req = (p->ep->nr == UAS_PIPE_ID_DATA_IN)
881 ? uas->datain2 : uas->dataout2;
882 }
883 if (req == NULL) {
884 if (p->stream) {
885 assert(uas->data3[p->stream] == NULL);
886 uas->data3[p->stream] = p;
887 p->status = USB_RET_ASYNC;
888 break;
889 } else {
890 error_report("%s: no inflight request", __func__);
891 p->status = USB_RET_STALL;
892 break;
893 }
894 }
895 scsi_req_ref(req->req);
896 req->data = p;
897 usb_uas_copy_data(req);
898 if (p->actual_length == p->iov.size || req->complete) {
899 req->data = NULL;
900 } else {
901 req->data_async = true;
902 p->status = USB_RET_ASYNC;
903 }
904 scsi_req_unref(req->req);
905 usb_uas_start_next_transfer(uas);
906 break;
907 default:
908 error_report("%s: invalid endpoint %d", __func__, p->ep->nr);
909 p->status = USB_RET_STALL;
910 break;
911 }
912 return;
913
914err_stream:
915 error_report("%s: invalid stream %d", __func__, p->stream);
916 p->status = USB_RET_STALL;
917 return;
918}
919
920static void usb_uas_unrealize(USBDevice *dev)
921{
922 UASDevice *uas = USB_UAS(dev);
923
924 qemu_bh_delete(uas->status_bh);
925}
926
927static void usb_uas_realize(USBDevice *dev, Error **errp)
928{
929 UASDevice *uas = USB_UAS(dev);
930 DeviceState *d = DEVICE(dev);
931
932 usb_desc_create_serial(dev);
933 usb_desc_init(dev);
934 if (d->hotplugged) {
935 uas->dev.auto_attach = 0;
936 }
937
938 QTAILQ_INIT(&uas->results);
939 QTAILQ_INIT(&uas->requests);
940 uas->status_bh = qemu_bh_new_guarded(usb_uas_send_status_bh, uas,
941 &d->mem_reentrancy_guard);
942
943 dev->flags |= (1 << USB_DEV_FLAG_IS_SCSI_STORAGE);
944 scsi_bus_init(&uas->bus, sizeof(uas->bus), DEVICE(dev), &usb_uas_scsi_info);
945}
946
947static const VMStateDescription vmstate_usb_uas = {
948 .name = "usb-uas",
949 .unmigratable = 1,
950 .fields = (VMStateField[]) {
951 VMSTATE_USB_DEVICE(dev, UASDevice),
952 VMSTATE_END_OF_LIST()
953 }
954};
955
956static Property uas_properties[] = {
957 DEFINE_PROP_UINT32("log-scsi-req", UASDevice, requestlog, 0),
958 DEFINE_PROP_END_OF_LIST(),
959};
960
961static void usb_uas_class_initfn(ObjectClass *klass, void *data)
962{
963 DeviceClass *dc = DEVICE_CLASS(klass);
964 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
965
966 uc->realize = usb_uas_realize;
967 uc->product_desc = desc_strings[STR_PRODUCT];
968 uc->usb_desc = &desc;
969 uc->cancel_packet = usb_uas_cancel_io;
970 uc->handle_attach = usb_desc_attach;
971 uc->handle_reset = usb_uas_handle_reset;
972 uc->handle_control = usb_uas_handle_control;
973 uc->handle_data = usb_uas_handle_data;
974 uc->unrealize = usb_uas_unrealize;
975 uc->attached_settable = true;
976 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
977 dc->fw_name = "storage";
978 dc->vmsd = &vmstate_usb_uas;
979 device_class_set_props(dc, uas_properties);
980}
981
982static const TypeInfo uas_info = {
983 .name = TYPE_USB_UAS,
984 .parent = TYPE_USB_DEVICE,
985 .instance_size = sizeof(UASDevice),
986 .class_init = usb_uas_class_initfn,
987};
988
989static void usb_uas_register_types(void)
990{
991 type_register_static(&uas_info);
992}
993
994type_init(usb_uas_register_types)
995
