2006-04-24 23:18:20 +02:00
|
|
|
/*
|
|
|
|
* QEMU USB HUB emulation
|
|
|
|
*
|
|
|
|
* Copyright (c) 2005 Fabrice Bellard
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2006-04-24 23:18:20 +02:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2019-05-23 16:35:07 +02:00
|
|
|
|
2016-01-26 19:17:12 +01:00
|
|
|
#include "qemu/osdep.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"
|
2019-05-24 09:03:10 +02:00
|
|
|
#include "qemu/timer.h"
|
2012-03-23 15:42:58 +01:00
|
|
|
#include "trace.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"
|
2019-08-12 07:23:45 +02:00
|
|
|
#include "migration/vmstate.h"
|
2018-05-03 21:50:48 +02:00
|
|
|
#include "desc.h"
|
2013-03-20 11:40:02 +01:00
|
|
|
#include "qemu/error-report.h"
|
2019-05-23 16:35:07 +02:00
|
|
|
#include "qemu/module.h"
|
2020-09-03 22:43:22 +02:00
|
|
|
#include "qom/object.h"
|
2006-04-24 23:18:20 +02:00
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
#define MAX_PORTS 8
|
2006-04-24 23:18:20 +02:00
|
|
|
|
|
|
|
typedef struct USBHubPort {
|
|
|
|
USBPort port;
|
|
|
|
uint16_t wPortStatus;
|
|
|
|
uint16_t wPortChange;
|
|
|
|
} USBHubPort;
|
|
|
|
|
2020-09-03 22:43:22 +02:00
|
|
|
struct USBHubState {
|
2006-04-24 23:18:20 +02:00
|
|
|
USBDevice dev;
|
2012-01-17 13:25:46 +01:00
|
|
|
USBEndpoint *intr;
|
2019-05-24 09:03:07 +02:00
|
|
|
uint32_t num_ports;
|
2019-05-24 09:03:10 +02:00
|
|
|
bool port_power;
|
|
|
|
QEMUTimer *port_timer;
|
2019-05-24 09:03:07 +02:00
|
|
|
USBHubPort ports[MAX_PORTS];
|
2020-09-03 22:43:22 +02:00
|
|
|
};
|
2006-04-24 23:18:20 +02:00
|
|
|
|
2015-05-06 14:55:27 +02:00
|
|
|
#define TYPE_USB_HUB "usb-hub"
|
2020-09-16 20:25:19 +02:00
|
|
|
OBJECT_DECLARE_SIMPLE_TYPE(USBHubState, USB_HUB)
|
2015-05-06 14:55:27 +02:00
|
|
|
|
2006-04-24 23:18:20 +02:00
|
|
|
#define ClearHubFeature (0x2000 | USB_REQ_CLEAR_FEATURE)
|
|
|
|
#define ClearPortFeature (0x2300 | USB_REQ_CLEAR_FEATURE)
|
|
|
|
#define GetHubDescriptor (0xa000 | USB_REQ_GET_DESCRIPTOR)
|
|
|
|
#define GetHubStatus (0xa000 | USB_REQ_GET_STATUS)
|
|
|
|
#define GetPortStatus (0xa300 | USB_REQ_GET_STATUS)
|
|
|
|
#define SetHubFeature (0x2000 | USB_REQ_SET_FEATURE)
|
|
|
|
#define SetPortFeature (0x2300 | USB_REQ_SET_FEATURE)
|
|
|
|
|
|
|
|
#define PORT_STAT_CONNECTION 0x0001
|
|
|
|
#define PORT_STAT_ENABLE 0x0002
|
|
|
|
#define PORT_STAT_SUSPEND 0x0004
|
|
|
|
#define PORT_STAT_OVERCURRENT 0x0008
|
|
|
|
#define PORT_STAT_RESET 0x0010
|
|
|
|
#define PORT_STAT_POWER 0x0100
|
|
|
|
#define PORT_STAT_LOW_SPEED 0x0200
|
|
|
|
#define PORT_STAT_HIGH_SPEED 0x0400
|
|
|
|
#define PORT_STAT_TEST 0x0800
|
|
|
|
#define PORT_STAT_INDICATOR 0x1000
|
|
|
|
|
|
|
|
#define PORT_STAT_C_CONNECTION 0x0001
|
|
|
|
#define PORT_STAT_C_ENABLE 0x0002
|
|
|
|
#define PORT_STAT_C_SUSPEND 0x0004
|
|
|
|
#define PORT_STAT_C_OVERCURRENT 0x0008
|
|
|
|
#define PORT_STAT_C_RESET 0x0010
|
|
|
|
|
|
|
|
#define PORT_CONNECTION 0
|
|
|
|
#define PORT_ENABLE 1
|
|
|
|
#define PORT_SUSPEND 2
|
|
|
|
#define PORT_OVERCURRENT 3
|
|
|
|
#define PORT_RESET 4
|
|
|
|
#define PORT_POWER 8
|
|
|
|
#define PORT_LOWSPEED 9
|
|
|
|
#define PORT_HIGHSPEED 10
|
|
|
|
#define PORT_C_CONNECTION 16
|
|
|
|
#define PORT_C_ENABLE 17
|
|
|
|
#define PORT_C_SUSPEND 18
|
|
|
|
#define PORT_C_OVERCURRENT 19
|
|
|
|
#define PORT_C_RESET 20
|
|
|
|
#define PORT_TEST 21
|
|
|
|
#define PORT_INDICATOR 22
|
|
|
|
|
|
|
|
/* same as Linux kernel root hubs */
|
|
|
|
|
2010-11-26 13:13:22 +01:00
|
|
|
enum {
|
|
|
|
STR_MANUFACTURER = 1,
|
|
|
|
STR_PRODUCT,
|
|
|
|
STR_SERIALNUMBER,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescStrings desc_strings = {
|
2012-05-30 05:35:51 +02:00
|
|
|
[STR_MANUFACTURER] = "QEMU",
|
2010-11-26 13:13:22 +01:00
|
|
|
[STR_PRODUCT] = "QEMU USB Hub",
|
|
|
|
[STR_SERIALNUMBER] = "314159",
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescIface desc_iface_hub = {
|
|
|
|
.bInterfaceNumber = 0,
|
|
|
|
.bNumEndpoints = 1,
|
|
|
|
.bInterfaceClass = USB_CLASS_HUB,
|
|
|
|
.eps = (USBDescEndpoint[]) {
|
|
|
|
{
|
|
|
|
.bEndpointAddress = USB_DIR_IN | 0x01,
|
|
|
|
.bmAttributes = USB_ENDPOINT_XFER_INT,
|
2019-05-24 09:03:07 +02:00
|
|
|
.wMaxPacketSize = 1 + DIV_ROUND_UP(MAX_PORTS, 8),
|
2010-11-26 13:13:22 +01:00
|
|
|
.bInterval = 0xff,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDescDevice desc_device_hub = {
|
|
|
|
.bcdUSB = 0x0110,
|
|
|
|
.bDeviceClass = USB_CLASS_HUB,
|
|
|
|
.bMaxPacketSize0 = 8,
|
|
|
|
.bNumConfigurations = 1,
|
|
|
|
.confs = (USBDescConfig[]) {
|
|
|
|
{
|
|
|
|
.bNumInterfaces = 1,
|
|
|
|
.bConfigurationValue = 1,
|
2013-12-16 08:42:49 +01:00
|
|
|
.bmAttributes = USB_CFG_ATT_ONE | USB_CFG_ATT_SELFPOWER |
|
|
|
|
USB_CFG_ATT_WAKEUP,
|
2011-04-03 07:33:19 +02:00
|
|
|
.nif = 1,
|
2010-11-26 13:13:22 +01:00
|
|
|
.ifs = &desc_iface_hub,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const USBDesc desc_hub = {
|
|
|
|
.id = {
|
2011-09-15 05:25:47 +02:00
|
|
|
.idVendor = 0x0409,
|
|
|
|
.idProduct = 0x55aa,
|
2010-11-26 13:13:22 +01:00
|
|
|
.bcdDevice = 0x0101,
|
|
|
|
.iManufacturer = STR_MANUFACTURER,
|
|
|
|
.iProduct = STR_PRODUCT,
|
|
|
|
.iSerialNumber = STR_SERIALNUMBER,
|
|
|
|
},
|
|
|
|
.full = &desc_device_hub,
|
|
|
|
.str = desc_strings,
|
|
|
|
};
|
|
|
|
|
2006-04-24 23:18:20 +02:00
|
|
|
static const uint8_t qemu_hub_hub_descriptor[] =
|
|
|
|
{
|
2018-12-13 23:37:37 +01:00
|
|
|
0x00, /* u8 bLength; patched in later */
|
|
|
|
0x29, /* u8 bDescriptorType; Hub-descriptor */
|
|
|
|
0x00, /* u8 bNbrPorts; (patched later) */
|
|
|
|
0x0a, /* u16 wHubCharacteristics; */
|
|
|
|
0x00, /* (per-port OC, no power switching) */
|
|
|
|
0x01, /* u8 bPwrOn2pwrGood; 2ms */
|
|
|
|
0x00 /* u8 bHubContrCurrent; 0 mA */
|
2006-04-30 23:53:59 +02:00
|
|
|
|
|
|
|
/* DeviceRemovable and PortPwrCtrlMask patched in later */
|
2006-04-24 23:18:20 +02:00
|
|
|
};
|
|
|
|
|
2019-05-24 09:03:08 +02:00
|
|
|
static bool usb_hub_port_change(USBHubPort *port, uint16_t status)
|
|
|
|
{
|
|
|
|
bool notify = false;
|
|
|
|
|
|
|
|
if (status & 0x1f) {
|
|
|
|
port->wPortChange |= status;
|
|
|
|
notify = true;
|
|
|
|
}
|
|
|
|
return notify;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool usb_hub_port_set(USBHubPort *port, uint16_t status)
|
|
|
|
{
|
|
|
|
if (port->wPortStatus & status) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
port->wPortStatus |= status;
|
|
|
|
return usb_hub_port_change(port, status);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool usb_hub_port_clear(USBHubPort *port, uint16_t status)
|
|
|
|
{
|
|
|
|
if (!(port->wPortStatus & status)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
port->wPortStatus &= ~status;
|
|
|
|
return usb_hub_port_change(port, status);
|
|
|
|
}
|
|
|
|
|
2019-05-24 09:03:09 +02:00
|
|
|
static bool usb_hub_port_update(USBHubPort *port)
|
|
|
|
{
|
|
|
|
bool notify = false;
|
|
|
|
|
|
|
|
if (port->port.dev && port->port.dev->attached) {
|
|
|
|
notify = usb_hub_port_set(port, PORT_STAT_CONNECTION);
|
|
|
|
if (port->port.dev->speed == USB_SPEED_LOW) {
|
|
|
|
usb_hub_port_set(port, PORT_STAT_LOW_SPEED);
|
|
|
|
} else {
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_LOW_SPEED);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return notify;
|
|
|
|
}
|
|
|
|
|
2019-05-24 09:03:10 +02:00
|
|
|
static void usb_hub_port_update_timer(void *opaque)
|
|
|
|
{
|
|
|
|
USBHubState *s = opaque;
|
|
|
|
bool notify = false;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < s->num_ports; i++) {
|
|
|
|
notify |= usb_hub_port_update(&s->ports[i]);
|
|
|
|
}
|
|
|
|
if (notify) {
|
|
|
|
usb_wakeup(s->intr, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-01 11:27:05 +01:00
|
|
|
static void usb_hub_attach(USBPort *port1)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
USBHubPort *port = &s->ports[port1->index];
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_attach(s->dev.addr, port1->index + 1);
|
2019-05-24 09:03:09 +02:00
|
|
|
usb_hub_port_update(port);
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2010-12-01 11:27:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void usb_hub_detach(USBPort *port1)
|
|
|
|
{
|
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
USBHubPort *port = &s->ports[port1->index];
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_detach(s->dev.addr, port1->index + 1);
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2011-11-22 13:20:14 +01:00
|
|
|
|
2011-06-24 12:31:11 +02:00
|
|
|
/* Let upstream know the device on this port is gone */
|
|
|
|
s->dev.port->ops->child_detach(s->dev.port, port1->dev);
|
|
|
|
|
2019-05-24 09:03:08 +02:00
|
|
|
usb_hub_port_clear(port, PORT_STAT_CONNECTION);
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_ENABLE);
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_SUSPEND);
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
|
2011-06-24 12:31:11 +02:00
|
|
|
static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
|
|
|
|
{
|
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
|
|
|
|
/* Pass along upstream */
|
|
|
|
s->dev.port->ops->child_detach(s->dev.port, child);
|
|
|
|
}
|
|
|
|
|
2011-06-21 11:52:28 +02:00
|
|
|
static void usb_hub_wakeup(USBPort *port1)
|
2010-12-15 12:26:59 +01:00
|
|
|
{
|
2011-06-21 11:52:28 +02:00
|
|
|
USBHubState *s = port1->opaque;
|
|
|
|
USBHubPort *port = &s->ports[port1->index];
|
2010-12-15 12:26:59 +01:00
|
|
|
|
2019-05-24 09:03:08 +02:00
|
|
|
if (usb_hub_port_clear(port, PORT_STAT_SUSPEND)) {
|
2013-01-29 12:44:35 +01:00
|
|
|
usb_wakeup(s->intr, 0);
|
2010-12-15 12:26:59 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-21 11:52:28 +02:00
|
|
|
static void usb_hub_complete(USBPort *port, USBPacket *packet)
|
2010-12-16 17:03:44 +01:00
|
|
|
{
|
2011-06-21 11:52:28 +02:00
|
|
|
USBHubState *s = port->opaque;
|
2010-12-16 17:03:44 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Just pass it along upstream for now.
|
|
|
|
*
|
2011-10-13 12:52:47 +02:00
|
|
|
* If we ever implement usb 2.0 split transactions this will
|
2010-12-16 17:03:44 +01:00
|
|
|
* become a little more complicated ...
|
2011-10-13 12:52:47 +02:00
|
|
|
*
|
|
|
|
* Can't use usb_packet_complete() here because packet->owner is
|
|
|
|
* cleared already, go call the ->complete() callback directly
|
|
|
|
* instead.
|
2010-12-16 17:03:44 +01:00
|
|
|
*/
|
2011-10-13 12:52:47 +02:00
|
|
|
s->dev.port->ops->complete(s->dev.port, packet);
|
2010-12-16 17:03:44 +01:00
|
|
|
}
|
|
|
|
|
2012-01-10 17:08:13 +01:00
|
|
|
static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
|
|
|
|
{
|
2015-05-06 14:55:27 +02:00
|
|
|
USBHubState *s = USB_HUB(dev);
|
2012-01-10 17:08:13 +01:00
|
|
|
USBHubPort *port;
|
|
|
|
USBDevice *downstream;
|
|
|
|
int i;
|
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
for (i = 0; i < s->num_ports; i++) {
|
2012-01-10 17:08:13 +01:00
|
|
|
port = &s->ports[i];
|
|
|
|
if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
downstream = usb_find_device(&port->port, addr);
|
|
|
|
if (downstream != NULL) {
|
|
|
|
return downstream;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-19 20:06:15 +02:00
|
|
|
static void usb_hub_handle_reset(USBDevice *dev)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
2015-05-06 14:55:27 +02:00
|
|
|
USBHubState *s = USB_HUB(dev);
|
2011-11-23 13:31:08 +01:00
|
|
|
USBHubPort *port;
|
|
|
|
int i;
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_reset(s->dev.addr);
|
2019-05-24 09:03:07 +02:00
|
|
|
for (i = 0; i < s->num_ports; i++) {
|
2011-11-23 13:31:08 +01:00
|
|
|
port = s->ports + i;
|
2019-05-24 09:03:08 +02:00
|
|
|
port->wPortStatus = 0;
|
2011-11-23 13:31:08 +01:00
|
|
|
port->wPortChange = 0;
|
2019-05-24 09:03:08 +02:00
|
|
|
usb_hub_port_set(port, PORT_STAT_POWER);
|
2019-05-24 09:03:09 +02:00
|
|
|
usb_hub_port_update(port);
|
2011-11-23 13:31:08 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
static const char *feature_name(int feature)
|
|
|
|
{
|
|
|
|
static const char *name[] = {
|
|
|
|
[PORT_CONNECTION] = "connection",
|
|
|
|
[PORT_ENABLE] = "enable",
|
|
|
|
[PORT_SUSPEND] = "suspend",
|
|
|
|
[PORT_OVERCURRENT] = "overcurrent",
|
|
|
|
[PORT_RESET] = "reset",
|
|
|
|
[PORT_POWER] = "power",
|
|
|
|
[PORT_LOWSPEED] = "lowspeed",
|
|
|
|
[PORT_HIGHSPEED] = "highspeed",
|
2019-05-24 09:03:06 +02:00
|
|
|
[PORT_C_CONNECTION] = "change-connection",
|
|
|
|
[PORT_C_ENABLE] = "change-enable",
|
|
|
|
[PORT_C_SUSPEND] = "change-suspend",
|
|
|
|
[PORT_C_OVERCURRENT] = "change-overcurrent",
|
|
|
|
[PORT_C_RESET] = "change-reset",
|
2012-03-23 15:42:58 +01:00
|
|
|
[PORT_TEST] = "test",
|
|
|
|
[PORT_INDICATOR] = "indicator",
|
|
|
|
};
|
|
|
|
if (feature < 0 || feature >= ARRAY_SIZE(name)) {
|
|
|
|
return "?";
|
|
|
|
}
|
|
|
|
return name[feature] ?: "?";
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static void usb_hub_handle_control(USBDevice *dev, USBPacket *p,
|
2011-02-02 16:33:13 +01:00
|
|
|
int request, int value, int index, int length, uint8_t *data)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = (USBHubState *)dev;
|
|
|
|
int ret;
|
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_control(s->dev.addr, request, value, index, length);
|
|
|
|
|
2011-02-02 16:33:13 +01:00
|
|
|
ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
|
2010-11-26 13:13:22 +01:00
|
|
|
if (ret >= 0) {
|
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
|
|
|
return;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
|
|
|
|
2006-04-24 23:18:20 +02:00
|
|
|
switch(request) {
|
2006-04-30 23:53:59 +02:00
|
|
|
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
|
|
|
|
if (value == 0 && index != 0x81) { /* clear ep halt */
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
2006-04-24 23:18:20 +02:00
|
|
|
/* usb specific requests */
|
|
|
|
case GetHubStatus:
|
|
|
|
data[0] = 0;
|
|
|
|
data[1] = 0;
|
|
|
|
data[2] = 0;
|
|
|
|
data[3] = 0;
|
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
|
|
|
p->actual_length = 4;
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
case GetPortStatus:
|
|
|
|
{
|
|
|
|
unsigned int n = index - 1;
|
|
|
|
USBHubPort *port;
|
2019-05-24 09:03:07 +02:00
|
|
|
if (n >= s->num_ports) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[n];
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_get_port_status(s->dev.addr, index,
|
|
|
|
port->wPortStatus,
|
|
|
|
port->wPortChange);
|
2006-04-24 23:18:20 +02:00
|
|
|
data[0] = port->wPortStatus;
|
|
|
|
data[1] = port->wPortStatus >> 8;
|
|
|
|
data[2] = port->wPortChange;
|
|
|
|
data[3] = port->wPortChange >> 8;
|
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
|
|
|
p->actual_length = 4;
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SetHubFeature:
|
|
|
|
case ClearHubFeature:
|
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
|
|
|
if (value != 0 && value != 1) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case SetPortFeature:
|
|
|
|
{
|
|
|
|
unsigned int n = index - 1;
|
|
|
|
USBHubPort *port;
|
|
|
|
USBDevice *dev;
|
2012-03-23 15:42:58 +01:00
|
|
|
|
|
|
|
trace_usb_hub_set_port_feature(s->dev.addr, index,
|
|
|
|
feature_name(value));
|
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
if (n >= s->num_ports) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[n];
|
|
|
|
dev = port->port.dev;
|
|
|
|
switch(value) {
|
|
|
|
case PORT_SUSPEND:
|
|
|
|
port->wPortStatus |= PORT_STAT_SUSPEND;
|
|
|
|
break;
|
|
|
|
case PORT_RESET:
|
2019-05-24 09:03:08 +02:00
|
|
|
usb_hub_port_set(port, PORT_STAT_RESET);
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_RESET);
|
2011-09-15 09:20:02 +02:00
|
|
|
if (dev && dev->attached) {
|
2012-01-06 15:23:10 +01:00
|
|
|
usb_device_reset(dev);
|
2019-05-24 09:03:08 +02:00
|
|
|
usb_hub_port_set(port, PORT_STAT_ENABLE);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2019-05-24 09:03:08 +02:00
|
|
|
usb_wakeup(s->intr, 0);
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
case PORT_POWER:
|
2019-05-24 09:03:10 +02:00
|
|
|
if (s->port_power) {
|
|
|
|
int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
|
|
|
usb_hub_port_set(port, PORT_STAT_POWER);
|
|
|
|
timer_mod(s->port_timer, now + 5000000); /* 5 ms */
|
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ClearPortFeature:
|
|
|
|
{
|
|
|
|
unsigned int n = index - 1;
|
|
|
|
USBHubPort *port;
|
2010-04-25 20:23:04 +02:00
|
|
|
|
2012-03-23 15:42:58 +01:00
|
|
|
trace_usb_hub_clear_port_feature(s->dev.addr, index,
|
|
|
|
feature_name(value));
|
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
if (n >= s->num_ports) {
|
2006-04-24 23:18:20 +02:00
|
|
|
goto fail;
|
2010-11-26 13:13:22 +01:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[n];
|
|
|
|
switch(value) {
|
|
|
|
case PORT_ENABLE:
|
|
|
|
port->wPortStatus &= ~PORT_STAT_ENABLE;
|
|
|
|
break;
|
|
|
|
case PORT_C_ENABLE:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_ENABLE;
|
|
|
|
break;
|
|
|
|
case PORT_SUSPEND:
|
2019-05-24 09:03:08 +02:00
|
|
|
usb_hub_port_clear(port, PORT_STAT_SUSPEND);
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
case PORT_C_SUSPEND:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_SUSPEND;
|
|
|
|
break;
|
|
|
|
case PORT_C_CONNECTION:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_CONNECTION;
|
|
|
|
break;
|
|
|
|
case PORT_C_OVERCURRENT:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
|
|
|
|
break;
|
|
|
|
case PORT_C_RESET:
|
|
|
|
port->wPortChange &= ~PORT_STAT_C_RESET;
|
|
|
|
break;
|
2019-05-24 09:03:10 +02:00
|
|
|
case PORT_POWER:
|
|
|
|
if (s->port_power) {
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_POWER);
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_CONNECTION);
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_ENABLE);
|
|
|
|
usb_hub_port_clear(port, PORT_STAT_SUSPEND);
|
|
|
|
port->wPortChange = 0;
|
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
default:
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GetHubDescriptor:
|
2006-04-30 23:53:59 +02:00
|
|
|
{
|
|
|
|
unsigned int n, limit, var_hub_size = 0;
|
2007-09-16 23:08:06 +02:00
|
|
|
memcpy(data, qemu_hub_hub_descriptor,
|
2006-04-30 23:53:59 +02:00
|
|
|
sizeof(qemu_hub_hub_descriptor));
|
2019-05-24 09:03:07 +02:00
|
|
|
data[2] = s->num_ports;
|
2006-04-30 23:53:59 +02:00
|
|
|
|
2019-05-24 09:03:10 +02:00
|
|
|
if (s->port_power) {
|
|
|
|
data[3] &= ~0x03;
|
|
|
|
data[3] |= 0x01;
|
|
|
|
}
|
|
|
|
|
2006-04-30 23:53:59 +02:00
|
|
|
/* fill DeviceRemovable bits */
|
2019-05-24 09:03:07 +02:00
|
|
|
limit = DIV_ROUND_UP(s->num_ports + 1, 8) + 7;
|
2006-04-30 23:53:59 +02:00
|
|
|
for (n = 7; n < limit; n++) {
|
|
|
|
data[n] = 0x00;
|
|
|
|
var_hub_size++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill PortPwrCtrlMask bits */
|
2019-05-24 09:03:07 +02:00
|
|
|
limit = limit + DIV_ROUND_UP(s->num_ports, 8);
|
2006-04-30 23:53:59 +02:00
|
|
|
for (;n < limit; n++) {
|
|
|
|
data[n] = 0xff;
|
|
|
|
var_hub_size++;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
p->actual_length = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
|
|
|
|
data[0] = p->actual_length;
|
2006-04-30 23:53:59 +02:00
|
|
|
break;
|
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
default:
|
|
|
|
fail:
|
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
|
|
|
p->status = USB_RET_STALL;
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static void usb_hub_handle_data(USBDevice *dev, USBPacket *p)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = (USBHubState *)dev;
|
|
|
|
|
2006-08-12 03:04:27 +02:00
|
|
|
switch(p->pid) {
|
2006-04-24 23:18:20 +02:00
|
|
|
case USB_TOKEN_IN:
|
2012-01-12 13:23:01 +01:00
|
|
|
if (p->ep->nr == 1) {
|
2006-04-24 23:18:20 +02:00
|
|
|
USBHubPort *port;
|
|
|
|
unsigned int status;
|
2011-07-12 15:22:25 +02:00
|
|
|
uint8_t buf[4];
|
2006-04-24 23:18:20 +02:00
|
|
|
int i, n;
|
2019-05-24 09:03:07 +02:00
|
|
|
n = DIV_ROUND_UP(s->num_ports + 1, 8);
|
2011-07-12 15:22:25 +02:00
|
|
|
if (p->iov.size == 1) { /* FreeBSD workaround */
|
2006-04-30 23:53:59 +02:00
|
|
|
n = 1;
|
2011-07-12 15:22:25 +02:00
|
|
|
} else if (n > p->iov.size) {
|
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
|
|
|
p->status = USB_RET_BABBLE;
|
|
|
|
return;
|
2006-04-30 23:53:59 +02:00
|
|
|
}
|
2006-04-24 23:18:20 +02:00
|
|
|
status = 0;
|
2019-05-24 09:03:07 +02:00
|
|
|
for (i = 0; i < s->num_ports; i++) {
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[i];
|
2013-08-27 17:00:04 +02:00
|
|
|
if (port->wPortChange)
|
2006-04-24 23:18:20 +02:00
|
|
|
status |= (1 << (i + 1));
|
|
|
|
}
|
|
|
|
if (status != 0) {
|
2013-08-27 16:59:37 +02:00
|
|
|
trace_usb_hub_status_report(s->dev.addr, status);
|
2006-04-24 23:18:20 +02:00
|
|
|
for(i = 0; i < n; i++) {
|
2011-07-12 15:22:25 +02:00
|
|
|
buf[i] = status >> (8 * i);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2011-07-12 15:22:25 +02:00
|
|
|
usb_packet_copy(p, buf, n);
|
2006-04-24 23:18:20 +02:00
|
|
|
} else {
|
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
|
|
|
p->status = USB_RET_NAK; /* usb11 11.13.1 */
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case USB_TOKEN_OUT:
|
|
|
|
default:
|
|
|
|
fail:
|
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
|
|
|
p->status = USB_RET_STALL;
|
2006-04-24 23:18:20 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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_hub_unrealize(USBDevice *dev)
|
2006-07-19 20:06:15 +02:00
|
|
|
{
|
|
|
|
USBHubState *s = (USBHubState *)dev;
|
2009-09-25 21:42:39 +02:00
|
|
|
int i;
|
2006-07-19 20:06:15 +02:00
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
for (i = 0; i < s->num_ports; i++) {
|
2009-09-25 21:42:39 +02:00
|
|
|
usb_unregister_port(usb_bus_from_device(dev),
|
|
|
|
&s->ports[i].port);
|
|
|
|
}
|
2019-05-24 09:03:10 +02:00
|
|
|
|
|
|
|
timer_del(s->port_timer);
|
|
|
|
timer_free(s->port_timer);
|
2006-07-19 20:06:15 +02:00
|
|
|
}
|
|
|
|
|
2010-12-01 11:08:44 +01:00
|
|
|
static USBPortOps usb_hub_port_ops = {
|
|
|
|
.attach = usb_hub_attach,
|
2010-12-01 11:27:05 +01:00
|
|
|
.detach = usb_hub_detach,
|
2011-06-24 12:31:11 +02:00
|
|
|
.child_detach = usb_hub_child_detach,
|
2010-12-15 12:26:59 +01:00
|
|
|
.wakeup = usb_hub_wakeup,
|
2010-12-16 17:03:44 +01:00
|
|
|
.complete = usb_hub_complete,
|
2010-12-01 11:08:44 +01:00
|
|
|
};
|
|
|
|
|
2014-09-19 08:48:28 +02:00
|
|
|
static void usb_hub_realize(USBDevice *dev, Error **errp)
|
2006-04-24 23:18:20 +02:00
|
|
|
{
|
2015-05-06 14:55:27 +02:00
|
|
|
USBHubState *s = USB_HUB(dev);
|
2006-04-24 23:18:20 +02:00
|
|
|
USBHubPort *port;
|
|
|
|
int i;
|
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
if (s->num_ports < 1 || s->num_ports > MAX_PORTS) {
|
|
|
|
error_setg(errp, "num_ports (%d) out of range (1..%d)",
|
|
|
|
s->num_ports, MAX_PORTS);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-03-20 11:40:02 +01:00
|
|
|
if (dev->port->hubcount == 5) {
|
2014-09-19 08:48:28 +02:00
|
|
|
error_setg(errp, "usb hub chain too deep");
|
|
|
|
return;
|
2013-03-20 11:40:02 +01:00
|
|
|
}
|
|
|
|
|
2012-04-20 12:33:30 +02:00
|
|
|
usb_desc_create_serial(dev);
|
2010-11-26 20:20:41 +01:00
|
|
|
usb_desc_init(dev);
|
2019-05-24 09:03:10 +02:00
|
|
|
s->port_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
|
|
|
|
usb_hub_port_update_timer, s);
|
2012-01-17 13:25:46 +01:00
|
|
|
s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
|
2019-05-24 09:03:07 +02:00
|
|
|
for (i = 0; i < s->num_ports; i++) {
|
2006-04-24 23:18:20 +02:00
|
|
|
port = &s->ports[i];
|
2009-08-31 14:24:00 +02:00
|
|
|
usb_register_port(usb_bus_from_device(dev),
|
2011-01-12 11:34:50 +01:00
|
|
|
&port->port, s, i, &usb_hub_port_ops,
|
2010-12-03 17:30:13 +01:00
|
|
|
USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
|
2011-09-01 13:56:37 +02:00
|
|
|
usb_port_location(&port->port, dev->port, i+1);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2011-11-23 13:31:08 +01:00
|
|
|
usb_hub_handle_reset(dev);
|
2009-08-31 14:23:59 +02:00
|
|
|
}
|
|
|
|
|
2010-12-15 12:45:24 +01:00
|
|
|
static const VMStateDescription vmstate_usb_hub_port = {
|
|
|
|
.name = "usb-hub-port",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 13:31:26 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2010-12-15 12:45:24 +01:00
|
|
|
VMSTATE_UINT16(wPortStatus, USBHubPort),
|
|
|
|
VMSTATE_UINT16(wPortChange, USBHubPort),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-05-24 09:03:10 +02:00
|
|
|
static bool usb_hub_port_timer_needed(void *opaque)
|
|
|
|
{
|
|
|
|
USBHubState *s = opaque;
|
|
|
|
|
|
|
|
return s->port_power;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const VMStateDescription vmstate_usb_hub_port_timer = {
|
|
|
|
.name = "usb-hub/port-timer",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.needed = usb_hub_port_timer_needed,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_TIMER_PTR(port_timer, USBHubState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2010-12-15 12:45:24 +01:00
|
|
|
static const VMStateDescription vmstate_usb_hub = {
|
|
|
|
.name = "usb-hub",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 13:31:26 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2010-12-15 12:45:24 +01:00
|
|
|
VMSTATE_USB_DEVICE(dev, USBHubState),
|
2019-05-24 09:03:07 +02:00
|
|
|
VMSTATE_STRUCT_ARRAY(ports, USBHubState, MAX_PORTS, 0,
|
2010-12-15 12:45:24 +01:00
|
|
|
vmstate_usb_hub_port, USBHubPort),
|
|
|
|
VMSTATE_END_OF_LIST()
|
2019-05-24 09:03:10 +02:00
|
|
|
},
|
|
|
|
.subsections = (const VMStateDescription * []) {
|
|
|
|
&vmstate_usb_hub_port_timer,
|
|
|
|
NULL
|
2010-12-15 12:45:24 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-05-24 09:03:07 +02:00
|
|
|
static Property usb_hub_properties[] = {
|
|
|
|
DEFINE_PROP_UINT32("ports", USBHubState, num_ports, 8),
|
2019-05-24 09:03:10 +02:00
|
|
|
DEFINE_PROP_BOOL("port-power", USBHubState, port_power, false),
|
2019-05-24 09:03:07 +02:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static void usb_hub_class_initfn(ObjectClass *klass, void *data)
|
2011-12-15 21:53:10 +01:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2011-12-15 21:53:10 +01:00
|
|
|
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
|
|
|
|
|
2014-09-19 08:48:28 +02:00
|
|
|
uc->realize = usb_hub_realize;
|
2011-12-15 21:53:10 +01:00
|
|
|
uc->product_desc = "QEMU USB Hub";
|
|
|
|
uc->usb_desc = &desc_hub;
|
2012-01-10 17:08:13 +01:00
|
|
|
uc->find_device = usb_hub_find_device;
|
2011-12-15 21:53:10 +01:00
|
|
|
uc->handle_reset = usb_hub_handle_reset;
|
|
|
|
uc->handle_control = usb_hub_handle_control;
|
|
|
|
uc->handle_data = usb_hub_handle_data;
|
2017-02-21 15:14:45 +01:00
|
|
|
uc->unrealize = usb_hub_unrealize;
|
2013-07-29 16:17:45 +02:00
|
|
|
set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
|
2011-12-08 04:34:16 +01:00
|
|
|
dc->fw_name = "hub";
|
|
|
|
dc->vmsd = &vmstate_usb_hub;
|
2020-01-10 16:30:32 +01:00
|
|
|
device_class_set_props(dc, usb_hub_properties);
|
2011-12-15 21:53:10 +01:00
|
|
|
}
|
|
|
|
|
2013-01-10 16:19:07 +01:00
|
|
|
static const TypeInfo hub_info = {
|
2015-05-06 14:55:27 +02:00
|
|
|
.name = TYPE_USB_HUB,
|
2011-12-08 04:34:16 +01:00
|
|
|
.parent = TYPE_USB_DEVICE,
|
|
|
|
.instance_size = sizeof(USBHubState),
|
|
|
|
.class_init = usb_hub_class_initfn,
|
2009-08-31 14:23:59 +02:00
|
|
|
};
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
static void usb_hub_register_types(void)
|
2009-08-31 14:23:59 +02:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
type_register_static(&hub_info);
|
2006-04-24 23:18:20 +02:00
|
|
|
}
|
2012-02-09 15:20:55 +01:00
|
|
|
|
|
|
|
type_init(usb_hub_register_types)
|