1 #include "qemu/osdep.h"
2 #include "hw/qdev-properties.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"
13 #include "qemu/cutils.h"
15 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
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);
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()
30 static void usb_bus_class_init(ObjectClass *klass, void *data)
32 BusClass *k = BUS_CLASS(klass);
33 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
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;
41 static const TypeInfo usb_bus_info = {
44 .instance_size = sizeof(USBBus),
45 .class_init = usb_bus_class_init,
46 .interfaces = (InterfaceInfo[]) {
47 { TYPE_HOTPLUG_HANDLER },
52 static int next_usb_bus = 0;
53 static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
55 static int usb_device_post_load(void *opaque, int version_id)
57 USBDevice *dev = opaque;
59 if (dev->state == USB_STATE_NOTATTACHED) {
60 dev->attached = false;
67 const VMStateDescription vmstate_usb_device = {
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(),
84 void usb_bus_new(USBBus *bus, size_t bus_size,
85 USBBusOps *ops, DeviceState *host)
87 qbus_init(bus, bus_size, TYPE_USB_BUS, host, NULL);
88 qbus_set_bus_hotplug_handler(BUS(bus));
90 bus->busnr = next_usb_bus++;
91 QTAILQ_INIT(&bus->free);
92 QTAILQ_INIT(&bus->used);
93 QTAILQ_INSERT_TAIL(&busses, bus, next);
96 void usb_bus_release(USBBus *bus)
98 assert(next_usb_bus > 0);
100 QTAILQ_REMOVE(&busses, bus, next);
103 USBBus *usb_bus_find(int busnr)
108 return QTAILQ_FIRST(&busses);
109 QTAILQ_FOREACH(bus, &busses, next) {
110 if (bus->busnr == busnr)
116 static void usb_device_realize(USBDevice *dev, Error **errp)
118 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
120 if (klass->realize) {
121 klass->realize(dev, errp);
125 USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
127 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
128 if (klass->find_device) {
129 return klass->find_device(dev, addr);
134 static void usb_device_unrealize(USBDevice *dev)
136 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
138 if (klass->unrealize) {
139 klass->unrealize(dev);
143 void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
145 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
146 if (klass->cancel_packet) {
147 klass->cancel_packet(dev, p);
151 void usb_device_handle_attach(USBDevice *dev)
153 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
154 if (klass->handle_attach) {
155 klass->handle_attach(dev);
159 void usb_device_handle_reset(USBDevice *dev)
161 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
162 if (klass->handle_reset) {
163 klass->handle_reset(dev);
167 void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
168 int value, int index, int length, uint8_t *data)
170 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
171 if (klass->handle_control) {
172 klass->handle_control(dev, p, request, value, index, length, data);
176 void usb_device_handle_data(USBDevice *dev, USBPacket *p)
178 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
179 if (klass->handle_data) {
180 klass->handle_data(dev, p);
184 const char *usb_device_get_product_desc(USBDevice *dev)
186 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
187 return klass->product_desc;
190 const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
192 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
194 return dev->usb_desc;
196 return klass->usb_desc;
199 void usb_device_set_interface(USBDevice *dev, int interface,
200 int alt_old, int alt_new)
202 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
203 if (klass->set_interface) {
204 klass->set_interface(dev, interface, alt_old, alt_new);
208 void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
210 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
211 if (klass->flush_ep_queue) {
212 klass->flush_ep_queue(dev, ep);
216 void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
218 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
219 if (klass->ep_stopped) {
220 klass->ep_stopped(dev, ep);
224 int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
227 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
228 if (klass->alloc_streams) {
229 return klass->alloc_streams(dev, eps, nr_eps, streams);
234 void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
236 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
237 if (klass->free_streams) {
238 klass->free_streams(dev, eps, nr_eps);
242 static void usb_qdev_realize(DeviceState *qdev, Error **errp)
244 USBDevice *dev = USB_DEVICE(qdev);
245 Error *local_err = NULL;
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);
253 usb_claim_port(dev, &local_err);
255 error_propagate(errp, local_err);
259 usb_device_realize(dev, &local_err);
261 usb_release_port(dev);
262 error_propagate(errp, local_err);
266 if (dev->auto_attach) {
267 usb_device_attach(dev, &local_err);
269 usb_qdev_unrealize(qdev);
270 error_propagate(errp, local_err);
275 if (dev->pcap_filename) {
276 int fd = qemu_open_old(dev->pcap_filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
278 error_setg(errp, "open %s failed", dev->pcap_filename);
279 usb_qdev_unrealize(qdev);
282 dev->pcap = fdopen(fd, "w");
283 usb_pcap_init(dev->pcap);
287 static void usb_qdev_unrealize(DeviceState *qdev)
289 USBDevice *dev = USB_DEVICE(qdev);
290 USBDescString *s, *next;
292 QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
293 QLIST_REMOVE(s, next);
303 usb_device_detach(dev);
305 usb_device_unrealize(dev);
307 usb_release_port(dev);
311 typedef struct LegacyUSBFactory
314 const char *usbdevice_name;
315 USBDevice *(*usbdevice_init)(void);
318 static GSList *legacy_usb_factory;
320 void usb_legacy_register(const char *typename, const char *usbdevice_name,
321 USBDevice *(*usbdevice_init)(void))
323 if (usbdevice_name) {
324 LegacyUSBFactory *f = g_malloc0(sizeof(*f));
326 f->usbdevice_name = usbdevice_name;
327 f->usbdevice_init = usbdevice_init;
328 legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
332 USBDevice *usb_new(const char *name)
334 return USB_DEVICE(qdev_new(name));
337 static USBDevice *usb_try_new(const char *name)
339 return USB_DEVICE(qdev_try_new(name));
342 bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp)
344 return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
347 USBDevice *usb_create_simple(USBBus *bus, const char *name)
349 USBDevice *dev = usb_new(name);
351 usb_realize_and_unref(dev, bus, &error_abort);
355 static void usb_fill_port(USBPort *port, void *opaque, int index,
356 USBPortOps *ops, int speedmask)
358 port->opaque = opaque;
361 port->speedmask = speedmask;
362 usb_port_location(port, NULL, index + 1);
365 void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
366 USBPortOps *ops, int speedmask)
368 usb_fill_port(port, opaque, index, ops, speedmask);
369 QTAILQ_INSERT_TAIL(&bus->free, port, next);
373 void usb_register_companion(const char *masterbus, USBPort *ports[],
374 uint32_t portcount, uint32_t firstport,
375 void *opaque, USBPortOps *ops, int speedmask,
381 QTAILQ_FOREACH(bus, &busses, next) {
382 if (strcmp(bus->qbus.name, masterbus) == 0) {
388 error_setg(errp, "USB bus '%s' not found", masterbus);
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",
398 for (i = 0; i < portcount; i++) {
399 usb_fill_port(ports[i], opaque, i, ops, speedmask);
402 bus->ops->register_companion(bus, ports, portcount, firstport, errp);
405 void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
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;
414 snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
415 downstream->hubcount = 0;
419 void usb_unregister_port(USBBus *bus, USBPort *port)
422 object_unparent(OBJECT(port->dev));
424 QTAILQ_REMOVE(&bus->free, port, next);
428 void usb_claim_port(USBDevice *dev, Error **errp)
430 USBBus *bus = usb_bus_from_device(dev);
434 assert(dev->port == NULL);
436 if (dev->port_path) {
437 QTAILQ_FOREACH(port, &bus->free, next) {
438 if (strcmp(port->path, dev->port_path) == 0) {
443 error_setg(errp, "usb port %s (bus %s) not found (in use?)",
444 dev->port_path, bus->qbus.name);
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");
452 usb_realize_and_unref(hub, bus, NULL);
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);
460 port = QTAILQ_FIRST(&bus->free);
462 trace_usb_port_claim(bus->busnr, port->path);
464 QTAILQ_REMOVE(&bus->free, port, next);
470 QTAILQ_INSERT_TAIL(&bus->used, port, next);
474 void usb_release_port(USBDevice *dev)
476 USBBus *bus = usb_bus_from_device(dev);
477 USBPort *port = dev->port;
479 assert(port != NULL);
480 trace_usb_port_release(bus->busnr, port->path);
482 QTAILQ_REMOVE(&bus->used, port, next);
488 QTAILQ_INSERT_TAIL(&bus->free, port, next);
492 static void usb_mask_to_str(char *dest, size_t size,
493 unsigned int speedmask)
495 static const struct {
499 { .mask = USB_SPEED_MASK_FULL, .name = "full" },
500 { .mask = USB_SPEED_MASK_HIGH, .name = "high" },
501 { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
505 for (i = 0; i < ARRAY_SIZE(speeds); i++) {
506 if (speeds[i].mask & speedmask) {
507 pos += snprintf(dest + pos, size - pos, "%s%s",
514 snprintf(dest, size, "unknown");
518 void usb_check_attach(USBDevice *dev, Error **errp)
520 USBBus *bus = usb_bus_from_device(dev);
521 USBPort *port = dev->port;
522 char devspeed[32], portspeed[32];
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);
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);
541 void usb_device_attach(USBDevice *dev, Error **errp)
543 USBPort *port = dev->port;
544 Error *local_err = NULL;
546 usb_check_attach(dev, &local_err);
548 error_propagate(errp, local_err);
552 dev->attached = true;
556 int usb_device_detach(USBDevice *dev)
558 USBBus *bus = usb_bus_from_device(dev);
559 USBPort *port = dev->port;
561 assert(port != NULL);
562 assert(dev->attached);
563 trace_usb_port_detach(bus->busnr, port->path);
566 dev->attached = false;
570 static const char *usb_speed(unsigned int speed)
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",
578 if (speed >= ARRAY_SIZE(txt))
583 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
585 USBDevice *dev = USB_DEVICE(qdev);
586 USBBus *bus = usb_bus_from_device(dev);
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" : "");
595 static char *usb_get_dev_path(DeviceState *qdev)
597 USBDevice *dev = USB_DEVICE(qdev);
598 DeviceState *hcd = qdev->parent_bus->parent;
599 char *id = qdev_get_dev_path(hcd);
602 char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
606 return g_strdup(dev->port->path);
610 static char *usb_get_fw_dev_path(DeviceState *qdev)
612 USBDevice *dev = USB_DEVICE(qdev);
614 ssize_t pos = 0, fw_len;
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);
623 /* some hub between root port and device */
624 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
627 /* the device itself */
628 snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
629 qdev_fw_name(qdev), nr);
636 HumanReadableText *qmp_x_query_usb(Error **errp)
638 g_autoptr(GString) buf = g_string_new("");
643 if (QTAILQ_EMPTY(&busses)) {
644 error_setg(errp, "USB support not enabled");
648 QTAILQ_FOREACH(bus, &busses, next) {
649 QTAILQ_FOREACH(port, &bus->used, next) {
653 g_string_append_printf(buf,
654 " Device %d.%d, Port %s, Speed %s Mb/s, "
656 bus->busnr, dev->addr, port->path,
657 usb_speed(dev->speed), dev->product_desc,
658 dev->qdev.id ? ", ID: " : "",
663 return human_readable_text_from_str(buf);
666 /* handle legacy -usbdevice cmd line option */
667 USBDevice *usbdevice_create(const char *driver)
669 USBBus *bus = usb_bus_find(-1 /* any */);
670 LegacyUSBFactory *f = NULL;
675 if (strchr(driver, ':')) {
676 error_report("usbdevice parameters are not supported anymore");
680 for (i = legacy_usb_factory; i; i = i->next) {
682 if (strcmp(f->usbdevice_name, driver) == 0) {
688 /* no error because some drivers are not converted (yet) */
689 error_report("usbdevice %s not found", driver);
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);
701 dev = f->usbdevice_init ? f->usbdevice_init() : usb_new(f->name);
703 error_report("Failed to create USB device '%s'", f->name);
706 if (!usb_realize_and_unref(dev, bus, &err)) {
707 error_reportf_err(err, "Failed to initialize USB device '%s': ",
709 object_unparent(OBJECT(dev));
715 static bool usb_get_attached(Object *obj, Error **errp)
717 USBDevice *dev = USB_DEVICE(obj);
719 return dev->attached;
722 static void usb_set_attached(Object *obj, bool value, Error **errp)
724 USBDevice *dev = USB_DEVICE(obj);
726 if (dev->attached == value) {
731 usb_device_attach(dev, errp);
733 usb_device_detach(dev);
737 static void usb_device_instance_init(Object *obj)
739 USBDevice *dev = USB_DEVICE(obj);
740 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
742 if (klass->attached_settable) {
743 object_property_add_bool(obj, "attached",
744 usb_get_attached, usb_set_attached);
746 object_property_add_bool(obj, "attached",
747 usb_get_attached, NULL);
751 static void usb_device_class_init(ObjectClass *klass, void *data)
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);
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,
766 .class_size = sizeof(USBDeviceClass),
767 .class_init = usb_device_class_init,
770 static void usb_register_types(void)
772 type_register_static(&usb_bus_info);
773 type_register_static(&usb_device_type_info);
776 type_init(usb_register_types)