5 #include "monitor/monitor.h"
8 static void usb_bus_dev_print(Monitor
*mon
, DeviceState
*qdev
, int indent
);
10 static char *usb_get_dev_path(DeviceState
*dev
);
11 static char *usb_get_fw_dev_path(DeviceState
*qdev
);
12 static int usb_qdev_exit(DeviceState
*qdev
);
14 static Property usb_props
[] = {
15 DEFINE_PROP_STRING("port", USBDevice
, port_path
),
16 DEFINE_PROP_BIT("full-path", USBDevice
, flags
,
17 USB_DEV_FLAG_FULL_PATH
, true),
18 DEFINE_PROP_END_OF_LIST()
21 static void usb_bus_class_init(ObjectClass
*klass
, void *data
)
23 BusClass
*k
= BUS_CLASS(klass
);
25 k
->print_dev
= usb_bus_dev_print
;
26 k
->get_dev_path
= usb_get_dev_path
;
27 k
->get_fw_dev_path
= usb_get_fw_dev_path
;
30 static const TypeInfo usb_bus_info
= {
33 .instance_size
= sizeof(USBBus
),
34 .class_init
= usb_bus_class_init
,
37 static int next_usb_bus
= 0;
38 static QTAILQ_HEAD(, USBBus
) busses
= QTAILQ_HEAD_INITIALIZER(busses
);
40 static int usb_device_post_load(void *opaque
, int version_id
)
42 USBDevice
*dev
= opaque
;
44 if (dev
->state
== USB_STATE_NOTATTACHED
) {
52 const VMStateDescription vmstate_usb_device
= {
55 .minimum_version_id
= 1,
56 .post_load
= usb_device_post_load
,
57 .fields
= (VMStateField
[]) {
58 VMSTATE_UINT8(addr
, USBDevice
),
59 VMSTATE_INT32(state
, USBDevice
),
60 VMSTATE_INT32(remote_wakeup
, USBDevice
),
61 VMSTATE_INT32(setup_state
, USBDevice
),
62 VMSTATE_INT32(setup_len
, USBDevice
),
63 VMSTATE_INT32(setup_index
, USBDevice
),
64 VMSTATE_UINT8_ARRAY(setup_buf
, USBDevice
, 8),
65 VMSTATE_END_OF_LIST(),
69 void usb_bus_new(USBBus
*bus
, USBBusOps
*ops
, DeviceState
*host
)
71 qbus_create_inplace(&bus
->qbus
, TYPE_USB_BUS
, host
, NULL
);
73 bus
->busnr
= next_usb_bus
++;
74 bus
->qbus
.allow_hotplug
= 1; /* Yes, we can */
75 QTAILQ_INIT(&bus
->free
);
76 QTAILQ_INIT(&bus
->used
);
77 QTAILQ_INSERT_TAIL(&busses
, bus
, next
);
80 USBBus
*usb_bus_find(int busnr
)
85 return QTAILQ_FIRST(&busses
);
86 QTAILQ_FOREACH(bus
, &busses
, next
) {
87 if (bus
->busnr
== busnr
)
93 static int usb_device_init(USBDevice
*dev
)
95 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
97 return klass
->init(dev
);
102 USBDevice
*usb_device_find_device(USBDevice
*dev
, uint8_t addr
)
104 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
105 if (klass
->find_device
) {
106 return klass
->find_device(dev
, addr
);
111 static void usb_device_handle_destroy(USBDevice
*dev
)
113 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
114 if (klass
->handle_destroy
) {
115 klass
->handle_destroy(dev
);
119 void usb_device_cancel_packet(USBDevice
*dev
, USBPacket
*p
)
121 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
122 if (klass
->cancel_packet
) {
123 klass
->cancel_packet(dev
, p
);
127 void usb_device_handle_attach(USBDevice
*dev
)
129 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
130 if (klass
->handle_attach
) {
131 klass
->handle_attach(dev
);
135 void usb_device_handle_reset(USBDevice
*dev
)
137 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
138 if (klass
->handle_reset
) {
139 klass
->handle_reset(dev
);
143 void usb_device_handle_control(USBDevice
*dev
, USBPacket
*p
, int request
,
144 int value
, int index
, int length
, uint8_t *data
)
146 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
147 if (klass
->handle_control
) {
148 klass
->handle_control(dev
, p
, request
, value
, index
, length
, data
);
152 void usb_device_handle_data(USBDevice
*dev
, USBPacket
*p
)
154 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
155 if (klass
->handle_data
) {
156 klass
->handle_data(dev
, p
);
160 const char *usb_device_get_product_desc(USBDevice
*dev
)
162 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
163 return klass
->product_desc
;
166 const USBDesc
*usb_device_get_usb_desc(USBDevice
*dev
)
168 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
170 return dev
->usb_desc
;
172 return klass
->usb_desc
;
175 void usb_device_set_interface(USBDevice
*dev
, int interface
,
176 int alt_old
, int alt_new
)
178 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
179 if (klass
->set_interface
) {
180 klass
->set_interface(dev
, interface
, alt_old
, alt_new
);
184 void usb_device_flush_ep_queue(USBDevice
*dev
, USBEndpoint
*ep
)
186 USBDeviceClass
*klass
= USB_DEVICE_GET_CLASS(dev
);
187 if (klass
->flush_ep_queue
) {
188 klass
->flush_ep_queue(dev
, ep
);
192 static int usb_qdev_init(DeviceState
*qdev
)
194 USBDevice
*dev
= USB_DEVICE(qdev
);
197 pstrcpy(dev
->product_desc
, sizeof(dev
->product_desc
),
198 usb_device_get_product_desc(dev
));
199 dev
->auto_attach
= 1;
200 QLIST_INIT(&dev
->strings
);
202 rc
= usb_claim_port(dev
);
206 rc
= usb_device_init(dev
);
208 usb_release_port(dev
);
211 if (dev
->auto_attach
) {
212 rc
= usb_device_attach(dev
);
221 static int usb_qdev_exit(DeviceState
*qdev
)
223 USBDevice
*dev
= USB_DEVICE(qdev
);
226 usb_device_detach(dev
);
228 usb_device_handle_destroy(dev
);
230 usb_release_port(dev
);
235 typedef struct LegacyUSBFactory
238 const char *usbdevice_name
;
239 USBDevice
*(*usbdevice_init
)(USBBus
*bus
, const char *params
);
242 static GSList
*legacy_usb_factory
;
244 void usb_legacy_register(const char *typename
, const char *usbdevice_name
,
245 USBDevice
*(*usbdevice_init
)(USBBus
*bus
,
248 if (usbdevice_name
) {
249 LegacyUSBFactory
*f
= g_malloc0(sizeof(*f
));
251 f
->usbdevice_name
= usbdevice_name
;
252 f
->usbdevice_init
= usbdevice_init
;
253 legacy_usb_factory
= g_slist_append(legacy_usb_factory
, f
);
257 USBDevice
*usb_create(USBBus
*bus
, const char *name
)
261 dev
= qdev_create(&bus
->qbus
, name
);
262 return USB_DEVICE(dev
);
265 USBDevice
*usb_create_simple(USBBus
*bus
, const char *name
)
267 USBDevice
*dev
= usb_create(bus
, name
);
271 error_report("Failed to create USB device '%s'", name
);
274 rc
= qdev_init(&dev
->qdev
);
276 error_report("Failed to initialize USB device '%s'", name
);
282 static void usb_fill_port(USBPort
*port
, void *opaque
, int index
,
283 USBPortOps
*ops
, int speedmask
)
285 port
->opaque
= opaque
;
288 port
->speedmask
= speedmask
;
289 usb_port_location(port
, NULL
, index
+ 1);
292 void usb_register_port(USBBus
*bus
, USBPort
*port
, void *opaque
, int index
,
293 USBPortOps
*ops
, int speedmask
)
295 usb_fill_port(port
, opaque
, index
, ops
, speedmask
);
296 QTAILQ_INSERT_TAIL(&bus
->free
, port
, next
);
300 int usb_register_companion(const char *masterbus
, USBPort
*ports
[],
301 uint32_t portcount
, uint32_t firstport
,
302 void *opaque
, USBPortOps
*ops
, int speedmask
)
307 QTAILQ_FOREACH(bus
, &busses
, next
) {
308 if (strcmp(bus
->qbus
.name
, masterbus
) == 0) {
313 if (!bus
|| !bus
->ops
->register_companion
) {
314 qerror_report(QERR_INVALID_PARAMETER_VALUE
, "masterbus",
317 error_printf_unless_qmp(
318 "USB bus '%s' does not allow companion controllers\n",
324 for (i
= 0; i
< portcount
; i
++) {
325 usb_fill_port(ports
[i
], opaque
, i
, ops
, speedmask
);
328 return bus
->ops
->register_companion(bus
, ports
, portcount
, firstport
);
331 void usb_port_location(USBPort
*downstream
, USBPort
*upstream
, int portnr
)
334 snprintf(downstream
->path
, sizeof(downstream
->path
), "%s.%d",
335 upstream
->path
, portnr
);
337 snprintf(downstream
->path
, sizeof(downstream
->path
), "%d", portnr
);
341 void usb_unregister_port(USBBus
*bus
, USBPort
*port
)
344 qdev_free(&port
->dev
->qdev
);
345 QTAILQ_REMOVE(&bus
->free
, port
, next
);
349 int usb_claim_port(USBDevice
*dev
)
351 USBBus
*bus
= usb_bus_from_device(dev
);
354 assert(dev
->port
== NULL
);
356 if (dev
->port_path
) {
357 QTAILQ_FOREACH(port
, &bus
->free
, next
) {
358 if (strcmp(port
->path
, dev
->port_path
) == 0) {
363 error_report("Error: usb port %s (bus %s) not found (in use?)",
364 dev
->port_path
, bus
->qbus
.name
);
368 if (bus
->nfree
== 1 && strcmp(object_get_typename(OBJECT(dev
)), "usb-hub") != 0) {
369 /* Create a new hub and chain it on */
370 usb_create_simple(bus
, "usb-hub");
372 if (bus
->nfree
== 0) {
373 error_report("Error: tried to attach usb device %s to a bus "
374 "with no free ports", dev
->product_desc
);
377 port
= QTAILQ_FIRST(&bus
->free
);
379 trace_usb_port_claim(bus
->busnr
, port
->path
);
381 QTAILQ_REMOVE(&bus
->free
, port
, next
);
387 QTAILQ_INSERT_TAIL(&bus
->used
, port
, next
);
392 void usb_release_port(USBDevice
*dev
)
394 USBBus
*bus
= usb_bus_from_device(dev
);
395 USBPort
*port
= dev
->port
;
397 assert(port
!= NULL
);
398 trace_usb_port_release(bus
->busnr
, port
->path
);
400 QTAILQ_REMOVE(&bus
->used
, port
, next
);
406 QTAILQ_INSERT_TAIL(&bus
->free
, port
, next
);
410 int usb_device_attach(USBDevice
*dev
)
412 USBBus
*bus
= usb_bus_from_device(dev
);
413 USBPort
*port
= dev
->port
;
415 assert(port
!= NULL
);
416 assert(!dev
->attached
);
417 trace_usb_port_attach(bus
->busnr
, port
->path
);
419 if (!(port
->speedmask
& dev
->speedmask
)) {
420 error_report("Warning: speed mismatch trying to attach "
421 "usb device %s to bus %s",
422 dev
->product_desc
, bus
->qbus
.name
);
432 int usb_device_detach(USBDevice
*dev
)
434 USBBus
*bus
= usb_bus_from_device(dev
);
435 USBPort
*port
= dev
->port
;
437 assert(port
!= NULL
);
438 assert(dev
->attached
);
439 trace_usb_port_detach(bus
->busnr
, port
->path
);
446 int usb_device_delete_addr(int busnr
, int addr
)
452 bus
= usb_bus_find(busnr
);
456 QTAILQ_FOREACH(port
, &bus
->used
, next
) {
457 if (port
->dev
->addr
== addr
)
464 qdev_free(&dev
->qdev
);
468 static const char *usb_speed(unsigned int speed
)
470 static const char *txt
[] = {
471 [ USB_SPEED_LOW
] = "1.5",
472 [ USB_SPEED_FULL
] = "12",
473 [ USB_SPEED_HIGH
] = "480",
474 [ USB_SPEED_SUPER
] = "5000",
476 if (speed
>= ARRAY_SIZE(txt
))
481 static void usb_bus_dev_print(Monitor
*mon
, DeviceState
*qdev
, int indent
)
483 USBDevice
*dev
= USB_DEVICE(qdev
);
484 USBBus
*bus
= usb_bus_from_device(dev
);
486 monitor_printf(mon
, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
487 indent
, "", bus
->busnr
, dev
->addr
,
488 dev
->port
? dev
->port
->path
: "-",
489 usb_speed(dev
->speed
), dev
->product_desc
,
490 dev
->attached
? ", attached" : "");
493 static char *usb_get_dev_path(DeviceState
*qdev
)
495 USBDevice
*dev
= USB_DEVICE(qdev
);
496 DeviceState
*hcd
= qdev
->parent_bus
->parent
;
499 if (dev
->flags
& (1 << USB_DEV_FLAG_FULL_PATH
)) {
500 id
= qdev_get_dev_path(hcd
);
503 char *ret
= g_strdup_printf("%s/%s", id
, dev
->port
->path
);
507 return g_strdup(dev
->port
->path
);
511 static char *usb_get_fw_dev_path(DeviceState
*qdev
)
513 USBDevice
*dev
= USB_DEVICE(qdev
);
515 ssize_t pos
= 0, fw_len
;
518 fw_len
= 32 + strlen(dev
->port
->path
) * 6;
519 fw_path
= g_malloc(fw_len
);
520 in
= dev
->port
->path
;
521 while (fw_len
- pos
> 0) {
522 nr
= strtol(in
, &in
, 10);
524 /* some hub between root port and device */
525 pos
+= snprintf(fw_path
+ pos
, fw_len
- pos
, "hub@%ld/", nr
);
528 /* the device itself */
529 pos
+= snprintf(fw_path
+ pos
, fw_len
- pos
, "%s@%ld",
530 qdev_fw_name(qdev
), nr
);
537 void usb_info(Monitor
*mon
)
543 if (QTAILQ_EMPTY(&busses
)) {
544 monitor_printf(mon
, "USB support not enabled\n");
548 QTAILQ_FOREACH(bus
, &busses
, next
) {
549 QTAILQ_FOREACH(port
, &bus
->used
, next
) {
553 monitor_printf(mon
, " Device %d.%d, Port %s, Speed %s Mb/s, Product %s\n",
554 bus
->busnr
, dev
->addr
, port
->path
, usb_speed(dev
->speed
),
560 /* handle legacy -usbdevice cmd line option */
561 USBDevice
*usbdevice_create(const char *cmdline
)
563 USBBus
*bus
= usb_bus_find(-1 /* any */);
564 LegacyUSBFactory
*f
= NULL
;
570 params
= strchr(cmdline
,':');
573 len
= params
- cmdline
;
574 if (len
> sizeof(driver
))
575 len
= sizeof(driver
);
576 pstrcpy(driver
, len
, cmdline
);
579 pstrcpy(driver
, sizeof(driver
), cmdline
);
582 for (i
= legacy_usb_factory
; i
; i
= i
->next
) {
584 if (strcmp(f
->usbdevice_name
, driver
) == 0) {
590 /* no error because some drivers are not converted (yet) */
591 error_report("usbdevice %s not found", driver
);
597 error_report("Error: no usb bus to attach usbdevice %s, "
598 "please try -machine usb=on and check that "
599 "the machine model supports USB", driver
);
603 if (!f
->usbdevice_init
) {
605 error_report("usbdevice %s accepts no params", driver
);
608 return usb_create_simple(bus
, f
->name
);
610 return f
->usbdevice_init(bus
, params
);
613 static void usb_device_class_init(ObjectClass
*klass
, void *data
)
615 DeviceClass
*k
= DEVICE_CLASS(klass
);
616 k
->bus_type
= TYPE_USB_BUS
;
617 k
->init
= usb_qdev_init
;
618 k
->unplug
= qdev_simple_unplug_cb
;
619 k
->exit
= usb_qdev_exit
;
620 k
->props
= usb_props
;
623 static TypeInfo usb_device_type_info
= {
624 .name
= TYPE_USB_DEVICE
,
625 .parent
= TYPE_DEVICE
,
626 .instance_size
= sizeof(USBDevice
),
628 .class_size
= sizeof(USBDeviceClass
),
629 .class_init
= usb_device_class_init
,
632 static void usb_register_types(void)
634 type_register_static(&usb_bus_info
);
635 type_register_static(&usb_device_type_info
);
638 type_init(usb_register_types
)