xref: /openbmc/qemu/hw/usb/bus.c (revision fe44dc91)
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 #include "migration/migration.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, Error **errp);
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     if (dev->setup_index < 0 ||
64         dev->setup_len < 0 ||
65         dev->setup_index > dev->setup_len ||
66         dev->setup_len > sizeof(dev->data_buf)) {
67         return -EINVAL;
68     }
69     return 0;
70 }
71 
72 const VMStateDescription vmstate_usb_device = {
73     .name = "USBDevice",
74     .version_id = 1,
75     .minimum_version_id = 1,
76     .post_load = usb_device_post_load,
77     .fields = (VMStateField[]) {
78         VMSTATE_UINT8(addr, USBDevice),
79         VMSTATE_INT32(state, USBDevice),
80         VMSTATE_INT32(remote_wakeup, USBDevice),
81         VMSTATE_INT32(setup_state, USBDevice),
82         VMSTATE_INT32(setup_len, USBDevice),
83         VMSTATE_INT32(setup_index, USBDevice),
84         VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8),
85         VMSTATE_END_OF_LIST(),
86     }
87 };
88 
89 void usb_bus_new(USBBus *bus, size_t bus_size,
90                  USBBusOps *ops, DeviceState *host)
91 {
92     qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL);
93     qbus_set_bus_hotplug_handler(BUS(bus), &error_abort);
94     bus->ops = ops;
95     bus->busnr = next_usb_bus++;
96     QTAILQ_INIT(&bus->free);
97     QTAILQ_INIT(&bus->used);
98     QTAILQ_INSERT_TAIL(&busses, bus, next);
99 }
100 
101 void usb_bus_release(USBBus *bus)
102 {
103     assert(next_usb_bus > 0);
104 
105     QTAILQ_REMOVE(&busses, bus, next);
106 }
107 
108 USBBus *usb_bus_find(int busnr)
109 {
110     USBBus *bus;
111 
112     if (-1 == busnr)
113         return QTAILQ_FIRST(&busses);
114     QTAILQ_FOREACH(bus, &busses, next) {
115         if (bus->busnr == busnr)
116             return bus;
117     }
118     return NULL;
119 }
120 
121 static void usb_device_realize(USBDevice *dev, Error **errp)
122 {
123     USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
124 
125     if (klass->realize) {
126         klass->realize(dev, errp);
127     }
128 }
129 
130 USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
131 {
132     USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
133     if (klass->find_device) {
134         return klass->find_device(dev, addr);
135     }
136     return NULL;
137 }
138 
139 static void usb_device_handle_destroy(USBDevice *dev)
140 {
141     USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
142     if (klass->handle_destroy) {
143         klass->handle_destroy(dev);
144     }
145 }
146 
147 void 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 
155 void 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 
163 void 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 
171 void 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 
180 void 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 
188 const char *usb_device_get_product_desc(USBDevice *dev)
189 {
190     USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
191     return klass->product_desc;
192 }
193 
194 const 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 
203 void 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 
212 void 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 
220 void 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 
228 int 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 
238 void 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 
246 static 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 
280 static 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_handle_destroy(dev);
295     if (dev->port) {
296         usb_release_port(dev);
297     }
298 }
299 
300 typedef struct LegacyUSBFactory
301 {
302     const char *name;
303     const char *usbdevice_name;
304     USBDevice *(*usbdevice_init)(USBBus *bus, const char *params);
305 } LegacyUSBFactory;
306 
307 static GSList *legacy_usb_factory;
308 
309 void 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 
322 USBDevice *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 
330 static 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(errp, err);
344         error_prepend(errp, "Failed to initialize USB device '%s': ",
345                       name);
346         object_unparent(OBJECT(dev));
347         return NULL;
348     }
349     return dev;
350 }
351 
352 USBDevice *usb_create_simple(USBBus *bus, const char *name)
353 {
354     return usb_try_create_simple(bus, name, &error_abort);
355 }
356 
357 static void usb_fill_port(USBPort *port, void *opaque, int index,
358                           USBPortOps *ops, int speedmask)
359 {
360     port->opaque = opaque;
361     port->index = index;
362     port->ops = ops;
363     port->speedmask = speedmask;
364     usb_port_location(port, NULL, index + 1);
365 }
366 
367 void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
368                        USBPortOps *ops, int speedmask)
369 {
370     usb_fill_port(port, opaque, index, ops, speedmask);
371     QTAILQ_INSERT_TAIL(&bus->free, port, next);
372     bus->nfree++;
373 }
374 
375 void usb_register_companion(const char *masterbus, USBPort *ports[],
376                             uint32_t portcount, uint32_t firstport,
377                             void *opaque, USBPortOps *ops, int speedmask,
378                             Error **errp)
379 {
380     USBBus *bus;
381     int i;
382 
383     QTAILQ_FOREACH(bus, &busses, next) {
384         if (strcmp(bus->qbus.name, masterbus) == 0) {
385             break;
386         }
387     }
388 
389     if (!bus) {
390         error_setg(errp, "USB bus '%s' not found", masterbus);
391         return;
392     }
393     if (!bus->ops->register_companion) {
394         error_setg(errp, "Can't use USB bus '%s' as masterbus,"
395                    " it doesn't support companion controllers",
396                    masterbus);
397         return;
398     }
399 
400     for (i = 0; i < portcount; i++) {
401         usb_fill_port(ports[i], opaque, i, ops, speedmask);
402     }
403 
404     bus->ops->register_companion(bus, ports, portcount, firstport, errp);
405 }
406 
407 void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
408 {
409     if (upstream) {
410         snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
411                  upstream->path, portnr);
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 
433     assert(dev->port == NULL);
434 
435     if (dev->port_path) {
436         QTAILQ_FOREACH(port, &bus->free, next) {
437             if (strcmp(port->path, dev->port_path) == 0) {
438                 break;
439             }
440         }
441         if (port == NULL) {
442             error_setg(errp, "usb port %s (bus %s) not found (in use?)",
443                        dev->port_path, bus->qbus.name);
444             return;
445         }
446     } else {
447         if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
448             /* Create a new hub and chain it on */
449             usb_try_create_simple(bus, "usb-hub", NULL);
450         }
451         if (bus->nfree == 0) {
452             error_setg(errp, "tried to attach usb device %s to a bus "
453                        "with no free ports", dev->product_desc);
454             return;
455         }
456         port = QTAILQ_FIRST(&bus->free);
457     }
458     trace_usb_port_claim(bus->busnr, port->path);
459 
460     QTAILQ_REMOVE(&bus->free, port, next);
461     bus->nfree--;
462 
463     dev->port = port;
464     port->dev = dev;
465 
466     QTAILQ_INSERT_TAIL(&bus->used, port, next);
467     bus->nused++;
468 }
469 
470 void usb_release_port(USBDevice *dev)
471 {
472     USBBus *bus = usb_bus_from_device(dev);
473     USBPort *port = dev->port;
474 
475     assert(port != NULL);
476     trace_usb_port_release(bus->busnr, port->path);
477 
478     QTAILQ_REMOVE(&bus->used, port, next);
479     bus->nused--;
480 
481     dev->port = NULL;
482     port->dev = NULL;
483 
484     QTAILQ_INSERT_TAIL(&bus->free, port, next);
485     bus->nfree++;
486 }
487 
488 static void usb_mask_to_str(char *dest, size_t size,
489                             unsigned int speedmask)
490 {
491     static const struct {
492         unsigned int mask;
493         const char *name;
494     } speeds[] = {
495         { .mask = USB_SPEED_MASK_FULL,  .name = "full"  },
496         { .mask = USB_SPEED_MASK_HIGH,  .name = "high"  },
497         { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
498     };
499     int i, pos = 0;
500 
501     for (i = 0; i < ARRAY_SIZE(speeds); i++) {
502         if (speeds[i].mask & speedmask) {
503             pos += snprintf(dest + pos, size - pos, "%s%s",
504                             pos ? "+" : "",
505                             speeds[i].name);
506         }
507     }
508 }
509 
510 void usb_check_attach(USBDevice *dev, Error **errp)
511 {
512     USBBus *bus = usb_bus_from_device(dev);
513     USBPort *port = dev->port;
514     char devspeed[32], portspeed[32];
515 
516     assert(port != NULL);
517     assert(!dev->attached);
518     usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask);
519     usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask);
520     trace_usb_port_attach(bus->busnr, port->path,
521                           devspeed, portspeed);
522 
523     if (!(port->speedmask & dev->speedmask)) {
524         error_setg(errp, "Warning: speed mismatch trying to attach"
525                    " usb device \"%s\" (%s speed)"
526                    " to bus \"%s\", port \"%s\" (%s speed)",
527                    dev->product_desc, devspeed,
528                    bus->qbus.name, port->path, portspeed);
529         return;
530     }
531 }
532 
533 void usb_device_attach(USBDevice *dev, Error **errp)
534 {
535     USBPort *port = dev->port;
536     Error *local_err = NULL;
537 
538     usb_check_attach(dev, &local_err);
539     if (local_err) {
540         error_propagate(errp, local_err);
541         return;
542     }
543 
544     dev->attached = true;
545     usb_attach(port);
546 }
547 
548 int usb_device_detach(USBDevice *dev)
549 {
550     USBBus *bus = usb_bus_from_device(dev);
551     USBPort *port = dev->port;
552 
553     assert(port != NULL);
554     assert(dev->attached);
555     trace_usb_port_detach(bus->busnr, port->path);
556 
557     usb_detach(port);
558     dev->attached = false;
559     return 0;
560 }
561 
562 int usb_device_delete_addr(int busnr, int addr)
563 {
564     USBBus *bus;
565     USBPort *port;
566     USBDevice *dev;
567 
568     bus = usb_bus_find(busnr);
569     if (!bus)
570         return -1;
571 
572     QTAILQ_FOREACH(port, &bus->used, next) {
573         if (port->dev->addr == addr)
574             break;
575     }
576     if (!port)
577         return -1;
578     dev = port->dev;
579 
580     object_unparent(OBJECT(dev));
581     return 0;
582 }
583 
584 static const char *usb_speed(unsigned int speed)
585 {
586     static const char *txt[] = {
587         [ USB_SPEED_LOW  ] = "1.5",
588         [ USB_SPEED_FULL ] = "12",
589         [ USB_SPEED_HIGH ] = "480",
590         [ USB_SPEED_SUPER ] = "5000",
591     };
592     if (speed >= ARRAY_SIZE(txt))
593         return "?";
594     return txt[speed];
595 }
596 
597 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
598 {
599     USBDevice *dev = USB_DEVICE(qdev);
600     USBBus *bus = usb_bus_from_device(dev);
601 
602     monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
603                    indent, "", bus->busnr, dev->addr,
604                    dev->port ? dev->port->path : "-",
605                    usb_speed(dev->speed), dev->product_desc,
606                    dev->attached ? ", attached" : "");
607 }
608 
609 static char *usb_get_dev_path(DeviceState *qdev)
610 {
611     USBDevice *dev = USB_DEVICE(qdev);
612     DeviceState *hcd = qdev->parent_bus->parent;
613     char *id = NULL;
614 
615     if (dev->flags & (1 << USB_DEV_FLAG_FULL_PATH)) {
616         id = qdev_get_dev_path(hcd);
617     }
618     if (id) {
619         char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
620         g_free(id);
621         return ret;
622     } else {
623         return g_strdup(dev->port->path);
624     }
625 }
626 
627 static char *usb_get_fw_dev_path(DeviceState *qdev)
628 {
629     USBDevice *dev = USB_DEVICE(qdev);
630     char *fw_path, *in;
631     ssize_t pos = 0, fw_len;
632     long nr;
633 
634     fw_len = 32 + strlen(dev->port->path) * 6;
635     fw_path = g_malloc(fw_len);
636     in = dev->port->path;
637     while (fw_len - pos > 0) {
638         nr = strtol(in, &in, 10);
639         if (in[0] == '.') {
640             /* some hub between root port and device */
641             pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
642             in++;
643         } else {
644             /* the device itself */
645             pos += snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
646                             qdev_fw_name(qdev), nr);
647             break;
648         }
649     }
650     return fw_path;
651 }
652 
653 void hmp_info_usb(Monitor *mon, const QDict *qdict)
654 {
655     USBBus *bus;
656     USBDevice *dev;
657     USBPort *port;
658 
659     if (QTAILQ_EMPTY(&busses)) {
660         monitor_printf(mon, "USB support not enabled\n");
661         return;
662     }
663 
664     QTAILQ_FOREACH(bus, &busses, next) {
665         QTAILQ_FOREACH(port, &bus->used, next) {
666             dev = port->dev;
667             if (!dev)
668                 continue;
669             monitor_printf(mon, "  Device %d.%d, Port %s, Speed %s Mb/s, "
670                            "Product %s%s%s\n",
671                            bus->busnr, dev->addr, port->path,
672                            usb_speed(dev->speed), dev->product_desc,
673                            dev->qdev.id ? ", ID: " : "",
674                            dev->qdev.id ?: "");
675         }
676     }
677 }
678 
679 /* handle legacy -usbdevice cmd line option */
680 USBDevice *usbdevice_create(const char *cmdline)
681 {
682     USBBus *bus = usb_bus_find(-1 /* any */);
683     LegacyUSBFactory *f = NULL;
684     Error *err = NULL;
685     GSList *i;
686     char driver[32];
687     const char *params;
688     int len;
689     USBDevice *dev;
690     ObjectClass *klass;
691     DeviceClass *dc;
692 
693     params = strchr(cmdline,':');
694     if (params) {
695         params++;
696         len = params - cmdline;
697         if (len > sizeof(driver))
698             len = sizeof(driver);
699         pstrcpy(driver, len, cmdline);
700     } else {
701         params = "";
702         pstrcpy(driver, sizeof(driver), cmdline);
703     }
704 
705     for (i = legacy_usb_factory; i; i = i->next) {
706         f = i->data;
707         if (strcmp(f->usbdevice_name, driver) == 0) {
708             break;
709         }
710     }
711     if (i == NULL) {
712 #if 0
713         /* no error because some drivers are not converted (yet) */
714         error_report("usbdevice %s not found", driver);
715 #endif
716         return NULL;
717     }
718 
719     if (!bus) {
720         error_report("Error: no usb bus to attach usbdevice %s, "
721                      "please try -machine usb=on and check that "
722                      "the machine model supports USB", driver);
723         return NULL;
724     }
725 
726     klass = object_class_by_name(f->name);
727     if (klass == NULL) {
728         error_report("Device '%s' not found", f->name);
729         return NULL;
730     }
731 
732     dc = DEVICE_CLASS(klass);
733 
734     if (only_migratable) {
735         if (dc->vmsd->unmigratable) {
736             error_report("Device %s is not migratable, but --only-migratable "
737                          "was specified", f->name);
738             return NULL;
739         }
740     }
741 
742     if (f->usbdevice_init) {
743         dev = f->usbdevice_init(bus, params);
744     } else {
745         if (*params) {
746             error_report("usbdevice %s accepts no params", driver);
747             return NULL;
748         }
749         dev = usb_create(bus, f->name);
750     }
751     if (!dev) {
752         error_report("Failed to create USB device '%s'", f->name);
753         return NULL;
754     }
755     object_property_set_bool(OBJECT(dev), true, "realized", &err);
756     if (err) {
757         error_reportf_err(err, "Failed to initialize USB device '%s': ",
758                           f->name);
759         object_unparent(OBJECT(dev));
760         return NULL;
761     }
762     return dev;
763 }
764 
765 static bool usb_get_attached(Object *obj, Error **errp)
766 {
767     USBDevice *dev = USB_DEVICE(obj);
768 
769     return dev->attached;
770 }
771 
772 static void usb_set_attached(Object *obj, bool value, Error **errp)
773 {
774     USBDevice *dev = USB_DEVICE(obj);
775     Error *err = NULL;
776 
777     if (dev->attached == value) {
778         return;
779     }
780 
781     if (value) {
782         usb_device_attach(dev, &err);
783         if (err) {
784             error_propagate(errp, err);
785         }
786     } else {
787         usb_device_detach(dev);
788     }
789 }
790 
791 static void usb_device_instance_init(Object *obj)
792 {
793     USBDevice *dev = USB_DEVICE(obj);
794     USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
795 
796     if (klass->attached_settable) {
797         object_property_add_bool(obj, "attached",
798                                  usb_get_attached, usb_set_attached,
799                                  NULL);
800     } else {
801         object_property_add_bool(obj, "attached",
802                                  usb_get_attached, NULL,
803                                  NULL);
804     }
805 }
806 
807 static void usb_device_class_init(ObjectClass *klass, void *data)
808 {
809     DeviceClass *k = DEVICE_CLASS(klass);
810     k->bus_type = TYPE_USB_BUS;
811     k->realize  = usb_qdev_realize;
812     k->unrealize = usb_qdev_unrealize;
813     k->props    = usb_props;
814 }
815 
816 static const TypeInfo usb_device_type_info = {
817     .name = TYPE_USB_DEVICE,
818     .parent = TYPE_DEVICE,
819     .instance_size = sizeof(USBDevice),
820     .instance_init = usb_device_instance_init,
821     .abstract = true,
822     .class_size = sizeof(USBDeviceClass),
823     .class_init = usb_device_class_init,
824 };
825 
826 static void usb_register_types(void)
827 {
828     type_register_static(&usb_bus_info);
829     type_register_static(&usb_device_type_info);
830 }
831 
832 type_init(usb_register_types)
833