hw/arm/raspi: fix CPRMAN base address
[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 "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
13 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
14
15 static char *usb_get_dev_path(DeviceState *dev);
16 static char *usb_get_fw_dev_path(DeviceState *qdev);
17 static void usb_qdev_unrealize(DeviceState *qdev);
18
19 static 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
29 static 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
40 static 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
51 static int next_usb_bus = 0;
52 static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
53
54 static 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
66 const 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
83 void 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
95 void usb_bus_release(USBBus *bus)
96 {
97 assert(next_usb_bus > 0);
98
99 QTAILQ_REMOVE(&busses, bus, next);
100 }
101
102 USBBus *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
115 static 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
124 USBDevice *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
133 static 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
142 void 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
150 void 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
158 void 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
166 void 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
175 void 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
183 const char *usb_device_get_product_desc(USBDevice *dev)
184 {
185 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
186 return klass->product_desc;
187 }
188
189 const 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
198 void 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
207 void 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
215 void 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
223 int 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
233 void 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
241 static 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
275 static 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
295 typedef struct LegacyUSBFactory
296 {
297 const char *name;
298 const char *usbdevice_name;
299 USBDevice *(*usbdevice_init)(const char *params);
300 } LegacyUSBFactory;
301
302 static GSList *legacy_usb_factory;
303
304 void 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
316 USBDevice *usb_new(const char *name)
317 {
318 return USB_DEVICE(qdev_new(name));
319 }
320
321 static USBDevice *usb_try_new(const char *name)
322 {
323 return USB_DEVICE(qdev_try_new(name));
324 }
325
326 bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp)
327 {
328 return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
329 }
330
331 USBDevice *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
339 static 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
349 void 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
357 void 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
389 void 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 /* Max string is nn.nn.nn.nn.nn, which fits in 16 bytes */
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
403 void 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
412 void 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 /* Create a new hub and chain it on */
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
458 void 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
476 static 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
502 void 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
525 void 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
540 int 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
554 static 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
567 static 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
579 static 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
597 static 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 /* some hub between root port and device */
611 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
612 in++;
613 } else {
614 /* the device itself */
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
623 void 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 /* handle legacy -usbdevice cmd line option */
650 USBDevice *usbdevice_create(const char *cmdline)
651 {
652 USBBus *bus = usb_bus_find(-1 /* any */);
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 /* no error because some drivers are not converted (yet) */
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
716 static bool usb_get_attached(Object *obj, Error **errp)
717 {
718 USBDevice *dev = USB_DEVICE(obj);
719
720 return dev->attached;
721 }
722
723 static 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
738 static 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
752 static 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
761 static 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
771 static void usb_register_types(void)
772 {
773 type_register_static(&usb_bus_info);
774 type_register_static(&usb_device_type_info);
775 }
776
777 type_init(usb_register_types)