1
2
3
4
5
6
7
8
9
10#include "qemu/osdep.h"
11#include "qapi/error.h"
12#include "qemu-common.h"
13#include "qemu/error-report.h"
14#include "qemu/option.h"
15#include "qemu/config-file.h"
16#include "hw/usb.h"
17#include "desc.h"
18#include "hw/scsi/scsi.h"
19#include "ui/console.h"
20#include "monitor/monitor.h"
21#include "sysemu/sysemu.h"
22#include "sysemu/block-backend.h"
23#include "qapi/visitor.h"
24#include "qemu/cutils.h"
25
26
27
28#ifdef DEBUG_MSD
29#define DPRINTF(fmt, ...) \
30do { printf("usb-msd: " fmt , ## __VA_ARGS__); } while (0)
31#else
32#define DPRINTF(fmt, ...) do {} while(0)
33#endif
34
35
36#define MassStorageReset 0xff
37#define GetMaxLun 0xfe
38
39enum USBMSDMode {
40 USB_MSDM_CBW,
41 USB_MSDM_DATAOUT,
42 USB_MSDM_DATAIN,
43 USB_MSDM_CSW
44};
45
46struct usb_msd_csw {
47 uint32_t sig;
48 uint32_t tag;
49 uint32_t residue;
50 uint8_t status;
51};
52
53typedef struct {
54 USBDevice dev;
55 enum USBMSDMode mode;
56 uint32_t scsi_off;
57 uint32_t scsi_len;
58 uint32_t data_len;
59 struct usb_msd_csw csw;
60 SCSIRequest *req;
61 SCSIBus bus;
62
63 USBPacket *packet;
64
65 BlockConf conf;
66 uint32_t removable;
67 SCSIDevice *scsi_dev;
68} MSDState;
69
70#define TYPE_USB_STORAGE "usb-storage-dev"
71#define USB_STORAGE_DEV(obj) OBJECT_CHECK(MSDState, (obj), TYPE_USB_STORAGE)
72
73struct usb_msd_cbw {
74 uint32_t sig;
75 uint32_t tag;
76 uint32_t data_len;
77 uint8_t flags;
78 uint8_t lun;
79 uint8_t cmd_len;
80 uint8_t cmd[16];
81};
82
83enum {
84 STR_MANUFACTURER = 1,
85 STR_PRODUCT,
86 STR_SERIALNUMBER,
87 STR_CONFIG_FULL,
88 STR_CONFIG_HIGH,
89 STR_CONFIG_SUPER,
90};
91
92static const USBDescStrings desc_strings = {
93 [STR_MANUFACTURER] = "QEMU",
94 [STR_PRODUCT] = "QEMU USB HARDDRIVE",
95 [STR_SERIALNUMBER] = "1",
96 [STR_CONFIG_FULL] = "Full speed config (usb 1.1)",
97 [STR_CONFIG_HIGH] = "High speed config (usb 2.0)",
98 [STR_CONFIG_SUPER] = "Super speed config (usb 3.0)",
99};
100
101static const USBDescIface desc_iface_full = {
102 .bInterfaceNumber = 0,
103 .bNumEndpoints = 2,
104 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
105 .bInterfaceSubClass = 0x06,
106 .bInterfaceProtocol = 0x50,
107 .eps = (USBDescEndpoint[]) {
108 {
109 .bEndpointAddress = USB_DIR_IN | 0x01,
110 .bmAttributes = USB_ENDPOINT_XFER_BULK,
111 .wMaxPacketSize = 64,
112 },{
113 .bEndpointAddress = USB_DIR_OUT | 0x02,
114 .bmAttributes = USB_ENDPOINT_XFER_BULK,
115 .wMaxPacketSize = 64,
116 },
117 }
118};
119
120static const USBDescDevice desc_device_full = {
121 .bcdUSB = 0x0200,
122 .bMaxPacketSize0 = 8,
123 .bNumConfigurations = 1,
124 .confs = (USBDescConfig[]) {
125 {
126 .bNumInterfaces = 1,
127 .bConfigurationValue = 1,
128 .iConfiguration = STR_CONFIG_FULL,
129 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
130 .nif = 1,
131 .ifs = &desc_iface_full,
132 },
133 },
134};
135
136static const USBDescIface desc_iface_high = {
137 .bInterfaceNumber = 0,
138 .bNumEndpoints = 2,
139 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
140 .bInterfaceSubClass = 0x06,
141 .bInterfaceProtocol = 0x50,
142 .eps = (USBDescEndpoint[]) {
143 {
144 .bEndpointAddress = USB_DIR_IN | 0x01,
145 .bmAttributes = USB_ENDPOINT_XFER_BULK,
146 .wMaxPacketSize = 512,
147 },{
148 .bEndpointAddress = USB_DIR_OUT | 0x02,
149 .bmAttributes = USB_ENDPOINT_XFER_BULK,
150 .wMaxPacketSize = 512,
151 },
152 }
153};
154
155static const USBDescDevice desc_device_high = {
156 .bcdUSB = 0x0200,
157 .bMaxPacketSize0 = 64,
158 .bNumConfigurations = 1,
159 .confs = (USBDescConfig[]) {
160 {
161 .bNumInterfaces = 1,
162 .bConfigurationValue = 1,
163 .iConfiguration = STR_CONFIG_HIGH,
164 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
165 .nif = 1,
166 .ifs = &desc_iface_high,
167 },
168 },
169};
170
171static const USBDescIface desc_iface_super = {
172 .bInterfaceNumber = 0,
173 .bNumEndpoints = 2,
174 .bInterfaceClass = USB_CLASS_MASS_STORAGE,
175 .bInterfaceSubClass = 0x06,
176 .bInterfaceProtocol = 0x50,
177 .eps = (USBDescEndpoint[]) {
178 {
179 .bEndpointAddress = USB_DIR_IN | 0x01,
180 .bmAttributes = USB_ENDPOINT_XFER_BULK,
181 .wMaxPacketSize = 1024,
182 .bMaxBurst = 15,
183 },{
184 .bEndpointAddress = USB_DIR_OUT | 0x02,
185 .bmAttributes = USB_ENDPOINT_XFER_BULK,
186 .wMaxPacketSize = 1024,
187 .bMaxBurst = 15,
188 },
189 }
190};
191
192static const USBDescDevice desc_device_super = {
193 .bcdUSB = 0x0300,
194 .bMaxPacketSize0 = 9,
195 .bNumConfigurations = 1,
196 .confs = (USBDescConfig[]) {
197 {
198 .bNumInterfaces = 1,
199 .bConfigurationValue = 1,
200 .iConfiguration = STR_CONFIG_SUPER,
201 .bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER,
202 .nif = 1,
203 .ifs = &desc_iface_super,
204 },
205 },
206};
207
208static const USBDesc desc = {
209 .id = {
210 .idVendor = 0x46f4,
211 .idProduct = 0x0001,
212 .bcdDevice = 0,
213 .iManufacturer = STR_MANUFACTURER,
214 .iProduct = STR_PRODUCT,
215 .iSerialNumber = STR_SERIALNUMBER,
216 },
217 .full = &desc_device_full,
218 .high = &desc_device_high,
219 .super = &desc_device_super,
220 .str = desc_strings,
221};
222
223static void usb_msd_copy_data(MSDState *s, USBPacket *p)
224{
225 uint32_t len;
226 len = p->iov.size - p->actual_length;
227 if (len > s->scsi_len)
228 len = s->scsi_len;
229 usb_packet_copy(p, scsi_req_get_buf(s->req) + s->scsi_off, len);
230 s->scsi_len -= len;
231 s->scsi_off += len;
232 s->data_len -= len;
233 if (s->scsi_len == 0 || s->data_len == 0) {
234 scsi_req_continue(s->req);
235 }
236}
237
238static void usb_msd_send_status(MSDState *s, USBPacket *p)
239{
240 int len;
241
242 DPRINTF("Command status %d tag 0x%x, len %zd\n",
243 s->csw.status, le32_to_cpu(s->csw.tag), p->iov.size);
244
245 assert(s->csw.sig == cpu_to_le32(0x53425355));
246 len = MIN(sizeof(s->csw), p->iov.size);
247 usb_packet_copy(p, &s->csw, len);
248 memset(&s->csw, 0, sizeof(s->csw));
249}
250
251static void usb_msd_packet_complete(MSDState *s)
252{
253 USBPacket *p = s->packet;
254
255
256
257
258 DPRINTF("Packet complete %p\n", p);
259 s->packet = NULL;
260 usb_packet_complete(&s->dev, p);
261}
262
263static void usb_msd_transfer_data(SCSIRequest *req, uint32_t len)
264{
265 MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
266 USBPacket *p = s->packet;
267
268 assert((s->mode == USB_MSDM_DATAOUT) == (req->cmd.mode == SCSI_XFER_TO_DEV));
269 s->scsi_len = len;
270 s->scsi_off = 0;
271 if (p) {
272 usb_msd_copy_data(s, p);
273 p = s->packet;
274 if (p && p->actual_length == p->iov.size) {
275 p->status = USB_RET_SUCCESS;
276 usb_msd_packet_complete(s);
277 }
278 }
279}
280
281static void usb_msd_command_complete(SCSIRequest *req, uint32_t status, size_t resid)
282{
283 MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
284 USBPacket *p = s->packet;
285
286 DPRINTF("Command complete %d tag 0x%x\n", status, req->tag);
287
288 s->csw.sig = cpu_to_le32(0x53425355);
289 s->csw.tag = cpu_to_le32(req->tag);
290 s->csw.residue = cpu_to_le32(s->data_len);
291 s->csw.status = status != 0;
292
293 if (s->packet) {
294 if (s->data_len == 0 && s->mode == USB_MSDM_DATAOUT) {
295
296
297 usb_msd_send_status(s, p);
298 s->mode = USB_MSDM_CBW;
299 } else if (s->mode == USB_MSDM_CSW) {
300 usb_msd_send_status(s, p);
301 s->mode = USB_MSDM_CBW;
302 } else {
303 if (s->data_len) {
304 int len = (p->iov.size - p->actual_length);
305 usb_packet_skip(p, len);
306 s->data_len -= len;
307 }
308 if (s->data_len == 0) {
309 s->mode = USB_MSDM_CSW;
310 }
311 }
312 p->status = USB_RET_SUCCESS;
313 usb_msd_packet_complete(s);
314 } else if (s->data_len == 0) {
315 s->mode = USB_MSDM_CSW;
316 }
317 scsi_req_unref(req);
318 s->req = NULL;
319}
320
321static void usb_msd_request_cancelled(SCSIRequest *req)
322{
323 MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
324
325 if (req == s->req) {
326 scsi_req_unref(s->req);
327 s->req = NULL;
328 s->scsi_len = 0;
329 }
330}
331
332static void usb_msd_handle_reset(USBDevice *dev)
333{
334 MSDState *s = (MSDState *)dev;
335
336 DPRINTF("Reset\n");
337 if (s->req) {
338 scsi_req_cancel(s->req);
339 }
340 assert(s->req == NULL);
341
342 if (s->packet) {
343 s->packet->status = USB_RET_STALL;
344 usb_msd_packet_complete(s);
345 }
346
347 s->mode = USB_MSDM_CBW;
348}
349
350static void usb_msd_handle_control(USBDevice *dev, USBPacket *p,
351 int request, int value, int index, int length, uint8_t *data)
352{
353 MSDState *s = (MSDState *)dev;
354 SCSIDevice *scsi_dev;
355 int ret, maxlun;
356
357 ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
358 if (ret >= 0) {
359 return;
360 }
361
362 switch (request) {
363 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
364 break;
365
366 case ClassInterfaceOutRequest | MassStorageReset:
367
368 s->mode = USB_MSDM_CBW;
369 break;
370 case ClassInterfaceRequest | GetMaxLun:
371 maxlun = 0;
372 for (;;) {
373 scsi_dev = scsi_device_find(&s->bus, 0, 0, maxlun+1);
374 if (scsi_dev == NULL) {
375 break;
376 }
377 if (scsi_dev->lun != maxlun+1) {
378 break;
379 }
380 maxlun++;
381 }
382 DPRINTF("MaxLun %d\n", maxlun);
383 data[0] = maxlun;
384 p->actual_length = 1;
385 break;
386 default:
387 p->status = USB_RET_STALL;
388 break;
389 }
390}
391
392static void usb_msd_cancel_io(USBDevice *dev, USBPacket *p)
393{
394 MSDState *s = USB_STORAGE_DEV(dev);
395
396 assert(s->packet == p);
397 s->packet = NULL;
398
399 if (s->req) {
400 scsi_req_cancel(s->req);
401 }
402}
403
404static void usb_msd_handle_data(USBDevice *dev, USBPacket *p)
405{
406 MSDState *s = (MSDState *)dev;
407 uint32_t tag;
408 struct usb_msd_cbw cbw;
409 uint8_t devep = p->ep->nr;
410 SCSIDevice *scsi_dev;
411 uint32_t len;
412
413 switch (p->pid) {
414 case USB_TOKEN_OUT:
415 if (devep != 2)
416 goto fail;
417
418 switch (s->mode) {
419 case USB_MSDM_CBW:
420 if (p->iov.size != 31) {
421 error_report("usb-msd: Bad CBW size");
422 goto fail;
423 }
424 usb_packet_copy(p, &cbw, 31);
425 if (le32_to_cpu(cbw.sig) != 0x43425355) {
426 error_report("usb-msd: Bad signature %08x",
427 le32_to_cpu(cbw.sig));
428 goto fail;
429 }
430 DPRINTF("Command on LUN %d\n", cbw.lun);
431 scsi_dev = scsi_device_find(&s->bus, 0, 0, cbw.lun);
432 if (scsi_dev == NULL) {
433 error_report("usb-msd: Bad LUN %d", cbw.lun);
434 goto fail;
435 }
436 tag = le32_to_cpu(cbw.tag);
437 s->data_len = le32_to_cpu(cbw.data_len);
438 if (s->data_len == 0) {
439 s->mode = USB_MSDM_CSW;
440 } else if (cbw.flags & 0x80) {
441 s->mode = USB_MSDM_DATAIN;
442 } else {
443 s->mode = USB_MSDM_DATAOUT;
444 }
445 DPRINTF("Command tag 0x%x flags %08x len %d data %d\n",
446 tag, cbw.flags, cbw.cmd_len, s->data_len);
447 assert(le32_to_cpu(s->csw.residue) == 0);
448 s->scsi_len = 0;
449 s->req = scsi_req_new(scsi_dev, tag, cbw.lun, cbw.cmd, NULL);
450#ifdef DEBUG_MSD
451 scsi_req_print(s->req);
452#endif
453 len = scsi_req_enqueue(s->req);
454 if (len) {
455 scsi_req_continue(s->req);
456 }
457 break;
458
459 case USB_MSDM_DATAOUT:
460 DPRINTF("Data out %zd/%d\n", p->iov.size, s->data_len);
461 if (p->iov.size > s->data_len) {
462 goto fail;
463 }
464
465 if (s->scsi_len) {
466 usb_msd_copy_data(s, p);
467 }
468 if (le32_to_cpu(s->csw.residue)) {
469 int len = p->iov.size - p->actual_length;
470 if (len) {
471 usb_packet_skip(p, len);
472 s->data_len -= len;
473 if (s->data_len == 0) {
474 s->mode = USB_MSDM_CSW;
475 }
476 }
477 }
478 if (p->actual_length < p->iov.size) {
479 DPRINTF("Deferring packet %p [wait data-out]\n", p);
480 s->packet = p;
481 p->status = USB_RET_ASYNC;
482 }
483 break;
484
485 default:
486 DPRINTF("Unexpected write (len %zd)\n", p->iov.size);
487 goto fail;
488 }
489 break;
490
491 case USB_TOKEN_IN:
492 if (devep != 1)
493 goto fail;
494
495 switch (s->mode) {
496 case USB_MSDM_DATAOUT:
497 if (s->data_len != 0 || p->iov.size < 13) {
498 goto fail;
499 }
500
501 s->packet = p;
502 p->status = USB_RET_ASYNC;
503 break;
504
505 case USB_MSDM_CSW:
506 if (p->iov.size < 13) {
507 goto fail;
508 }
509
510 if (s->req) {
511
512 DPRINTF("Deferring packet %p [wait status]\n", p);
513 s->packet = p;
514 p->status = USB_RET_ASYNC;
515 } else {
516 usb_msd_send_status(s, p);
517 s->mode = USB_MSDM_CBW;
518 }
519 break;
520
521 case USB_MSDM_DATAIN:
522 DPRINTF("Data in %zd/%d, scsi_len %d\n",
523 p->iov.size, s->data_len, s->scsi_len);
524 if (s->scsi_len) {
525 usb_msd_copy_data(s, p);
526 }
527 if (le32_to_cpu(s->csw.residue)) {
528 int len = p->iov.size - p->actual_length;
529 if (len) {
530 usb_packet_skip(p, len);
531 s->data_len -= len;
532 if (s->data_len == 0) {
533 s->mode = USB_MSDM_CSW;
534 }
535 }
536 }
537 if (p->actual_length < p->iov.size) {
538 DPRINTF("Deferring packet %p [wait data-in]\n", p);
539 s->packet = p;
540 p->status = USB_RET_ASYNC;
541 }
542 break;
543
544 default:
545 DPRINTF("Unexpected read (len %zd)\n", p->iov.size);
546 goto fail;
547 }
548 break;
549
550 default:
551 DPRINTF("Bad token\n");
552 fail:
553 p->status = USB_RET_STALL;
554 break;
555 }
556}
557
558static void *usb_msd_load_request(QEMUFile *f, SCSIRequest *req)
559{
560 MSDState *s = DO_UPCAST(MSDState, dev.qdev, req->bus->qbus.parent);
561
562
563 assert(s->req == NULL);
564 scsi_req_ref(req);
565 s->req = req;
566 return NULL;
567}
568
569static const struct SCSIBusInfo usb_msd_scsi_info_storage = {
570 .tcq = false,
571 .max_target = 0,
572 .max_lun = 0,
573
574 .transfer_data = usb_msd_transfer_data,
575 .complete = usb_msd_command_complete,
576 .cancel = usb_msd_request_cancelled,
577 .load_request = usb_msd_load_request,
578};
579
580static const struct SCSIBusInfo usb_msd_scsi_info_bot = {
581 .tcq = false,
582 .max_target = 0,
583 .max_lun = 15,
584
585 .transfer_data = usb_msd_transfer_data,
586 .complete = usb_msd_command_complete,
587 .cancel = usb_msd_request_cancelled,
588 .load_request = usb_msd_load_request,
589};
590
591static void usb_msd_storage_realize(USBDevice *dev, Error **errp)
592{
593 MSDState *s = USB_STORAGE_DEV(dev);
594 BlockBackend *blk = s->conf.blk;
595 SCSIDevice *scsi_dev;
596
597 if (!blk) {
598 error_setg(errp, "drive property not set");
599 return;
600 }
601
602 blkconf_blocksizes(&s->conf);
603 if (!blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true,
604 errp)) {
605 return;
606 }
607
608
609
610
611
612
613
614
615
616
617
618 blk_ref(blk);
619 blk_detach_dev(blk, &s->dev.qdev);
620 s->conf.blk = NULL;
621
622 usb_desc_create_serial(dev);
623 usb_desc_init(dev);
624 scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev),
625 &usb_msd_scsi_info_storage, NULL);
626 scsi_dev = scsi_bus_legacy_add_drive(&s->bus, blk, 0, !!s->removable,
627 s->conf.bootindex, s->conf.share_rw,
628 s->conf.rerror, s->conf.werror,
629 dev->serial,
630 errp);
631 blk_unref(blk);
632 if (!scsi_dev) {
633 return;
634 }
635 usb_msd_handle_reset(dev);
636 s->scsi_dev = scsi_dev;
637}
638
639static void usb_msd_bot_realize(USBDevice *dev, Error **errp)
640{
641 MSDState *s = USB_STORAGE_DEV(dev);
642 DeviceState *d = DEVICE(dev);
643
644 usb_desc_create_serial(dev);
645 usb_desc_init(dev);
646 if (d->hotplugged) {
647 s->dev.auto_attach = 0;
648 }
649
650 scsi_bus_new(&s->bus, sizeof(s->bus), DEVICE(dev),
651 &usb_msd_scsi_info_bot, NULL);
652 usb_msd_handle_reset(dev);
653}
654
655static const VMStateDescription vmstate_usb_msd = {
656 .name = "usb-storage",
657 .version_id = 1,
658 .minimum_version_id = 1,
659 .fields = (VMStateField[]) {
660 VMSTATE_USB_DEVICE(dev, MSDState),
661 VMSTATE_UINT32(mode, MSDState),
662 VMSTATE_UINT32(scsi_len, MSDState),
663 VMSTATE_UINT32(scsi_off, MSDState),
664 VMSTATE_UINT32(data_len, MSDState),
665 VMSTATE_UINT32(csw.sig, MSDState),
666 VMSTATE_UINT32(csw.tag, MSDState),
667 VMSTATE_UINT32(csw.residue, MSDState),
668 VMSTATE_UINT8(csw.status, MSDState),
669 VMSTATE_END_OF_LIST()
670 }
671};
672
673static Property msd_properties[] = {
674 DEFINE_BLOCK_PROPERTIES(MSDState, conf),
675 DEFINE_BLOCK_ERROR_PROPERTIES(MSDState, conf),
676 DEFINE_PROP_BIT("removable", MSDState, removable, 0, false),
677 DEFINE_PROP_END_OF_LIST(),
678};
679
680static void usb_msd_class_initfn_common(ObjectClass *klass, void *data)
681{
682 DeviceClass *dc = DEVICE_CLASS(klass);
683 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
684
685 uc->product_desc = "QEMU USB MSD";
686 uc->usb_desc = &desc;
687 uc->cancel_packet = usb_msd_cancel_io;
688 uc->handle_attach = usb_desc_attach;
689 uc->handle_reset = usb_msd_handle_reset;
690 uc->handle_control = usb_msd_handle_control;
691 uc->handle_data = usb_msd_handle_data;
692 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
693 dc->fw_name = "storage";
694 dc->vmsd = &vmstate_usb_msd;
695}
696
697static void usb_msd_class_storage_initfn(ObjectClass *klass, void *data)
698{
699 DeviceClass *dc = DEVICE_CLASS(klass);
700 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
701
702 uc->realize = usb_msd_storage_realize;
703 dc->props = msd_properties;
704}
705
706static void usb_msd_get_bootindex(Object *obj, Visitor *v, const char *name,
707 void *opaque, Error **errp)
708{
709 USBDevice *dev = USB_DEVICE(obj);
710 MSDState *s = USB_STORAGE_DEV(dev);
711
712 visit_type_int32(v, name, &s->conf.bootindex, errp);
713}
714
715static void usb_msd_set_bootindex(Object *obj, Visitor *v, const char *name,
716 void *opaque, Error **errp)
717{
718 USBDevice *dev = USB_DEVICE(obj);
719 MSDState *s = USB_STORAGE_DEV(dev);
720 int32_t boot_index;
721 Error *local_err = NULL;
722
723 visit_type_int32(v, name, &boot_index, &local_err);
724 if (local_err) {
725 goto out;
726 }
727
728 check_boot_index(boot_index, &local_err);
729 if (local_err) {
730 goto out;
731 }
732
733 s->conf.bootindex = boot_index;
734
735 if (s->scsi_dev) {
736 object_property_set_int(OBJECT(s->scsi_dev), boot_index, "bootindex",
737 &error_abort);
738 }
739
740out:
741 error_propagate(errp, local_err);
742}
743
744static const TypeInfo usb_storage_dev_type_info = {
745 .name = TYPE_USB_STORAGE,
746 .parent = TYPE_USB_DEVICE,
747 .instance_size = sizeof(MSDState),
748 .abstract = true,
749 .class_init = usb_msd_class_initfn_common,
750};
751
752static void usb_msd_instance_init(Object *obj)
753{
754 object_property_add(obj, "bootindex", "int32",
755 usb_msd_get_bootindex,
756 usb_msd_set_bootindex, NULL, NULL, NULL);
757 object_property_set_int(obj, -1, "bootindex", NULL);
758}
759
760static void usb_msd_class_bot_initfn(ObjectClass *klass, void *data)
761{
762 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
763
764 uc->realize = usb_msd_bot_realize;
765 uc->attached_settable = true;
766}
767
768static const TypeInfo msd_info = {
769 .name = "usb-storage",
770 .parent = TYPE_USB_STORAGE,
771 .class_init = usb_msd_class_storage_initfn,
772 .instance_init = usb_msd_instance_init,
773};
774
775static const TypeInfo bot_info = {
776 .name = "usb-bot",
777 .parent = TYPE_USB_STORAGE,
778 .class_init = usb_msd_class_bot_initfn,
779};
780
781static void usb_msd_register_types(void)
782{
783 type_register_static(&usb_storage_dev_type_info);
784 type_register_static(&msd_info);
785 type_register_static(&bot_info);
786}
787
788type_init(usb_msd_register_types)
789
