2 * USB Mass Storage Device emulation
4 * Copyright (c) 2006 CodeSourcery.
5 * Written by Paul Brook
7 * This code is licensed under the LGPL.
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"
17 #include "hw/usb/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 "sysemu/blockdev.h"
24 #include "qapi/visitor.h"
29 #define DPRINTF(fmt, ...) \
30 do { printf("usb-msd: " fmt , ## __VA_ARGS__); } while (0)
32 #define DPRINTF(fmt, ...) do {} while(0)
36 #define MassStorageReset 0xff
37 #define GetMaxLun 0xfe
40 USB_MSDM_CBW
, /* Command Block. */
41 USB_MSDM_DATAOUT
, /* Transfer data to device. */
42 USB_MSDM_DATAIN
, /* Transfer data from device. */
43 USB_MSDM_CSW
/* Command Status. */
59 struct usb_msd_csw csw
;
62 /* For async completion. */
64 /* usb-storage only */
70 #define TYPE_USB_STORAGE "usb-storage-dev"
71 #define USB_STORAGE_DEV(obj) OBJECT_CHECK(MSDState, (obj), TYPE_USB_STORAGE)
92 static 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)",
101 static const USBDescIface desc_iface_full
= {
102 .bInterfaceNumber
= 0,
104 .bInterfaceClass
= USB_CLASS_MASS_STORAGE
,
105 .bInterfaceSubClass
= 0x06, /* SCSI */
106 .bInterfaceProtocol
= 0x50, /* Bulk */
107 .eps
= (USBDescEndpoint
[]) {
109 .bEndpointAddress
= USB_DIR_IN
| 0x01,
110 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
111 .wMaxPacketSize
= 64,
113 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
114 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
115 .wMaxPacketSize
= 64,
120 static const USBDescDevice desc_device_full
= {
122 .bMaxPacketSize0
= 8,
123 .bNumConfigurations
= 1,
124 .confs
= (USBDescConfig
[]) {
127 .bConfigurationValue
= 1,
128 .iConfiguration
= STR_CONFIG_FULL
,
129 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
131 .ifs
= &desc_iface_full
,
136 static const USBDescIface desc_iface_high
= {
137 .bInterfaceNumber
= 0,
139 .bInterfaceClass
= USB_CLASS_MASS_STORAGE
,
140 .bInterfaceSubClass
= 0x06, /* SCSI */
141 .bInterfaceProtocol
= 0x50, /* Bulk */
142 .eps
= (USBDescEndpoint
[]) {
144 .bEndpointAddress
= USB_DIR_IN
| 0x01,
145 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
146 .wMaxPacketSize
= 512,
148 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
149 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
150 .wMaxPacketSize
= 512,
155 static const USBDescDevice desc_device_high
= {
157 .bMaxPacketSize0
= 64,
158 .bNumConfigurations
= 1,
159 .confs
= (USBDescConfig
[]) {
162 .bConfigurationValue
= 1,
163 .iConfiguration
= STR_CONFIG_HIGH
,
164 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
166 .ifs
= &desc_iface_high
,
171 static const USBDescIface desc_iface_super
= {
172 .bInterfaceNumber
= 0,
174 .bInterfaceClass
= USB_CLASS_MASS_STORAGE
,
175 .bInterfaceSubClass
= 0x06, /* SCSI */
176 .bInterfaceProtocol
= 0x50, /* Bulk */
177 .eps
= (USBDescEndpoint
[]) {
179 .bEndpointAddress
= USB_DIR_IN
| 0x01,
180 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
181 .wMaxPacketSize
= 1024,
184 .bEndpointAddress
= USB_DIR_OUT
| 0x02,
185 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
186 .wMaxPacketSize
= 1024,
192 static const USBDescDevice desc_device_super
= {
194 .bMaxPacketSize0
= 9,
195 .bNumConfigurations
= 1,
196 .confs
= (USBDescConfig
[]) {
199 .bConfigurationValue
= 1,
200 .iConfiguration
= STR_CONFIG_SUPER
,
201 .bmAttributes
= USB_CFG_ATT_ONE
| USB_CFG_ATT_SELFPOWER
,
203 .ifs
= &desc_iface_super
,
208 static const USBDesc desc
= {
210 .idVendor
= 0x46f4, /* CRC16() of "QEMU" */
213 .iManufacturer
= STR_MANUFACTURER
,
214 .iProduct
= STR_PRODUCT
,
215 .iSerialNumber
= STR_SERIALNUMBER
,
217 .full
= &desc_device_full
,
218 .high
= &desc_device_high
,
219 .super
= &desc_device_super
,
223 static void usb_msd_copy_data(MSDState
*s
, USBPacket
*p
)
226 len
= p
->iov
.size
- p
->actual_length
;
227 if (len
> s
->scsi_len
)
229 usb_packet_copy(p
, scsi_req_get_buf(s
->req
) + s
->scsi_off
, len
);
233 if (s
->scsi_len
== 0 || s
->data_len
== 0) {
234 scsi_req_continue(s
->req
);
238 static void usb_msd_send_status(MSDState
*s
, USBPacket
*p
)
242 DPRINTF("Command status %d tag 0x%x, len %zd\n",
243 s
->csw
.status
, le32_to_cpu(s
->csw
.tag
), p
->iov
.size
);
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
));
251 static void usb_msd_packet_complete(MSDState
*s
)
253 USBPacket
*p
= s
->packet
;
255 /* Set s->packet to NULL before calling usb_packet_complete
256 because another request may be issued before
257 usb_packet_complete returns. */
258 DPRINTF("Packet complete %p\n", p
);
260 usb_packet_complete(&s
->dev
, p
);
263 static void usb_msd_transfer_data(SCSIRequest
*req
, uint32_t len
)
265 MSDState
*s
= DO_UPCAST(MSDState
, dev
.qdev
, req
->bus
->qbus
.parent
);
266 USBPacket
*p
= s
->packet
;
268 assert((s
->mode
== USB_MSDM_DATAOUT
) == (req
->cmd
.mode
== SCSI_XFER_TO_DEV
));
272 usb_msd_copy_data(s
, p
);
274 if (p
&& p
->actual_length
== p
->iov
.size
) {
275 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
276 usb_msd_packet_complete(s
);
281 static void usb_msd_command_complete(SCSIRequest
*req
, uint32_t status
, size_t resid
)
283 MSDState
*s
= DO_UPCAST(MSDState
, dev
.qdev
, req
->bus
->qbus
.parent
);
284 USBPacket
*p
= s
->packet
;
286 DPRINTF("Command complete %d tag 0x%x\n", status
, req
->tag
);
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;
294 if (s
->data_len
== 0 && s
->mode
== USB_MSDM_DATAOUT
) {
295 /* A deferred packet with no write data remaining must be
296 the status read packet. */
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
;
304 int len
= (p
->iov
.size
- p
->actual_length
);
305 usb_packet_skip(p
, len
);
308 if (s
->data_len
== 0) {
309 s
->mode
= USB_MSDM_CSW
;
312 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
313 usb_msd_packet_complete(s
);
314 } else if (s
->data_len
== 0) {
315 s
->mode
= USB_MSDM_CSW
;
321 static void usb_msd_request_cancelled(SCSIRequest
*req
)
323 MSDState
*s
= DO_UPCAST(MSDState
, dev
.qdev
, req
->bus
->qbus
.parent
);
326 scsi_req_unref(s
->req
);
332 static void usb_msd_handle_reset(USBDevice
*dev
)
334 MSDState
*s
= (MSDState
*)dev
;
338 scsi_req_cancel(s
->req
);
340 assert(s
->req
== NULL
);
343 s
->packet
->status
= USB_RET_STALL
;
344 usb_msd_packet_complete(s
);
347 s
->mode
= USB_MSDM_CBW
;
350 static void usb_msd_handle_control(USBDevice
*dev
, USBPacket
*p
,
351 int request
, int value
, int index
, int length
, uint8_t *data
)
353 MSDState
*s
= (MSDState
*)dev
;
354 SCSIDevice
*scsi_dev
;
357 ret
= usb_desc_handle_control(dev
, p
, request
, value
, index
, length
, data
);
363 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
365 /* Class specific requests. */
366 case ClassInterfaceOutRequest
| MassStorageReset
:
367 /* Reset state ready for the next CBW. */
368 s
->mode
= USB_MSDM_CBW
;
370 case ClassInterfaceRequest
| GetMaxLun
:
373 scsi_dev
= scsi_device_find(&s
->bus
, 0, 0, maxlun
+1);
374 if (scsi_dev
== NULL
) {
377 if (scsi_dev
->lun
!= maxlun
+1) {
382 DPRINTF("MaxLun %d\n", maxlun
);
384 p
->actual_length
= 1;
387 p
->status
= USB_RET_STALL
;
392 static void usb_msd_cancel_io(USBDevice
*dev
, USBPacket
*p
)
394 MSDState
*s
= USB_STORAGE_DEV(dev
);
396 assert(s
->packet
== p
);
400 scsi_req_cancel(s
->req
);
404 static void usb_msd_handle_data(USBDevice
*dev
, USBPacket
*p
)
406 MSDState
*s
= (MSDState
*)dev
;
408 struct usb_msd_cbw cbw
;
409 uint8_t devep
= p
->ep
->nr
;
410 SCSIDevice
*scsi_dev
;
420 if (p
->iov
.size
!= 31) {
421 error_report("usb-msd: Bad CBW size");
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
));
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
);
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
;
443 s
->mode
= USB_MSDM_DATAOUT
;
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);
449 s
->req
= scsi_req_new(scsi_dev
, tag
, cbw
.lun
, cbw
.cmd
, NULL
);
451 scsi_req_print(s
->req
);
453 len
= scsi_req_enqueue(s
->req
);
455 scsi_req_continue(s
->req
);
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
) {
466 usb_msd_copy_data(s
, p
);
468 if (le32_to_cpu(s
->csw
.residue
)) {
469 int len
= p
->iov
.size
- p
->actual_length
;
471 usb_packet_skip(p
, len
);
473 if (s
->data_len
== 0) {
474 s
->mode
= USB_MSDM_CSW
;
478 if (p
->actual_length
< p
->iov
.size
) {
479 DPRINTF("Deferring packet %p [wait data-out]\n", p
);
481 p
->status
= USB_RET_ASYNC
;
486 DPRINTF("Unexpected write (len %zd)\n", p
->iov
.size
);
496 case USB_MSDM_DATAOUT
:
497 if (s
->data_len
!= 0 || p
->iov
.size
< 13) {
500 /* Waiting for SCSI write to complete. */
502 p
->status
= USB_RET_ASYNC
;
506 if (p
->iov
.size
< 13) {
511 /* still in flight */
512 DPRINTF("Deferring packet %p [wait status]\n", p
);
514 p
->status
= USB_RET_ASYNC
;
516 usb_msd_send_status(s
, p
);
517 s
->mode
= USB_MSDM_CBW
;
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
);
525 usb_msd_copy_data(s
, p
);
527 if (le32_to_cpu(s
->csw
.residue
)) {
528 int len
= p
->iov
.size
- p
->actual_length
;
530 usb_packet_skip(p
, len
);
532 if (s
->data_len
== 0) {
533 s
->mode
= USB_MSDM_CSW
;
537 if (p
->actual_length
< p
->iov
.size
) {
538 DPRINTF("Deferring packet %p [wait data-in]\n", p
);
540 p
->status
= USB_RET_ASYNC
;
545 DPRINTF("Unexpected read (len %zd)\n", p
->iov
.size
);
551 DPRINTF("Bad token\n");
553 p
->status
= USB_RET_STALL
;
558 static void usb_msd_password_cb(void *opaque
, int err
)
560 MSDState
*s
= opaque
;
561 Error
*local_err
= NULL
;
564 usb_device_attach(&s
->dev
, &local_err
);
568 error_report_err(local_err
);
569 qdev_unplug(&s
->dev
.qdev
, NULL
);
573 static void *usb_msd_load_request(QEMUFile
*f
, SCSIRequest
*req
)
575 MSDState
*s
= DO_UPCAST(MSDState
, dev
.qdev
, req
->bus
->qbus
.parent
);
577 /* nothing to load, just store req in our state struct */
578 assert(s
->req
== NULL
);
584 static const struct SCSIBusInfo usb_msd_scsi_info_storage
= {
589 .transfer_data
= usb_msd_transfer_data
,
590 .complete
= usb_msd_command_complete
,
591 .cancel
= usb_msd_request_cancelled
,
592 .load_request
= usb_msd_load_request
,
595 static const struct SCSIBusInfo usb_msd_scsi_info_bot
= {
600 .transfer_data
= usb_msd_transfer_data
,
601 .complete
= usb_msd_command_complete
,
602 .cancel
= usb_msd_request_cancelled
,
603 .load_request
= usb_msd_load_request
,
606 static void usb_msd_realize_storage(USBDevice
*dev
, Error
**errp
)
608 MSDState
*s
= USB_STORAGE_DEV(dev
);
609 BlockBackend
*blk
= s
->conf
.blk
;
610 SCSIDevice
*scsi_dev
;
614 error_setg(errp
, "drive property not set");
619 bdrv_add_key(blk_bs(blk
), NULL
, &err
);
621 if (monitor_cur_is_qmp()) {
622 error_propagate(errp
, err
);
628 monitor_read_bdrv_key_start(cur_mon
, blk_bs(blk
),
629 usb_msd_password_cb
, s
);
630 s
->dev
.auto_attach
= 0;
637 blkconf_serial(&s
->conf
, &dev
->serial
);
638 blkconf_blocksizes(&s
->conf
);
641 * Hack alert: this pretends to be a block device, but it's really
642 * a SCSI bus that can serve only a single device, which it
643 * creates automatically. But first it needs to detach from its
644 * blockdev, or else scsi_bus_legacy_add_drive() dies when it
647 * The hack is probably a bad idea.
649 blk_detach_dev(blk
, &s
->dev
.qdev
);
652 usb_desc_create_serial(dev
);
654 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), DEVICE(dev
),
655 &usb_msd_scsi_info_storage
, NULL
);
656 scsi_dev
= scsi_bus_legacy_add_drive(&s
->bus
, blk
, 0, !!s
->removable
,
657 s
->conf
.bootindex
, dev
->serial
,
660 error_propagate(errp
, err
);
663 usb_msd_handle_reset(dev
);
664 s
->scsi_dev
= scsi_dev
;
667 static void usb_msd_realize_bot(USBDevice
*dev
, Error
**errp
)
669 MSDState
*s
= USB_STORAGE_DEV(dev
);
671 usb_desc_create_serial(dev
);
673 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), DEVICE(dev
),
674 &usb_msd_scsi_info_bot
, NULL
);
675 usb_msd_handle_reset(dev
);
678 static USBDevice
*usb_msd_init(USBBus
*bus
, const char *filename
)
689 /* parse -usbdevice disk: syntax into drive opts */
691 snprintf(id
, sizeof(id
), "usb%d", nr
++);
692 opts
= qemu_opts_create(qemu_find_opts("drive"), id
, 1, NULL
);
695 p1
= strchr(filename
, ':');
699 if (strstart(filename
, "format=", &p2
)) {
700 int len
= MIN(p1
- p2
, sizeof(fmt
));
701 pstrcpy(fmt
, len
, p2
);
702 qemu_opt_set(opts
, "format", fmt
, &error_abort
);
703 } else if (*filename
!= ':') {
704 error_report("unrecognized USB mass-storage option %s", filename
);
710 error_report("block device specification needed");
713 qemu_opt_set(opts
, "file", filename
, &error_abort
);
714 qemu_opt_set(opts
, "if", "none", &error_abort
);
716 /* create host drive */
717 dinfo
= drive_new(opts
, 0);
723 /* create guest device */
724 dev
= usb_create(bus
, "usb-storage");
725 qdev_prop_set_drive(&dev
->qdev
, "drive", blk_by_legacy_dinfo(dinfo
),
728 error_report_err(err
);
729 object_unparent(OBJECT(dev
));
735 static const VMStateDescription vmstate_usb_msd
= {
736 .name
= "usb-storage",
738 .minimum_version_id
= 1,
739 .fields
= (VMStateField
[]) {
740 VMSTATE_USB_DEVICE(dev
, MSDState
),
741 VMSTATE_UINT32(mode
, MSDState
),
742 VMSTATE_UINT32(scsi_len
, MSDState
),
743 VMSTATE_UINT32(scsi_off
, MSDState
),
744 VMSTATE_UINT32(data_len
, MSDState
),
745 VMSTATE_UINT32(csw
.sig
, MSDState
),
746 VMSTATE_UINT32(csw
.tag
, MSDState
),
747 VMSTATE_UINT32(csw
.residue
, MSDState
),
748 VMSTATE_UINT8(csw
.status
, MSDState
),
749 VMSTATE_END_OF_LIST()
753 static Property msd_properties
[] = {
754 DEFINE_BLOCK_PROPERTIES(MSDState
, conf
),
755 DEFINE_PROP_BIT("removable", MSDState
, removable
, 0, false),
756 DEFINE_PROP_END_OF_LIST(),
759 static void usb_msd_class_initfn_common(ObjectClass
*klass
, void *data
)
761 DeviceClass
*dc
= DEVICE_CLASS(klass
);
762 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
764 uc
->product_desc
= "QEMU USB MSD";
765 uc
->usb_desc
= &desc
;
766 uc
->cancel_packet
= usb_msd_cancel_io
;
767 uc
->handle_attach
= usb_desc_attach
;
768 uc
->handle_reset
= usb_msd_handle_reset
;
769 uc
->handle_control
= usb_msd_handle_control
;
770 uc
->handle_data
= usb_msd_handle_data
;
771 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
772 dc
->fw_name
= "storage";
773 dc
->vmsd
= &vmstate_usb_msd
;
776 static void usb_msd_class_initfn_storage(ObjectClass
*klass
, void *data
)
778 DeviceClass
*dc
= DEVICE_CLASS(klass
);
779 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
781 uc
->realize
= usb_msd_realize_storage
;
782 dc
->props
= msd_properties
;
785 static void usb_msd_get_bootindex(Object
*obj
, Visitor
*v
, const char *name
,
786 void *opaque
, Error
**errp
)
788 USBDevice
*dev
= USB_DEVICE(obj
);
789 MSDState
*s
= USB_STORAGE_DEV(dev
);
791 visit_type_int32(v
, name
, &s
->conf
.bootindex
, errp
);
794 static void usb_msd_set_bootindex(Object
*obj
, Visitor
*v
, const char *name
,
795 void *opaque
, Error
**errp
)
797 USBDevice
*dev
= USB_DEVICE(obj
);
798 MSDState
*s
= USB_STORAGE_DEV(dev
);
800 Error
*local_err
= NULL
;
802 visit_type_int32(v
, name
, &boot_index
, &local_err
);
806 /* check whether bootindex is present in fw_boot_order list */
807 check_boot_index(boot_index
, &local_err
);
811 /* change bootindex to a new one */
812 s
->conf
.bootindex
= boot_index
;
815 object_property_set_int(OBJECT(s
->scsi_dev
), boot_index
, "bootindex",
821 error_propagate(errp
, local_err
);
825 static const TypeInfo usb_storage_dev_type_info
= {
826 .name
= TYPE_USB_STORAGE
,
827 .parent
= TYPE_USB_DEVICE
,
828 .instance_size
= sizeof(MSDState
),
830 .class_init
= usb_msd_class_initfn_common
,
833 static void usb_msd_instance_init(Object
*obj
)
835 object_property_add(obj
, "bootindex", "int32",
836 usb_msd_get_bootindex
,
837 usb_msd_set_bootindex
, NULL
, NULL
, NULL
);
838 object_property_set_int(obj
, -1, "bootindex", NULL
);
841 static void usb_msd_class_initfn_bot(ObjectClass
*klass
, void *data
)
843 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
844 DeviceClass
*dc
= DEVICE_CLASS(klass
);
846 uc
->realize
= usb_msd_realize_bot
;
847 dc
->hotpluggable
= false;
850 static const TypeInfo msd_info
= {
851 .name
= "usb-storage",
852 .parent
= TYPE_USB_STORAGE
,
853 .class_init
= usb_msd_class_initfn_storage
,
854 .instance_init
= usb_msd_instance_init
,
857 static const TypeInfo bot_info
= {
859 .parent
= TYPE_USB_STORAGE
,
860 .class_init
= usb_msd_class_initfn_bot
,
863 static void usb_msd_register_types(void)
865 type_register_static(&usb_storage_dev_type_info
);
866 type_register_static(&msd_info
);
867 type_register_static(&bot_info
);
868 usb_legacy_register("usb-storage", "disk", usb_msd_init
);
871 type_init(usb_msd_register_types
)