qapi: Fix broken discriminator error messages
[qemu/kevin.git] / hw / usb / bus.c
bloba6522f54293147a6d156830a41932800f21245ab
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"
13 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
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);
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()
29 static void usb_bus_class_init(ObjectClass *klass, void *data)
31 BusClass *k = BUS_CLASS(klass);
32 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
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;
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 { }
51 static int next_usb_bus = 0;
52 static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
54 static int usb_device_post_load(void *opaque, int version_id)
56 USBDevice *dev = opaque;
58 if (dev->state == USB_STATE_NOTATTACHED) {
59 dev->attached = false;
60 } else {
61 dev->attached = true;
63 return 0;
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(),
83 void usb_bus_new(USBBus *bus, size_t bus_size,
84 USBBusOps *ops, DeviceState *host)
86 qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL);
87 qbus_set_bus_hotplug_handler(BUS(bus), &error_abort);
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);
95 void usb_bus_release(USBBus *bus)
97 assert(next_usb_bus > 0);
99 QTAILQ_REMOVE(&busses, bus, next);
102 USBBus *usb_bus_find(int busnr)
104 USBBus *bus;
106 if (-1 == busnr)
107 return QTAILQ_FIRST(&busses);
108 QTAILQ_FOREACH(bus, &busses, next) {
109 if (bus->busnr == busnr)
110 return bus;
112 return NULL;
115 static void usb_device_realize(USBDevice *dev, Error **errp)
117 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
119 if (klass->realize) {
120 klass->realize(dev, errp);
124 USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
126 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
127 if (klass->find_device) {
128 return klass->find_device(dev, addr);
130 return NULL;
133 static void usb_device_unrealize(USBDevice *dev, Error **errp)
135 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
137 if (klass->unrealize) {
138 klass->unrealize(dev, errp);
142 void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
144 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
145 if (klass->cancel_packet) {
146 klass->cancel_packet(dev, p);
150 void usb_device_handle_attach(USBDevice *dev)
152 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
153 if (klass->handle_attach) {
154 klass->handle_attach(dev);
158 void usb_device_handle_reset(USBDevice *dev)
160 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
161 if (klass->handle_reset) {
162 klass->handle_reset(dev);
166 void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
167 int value, int index, int length, uint8_t *data)
169 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
170 if (klass->handle_control) {
171 klass->handle_control(dev, p, request, value, index, length, data);
175 void usb_device_handle_data(USBDevice *dev, USBPacket *p)
177 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
178 if (klass->handle_data) {
179 klass->handle_data(dev, p);
183 const char *usb_device_get_product_desc(USBDevice *dev)
185 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
186 return klass->product_desc;
189 const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
191 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
192 if (dev->usb_desc) {
193 return dev->usb_desc;
195 return klass->usb_desc;
198 void usb_device_set_interface(USBDevice *dev, int interface,
199 int alt_old, int alt_new)
201 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
202 if (klass->set_interface) {
203 klass->set_interface(dev, interface, alt_old, alt_new);
207 void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
209 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
210 if (klass->flush_ep_queue) {
211 klass->flush_ep_queue(dev, ep);
215 void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
217 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
218 if (klass->ep_stopped) {
219 klass->ep_stopped(dev, ep);
223 int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
224 int streams)
226 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
227 if (klass->alloc_streams) {
228 return klass->alloc_streams(dev, eps, nr_eps, streams);
230 return 0;
233 void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
235 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
236 if (klass->free_streams) {
237 klass->free_streams(dev, eps, nr_eps);
241 static void usb_qdev_realize(DeviceState *qdev, Error **errp)
243 USBDevice *dev = USB_DEVICE(qdev);
244 Error *local_err = NULL;
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);
252 usb_claim_port(dev, &local_err);
253 if (local_err) {
254 error_propagate(errp, local_err);
255 return;
258 usb_device_realize(dev, &local_err);
259 if (local_err) {
260 usb_release_port(dev);
261 error_propagate(errp, local_err);
262 return;
265 if (dev->auto_attach) {
266 usb_device_attach(dev, &local_err);
267 if (local_err) {
268 usb_qdev_unrealize(qdev, NULL);
269 error_propagate(errp, local_err);
270 return;
275 static void usb_qdev_unrealize(DeviceState *qdev, Error **errp)
277 USBDevice *dev = USB_DEVICE(qdev);
278 USBDescString *s, *next;
280 QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
281 QLIST_REMOVE(s, next);
282 g_free(s->str);
283 g_free(s);
286 if (dev->attached) {
287 usb_device_detach(dev);
289 usb_device_unrealize(dev, errp);
290 if (dev->port) {
291 usb_release_port(dev);
295 typedef struct LegacyUSBFactory
297 const char *name;
298 const char *usbdevice_name;
299 USBDevice *(*usbdevice_init)(USBBus *bus, const char *params);
300 } LegacyUSBFactory;
302 static GSList *legacy_usb_factory;
304 void usb_legacy_register(const char *typename, const char *usbdevice_name,
305 USBDevice *(*usbdevice_init)(USBBus *bus,
306 const char *params))
308 if (usbdevice_name) {
309 LegacyUSBFactory *f = g_malloc0(sizeof(*f));
310 f->name = typename;
311 f->usbdevice_name = usbdevice_name;
312 f->usbdevice_init = usbdevice_init;
313 legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
317 USBDevice *usb_create(USBBus *bus, const char *name)
319 DeviceState *dev;
321 dev = qdev_create(&bus->qbus, name);
322 return USB_DEVICE(dev);
325 static USBDevice *usb_try_create_simple(USBBus *bus, const char *name,
326 Error **errp)
328 Error *err = NULL;
329 USBDevice *dev;
331 dev = USB_DEVICE(qdev_try_create(&bus->qbus, name));
332 if (!dev) {
333 error_setg(errp, "Failed to create USB device '%s'", name);
334 return NULL;
336 object_property_set_bool(OBJECT(dev), true, "realized", &err);
337 if (err) {
338 error_propagate_prepend(errp, err,
339 "Failed to initialize USB device '%s': ",
340 name);
341 return NULL;
343 return dev;
346 USBDevice *usb_create_simple(USBBus *bus, const char *name)
348 return usb_try_create_simple(bus, name, &error_abort);
351 static void usb_fill_port(USBPort *port, void *opaque, int index,
352 USBPortOps *ops, int speedmask)
354 port->opaque = opaque;
355 port->index = index;
356 port->ops = ops;
357 port->speedmask = speedmask;
358 usb_port_location(port, NULL, index + 1);
361 void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
362 USBPortOps *ops, int speedmask)
364 usb_fill_port(port, opaque, index, ops, speedmask);
365 QTAILQ_INSERT_TAIL(&bus->free, port, next);
366 bus->nfree++;
369 void usb_register_companion(const char *masterbus, USBPort *ports[],
370 uint32_t portcount, uint32_t firstport,
371 void *opaque, USBPortOps *ops, int speedmask,
372 Error **errp)
374 USBBus *bus;
375 int i;
377 QTAILQ_FOREACH(bus, &busses, next) {
378 if (strcmp(bus->qbus.name, masterbus) == 0) {
379 break;
383 if (!bus) {
384 error_setg(errp, "USB bus '%s' not found", masterbus);
385 return;
387 if (!bus->ops->register_companion) {
388 error_setg(errp, "Can't use USB bus '%s' as masterbus,"
389 " it doesn't support companion controllers",
390 masterbus);
391 return;
394 for (i = 0; i < portcount; i++) {
395 usb_fill_port(ports[i], opaque, i, ops, speedmask);
398 bus->ops->register_companion(bus, ports, portcount, firstport, errp);
401 void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
403 if (upstream) {
404 int l = snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
405 upstream->path, portnr);
406 /* Max string is nn.nn.nn.nn.nn, which fits in 16 bytes */
407 assert(l < sizeof(downstream->path));
408 downstream->hubcount = upstream->hubcount + 1;
409 } else {
410 snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
411 downstream->hubcount = 0;
415 void usb_unregister_port(USBBus *bus, USBPort *port)
417 if (port->dev) {
418 object_unparent(OBJECT(port->dev));
420 QTAILQ_REMOVE(&bus->free, port, next);
421 bus->nfree--;
424 void usb_claim_port(USBDevice *dev, Error **errp)
426 USBBus *bus = usb_bus_from_device(dev);
427 USBPort *port;
429 assert(dev->port == NULL);
431 if (dev->port_path) {
432 QTAILQ_FOREACH(port, &bus->free, next) {
433 if (strcmp(port->path, dev->port_path) == 0) {
434 break;
437 if (port == NULL) {
438 error_setg(errp, "usb port %s (bus %s) not found (in use?)",
439 dev->port_path, bus->qbus.name);
440 return;
442 } else {
443 if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
444 /* Create a new hub and chain it on */
445 usb_try_create_simple(bus, "usb-hub", NULL);
447 if (bus->nfree == 0) {
448 error_setg(errp, "tried to attach usb device %s to a bus "
449 "with no free ports", dev->product_desc);
450 return;
452 port = QTAILQ_FIRST(&bus->free);
454 trace_usb_port_claim(bus->busnr, port->path);
456 QTAILQ_REMOVE(&bus->free, port, next);
457 bus->nfree--;
459 dev->port = port;
460 port->dev = dev;
462 QTAILQ_INSERT_TAIL(&bus->used, port, next);
463 bus->nused++;
466 void usb_release_port(USBDevice *dev)
468 USBBus *bus = usb_bus_from_device(dev);
469 USBPort *port = dev->port;
471 assert(port != NULL);
472 trace_usb_port_release(bus->busnr, port->path);
474 QTAILQ_REMOVE(&bus->used, port, next);
475 bus->nused--;
477 dev->port = NULL;
478 port->dev = NULL;
480 QTAILQ_INSERT_TAIL(&bus->free, port, next);
481 bus->nfree++;
484 static void usb_mask_to_str(char *dest, size_t size,
485 unsigned int speedmask)
487 static const struct {
488 unsigned int mask;
489 const char *name;
490 } speeds[] = {
491 { .mask = USB_SPEED_MASK_FULL, .name = "full" },
492 { .mask = USB_SPEED_MASK_HIGH, .name = "high" },
493 { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
495 int i, pos = 0;
497 for (i = 0; i < ARRAY_SIZE(speeds); i++) {
498 if (speeds[i].mask & speedmask) {
499 pos += snprintf(dest + pos, size - pos, "%s%s",
500 pos ? "+" : "",
501 speeds[i].name);
505 if (pos == 0) {
506 snprintf(dest, size, "unknown");
510 void usb_check_attach(USBDevice *dev, Error **errp)
512 USBBus *bus = usb_bus_from_device(dev);
513 USBPort *port = dev->port;
514 char devspeed[32], portspeed[32];
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);
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;
533 void usb_device_attach(USBDevice *dev, Error **errp)
535 USBPort *port = dev->port;
536 Error *local_err = NULL;
538 usb_check_attach(dev, &local_err);
539 if (local_err) {
540 error_propagate(errp, local_err);
541 return;
544 dev->attached = true;
545 usb_attach(port);
548 int usb_device_detach(USBDevice *dev)
550 USBBus *bus = usb_bus_from_device(dev);
551 USBPort *port = dev->port;
553 assert(port != NULL);
554 assert(dev->attached);
555 trace_usb_port_detach(bus->busnr, port->path);
557 usb_detach(port);
558 dev->attached = false;
559 return 0;
562 static const char *usb_speed(unsigned int speed)
564 static const char *txt[] = {
565 [ USB_SPEED_LOW ] = "1.5",
566 [ USB_SPEED_FULL ] = "12",
567 [ USB_SPEED_HIGH ] = "480",
568 [ USB_SPEED_SUPER ] = "5000",
570 if (speed >= ARRAY_SIZE(txt))
571 return "?";
572 return txt[speed];
575 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
577 USBDevice *dev = USB_DEVICE(qdev);
578 USBBus *bus = usb_bus_from_device(dev);
580 monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
581 indent, "", bus->busnr, dev->addr,
582 dev->port ? dev->port->path : "-",
583 usb_speed(dev->speed), dev->product_desc,
584 dev->attached ? ", attached" : "");
587 static char *usb_get_dev_path(DeviceState *qdev)
589 USBDevice *dev = USB_DEVICE(qdev);
590 DeviceState *hcd = qdev->parent_bus->parent;
591 char *id = NULL;
593 if (dev->flags & (1 << USB_DEV_FLAG_FULL_PATH)) {
594 id = qdev_get_dev_path(hcd);
596 if (id) {
597 char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
598 g_free(id);
599 return ret;
600 } else {
601 return g_strdup(dev->port->path);
605 static char *usb_get_fw_dev_path(DeviceState *qdev)
607 USBDevice *dev = USB_DEVICE(qdev);
608 char *fw_path, *in;
609 ssize_t pos = 0, fw_len;
610 long nr;
612 fw_len = 32 + strlen(dev->port->path) * 6;
613 fw_path = g_malloc(fw_len);
614 in = dev->port->path;
615 while (fw_len - pos > 0) {
616 nr = strtol(in, &in, 10);
617 if (in[0] == '.') {
618 /* some hub between root port and device */
619 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
620 in++;
621 } else {
622 /* the device itself */
623 pos += snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
624 qdev_fw_name(qdev), nr);
625 break;
628 return fw_path;
631 void hmp_info_usb(Monitor *mon, const QDict *qdict)
633 USBBus *bus;
634 USBDevice *dev;
635 USBPort *port;
637 if (QTAILQ_EMPTY(&busses)) {
638 monitor_printf(mon, "USB support not enabled\n");
639 return;
642 QTAILQ_FOREACH(bus, &busses, next) {
643 QTAILQ_FOREACH(port, &bus->used, next) {
644 dev = port->dev;
645 if (!dev)
646 continue;
647 monitor_printf(mon, " Device %d.%d, Port %s, Speed %s Mb/s, "
648 "Product %s%s%s\n",
649 bus->busnr, dev->addr, port->path,
650 usb_speed(dev->speed), dev->product_desc,
651 dev->qdev.id ? ", ID: " : "",
652 dev->qdev.id ?: "");
657 /* handle legacy -usbdevice cmd line option */
658 USBDevice *usbdevice_create(const char *cmdline)
660 USBBus *bus = usb_bus_find(-1 /* any */);
661 LegacyUSBFactory *f = NULL;
662 Error *err = NULL;
663 GSList *i;
664 char driver[32];
665 const char *params;
666 int len;
667 USBDevice *dev;
669 params = strchr(cmdline,':');
670 if (params) {
671 params++;
672 len = params - cmdline;
673 if (len > sizeof(driver))
674 len = sizeof(driver);
675 pstrcpy(driver, len, cmdline);
676 } else {
677 params = "";
678 pstrcpy(driver, sizeof(driver), cmdline);
681 for (i = legacy_usb_factory; i; i = i->next) {
682 f = i->data;
683 if (strcmp(f->usbdevice_name, driver) == 0) {
684 break;
687 if (i == NULL) {
688 #if 0
689 /* no error because some drivers are not converted (yet) */
690 error_report("usbdevice %s not found", driver);
691 #endif
692 return NULL;
695 if (!bus) {
696 error_report("Error: no usb bus to attach usbdevice %s, "
697 "please try -machine usb=on and check that "
698 "the machine model supports USB", driver);
699 return NULL;
702 if (f->usbdevice_init) {
703 dev = f->usbdevice_init(bus, params);
704 } else {
705 if (*params) {
706 error_report("usbdevice %s accepts no params", driver);
707 return NULL;
709 dev = usb_create(bus, f->name);
711 if (!dev) {
712 error_report("Failed to create USB device '%s'", f->name);
713 return NULL;
715 object_property_set_bool(OBJECT(dev), true, "realized", &err);
716 if (err) {
717 error_reportf_err(err, "Failed to initialize USB device '%s': ",
718 f->name);
719 object_unparent(OBJECT(dev));
720 return NULL;
722 return dev;
725 static bool usb_get_attached(Object *obj, Error **errp)
727 USBDevice *dev = USB_DEVICE(obj);
729 return dev->attached;
732 static void usb_set_attached(Object *obj, bool value, Error **errp)
734 USBDevice *dev = USB_DEVICE(obj);
735 Error *err = NULL;
737 if (dev->attached == value) {
738 return;
741 if (value) {
742 usb_device_attach(dev, &err);
743 error_propagate(errp, err);
744 } else {
745 usb_device_detach(dev);
749 static void usb_device_instance_init(Object *obj)
751 USBDevice *dev = USB_DEVICE(obj);
752 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
754 if (klass->attached_settable) {
755 object_property_add_bool(obj, "attached",
756 usb_get_attached, usb_set_attached,
757 NULL);
758 } else {
759 object_property_add_bool(obj, "attached",
760 usb_get_attached, NULL,
761 NULL);
765 static void usb_device_class_init(ObjectClass *klass, void *data)
767 DeviceClass *k = DEVICE_CLASS(klass);
768 k->bus_type = TYPE_USB_BUS;
769 k->realize = usb_qdev_realize;
770 k->unrealize = usb_qdev_unrealize;
771 k->props = usb_props;
774 static const TypeInfo usb_device_type_info = {
775 .name = TYPE_USB_DEVICE,
776 .parent = TYPE_DEVICE,
777 .instance_size = sizeof(USBDevice),
778 .instance_init = usb_device_instance_init,
779 .abstract = true,
780 .class_size = sizeof(USBDeviceClass),
781 .class_init = usb_device_class_init,
784 static void usb_register_types(void)
786 type_register_static(&usb_bus_info);
787 type_register_static(&usb_device_type_info);
790 type_init(usb_register_types)