2011-12-16 00:53:10 +04:00
|
|
|
#ifndef QEMU_USB_H
|
|
|
|
|
#define QEMU_USB_H
|
|
|
|
|
|
2005-11-05 17:22:28 +03:00
|
|
|
/*
|
|
|
|
|
* QEMU USB API
|
2007-09-17 01:08:06 +04:00
|
|
|
*
|
2005-11-05 17:22:28 +03:00
|
|
|
* Copyright (c) 2005 Fabrice Bellard
|
2007-09-17 01:08:06 +04:00
|
|
|
*
|
2005-11-05 17:22:28 +03: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.
|
|
|
|
|
*/
|
2009-03-06 02:01:01 +03:00
|
|
|
|
2019-08-12 08:23:46 +03:00
|
|
|
#include "exec/memory.h"
|
2019-08-12 08:23:51 +03:00
|
|
|
#include "hw/qdev-core.h"
|
2016-03-09 12:52:44 +03:00
|
|
|
#include "qemu/iov.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/queue.h"
|
2020-09-03 23:43:22 +03:00
|
|
|
#include "qom/object.h"
|
2009-03-06 02:01:01 +03:00
|
|
|
|
2011-06-02 05:18:46 +04:00
|
|
|
/* Constants related to the USB / PCI interaction */
|
|
|
|
|
#define USB_SBRN 0x60 /* Serial Bus Release Number Register */
|
|
|
|
|
#define USB_RELEASE_1 0x10 /* USB 1.0 */
|
|
|
|
|
#define USB_RELEASE_2 0x20 /* USB 2.0 */
|
|
|
|
|
#define USB_RELEASE_3 0x30 /* USB 3.0 */
|
|
|
|
|
|
2005-11-05 17:22:28 +03:00
|
|
|
#define USB_TOKEN_SETUP 0x2d
|
|
|
|
|
#define USB_TOKEN_IN 0x69 /* device -> host */
|
|
|
|
|
#define USB_TOKEN_OUT 0xe1 /* host -> device */
|
|
|
|
|
|
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 20:15:01 +04:00
|
|
|
#define USB_RET_SUCCESS (0)
|
2012-10-24 20:14:07 +04:00
|
|
|
#define USB_RET_NODEV (-1)
|
|
|
|
|
#define USB_RET_NAK (-2)
|
|
|
|
|
#define USB_RET_STALL (-3)
|
|
|
|
|
#define USB_RET_BABBLE (-4)
|
|
|
|
|
#define USB_RET_IOERROR (-5)
|
|
|
|
|
#define USB_RET_ASYNC (-6)
|
|
|
|
|
#define USB_RET_ADD_TO_QUEUE (-7)
|
2012-10-24 20:14:08 +04:00
|
|
|
#define USB_RET_REMOVE_FROM_QUEUE (-8)
|
2005-11-05 17:22:28 +03:00
|
|
|
|
|
|
|
|
#define USB_SPEED_LOW 0
|
|
|
|
|
#define USB_SPEED_FULL 1
|
|
|
|
|
#define USB_SPEED_HIGH 2
|
2010-12-03 19:30:13 +03:00
|
|
|
#define USB_SPEED_SUPER 3
|
|
|
|
|
|
|
|
|
|
#define USB_SPEED_MASK_LOW (1 << USB_SPEED_LOW)
|
|
|
|
|
#define USB_SPEED_MASK_FULL (1 << USB_SPEED_FULL)
|
|
|
|
|
#define USB_SPEED_MASK_HIGH (1 << USB_SPEED_HIGH)
|
|
|
|
|
#define USB_SPEED_MASK_SUPER (1 << USB_SPEED_SUPER)
|
2005-11-05 17:22:28 +03:00
|
|
|
|
|
|
|
|
#define USB_STATE_NOTATTACHED 0
|
|
|
|
|
#define USB_STATE_ATTACHED 1
|
|
|
|
|
//#define USB_STATE_POWERED 2
|
|
|
|
|
#define USB_STATE_DEFAULT 3
|
|
|
|
|
//#define USB_STATE_ADDRESS 4
|
|
|
|
|
//#define USB_STATE_CONFIGURED 5
|
|
|
|
|
#define USB_STATE_SUSPENDED 6
|
|
|
|
|
|
2005-11-06 19:13:29 +03:00
|
|
|
#define USB_CLASS_AUDIO 1
|
|
|
|
|
#define USB_CLASS_COMM 2
|
|
|
|
|
#define USB_CLASS_HID 3
|
|
|
|
|
#define USB_CLASS_PHYSICAL 5
|
|
|
|
|
#define USB_CLASS_STILL_IMAGE 6
|
|
|
|
|
#define USB_CLASS_PRINTER 7
|
|
|
|
|
#define USB_CLASS_MASS_STORAGE 8
|
|
|
|
|
#define USB_CLASS_HUB 9
|
|
|
|
|
#define USB_CLASS_CDC_DATA 0x0a
|
|
|
|
|
#define USB_CLASS_CSCID 0x0b
|
|
|
|
|
#define USB_CLASS_CONTENT_SEC 0x0d
|
|
|
|
|
#define USB_CLASS_APP_SPEC 0xfe
|
|
|
|
|
#define USB_CLASS_VENDOR_SPEC 0xff
|
|
|
|
|
|
2010-09-11 01:47:56 +04:00
|
|
|
#define USB_SUBCLASS_UNDEFINED 0
|
|
|
|
|
#define USB_SUBCLASS_AUDIO_CONTROL 1
|
|
|
|
|
#define USB_SUBCLASS_AUDIO_STREAMING 2
|
|
|
|
|
#define USB_SUBCLASS_AUDIO_MIDISTREAMING 3
|
|
|
|
|
|
2005-11-05 17:22:28 +03:00
|
|
|
#define USB_DIR_OUT 0
|
|
|
|
|
#define USB_DIR_IN 0x80
|
|
|
|
|
|
|
|
|
|
#define USB_TYPE_MASK (0x03 << 5)
|
|
|
|
|
#define USB_TYPE_STANDARD (0x00 << 5)
|
|
|
|
|
#define USB_TYPE_CLASS (0x01 << 5)
|
|
|
|
|
#define USB_TYPE_VENDOR (0x02 << 5)
|
|
|
|
|
#define USB_TYPE_RESERVED (0x03 << 5)
|
|
|
|
|
|
|
|
|
|
#define USB_RECIP_MASK 0x1f
|
|
|
|
|
#define USB_RECIP_DEVICE 0x00
|
|
|
|
|
#define USB_RECIP_INTERFACE 0x01
|
|
|
|
|
#define USB_RECIP_ENDPOINT 0x02
|
|
|
|
|
#define USB_RECIP_OTHER 0x03
|
|
|
|
|
|
|
|
|
|
#define DeviceRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
|
|
|
|
|
#define DeviceOutRequest ((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_DEVICE)<<8)
|
2013-11-19 15:37:58 +04:00
|
|
|
#define VendorDeviceRequest ((USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
|
|
|
|
|
#define VendorDeviceOutRequest \
|
|
|
|
|
((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
|
|
|
|
|
|
|
|
|
|
#define InterfaceRequest \
|
2005-11-05 19:57:08 +03:00
|
|
|
((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
|
|
|
|
|
#define InterfaceOutRequest \
|
|
|
|
|
((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_INTERFACE)<<8)
|
2010-03-14 14:19:03 +03:00
|
|
|
#define ClassInterfaceRequest \
|
|
|
|
|
((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
|
|
|
|
|
#define ClassInterfaceOutRequest \
|
|
|
|
|
((USB_DIR_OUT|USB_TYPE_CLASS|USB_RECIP_INTERFACE)<<8)
|
2013-11-19 15:37:58 +04:00
|
|
|
#define VendorInterfaceRequest \
|
|
|
|
|
((USB_DIR_IN|USB_TYPE_VENDOR|USB_RECIP_INTERFACE)<<8)
|
|
|
|
|
#define VendorInterfaceOutRequest \
|
|
|
|
|
((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE)<<8)
|
|
|
|
|
|
|
|
|
|
#define EndpointRequest ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8)
|
|
|
|
|
#define EndpointOutRequest \
|
|
|
|
|
((USB_DIR_OUT|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT)<<8)
|
2005-11-05 17:22:28 +03:00
|
|
|
|
|
|
|
|
#define USB_REQ_GET_STATUS 0x00
|
|
|
|
|
#define USB_REQ_CLEAR_FEATURE 0x01
|
|
|
|
|
#define USB_REQ_SET_FEATURE 0x03
|
|
|
|
|
#define USB_REQ_SET_ADDRESS 0x05
|
|
|
|
|
#define USB_REQ_GET_DESCRIPTOR 0x06
|
|
|
|
|
#define USB_REQ_SET_DESCRIPTOR 0x07
|
|
|
|
|
#define USB_REQ_GET_CONFIGURATION 0x08
|
|
|
|
|
#define USB_REQ_SET_CONFIGURATION 0x09
|
|
|
|
|
#define USB_REQ_GET_INTERFACE 0x0A
|
|
|
|
|
#define USB_REQ_SET_INTERFACE 0x0B
|
|
|
|
|
#define USB_REQ_SYNCH_FRAME 0x0C
|
2017-01-31 16:52:07 +03:00
|
|
|
#define USB_REQ_SET_SEL 0x30
|
|
|
|
|
#define USB_REQ_SET_ISOCH_DELAY 0x31
|
2005-11-05 17:22:28 +03:00
|
|
|
|
|
|
|
|
#define USB_DEVICE_SELF_POWERED 0
|
|
|
|
|
#define USB_DEVICE_REMOTE_WAKEUP 1
|
|
|
|
|
|
|
|
|
|
#define USB_DT_DEVICE 0x01
|
|
|
|
|
#define USB_DT_CONFIG 0x02
|
|
|
|
|
#define USB_DT_STRING 0x03
|
|
|
|
|
#define USB_DT_INTERFACE 0x04
|
|
|
|
|
#define USB_DT_ENDPOINT 0x05
|
2010-12-08 19:35:22 +03:00
|
|
|
#define USB_DT_DEVICE_QUALIFIER 0x06
|
|
|
|
|
#define USB_DT_OTHER_SPEED_CONFIG 0x07
|
2011-06-23 19:15:43 +04:00
|
|
|
#define USB_DT_DEBUG 0x0A
|
2011-04-03 09:33:18 +04:00
|
|
|
#define USB_DT_INTERFACE_ASSOC 0x0B
|
2012-08-28 19:46:29 +04:00
|
|
|
#define USB_DT_BOS 0x0F
|
|
|
|
|
#define USB_DT_DEVICE_CAPABILITY 0x10
|
2010-09-11 01:47:56 +04:00
|
|
|
#define USB_DT_CS_INTERFACE 0x24
|
|
|
|
|
#define USB_DT_CS_ENDPOINT 0x25
|
2012-08-28 19:28:03 +04:00
|
|
|
#define USB_DT_ENDPOINT_COMPANION 0x30
|
2005-11-05 17:22:28 +03:00
|
|
|
|
2012-08-28 19:46:29 +04:00
|
|
|
#define USB_DEV_CAP_WIRELESS 0x01
|
|
|
|
|
#define USB_DEV_CAP_USB2_EXT 0x02
|
|
|
|
|
#define USB_DEV_CAP_SUPERSPEED 0x03
|
|
|
|
|
|
2013-12-16 11:42:49 +04:00
|
|
|
#define USB_CFG_ATT_ONE (1 << 7) /* should always be set */
|
|
|
|
|
#define USB_CFG_ATT_SELFPOWER (1 << 6)
|
|
|
|
|
#define USB_CFG_ATT_WAKEUP (1 << 5)
|
|
|
|
|
#define USB_CFG_ATT_BATTERY (1 << 4)
|
|
|
|
|
|
2008-04-22 07:15:10 +04:00
|
|
|
#define USB_ENDPOINT_XFER_CONTROL 0
|
|
|
|
|
#define USB_ENDPOINT_XFER_ISOC 1
|
|
|
|
|
#define USB_ENDPOINT_XFER_BULK 2
|
|
|
|
|
#define USB_ENDPOINT_XFER_INT 3
|
2011-08-29 14:49:46 +04:00
|
|
|
#define USB_ENDPOINT_XFER_INVALID 255
|
2008-04-22 07:15:10 +04:00
|
|
|
|
2012-07-03 12:15:08 +04:00
|
|
|
#define USB_INTERFACE_INVALID 255
|
|
|
|
|
|
2011-05-23 19:37:12 +04:00
|
|
|
typedef struct USBBusOps USBBusOps;
|
2005-11-05 17:22:28 +03:00
|
|
|
typedef struct USBPort USBPort;
|
|
|
|
|
typedef struct USBDevice USBDevice;
|
2006-08-12 05:04:27 +04:00
|
|
|
typedef struct USBPacket USBPacket;
|
usb: Add packet combining functions
Currently we only do pipelining for output endpoints, since to properly
support short-not-ok semantics we can only have one outstanding input
packet. Since the ehci and uhci controllers have a limited per td packet
size guests will split large input transfers to into multiple packets,
and since we don't pipeline these, this comes with a serious performance
penalty.
This patch adds helper functions to (re-)combine packets which belong to 1
transfer at the guest device-driver level into 1 large transger. This can be
used by (redirection) usb-devices to enable pipelining for input endpoints.
This patch will combine packets together until a transfer terminating packet
is encountered. A terminating packet is a packet which meets one or more of
the following conditions:
1) The packet size is *not* a multiple of the endpoint max packet size
2) The packet does *not* have its short-not-ok flag set
3) The packet has its interrupt-on-complete flag set
The short-not-ok flag of the combined packet is that of the terminating packet.
Multiple combined packets may be submitted to the device, if the combined
packets do not have their short-not-ok flag set, enabling true pipelining.
If a combined packet does have its short-not-ok flag set the queue will
wait with submitting further packets to the device until that packet has
completed.
Once enabled in the usb-redir and ehci code, this improves the speed (MB/s)
of a Linux guest reading from a USB mass storage device by a factor of
1.2 - 1.5.
And the main reason why I started working on this, when reading from a pl2303
USB<->serial converter, it combines the previous 4 packets submitted per
device-driver level read into 1 big read, reducing the number of packets / sec
by a factor 4, and it allows to have multiple reads outstanding. This allows
for much better latency tolerance without the pl2303's internal buffer
overflowing (which was happening at 115200 bps, without serial flow control).
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-10-31 16:47:09 +04:00
|
|
|
typedef struct USBCombinedPacket USBCombinedPacket;
|
2011-08-29 14:49:46 +04:00
|
|
|
typedef struct USBEndpoint USBEndpoint;
|
2005-11-05 17:22:28 +03:00
|
|
|
|
2010-11-17 13:03:53 +03:00
|
|
|
typedef struct USBDesc USBDesc;
|
|
|
|
|
typedef struct USBDescID USBDescID;
|
|
|
|
|
typedef struct USBDescDevice USBDescDevice;
|
|
|
|
|
typedef struct USBDescConfig USBDescConfig;
|
2011-04-03 09:33:21 +04:00
|
|
|
typedef struct USBDescIfaceAssoc USBDescIfaceAssoc;
|
2010-11-17 13:03:53 +03:00
|
|
|
typedef struct USBDescIface USBDescIface;
|
|
|
|
|
typedef struct USBDescEndpoint USBDescEndpoint;
|
|
|
|
|
typedef struct USBDescOther USBDescOther;
|
2010-11-26 14:25:32 +03:00
|
|
|
typedef struct USBDescString USBDescString;
|
2013-11-20 10:32:31 +04:00
|
|
|
typedef struct USBDescMSOS USBDescMSOS;
|
2010-11-26 14:25:32 +03:00
|
|
|
|
|
|
|
|
struct USBDescString {
|
|
|
|
|
uint8_t index;
|
|
|
|
|
char *str;
|
|
|
|
|
QLIST_ENTRY(USBDescString) next;
|
|
|
|
|
};
|
2010-11-17 13:03:53 +03:00
|
|
|
|
2011-08-30 15:21:27 +04:00
|
|
|
#define USB_MAX_ENDPOINTS 15
|
|
|
|
|
#define USB_MAX_INTERFACES 16
|
|
|
|
|
|
2011-08-29 14:49:46 +04:00
|
|
|
struct USBEndpoint {
|
2012-01-12 16:24:22 +04:00
|
|
|
uint8_t nr;
|
|
|
|
|
uint8_t pid;
|
2011-08-29 14:49:46 +04:00
|
|
|
uint8_t type;
|
2011-08-29 14:57:48 +04:00
|
|
|
uint8_t ifnum;
|
2011-08-31 18:09:27 +04:00
|
|
|
int max_packet_size;
|
2013-11-19 17:36:56 +04:00
|
|
|
int max_streams;
|
2012-03-01 17:39:28 +04:00
|
|
|
bool pipeline;
|
usb: Halt ep queue en cancel pending packets on a packet error
For controllers which queue up more then 1 packet at a time, we must halt the
ep queue, and inside the controller code cancel all pending packets on an
error.
There are multiple reasons for this:
1) Guests expect the controllers to halt ep queues on error, so that they
get the opportunity to cancel transfers which the scheduled after the failing
one, before processing continues
2) Not cancelling queued up packets after a failed transfer also messes up
the controller state machine, in the case of EHCI causing the following
assert to trigger: "assert(p->qtdaddr == q->qtdaddr)" at hcd-ehci.c:2075
3) For bulk endpoints with pipelining enabled (redirection to a real USB
device), we must cancel all the transfers after this a failed one so that:
a) If they've completed already, they are not processed further causing more
stalls to be reported, originating from the same failed transfer
b) If still in flight, they are cancelled before the guest does
a clear stall, otherwise the guest and device can loose sync!
Note this patch only touches the ehci and uhci controller changes, since AFAIK
no other controllers actually queue up multiple transfer. If I'm wrong on this
other controllers need to be updated too!
Also note that this patch was heavily tested with the ehci code, where I had
a reproducer for a device causing a transfer to fail. The uhci code is not
tested with actually failing transfers and could do with a thorough review!
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-08-17 17:24:49 +04:00
|
|
|
bool halted;
|
2011-12-13 18:58:19 +04:00
|
|
|
USBDevice *dev;
|
2012-01-12 17:26:13 +04:00
|
|
|
QTAILQ_HEAD(, USBPacket) queue;
|
2011-08-29 14:49:46 +04:00
|
|
|
};
|
|
|
|
|
|
2011-08-22 11:09:51 +04:00
|
|
|
enum USBDeviceFlags {
|
2012-11-17 15:47:15 +04:00
|
|
|
USB_DEV_FLAG_IS_HOST,
|
2013-11-20 10:32:31 +04:00
|
|
|
USB_DEV_FLAG_MSOS_DESC_ENABLE,
|
|
|
|
|
USB_DEV_FLAG_MSOS_DESC_IN_USE,
|
2011-08-22 11:09:51 +04:00
|
|
|
};
|
|
|
|
|
|
2005-11-05 17:22:28 +03:00
|
|
|
/* definition of a USB device */
|
|
|
|
|
struct USBDevice {
|
2009-08-31 16:23:59 +04:00
|
|
|
DeviceState qdev;
|
2010-12-01 13:27:05 +03:00
|
|
|
USBPort *port;
|
2010-12-10 13:43:35 +03:00
|
|
|
char *port_path;
|
2013-06-12 15:01:49 +04:00
|
|
|
char *serial;
|
2005-11-05 17:22:28 +03:00
|
|
|
void *opaque;
|
2011-08-22 11:09:51 +04:00
|
|
|
uint32_t flags;
|
2008-08-21 23:29:38 +04:00
|
|
|
|
2021-01-19 22:44:51 +03:00
|
|
|
char *pcap_filename;
|
|
|
|
|
FILE *pcap;
|
|
|
|
|
|
2011-05-27 16:27:18 +04:00
|
|
|
/* Actual connected speed */
|
2009-08-31 16:23:59 +04:00
|
|
|
int speed;
|
2011-05-27 16:27:18 +04:00
|
|
|
/* Supported speeds, not in info because it may be variable (hostdevs) */
|
|
|
|
|
int speedmask;
|
2009-08-31 16:23:59 +04:00
|
|
|
uint8_t addr;
|
2009-12-09 19:07:51 +03:00
|
|
|
char product_desc[32];
|
2009-10-26 17:56:48 +03:00
|
|
|
int auto_attach;
|
2016-06-15 12:46:56 +03:00
|
|
|
bool attached;
|
2009-08-31 16:23:59 +04:00
|
|
|
|
2010-12-10 16:20:46 +03:00
|
|
|
int32_t state;
|
2009-08-31 16:23:59 +04:00
|
|
|
uint8_t setup_buf[8];
|
2011-02-02 19:46:00 +03:00
|
|
|
uint8_t data_buf[4096];
|
2010-12-10 16:20:46 +03:00
|
|
|
int32_t remote_wakeup;
|
|
|
|
|
int32_t setup_state;
|
|
|
|
|
int32_t setup_len;
|
|
|
|
|
int32_t setup_index;
|
2010-11-26 14:25:32 +03:00
|
|
|
|
2011-12-13 18:58:19 +04:00
|
|
|
USBEndpoint ep_ctl;
|
2011-08-29 14:49:46 +04:00
|
|
|
USBEndpoint ep_in[USB_MAX_ENDPOINTS];
|
|
|
|
|
USBEndpoint ep_out[USB_MAX_ENDPOINTS];
|
|
|
|
|
|
2010-11-26 14:25:32 +03:00
|
|
|
QLIST_HEAD(, USBDescString) strings;
|
2012-11-17 15:47:16 +04:00
|
|
|
const USBDesc *usb_desc; /* Overrides class usb_desc if not NULL */
|
2010-11-26 22:20:41 +03:00
|
|
|
const USBDescDevice *device;
|
2011-08-30 13:11:29 +04:00
|
|
|
|
|
|
|
|
int configuration;
|
|
|
|
|
int ninterfaces;
|
2011-08-30 15:21:27 +04:00
|
|
|
int altsetting[USB_MAX_INTERFACES];
|
2010-11-26 22:20:41 +03:00
|
|
|
const USBDescConfig *config;
|
2011-08-30 15:21:27 +04:00
|
|
|
const USBDescIface *ifaces[USB_MAX_INTERFACES];
|
2009-08-31 16:23:59 +04:00
|
|
|
};
|
|
|
|
|
|
2011-12-16 00:53:10 +04:00
|
|
|
#define TYPE_USB_DEVICE "usb-device"
|
2020-09-16 21:25:18 +03:00
|
|
|
OBJECT_DECLARE_TYPE(USBDevice, USBDeviceClass, USB_DEVICE)
|
2011-12-16 00:53:10 +04:00
|
|
|
|
2014-09-19 10:48:24 +04:00
|
|
|
typedef void (*USBDeviceRealize)(USBDevice *dev, Error **errp);
|
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 18:29:24 +03:00
|
|
|
typedef void (*USBDeviceUnrealize)(USBDevice *dev);
|
2014-09-19 10:48:24 +04:00
|
|
|
|
2020-09-03 23:43:22 +03:00
|
|
|
struct USBDeviceClass {
|
2011-12-16 00:53:10 +04:00
|
|
|
DeviceClass parent_class;
|
|
|
|
|
|
2014-09-19 10:48:24 +04:00
|
|
|
USBDeviceRealize realize;
|
|
|
|
|
USBDeviceUnrealize unrealize;
|
|
|
|
|
|
2012-01-10 19:59:28 +04:00
|
|
|
/*
|
|
|
|
|
* Walk (enabled) downstream ports, check for a matching device.
|
|
|
|
|
* Only hubs implement this.
|
|
|
|
|
*/
|
|
|
|
|
USBDevice *(*find_device)(USBDevice *dev, uint8_t addr);
|
|
|
|
|
|
2011-05-16 12:34:53 +04:00
|
|
|
/*
|
|
|
|
|
* Called when a packet is canceled.
|
|
|
|
|
*/
|
|
|
|
|
void (*cancel_packet)(USBDevice *dev, USBPacket *p);
|
|
|
|
|
|
2010-12-03 19:59:36 +03:00
|
|
|
/*
|
|
|
|
|
* Attach the device
|
|
|
|
|
*/
|
|
|
|
|
void (*handle_attach)(USBDevice *dev);
|
|
|
|
|
|
2008-08-21 23:29:38 +04:00
|
|
|
/*
|
|
|
|
|
* Reset the device
|
2009-08-31 16:23:59 +04:00
|
|
|
*/
|
2006-07-19 22:06:15 +04:00
|
|
|
void (*handle_reset)(USBDevice *dev);
|
2008-08-21 23:29:38 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Process control request.
|
|
|
|
|
* Called from handle_packet().
|
|
|
|
|
*
|
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 20:15:01 +04:00
|
|
|
* Status gets stored in p->status, and if p->status == USB_RET_SUCCESS
|
2012-11-23 10:26:04 +04:00
|
|
|
* then the number of bytes transferred is stored in p->actual_length
|
2008-08-21 23:29:38 +04: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 20:15:01 +04:00
|
|
|
void (*handle_control)(USBDevice *dev, USBPacket *p, int request, int value,
|
|
|
|
|
int index, int length, uint8_t *data);
|
2008-08-21 23:29:38 +04:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Process data transfers (both BULK and ISOC).
|
|
|
|
|
* Called from handle_packet().
|
|
|
|
|
*
|
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 20:15:01 +04:00
|
|
|
* Status gets stored in p->status, and if p->status == USB_RET_SUCCESS
|
2012-11-23 10:26:04 +04:00
|
|
|
* then the number of bytes transferred is stored in p->actual_length
|
2008-08-21 23:29:38 +04: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 20:15:01 +04:00
|
|
|
void (*handle_data)(USBDevice *dev, USBPacket *p);
|
2009-10-26 17:56:45 +03:00
|
|
|
|
2011-08-30 15:21:27 +04:00
|
|
|
void (*set_interface)(USBDevice *dev, int interface,
|
|
|
|
|
int alt_old, int alt_new);
|
|
|
|
|
|
2012-10-24 20:14:07 +04:00
|
|
|
/*
|
|
|
|
|
* Called when the hcd is done queuing packets for an endpoint, only
|
|
|
|
|
* necessary for devices which can return USB_RET_ADD_TO_QUEUE.
|
|
|
|
|
*/
|
|
|
|
|
void (*flush_ep_queue)(USBDevice *dev, USBEndpoint *ep);
|
|
|
|
|
|
2012-12-14 17:35:40 +04:00
|
|
|
/*
|
|
|
|
|
* Called by the hcd to let the device know the queue for an endpoint
|
|
|
|
|
* has been unlinked / stopped. Optional may be NULL.
|
|
|
|
|
*/
|
|
|
|
|
void (*ep_stopped)(USBDevice *dev, USBEndpoint *ep);
|
|
|
|
|
|
2013-11-19 17:36:57 +04:00
|
|
|
/*
|
|
|
|
|
* Called by the hcd to alloc / free streams on a bulk endpoint.
|
|
|
|
|
* Optional may be NULL.
|
|
|
|
|
*/
|
|
|
|
|
int (*alloc_streams)(USBDevice *dev, USBEndpoint **eps, int nr_eps,
|
|
|
|
|
int streams);
|
|
|
|
|
void (*free_streams)(USBDevice *dev, USBEndpoint **eps, int nr_eps);
|
|
|
|
|
|
2009-12-09 19:07:52 +03:00
|
|
|
const char *product_desc;
|
2010-11-17 13:03:53 +03:00
|
|
|
const USBDesc *usb_desc;
|
2016-06-15 12:46:57 +03:00
|
|
|
bool attached_settable;
|
2020-09-03 23:43:22 +03:00
|
|
|
};
|
2005-11-05 17:22:28 +03:00
|
|
|
|
2010-12-01 13:08:44 +03:00
|
|
|
typedef struct USBPortOps {
|
2010-12-01 13:27:05 +03:00
|
|
|
void (*attach)(USBPort *port);
|
|
|
|
|
void (*detach)(USBPort *port);
|
2011-06-24 14:31:11 +04:00
|
|
|
/*
|
|
|
|
|
* This gets called when a device downstream from the device attached to
|
|
|
|
|
* the port (iow attached through a hub) gets detached.
|
|
|
|
|
*/
|
|
|
|
|
void (*child_detach)(USBPort *port, USBDevice *child);
|
2011-06-21 13:52:28 +04:00
|
|
|
void (*wakeup)(USBPort *port);
|
|
|
|
|
/*
|
|
|
|
|
* Note that port->dev will be different then the device from which
|
2012-01-12 15:51:48 +04:00
|
|
|
* the packet originated when a hub is involved.
|
2011-06-21 13:52:28 +04:00
|
|
|
*/
|
|
|
|
|
void (*complete)(USBPort *port, USBPacket *p);
|
2010-12-01 13:08:44 +03:00
|
|
|
} USBPortOps;
|
2006-05-21 20:30:15 +04:00
|
|
|
|
2005-11-05 17:22:28 +03:00
|
|
|
/* USB port on which a device can be connected */
|
|
|
|
|
struct USBPort {
|
2005-11-06 19:13:29 +03:00
|
|
|
USBDevice *dev;
|
2010-12-03 19:30:13 +03:00
|
|
|
int speedmask;
|
2013-03-20 14:40:02 +04:00
|
|
|
int hubcount;
|
2010-12-10 13:37:45 +03:00
|
|
|
char path[16];
|
2010-12-01 13:08:44 +03:00
|
|
|
USBPortOps *ops;
|
2005-11-05 17:22:28 +03:00
|
|
|
void *opaque;
|
|
|
|
|
int index; /* internal port index, may be used with the opaque */
|
2009-09-12 11:36:22 +04:00
|
|
|
QTAILQ_ENTRY(USBPort) next;
|
2005-11-05 17:22:28 +03:00
|
|
|
};
|
|
|
|
|
|
2006-08-12 05:04:27 +04:00
|
|
|
typedef void USBCallback(USBPacket * packet, void *opaque);
|
|
|
|
|
|
2012-01-12 15:51:48 +04:00
|
|
|
typedef enum USBPacketState {
|
|
|
|
|
USB_PACKET_UNDEFINED = 0,
|
|
|
|
|
USB_PACKET_SETUP,
|
2012-01-12 17:26:13 +04:00
|
|
|
USB_PACKET_QUEUED,
|
2012-01-12 15:51:48 +04:00
|
|
|
USB_PACKET_ASYNC,
|
|
|
|
|
USB_PACKET_COMPLETE,
|
|
|
|
|
USB_PACKET_CANCELED,
|
|
|
|
|
} USBPacketState;
|
|
|
|
|
|
2012-01-12 17:26:13 +04:00
|
|
|
/* Structure used to hold information about an active USB packet. */
|
2006-08-12 05:04:27 +04:00
|
|
|
struct USBPacket {
|
|
|
|
|
/* Data fields for use by the driver. */
|
|
|
|
|
int pid;
|
2012-08-23 15:30:13 +04:00
|
|
|
uint64_t id;
|
2012-01-12 15:51:48 +04:00
|
|
|
USBEndpoint *ep;
|
2013-01-29 15:44:35 +04:00
|
|
|
unsigned int stream;
|
2011-07-12 17:22:25 +04:00
|
|
|
QEMUIOVector iov;
|
2012-03-02 16:22:29 +04:00
|
|
|
uint64_t parameter; /* control transfers */
|
2012-10-24 20:14:09 +04:00
|
|
|
bool short_not_ok;
|
2012-10-24 20:14:10 +04:00
|
|
|
bool int_req;
|
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 20:15:01 +04:00
|
|
|
int status; /* USB_RET_* status code */
|
2012-11-23 10:26:04 +04:00
|
|
|
int actual_length; /* Number of bytes actually transferred */
|
2006-08-12 05:04:27 +04:00
|
|
|
/* Internal use by the USB layer. */
|
2012-01-12 15:51:48 +04:00
|
|
|
USBPacketState state;
|
usb: Add packet combining functions
Currently we only do pipelining for output endpoints, since to properly
support short-not-ok semantics we can only have one outstanding input
packet. Since the ehci and uhci controllers have a limited per td packet
size guests will split large input transfers to into multiple packets,
and since we don't pipeline these, this comes with a serious performance
penalty.
This patch adds helper functions to (re-)combine packets which belong to 1
transfer at the guest device-driver level into 1 large transger. This can be
used by (redirection) usb-devices to enable pipelining for input endpoints.
This patch will combine packets together until a transfer terminating packet
is encountered. A terminating packet is a packet which meets one or more of
the following conditions:
1) The packet size is *not* a multiple of the endpoint max packet size
2) The packet does *not* have its short-not-ok flag set
3) The packet has its interrupt-on-complete flag set
The short-not-ok flag of the combined packet is that of the terminating packet.
Multiple combined packets may be submitted to the device, if the combined
packets do not have their short-not-ok flag set, enabling true pipelining.
If a combined packet does have its short-not-ok flag set the queue will
wait with submitting further packets to the device until that packet has
completed.
Once enabled in the usb-redir and ehci code, this improves the speed (MB/s)
of a Linux guest reading from a USB mass storage device by a factor of
1.2 - 1.5.
And the main reason why I started working on this, when reading from a pl2303
USB<->serial converter, it combines the previous 4 packets submitted per
device-driver level read into 1 big read, reducing the number of packets / sec
by a factor 4, and it allows to have multiple reads outstanding. This allows
for much better latency tolerance without the pl2303's internal buffer
overflowing (which was happening at 115200 bps, without serial flow control).
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-10-31 16:47:09 +04:00
|
|
|
USBCombinedPacket *combined;
|
2012-01-12 17:26:13 +04:00
|
|
|
QTAILQ_ENTRY(USBPacket) queue;
|
usb: Add packet combining functions
Currently we only do pipelining for output endpoints, since to properly
support short-not-ok semantics we can only have one outstanding input
packet. Since the ehci and uhci controllers have a limited per td packet
size guests will split large input transfers to into multiple packets,
and since we don't pipeline these, this comes with a serious performance
penalty.
This patch adds helper functions to (re-)combine packets which belong to 1
transfer at the guest device-driver level into 1 large transger. This can be
used by (redirection) usb-devices to enable pipelining for input endpoints.
This patch will combine packets together until a transfer terminating packet
is encountered. A terminating packet is a packet which meets one or more of
the following conditions:
1) The packet size is *not* a multiple of the endpoint max packet size
2) The packet does *not* have its short-not-ok flag set
3) The packet has its interrupt-on-complete flag set
The short-not-ok flag of the combined packet is that of the terminating packet.
Multiple combined packets may be submitted to the device, if the combined
packets do not have their short-not-ok flag set, enabling true pipelining.
If a combined packet does have its short-not-ok flag set the queue will
wait with submitting further packets to the device until that packet has
completed.
Once enabled in the usb-redir and ehci code, this improves the speed (MB/s)
of a Linux guest reading from a USB mass storage device by a factor of
1.2 - 1.5.
And the main reason why I started working on this, when reading from a pl2303
USB<->serial converter, it combines the previous 4 packets submitted per
device-driver level read into 1 big read, reducing the number of packets / sec
by a factor 4, and it allows to have multiple reads outstanding. This allows
for much better latency tolerance without the pl2303's internal buffer
overflowing (which was happening at 115200 bps, without serial flow control).
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-10-31 16:47:09 +04:00
|
|
|
QTAILQ_ENTRY(USBPacket) combined_entry;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct USBCombinedPacket {
|
|
|
|
|
USBPacket *first;
|
2018-12-06 15:10:34 +03:00
|
|
|
QTAILQ_HEAD(, USBPacket) packets;
|
usb: Add packet combining functions
Currently we only do pipelining for output endpoints, since to properly
support short-not-ok semantics we can only have one outstanding input
packet. Since the ehci and uhci controllers have a limited per td packet
size guests will split large input transfers to into multiple packets,
and since we don't pipeline these, this comes with a serious performance
penalty.
This patch adds helper functions to (re-)combine packets which belong to 1
transfer at the guest device-driver level into 1 large transger. This can be
used by (redirection) usb-devices to enable pipelining for input endpoints.
This patch will combine packets together until a transfer terminating packet
is encountered. A terminating packet is a packet which meets one or more of
the following conditions:
1) The packet size is *not* a multiple of the endpoint max packet size
2) The packet does *not* have its short-not-ok flag set
3) The packet has its interrupt-on-complete flag set
The short-not-ok flag of the combined packet is that of the terminating packet.
Multiple combined packets may be submitted to the device, if the combined
packets do not have their short-not-ok flag set, enabling true pipelining.
If a combined packet does have its short-not-ok flag set the queue will
wait with submitting further packets to the device until that packet has
completed.
Once enabled in the usb-redir and ehci code, this improves the speed (MB/s)
of a Linux guest reading from a USB mass storage device by a factor of
1.2 - 1.5.
And the main reason why I started working on this, when reading from a pl2303
USB<->serial converter, it combines the previous 4 packets submitted per
device-driver level read into 1 big read, reducing the number of packets / sec
by a factor 4, and it allows to have multiple reads outstanding. This allows
for much better latency tolerance without the pl2303's internal buffer
overflowing (which was happening at 115200 bps, without serial flow control).
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-10-31 16:47:09 +04:00
|
|
|
QEMUIOVector iov;
|
2006-08-12 05:04:27 +04:00
|
|
|
};
|
|
|
|
|
|
2011-07-12 17:22:25 +04:00
|
|
|
void usb_packet_init(USBPacket *p);
|
2012-01-12 17:26:13 +04:00
|
|
|
void usb_packet_set_state(USBPacket *p, USBPacketState state);
|
2012-03-08 15:27:47 +04:00
|
|
|
void usb_packet_check_state(USBPacket *p, USBPacketState expected);
|
2013-01-29 15:44:35 +04:00
|
|
|
void usb_packet_setup(USBPacket *p, int pid,
|
|
|
|
|
USBEndpoint *ep, unsigned int stream,
|
|
|
|
|
uint64_t id, bool short_not_ok, bool int_req);
|
2011-07-12 17:22:25 +04:00
|
|
|
void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len);
|
|
|
|
|
int usb_packet_map(USBPacket *p, QEMUSGList *sgl);
|
2012-06-27 08:50:42 +04:00
|
|
|
void usb_packet_unmap(USBPacket *p, QEMUSGList *sgl);
|
2011-07-12 17:22:25 +04:00
|
|
|
void usb_packet_copy(USBPacket *p, void *ptr, size_t bytes);
|
|
|
|
|
void usb_packet_skip(USBPacket *p, size_t bytes);
|
2013-01-24 18:38:23 +04:00
|
|
|
size_t usb_packet_size(USBPacket *p);
|
2011-07-12 17:22:25 +04:00
|
|
|
void usb_packet_cleanup(USBPacket *p);
|
|
|
|
|
|
2012-01-12 15:51:48 +04:00
|
|
|
static inline bool usb_packet_is_inflight(USBPacket *p)
|
|
|
|
|
{
|
2012-01-12 17:26:13 +04:00
|
|
|
return (p->state == USB_PACKET_QUEUED ||
|
|
|
|
|
p->state == USB_PACKET_ASYNC);
|
2012-01-12 15:51:48 +04:00
|
|
|
}
|
|
|
|
|
|
2012-01-10 19:59:28 +04:00
|
|
|
USBDevice *usb_find_device(USBPort *port, uint8_t addr);
|
|
|
|
|
|
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 20:15:01 +04:00
|
|
|
void usb_handle_packet(USBDevice *dev, USBPacket *p);
|
2011-05-12 15:48:13 +04:00
|
|
|
void usb_packet_complete(USBDevice *dev, USBPacket *p);
|
2012-10-24 20:14:06 +04:00
|
|
|
void usb_packet_complete_one(USBDevice *dev, USBPacket *p);
|
2011-05-12 15:48:13 +04:00
|
|
|
void usb_cancel_packet(USBPacket * p);
|
2011-05-12 15:20:39 +04:00
|
|
|
|
2011-08-29 14:49:46 +04:00
|
|
|
void usb_ep_init(USBDevice *dev);
|
2012-07-03 12:11:21 +04:00
|
|
|
void usb_ep_reset(USBDevice *dev);
|
2011-08-29 15:45:25 +04:00
|
|
|
void usb_ep_dump(USBDevice *dev);
|
2011-08-29 14:49:46 +04:00
|
|
|
struct USBEndpoint *usb_ep_get(USBDevice *dev, int pid, int ep);
|
|
|
|
|
uint8_t usb_ep_get_type(USBDevice *dev, int pid, int ep);
|
|
|
|
|
void usb_ep_set_type(USBDevice *dev, int pid, int ep, uint8_t type);
|
2011-08-29 14:57:48 +04:00
|
|
|
void usb_ep_set_ifnum(USBDevice *dev, int pid, int ep, uint8_t ifnum);
|
2011-08-31 18:09:27 +04:00
|
|
|
void usb_ep_set_max_packet_size(USBDevice *dev, int pid, int ep,
|
|
|
|
|
uint16_t raw);
|
2013-11-19 17:36:56 +04:00
|
|
|
void usb_ep_set_max_streams(USBDevice *dev, int pid, int ep, uint8_t raw);
|
2012-12-12 16:40:59 +04:00
|
|
|
void usb_ep_set_halted(USBDevice *dev, int pid, int ep, bool halted);
|
2012-08-28 11:43:18 +04:00
|
|
|
USBPacket *usb_ep_find_packet_by_id(USBDevice *dev, int pid, int ep,
|
|
|
|
|
uint64_t id);
|
2011-08-29 14:49:46 +04:00
|
|
|
|
usb: Add packet combining functions
Currently we only do pipelining for output endpoints, since to properly
support short-not-ok semantics we can only have one outstanding input
packet. Since the ehci and uhci controllers have a limited per td packet
size guests will split large input transfers to into multiple packets,
and since we don't pipeline these, this comes with a serious performance
penalty.
This patch adds helper functions to (re-)combine packets which belong to 1
transfer at the guest device-driver level into 1 large transger. This can be
used by (redirection) usb-devices to enable pipelining for input endpoints.
This patch will combine packets together until a transfer terminating packet
is encountered. A terminating packet is a packet which meets one or more of
the following conditions:
1) The packet size is *not* a multiple of the endpoint max packet size
2) The packet does *not* have its short-not-ok flag set
3) The packet has its interrupt-on-complete flag set
The short-not-ok flag of the combined packet is that of the terminating packet.
Multiple combined packets may be submitted to the device, if the combined
packets do not have their short-not-ok flag set, enabling true pipelining.
If a combined packet does have its short-not-ok flag set the queue will
wait with submitting further packets to the device until that packet has
completed.
Once enabled in the usb-redir and ehci code, this improves the speed (MB/s)
of a Linux guest reading from a USB mass storage device by a factor of
1.2 - 1.5.
And the main reason why I started working on this, when reading from a pl2303
USB<->serial converter, it combines the previous 4 packets submitted per
device-driver level read into 1 big read, reducing the number of packets / sec
by a factor 4, and it allows to have multiple reads outstanding. This allows
for much better latency tolerance without the pl2303's internal buffer
overflowing (which was happening at 115200 bps, without serial flow control).
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2012-10-31 16:47:09 +04:00
|
|
|
void usb_ep_combine_input_packets(USBEndpoint *ep);
|
|
|
|
|
void usb_combined_input_packet_complete(USBDevice *dev, USBPacket *p);
|
|
|
|
|
void usb_combined_packet_cancel(USBDevice *dev, USBPacket *p);
|
|
|
|
|
|
2014-05-23 18:20:54 +04:00
|
|
|
void usb_pick_speed(USBPort *port);
|
2011-09-01 15:56:37 +04:00
|
|
|
void usb_attach(USBPort *port);
|
|
|
|
|
void usb_detach(USBPort *port);
|
2012-01-06 18:23:10 +04:00
|
|
|
void usb_port_reset(USBPort *port);
|
|
|
|
|
void usb_device_reset(USBDevice *dev);
|
2013-01-29 15:44:35 +04:00
|
|
|
void usb_wakeup(USBEndpoint *ep, unsigned int stream);
|
2011-02-02 19:36:29 +03:00
|
|
|
void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p);
|
2006-08-12 05:04:27 +04:00
|
|
|
|
2005-11-05 17:22:28 +03:00
|
|
|
/* usb-linux.c */
|
2015-02-06 16:18:24 +03:00
|
|
|
void hmp_info_usbhost(Monitor *mon, const QDict *qdict);
|
hw/ppc/spapr: Fix boot path of usb-host storage devices
When passing through an USB storage device to a pseries guest, it
is currently not possible to automatically boot from the device
if the "bootindex" property has been specified, too (e.g. when using
"-device nec-usb-xhci -device usb-host,hostbus=1,hostaddr=2,bootindex=0"
at the command line). The problem is that QEMU builds a device tree path
like "/pci@800000020000000/usb@0/usb-host@1" and passes it to SLOF
in the /chosen/qemu,boot-list property. SLOF, however, probes the
USB device, recognizes that it is a storage device and thus changes
its name to "storage", and additionally adds a child node for the
SCSI LUN, so the correct boot path in SLOF is something like
"/pci@800000020000000/usb@0/storage@1/disk@101000000000000" instead.
So when we detect an USB mass storage device with SCSI interface,
we've got to adjust the firmware boot-device path properly that
SLOF can automatically boot from the device.
Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=1354177
Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
2016-12-15 00:44:17 +03:00
|
|
|
bool usb_host_dev_is_scsi_storage(USBDevice *usbdev);
|
2005-11-05 19:57:08 +03:00
|
|
|
|
2007-11-17 20:14:51 +03:00
|
|
|
/* usb ports of the VM */
|
|
|
|
|
|
|
|
|
|
#define VM_USB_HUB_SIZE 8
|
|
|
|
|
|
2009-08-31 16:23:59 +04:00
|
|
|
/* usb-bus.c */
|
|
|
|
|
|
2012-05-02 11:00:20 +04:00
|
|
|
#define TYPE_USB_BUS "usb-bus"
|
2020-09-16 21:25:19 +03:00
|
|
|
OBJECT_DECLARE_SIMPLE_TYPE(USBBus, USB_BUS)
|
2012-05-02 11:00:20 +04:00
|
|
|
|
2009-08-31 16:23:59 +04:00
|
|
|
struct USBBus {
|
|
|
|
|
BusState qbus;
|
2011-05-23 19:37:12 +04:00
|
|
|
USBBusOps *ops;
|
2009-08-31 16:23:59 +04:00
|
|
|
int busnr;
|
|
|
|
|
int nfree;
|
|
|
|
|
int nused;
|
2009-09-12 11:36:22 +04:00
|
|
|
QTAILQ_HEAD(, USBPort) free;
|
|
|
|
|
QTAILQ_HEAD(, USBPort) used;
|
|
|
|
|
QTAILQ_ENTRY(USBBus) next;
|
2009-08-31 16:23:59 +04:00
|
|
|
};
|
|
|
|
|
|
2011-05-23 19:37:12 +04:00
|
|
|
struct USBBusOps {
|
2015-02-17 16:28:02 +03:00
|
|
|
void (*register_companion)(USBBus *bus, USBPort *ports[],
|
|
|
|
|
uint32_t portcount, uint32_t firstport,
|
|
|
|
|
Error **errp);
|
2013-01-29 15:44:35 +04:00
|
|
|
void (*wakeup_endpoint)(USBBus *bus, USBEndpoint *ep, unsigned int stream);
|
2011-05-23 19:37:12 +04:00
|
|
|
};
|
|
|
|
|
|
2013-08-23 22:32:04 +04:00
|
|
|
void usb_bus_new(USBBus *bus, size_t bus_size,
|
|
|
|
|
USBBusOps *ops, DeviceState *host);
|
2014-06-04 12:31:46 +04:00
|
|
|
void usb_bus_release(USBBus *bus);
|
2009-08-31 16:23:59 +04:00
|
|
|
USBBus *usb_bus_find(int busnr);
|
2011-12-09 00:56:53 +04:00
|
|
|
void usb_legacy_register(const char *typename, const char *usbdevice_name,
|
2021-03-10 20:33:20 +03:00
|
|
|
USBDevice *(*usbdevice_init)(void));
|
2020-06-10 08:32:15 +03:00
|
|
|
USBDevice *usb_new(const char *name);
|
|
|
|
|
bool usb_realize_and_unref(USBDevice *dev, USBBus *bus, Error **errp);
|
2009-08-31 16:23:59 +04:00
|
|
|
USBDevice *usb_create_simple(USBBus *bus, const char *name);
|
2009-10-26 17:56:45 +03:00
|
|
|
USBDevice *usbdevice_create(const char *cmdline);
|
2009-08-31 16:24:00 +04:00
|
|
|
void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index,
|
2011-01-12 13:34:50 +03:00
|
|
|
USBPortOps *ops, int speedmask);
|
2015-02-17 16:28:02 +03:00
|
|
|
void usb_register_companion(const char *masterbus, USBPort *ports[],
|
|
|
|
|
uint32_t portcount, uint32_t firstport,
|
|
|
|
|
void *opaque, USBPortOps *ops, int speedmask,
|
|
|
|
|
Error **errp);
|
2010-12-10 13:37:45 +03:00
|
|
|
void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr);
|
2009-09-25 23:42:39 +04:00
|
|
|
void usb_unregister_port(USBBus *bus, USBPort *port);
|
2014-09-19 10:48:24 +04:00
|
|
|
void usb_claim_port(USBDevice *dev, Error **errp);
|
2011-09-01 15:56:37 +04:00
|
|
|
void usb_release_port(USBDevice *dev);
|
2014-09-19 10:48:24 +04:00
|
|
|
void usb_device_attach(USBDevice *dev, Error **errp);
|
2009-09-25 23:42:39 +04:00
|
|
|
int usb_device_detach(USBDevice *dev);
|
2014-09-19 11:25:20 +04:00
|
|
|
void usb_check_attach(USBDevice *dev, Error **errp);
|
2009-08-31 16:24:00 +04:00
|
|
|
|
|
|
|
|
static inline USBBus *usb_bus_from_device(USBDevice *d)
|
|
|
|
|
{
|
|
|
|
|
return DO_UPCAST(USBBus, qbus, d->qdev.parent_bus);
|
|
|
|
|
}
|
2012-01-13 20:07:20 +04:00
|
|
|
|
|
|
|
|
extern const VMStateDescription vmstate_usb_device;
|
|
|
|
|
|
|
|
|
|
#define VMSTATE_USB_DEVICE(_field, _state) { \
|
|
|
|
|
.name = (stringify(_field)), \
|
|
|
|
|
.size = sizeof(USBDevice), \
|
|
|
|
|
.vmsd = &vmstate_usb_device, \
|
|
|
|
|
.flags = VMS_STRUCT, \
|
|
|
|
|
.offset = vmstate_offset_value(_state, _field, USBDevice), \
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-10 19:59:28 +04:00
|
|
|
USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr);
|
|
|
|
|
|
2011-12-16 00:53:10 +04:00
|
|
|
void usb_device_cancel_packet(USBDevice *dev, USBPacket *p);
|
|
|
|
|
|
|
|
|
|
void usb_device_handle_attach(USBDevice *dev);
|
|
|
|
|
|
|
|
|
|
void usb_device_handle_reset(USBDevice *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 20:15:01 +04:00
|
|
|
void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request,
|
|
|
|
|
int val, int index, int length, uint8_t *data);
|
2011-12-16 00:53:10 +04: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 20:15:01 +04:00
|
|
|
void usb_device_handle_data(USBDevice *dev, USBPacket *p);
|
2011-12-16 00:53:10 +04:00
|
|
|
|
|
|
|
|
void usb_device_set_interface(USBDevice *dev, int interface,
|
|
|
|
|
int alt_old, int alt_new);
|
|
|
|
|
|
2012-10-24 20:14:07 +04:00
|
|
|
void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep);
|
|
|
|
|
|
2012-12-14 17:35:40 +04:00
|
|
|
void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep);
|
|
|
|
|
|
2013-11-19 17:36:57 +04:00
|
|
|
int usb_device_alloc_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps,
|
|
|
|
|
int streams);
|
|
|
|
|
void usb_device_free_streams(USBDevice *dev, USBEndpoint **eps, int nr_eps);
|
|
|
|
|
|
2011-12-16 00:53:10 +04:00
|
|
|
const char *usb_device_get_product_desc(USBDevice *dev);
|
|
|
|
|
|
|
|
|
|
const USBDesc *usb_device_get_usb_desc(USBDevice *dev);
|
|
|
|
|
|
2012-12-19 18:08:33 +04:00
|
|
|
/* quirks.c */
|
|
|
|
|
|
|
|
|
|
/* In bulk endpoints are streaming data sources (iow behave like isoc eps) */
|
|
|
|
|
#define USB_QUIRK_BUFFER_BULK_IN 0x01
|
|
|
|
|
/* Bulk pkts in FTDI format, need special handling when combining packets */
|
|
|
|
|
#define USB_QUIRK_IS_FTDI 0x02
|
2012-01-13 20:07:20 +04:00
|
|
|
|
2012-12-19 18:08:33 +04:00
|
|
|
int usb_get_quirks(uint16_t vendor_id, uint16_t product_id,
|
|
|
|
|
uint8_t interface_class, uint8_t interface_subclass,
|
|
|
|
|
uint8_t interface_protocol);
|
|
|
|
|
|
2021-01-19 22:44:51 +03:00
|
|
|
/* pcap.c */
|
|
|
|
|
void usb_pcap_init(FILE *fp);
|
|
|
|
|
void usb_pcap_ctrl(USBPacket *p, bool setup);
|
|
|
|
|
void usb_pcap_data(USBPacket *p, bool setup);
|
|
|
|
|
|
2012-12-19 18:08:33 +04:00
|
|
|
#endif
|