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