2016-01-26 19:17:12 +01:00
|
|
|
#include "qemu/osdep.h"
|
2019-08-12 07:23:51 +02:00
|
|
|
#include "hw/qdev-properties.h"
|
2012-03-07 14:55:18 +01:00
|
|
|
#include "hw/usb.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2015-03-17 18:29:20 +01:00
|
|
|
#include "qemu/error-report.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2019-08-12 07:23:45 +02:00
|
|
|
#include "migration/vmstate.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "monitor/monitor.h"
|
2011-09-01 13:56:37 +02:00
|
|
|
#include "trace.h"
|
2016-03-20 18:16:19 +01:00
|
|
|
#include "qemu/cutils.h"
|
2009-08-31 14:24:00 +02:00
|
|
|
|
|
|
|
static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent);
|
2010-12-10 11:37:45 +01:00
|
|
|
|
|
|
|
static char *usb_get_dev_path(DeviceState *dev);
|
2011-01-12 10:58:27 +01:00
|
|
|
static char *usb_get_fw_dev_path(DeviceState *qdev);
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
static void usb_qdev_unrealize(DeviceState *qdev);
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2012-03-28 18:01:36 +02:00
|
|
|
static Property usb_props[] = {
|
|
|
|
DEFINE_PROP_STRING("port", USBDevice, port_path),
|
2013-06-12 13:01:49 +02:00
|
|
|
DEFINE_PROP_STRING("serial", USBDevice, serial),
|
2012-03-28 18:01:36 +02:00
|
|
|
DEFINE_PROP_BIT("full-path", USBDevice, flags,
|
|
|
|
USB_DEV_FLAG_FULL_PATH, true),
|
2013-11-20 07:32:31 +01:00
|
|
|
DEFINE_PROP_BIT("msos-desc", USBDevice, flags,
|
|
|
|
USB_DEV_FLAG_MSOS_DESC_ENABLE, true),
|
2012-03-28 18:01:36 +02:00
|
|
|
DEFINE_PROP_END_OF_LIST()
|
|
|
|
};
|
|
|
|
|
2012-05-02 09:00:20 +02:00
|
|
|
static void usb_bus_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
BusClass *k = BUS_CLASS(klass);
|
2014-09-26 11:28:39 +02:00
|
|
|
HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass);
|
2012-05-02 09:00:20 +02:00
|
|
|
|
|
|
|
k->print_dev = usb_bus_dev_print;
|
|
|
|
k->get_dev_path = usb_get_dev_path;
|
|
|
|
k->get_fw_dev_path = usb_get_fw_dev_path;
|
2014-09-26 11:28:39 +02:00
|
|
|
hc->unplug = qdev_simple_device_unplug_cb;
|
2012-05-02 09:00:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo usb_bus_info = {
|
|
|
|
.name = TYPE_USB_BUS,
|
|
|
|
.parent = TYPE_BUS,
|
|
|
|
.instance_size = sizeof(USBBus),
|
|
|
|
.class_init = usb_bus_class_init,
|
2014-09-26 11:28:39 +02:00
|
|
|
.interfaces = (InterfaceInfo[]) {
|
|
|
|
{ TYPE_HOTPLUG_HANDLER },
|
|
|
|
{ }
|
|
|
|
}
|
2009-08-31 14:23:59 +02:00
|
|
|
};
|
2012-03-28 18:01:36 +02:00
|
|
|
|
2009-08-31 14:23:59 +02:00
|
|
|
static int next_usb_bus = 0;
|
2009-09-12 09:36:22 +02:00
|
|
|
static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses);
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2012-06-08 12:58:46 +02:00
|
|
|
static int usb_device_post_load(void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
USBDevice *dev = opaque;
|
|
|
|
|
|
|
|
if (dev->state == USB_STATE_NOTATTACHED) {
|
2016-06-15 11:46:56 +02:00
|
|
|
dev->attached = false;
|
2012-06-08 12:58:46 +02:00
|
|
|
} else {
|
2016-06-15 11:46:56 +02:00
|
|
|
dev->attached = true;
|
2012-06-08 12:58:46 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-10 14:20:46 +01:00
|
|
|
const VMStateDescription vmstate_usb_device = {
|
|
|
|
.name = "USBDevice",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2012-06-08 12:58:46 +02:00
|
|
|
.post_load = usb_device_post_load,
|
2014-04-16 13:31:26 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2010-12-10 14:20:46 +01:00
|
|
|
VMSTATE_UINT8(addr, USBDevice),
|
|
|
|
VMSTATE_INT32(state, USBDevice),
|
|
|
|
VMSTATE_INT32(remote_wakeup, USBDevice),
|
|
|
|
VMSTATE_INT32(setup_state, USBDevice),
|
|
|
|
VMSTATE_INT32(setup_len, USBDevice),
|
|
|
|
VMSTATE_INT32(setup_index, USBDevice),
|
|
|
|
VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8),
|
|
|
|
VMSTATE_END_OF_LIST(),
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-08-23 20:32:04 +02:00
|
|
|
void usb_bus_new(USBBus *bus, size_t bus_size,
|
|
|
|
USBBusOps *ops, DeviceState *host)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2013-08-24 00:02:27 +02:00
|
|
|
qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL);
|
2014-09-26 11:28:39 +02:00
|
|
|
qbus_set_bus_hotplug_handler(BUS(bus), &error_abort);
|
2011-05-23 17:37:12 +02:00
|
|
|
bus->ops = ops;
|
2009-08-31 14:23:59 +02:00
|
|
|
bus->busnr = next_usb_bus++;
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INIT(&bus->free);
|
|
|
|
QTAILQ_INIT(&bus->used);
|
|
|
|
QTAILQ_INSERT_TAIL(&busses, bus, next);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
|
|
|
|
2014-06-04 10:31:46 +02:00
|
|
|
void usb_bus_release(USBBus *bus)
|
|
|
|
{
|
|
|
|
assert(next_usb_bus > 0);
|
|
|
|
|
|
|
|
QTAILQ_REMOVE(&busses, bus, next);
|
|
|
|
}
|
|
|
|
|
2009-08-31 14:23:59 +02:00
|
|
|
USBBus *usb_bus_find(int busnr)
|
|
|
|
{
|
|
|
|
USBBus *bus;
|
|
|
|
|
|
|
|
if (-1 == busnr)
|
2009-09-12 09:36:22 +02:00
|
|
|
return QTAILQ_FIRST(&busses);
|
|
|
|
QTAILQ_FOREACH(bus, &busses, next) {
|
2009-08-31 14:23:59 +02:00
|
|
|
if (bus->busnr == busnr)
|
|
|
|
return bus;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-19 08:48:24 +02:00
|
|
|
static void usb_device_realize(USBDevice *dev, Error **errp)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
2014-09-19 08:48:24 +02:00
|
|
|
|
|
|
|
if (klass->realize) {
|
|
|
|
klass->realize(dev, errp);
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-10 16:59:28 +01:00
|
|
|
USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
2012-01-10 16:59:28 +01:00
|
|
|
if (klass->find_device) {
|
|
|
|
return klass->find_device(dev, addr);
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
2012-01-10 16:59:28 +01:00
|
|
|
return NULL;
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
static void usb_device_unrealize(USBDevice *dev)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
2017-02-21 15:14:45 +01:00
|
|
|
|
|
|
|
if (klass->unrealize) {
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
klass->unrealize(dev);
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_device_cancel_packet(USBDevice *dev, USBPacket *p)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->cancel_packet) {
|
|
|
|
klass->cancel_packet(dev, p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_device_handle_attach(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->handle_attach) {
|
|
|
|
klass->handle_attach(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_device_handle_reset(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->handle_reset) {
|
|
|
|
klass->handle_reset(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
|
|
|
|
int value, int index, int length, uint8_t *data)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->handle_control) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
klass->handle_control(dev, p, request, value, index, length, data);
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
void usb_device_handle_data(USBDevice *dev, USBPacket *p)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->handle_data) {
|
usb: split packet result into actual_length + status
Since with the ehci and xhci controllers a single packet can be larger
then maxpacketsize, it is possible for the result of a single packet
to be both having transferred some data as well as the transfer to have
an error.
An example would be an input transfer from a bulk endpoint successfully
receiving 1 or more maxpacketsize packets from the device, followed
by a packet signalling halt.
While already touching all the devices and controllers handle_packet /
handle_data / handle_control code, also change the return type of
these functions to void, solely storing the status in the packet. To
make the code paths for regular versus async packet handling more
uniform.
This patch unfortunately is somewhat invasive, since makeing the qemu
usb core deal with this requires changes everywhere. This patch only
prepares the usb core for this, all the hcd / device changes are done
in such a way that there are no functional changes.
This patch has been tested with uhci and ehci hcds, together with usb-audio,
usb-hid and usb-storage devices, as well as with usb-redir redirection
with a wide variety of real devices.
Note that there is usually no need to directly set packet->actual_length
form devices handle_data callback, as that is done by usb_packet_copy()
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-11-01 17:15:01 +01:00
|
|
|
klass->handle_data(dev, p);
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *usb_device_get_product_desc(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
return klass->product_desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
const USBDesc *usb_device_get_usb_desc(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
2012-11-17 12:47:16 +01:00
|
|
|
if (dev->usb_desc) {
|
|
|
|
return dev->usb_desc;
|
|
|
|
}
|
2011-12-15 21:53:10 +01:00
|
|
|
return klass->usb_desc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_device_set_interface(USBDevice *dev, int interface,
|
|
|
|
int alt_old, int alt_new)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->set_interface) {
|
|
|
|
klass->set_interface(dev, interface, alt_old, alt_new);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-24 18:14:07 +02:00
|
|
|
void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->flush_ep_queue) {
|
|
|
|
klass->flush_ep_queue(dev, ep);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-14 14:35:40 +01:00
|
|
|
void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->ep_stopped) {
|
|
|
|
klass->ep_stopped(dev, ep);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-19 14:36:57 +01:00
|
|
|
int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
|
|
|
|
int streams)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->alloc_streams) {
|
|
|
|
return klass->alloc_streams(dev, eps, nr_eps, streams);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps)
|
|
|
|
{
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
if (klass->free_streams) {
|
|
|
|
klass->free_streams(dev, eps, nr_eps);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-19 08:48:24 +02:00
|
|
|
static void usb_qdev_realize(DeviceState *qdev, Error **errp)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDevice *dev = USB_DEVICE(qdev);
|
2014-09-19 08:48:24 +02:00
|
|
|
Error *local_err = NULL;
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2011-12-15 21:53:10 +01:00
|
|
|
pstrcpy(dev->product_desc, sizeof(dev->product_desc),
|
|
|
|
usb_device_get_product_desc(dev));
|
2009-10-26 15:56:48 +01:00
|
|
|
dev->auto_attach = 1;
|
2010-11-26 12:25:32 +01:00
|
|
|
QLIST_INIT(&dev->strings);
|
2011-08-29 12:49:46 +02:00
|
|
|
usb_ep_init(dev);
|
2014-09-19 08:48:24 +02:00
|
|
|
|
|
|
|
usb_claim_port(dev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
2011-09-01 13:56:37 +02:00
|
|
|
}
|
2014-09-19 08:48:24 +02:00
|
|
|
|
|
|
|
usb_device_realize(dev, &local_err);
|
|
|
|
if (local_err) {
|
2011-12-15 11:05:18 +01:00
|
|
|
usb_release_port(dev);
|
2014-09-19 08:48:24 +02:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
2011-11-22 12:48:14 +01:00
|
|
|
}
|
2014-09-19 08:48:24 +02:00
|
|
|
|
2011-11-22 12:48:14 +01:00
|
|
|
if (dev->auto_attach) {
|
2014-09-19 08:48:24 +02:00
|
|
|
usb_device_attach(dev, &local_err);
|
|
|
|
if (local_err) {
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
usb_qdev_unrealize(qdev);
|
2014-09-19 08:48:24 +02:00
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
2011-11-22 12:48:14 +01:00
|
|
|
}
|
2011-09-01 13:56:37 +02:00
|
|
|
}
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
|
|
|
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
static void usb_qdev_unrealize(DeviceState *qdev)
|
2009-09-25 21:42:39 +02:00
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDevice *dev = USB_DEVICE(qdev);
|
2016-07-15 11:14:07 +02:00
|
|
|
USBDescString *s, *next;
|
|
|
|
|
|
|
|
QLIST_FOREACH_SAFE(s, &dev->strings, next, next) {
|
|
|
|
QLIST_REMOVE(s, next);
|
|
|
|
g_free(s->str);
|
|
|
|
g_free(s);
|
|
|
|
}
|
2009-09-25 21:42:39 +02:00
|
|
|
|
2011-05-31 11:35:29 +02:00
|
|
|
if (dev->attached) {
|
|
|
|
usb_device_detach(dev);
|
|
|
|
}
|
qdev: Unrealize must not fail
Devices may have component devices and buses.
Device realization may fail. Realization is recursive: a device's
realize() method realizes its components, and device_set_realized()
realizes its buses (which should in turn realize the devices on that
bus, except bus_set_realized() doesn't implement that, yet).
When realization of a component or bus fails, we need to roll back:
unrealize everything we realized so far. If any of these unrealizes
failed, the device would be left in an inconsistent state. Must not
happen.
device_set_realized() lets it happen: it ignores errors in the roll
back code starting at label child_realize_fail.
Since realization is recursive, unrealization must be recursive, too.
But how could a partly failed unrealize be rolled back? We'd have to
re-realize, which can fail. This design is fundamentally broken.
device_set_realized() does not roll back at all. Instead, it keeps
unrealizing, ignoring further errors.
It can screw up even for a device with no buses: if the lone
dc->unrealize() fails, it still unregisters vmstate, and calls
listeners' unrealize() callback.
bus_set_realized() does not roll back either. Instead, it stops
unrealizing.
Fortunately, no unrealize method can fail, as we'll see below.
To fix the design error, drop parameter @errp from all the unrealize
methods.
Any unrealize method that uses @errp now needs an update. This leads
us to unrealize() methods that can fail. Merely passing it to another
unrealize method cannot cause failure, though. Here are the ones that
do other things with @errp:
* virtio_serial_device_unrealize()
Fails when qbus_set_hotplug_handler() fails, but still does all the
other work. On failure, the device would stay realized with its
resources completely gone. Oops. Can't happen, because
qbus_set_hotplug_handler() can't actually fail here. Pass
&error_abort to qbus_set_hotplug_handler() instead.
* hw/ppc/spapr_drc.c's unrealize()
Fails when object_property_del() fails, but all the other work is
already done. On failure, the device would stay realized with its
vmstate registration gone. Oops. Can't happen, because
object_property_del() can't actually fail here. Pass &error_abort
to object_property_del() instead.
* spapr_phb_unrealize()
Fails and bails out when remove_drcs() fails, but other work is
already done. On failure, the device would stay realized with some
of its resources gone. Oops. remove_drcs() fails only when
chassis_from_bus()'s object_property_get_uint() fails, and it can't
here. Pass &error_abort to remove_drcs() instead.
Therefore, no unrealize method can fail before this patch.
device_set_realized()'s recursive unrealization via bus uses
object_property_set_bool(). Can't drop @errp there, so pass
&error_abort.
We similarly unrealize with object_property_set_bool() elsewhere,
always ignoring errors. Pass &error_abort instead.
Several unrealize methods no longer handle errors from other unrealize
methods: virtio_9p_device_unrealize(),
virtio_input_device_unrealize(), scsi_qdev_unrealize(), ...
Much of the deleted error handling looks wrong anyway.
One unrealize methods no longer ignore such errors:
usb_ehci_pci_exit().
Several realize methods no longer ignore errors when rolling back:
v9fs_device_realize_common(), pci_qdev_unrealize(),
spapr_phb_realize(), usb_qdev_realize(), vfio_ccw_realize(),
virtio_device_realize().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-17-armbru@redhat.com>
2020-05-05 17:29:24 +02:00
|
|
|
usb_device_unrealize(dev);
|
2011-09-01 13:56:37 +02:00
|
|
|
if (dev->port) {
|
|
|
|
usb_release_port(dev);
|
|
|
|
}
|
2009-09-25 21:42:39 +02:00
|
|
|
}
|
|
|
|
|
2011-12-15 21:53:10 +01:00
|
|
|
typedef struct LegacyUSBFactory
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
const char *name;
|
|
|
|
const char *usbdevice_name;
|
2012-02-27 15:18:47 +01:00
|
|
|
USBDevice *(*usbdevice_init)(USBBus *bus, const char *params);
|
2011-12-15 21:53:10 +01:00
|
|
|
} LegacyUSBFactory;
|
2009-08-31 14:23:59 +02:00
|
|
|
|
2011-12-15 21:53:10 +01:00
|
|
|
static GSList *legacy_usb_factory;
|
|
|
|
|
2011-12-08 21:56:53 +01:00
|
|
|
void usb_legacy_register(const char *typename, const char *usbdevice_name,
|
2012-02-27 15:18:47 +01:00
|
|
|
USBDevice *(*usbdevice_init)(USBBus *bus,
|
|
|
|
const char *params))
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
if (usbdevice_name) {
|
|
|
|
LegacyUSBFactory *f = g_malloc0(sizeof(*f));
|
2011-12-08 21:56:53 +01:00
|
|
|
f->name = typename;
|
2011-12-15 21:53:10 +01:00
|
|
|
f->usbdevice_name = usbdevice_name;
|
|
|
|
f->usbdevice_init = usbdevice_init;
|
|
|
|
legacy_usb_factory = g_slist_append(legacy_usb_factory, f);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-31 14:24:00 +02:00
|
|
|
USBDevice *usb_create(USBBus *bus, const char *name)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
|
|
|
DeviceState *dev;
|
|
|
|
|
|
|
|
dev = qdev_create(&bus->qbus, name);
|
2011-12-15 21:53:10 +01:00
|
|
|
return USB_DEVICE(dev);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
2009-08-31 14:24:00 +02:00
|
|
|
|
usb: Suppress bogus error when automatic usb-hub creation fails
USBDevice's realize method usb_qdev_realize() automatically creates a
usb-hub when only one port is left. Creating devices in realize
methods is questionable, but works.
If usb-hub creation fails, an error is reported to stderr, but the
failure is otherwise ignored. We then create the actual device using
the last port, which may well succeed.
Example:
$ qemu -nodefaults -S -display none -machine usb=on -monitor stdio
QEMU 2.2.50 monitor - type 'help' for more information
(qemu) device_add usb-mouse
[Repeat 36 times]
(qemu) info usb
Device 0.0, Port 1, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2, Speed 12 Mb/s, Product QEMU USB Hub
Device 0.0, Port 2.1, Speed 12 Mb/s, Product QEMU USB Mouse
[More mice and hubs omitted...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
(qemu) device_add usb-mouse
usb hub chain too deep
Failed to initialize USB device 'usb-hub'
(qemu) info usb
[...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2.8.8.8.8.8, Speed 12 Mb/s, Product QEMU USB Mouse
Despite the "Failed" message, the command actually succeeded.
In QMP, it's worse. When adding the 37th mouse via QMP, the command
fails with
{"error": {"class": "GenericError", "desc": "usb hub chain too deep"}}
Additionally, "Failed to initialize USB device 'usb-hub'" is reported
on stderr. Despite the command failure, the device was created. This
is wrong.
Fix by avoiding qdev_init() for usb-hub creation, so we can ignore
errors cleanly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2015-02-04 13:28:11 +01:00
|
|
|
static USBDevice *usb_try_create_simple(USBBus *bus, const char *name,
|
|
|
|
Error **errp)
|
2009-08-31 14:24:00 +02:00
|
|
|
{
|
usb: Suppress bogus error when automatic usb-hub creation fails
USBDevice's realize method usb_qdev_realize() automatically creates a
usb-hub when only one port is left. Creating devices in realize
methods is questionable, but works.
If usb-hub creation fails, an error is reported to stderr, but the
failure is otherwise ignored. We then create the actual device using
the last port, which may well succeed.
Example:
$ qemu -nodefaults -S -display none -machine usb=on -monitor stdio
QEMU 2.2.50 monitor - type 'help' for more information
(qemu) device_add usb-mouse
[Repeat 36 times]
(qemu) info usb
Device 0.0, Port 1, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2, Speed 12 Mb/s, Product QEMU USB Hub
Device 0.0, Port 2.1, Speed 12 Mb/s, Product QEMU USB Mouse
[More mice and hubs omitted...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
(qemu) device_add usb-mouse
usb hub chain too deep
Failed to initialize USB device 'usb-hub'
(qemu) info usb
[...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2.8.8.8.8.8, Speed 12 Mb/s, Product QEMU USB Mouse
Despite the "Failed" message, the command actually succeeded.
In QMP, it's worse. When adding the 37th mouse via QMP, the command
fails with
{"error": {"class": "GenericError", "desc": "usb hub chain too deep"}}
Additionally, "Failed to initialize USB device 'usb-hub'" is reported
on stderr. Despite the command failure, the device was created. This
is wrong.
Fix by avoiding qdev_init() for usb-hub creation, so we can ignore
errors cleanly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2015-02-04 13:28:11 +01:00
|
|
|
Error *err = NULL;
|
|
|
|
USBDevice *dev;
|
2011-11-22 12:39:58 +01:00
|
|
|
|
usb: Suppress bogus error when automatic usb-hub creation fails
USBDevice's realize method usb_qdev_realize() automatically creates a
usb-hub when only one port is left. Creating devices in realize
methods is questionable, but works.
If usb-hub creation fails, an error is reported to stderr, but the
failure is otherwise ignored. We then create the actual device using
the last port, which may well succeed.
Example:
$ qemu -nodefaults -S -display none -machine usb=on -monitor stdio
QEMU 2.2.50 monitor - type 'help' for more information
(qemu) device_add usb-mouse
[Repeat 36 times]
(qemu) info usb
Device 0.0, Port 1, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2, Speed 12 Mb/s, Product QEMU USB Hub
Device 0.0, Port 2.1, Speed 12 Mb/s, Product QEMU USB Mouse
[More mice and hubs omitted...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
(qemu) device_add usb-mouse
usb hub chain too deep
Failed to initialize USB device 'usb-hub'
(qemu) info usb
[...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2.8.8.8.8.8, Speed 12 Mb/s, Product QEMU USB Mouse
Despite the "Failed" message, the command actually succeeded.
In QMP, it's worse. When adding the 37th mouse via QMP, the command
fails with
{"error": {"class": "GenericError", "desc": "usb hub chain too deep"}}
Additionally, "Failed to initialize USB device 'usb-hub'" is reported
on stderr. Despite the command failure, the device was created. This
is wrong.
Fix by avoiding qdev_init() for usb-hub creation, so we can ignore
errors cleanly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2015-02-04 13:28:11 +01:00
|
|
|
dev = USB_DEVICE(qdev_try_create(&bus->qbus, name));
|
|
|
|
if (!dev) {
|
|
|
|
error_setg(errp, "Failed to create USB device '%s'", name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
object_property_set_bool(OBJECT(dev), true, "realized", &err);
|
|
|
|
if (err) {
|
2018-10-17 10:26:25 +02:00
|
|
|
error_propagate_prepend(errp, err,
|
|
|
|
"Failed to initialize USB device '%s': ",
|
|
|
|
name);
|
2011-11-22 12:39:58 +01:00
|
|
|
return NULL;
|
2010-02-25 14:29:06 +01:00
|
|
|
}
|
2009-08-31 14:24:00 +02:00
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
usb: Suppress bogus error when automatic usb-hub creation fails
USBDevice's realize method usb_qdev_realize() automatically creates a
usb-hub when only one port is left. Creating devices in realize
methods is questionable, but works.
If usb-hub creation fails, an error is reported to stderr, but the
failure is otherwise ignored. We then create the actual device using
the last port, which may well succeed.
Example:
$ qemu -nodefaults -S -display none -machine usb=on -monitor stdio
QEMU 2.2.50 monitor - type 'help' for more information
(qemu) device_add usb-mouse
[Repeat 36 times]
(qemu) info usb
Device 0.0, Port 1, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2, Speed 12 Mb/s, Product QEMU USB Hub
Device 0.0, Port 2.1, Speed 12 Mb/s, Product QEMU USB Mouse
[More mice and hubs omitted...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
(qemu) device_add usb-mouse
usb hub chain too deep
Failed to initialize USB device 'usb-hub'
(qemu) info usb
[...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2.8.8.8.8.8, Speed 12 Mb/s, Product QEMU USB Mouse
Despite the "Failed" message, the command actually succeeded.
In QMP, it's worse. When adding the 37th mouse via QMP, the command
fails with
{"error": {"class": "GenericError", "desc": "usb hub chain too deep"}}
Additionally, "Failed to initialize USB device 'usb-hub'" is reported
on stderr. Despite the command failure, the device was created. This
is wrong.
Fix by avoiding qdev_init() for usb-hub creation, so we can ignore
errors cleanly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2015-02-04 13:28:11 +01:00
|
|
|
USBDevice *usb_create_simple(USBBus *bus, const char *name)
|
|
|
|
{
|
2015-02-04 13:28:12 +01:00
|
|
|
return usb_try_create_simple(bus, name, &error_abort);
|
usb: Suppress bogus error when automatic usb-hub creation fails
USBDevice's realize method usb_qdev_realize() automatically creates a
usb-hub when only one port is left. Creating devices in realize
methods is questionable, but works.
If usb-hub creation fails, an error is reported to stderr, but the
failure is otherwise ignored. We then create the actual device using
the last port, which may well succeed.
Example:
$ qemu -nodefaults -S -display none -machine usb=on -monitor stdio
QEMU 2.2.50 monitor - type 'help' for more information
(qemu) device_add usb-mouse
[Repeat 36 times]
(qemu) info usb
Device 0.0, Port 1, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2, Speed 12 Mb/s, Product QEMU USB Hub
Device 0.0, Port 2.1, Speed 12 Mb/s, Product QEMU USB Mouse
[More mice and hubs omitted...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
(qemu) device_add usb-mouse
usb hub chain too deep
Failed to initialize USB device 'usb-hub'
(qemu) info usb
[...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2.8.8.8.8.8, Speed 12 Mb/s, Product QEMU USB Mouse
Despite the "Failed" message, the command actually succeeded.
In QMP, it's worse. When adding the 37th mouse via QMP, the command
fails with
{"error": {"class": "GenericError", "desc": "usb hub chain too deep"}}
Additionally, "Failed to initialize USB device 'usb-hub'" is reported
on stderr. Despite the command failure, the device was created. This
is wrong.
Fix by avoiding qdev_init() for usb-hub creation, so we can ignore
errors cleanly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2015-02-04 13:28:11 +01:00
|
|
|
}
|
|
|
|
|
2011-06-30 11:57:57 +02:00
|
|
|
static void usb_fill_port(USBPort *port, void *opaque, int index,
|
|
|
|
USBPortOps *ops, int speedmask)
|
2009-08-31 14:24:00 +02:00
|
|
|
{
|
2010-12-01 11:08:44 +01:00
|
|
|
port->opaque = opaque;
|
|
|
|
port->index = index;
|
|
|
|
port->ops = ops;
|
2010-12-03 17:30:13 +01:00
|
|
|
port->speedmask = speedmask;
|
2011-06-30 12:05:19 +02:00
|
|
|
usb_port_location(port, NULL, index + 1);
|
2011-06-30 11:57:57 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
|
|
|
|
USBPortOps *ops, int speedmask)
|
|
|
|
{
|
|
|
|
usb_fill_port(port, opaque, index, ops, speedmask);
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_TAIL(&bus->free, port, next);
|
2009-08-31 14:24:00 +02:00
|
|
|
bus->nfree++;
|
|
|
|
}
|
|
|
|
|
2015-02-17 14:28:02 +01:00
|
|
|
void usb_register_companion(const char *masterbus, USBPort *ports[],
|
|
|
|
uint32_t portcount, uint32_t firstport,
|
|
|
|
void *opaque, USBPortOps *ops, int speedmask,
|
|
|
|
Error **errp)
|
2011-06-24 11:29:56 +02:00
|
|
|
{
|
|
|
|
USBBus *bus;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(bus, &busses, next) {
|
|
|
|
if (strcmp(bus->qbus.name, masterbus) == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-17 14:28:03 +01:00
|
|
|
if (!bus) {
|
|
|
|
error_setg(errp, "USB bus '%s' not found", masterbus);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!bus->ops->register_companion) {
|
|
|
|
error_setg(errp, "Can't use USB bus '%s' as masterbus,"
|
|
|
|
" it doesn't support companion controllers",
|
|
|
|
masterbus);
|
2015-02-17 14:28:02 +01:00
|
|
|
return;
|
2011-06-24 11:29:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < portcount; i++) {
|
|
|
|
usb_fill_port(ports[i], opaque, i, ops, speedmask);
|
|
|
|
}
|
|
|
|
|
2015-02-17 14:28:02 +01:00
|
|
|
bus->ops->register_companion(bus, ports, portcount, firstport, errp);
|
2011-06-24 11:29:56 +02:00
|
|
|
}
|
|
|
|
|
2010-12-10 11:37:45 +01:00
|
|
|
void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr)
|
|
|
|
{
|
|
|
|
if (upstream) {
|
2017-07-17 17:13:34 +02:00
|
|
|
int l = snprintf(downstream->path, sizeof(downstream->path), "%s.%d",
|
|
|
|
upstream->path, portnr);
|
|
|
|
/* Max string is nn.nn.nn.nn.nn, which fits in 16 bytes */
|
|
|
|
assert(l < sizeof(downstream->path));
|
2013-03-20 11:40:02 +01:00
|
|
|
downstream->hubcount = upstream->hubcount + 1;
|
2010-12-10 11:37:45 +01:00
|
|
|
} else {
|
|
|
|
snprintf(downstream->path, sizeof(downstream->path), "%d", portnr);
|
2013-03-20 11:40:02 +01:00
|
|
|
downstream->hubcount = 0;
|
2010-12-10 11:37:45 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-25 21:42:39 +02:00
|
|
|
void usb_unregister_port(USBBus *bus, USBPort *port)
|
|
|
|
{
|
2013-09-11 14:54:09 +02:00
|
|
|
if (port->dev) {
|
|
|
|
object_unparent(OBJECT(port->dev));
|
|
|
|
}
|
2009-09-25 21:42:39 +02:00
|
|
|
QTAILQ_REMOVE(&bus->free, port, next);
|
|
|
|
bus->nfree--;
|
|
|
|
}
|
|
|
|
|
2014-09-19 08:48:24 +02:00
|
|
|
void usb_claim_port(USBDevice *dev, Error **errp)
|
2009-08-31 14:24:00 +02:00
|
|
|
{
|
|
|
|
USBBus *bus = usb_bus_from_device(dev);
|
|
|
|
USBPort *port;
|
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
assert(dev->port == NULL);
|
|
|
|
|
2010-12-10 11:43:35 +01:00
|
|
|
if (dev->port_path) {
|
|
|
|
QTAILQ_FOREACH(port, &bus->free, next) {
|
|
|
|
if (strcmp(port->path, dev->port_path) == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (port == NULL) {
|
2015-02-04 13:28:10 +01:00
|
|
|
error_setg(errp, "usb port %s (bus %s) not found (in use?)",
|
2014-09-19 08:48:24 +02:00
|
|
|
dev->port_path, bus->qbus.name);
|
|
|
|
return;
|
2010-12-10 11:43:35 +01:00
|
|
|
}
|
|
|
|
} else {
|
2011-12-04 18:17:51 +01:00
|
|
|
if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) {
|
2011-09-01 13:56:37 +02:00
|
|
|
/* Create a new hub and chain it on */
|
usb: Suppress bogus error when automatic usb-hub creation fails
USBDevice's realize method usb_qdev_realize() automatically creates a
usb-hub when only one port is left. Creating devices in realize
methods is questionable, but works.
If usb-hub creation fails, an error is reported to stderr, but the
failure is otherwise ignored. We then create the actual device using
the last port, which may well succeed.
Example:
$ qemu -nodefaults -S -display none -machine usb=on -monitor stdio
QEMU 2.2.50 monitor - type 'help' for more information
(qemu) device_add usb-mouse
[Repeat 36 times]
(qemu) info usb
Device 0.0, Port 1, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2, Speed 12 Mb/s, Product QEMU USB Hub
Device 0.0, Port 2.1, Speed 12 Mb/s, Product QEMU USB Mouse
[More mice and hubs omitted...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
(qemu) device_add usb-mouse
usb hub chain too deep
Failed to initialize USB device 'usb-hub'
(qemu) info usb
[...]
Device 0.0, Port 2.8.8.8.8.7, Speed 12 Mb/s, Product QEMU USB Mouse
Device 0.0, Port 2.8.8.8.8.8, Speed 12 Mb/s, Product QEMU USB Mouse
Despite the "Failed" message, the command actually succeeded.
In QMP, it's worse. When adding the 37th mouse via QMP, the command
fails with
{"error": {"class": "GenericError", "desc": "usb hub chain too deep"}}
Additionally, "Failed to initialize USB device 'usb-hub'" is reported
on stderr. Despite the command failure, the device was created. This
is wrong.
Fix by avoiding qdev_init() for usb-hub creation, so we can ignore
errors cleanly.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2015-02-04 13:28:11 +01:00
|
|
|
usb_try_create_simple(bus, "usb-hub", NULL);
|
2011-09-01 13:56:37 +02:00
|
|
|
}
|
|
|
|
if (bus->nfree == 0) {
|
2015-02-04 13:28:10 +01:00
|
|
|
error_setg(errp, "tried to attach usb device %s to a bus "
|
2014-09-19 08:48:24 +02:00
|
|
|
"with no free ports", dev->product_desc);
|
|
|
|
return;
|
2011-09-01 13:56:37 +02:00
|
|
|
}
|
2010-12-10 11:43:35 +01:00
|
|
|
port = QTAILQ_FIRST(&bus->free);
|
|
|
|
}
|
2011-09-01 13:56:37 +02:00
|
|
|
trace_usb_port_claim(bus->busnr, port->path);
|
2009-08-31 14:24:00 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(&bus->free, port, next);
|
2009-08-31 14:24:00 +02:00
|
|
|
bus->nfree--;
|
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
dev->port = port;
|
|
|
|
port->dev = dev;
|
2009-08-31 14:24:00 +02:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_TAIL(&bus->used, port, next);
|
2009-08-31 14:24:00 +02:00
|
|
|
bus->nused++;
|
|
|
|
}
|
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
void usb_release_port(USBDevice *dev)
|
2009-08-31 14:24:00 +02:00
|
|
|
{
|
|
|
|
USBBus *bus = usb_bus_from_device(dev);
|
2011-09-01 13:56:37 +02:00
|
|
|
USBPort *port = dev->port;
|
2009-08-31 14:24:00 +02:00
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
assert(port != NULL);
|
|
|
|
trace_usb_port_release(bus->busnr, port->path);
|
|
|
|
|
|
|
|
QTAILQ_REMOVE(&bus->used, port, next);
|
|
|
|
bus->nused--;
|
|
|
|
|
|
|
|
dev->port = NULL;
|
|
|
|
port->dev = NULL;
|
|
|
|
|
|
|
|
QTAILQ_INSERT_TAIL(&bus->free, port, next);
|
|
|
|
bus->nfree++;
|
2009-08-31 14:24:00 +02:00
|
|
|
}
|
|
|
|
|
2013-04-18 11:57:21 +02:00
|
|
|
static void usb_mask_to_str(char *dest, size_t size,
|
|
|
|
unsigned int speedmask)
|
|
|
|
{
|
|
|
|
static const struct {
|
|
|
|
unsigned int mask;
|
|
|
|
const char *name;
|
|
|
|
} speeds[] = {
|
|
|
|
{ .mask = USB_SPEED_MASK_FULL, .name = "full" },
|
|
|
|
{ .mask = USB_SPEED_MASK_HIGH, .name = "high" },
|
|
|
|
{ .mask = USB_SPEED_MASK_SUPER, .name = "super" },
|
|
|
|
};
|
|
|
|
int i, pos = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(speeds); i++) {
|
|
|
|
if (speeds[i].mask & speedmask) {
|
|
|
|
pos += snprintf(dest + pos, size - pos, "%s%s",
|
|
|
|
pos ? "+" : "",
|
|
|
|
speeds[i].name);
|
|
|
|
}
|
|
|
|
}
|
2019-03-28 14:35:03 +01:00
|
|
|
|
|
|
|
if (pos == 0) {
|
|
|
|
snprintf(dest, size, "unknown");
|
|
|
|
}
|
2013-04-18 11:57:21 +02:00
|
|
|
}
|
|
|
|
|
2014-09-19 09:25:20 +02:00
|
|
|
void usb_check_attach(USBDevice *dev, Error **errp)
|
2009-09-25 21:42:39 +02:00
|
|
|
{
|
|
|
|
USBBus *bus = usb_bus_from_device(dev);
|
2011-09-01 13:56:37 +02:00
|
|
|
USBPort *port = dev->port;
|
2013-04-18 11:57:21 +02:00
|
|
|
char devspeed[32], portspeed[32];
|
2009-09-25 21:42:39 +02:00
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
assert(port != NULL);
|
|
|
|
assert(!dev->attached);
|
2013-04-18 11:57:21 +02:00
|
|
|
usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask);
|
|
|
|
usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask);
|
|
|
|
trace_usb_port_attach(bus->busnr, port->path,
|
|
|
|
devspeed, portspeed);
|
2011-09-01 13:56:37 +02:00
|
|
|
|
|
|
|
if (!(port->speedmask & dev->speedmask)) {
|
2014-09-19 08:48:24 +02:00
|
|
|
error_setg(errp, "Warning: speed mismatch trying to attach"
|
|
|
|
" usb device \"%s\" (%s speed)"
|
|
|
|
" to bus \"%s\", port \"%s\" (%s speed)",
|
|
|
|
dev->product_desc, devspeed,
|
|
|
|
bus->qbus.name, port->path, portspeed);
|
|
|
|
return;
|
2009-09-25 21:42:39 +02:00
|
|
|
}
|
2014-09-19 09:25:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void usb_device_attach(USBDevice *dev, Error **errp)
|
|
|
|
{
|
|
|
|
USBPort *port = dev->port;
|
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
usb_check_attach(dev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
2009-09-25 21:42:39 +02:00
|
|
|
|
2016-06-15 11:46:56 +02:00
|
|
|
dev->attached = true;
|
2011-09-01 13:56:37 +02:00
|
|
|
usb_attach(port);
|
|
|
|
}
|
|
|
|
|
|
|
|
int usb_device_detach(USBDevice *dev)
|
|
|
|
{
|
|
|
|
USBBus *bus = usb_bus_from_device(dev);
|
|
|
|
USBPort *port = dev->port;
|
2009-09-25 21:42:39 +02:00
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
assert(port != NULL);
|
|
|
|
assert(dev->attached);
|
|
|
|
trace_usb_port_detach(bus->busnr, port->path);
|
2009-09-25 21:42:39 +02:00
|
|
|
|
2011-09-01 13:56:37 +02:00
|
|
|
usb_detach(port);
|
2016-06-15 11:46:56 +02:00
|
|
|
dev->attached = false;
|
2009-09-25 21:42:39 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-31 14:24:00 +02:00
|
|
|
static const char *usb_speed(unsigned int speed)
|
|
|
|
{
|
|
|
|
static const char *txt[] = {
|
|
|
|
[ USB_SPEED_LOW ] = "1.5",
|
|
|
|
[ USB_SPEED_FULL ] = "12",
|
|
|
|
[ USB_SPEED_HIGH ] = "480",
|
2011-05-31 11:35:27 +02:00
|
|
|
[ USB_SPEED_SUPER ] = "5000",
|
2009-08-31 14:24:00 +02:00
|
|
|
};
|
|
|
|
if (speed >= ARRAY_SIZE(txt))
|
|
|
|
return "?";
|
|
|
|
return txt[speed];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent)
|
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDevice *dev = USB_DEVICE(qdev);
|
2009-08-31 14:24:00 +02:00
|
|
|
USBBus *bus = usb_bus_from_device(dev);
|
|
|
|
|
2010-12-10 11:37:45 +01:00
|
|
|
monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n",
|
2009-10-26 15:56:51 +01:00
|
|
|
indent, "", bus->busnr, dev->addr,
|
2010-12-10 11:37:45 +01:00
|
|
|
dev->port ? dev->port->path : "-",
|
2009-12-09 17:07:51 +01:00
|
|
|
usb_speed(dev->speed), dev->product_desc,
|
2009-10-26 15:56:51 +01:00
|
|
|
dev->attached ? ", attached" : "");
|
2009-08-31 14:24:00 +02:00
|
|
|
}
|
|
|
|
|
2010-12-10 11:37:45 +01:00
|
|
|
static char *usb_get_dev_path(DeviceState *qdev)
|
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDevice *dev = USB_DEVICE(qdev);
|
2011-08-22 09:09:51 +02:00
|
|
|
DeviceState *hcd = qdev->parent_bus->parent;
|
|
|
|
char *id = NULL;
|
|
|
|
|
2012-02-03 19:28:43 +01:00
|
|
|
if (dev->flags & (1 << USB_DEV_FLAG_FULL_PATH)) {
|
|
|
|
id = qdev_get_dev_path(hcd);
|
2011-08-22 09:09:51 +02:00
|
|
|
}
|
|
|
|
if (id) {
|
|
|
|
char *ret = g_strdup_printf("%s/%s", id, dev->port->path);
|
|
|
|
g_free(id);
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
return g_strdup(dev->port->path);
|
|
|
|
}
|
2010-12-10 11:37:45 +01:00
|
|
|
}
|
|
|
|
|
2011-01-12 10:58:27 +01:00
|
|
|
static char *usb_get_fw_dev_path(DeviceState *qdev)
|
|
|
|
{
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDevice *dev = USB_DEVICE(qdev);
|
2011-01-12 10:58:27 +01:00
|
|
|
char *fw_path, *in;
|
2011-01-23 09:48:41 +01:00
|
|
|
ssize_t pos = 0, fw_len;
|
2011-01-12 10:58:27 +01:00
|
|
|
long nr;
|
|
|
|
|
2011-01-23 09:48:41 +01:00
|
|
|
fw_len = 32 + strlen(dev->port->path) * 6;
|
2011-08-21 05:09:37 +02:00
|
|
|
fw_path = g_malloc(fw_len);
|
2011-01-12 10:58:27 +01:00
|
|
|
in = dev->port->path;
|
2011-01-23 09:48:41 +01:00
|
|
|
while (fw_len - pos > 0) {
|
2011-01-12 10:58:27 +01:00
|
|
|
nr = strtol(in, &in, 10);
|
|
|
|
if (in[0] == '.') {
|
|
|
|
/* some hub between root port and device */
|
2014-08-15 13:32:36 +02:00
|
|
|
pos += snprintf(fw_path + pos, fw_len - pos, "hub@%lx/", nr);
|
2011-01-12 10:58:27 +01:00
|
|
|
in++;
|
|
|
|
} else {
|
|
|
|
/* the device itself */
|
2014-08-15 13:32:36 +02:00
|
|
|
pos += snprintf(fw_path + pos, fw_len - pos, "%s@%lx",
|
2011-01-23 09:48:41 +01:00
|
|
|
qdev_fw_name(qdev), nr);
|
2011-01-12 10:58:27 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return fw_path;
|
|
|
|
}
|
|
|
|
|
2015-02-06 14:18:24 +01:00
|
|
|
void hmp_info_usb(Monitor *mon, const QDict *qdict)
|
2009-08-31 14:24:00 +02:00
|
|
|
{
|
|
|
|
USBBus *bus;
|
|
|
|
USBDevice *dev;
|
|
|
|
USBPort *port;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
if (QTAILQ_EMPTY(&busses)) {
|
2009-08-31 14:24:00 +02:00
|
|
|
monitor_printf(mon, "USB support not enabled\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(bus, &busses, next) {
|
|
|
|
QTAILQ_FOREACH(port, &bus->used, next) {
|
2009-08-31 14:24:00 +02:00
|
|
|
dev = port->dev;
|
|
|
|
if (!dev)
|
|
|
|
continue;
|
2015-10-06 15:31:21 +02:00
|
|
|
monitor_printf(mon, " Device %d.%d, Port %s, Speed %s Mb/s, "
|
|
|
|
"Product %s%s%s\n",
|
|
|
|
bus->busnr, dev->addr, port->path,
|
|
|
|
usb_speed(dev->speed), dev->product_desc,
|
|
|
|
dev->qdev.id ? ", ID: " : "",
|
|
|
|
dev->qdev.id ?: "");
|
2009-08-31 14:24:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-26 15:56:45 +01:00
|
|
|
/* handle legacy -usbdevice cmd line option */
|
|
|
|
USBDevice *usbdevice_create(const char *cmdline)
|
|
|
|
{
|
|
|
|
USBBus *bus = usb_bus_find(-1 /* any */);
|
2011-12-15 21:53:10 +01:00
|
|
|
LegacyUSBFactory *f = NULL;
|
2015-02-04 13:28:09 +01:00
|
|
|
Error *err = NULL;
|
2011-12-15 21:53:10 +01:00
|
|
|
GSList *i;
|
2010-03-07 12:17:08 +01:00
|
|
|
char driver[32];
|
|
|
|
const char *params;
|
2009-10-26 15:56:45 +01:00
|
|
|
int len;
|
2015-02-04 13:28:09 +01:00
|
|
|
USBDevice *dev;
|
2009-10-26 15:56:45 +01:00
|
|
|
|
|
|
|
params = strchr(cmdline,':');
|
|
|
|
if (params) {
|
|
|
|
params++;
|
|
|
|
len = params - cmdline;
|
|
|
|
if (len > sizeof(driver))
|
|
|
|
len = sizeof(driver);
|
|
|
|
pstrcpy(driver, len, cmdline);
|
|
|
|
} else {
|
2010-03-07 12:17:08 +01:00
|
|
|
params = "";
|
2009-10-26 15:56:45 +01:00
|
|
|
pstrcpy(driver, sizeof(driver), cmdline);
|
|
|
|
}
|
|
|
|
|
2011-12-15 21:53:10 +01:00
|
|
|
for (i = legacy_usb_factory; i; i = i->next) {
|
|
|
|
f = i->data;
|
|
|
|
if (strcmp(f->usbdevice_name, driver) == 0) {
|
|
|
|
break;
|
|
|
|
}
|
2009-10-26 15:56:45 +01:00
|
|
|
}
|
2011-12-15 21:53:10 +01:00
|
|
|
if (i == NULL) {
|
2009-10-26 15:56:45 +01:00
|
|
|
#if 0
|
|
|
|
/* no error because some drivers are not converted (yet) */
|
2010-02-18 17:25:24 +01:00
|
|
|
error_report("usbdevice %s not found", driver);
|
2009-10-26 15:56:45 +01:00
|
|
|
#endif
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-11-25 16:49:15 +01:00
|
|
|
if (!bus) {
|
|
|
|
error_report("Error: no usb bus to attach usbdevice %s, "
|
|
|
|
"please try -machine usb=on and check that "
|
|
|
|
"the machine model supports USB", driver);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-02-04 13:28:09 +01:00
|
|
|
if (f->usbdevice_init) {
|
|
|
|
dev = f->usbdevice_init(bus, params);
|
|
|
|
} else {
|
2010-03-30 03:33:24 +02:00
|
|
|
if (*params) {
|
2010-02-18 17:25:24 +01:00
|
|
|
error_report("usbdevice %s accepts no params", driver);
|
2009-10-26 15:56:45 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
2015-02-04 13:28:09 +01:00
|
|
|
dev = usb_create(bus, f->name);
|
|
|
|
}
|
|
|
|
if (!dev) {
|
|
|
|
error_report("Failed to create USB device '%s'", f->name);
|
|
|
|
return NULL;
|
2009-10-26 15:56:45 +01:00
|
|
|
}
|
2015-02-04 13:28:09 +01:00
|
|
|
object_property_set_bool(OBJECT(dev), true, "realized", &err);
|
|
|
|
if (err) {
|
2015-12-18 16:35:14 +01:00
|
|
|
error_reportf_err(err, "Failed to initialize USB device '%s': ",
|
|
|
|
f->name);
|
2015-02-04 13:28:09 +01:00
|
|
|
object_unparent(OBJECT(dev));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return dev;
|
2009-10-26 15:56:45 +01:00
|
|
|
}
|
2011-12-15 21:53:10 +01:00
|
|
|
|
2016-06-15 11:46:57 +02:00
|
|
|
static bool usb_get_attached(Object *obj, Error **errp)
|
|
|
|
{
|
|
|
|
USBDevice *dev = USB_DEVICE(obj);
|
|
|
|
|
|
|
|
return dev->attached;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void usb_set_attached(Object *obj, bool value, Error **errp)
|
|
|
|
{
|
|
|
|
USBDevice *dev = USB_DEVICE(obj);
|
|
|
|
Error *err = NULL;
|
|
|
|
|
|
|
|
if (dev->attached == value) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
usb_device_attach(dev, &err);
|
2017-04-21 14:27:10 +02:00
|
|
|
error_propagate(errp, err);
|
2016-06-15 11:46:57 +02:00
|
|
|
} else {
|
|
|
|
usb_device_detach(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void usb_device_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
USBDevice *dev = USB_DEVICE(obj);
|
|
|
|
USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev);
|
|
|
|
|
|
|
|
if (klass->attached_settable) {
|
|
|
|
object_property_add_bool(obj, "attached",
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
usb_get_attached, usb_set_attached);
|
2016-06-15 11:46:57 +02:00
|
|
|
} else {
|
|
|
|
object_property_add_bool(obj, "attached",
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 17:29:22 +02:00
|
|
|
usb_get_attached, NULL);
|
2016-06-15 11:46:57 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static void usb_device_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *k = DEVICE_CLASS(klass);
|
2012-05-02 09:00:20 +02:00
|
|
|
k->bus_type = TYPE_USB_BUS;
|
2014-09-19 08:48:24 +02:00
|
|
|
k->realize = usb_qdev_realize;
|
|
|
|
k->unrealize = usb_qdev_unrealize;
|
2020-01-10 16:30:32 +01:00
|
|
|
device_class_set_props(k, usb_props);
|
2011-12-08 04:34:16 +01:00
|
|
|
}
|
|
|
|
|
2013-01-10 16:19:07 +01:00
|
|
|
static const TypeInfo usb_device_type_info = {
|
2011-12-15 21:53:10 +01:00
|
|
|
.name = TYPE_USB_DEVICE,
|
|
|
|
.parent = TYPE_DEVICE,
|
|
|
|
.instance_size = sizeof(USBDevice),
|
2016-06-15 11:46:57 +02:00
|
|
|
.instance_init = usb_device_instance_init,
|
2011-12-15 21:53:10 +01:00
|
|
|
.abstract = true,
|
|
|
|
.class_size = sizeof(USBDeviceClass),
|
2011-12-08 04:34:16 +01:00
|
|
|
.class_init = usb_device_class_init,
|
2011-12-15 21:53:10 +01:00
|
|
|
};
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
static void usb_register_types(void)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
2012-05-02 09:00:20 +02:00
|
|
|
type_register_static(&usb_bus_info);
|
2011-12-15 21:53:10 +01:00
|
|
|
type_register_static(&usb_device_type_info);
|
|
|
|
}
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
type_init(usb_register_types)
|