Merge tag 'pull-request-2022-09-28' of https://gitlab.com/thuth/qemu into staging
[qemu.git] / hw / usb / bus.c
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
15 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
16
17 static char *usb_get_dev_path(DeviceState *dev);
18 static char *usb_get_fw_dev_path(DeviceState *qdev);
19 static void usb_qdev_unrealize(DeviceState *qdev);
20
21 static 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
30 static 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
41 static 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
52 static int next_usb_bus = 0;
53 static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
54
55 static 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
67 const 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
84 void 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
96 void usb_bus_release(USBBus *bus)
97 {
98 assert(next_usb_bus > 0);
99
100 QTAILQ_REMOVE(&busses, bus, next);
101 }
102
103 USBBus *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
116 static 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
125 USBDevice *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
134 static 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
143 void 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
151 void 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
159 void 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
167 void 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
176 void 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
184 const char *usb_device_get_product_desc(USBDevice *dev)
185 {
186 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
187 return klass->product_desc;
188 }
189
190 const 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
199 void 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
208 void 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
216 void 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
224 int 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
234 void 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
242 static 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
287 static 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
311 typedef struct LegacyUSBFactory
312 {
313 const char *name;
314 const char *usbdevice_name;
315 USBDevice *(*usbdevice_init)(void);
316 } LegacyUSBFactory;
317
318 static GSList *legacy_usb_factory;
319
320 void 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
332 USBDevice *usb_new(const char *name)
333 {
334 return USB_DEVICE(qdev_new(name));
335 }
336
337 static USBDevice *usb_try_new(const char *name)
338 {
339 return USB_DEVICE(qdev_try_new(name));
340 }
341
342 bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp)
343 {
344 return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
345 }
346
347 USBDevice *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
355 static 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
365 void 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
373 void 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
405 void 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 /* Max string is nn.nn.nn.nn.nn, which fits in 16 bytes */
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
419 void 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
428 void 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 /* Create a new hub and chain it on */
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
474 void 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
492 static 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
518 void 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
541 void 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
556 int 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
570 static 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
583 static 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
595 static 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
610 static 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 /* some hub between root port and device */
624 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
625 in++;
626 } else {
627 /* the device itself */
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
636 HumanReadableText *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 /* handle legacy -usbdevice cmd line option */
667 USBDevice *usbdevice_create(const char *driver)
668 {
669 USBBus *bus = usb_bus_find(-1 /* any */);
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 /* no error because some drivers are not converted (yet) */
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
715 static bool usb_get_attached(Object *obj, Error **errp)
716 {
717 USBDevice *dev = USB_DEVICE(obj);
718
719 return dev->attached;
720 }
721
722 static 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
737 static 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
751 static 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
760 static 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
770 static void usb_register_types(void)
771 {
772 type_register_static(&usb_bus_info);
773 type_register_static(&usb_device_type_info);
774 }
775
776 type_init(usb_register_types)