blob: 1804cb67997f0e823658541ad70b4a0d365f5b81 [file] [log] [blame]
Gerd Hoffmann0f58f682012-06-08 16:03:37 +02001/*
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
Peter Maydelle532b2e2016-01-26 18:17:12 +000012#include "qemu/osdep.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010013#include "qemu/option.h"
14#include "qemu/config-file.h"
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020015#include "trace.h"
Gonglei6b7afb72014-09-19 14:48:32 +080016#include "qemu/error-report.h"
Markus Armbrusterdb725812019-08-12 07:23:50 +020017#include "qemu/main-loop.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020018#include "qemu/module.h"
Philippe Mathieu-Daudéd755cb92021-01-20 16:35:22 +010019#include "qemu/log.h"
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020020
21#include "hw/usb.h"
Markus Armbrusterd6454272019-08-12 07:23:45 +020022#include "migration/vmstate.h"
Michael S. Tsirkin463581a2018-05-03 22:50:48 +030023#include "desc.h"
Markus Armbrustera27bd6c2019-08-12 07:23:51 +020024#include "hw/qdev-properties.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010025#include "hw/scsi/scsi.h"
Paolo Bonzini08e2c9f2017-08-22 09:23:55 +020026#include "scsi/constants.h"
Eduardo Habkostdb1015e2020-09-03 16:43:22 -040027#include "qom/object.h"
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020028
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;
Hans de Goede5007c942013-11-19 14:37:04 +010065} QEMU_PACKED uas_iu_header;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020066
67typedef struct {
68 uint8_t prio_taskattr; /* 6:3 priority, 2:0 task attribute */
69 uint8_t reserved_1;
70 uint8_t add_cdb_length; /* 7:2 additional adb length (dwords) */
71 uint8_t reserved_2;
72 uint64_t lun;
73 uint8_t cdb[16];
John Millikinfe9d8922022-08-17 14:34:58 +090074 uint8_t add_cdb[1];
Hans de Goede5007c942013-11-19 14:37:04 +010075} QEMU_PACKED uas_iu_command;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020076
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];
Hans de Goede5007c942013-11-19 14:37:04 +010083} QEMU_PACKED uas_iu_sense;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020084
85typedef struct {
Hans de Goede49cfa2f2013-10-31 10:35:31 +010086 uint8_t add_response_info[3];
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020087 uint8_t response_code;
Hans de Goede5007c942013-11-19 14:37:04 +010088} QEMU_PACKED uas_iu_response;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020089
90typedef struct {
91 uint8_t function;
92 uint8_t reserved;
93 uint16_t task_tag;
94 uint64_t lun;
Hans de Goede5007c942013-11-19 14:37:04 +010095} QEMU_PACKED uas_iu_task_mgmt;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020096
97typedef struct {
Hans de Goede5007c942013-11-19 14:37:04 +010098 uas_iu_header hdr;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +020099 union {
Hans de Goede5007c942013-11-19 14:37:04 +0100100 uas_iu_command command;
101 uas_iu_sense sense;
102 uas_iu_task_mgmt task;
103 uas_iu_response response;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200104 };
Hans de Goede5007c942013-11-19 14:37:04 +0100105} QEMU_PACKED uas_iu;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200106
107/* --------------------------------------------------------------------- */
108
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100109#define UAS_STREAM_BM_ATTR 4
110#define UAS_MAX_STREAMS (1 << UAS_STREAM_BM_ATTR)
111
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200112typedef struct UASDevice UASDevice;
113typedef struct UASRequest UASRequest;
114typedef struct UASStatus UASStatus;
115
116struct UASDevice {
117 USBDevice dev;
118 SCSIBus bus;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200119 QEMUBH *status_bh;
120 QTAILQ_HEAD(, UASStatus) results;
121 QTAILQ_HEAD(, UASRequest) requests;
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100122
Gerd Hoffmann1556a8f2013-08-27 14:54:44 +0200123 /* properties */
124 uint32_t requestlog;
125
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100126 /* usb 2.0 only */
127 USBPacket *status2;
128 UASRequest *datain2;
129 UASRequest *dataout2;
130
131 /* usb 3.0 only */
Hans de Goede04786612013-10-24 18:15:52 +0100132 USBPacket *data3[UAS_MAX_STREAMS + 1];
133 USBPacket *status3[UAS_MAX_STREAMS + 1];
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200134};
135
Gonglei0b06d092015-05-06 20:55:33 +0800136#define TYPE_USB_UAS "usb-uas"
Eduardo Habkost80633962020-09-16 14:25:19 -0400137OBJECT_DECLARE_SIMPLE_TYPE(UASDevice, USB_UAS)
Gonglei0b06d092015-05-06 20:55:33 +0800138
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200139struct 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 {
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100157 uint32_t stream;
Hans de Goede5007c942013-11-19 14:37:04 +0100158 uas_iu status;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200159 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,
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100170 STR_CONFIG_SUPER,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200171};
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)",
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100178 [STR_CONFIG_SUPER] = "Super speed config (usb 3.0)",
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200179};
180
181static const USBDescIface desc_iface_high = {
182 .bInterfaceNumber = 0,
183 .bNumEndpoints = 4,
184 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
185 .bInterfaceSubClass = 0x06, /* SCSI */
186 .bInterfaceProtocol = 0x62, /* UAS */
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, /* u8 bLength */
194 0x24, /* u8 bDescriptorType */
195 UAS_PIPE_ID_COMMAND,
196 0x00, /* u8 bReserved */
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, /* u8 bLength */
204 0x24, /* u8 bDescriptorType */
205 UAS_PIPE_ID_STATUS,
206 0x00, /* u8 bReserved */
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, /* u8 bLength */
214 0x24, /* u8 bDescriptorType */
215 UAS_PIPE_ID_DATA_IN,
216 0x00, /* u8 bReserved */
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, /* u8 bLength */
224 0x24, /* u8 bDescriptorType */
225 UAS_PIPE_ID_DATA_OUT,
226 0x00, /* u8 bReserved */
227 },
228 },
229 }
230};
231
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100232static const USBDescIface desc_iface_super = {
233 .bInterfaceNumber = 0,
234 .bNumEndpoints = 4,
235 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
236 .bInterfaceSubClass = 0x06, /* SCSI */
237 .bInterfaceProtocol = 0x62, /* UAS */
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, /* u8 bLength */
246 0x24, /* u8 bDescriptorType */
247 UAS_PIPE_ID_COMMAND,
248 0x00, /* u8 bReserved */
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, /* u8 bLength */
258 0x24, /* u8 bDescriptorType */
259 UAS_PIPE_ID_STATUS,
260 0x00, /* u8 bReserved */
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, /* u8 bLength */
270 0x24, /* u8 bDescriptorType */
271 UAS_PIPE_ID_DATA_IN,
272 0x00, /* u8 bReserved */
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, /* u8 bLength */
282 0x24, /* u8 bDescriptorType */
283 UAS_PIPE_ID_DATA_OUT,
284 0x00, /* u8 bReserved */
285 },
286 },
287 }
288};
289
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200290static 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,
Pantelis Koukousoulasbd939762013-12-16 09:42:49 +0200299 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200300 .nif = 1,
301 .ifs = &desc_iface_high,
302 },
303 },
304};
305
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100306static const USBDescDevice desc_device_super = {
307 .bcdUSB = 0x0300,
Gerd Hoffmann8ddcc432020-01-17 08:37:16 +0100308 .bMaxPacketSize0 = 9,
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100309 .bNumConfigurations = 1,
310 .confs = (USBDescConfig[]) {
311 {
312 .bNumInterfaces = 1,
313 .bConfigurationValue = 1,
314 .iConfiguration = STR_CONFIG_SUPER,
Pantelis Koukousoulasbd939762013-12-16 09:42:49 +0200315 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100316 .nif = 1,
317 .ifs = &desc_iface_super,
318 },
319 },
320};
321
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200322static const USBDesc desc = {
323 .id = {
324 .idVendor = 0x46f4, /* CRC16() of "QEMU" */
Gerd Hoffmann0daf5302012-08-10 13:06:05 +0200325 .idProduct = 0x0003,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200326 .bcdDevice = 0,
327 .iManufacturer = STR_MANUFACTURER,
328 .iProduct = STR_PRODUCT,
329 .iSerialNumber = STR_SERIALNUMBER,
330 },
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100331 .high = &desc_device_high,
332 .super = &desc_device_super,
333 .str = desc_strings,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200334};
335
336/* --------------------------------------------------------------------- */
337
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100338static 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)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200346{
347 UASStatus *st = g_new0(UASStatus, 1);
348
349 st->status.hdr.id = id;
350 st->status.hdr.tag = cpu_to_be16(tag);
Hans de Goede5007c942013-11-19 14:37:04 +0100351 st->length = sizeof(uas_iu_header);
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100352 if (uas_using_streams(uas)) {
353 st->stream = tag;
354 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200355 return st;
356}
357
358static void usb_uas_send_status_bh(void *opaque)
359{
360 UASDevice *uas = opaque;
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100361 UASStatus *st;
362 USBPacket *p;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200363
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100364 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 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200375
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100376 usb_packet_copy(p, &st->status, st->length);
377 QTAILQ_REMOVE(&uas->results, st, next);
378 g_free(st);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200379
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100380 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
381 usb_packet_complete(&uas->dev, p);
382 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200383}
384
385static void usb_uas_queue_status(UASDevice *uas, UASStatus *st, int length)
386{
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100387 USBPacket *p = uas_using_streams(uas) ?
388 uas->status3[st->stream] : uas->status2;
389
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200390 st->length += length;
391 QTAILQ_INSERT_TAIL(&uas->results, st, next);
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100392 if (p) {
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200393 /*
394 * Just schedule bh make sure any in-flight data transaction
395 * is finished before completing (sending) the status packet.
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);
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100401 usb_wakeup(ep, st->stream);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200402 }
403}
404
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100405static void usb_uas_queue_response(UASDevice *uas, uint16_t tag, uint8_t code)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200406{
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100407 UASStatus *st = usb_uas_alloc_status(uas, UAS_UI_RESPONSE, tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200408
409 trace_usb_uas_response(uas->dev.addr, tag, code);
410 st->status.response.response_code = code;
Hans de Goede5007c942013-11-19 14:37:04 +0100411 usb_uas_queue_status(uas, st, sizeof(uas_iu_response));
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200412}
413
414static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
415{
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100416 UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_SENSE, req->tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200417 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 }
Hans de Goede5007c942013-11-19 14:37:04 +0100427 len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200428 usb_uas_queue_status(req->uas, st, len);
429}
430
Hans de Goeded4bfc7b2013-10-24 18:15:50 +0100431static 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;
Hans de Goede5007c942013-11-19 14:37:04 +0100445 len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
Hans de Goeded4bfc7b2013-10-24 18:15:50 +0100446 usb_uas_queue_status(uas, st, len);
447}
448
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200449static void usb_uas_queue_read_ready(UASRequest *req)
450{
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100451 UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_READ_READY,
452 req->tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200453
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{
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100460 UASStatus *st = usb_uas_alloc_status(req->uas, UAS_UI_WRITE_READY,
461 req->tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200462
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;
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100492 p->status = USB_RET_SUCCESS; /* Clear previous ASYNC status */
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200493 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,
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100501 req->data->iov.size - req->data->actual_length);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200502 trace_usb_uas_xfer_data(req->uas->dev.addr, req->tag, length,
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100503 req->data->actual_length, req->data->iov.size,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200504 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
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100510 if (req->data->actual_length == req->data->iov.size) {
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200511 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
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100524 if (uas_using_streams(uas)) {
525 return;
526 }
527
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200528 QTAILQ_FOREACH(req, &uas->requests, next) {
529 if (req->active || req->complete) {
530 continue;
531 }
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100532 if (req->req->cmd.mode == SCSI_XFER_FROM_DEV && uas->datain2 == NULL) {
533 uas->datain2 = req;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200534 usb_uas_queue_read_ready(req);
535 req->active = true;
536 return;
537 }
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100538 if (req->req->cmd.mode == SCSI_XFER_TO_DEV && uas->dataout2 == NULL) {
539 uas->dataout2 = req;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200540 usb_uas_queue_write_ready(req);
541 req->active = true;
542 return;
543 }
544 }
545}
546
Hans de Goede5007c942013-11-19 14:37:04 +0100547static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_iu *iu)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200548{
549 UASRequest *req;
550
551 req = g_new0(UASRequest, 1);
552 req->uas = uas;
Hans de Goede5007c942013-11-19 14:37:04 +0100553 req->tag = be16_to_cpu(iu->hdr.tag);
554 req->lun = be64_to_cpu(iu->command.lun);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200555 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
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100564 if (req == uas->datain2) {
565 uas->datain2 = NULL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200566 }
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100567 if (req == uas->dataout2) {
568 uas->dataout2 = NULL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200569 }
570 QTAILQ_REMOVE(&uas->requests, req, next);
571 g_free(req);
Gerd Hoffmann347e40f2012-08-31 14:34:19 +0200572 usb_uas_start_next_transfer(uas);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200573}
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
Hannes Reinecke17ea26c22020-11-16 19:40:36 +0100601static void usb_uas_scsi_command_complete(SCSIRequest *r, size_t resid)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200602{
603 UASRequest *req = r->hba_private;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200604
Hannes Reinecke17ea26c22020-11-16 19:40:36 +0100605 trace_usb_uas_scsi_complete(req->uas->dev.addr, req->tag, r->status, resid);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200606 req->complete = true;
607 if (req->data) {
608 usb_uas_complete_data_packet(req);
609 }
Hannes Reinecke17ea26c22020-11-16 19:40:36 +0100610 usb_uas_queue_sense(req, r->status);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200611 scsi_req_unref(req->req);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200612}
613
614static void usb_uas_scsi_request_cancelled(SCSIRequest *r)
615{
616 UASRequest *req = r->hba_private;
617
618 /* FIXME: queue notification to status pipe? */
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{
Gonglei0b06d092015-05-06 20:55:33 +0800637 UASDevice *uas = USB_UAS(dev);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200638 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
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100651static void usb_uas_handle_control(USBDevice *dev, USBPacket *p,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200652 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) {
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100658 return;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200659 }
Gerd Hoffmanne306b2f2017-01-31 14:52:06 +0100660 error_report("%s: unhandled control request (req 0x%x, val 0x%x, idx 0x%x",
661 __func__, request, value, index);
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100662 p->status = USB_RET_STALL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200663}
664
665static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
666{
Gonglei0b06d092015-05-06 20:55:33 +0800667 UASDevice *uas = USB_UAS(dev);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200668 UASRequest *req, *nreq;
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100669 int i;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200670
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100671 if (uas->status2 == p) {
672 uas->status2 = NULL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200673 qemu_bh_cancel(uas->status_bh);
674 return;
675 }
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100676 if (uas_using_streams(uas)) {
Hans de Goede04786612013-10-24 18:15:52 +0100677 for (i = 0; i <= UAS_MAX_STREAMS; i++) {
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100678 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 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200688 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
Hans de Goede5007c942013-11-19 14:37:04 +0100697static void usb_uas_command(UASDevice *uas, uas_iu *iu)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200698{
699 UASRequest *req;
700 uint32_t len;
Hans de Goede5007c942013-11-19 14:37:04 +0100701 uint16_t tag = be16_to_cpu(iu->hdr.tag);
John Millikinfe9d8922022-08-17 14:34:58 +0900702 size_t cdb_len = sizeof(iu->command.cdb) + iu->command.add_cdb_length;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200703
Philippe Mathieu-Daudéd755cb92021-01-20 16:35:22 +0100704 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
Hans de Goede3453f9a2013-10-24 18:15:53 +0100709 if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
710 goto invalid_tag;
711 }
Hans de Goeded4bfc7b2013-10-24 18:15:50 +0100712 req = usb_uas_find_request(uas, tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200713 if (req) {
714 goto overlapped_tag;
715 }
Hans de Goede5007c942013-11-19 14:37:04 +0100716 req = usb_uas_alloc_request(uas, iu);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200717 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);
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100725 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
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200731 req->req = scsi_req_new(req->dev, req->tag,
732 usb_uas_get_lun(req->lun),
John Millikinfe9d8922022-08-17 14:34:58 +0900733 iu->command.cdb, cdb_len, req);
Gerd Hoffmann1556a8f2013-08-27 14:54:44 +0200734 if (uas->requestlog) {
735 scsi_req_print(req->req);
736 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200737 len = scsi_req_enqueue(req->req);
738 if (len) {
739 req->data_size = len;
740 scsi_req_continue(req->req);
741 }
742 return;
743
Philippe Mathieu-Daudéd755cb92021-01-20 16:35:22 +0100744unsupported_len:
745 usb_uas_queue_fake_sense(uas, tag, sense_code_INVALID_PARAM_VALUE);
746 return;
747
Hans de Goede3453f9a2013-10-24 18:15:53 +0100748invalid_tag:
749 usb_uas_queue_fake_sense(uas, tag, sense_code_INVALID_TAG);
750 return;
751
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200752overlapped_tag:
Hans de Goeded4bfc7b2013-10-24 18:15:50 +0100753 usb_uas_queue_fake_sense(uas, tag, sense_code_OVERLAPPED_COMMANDS);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200754 return;
755
756bad_target:
Hans de Goeded4bfc7b2013-10-24 18:15:50 +0100757 usb_uas_queue_fake_sense(uas, tag, sense_code_LUN_NOT_SUPPORTED);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200758 g_free(req);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200759}
760
Hans de Goede5007c942013-11-19 14:37:04 +0100761static void usb_uas_task(UASDevice *uas, uas_iu *iu)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200762{
Hans de Goede5007c942013-11-19 14:37:04 +0100763 uint16_t tag = be16_to_cpu(iu->hdr.tag);
764 uint64_t lun64 = be64_to_cpu(iu->task.lun);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200765 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
Hans de Goede3453f9a2013-10-24 18:15:53 +0100770 if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
771 goto invalid_tag;
772 }
Hans de Goede5007c942013-11-19 14:37:04 +0100773 req = usb_uas_find_request(uas, be16_to_cpu(iu->hdr.tag));
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200774 if (req) {
775 goto overlapped_tag;
776 }
Hans de Goede5eb6d9e2013-10-24 18:15:51 +0100777 if (dev == NULL) {
778 goto incorrect_lun;
779 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200780
Hans de Goede5007c942013-11-19 14:37:04 +0100781 switch (iu->task.function) {
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200782 case UAS_TMF_ABORT_TASK:
Hans de Goede5007c942013-11-19 14:37:04 +0100783 task_tag = be16_to_cpu(iu->task.task_tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200784 trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200785 req = usb_uas_find_request(uas, task_tag);
786 if (req && req->dev == dev) {
787 scsi_req_cancel(req->req);
788 }
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100789 usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200790 break;
791
792 case UAS_TMF_LOGICAL_UNIT_RESET:
793 trace_usb_uas_tmf_logical_unit_reset(uas->dev.addr, tag, lun);
Peter Maydelldfa6ba62022-12-16 15:55:27 +0000794 device_cold_reset(&dev->qdev);
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100795 usb_uas_queue_response(uas, tag, UAS_RC_TMF_COMPLETE);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200796 break;
797
798 default:
Hans de Goede5007c942013-11-19 14:37:04 +0100799 trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, iu->task.function);
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100800 usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200801 break;
802 }
803 return;
804
Hans de Goede3453f9a2013-10-24 18:15:53 +0100805invalid_tag:
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100806 usb_uas_queue_response(uas, tag, UAS_RC_INVALID_INFO_UNIT);
Hans de Goede3453f9a2013-10-24 18:15:53 +0100807 return;
808
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200809overlapped_tag:
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100810 usb_uas_queue_response(uas, req->tag, UAS_RC_OVERLAPPED_TAG);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200811 return;
812
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200813incorrect_lun:
Hans de Goede49cfa2f2013-10-31 10:35:31 +0100814 usb_uas_queue_response(uas, tag, UAS_RC_INCORRECT_LUN);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200815}
816
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100817static void usb_uas_handle_data(USBDevice *dev, USBPacket *p)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200818{
Gonglei0b06d092015-05-06 20:55:33 +0800819 UASDevice *uas = USB_UAS(dev);
Hans de Goede5007c942013-11-19 14:37:04 +0100820 uas_iu iu;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200821 UASStatus *st;
822 UASRequest *req;
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100823 int length;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200824
825 switch (p->ep->nr) {
826 case UAS_PIPE_ID_COMMAND:
Hans de Goede5007c942013-11-19 14:37:04 +0100827 length = MIN(sizeof(iu), p->iov.size);
828 usb_packet_copy(p, &iu, length);
829 switch (iu.hdr.id) {
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200830 case UAS_UI_COMMAND:
Hans de Goede5007c942013-11-19 14:37:04 +0100831 usb_uas_command(uas, &iu);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200832 break;
833 case UAS_UI_TASK_MGMT:
Hans de Goede5007c942013-11-19 14:37:04 +0100834 usb_uas_task(uas, &iu);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200835 break;
836 default:
Gonglei6b7afb72014-09-19 14:48:32 +0800837 error_report("%s: unknown command iu: id 0x%x",
838 __func__, iu.hdr.id);
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100839 p->status = USB_RET_STALL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200840 break;
841 }
842 break;
843 case UAS_PIPE_ID_STATUS:
Gerd Hoffmann13b250b2021-08-18 14:05:05 +0200844 if (p->stream > UAS_MAX_STREAMS) {
845 goto err_stream;
846 }
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100847 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 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200867 }
868 usb_packet_copy(p, &st->status, st->length);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200869 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:
Gerd Hoffmann13b250b2021-08-18 14:05:05 +0200874 if (p->stream > UAS_MAX_STREAMS) {
875 goto err_stream;
876 }
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100877 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 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200883 if (req == NULL) {
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100884 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 {
Gonglei6b7afb72014-09-19 14:48:32 +0800890 error_report("%s: no inflight request", __func__);
Gerd Hoffmann89a453d2013-01-25 17:38:59 +0100891 p->status = USB_RET_STALL;
892 break;
893 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200894 }
895 scsi_req_ref(req->req);
896 req->data = p;
897 usb_uas_copy_data(req);
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100898 if (p->actual_length == p->iov.size || req->complete) {
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200899 req->data = NULL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200900 } else {
901 req->data_async = true;
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100902 p->status = USB_RET_ASYNC;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200903 }
904 scsi_req_unref(req->req);
905 usb_uas_start_next_transfer(uas);
906 break;
907 default:
Gonglei6b7afb72014-09-19 14:48:32 +0800908 error_report("%s: invalid endpoint %d", __func__, p->ep->nr);
Hans de Goede9a77a0f2012-11-01 17:15:01 +0100909 p->status = USB_RET_STALL;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200910 break;
911 }
Gerd Hoffmann1c6c0b92021-12-10 09:06:59 +0100912 return;
Gerd Hoffmann13b250b2021-08-18 14:05:05 +0200913
914err_stream:
915 error_report("%s: invalid stream %d", __func__, p->stream);
916 p->status = USB_RET_STALL;
917 return;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200918}
919
Markus Armbrusterb69c3c22020-05-05 17:29:24 +0200920static void usb_uas_unrealize(USBDevice *dev)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200921{
Gonglei0b06d092015-05-06 20:55:33 +0800922 UASDevice *uas = USB_UAS(dev);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200923
924 qemu_bh_delete(uas->status_bh);
925}
926
Gongleib89dc7e2014-09-19 14:48:31 +0800927static void usb_uas_realize(USBDevice *dev, Error **errp)
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200928{
Gonglei0b06d092015-05-06 20:55:33 +0800929 UASDevice *uas = USB_UAS(dev);
Gerd Hoffmann0d4cf3e2016-06-15 11:46:59 +0200930 DeviceState *d = DEVICE(dev);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200931
932 usb_desc_create_serial(dev);
933 usb_desc_init(dev);
Gerd Hoffmann0d4cf3e2016-06-15 11:46:59 +0200934 if (d->hotplugged) {
935 uas->dev.auto_attach = 0;
936 }
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200937
938 QTAILQ_INIT(&uas->results);
939 QTAILQ_INIT(&uas->requests);
Alexander Bulekovf63192b2023-04-27 17:10:09 -0400940 uas->status_bh = qemu_bh_new_guarded(usb_uas_send_status_bh, uas,
941 &d->mem_reentrancy_guard);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200942
Gerd Hoffmannb7b2a602021-06-24 12:38:33 +0200943 dev->flags |= (1 << USB_DEV_FLAG_IS_SCSI_STORAGE);
Peter Maydell739e95f2021-09-23 13:11:48 +0100944 scsi_bus_init(&uas->bus, sizeof(uas->bus), DEVICE(dev), &usb_uas_scsi_info);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200945}
946
947static const VMStateDescription vmstate_usb_uas = {
948 .name = "usb-uas",
949 .unmigratable = 1,
Richard Henderson3abedf22023-12-21 14:16:39 +1100950 .fields = (const VMStateField[]) {
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200951 VMSTATE_USB_DEVICE(dev, UASDevice),
952 VMSTATE_END_OF_LIST()
953 }
954};
955
Gerd Hoffmann1556a8f2013-08-27 14:54:44 +0200956static Property uas_properties[] = {
957 DEFINE_PROP_UINT32("log-scsi-req", UASDevice, requestlog, 0),
958 DEFINE_PROP_END_OF_LIST(),
959};
960
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200961static void usb_uas_class_initfn(ObjectClass *klass, void *data)
962{
963 DeviceClass *dc = DEVICE_CLASS(klass);
964 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
965
Gongleib89dc7e2014-09-19 14:48:31 +0800966 uc->realize = usb_uas_realize;
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200967 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;
Marc-André Lureauc4fe9702017-02-21 18:14:45 +0400974 uc->unrealize = usb_uas_unrealize;
Gerd Hoffmann0d4cf3e2016-06-15 11:46:59 +0200975 uc->attached_settable = true;
Marcel Apfelbaum125ee0e2013-07-29 17:17:45 +0300976 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200977 dc->fw_name = "storage";
978 dc->vmsd = &vmstate_usb_uas;
Marc-André Lureau4f67d302020-01-10 19:30:32 +0400979 device_class_set_props(dc, uas_properties);
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200980}
981
Andreas Färber8c43a6f2013-01-10 16:19:07 +0100982static const TypeInfo uas_info = {
Gonglei0b06d092015-05-06 20:55:33 +0800983 .name = TYPE_USB_UAS,
Gerd Hoffmann0f58f682012-06-08 16:03:37 +0200984 .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)