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