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