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
13static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
14
15static char *usb_get_dev_path(DeviceState *dev);
16static char *usb_get_fw_dev_path(DeviceState *qdev);
17static void usb_qdev_unrealize(DeviceState *qdev);
18
19static Property usb_props[] = {
20 DEFINE_PROP_STRING("port", USBDevice, port_path),
21 DEFINE_PROP_STRING("serial", USBDevice, serial),
22 DEFINE_PROP_BIT("msos-desc", USBDevice, flags,
23 USB_DEV_FLAG_MSOS_DESC_ENABLE, true),
24 DEFINE_PROP_STRING("pcap", USBDevice, pcap_filename),
25 DEFINE_PROP_END_OF_LIST()
26};
27
28static void usb_bus_class_init(ObjectClass *klass, void *data)
29{
30 BusClass *k = BUS_CLASS(klass);
31 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
32
33 k->print_dev = usb_bus_dev_print;
34 k->get_dev_path = usb_get_dev_path;
35 k->get_fw_dev_path = usb_get_fw_dev_path;
36 hc->unplug = qdev_simple_device_unplug_cb;
37}
38
39static const TypeInfo usb_bus_info = {
40 .name = TYPE_USB_BUS,
41 .parent = TYPE_BUS,
42 .instance_size = sizeof(USBBus),
43 .class_init = usb_bus_class_init,
44 .interfaces = (InterfaceInfo[]) {
45 { TYPE_HOTPLUG_HANDLER },
46 { }
47 }
48};
49
50static int next_usb_bus = 0;
51static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
52
53static int usb_device_post_load(void *opaque, int version_id)
54{
55 USBDevice *dev = opaque;
56
57 if (dev->state == USB_STATE_NOTATTACHED) {
58 dev->attached = false;
59 } else {
60 dev->attached = true;
61 }
62 return 0;
63}
64
65const VMStateDescription vmstate_usb_device = {
66 .name = "USBDevice",
67 .version_id = 1,
68 .minimum_version_id = 1,
69 .post_load = usb_device_post_load,
70 .fields = (VMStateField[]) {
71 VMSTATE_UINT8(addr, USBDevice),
72 VMSTATE_INT32(state, USBDevice),
73 VMSTATE_INT32(remote_wakeup, USBDevice),
74 VMSTATE_INT32(setup_state, USBDevice),
75 VMSTATE_INT32(setup_len, USBDevice),
76 VMSTATE_INT32(setup_index, USBDevice),
77 VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8),
78 VMSTATE_END_OF_LIST(),
79 }
80};
81
82void usb_bus_new(USBBus *bus, size_t bus_size,
83 USBBusOps *ops, DeviceState *host)
84{
85 qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL);
86 qbus_set_bus_hotplug_handler(BUS(bus));
87 bus->ops = ops;
88 bus->busnr = next_usb_bus++;
89 QTAILQ_INIT(&bus->free);
90 QTAILQ_INIT(&bus->used);
91 QTAILQ_INSERT_TAIL(&busses, bus, next);
92}
93
94void usb_bus_release(USBBus *bus)
95{
96 assert(next_usb_bus > 0);
97
98 QTAILQ_REMOVE(&busses, bus, next);
99}
100
101USBBus *usb_bus_find(int busnr)
102{
103 USBBus *bus;
104
105 if (-1 == busnr)
106 return QTAILQ_FIRST(&busses);
107 QTAILQ_FOREACH(bus, &busses, next) {
108 if (bus->busnr == busnr)
109 return bus;
110 }
111 return NULL;
112}
113
114static void usb_device_realize(USBDevice *dev, Error **errp)
115{
116 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
117
118 if (klass->realize) {
119 klass->realize(dev, errp);
120 }
121}
122
123USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
124{
125 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
126 if (klass->find_device) {
127 return klass->find_device(dev, addr);
128 }
129 return NULL;
130}
131
132static void usb_device_unrealize(USBDevice *dev)
133{
134 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
135
136 if (klass->unrealize) {
137 klass->unrealize(dev);
138 }
139}
140
141void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
142{
143 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
144 if (klass->cancel_packet) {
145 klass->cancel_packet(dev, p);
146 }
147}
148
149void usb_device_handle_attach(USBDevice *dev)
150{
151 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
152 if (klass->handle_attach) {
153 klass->handle_attach(dev);
154 }
155}
156
157void usb_device_handle_reset(USBDevice *dev)
158{
159 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
160 if (klass->handle_reset) {
161 klass->handle_reset(dev);
162 }
163}
164
165void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
166 int value, int index, int length, uint8_t *data)
167{
168 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
169 if (klass->handle_control) {
170 klass->handle_control(dev, p, request, value, index, length, data);
171 }
172}
173
174void usb_device_handle_data(USBDevice *dev, USBPacket *p)
175{
176 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
177 if (klass->handle_data) {
178 klass->handle_data(dev, p);
179 }
180}
181
182const char *usb_device_get_product_desc(USBDevice *dev)
183{
184 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
185 return klass->product_desc;
186}
187
188const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
189{
190 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
191 if (dev->usb_desc) {
192 return dev->usb_desc;
193 }
194 return klass->usb_desc;
195}
196
197void usb_device_set_interface(USBDevice *dev, int interface,
198 int alt_old, int alt_new)
199{
200 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
201 if (klass->set_interface) {
202 klass->set_interface(dev, interface, alt_old, alt_new);
203 }
204}
205
206void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
207{
208 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
209 if (klass->flush_ep_queue) {
210 klass->flush_ep_queue(dev, ep);
211 }
212}
213
214void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
215{
216 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
217 if (klass->ep_stopped) {
218 klass->ep_stopped(dev, ep);
219 }
220}
221
222int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
223 int streams)
224{
225 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
226 if (klass->alloc_streams) {
227 return klass->alloc_streams(dev, eps, nr_eps, streams);
228 }
229 return 0;
230}
231
232void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
233{
234 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
235 if (klass->free_streams) {
236 klass->free_streams(dev, eps, nr_eps);
237 }
238}
239
240static void usb_qdev_realize(DeviceState *qdev, Error **errp)
241{
242 USBDevice *dev = USB_DEVICE(qdev);
243 Error *local_err = NULL;
244
245 pstrcpy(dev->product_desc, sizeof(dev->product_desc),
246 usb_device_get_product_desc(dev));
247 dev->auto_attach = 1;
248 QLIST_INIT(&dev->strings);
249 usb_ep_init(dev);
250
251 usb_claim_port(dev, &local_err);
252 if (local_err) {
253 error_propagate(errp, local_err);
254 return;
255 }
256
257 usb_device_realize(dev, &local_err);
258 if (local_err) {
259 usb_release_port(dev);
260 error_propagate(errp, local_err);
261 return;
262 }
263
264 if (dev->auto_attach) {
265 usb_device_attach(dev, &local_err);
266 if (local_err) {
267 usb_qdev_unrealize(qdev);
268 error_propagate(errp, local_err);
269 return;
270 }
271 }
272
273 if (dev->pcap_filename) {
274 int fd = qemu_open_old(dev->pcap_filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
275 if (fd < 0) {
276 error_setg(errp, "open %s failed", dev->pcap_filename);
277 usb_qdev_unrealize(qdev);
278 return;
279 }
280 dev->pcap = fdopen(fd, "w");
281 usb_pcap_init(dev->pcap);
282 }
283}
284
285static void usb_qdev_unrealize(DeviceState *qdev)
286{
287 USBDevice *dev = USB_DEVICE(qdev);
288 USBDescString *s, *next;
289
290 QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
291 QLIST_REMOVE(s, next);
292 g_free(s->str);
293 g_free(s);
294 }
295
296 if (dev->pcap) {
297 fclose(dev->pcap);
298 }
299
300 if (dev->attached) {
301 usb_device_detach(dev);
302 }
303 usb_device_unrealize(dev);
304 if (dev->port) {
305 usb_release_port(dev);
306 }
307}
308
309typedef struct LegacyUSBFactory
310{
311 const char *name;
312 const char *usbdevice_name;
313 USBDevice *(*usbdevice_init)(void);
314} LegacyUSBFactory;
315
316static GSList *legacy_usb_factory;
317
318void usb_legacy_register(const char *typename, const char *usbdevice_name,
319 USBDevice *(*usbdevice_init)(void))
320{
321 if (usbdevice_name) {
322 LegacyUSBFactory *f = g_malloc0(sizeof(*f));
323 f->name = typename;
324 f->usbdevice_name = usbdevice_name;
325 f->usbdevice_init = usbdevice_init;
326 legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
327 }
328}
329
330USBDevice *usb_new(const char *name)
331{
332 return USB_DEVICE(qdev_new(name));
333}
334
335static USBDevice *usb_try_new(const char *name)
336{
337 return USB_DEVICE(qdev_try_new(name));
338}
339
340bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp)
341{
342 return qdev_realize_and_unref(&dev->qdev, &bus->qbus, errp);
343}
344
345USBDevice *usb_create_simple(USBBus *bus, const char *name)
346{
347 USBDevice *dev = usb_new(name);
348
349 usb_realize_and_unref(dev, bus, &error_abort);
350 return dev;
351}
352
353static void usb_fill_port(USBPort *port, void *opaque, int index,
354 USBPortOps *ops, int speedmask)
355{
356 port->opaque = opaque;
357 port->index = index;
358 port->ops = ops;
359 port->speedmask = speedmask;
360 usb_port_location(port, NULL, index + 1);
361}
362
363void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
364 USBPortOps *ops, int speedmask)
365{
366 usb_fill_port(port, opaque, index, ops, speedmask);
367 QTAILQ_INSERT_TAIL(&bus->free, port, next);
368 bus->nfree++;
369}
370
371void usb_register_companion(const char *masterbus, USBPort *ports[],
372 uint32_t portcount, uint32_t firstport,
373 void *opaque, USBPortOps *ops, int speedmask,
374 Error **errp)
375{
376 USBBus *bus;
377 int i;
378
379 QTAILQ_FOREACH(bus, &busses, next) {
380 if (strcmp(bus->qbus.name, masterbus) == 0) {
381 break;
382 }
383 }
384
385 if (!bus) {
386 error_setg(errp, "USB bus '%s' not found", masterbus);
387 return;
388 }
389 if (!bus->ops->register_companion) {
390 error_setg(errp, "Can't use USB bus '%s' as masterbus,"
391 " it doesn't support companion controllers",
392 masterbus);
393 return;
394 }
395
396 for (i = 0; i < portcount; i++) {
397 usb_fill_port(ports[i], opaque, i, ops, speedmask);
398 }
399
400 bus->ops->register_companion(bus, ports, portcount, firstport, errp);
401}
402
403void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
404{
405 if (upstream) {
406 int l = snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
407 upstream->path, portnr);
408
409 assert(l < sizeof(downstream->path));
410 downstream->hubcount = upstream->hubcount + 1;
411 } else {
412 snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
413 downstream->hubcount = 0;
414 }
415}
416
417void usb_unregister_port(USBBus *bus, USBPort *port)
418{
419 if (port->dev) {
420 object_unparent(OBJECT(port->dev));
421 }
422 QTAILQ_REMOVE(&bus->free, port, next);
423 bus->nfree--;
424}
425
426void usb_claim_port(USBDevice *dev, Error **errp)
427{
428 USBBus *bus = usb_bus_from_device(dev);
429 USBPort *port;
430 USBDevice *hub;
431
432 assert(dev->port == NULL);
433
434 if (dev->port_path) {
435 QTAILQ_FOREACH(port, &bus->free, next) {
436 if (strcmp(port->path, dev->port_path) == 0) {
437 break;
438 }
439 }
440 if (port == NULL) {
441 error_setg(errp, "usb port %s (bus %s) not found (in use?)",
442 dev->port_path, bus->qbus.name);
443 return;
444 }
445 } else {
446 if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
447
448 hub = usb_try_new("usb-hub");
449 if (hub) {
450 usb_realize_and_unref(hub, bus, NULL);
451 }
452 }
453 if (bus->nfree == 0) {
454 error_setg(errp, "tried to attach usb device %s to a bus "
455 "with no free ports", dev->product_desc);
456 return;
457 }
458 port = QTAILQ_FIRST(&bus->free);
459 }
460 trace_usb_port_claim(bus->busnr, port->path);
461
462 QTAILQ_REMOVE(&bus->free, port, next);
463 bus->nfree--;
464
465 dev->port = port;
466 port->dev = dev;
467
468 QTAILQ_INSERT_TAIL(&bus->used, port, next);
469 bus->nused++;
470}
471
472void usb_release_port(USBDevice *dev)
473{
474 USBBus *bus = usb_bus_from_device(dev);
475 USBPort *port = dev->port;
476
477 assert(port != NULL);
478 trace_usb_port_release(bus->busnr, port->path);
479
480 QTAILQ_REMOVE(&bus->used, port, next);
481 bus->nused--;
482
483 dev->port = NULL;
484 port->dev = NULL;
485
486 QTAILQ_INSERT_TAIL(&bus->free, port, next);
487 bus->nfree++;
488}
489
490static void usb_mask_to_str(char *dest, size_t size,
491 unsigned int speedmask)
492{
493 static const struct {
494 unsigned int mask;
495 const char *name;
496 } speeds[] = {
497 { .mask = USB_SPEED_MASK_FULL, .name = "full" },
498 { .mask = USB_SPEED_MASK_HIGH, .name = "high" },
499 { .mask = USB_SPEED_MASK_SUPER, .name = "super" },
500 };
501 int i, pos = 0;
502
503 for (i = 0; i < ARRAY_SIZE(speeds); i++) {
504 if (speeds[i].mask & speedmask) {
505 pos += snprintf(dest + pos, size - pos, "%s%s",
506 pos ? "+" : "",
507 speeds[i].name);
508 }
509 }
510
511 if (pos == 0) {
512 snprintf(dest, size, "unknown");
513 }
514}
515
516void usb_check_attach(USBDevice *dev, Error **errp)
517{
518 USBBus *bus = usb_bus_from_device(dev);
519 USBPort *port = dev->port;
520 char devspeed[32], portspeed[32];
521
522 assert(port != NULL);
523 assert(!dev->attached);
524 usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask);
525 usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask);
526 trace_usb_port_attach(bus->busnr, port->path,
527 devspeed, portspeed);
528
529 if (!(port->speedmask & dev->speedmask)) {
530 error_setg(errp, "Warning: speed mismatch trying to attach"
531 " usb device \"%s\" (%s speed)"
532 " to bus \"%s\", port \"%s\" (%s speed)",
533 dev->product_desc, devspeed,
534 bus->qbus.name, port->path, portspeed);
535 return;
536 }
537}
538
539void usb_device_attach(USBDevice *dev, Error **errp)
540{
541 USBPort *port = dev->port;
542 Error *local_err = NULL;
543
544 usb_check_attach(dev, &local_err);
545 if (local_err) {
546 error_propagate(errp, local_err);
547 return;
548 }
549
550 dev->attached = true;
551 usb_attach(port);
552}
553
554int usb_device_detach(USBDevice *dev)
555{
556 USBBus *bus = usb_bus_from_device(dev);
557 USBPort *port = dev->port;
558
559 assert(port != NULL);
560 assert(dev->attached);
561 trace_usb_port_detach(bus->busnr, port->path);
562
563 usb_detach(port);
564 dev->attached = false;
565 return 0;
566}
567
568static const char *usb_speed(unsigned int speed)
569{
570 static const char *txt[] = {
571 [ USB_SPEED_LOW ] = "1.5",
572 [ USB_SPEED_FULL ] = "12",
573 [ USB_SPEED_HIGH ] = "480",
574 [ USB_SPEED_SUPER ] = "5000",
575 };
576 if (speed >= ARRAY_SIZE(txt))
577 return "?";
578 return txt[speed];
579}
580
581static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
582{
583 USBDevice *dev = USB_DEVICE(qdev);
584 USBBus *bus = usb_bus_from_device(dev);
585
586 monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
587 indent, "", bus->busnr, dev->addr,
588 dev->port ? dev->port->path : "-",
589 usb_speed(dev->speed), dev->product_desc,
590 dev->attached ? ", attached" : "");
591}
592
593static char *usb_get_dev_path(DeviceState *qdev)
594{
595 USBDevice *dev = USB_DEVICE(qdev);
596 DeviceState *hcd = qdev->parent_bus->parent;
597 char *id = qdev_get_dev_path(hcd);
598
599 if (id) {
600 char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
601 g_free(id);
602 return ret;
603 } else {
604 return g_strdup(dev->port->path);
605 }
606}
607
608static char *usb_get_fw_dev_path(DeviceState *qdev)
609{
610 USBDevice *dev = USB_DEVICE(qdev);
611 char *fw_path, *in;
612 ssize_t pos = 0, fw_len;
613 long nr;
614
615 fw_len = 32 + strlen(dev->port->path) * 6;
616 fw_path = g_malloc(fw_len);
617 in = dev->port->path;
618 while (fw_len - pos > 0) {
619 nr = strtol(in, &in, 10);
620 if (in[0] == '.') {
621
622 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
623 in++;
624 } else {
625
626 snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
627 qdev_fw_name(qdev), nr);
628 break;
629 }
630 }
631 return fw_path;
632}
633
634void hmp_info_usb(Monitor *mon, const QDict *qdict)
635{
636 USBBus *bus;
637 USBDevice *dev;
638 USBPort *port;
639
640 if (QTAILQ_EMPTY(&busses)) {
641 monitor_printf(mon, "USB support not enabled\n");
642 return;
643 }
644
645 QTAILQ_FOREACH(bus, &busses, next) {
646 QTAILQ_FOREACH(port, &bus->used, next) {
647 dev = port->dev;
648 if (!dev)
649 continue;
650 monitor_printf(mon, " Device %d.%d, Port %s, Speed %s Mb/s, "
651 "Product %s%s%s\n",
652 bus->busnr, dev->addr, port->path,
653 usb_speed(dev->speed), dev->product_desc,
654 dev->qdev.id ? ", ID: " : "",
655 dev->qdev.id ?: "");
656 }
657 }
658}
659
660
661USBDevice *usbdevice_create(const char *driver)
662{
663 USBBus *bus = usb_bus_find(-1 );
664 LegacyUSBFactory *f = NULL;
665 Error *err = NULL;
666 GSList *i;
667 USBDevice *dev;
668
669 if (strchr(driver, ':')) {
670 error_report("usbdevice parameters are not supported anymore");
671 return NULL;
672 }
673
674 for (i = legacy_usb_factory; i; i = i->next) {
675 f = i->data;
676 if (strcmp(f->usbdevice_name, driver) == 0) {
677 break;
678 }
679 }
680 if (i == NULL) {
681#if 0
682
683 error_report("usbdevice %s not found", driver);
684#endif
685 return NULL;
686 }
687
688 if (!bus) {
689 error_report("Error: no usb bus to attach usbdevice %s, "
690 "please try -machine usb=on and check that "
691 "the machine model supports USB", driver);
692 return NULL;
693 }
694
695 dev = f->usbdevice_init ? f->usbdevice_init() : usb_new(f->name);
696 if (!dev) {
697 error_report("Failed to create USB device '%s'", f->name);
698 return NULL;
699 }
700 if (!usb_realize_and_unref(dev, bus, &err)) {
701 error_reportf_err(err, "Failed to initialize USB device '%s': ",
702 f->name);
703 object_unparent(OBJECT(dev));
704 return NULL;
705 }
706 return dev;
707}
708
709static bool usb_get_attached(Object *obj, Error **errp)
710{
711 USBDevice *dev = USB_DEVICE(obj);
712
713 return dev->attached;
714}
715
716static void usb_set_attached(Object *obj, bool value, Error **errp)
717{
718 USBDevice *dev = USB_DEVICE(obj);
719
720 if (dev->attached == value) {
721 return;
722 }
723
724 if (value) {
725 usb_device_attach(dev, errp);
726 } else {
727 usb_device_detach(dev);
728 }
729}
730
731static void usb_device_instance_init(Object *obj)
732{
733 USBDevice *dev = USB_DEVICE(obj);
734 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
735
736 if (klass->attached_settable) {
737 object_property_add_bool(obj, "attached",
738 usb_get_attached, usb_set_attached);
739 } else {
740 object_property_add_bool(obj, "attached",
741 usb_get_attached, NULL);
742 }
743}
744
745static void usb_device_class_init(ObjectClass *klass, void *data)
746{
747 DeviceClass *k = DEVICE_CLASS(klass);
748 k->bus_type = TYPE_USB_BUS;
749 k->realize = usb_qdev_realize;
750 k->unrealize = usb_qdev_unrealize;
751 device_class_set_props(k, usb_props);
752}
753
754static const TypeInfo usb_device_type_info = {
755 .name = TYPE_USB_DEVICE,
756 .parent = TYPE_DEVICE,
757 .instance_size = sizeof(USBDevice),
758 .instance_init = usb_device_instance_init,
759 .abstract = true,
760 .class_size = sizeof(USBDeviceClass),
761 .class_init = usb_device_class_init,
762};
763
764static void usb_register_types(void)
765{
766 type_register_static(&usb_bus_info);
767 type_register_static(&usb_device_type_info);
768}
769
770type_init(usb_register_types)
771
