1#include "qemu/osdep.h"
2#include "hw/qdev-properties.h"
3#include "hw/usb.h"
4#include "qapi/error.h"
5#include "qapi/qapi-commands-machine.h"
6#include "qapi/type-helpers.h"
7#include "qemu/error-report.h"
8#include "qemu/module.h"
9#include "sysemu/sysemu.h"
10#include "migration/vmstate.h"
11#include "monitor/monitor.h"
12#include "trace.h"
13#include "qemu/cutils.h"
14
15static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
16
17static char *usb_get_dev_path(DeviceState *dev);
18static char *usb_get_fw_dev_path(DeviceState *qdev);
19static void usb_qdev_unrealize(DeviceState *qdev);
20
21static Property usb_props[] = {
22 DEFINE_PROP_STRING("port", USBDevice, port_path),
23 DEFINE_PROP_STRING("serial", USBDevice, serial),
24 DEFINE_PROP_BIT("msos-desc", USBDevice, flags,
25 USB_DEV_FLAG_MSOS_DESC_ENABLE, true),
26 DEFINE_PROP_STRING("pcap", USBDevice, pcap_filename),
27 DEFINE_PROP_END_OF_LIST()
28};
29
30static void usb_bus_class_init(ObjectClass *klass, void *data)
31{
32 BusClass *k = BUS_CLASS(klass);
33 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
34
35 k->print_dev = usb_bus_dev_print;
36 k->get_dev_path = usb_get_dev_path;
37 k->get_fw_dev_path = usb_get_fw_dev_path;
38 hc->unplug = qdev_simple_device_unplug_cb;
39}
40
41static const TypeInfo usb_bus_info = {
42 .name = TYPE_USB_BUS,
43 .parent = TYPE_BUS,
44 .instance_size = sizeof(USBBus),
45 .class_init = usb_bus_class_init,
46 .interfaces = (InterfaceInfo[]) {
47 { TYPE_HOTPLUG_HANDLER },
48 { }
49 }
50};
51
52static int next_usb_bus = 0;
53static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
54
55static int usb_device_post_load(void *opaque, int version_id)
56{
57 USBDevice *dev = opaque;
58
59 if (dev->state == USB_STATE_NOTATTACHED) {
60 dev->attached = false;
61 } else {
62 dev->attached = true;
63 }
64 return 0;
65}
66
67const VMStateDescription vmstate_usb_device = {
68 .name = "USBDevice",
69 .version_id = 1,
70 .minimum_version_id = 1,
71 .post_load = usb_device_post_load,
72 .fields = (VMStateField[]) {
73 VMSTATE_UINT8(addr, USBDevice),
74 VMSTATE_INT32(state, USBDevice),
75 VMSTATE_INT32(remote_wakeup, USBDevice),
76 VMSTATE_INT32(setup_state, USBDevice),
77 VMSTATE_INT32(setup_len, USBDevice),
78 VMSTATE_INT32(setup_index, USBDevice),
79 VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8),
80 VMSTATE_END_OF_LIST(),
81 }
82};
83
84void usb_bus_new(USBBus *bus, size_t bus_size,
85 USBBusOps *ops, DeviceState *host)
86{
87 qbus_init(bus, bus_size, TYPE_USB_BUS, host, NULL);
88 qbus_set_bus_hotplug_handler(BUS(bus));
89 bus->ops = ops;
90 bus->busnr = next_usb_bus++;
91 QTAILQ_INIT(&bus->free);
92 QTAILQ_INIT(&bus->used);
93 QTAILQ_INSERT_TAIL(&busses, bus, next);
94}
95
96void usb_bus_release(USBBus *bus)
97{
98 assert(next_usb_bus > 0);
99
100 QTAILQ_REMOVE(&busses, bus, next);
101}
102
103USBBus *usb_bus_find(int busnr)
104{
105 USBBus *bus;
106
107 if (-1 == busnr)
108 return QTAILQ_FIRST(&busses);
109 QTAILQ_FOREACH(bus, &busses, next) {
110 if (bus->busnr == busnr)
111 return bus;
112 }
113 return NULL;
114}
115
116static void usb_device_realize(USBDevice *dev, Error **errp)
117{
118 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
119
120 if (klass->realize) {
121 klass->realize(dev, errp);
122 }
123}
124
125USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
126{
127 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
128 if (klass->find_device) {
129 return klass->find_device(dev, addr);
130 }
131 return NULL;
132}
133
134static void usb_device_unrealize(USBDevice *dev)
135{
136 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
137
138 if (klass->unrealize) {
139 klass->unrealize(dev);
140 }
141}
142
143void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
144{
145 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
146 if (klass->cancel_packet) {
147 klass->cancel_packet(dev, p);
148 }
149}
150
151void usb_device_handle_attach(USBDevice *dev)
152{
153 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
154 if (klass->handle_attach) {
155 klass->handle_attach(dev);
156 }
157}
158
159void usb_device_handle_reset(USBDevice *dev)
160{
161 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
162 if (klass->handle_reset) {
163 klass->handle_reset(dev);
164 }
165}
166
167void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
168 int value, int index, int length, uint8_t *data)
169{
170 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
171 if (klass->handle_control) {
172 klass->handle_control(dev, p, request, value, index, length, data);
173 }
174}
175
176void usb_device_handle_data(USBDevice *dev, USBPacket *p)
177{
178 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
179 if (klass->handle_data) {
180 klass->handle_data(dev, p);
181 }
182}
183
184const char *usb_device_get_product_desc(USBDevice *dev)
185{
186 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
187 return klass->product_desc;
188}
189
190const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
191{
192 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
193 if (dev->usb_desc) {
194 return dev->usb_desc;
195 }
196 return klass->usb_desc;
197}
198
199void usb_device_set_interface(USBDevice *dev, int interface,
200 int alt_old, int alt_new)
201{
202 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
203 if (klass->set_interface) {
204 klass->set_interface(dev, interface, alt_old, alt_new);
205 }
206}
207
208void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
209{
210 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
211 if (klass->flush_ep_queue) {
212 klass->flush_ep_queue(dev, ep);
213 }
214}
215
216void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
217{
218 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
219 if (klass->ep_stopped) {
220 klass->ep_stopped(dev, ep);
221 }
222}
223
224int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
225 int streams)
226{
227 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
228 if (klass->alloc_streams) {
229 return klass->alloc_streams(dev, eps, nr_eps, streams);
230 }
231 return 0;
232}
233
234void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
235{
236 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
237 if (klass->free_streams) {
238 klass->free_streams(dev, eps, nr_eps);
239 }
240}
241
242static void usb_qdev_realize(DeviceState *qdev, Error **errp)
243{
244 USBDevice *dev = USB_DEVICE(qdev);
245 Error *local_err = NULL;
246
247 pstrcpy(dev->product_desc, sizeof(dev->product_desc),
248 usb_device_get_product_desc(dev));
249 dev->auto_attach = 1;
250 QLIST_INIT(&dev->strings);
251 usb_ep_init(dev);
252
253 usb_claim_port(dev, &local_err);
254 if (local_err) {
255 error_propagate(errp, local_err);
256 return;
257 }
258
259 usb_device_realize(dev, &local_err);
260 if (local_err) {
261 usb_release_port(dev);
262 error_propagate(errp, local_err);
263 return;
264 }
265
266 if (dev->auto_attach) {
267 usb_device_attach(dev, &local_err);
268 if (local_err) {
269 usb_qdev_unrealize(qdev);
270 error_propagate(errp, local_err);
271 return;
272 }
273 }
274
275 if (dev->pcap_filename) {
276 int fd = qemu_open_old(dev->pcap_filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
277 if (fd < 0) {
278 error_setg(errp, "open %s failed", dev->pcap_filename);
279 usb_qdev_unrealize(qdev);
280 return;
281 }
282 dev->pcap = fdopen(fd, "w");
283 usb_pcap_init(dev->pcap);
284 }
285}
286
287static void usb_qdev_unrealize(DeviceState *qdev)
288{
289 USBDevice *dev = USB_DEVICE(qdev);
290 USBDescString *s, *next;
291
292 QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
293 QLIST_REMOVE(s, next);
294 g_free(s->str);
295 g_free(s);
296 }
297
298 if (dev->pcap) {
299 fclose(dev->pcap);
300 }
301
302 if (dev->attached) {
303 usb_device_detach(dev);
304 }
305 usb_device_unrealize(dev);
306 if (dev->port) {
307 usb_release_port(dev);
308 }
309}
310
311typedef struct LegacyUSBFactory
312{
313 const char *name;
314 const char *usbdevice_name;
315 USBDevice *(*usbdevice_init)(void);
316} LegacyUSBFactory;
317
318static GSList *legacy_usb_factory;
319
320void usb_legacy_register(const char *typename, const char *usbdevice_name,
321 USBDevice *(*usbdevice_init)(void))
322{
323 if (usbdevice_name) {
324 LegacyUSBFactory *f = g_malloc0(sizeof(*f));
325 f->name = typename;
326 f->usbdevice_name = usbdevice_name;
327 f->usbdevice_init = usbdevice_init;
328 legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
329 }
330}
331
332USBDevice *usb_new(const char *name)
333{
334 return USB_DEVICE(qdev_new(name));
335}
336
337static USBDevice *usb_try_new(const char *name)
338{
339 return USB_DEVICE(qdev_try_new(name));
340}
341
342bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp)
343{
344 return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
345}
346
347USBDevice *usb_create_simple(USBBus *bus, const char *name)
348{
349 USBDevice *dev = usb_new(name);
350
351 usb_realize_and_unref(dev, bus, &error_abort);
352 return dev;
353}
354
355static void usb_fill_port(USBPort *port, void *opaque, int index,
356 USBPortOps *ops, int speedmask)
357{
358 port->opaque = opaque;
359 port->index = index;
360 port->ops = ops;
361 port->speedmask = speedmask;
362 usb_port_location(port, NULL, index + 1);
363}
364
365void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
366 USBPortOps *ops, int speedmask)
367{
368 usb_fill_port(port, opaque, index, ops, speedmask);
369 QTAILQ_INSERT_TAIL(&bus->free, port, next);
370 bus->nfree++;
371}
372
373void usb_register_companion(const char *masterbus, USBPort *ports[],
374 uint32_t portcount, uint32_t firstport,
375 void *opaque, USBPortOps *ops, int speedmask,
376 Error **errp)
377{
378 USBBus *bus;
379 int i;
380
381 QTAILQ_FOREACH(bus, &busses, next) {
382 if (strcmp(bus->qbus.name, masterbus) == 0) {
383 break;
384 }
385 }
386
387 if (!bus) {
388 error_setg(errp, "USB bus '%s' not found", masterbus);
389 return;
390 }
391 if (!bus->ops->register_companion) {
392 error_setg(errp, "Can't use USB bus '%s' as masterbus,"
393 " it doesn't support companion controllers",
394 masterbus);
395 return;
396 }
397
398 for (i = 0; i < portcount; i++) {
399 usb_fill_port(ports[i], opaque, i, ops, speedmask);
400 }
401
402 bus->ops->register_companion(bus, ports, portcount, firstport, errp);
403}
404
405void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
406{
407 if (upstream) {
408 int l = snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
409 upstream->path, portnr);
410
411 assert(l < sizeof(downstream->path));
412 downstream->hubcount = upstream->hubcount + 1;
413 } else {
414 snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
415 downstream->hubcount = 0;
416 }
417}
418
419void usb_unregister_port(USBBus *bus, USBPort *port)
420{
421 if (port->dev) {
422 object_unparent(OBJECT(port->dev));
423 }
424 QTAILQ_REMOVE(&bus->free, port, next);
425 bus->nfree--;
426}
427
428void usb_claim_port(USBDevice *dev, Error **errp)
429{
430 USBBus *bus = usb_bus_from_device(dev);
431 USBPort *port;
432 USBDevice *hub;
433
434 assert(dev->port == NULL);
435
436 if (dev->port_path) {
437 QTAILQ_FOREACH(port, &bus->free, next) {
438 if (strcmp(port->path, dev->port_path) == 0) {
439 break;
440 }
441 }
442 if (port == NULL) {
443 error_setg(errp, "usb port %s (bus %s) not found (in use?)",
444 dev->port_path, bus->qbus.name);
445 return;
446 }
447 } else {
448 if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
449
450 hub = usb_try_new("usb-hub");
451 if (hub) {
452 usb_realize_and_unref(hub, bus, NULL);
453 }
454 }
455 if (bus->nfree == 0) {
456 error_setg(errp, "tried to attach usb device %s to a bus "
457 "with no free ports", dev->product_desc);
458 return;
459 }
460 port = QTAILQ_FIRST(&bus->free);
461 }
462 trace_usb_port_claim(bus->busnr, port->path);
463
464 QTAILQ_REMOVE(&bus->free, port, next);
465 bus->nfree--;
466
467 dev->port = port;
468 port->dev = dev;
469
470 QTAILQ_INSERT_TAIL(&bus->used, port, next);
471 bus->nused++;
472}
473
474void usb_release_port(USBDevice *dev)
475{
476 USBBus *bus = usb_bus_from_device(dev);
477 USBPort *port = dev->port;
478
479 assert(port != NULL);
480 trace_usb_port_release(bus->busnr, port->path);
481
482 QTAILQ_REMOVE(&bus->used, port, next);
483 bus->nused--;
484
485 dev->port = NULL;
486 port->dev = NULL;
487
488 QTAILQ_INSERT_TAIL(&bus->free, port, next);
489 bus->nfree++;
490}
491
492static void usb_mask_to_str(char *dest, size_t size,
493 unsigned int speedmask)
494{
495 static const struct {
496 unsigned int mask;
497 const char *name;
498 } speeds[] = {
499 { .mask = USB_SPEED_MASK_FULL, .name = "full" },
500 { .mask = USB_SPEED_MASK_HIGH, .name = "high" },
501 { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
502 };
503 int i, pos = 0;
504
505 for (i = 0; i < ARRAY_SIZE(speeds); i++) {
506 if (speeds[i].mask & speedmask) {
507 pos += snprintf(dest + pos, size - pos, "%s%s",
508 pos ? "+" : "",
509 speeds[i].name);
510 }
511 }
512
513 if (pos == 0) {
514 snprintf(dest, size, "unknown");
515 }
516}
517
518void usb_check_attach(USBDevice *dev, Error **errp)
519{
520 USBBus *bus = usb_bus_from_device(dev);
521 USBPort *port = dev->port;
522 char devspeed[32], portspeed[32];
523
524 assert(port != NULL);
525 assert(!dev->attached);
526 usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask);
527 usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask);
528 trace_usb_port_attach(bus->busnr, port->path,
529 devspeed, portspeed);
530
531 if (!(port->speedmask & dev->speedmask)) {
532 error_setg(errp, "Warning: speed mismatch trying to attach"
533 " usb device \"%s\" (%s speed)"
534 " to bus \"%s\", port \"%s\" (%s speed)",
535 dev->product_desc, devspeed,
536 bus->qbus.name, port->path, portspeed);
537 return;
538 }
539}
540
541void usb_device_attach(USBDevice *dev, Error **errp)
542{
543 USBPort *port = dev->port;
544 Error *local_err = NULL;
545
546 usb_check_attach(dev, &local_err);
547 if (local_err) {
548 error_propagate(errp, local_err);
549 return;
550 }
551
552 dev->attached = true;
553 usb_attach(port);
554}
555
556int usb_device_detach(USBDevice *dev)
557{
558 USBBus *bus = usb_bus_from_device(dev);
559 USBPort *port = dev->port;
560
561 assert(port != NULL);
562 assert(dev->attached);
563 trace_usb_port_detach(bus->busnr, port->path);
564
565 usb_detach(port);
566 dev->attached = false;
567 return 0;
568}
569
570static const char *usb_speed(unsigned int speed)
571{
572 static const char *txt[] = {
573 [ USB_SPEED_LOW ] = "1.5",
574 [ USB_SPEED_FULL ] = "12",
575 [ USB_SPEED_HIGH ] = "480",
576 [ USB_SPEED_SUPER ] = "5000",
577 };
578 if (speed >= ARRAY_SIZE(txt))
579 return "?";
580 return txt[speed];
581}
582
583static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
584{
585 USBDevice *dev = USB_DEVICE(qdev);
586 USBBus *bus = usb_bus_from_device(dev);
587
588 monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
589 indent, "", bus->busnr, dev->addr,
590 dev->port ? dev->port->path : "-",
591 usb_speed(dev->speed), dev->product_desc,
592 dev->attached ? ", attached" : "");
593}
594
595static char *usb_get_dev_path(DeviceState *qdev)
596{
597 USBDevice *dev = USB_DEVICE(qdev);
598 DeviceState *hcd = qdev->parent_bus->parent;
599 char *id = qdev_get_dev_path(hcd);
600
601 if (id) {
602 char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
603 g_free(id);
604 return ret;
605 } else {
606 return g_strdup(dev->port->path);
607 }
608}
609
610static char *usb_get_fw_dev_path(DeviceState *qdev)
611{
612 USBDevice *dev = USB_DEVICE(qdev);
613 char *fw_path, *in;
614 ssize_t pos = 0, fw_len;
615 long nr;
616
617 fw_len = 32 + strlen(dev->port->path) * 6;
618 fw_path = g_malloc(fw_len);
619 in = dev->port->path;
620 while (fw_len - pos > 0) {
621 nr = strtol(in, &in, 10);
622 if (in[0] == '.') {
623
624 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
625 in++;
626 } else {
627
628 snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
629 qdev_fw_name(qdev), nr);
630 break;
631 }
632 }
633 return fw_path;
634}
635
636HumanReadableText *qmp_x_query_usb(Error **errp)
637{
638 g_autoptr(GString) buf = g_string_new("");
639 USBBus *bus;
640 USBDevice *dev;
641 USBPort *port;
642
643 if (QTAILQ_EMPTY(&busses)) {
644 error_setg(errp, "USB support not enabled");
645 return NULL;
646 }
647
648 QTAILQ_FOREACH(bus, &busses, next) {
649 QTAILQ_FOREACH(port, &bus->used, next) {
650 dev = port->dev;
651 if (!dev)
652 continue;
653 g_string_append_printf(buf,
654 " Device %d.%d, Port %s, Speed %s Mb/s, "
655 "Product %s%s%s\n",
656 bus->busnr, dev->addr, port->path,
657 usb_speed(dev->speed), dev->product_desc,
658 dev->qdev.id ? ", ID: " : "",
659 dev->qdev.id ?: "");
660 }
661 }
662
663 return human_readable_text_from_str(buf);
664}
665
666
667USBDevice *usbdevice_create(const char *driver)
668{
669 USBBus *bus = usb_bus_find(-1 );
670 LegacyUSBFactory *f = NULL;
671 Error *err = NULL;
672 GSList *i;
673 USBDevice *dev;
674
675 if (strchr(driver, ':')) {
676 error_report("usbdevice parameters are not supported anymore");
677 return NULL;
678 }
679
680 for (i = legacy_usb_factory; i; i = i->next) {
681 f = i->data;
682 if (strcmp(f->usbdevice_name, driver) == 0) {
683 break;
684 }
685 }
686 if (i == NULL) {
687#if 0
688
689 error_report("usbdevice %s not found", driver);
690#endif
691 return NULL;
692 }
693
694 if (!bus) {
695 error_report("Error: no usb bus to attach usbdevice %s, "
696 "please try -machine usb=on and check that "
697 "the machine model supports USB", driver);
698 return NULL;
699 }
700
701 dev = f->usbdevice_init ? f->usbdevice_init() : usb_new(f->name);
702 if (!dev) {
703 error_report("Failed to create USB device '%s'", f->name);
704 return NULL;
705 }
706 if (!usb_realize_and_unref(dev, bus, &err)) {
707 error_reportf_err(err, "Failed to initialize USB device '%s': ",
708 f->name);
709 object_unparent(OBJECT(dev));
710 return NULL;
711 }
712 return dev;
713}
714
715static bool usb_get_attached(Object *obj, Error **errp)
716{
717 USBDevice *dev = USB_DEVICE(obj);
718
719 return dev->attached;
720}
721
722static void usb_set_attached(Object *obj, bool value, Error **errp)
723{
724 USBDevice *dev = USB_DEVICE(obj);
725
726 if (dev->attached == value) {
727 return;
728 }
729
730 if (value) {
731 usb_device_attach(dev, errp);
732 } else {
733 usb_device_detach(dev);
734 }
735}
736
737static void usb_device_instance_init(Object *obj)
738{
739 USBDevice *dev = USB_DEVICE(obj);
740 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
741
742 if (klass->attached_settable) {
743 object_property_add_bool(obj, "attached",
744 usb_get_attached, usb_set_attached);
745 } else {
746 object_property_add_bool(obj, "attached",
747 usb_get_attached, NULL);
748 }
749}
750
751static void usb_device_class_init(ObjectClass *klass, void *data)
752{
753 DeviceClass *k = DEVICE_CLASS(klass);
754 k->bus_type = TYPE_USB_BUS;
755 k->realize = usb_qdev_realize;
756 k->unrealize = usb_qdev_unrealize;
757 device_class_set_props(k, usb_props);
758}
759
760static const TypeInfo usb_device_type_info = {
761 .name = TYPE_USB_DEVICE,
762 .parent = TYPE_DEVICE,
763 .instance_size = sizeof(USBDevice),
764 .instance_init = usb_device_instance_init,
765 .abstract = true,
766 .class_size = sizeof(USBDeviceClass),
767 .class_init = usb_device_class_init,
768};
769
770static void usb_register_types(void)
771{
772 type_register_static(&usb_bus_info);
773 type_register_static(&usb_device_type_info);
774}
775
776type_init(usb_register_types)
777
