bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Linux host USB redirector |
| 3 | * |
| 4 | * Copyright (c) 2005 Fabrice Bellard |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 5 | * |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 6 | * Copyright (c) 2008 Max Krasnyansky |
| 7 | * Support for host device auto connect & disconnect |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 8 | * Major rewrite to support fully async operation |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 9 | * |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 10 | * Copyright 2008 TJ <linux@tjworld.net> |
| 11 | * Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition |
| 12 | * to the legacy /proc/bus/usb USB device discovery and handling |
| 13 | * |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 14 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 15 | * of this software and associated documentation files (the "Software"), to deal |
| 16 | * in the Software without restriction, including without limitation the rights |
| 17 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 18 | * copies of the Software, and to permit persons to whom the Software is |
| 19 | * furnished to do so, subject to the following conditions: |
| 20 | * |
| 21 | * The above copyright notice and this permission notice shall be included in |
| 22 | * all copies or substantial portions of the Software. |
| 23 | * |
| 24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 25 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 26 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 27 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 28 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 29 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 30 | * THE SOFTWARE. |
| 31 | */ |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 32 | |
pbrook | 87ecb68 | 2007-11-17 17:14:51 +0000 | [diff] [blame] | 33 | #include "qemu-common.h" |
Paolo Bonzini | 1de7afc | 2012-12-17 18:20:00 +0100 | [diff] [blame] | 34 | #include "qemu/timer.h" |
Paolo Bonzini | 83c9089 | 2012-12-17 18:19:49 +0100 | [diff] [blame] | 35 | #include "monitor/monitor.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 36 | #include "sysemu/sysemu.h" |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 37 | #include "trace.h" |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 38 | |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 39 | #include <dirent.h> |
| 40 | #include <sys/ioctl.h> |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 41 | |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 42 | #include <linux/usbdevice_fs.h> |
| 43 | #include <linux/version.h> |
| 44 | #include "hw/usb.h" |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 45 | #include "hw/usb/desc.h" |
Gerd Hoffmann | 4075975 | 2013-01-23 14:15:38 +0100 | [diff] [blame] | 46 | #include "hw/usb/host.h" |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 47 | |
Gerd Hoffmann | 2b2325f | 2012-11-30 16:02:11 +0100 | [diff] [blame] | 48 | #ifdef CONFIG_USB_LIBUSB |
| 49 | # define DEVNAME "usb-host-linux" |
| 50 | #else |
| 51 | # define DEVNAME "usb-host" |
| 52 | #endif |
| 53 | |
blueswir1 | d9cf157 | 2008-09-15 14:57:11 +0000 | [diff] [blame] | 54 | /* We redefine it to avoid version problems */ |
| 55 | struct usb_ctrltransfer { |
| 56 | uint8_t bRequestType; |
| 57 | uint8_t bRequest; |
| 58 | uint16_t wValue; |
| 59 | uint16_t wIndex; |
| 60 | uint16_t wLength; |
| 61 | uint32_t timeout; |
| 62 | void *data; |
| 63 | }; |
| 64 | |
Gerd Hoffmann | ba9acab | 2011-08-17 23:35:45 +0200 | [diff] [blame] | 65 | typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port, |
Hans de Goede | 0f5160d | 2010-11-10 10:06:23 +0100 | [diff] [blame] | 66 | int class_id, int vendor_id, int product_id, |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 67 | const char *product_name, int speed); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 68 | |
Markus Armbruster | 0745eb1 | 2009-11-27 13:05:53 +0100 | [diff] [blame] | 69 | //#define DEBUG |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 70 | |
| 71 | #ifdef DEBUG |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 72 | #define DPRINTF printf |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 73 | #else |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 74 | #define DPRINTF(...) |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 75 | #endif |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 76 | |
bellard | 1f6e24e | 2006-06-26 21:00:51 +0000 | [diff] [blame] | 77 | #define PRODUCT_NAME_SZ 32 |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 78 | #define MAX_PORTLEN 16 |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 79 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 80 | /* endpoint association data */ |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 81 | #define ISO_FRAME_DESC_PER_URB 32 |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 82 | |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 83 | /* devio.c limits single requests to 16k */ |
| 84 | #define MAX_USBFS_BUFFER_SIZE 16384 |
| 85 | |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 86 | typedef struct AsyncURB AsyncURB; |
| 87 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 88 | struct endp_data { |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 89 | uint8_t halted; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 90 | uint8_t iso_started; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 91 | AsyncURB *iso_urb; |
| 92 | int iso_urb_idx; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 93 | int iso_buffer_used; |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 94 | int inflight; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 95 | }; |
| 96 | |
Gerd Hoffmann | 39c2057 | 2012-03-22 15:28:45 +0100 | [diff] [blame] | 97 | enum USBHostDeviceOptions { |
| 98 | USB_HOST_OPT_PIPELINE, |
| 99 | }; |
| 100 | |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 101 | typedef struct USBHostDevice { |
| 102 | USBDevice dev; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 103 | int fd; |
Gerd Hoffmann | 9516bb4 | 2011-08-24 13:34:17 +0200 | [diff] [blame] | 104 | int hub_fd; |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 105 | int hub_port; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 106 | |
Hans de Goede | f8ddbfb | 2011-05-31 11:35:26 +0200 | [diff] [blame] | 107 | uint8_t descr[8192]; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 108 | int descr_len; |
aliguori | 24772c1 | 2008-08-21 19:31:52 +0000 | [diff] [blame] | 109 | int closing; |
Gerd Hoffmann | b81bcd8 | 2011-06-10 14:03:56 +0200 | [diff] [blame] | 110 | uint32_t iso_urb_count; |
Gerd Hoffmann | 39c2057 | 2012-03-22 15:28:45 +0100 | [diff] [blame] | 111 | uint32_t options; |
Shahar Havivi | b373a63 | 2010-06-16 15:16:11 +0300 | [diff] [blame] | 112 | Notifier exit; |
Gerd Hoffmann | a229c05 | 2012-06-08 13:02:16 +0200 | [diff] [blame] | 113 | QEMUBH *bh; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 114 | |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 115 | struct endp_data ep_in[USB_MAX_ENDPOINTS]; |
| 116 | struct endp_data ep_out[USB_MAX_ENDPOINTS]; |
Gerd Hoffmann | 7a8fc83 | 2011-05-16 09:13:05 +0200 | [diff] [blame] | 117 | QLIST_HEAD(, AsyncURB) aurbs; |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 118 | |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 119 | /* Host side address */ |
| 120 | int bus_num; |
| 121 | int addr; |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 122 | char port[MAX_PORTLEN]; |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 123 | struct USBAutoFilter match; |
Gerd Hoffmann | 65bb3a5 | 2012-03-22 10:48:03 +0100 | [diff] [blame] | 124 | int32_t bootindex; |
Gerd Hoffmann | 3ee886c | 2011-08-24 13:45:06 +0200 | [diff] [blame] | 125 | int seen, errcount; |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 126 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 127 | QTAILQ_ENTRY(USBHostDevice) next; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 128 | } USBHostDevice; |
| 129 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 130 | static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs); |
| 131 | |
| 132 | static int usb_host_close(USBHostDevice *dev); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 133 | static void usb_host_auto_check(void *unused); |
Hans de Goede | 2cc59d8 | 2010-11-10 10:06:25 +0100 | [diff] [blame] | 134 | static int usb_host_read_file(char *line, size_t line_size, |
| 135 | const char *device_file, const char *device_name); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 136 | static void usb_linux_update_endp_table(USBHostDevice *s); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 137 | |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 138 | static int usb_host_usbfs_type(USBHostDevice *s, USBPacket *p) |
| 139 | { |
| 140 | static const int usbfs[] = { |
| 141 | [USB_ENDPOINT_XFER_CONTROL] = USBDEVFS_URB_TYPE_CONTROL, |
| 142 | [USB_ENDPOINT_XFER_ISOC] = USBDEVFS_URB_TYPE_ISO, |
| 143 | [USB_ENDPOINT_XFER_BULK] = USBDEVFS_URB_TYPE_BULK, |
| 144 | [USB_ENDPOINT_XFER_INT] = USBDEVFS_URB_TYPE_INTERRUPT, |
| 145 | }; |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 146 | uint8_t type = p->ep->type; |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 147 | assert(type < ARRAY_SIZE(usbfs)); |
| 148 | return usbfs[type]; |
| 149 | } |
| 150 | |
Gerd Hoffmann | c7662da | 2011-11-16 12:37:17 +0100 | [diff] [blame] | 151 | static int usb_host_do_reset(USBHostDevice *dev) |
| 152 | { |
| 153 | struct timeval s, e; |
| 154 | uint32_t usecs; |
| 155 | int ret; |
| 156 | |
| 157 | gettimeofday(&s, NULL); |
| 158 | ret = ioctl(dev->fd, USBDEVFS_RESET); |
| 159 | gettimeofday(&e, NULL); |
| 160 | usecs = (e.tv_sec - s.tv_sec) * 1000000; |
| 161 | usecs += e.tv_usec - s.tv_usec; |
| 162 | if (usecs > 1000000) { |
| 163 | /* more than a second, something is fishy, broken usb device? */ |
| 164 | fprintf(stderr, "husb: device %d:%d reset took %d.%06d seconds\n", |
| 165 | dev->bus_num, dev->addr, usecs / 1000000, usecs % 1000000); |
| 166 | } |
| 167 | return ret; |
| 168 | } |
| 169 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 170 | static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep) |
Gerd Hoffmann | ca3a36c | 2011-06-10 13:34:10 +0200 | [diff] [blame] | 171 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 172 | struct endp_data *eps = pid == USB_TOKEN_IN ? s->ep_in : s->ep_out; |
| 173 | assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT); |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 174 | assert(ep > 0 && ep <= USB_MAX_ENDPOINTS); |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 175 | return eps + ep - 1; |
Gerd Hoffmann | ca3a36c | 2011-06-10 13:34:10 +0200 | [diff] [blame] | 176 | } |
| 177 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 178 | static int is_isoc(USBHostDevice *s, int pid, int ep) |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 179 | { |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 180 | return usb_ep_get_type(&s->dev, pid, ep) == USB_ENDPOINT_XFER_ISOC; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 181 | } |
| 182 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 183 | static int is_valid(USBHostDevice *s, int pid, int ep) |
Hans de Goede | a0b5fec | 2010-11-26 14:56:17 +0100 | [diff] [blame] | 184 | { |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 185 | return usb_ep_get_type(&s->dev, pid, ep) != USB_ENDPOINT_XFER_INVALID; |
Hans de Goede | a0b5fec | 2010-11-26 14:56:17 +0100 | [diff] [blame] | 186 | } |
| 187 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 188 | static int is_halted(USBHostDevice *s, int pid, int ep) |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 189 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 190 | return get_endp(s, pid, ep)->halted; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 193 | static void clear_halt(USBHostDevice *s, int pid, int ep) |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 194 | { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 195 | trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep); |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 196 | get_endp(s, pid, ep)->halted = 0; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 197 | } |
| 198 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 199 | static void set_halt(USBHostDevice *s, int pid, int ep) |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 200 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 201 | if (ep != 0) { |
| 202 | trace_usb_host_ep_set_halt(s->bus_num, s->addr, ep); |
| 203 | get_endp(s, pid, ep)->halted = 1; |
| 204 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 205 | } |
| 206 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 207 | static int is_iso_started(USBHostDevice *s, int pid, int ep) |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 208 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 209 | return get_endp(s, pid, ep)->iso_started; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 210 | } |
| 211 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 212 | static void clear_iso_started(USBHostDevice *s, int pid, int ep) |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 213 | { |
Gerd Hoffmann | c32da15 | 2012-07-03 15:43:49 +0200 | [diff] [blame] | 214 | trace_usb_host_iso_stop(s->bus_num, s->addr, ep); |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 215 | get_endp(s, pid, ep)->iso_started = 0; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 216 | } |
| 217 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 218 | static void set_iso_started(USBHostDevice *s, int pid, int ep) |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 219 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 220 | struct endp_data *e = get_endp(s, pid, ep); |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 221 | |
Gerd Hoffmann | c32da15 | 2012-07-03 15:43:49 +0200 | [diff] [blame] | 222 | trace_usb_host_iso_start(s->bus_num, s->addr, ep); |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 223 | if (!e->iso_started) { |
| 224 | e->iso_started = 1; |
| 225 | e->inflight = 0; |
| 226 | } |
| 227 | } |
| 228 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 229 | static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value) |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 230 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 231 | struct endp_data *e = get_endp(s, pid, ep); |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 232 | |
| 233 | e->inflight += value; |
| 234 | return e->inflight; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 235 | } |
| 236 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 237 | static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 238 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 239 | get_endp(s, pid, ep)->iso_urb = iso_urb; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 240 | } |
| 241 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 242 | static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 243 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 244 | return get_endp(s, pid, ep)->iso_urb; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 245 | } |
| 246 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 247 | static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 248 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 249 | get_endp(s, pid, ep)->iso_urb_idx = i; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 250 | } |
| 251 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 252 | static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 253 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 254 | return get_endp(s, pid, ep)->iso_urb_idx; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 255 | } |
| 256 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 257 | static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i) |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 258 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 259 | get_endp(s, pid, ep)->iso_buffer_used = i; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 260 | } |
| 261 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 262 | static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep) |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 263 | { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 264 | return get_endp(s, pid, ep)->iso_buffer_used; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 265 | } |
| 266 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 267 | /* |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 268 | * Async URB state. |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 269 | * We always allocate iso packet descriptors even for bulk transfers |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 270 | * to simplify allocation and casts. |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 271 | */ |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 272 | struct AsyncURB |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 273 | { |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 274 | struct usbdevfs_urb urb; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 275 | struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB]; |
Gerd Hoffmann | 7a8fc83 | 2011-05-16 09:13:05 +0200 | [diff] [blame] | 276 | USBHostDevice *hdev; |
| 277 | QLIST_ENTRY(AsyncURB) next; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 278 | |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 279 | /* For regular async urbs */ |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 280 | USBPacket *packet; |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 281 | int more; /* large transfer, more urbs follow */ |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 282 | |
| 283 | /* For buffered iso handling */ |
| 284 | int iso_frame_idx; /* -1 means in flight */ |
| 285 | }; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 286 | |
Gerd Hoffmann | 7a8fc83 | 2011-05-16 09:13:05 +0200 | [diff] [blame] | 287 | static AsyncURB *async_alloc(USBHostDevice *s) |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 288 | { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 289 | AsyncURB *aurb = g_malloc0(sizeof(AsyncURB)); |
Gerd Hoffmann | 7a8fc83 | 2011-05-16 09:13:05 +0200 | [diff] [blame] | 290 | aurb->hdev = s; |
| 291 | QLIST_INSERT_HEAD(&s->aurbs, aurb, next); |
| 292 | return aurb; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 293 | } |
| 294 | |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 295 | static void async_free(AsyncURB *aurb) |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 296 | { |
Gerd Hoffmann | 7a8fc83 | 2011-05-16 09:13:05 +0200 | [diff] [blame] | 297 | QLIST_REMOVE(aurb, next); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 298 | g_free(aurb); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 299 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 300 | |
Gerd Hoffmann | 41c01ee | 2011-05-24 16:12:31 +0200 | [diff] [blame] | 301 | static void do_disconnect(USBHostDevice *s) |
| 302 | { |
Gerd Hoffmann | 41c01ee | 2011-05-24 16:12:31 +0200 | [diff] [blame] | 303 | usb_host_close(s); |
| 304 | usb_host_auto_check(NULL); |
| 305 | } |
| 306 | |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 307 | static void async_complete(void *opaque) |
| 308 | { |
| 309 | USBHostDevice *s = opaque; |
| 310 | AsyncURB *aurb; |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 311 | int urbs = 0; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 312 | |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 313 | while (1) { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 314 | USBPacket *p; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 315 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 316 | int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 317 | if (r < 0) { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 318 | if (errno == EAGAIN) { |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 319 | if (urbs > 2) { |
Gerd Hoffmann | c32da15 | 2012-07-03 15:43:49 +0200 | [diff] [blame] | 320 | /* indicates possible latency issues */ |
| 321 | trace_usb_host_iso_many_urbs(s->bus_num, s->addr, urbs); |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 322 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 323 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 324 | } |
Gerd Hoffmann | 40197c3 | 2011-08-22 14:18:21 +0200 | [diff] [blame] | 325 | if (errno == ENODEV) { |
| 326 | if (!s->closing) { |
| 327 | trace_usb_host_disconnect(s->bus_num, s->addr); |
| 328 | do_disconnect(s); |
| 329 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 330 | return; |
| 331 | } |
| 332 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 333 | perror("USBDEVFS_REAPURBNDELAY"); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 334 | return; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 335 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 336 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 337 | DPRINTF("husb: async completed. aurb %p status %d alen %d\n", |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 338 | aurb, aurb->urb.status, aurb->urb.actual_length); |
| 339 | |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 340 | /* If this is a buffered iso urb mark it as complete and don't do |
| 341 | anything else (it is handled further in usb_host_handle_iso_data) */ |
| 342 | if (aurb->iso_frame_idx == -1) { |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 343 | int inflight; |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 344 | int pid = (aurb->urb.endpoint & USB_DIR_IN) ? |
| 345 | USB_TOKEN_IN : USB_TOKEN_OUT; |
| 346 | int ep = aurb->urb.endpoint & 0xf; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 347 | if (aurb->urb.status == -EPIPE) { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 348 | set_halt(s, pid, ep); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 349 | } |
| 350 | aurb->iso_frame_idx = 0; |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 351 | urbs++; |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 352 | inflight = change_iso_inflight(s, pid, ep, -1); |
| 353 | if (inflight == 0 && is_iso_started(s, pid, ep)) { |
Gerd Hoffmann | c32da15 | 2012-07-03 15:43:49 +0200 | [diff] [blame] | 354 | /* can be latency issues, or simply end of stream */ |
| 355 | trace_usb_host_iso_out_of_bufs(s->bus_num, s->addr, ep); |
Gerd Hoffmann | 8288726 | 2011-06-10 14:00:24 +0200 | [diff] [blame] | 356 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 357 | continue; |
| 358 | } |
| 359 | |
| 360 | p = aurb->packet; |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 361 | trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status, |
| 362 | aurb->urb.actual_length, aurb->more); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 363 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 364 | if (p) { |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 365 | switch (aurb->urb.status) { |
| 366 | case 0: |
Gerd Hoffmann | 71e0aa3 | 2012-11-15 16:11:49 +0100 | [diff] [blame] | 367 | p->actual_length += aurb->urb.actual_length; |
| 368 | if (!aurb->more) { |
| 369 | /* Clear previous ASYNC status */ |
| 370 | p->status = USB_RET_SUCCESS; |
| 371 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 372 | break; |
| 373 | |
| 374 | case -EPIPE: |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 375 | set_halt(s, p->pid, p->ep->nr); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 376 | p->status = USB_RET_STALL; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 377 | break; |
Paul Bolle | dcc7e25 | 2009-10-13 13:40:08 +0200 | [diff] [blame] | 378 | |
Hans de Goede | 4d819a9 | 2012-03-02 21:27:19 +0100 | [diff] [blame] | 379 | case -EOVERFLOW: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 380 | p->status = USB_RET_BABBLE; |
Hans de Goede | 4d819a9 | 2012-03-02 21:27:19 +0100 | [diff] [blame] | 381 | break; |
| 382 | |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 383 | default: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 384 | p->status = USB_RET_IOERROR; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 385 | break; |
| 386 | } |
| 387 | |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 388 | if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) { |
Gerd Hoffmann | 8c908fc | 2012-11-15 16:11:20 +0100 | [diff] [blame] | 389 | trace_usb_host_req_complete(s->bus_num, s->addr, p, |
| 390 | p->status, aurb->urb.actual_length); |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 391 | usb_generic_async_ctrl_complete(&s->dev, p); |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 392 | } else if (!aurb->more) { |
Gerd Hoffmann | 8c908fc | 2012-11-15 16:11:20 +0100 | [diff] [blame] | 393 | trace_usb_host_req_complete(s->bus_num, s->addr, p, |
| 394 | p->status, aurb->urb.actual_length); |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 395 | usb_packet_complete(&s->dev, p); |
| 396 | } |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 397 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 398 | |
| 399 | async_free(aurb); |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 400 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 401 | } |
| 402 | |
Gerd Hoffmann | eb5e680 | 2011-05-16 10:34:53 +0200 | [diff] [blame] | 403 | static void usb_host_async_cancel(USBDevice *dev, USBPacket *p) |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 404 | { |
Gerd Hoffmann | eb5e680 | 2011-05-16 10:34:53 +0200 | [diff] [blame] | 405 | USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); |
Gerd Hoffmann | 227ebeb | 2011-05-16 09:20:06 +0200 | [diff] [blame] | 406 | AsyncURB *aurb; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 407 | |
Gerd Hoffmann | 19b8925 | 2012-03-23 12:35:55 +0100 | [diff] [blame] | 408 | trace_usb_host_req_canceled(s->bus_num, s->addr, p); |
Gerd Hoffmann | 6aebe40 | 2012-03-23 12:26:59 +0100 | [diff] [blame] | 409 | |
Gerd Hoffmann | 227ebeb | 2011-05-16 09:20:06 +0200 | [diff] [blame] | 410 | QLIST_FOREACH(aurb, &s->aurbs, next) { |
| 411 | if (p != aurb->packet) { |
| 412 | continue; |
| 413 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 414 | |
Gerd Hoffmann | 6aebe40 | 2012-03-23 12:26:59 +0100 | [diff] [blame] | 415 | trace_usb_host_urb_canceled(s->bus_num, s->addr, aurb); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 416 | |
Gerd Hoffmann | 227ebeb | 2011-05-16 09:20:06 +0200 | [diff] [blame] | 417 | /* Mark it as dead (see async_complete above) */ |
| 418 | aurb->packet = NULL; |
| 419 | |
| 420 | int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb); |
| 421 | if (r < 0) { |
| 422 | DPRINTF("husb: async. discard urb failed errno %d\n", errno); |
| 423 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 424 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 425 | } |
| 426 | |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 427 | static int usb_host_open_device(int bus, int addr) |
| 428 | { |
| 429 | const char *usbfs = NULL; |
| 430 | char filename[32]; |
| 431 | struct stat st; |
| 432 | int fd, rc; |
| 433 | |
| 434 | rc = stat("/dev/bus/usb", &st); |
| 435 | if (rc == 0 && S_ISDIR(st.st_mode)) { |
| 436 | /* udev-created device nodes available */ |
| 437 | usbfs = "/dev/bus/usb"; |
| 438 | } else { |
| 439 | /* fallback: usbfs mounted below /proc */ |
| 440 | usbfs = "/proc/bus/usb"; |
| 441 | } |
| 442 | |
| 443 | snprintf(filename, sizeof(filename), "%s/%03d/%03d", |
| 444 | usbfs, bus, addr); |
| 445 | fd = open(filename, O_RDWR | O_NONBLOCK); |
| 446 | if (fd < 0) { |
| 447 | fprintf(stderr, "husb: open %s: %s\n", filename, strerror(errno)); |
| 448 | } |
| 449 | return fd; |
| 450 | } |
| 451 | |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 452 | static int usb_host_claim_port(USBHostDevice *s) |
| 453 | { |
| 454 | #ifdef USBDEVFS_CLAIM_PORT |
| 455 | char *h, hub_name[64], line[1024]; |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 456 | int hub_addr, ret; |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 457 | |
| 458 | snprintf(hub_name, sizeof(hub_name), "%d-%s", |
| 459 | s->match.bus_num, s->match.port); |
| 460 | |
| 461 | /* try strip off last ".$portnr" to get hub */ |
| 462 | h = strrchr(hub_name, '.'); |
| 463 | if (h != NULL) { |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 464 | s->hub_port = atoi(h+1); |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 465 | *h = '\0'; |
| 466 | } else { |
| 467 | /* no dot in there -> it is the root hub */ |
| 468 | snprintf(hub_name, sizeof(hub_name), "usb%d", |
| 469 | s->match.bus_num); |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 470 | s->hub_port = atoi(s->match.port); |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 471 | } |
| 472 | |
| 473 | if (!usb_host_read_file(line, sizeof(line), "devnum", |
| 474 | hub_name)) { |
| 475 | return -1; |
| 476 | } |
| 477 | if (sscanf(line, "%d", &hub_addr) != 1) { |
| 478 | return -1; |
| 479 | } |
| 480 | |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 481 | s->hub_fd = usb_host_open_device(s->match.bus_num, hub_addr); |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 482 | if (s->hub_fd < 0) { |
| 483 | return -1; |
| 484 | } |
| 485 | |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 486 | ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &s->hub_port); |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 487 | if (ret < 0) { |
| 488 | close(s->hub_fd); |
| 489 | s->hub_fd = -1; |
| 490 | return -1; |
| 491 | } |
| 492 | |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 493 | trace_usb_host_claim_port(s->match.bus_num, hub_addr, s->hub_port); |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 494 | return 0; |
| 495 | #else |
| 496 | return -1; |
| 497 | #endif |
| 498 | } |
| 499 | |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 500 | static void usb_host_release_port(USBHostDevice *s) |
| 501 | { |
| 502 | if (s->hub_fd == -1) { |
| 503 | return; |
| 504 | } |
| 505 | #ifdef USBDEVFS_RELEASE_PORT |
| 506 | ioctl(s->hub_fd, USBDEVFS_RELEASE_PORT, &s->hub_port); |
| 507 | #endif |
| 508 | close(s->hub_fd); |
| 509 | s->hub_fd = -1; |
| 510 | } |
| 511 | |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 512 | static int usb_host_disconnect_ifaces(USBHostDevice *dev, int nb_interfaces) |
| 513 | { |
| 514 | /* earlier Linux 2.4 do not support that */ |
| 515 | #ifdef USBDEVFS_DISCONNECT |
| 516 | struct usbdevfs_ioctl ctrl; |
| 517 | int ret, interface; |
| 518 | |
| 519 | for (interface = 0; interface < nb_interfaces; interface++) { |
| 520 | ctrl.ioctl_code = USBDEVFS_DISCONNECT; |
| 521 | ctrl.ifno = interface; |
| 522 | ctrl.data = 0; |
| 523 | ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl); |
| 524 | if (ret < 0 && errno != ENODATA) { |
| 525 | perror("USBDEVFS_DISCONNECT"); |
| 526 | return -1; |
| 527 | } |
| 528 | } |
| 529 | #endif |
| 530 | return 0; |
| 531 | } |
| 532 | |
Gerd Hoffmann | 0fcc3bf | 2011-09-13 11:55:15 +0200 | [diff] [blame] | 533 | static int usb_linux_get_num_interfaces(USBHostDevice *s) |
| 534 | { |
| 535 | char device_name[64], line[1024]; |
| 536 | int num_interfaces = 0; |
| 537 | |
Gerd Hoffmann | 0fcc3bf | 2011-09-13 11:55:15 +0200 | [diff] [blame] | 538 | sprintf(device_name, "%d-%s", s->bus_num, s->port); |
| 539 | if (!usb_host_read_file(line, sizeof(line), "bNumInterfaces", |
| 540 | device_name)) { |
| 541 | return -1; |
| 542 | } |
| 543 | if (sscanf(line, "%d", &num_interfaces) != 1) { |
| 544 | return -1; |
| 545 | } |
| 546 | return num_interfaces; |
| 547 | } |
| 548 | |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 549 | static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration) |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 550 | { |
Gerd Hoffmann | 41c01ee | 2011-05-24 16:12:31 +0200 | [diff] [blame] | 551 | const char *op = NULL; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 552 | int dev_descr_len, config_descr_len; |
Blue Swirl | d4c4e6f | 2010-04-25 18:23:04 +0000 | [diff] [blame] | 553 | int interface, nb_interfaces; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 554 | int ret, i; |
| 555 | |
Gerd Hoffmann | 1de14d4 | 2011-08-30 13:21:27 +0200 | [diff] [blame] | 556 | for (i = 0; i < USB_MAX_INTERFACES; i++) { |
| 557 | dev->dev.altsetting[i] = 0; |
| 558 | } |
| 559 | |
Gerd Hoffmann | eb7700b | 2011-08-24 14:45:07 +0200 | [diff] [blame] | 560 | if (configuration == 0) { /* address state - ignore */ |
Gerd Hoffmann | 6536051 | 2011-08-30 11:11:29 +0200 | [diff] [blame] | 561 | dev->dev.ninterfaces = 0; |
| 562 | dev->dev.configuration = 0; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 563 | return 1; |
Gerd Hoffmann | eb7700b | 2011-08-24 14:45:07 +0200 | [diff] [blame] | 564 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 565 | |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 566 | DPRINTF("husb: claiming interfaces. config %d\n", configuration); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 567 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 568 | i = 0; |
| 569 | dev_descr_len = dev->descr[0]; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 570 | if (dev_descr_len > dev->descr_len) { |
Hans de Goede | 61c1117 | 2011-05-31 11:35:20 +0200 | [diff] [blame] | 571 | fprintf(stderr, "husb: update iface failed. descr too short\n"); |
| 572 | return 0; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 573 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 574 | |
| 575 | i += dev_descr_len; |
| 576 | while (i < dev->descr_len) { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 577 | DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n", |
| 578 | i, dev->descr_len, |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 579 | dev->descr[i], dev->descr[i+1]); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 580 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 581 | if (dev->descr[i+1] != USB_DT_CONFIG) { |
| 582 | i += dev->descr[i]; |
| 583 | continue; |
| 584 | } |
| 585 | config_descr_len = dev->descr[i]; |
| 586 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 587 | DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration); |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 588 | |
Gerd Hoffmann | eb7700b | 2011-08-24 14:45:07 +0200 | [diff] [blame] | 589 | if (configuration == dev->descr[i + 5]) { |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 590 | configuration = dev->descr[i + 5]; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 591 | break; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 592 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 593 | |
| 594 | i += config_descr_len; |
| 595 | } |
| 596 | |
| 597 | if (i >= dev->descr_len) { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 598 | fprintf(stderr, |
| 599 | "husb: update iface failed. no matching configuration\n"); |
Hans de Goede | 61c1117 | 2011-05-31 11:35:20 +0200 | [diff] [blame] | 600 | return 0; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 601 | } |
| 602 | nb_interfaces = dev->descr[i + 4]; |
| 603 | |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 604 | if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) { |
| 605 | goto fail; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 606 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 607 | |
| 608 | /* XXX: only grab if all interfaces are free */ |
| 609 | for (interface = 0; interface < nb_interfaces; interface++) { |
Gerd Hoffmann | 41c01ee | 2011-05-24 16:12:31 +0200 | [diff] [blame] | 610 | op = "USBDEVFS_CLAIMINTERFACE"; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 611 | ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface); |
| 612 | if (ret < 0) { |
Gerd Hoffmann | 41c01ee | 2011-05-24 16:12:31 +0200 | [diff] [blame] | 613 | goto fail; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 614 | } |
| 615 | } |
| 616 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 617 | trace_usb_host_claim_interfaces(dev->bus_num, dev->addr, |
| 618 | nb_interfaces, configuration); |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 619 | |
Gerd Hoffmann | 6536051 | 2011-08-30 11:11:29 +0200 | [diff] [blame] | 620 | dev->dev.ninterfaces = nb_interfaces; |
| 621 | dev->dev.configuration = configuration; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 622 | return 1; |
Gerd Hoffmann | 41c01ee | 2011-05-24 16:12:31 +0200 | [diff] [blame] | 623 | |
| 624 | fail: |
| 625 | if (errno == ENODEV) { |
| 626 | do_disconnect(dev); |
| 627 | } |
| 628 | perror(op); |
| 629 | return 0; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 630 | } |
| 631 | |
| 632 | static int usb_host_release_interfaces(USBHostDevice *s) |
| 633 | { |
| 634 | int ret, i; |
| 635 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 636 | trace_usb_host_release_interfaces(s->bus_num, s->addr); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 637 | |
Gerd Hoffmann | 6536051 | 2011-08-30 11:11:29 +0200 | [diff] [blame] | 638 | for (i = 0; i < s->dev.ninterfaces; i++) { |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 639 | ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i); |
| 640 | if (ret < 0) { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 641 | perror("USBDEVFS_RELEASEINTERFACE"); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 642 | return 0; |
| 643 | } |
| 644 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 645 | return 1; |
| 646 | } |
| 647 | |
bellard | 059809e | 2006-07-19 18:06:15 +0000 | [diff] [blame] | 648 | static void usb_host_handle_reset(USBDevice *dev) |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 649 | { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 650 | USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 651 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 652 | trace_usb_host_reset(s->bus_num, s->addr); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 653 | |
Dong Xu Wang | c7e775e | 2013-05-09 15:53:50 +0800 | [diff] [blame] | 654 | usb_host_do_reset(s); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 655 | |
Gerd Hoffmann | eb7700b | 2011-08-24 14:45:07 +0200 | [diff] [blame] | 656 | usb_host_claim_interfaces(s, 0); |
Gerd Hoffmann | 9b87e19 | 2011-08-24 10:55:40 +0200 | [diff] [blame] | 657 | usb_linux_update_endp_table(s); |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 658 | } |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 659 | |
bellard | 059809e | 2006-07-19 18:06:15 +0000 | [diff] [blame] | 660 | static void usb_host_handle_destroy(USBDevice *dev) |
| 661 | { |
| 662 | USBHostDevice *s = (USBHostDevice *)dev; |
| 663 | |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 664 | usb_host_release_port(s); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 665 | usb_host_close(s); |
| 666 | QTAILQ_REMOVE(&hostdevs, s, next); |
Shahar Havivi | b373a63 | 2010-06-16 15:16:11 +0300 | [diff] [blame] | 667 | qemu_remove_exit_notifier(&s->exit); |
bellard | 059809e | 2006-07-19 18:06:15 +0000 | [diff] [blame] | 668 | } |
| 669 | |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 670 | /* iso data is special, we need to keep enough urbs in flight to make sure |
| 671 | that the controller never runs out of them, otherwise the device will |
| 672 | likely suffer a buffer underrun / overrun. */ |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 673 | static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 674 | { |
| 675 | AsyncURB *aurb; |
Gerd Hoffmann | f003397 | 2011-08-31 16:09:27 +0200 | [diff] [blame] | 676 | int i, j, len = usb_ep_get_max_packet_size(&s->dev, pid, ep); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 677 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 678 | aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb)); |
Gerd Hoffmann | b81bcd8 | 2011-06-10 14:03:56 +0200 | [diff] [blame] | 679 | for (i = 0; i < s->iso_urb_count; i++) { |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 680 | aurb[i].urb.endpoint = ep; |
| 681 | aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 682 | aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 683 | aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO; |
| 684 | aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP; |
| 685 | aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB; |
| 686 | for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++) |
| 687 | aurb[i].urb.iso_frame_desc[j].length = len; |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 688 | if (pid == USB_TOKEN_IN) { |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 689 | aurb[i].urb.endpoint |= 0x80; |
| 690 | /* Mark as fully consumed (idle) */ |
| 691 | aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB; |
| 692 | } |
| 693 | } |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 694 | set_iso_urb(s, pid, ep, aurb); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 695 | |
| 696 | return aurb; |
| 697 | } |
| 698 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 699 | static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 700 | { |
| 701 | AsyncURB *aurb; |
| 702 | int i, ret, killed = 0, free = 1; |
| 703 | |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 704 | aurb = get_iso_urb(s, pid, ep); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 705 | if (!aurb) { |
| 706 | return; |
| 707 | } |
| 708 | |
Gerd Hoffmann | b81bcd8 | 2011-06-10 14:03:56 +0200 | [diff] [blame] | 709 | for (i = 0; i < s->iso_urb_count; i++) { |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 710 | /* in flight? */ |
| 711 | if (aurb[i].iso_frame_idx == -1) { |
| 712 | ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]); |
| 713 | if (ret < 0) { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 714 | perror("USBDEVFS_DISCARDURB"); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 715 | free = 0; |
| 716 | continue; |
| 717 | } |
| 718 | killed++; |
| 719 | } |
| 720 | } |
| 721 | |
| 722 | /* Make sure any urbs we've killed are reaped before we free them */ |
| 723 | if (killed) { |
| 724 | async_complete(s); |
| 725 | } |
| 726 | |
Gerd Hoffmann | b81bcd8 | 2011-06-10 14:03:56 +0200 | [diff] [blame] | 727 | for (i = 0; i < s->iso_urb_count; i++) { |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 728 | g_free(aurb[i].urb.buffer); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 729 | } |
| 730 | |
| 731 | if (free) |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 732 | g_free(aurb); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 733 | else |
| 734 | printf("husb: leaking iso urbs because of discard failure\n"); |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 735 | set_iso_urb(s, pid, ep, NULL); |
| 736 | set_iso_urb_idx(s, pid, ep, 0); |
| 737 | clear_iso_started(s, pid, ep); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 738 | } |
| 739 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 740 | static void urb_status_to_usb_ret(int status, USBPacket *p) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 741 | { |
| 742 | switch (status) { |
| 743 | case -EPIPE: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 744 | p->status = USB_RET_STALL; |
| 745 | break; |
Hans de Goede | 4d819a9 | 2012-03-02 21:27:19 +0100 | [diff] [blame] | 746 | case -EOVERFLOW: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 747 | p->status = USB_RET_BABBLE; |
| 748 | break; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 749 | default: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 750 | p->status = USB_RET_IOERROR; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 751 | } |
| 752 | } |
| 753 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 754 | static void usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in) |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 755 | { |
| 756 | AsyncURB *aurb; |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 757 | int i, j, max_packet_size, offset, len; |
Gerd Hoffmann | 4f4321c | 2011-07-12 15:22:25 +0200 | [diff] [blame] | 758 | uint8_t *buf; |
Hans de Goede | 975f299 | 2010-11-26 14:59:35 +0100 | [diff] [blame] | 759 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 760 | max_packet_size = p->ep->max_packet_size; |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 761 | if (max_packet_size == 0) { |
| 762 | p->status = USB_RET_NAK; |
| 763 | return; |
| 764 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 765 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 766 | aurb = get_iso_urb(s, p->pid, p->ep->nr); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 767 | if (!aurb) { |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 768 | aurb = usb_host_alloc_iso(s, p->pid, p->ep->nr); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 769 | } |
| 770 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 771 | i = get_iso_urb_idx(s, p->pid, p->ep->nr); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 772 | j = aurb[i].iso_frame_idx; |
| 773 | if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) { |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 774 | if (in) { |
| 775 | /* Check urb status */ |
| 776 | if (aurb[i].urb.status) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 777 | urb_status_to_usb_ret(aurb[i].urb.status, p); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 778 | /* Move to the next urb */ |
| 779 | aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1; |
| 780 | /* Check frame status */ |
| 781 | } else if (aurb[i].urb.iso_frame_desc[j].status) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 782 | urb_status_to_usb_ret(aurb[i].urb.iso_frame_desc[j].status, p); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 783 | /* Check the frame fits */ |
Gerd Hoffmann | 4f4321c | 2011-07-12 15:22:25 +0200 | [diff] [blame] | 784 | } else if (aurb[i].urb.iso_frame_desc[j].actual_length |
| 785 | > p->iov.size) { |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 786 | printf("husb: received iso data is larger then packet\n"); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 787 | p->status = USB_RET_BABBLE; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 788 | /* All good copy data over */ |
| 789 | } else { |
| 790 | len = aurb[i].urb.iso_frame_desc[j].actual_length; |
Gerd Hoffmann | 4f4321c | 2011-07-12 15:22:25 +0200 | [diff] [blame] | 791 | buf = aurb[i].urb.buffer + |
| 792 | j * aurb[i].urb.iso_frame_desc[0].length; |
| 793 | usb_packet_copy(p, buf, len); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 794 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 795 | } else { |
Gerd Hoffmann | 4f4321c | 2011-07-12 15:22:25 +0200 | [diff] [blame] | 796 | len = p->iov.size; |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 797 | offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->ep->nr); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 798 | |
| 799 | /* Check the frame fits */ |
| 800 | if (len > max_packet_size) { |
| 801 | printf("husb: send iso data is larger then max packet size\n"); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 802 | p->status = USB_RET_NAK; |
| 803 | return; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 804 | } |
| 805 | |
| 806 | /* All good copy data over */ |
Gerd Hoffmann | 4f4321c | 2011-07-12 15:22:25 +0200 | [diff] [blame] | 807 | usb_packet_copy(p, aurb[i].urb.buffer + offset, len); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 808 | aurb[i].urb.iso_frame_desc[j].length = len; |
| 809 | offset += len; |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 810 | set_iso_buffer_used(s, p->pid, p->ep->nr, offset); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 811 | |
| 812 | /* Start the stream once we have buffered enough data */ |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 813 | if (!is_iso_started(s, p->pid, p->ep->nr) && i == 1 && j == 8) { |
| 814 | set_iso_started(s, p->pid, p->ep->nr); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 815 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 816 | } |
| 817 | aurb[i].iso_frame_idx++; |
| 818 | if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) { |
Gerd Hoffmann | b81bcd8 | 2011-06-10 14:03:56 +0200 | [diff] [blame] | 819 | i = (i + 1) % s->iso_urb_count; |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 820 | set_iso_urb_idx(s, p->pid, p->ep->nr, i); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 821 | } |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 822 | } else { |
| 823 | if (in) { |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 824 | set_iso_started(s, p->pid, p->ep->nr); |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 825 | } else { |
| 826 | DPRINTF("hubs: iso out error no free buffer, dropping packet\n"); |
| 827 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 828 | } |
| 829 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 830 | if (is_iso_started(s, p->pid, p->ep->nr)) { |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 831 | /* (Re)-submit all fully consumed / filled urbs */ |
Gerd Hoffmann | b81bcd8 | 2011-06-10 14:03:56 +0200 | [diff] [blame] | 832 | for (i = 0; i < s->iso_urb_count; i++) { |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 833 | if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 834 | if (ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]) < 0) { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 835 | perror("USBDEVFS_SUBMITURB"); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 836 | if (!in || p->status == USB_RET_SUCCESS) { |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 837 | switch(errno) { |
| 838 | case ETIMEDOUT: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 839 | p->status = USB_RET_NAK; |
Stefan Weil | 0225e25 | 2011-05-07 22:10:53 +0200 | [diff] [blame] | 840 | break; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 841 | case EPIPE: |
| 842 | default: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 843 | p->status = USB_RET_STALL; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 844 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 845 | } |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 846 | break; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 847 | } |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 848 | aurb[i].iso_frame_idx = -1; |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 849 | change_iso_inflight(s, p->pid, p->ep->nr, 1); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 850 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 851 | } |
| 852 | } |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 853 | } |
| 854 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 855 | static void usb_host_handle_data(USBDevice *dev, USBPacket *p) |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 856 | { |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 857 | USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 858 | struct usbdevfs_urb *urb; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 859 | AsyncURB *aurb; |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 860 | int ret, rem, prem, v; |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 861 | uint8_t *pbuf; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 862 | uint8_t ep; |
| 863 | |
Gerd Hoffmann | 19b8925 | 2012-03-23 12:35:55 +0100 | [diff] [blame] | 864 | trace_usb_host_req_data(s->bus_num, s->addr, p, |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 865 | p->pid == USB_TOKEN_IN, |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 866 | p->ep->nr, p->iov.size); |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 867 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 868 | if (!is_valid(s, p->pid, p->ep->nr)) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 869 | p->status = USB_RET_NAK; |
Gerd Hoffmann | 8c908fc | 2012-11-15 16:11:20 +0100 | [diff] [blame] | 870 | trace_usb_host_req_complete(s->bus_num, s->addr, p, |
| 871 | p->status, p->actual_length); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 872 | return; |
Hans de Goede | a0b5fec | 2010-11-26 14:56:17 +0100 | [diff] [blame] | 873 | } |
| 874 | |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 875 | if (p->pid == USB_TOKEN_IN) { |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 876 | ep = p->ep->nr | 0x80; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 877 | } else { |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 878 | ep = p->ep->nr; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 879 | } |
| 880 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 881 | if (is_halted(s, p->pid, p->ep->nr)) { |
Gerd Hoffmann | 9b87e19 | 2011-08-24 10:55:40 +0200 | [diff] [blame] | 882 | unsigned int arg = ep; |
| 883 | ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 884 | if (ret < 0) { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 885 | perror("USBDEVFS_CLEAR_HALT"); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 886 | p->status = USB_RET_NAK; |
Gerd Hoffmann | 8c908fc | 2012-11-15 16:11:20 +0100 | [diff] [blame] | 887 | trace_usb_host_req_complete(s->bus_num, s->addr, p, |
| 888 | p->status, p->actual_length); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 889 | return; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 890 | } |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 891 | clear_halt(s, p->pid, p->ep->nr); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 892 | } |
| 893 | |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 894 | if (is_isoc(s, p->pid, p->ep->nr)) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 895 | usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN); |
| 896 | return; |
Hans de Goede | bb6d549 | 2010-11-26 19:11:03 +0100 | [diff] [blame] | 897 | } |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 898 | |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 899 | v = 0; |
Gerd Hoffmann | 818d59d | 2012-04-19 13:35:07 +0200 | [diff] [blame] | 900 | prem = 0; |
| 901 | pbuf = NULL; |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 902 | rem = p->iov.size; |
Gerd Hoffmann | 0b37716 | 2012-04-19 13:36:40 +0200 | [diff] [blame] | 903 | do { |
| 904 | if (prem == 0 && rem > 0) { |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 905 | assert(v < p->iov.niov); |
| 906 | prem = p->iov.iov[v].iov_len; |
| 907 | pbuf = p->iov.iov[v].iov_base; |
| 908 | assert(prem <= rem); |
Gerd Hoffmann | 818d59d | 2012-04-19 13:35:07 +0200 | [diff] [blame] | 909 | v++; |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 910 | } |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 911 | aurb = async_alloc(s); |
| 912 | aurb->packet = p; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 913 | |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 914 | urb = &aurb->urb; |
| 915 | urb->endpoint = ep; |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 916 | urb->type = usb_host_usbfs_type(s, p); |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 917 | urb->usercontext = s; |
| 918 | urb->buffer = pbuf; |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 919 | urb->buffer_length = prem; |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 920 | |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 921 | if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) { |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 922 | urb->buffer_length = MAX_USBFS_BUFFER_SIZE; |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 923 | } |
| 924 | pbuf += urb->buffer_length; |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 925 | prem -= urb->buffer_length; |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 926 | rem -= urb->buffer_length; |
Gerd Hoffmann | b621bab | 2011-07-13 11:28:17 +0200 | [diff] [blame] | 927 | if (rem) { |
| 928 | aurb->more = 1; |
| 929 | } |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 930 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 931 | trace_usb_host_urb_submit(s->bus_num, s->addr, aurb, |
| 932 | urb->buffer_length, aurb->more); |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 933 | ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 934 | |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 935 | DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n", |
| 936 | urb->endpoint, urb->buffer_length, aurb->more, p, aurb); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 937 | |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 938 | if (ret < 0) { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 939 | perror("USBDEVFS_SUBMITURB"); |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 940 | async_free(aurb); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 941 | |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 942 | switch(errno) { |
| 943 | case ETIMEDOUT: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 944 | p->status = USB_RET_NAK; |
Gerd Hoffmann | 8c908fc | 2012-11-15 16:11:20 +0100 | [diff] [blame] | 945 | trace_usb_host_req_complete(s->bus_num, s->addr, p, |
| 946 | p->status, p->actual_length); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 947 | break; |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 948 | case EPIPE: |
| 949 | default: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 950 | p->status = USB_RET_STALL; |
Gerd Hoffmann | 8c908fc | 2012-11-15 16:11:20 +0100 | [diff] [blame] | 951 | trace_usb_host_req_complete(s->bus_num, s->addr, p, |
| 952 | p->status, p->actual_length); |
Gerd Hoffmann | 7113853 | 2011-05-16 10:21:51 +0200 | [diff] [blame] | 953 | } |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 954 | return; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 955 | } |
Gerd Hoffmann | 0b37716 | 2012-04-19 13:36:40 +0200 | [diff] [blame] | 956 | } while (rem > 0); |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 957 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 958 | p->status = USB_RET_ASYNC; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 959 | } |
| 960 | |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 961 | static int ctrl_error(void) |
| 962 | { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 963 | if (errno == ETIMEDOUT) { |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 964 | return USB_RET_NAK; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 965 | } else { |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 966 | return USB_RET_STALL; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 967 | } |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 968 | } |
| 969 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 970 | static void usb_host_set_address(USBHostDevice *s, int addr) |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 971 | { |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 972 | trace_usb_host_set_address(s->bus_num, s->addr, addr); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 973 | s->dev.addr = addr; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 974 | } |
| 975 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 976 | static void usb_host_set_config(USBHostDevice *s, int config, USBPacket *p) |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 977 | { |
Gerd Hoffmann | 0fcc3bf | 2011-09-13 11:55:15 +0200 | [diff] [blame] | 978 | int ret, first = 1; |
| 979 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 980 | trace_usb_host_set_config(s->bus_num, s->addr, config); |
| 981 | |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 982 | usb_host_release_interfaces(s); |
| 983 | |
Gerd Hoffmann | 0fcc3bf | 2011-09-13 11:55:15 +0200 | [diff] [blame] | 984 | again: |
| 985 | ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 986 | |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 987 | DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 988 | |
Gerd Hoffmann | 0fcc3bf | 2011-09-13 11:55:15 +0200 | [diff] [blame] | 989 | if (ret < 0 && errno == EBUSY && first) { |
| 990 | /* happens if usb device is in use by host drivers */ |
| 991 | int count = usb_linux_get_num_interfaces(s); |
| 992 | if (count > 0) { |
| 993 | DPRINTF("husb: busy -> disconnecting %d interfaces\n", count); |
| 994 | usb_host_disconnect_ifaces(s, count); |
| 995 | first = 0; |
| 996 | goto again; |
| 997 | } |
| 998 | } |
| 999 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1000 | if (ret < 0) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1001 | p->status = ctrl_error(); |
| 1002 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1003 | } |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1004 | usb_host_claim_interfaces(s, config); |
Gerd Hoffmann | eb7700b | 2011-08-24 14:45:07 +0200 | [diff] [blame] | 1005 | usb_linux_update_endp_table(s); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1006 | } |
| 1007 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1008 | static void usb_host_set_interface(USBHostDevice *s, int iface, int alt, |
| 1009 | USBPacket *p) |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1010 | { |
| 1011 | struct usbdevfs_setinterface si; |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 1012 | int i, ret; |
| 1013 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1014 | trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt); |
| 1015 | |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 1016 | for (i = 1; i <= USB_MAX_ENDPOINTS; i++) { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 1017 | if (is_isoc(s, USB_TOKEN_IN, i)) { |
| 1018 | usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i); |
| 1019 | } |
| 1020 | if (is_isoc(s, USB_TOKEN_OUT, i)) { |
| 1021 | usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 1022 | } |
| 1023 | } |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1024 | |
Gerd Hoffmann | 1de14d4 | 2011-08-30 13:21:27 +0200 | [diff] [blame] | 1025 | if (iface >= USB_MAX_INTERFACES) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1026 | p->status = USB_RET_STALL; |
| 1027 | return; |
Gerd Hoffmann | 1de14d4 | 2011-08-30 13:21:27 +0200 | [diff] [blame] | 1028 | } |
| 1029 | |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1030 | si.interface = iface; |
| 1031 | si.altsetting = alt; |
| 1032 | ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1033 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1034 | DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n", |
| 1035 | iface, alt, ret, errno); |
| 1036 | |
| 1037 | if (ret < 0) { |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1038 | p->status = ctrl_error(); |
| 1039 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1040 | } |
Gerd Hoffmann | 1de14d4 | 2011-08-30 13:21:27 +0200 | [diff] [blame] | 1041 | |
| 1042 | s->dev.altsetting[iface] = alt; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1043 | usb_linux_update_endp_table(s); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1044 | } |
| 1045 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1046 | static void usb_host_handle_control(USBDevice *dev, USBPacket *p, |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1047 | int request, int value, int index, int length, uint8_t *data) |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1048 | { |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1049 | USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1050 | struct usbdevfs_urb *urb; |
| 1051 | AsyncURB *aurb; |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1052 | int ret; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1053 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1054 | /* |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1055 | * Process certain standard device requests. |
| 1056 | * These are infrequent and are processed synchronously. |
| 1057 | */ |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1058 | |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1059 | /* Note request is (bRequestType << 8) | bRequest */ |
Gerd Hoffmann | 19b8925 | 2012-03-23 12:35:55 +0100 | [diff] [blame] | 1060 | trace_usb_host_req_control(s->bus_num, s->addr, p, request, value, index); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1061 | |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1062 | switch (request) { |
| 1063 | case DeviceOutRequest | USB_REQ_SET_ADDRESS: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1064 | usb_host_set_address(s, value); |
| 1065 | trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status); |
| 1066 | return; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1067 | |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1068 | case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1069 | usb_host_set_config(s, value & 0xff, p); |
| 1070 | trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status); |
| 1071 | return; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1072 | |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1073 | case InterfaceOutRequest | USB_REQ_SET_INTERFACE: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1074 | usb_host_set_interface(s, index, value, p); |
| 1075 | trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status); |
| 1076 | return; |
Gerd Hoffmann | a2498f7 | 2012-05-08 13:54:45 +0200 | [diff] [blame] | 1077 | |
| 1078 | case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: |
| 1079 | if (value == 0) { /* clear halt */ |
| 1080 | int pid = (index & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT; |
| 1081 | ioctl(s->fd, USBDEVFS_CLEAR_HALT, &index); |
| 1082 | clear_halt(s, pid, index & 0x0f); |
| 1083 | trace_usb_host_req_emulated(s->bus_num, s->addr, p, 0); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1084 | return; |
Gerd Hoffmann | a2498f7 | 2012-05-08 13:54:45 +0200 | [diff] [blame] | 1085 | } |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1086 | } |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1087 | |
| 1088 | /* The rest are asynchronous */ |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1089 | if (length > sizeof(dev->data_buf)) { |
| 1090 | fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n", |
| 1091 | length, sizeof(dev->data_buf)); |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1092 | p->status = USB_RET_STALL; |
| 1093 | return; |
Jim Paris | c4c0e23 | 2009-08-24 14:56:12 -0400 | [diff] [blame] | 1094 | } |
| 1095 | |
Gerd Hoffmann | 7a8fc83 | 2011-05-16 09:13:05 +0200 | [diff] [blame] | 1096 | aurb = async_alloc(s); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1097 | aurb->packet = p; |
| 1098 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1099 | /* |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1100 | * Setup ctrl transfer. |
| 1101 | * |
Brad Hards | a010208 | 2011-04-13 19:45:33 +1000 | [diff] [blame] | 1102 | * s->ctrl is laid out such that data buffer immediately follows |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1103 | * 'req' struct which is exactly what usbdevfs expects. |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1104 | */ |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1105 | urb = &aurb->urb; |
| 1106 | |
| 1107 | urb->type = USBDEVFS_URB_TYPE_CONTROL; |
Gerd Hoffmann | 079d0b7 | 2012-01-12 13:23:01 +0100 | [diff] [blame] | 1108 | urb->endpoint = p->ep->nr; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1109 | |
Hans de Goede | 50b7963 | 2011-02-02 17:36:29 +0100 | [diff] [blame] | 1110 | urb->buffer = &dev->setup_buf; |
| 1111 | urb->buffer_length = length + 8; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1112 | |
| 1113 | urb->usercontext = s; |
| 1114 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1115 | trace_usb_host_urb_submit(s->bus_num, s->addr, aurb, |
| 1116 | urb->buffer_length, aurb->more); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1117 | ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb); |
| 1118 | |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 1119 | DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1120 | |
| 1121 | if (ret < 0) { |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 1122 | DPRINTF("husb: submit failed. errno %d\n", errno); |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1123 | async_free(aurb); |
| 1124 | |
| 1125 | switch(errno) { |
| 1126 | case ETIMEDOUT: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1127 | p->status = USB_RET_NAK; |
| 1128 | break; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1129 | case EPIPE: |
| 1130 | default: |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1131 | p->status = USB_RET_STALL; |
| 1132 | break; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1133 | } |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1134 | return; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1135 | } |
| 1136 | |
Hans de Goede | 9a77a0f | 2012-11-01 17:15:01 +0100 | [diff] [blame] | 1137 | p->status = USB_RET_ASYNC; |
aliguori | 446ab12 | 2008-09-14 01:06:09 +0000 | [diff] [blame] | 1138 | } |
| 1139 | |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1140 | static void usb_linux_update_endp_table(USBHostDevice *s) |
Hans de Goede | 71d71bb | 2010-11-10 10:06:24 +0100 | [diff] [blame] | 1141 | { |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1142 | static const char *tname[] = { |
| 1143 | [USB_ENDPOINT_XFER_CONTROL] = "control", |
| 1144 | [USB_ENDPOINT_XFER_ISOC] = "isoc", |
| 1145 | [USB_ENDPOINT_XFER_BULK] = "bulk", |
| 1146 | [USB_ENDPOINT_XFER_INT] = "int", |
| 1147 | }; |
| 1148 | uint8_t devep, type; |
| 1149 | uint16_t mps, v, p; |
| 1150 | int ep, pid; |
| 1151 | unsigned int i, configuration = -1, interface = -1, altsetting = -1; |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 1152 | struct endp_data *epd; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1153 | USBDescriptor *d; |
| 1154 | bool active = false; |
Hans de Goede | 71d71bb | 2010-11-10 10:06:24 +0100 | [diff] [blame] | 1155 | |
Gerd Hoffmann | 19deaa0 | 2012-07-03 10:11:21 +0200 | [diff] [blame] | 1156 | usb_ep_reset(&s->dev); |
Hans de Goede | a0b5fec | 2010-11-26 14:56:17 +0100 | [diff] [blame] | 1157 | |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1158 | for (i = 0;; i += d->bLength) { |
| 1159 | if (i+2 >= s->descr_len) { |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1160 | break; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1161 | } |
| 1162 | d = (void *)(s->descr + i); |
| 1163 | if (d->bLength < 2) { |
| 1164 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1165 | "descriptor too short"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1166 | return; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1167 | } |
| 1168 | if (i + d->bLength > s->descr_len) { |
| 1169 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1170 | "descriptor too long"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1171 | return; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1172 | } |
| 1173 | switch (d->bDescriptorType) { |
| 1174 | case 0: |
| 1175 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1176 | "invalid descriptor type"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1177 | return; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1178 | case USB_DT_DEVICE: |
| 1179 | if (d->bLength < 0x12) { |
| 1180 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1181 | "device descriptor too short"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1182 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1183 | } |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1184 | v = (d->u.device.idVendor_hi << 8) | d->u.device.idVendor_lo; |
| 1185 | p = (d->u.device.idProduct_hi << 8) | d->u.device.idProduct_lo; |
| 1186 | trace_usb_host_parse_device(s->bus_num, s->addr, v, p); |
| 1187 | break; |
| 1188 | case USB_DT_CONFIG: |
| 1189 | if (d->bLength < 0x09) { |
| 1190 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1191 | "config descriptor too short"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1192 | return; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1193 | } |
| 1194 | configuration = d->u.config.bConfigurationValue; |
| 1195 | active = (configuration == s->dev.configuration); |
| 1196 | trace_usb_host_parse_config(s->bus_num, s->addr, |
| 1197 | configuration, active); |
| 1198 | break; |
| 1199 | case USB_DT_INTERFACE: |
| 1200 | if (d->bLength < 0x09) { |
| 1201 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1202 | "interface descriptor too short"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1203 | return; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1204 | } |
| 1205 | interface = d->u.interface.bInterfaceNumber; |
| 1206 | altsetting = d->u.interface.bAlternateSetting; |
| 1207 | active = (configuration == s->dev.configuration) && |
| 1208 | (altsetting == s->dev.altsetting[interface]); |
| 1209 | trace_usb_host_parse_interface(s->bus_num, s->addr, |
| 1210 | interface, altsetting, active); |
| 1211 | break; |
| 1212 | case USB_DT_ENDPOINT: |
| 1213 | if (d->bLength < 0x07) { |
| 1214 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1215 | "endpoint descriptor too short"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1216 | return; |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1217 | } |
| 1218 | devep = d->u.endpoint.bEndpointAddress; |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 1219 | pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT; |
| 1220 | ep = devep & 0xf; |
| 1221 | if (ep == 0) { |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1222 | trace_usb_host_parse_error(s->bus_num, s->addr, |
| 1223 | "invalid endpoint address"); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1224 | return; |
Hans de Goede | 130314f | 2011-05-31 11:35:22 +0200 | [diff] [blame] | 1225 | } |
| 1226 | |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1227 | type = d->u.endpoint.bmAttributes & 0x3; |
| 1228 | mps = d->u.endpoint.wMaxPacketSize_lo | |
| 1229 | (d->u.endpoint.wMaxPacketSize_hi << 8); |
| 1230 | trace_usb_host_parse_endpoint(s->bus_num, s->addr, ep, |
| 1231 | (devep & USB_DIR_IN) ? "in" : "out", |
| 1232 | tname[type], active); |
| 1233 | |
| 1234 | if (active) { |
| 1235 | usb_ep_set_max_packet_size(&s->dev, pid, ep, mps); |
| 1236 | assert(usb_ep_get_type(&s->dev, pid, ep) == |
| 1237 | USB_ENDPOINT_XFER_INVALID); |
| 1238 | usb_ep_set_type(&s->dev, pid, ep, type); |
| 1239 | usb_ep_set_ifnum(&s->dev, pid, ep, interface); |
| 1240 | if ((s->options & (1 << USB_HOST_OPT_PIPELINE)) && |
Hans de Goede | 6ba43f1 | 2012-10-24 18:14:09 +0200 | [diff] [blame] | 1241 | (type == USB_ENDPOINT_XFER_BULK) && |
| 1242 | (pid == USB_TOKEN_OUT)) { |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1243 | usb_ep_set_pipeline(&s->dev, pid, ep, true); |
| 1244 | } |
| 1245 | |
| 1246 | epd = get_endp(s, pid, ep); |
| 1247 | epd->halted = 0; |
Gerd Hoffmann | 9424d4e | 2012-03-01 14:42:34 +0100 | [diff] [blame] | 1248 | } |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 1249 | |
Gerd Hoffmann | 96dd9aa | 2012-03-29 16:06:28 +0200 | [diff] [blame] | 1250 | break; |
| 1251 | default: |
| 1252 | trace_usb_host_parse_unknown(s->bus_num, s->addr, |
| 1253 | d->bLength, d->bDescriptorType); |
| 1254 | break; |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1255 | } |
| 1256 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1257 | } |
| 1258 | |
Hans de Goede | e4b1776 | 2011-05-30 11:40:45 +0200 | [diff] [blame] | 1259 | /* |
| 1260 | * Check if we can safely redirect a usb2 device to a usb1 virtual controller, |
| 1261 | * this function assumes this is safe, if: |
| 1262 | * 1) There are no isoc endpoints |
| 1263 | * 2) There are no interrupt endpoints with a max_packet_size > 64 |
| 1264 | * Note bulk endpoints with a max_packet_size > 64 in theory also are not |
| 1265 | * usb1 compatible, but in practice this seems to work fine. |
| 1266 | */ |
| 1267 | static int usb_linux_full_speed_compat(USBHostDevice *dev) |
| 1268 | { |
| 1269 | int i, packet_size; |
| 1270 | |
| 1271 | /* |
| 1272 | * usb_linux_update_endp_table only registers info about ep in the current |
| 1273 | * interface altsettings, so we need to parse the descriptors again. |
| 1274 | */ |
| 1275 | for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) { |
| 1276 | if (dev->descr[i + 1] == USB_DT_ENDPOINT) { |
| 1277 | switch (dev->descr[i + 3] & 0x3) { |
| 1278 | case 0x00: /* CONTROL */ |
| 1279 | break; |
| 1280 | case 0x01: /* ISO */ |
| 1281 | return 0; |
| 1282 | case 0x02: /* BULK */ |
| 1283 | break; |
| 1284 | case 0x03: /* INTERRUPT */ |
| 1285 | packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8); |
| 1286 | if (packet_size > 64) |
| 1287 | return 0; |
| 1288 | break; |
| 1289 | } |
| 1290 | } |
| 1291 | } |
| 1292 | return 1; |
| 1293 | } |
| 1294 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1295 | static int usb_host_open(USBHostDevice *dev, int bus_num, |
Gerd Hoffmann | ba9acab | 2011-08-17 23:35:45 +0200 | [diff] [blame] | 1296 | int addr, const char *port, |
| 1297 | const char *prod_name, int speed) |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1298 | { |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1299 | int fd = -1, ret; |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1300 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1301 | trace_usb_host_open_started(bus_num, addr); |
| 1302 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1303 | if (dev->fd != -1) { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1304 | goto fail; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1305 | } |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1306 | |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 1307 | fd = usb_host_open_device(bus_num, addr); |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1308 | if (fd < 0) { |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1309 | goto fail; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1310 | } |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 1311 | DPRINTF("husb: opened %s\n", buf); |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1312 | |
Gerd Hoffmann | 806b602 | 2009-08-31 14:23:59 +0200 | [diff] [blame] | 1313 | dev->bus_num = bus_num; |
| 1314 | dev->addr = addr; |
Markus Armbruster | 0360784 | 2013-01-10 14:33:25 +0100 | [diff] [blame] | 1315 | pstrcpy(dev->port, sizeof(dev->port), port); |
Gerd Hoffmann | 22f84e7 | 2009-09-25 16:55:28 +0200 | [diff] [blame] | 1316 | dev->fd = fd; |
Gerd Hoffmann | 806b602 | 2009-08-31 14:23:59 +0200 | [diff] [blame] | 1317 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1318 | /* read the device description */ |
| 1319 | dev->descr_len = read(fd, dev->descr, sizeof(dev->descr)); |
| 1320 | if (dev->descr_len <= 0) { |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 1321 | perror("husb: reading device data failed"); |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1322 | goto fail; |
| 1323 | } |
ths | 3b46e62 | 2007-09-17 08:09:54 +0000 | [diff] [blame] | 1324 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1325 | #ifdef DEBUG |
bellard | 868bfe2 | 2005-11-13 21:53:15 +0000 | [diff] [blame] | 1326 | { |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1327 | int x; |
| 1328 | printf("=== begin dumping device descriptor data ===\n"); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1329 | for (x = 0; x < dev->descr_len; x++) { |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1330 | printf("%02x ", dev->descr[x]); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1331 | } |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1332 | printf("\n=== end dumping device descriptor data ===\n"); |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1333 | } |
| 1334 | #endif |
| 1335 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1336 | |
Gerd Hoffmann | eb7700b | 2011-08-24 14:45:07 +0200 | [diff] [blame] | 1337 | /* start unconfigured -- we'll wait for the guest to set a configuration */ |
| 1338 | if (!usb_host_claim_interfaces(dev, 0)) { |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1339 | goto fail; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1340 | } |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1341 | |
Gerd Hoffmann | 19deaa0 | 2012-07-03 10:11:21 +0200 | [diff] [blame] | 1342 | usb_ep_init(&dev->dev); |
Jan Kiszka | 537e8f1 | 2012-11-15 09:23:30 +0100 | [diff] [blame] | 1343 | usb_linux_update_endp_table(dev); |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1344 | |
Hans de Goede | 3991c35 | 2011-05-31 11:35:18 +0200 | [diff] [blame] | 1345 | if (speed == -1) { |
| 1346 | struct usbdevfs_connectinfo ci; |
| 1347 | |
| 1348 | ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci); |
| 1349 | if (ret < 0) { |
| 1350 | perror("usb_host_device_open: USBDEVFS_CONNECTINFO"); |
| 1351 | goto fail; |
| 1352 | } |
| 1353 | |
| 1354 | if (ci.slow) { |
| 1355 | speed = USB_SPEED_LOW; |
| 1356 | } else { |
| 1357 | speed = USB_SPEED_HIGH; |
| 1358 | } |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1359 | } |
Hans de Goede | 3991c35 | 2011-05-31 11:35:18 +0200 | [diff] [blame] | 1360 | dev->dev.speed = speed; |
Hans de Goede | ba3f9bf | 2011-05-27 14:27:18 +0200 | [diff] [blame] | 1361 | dev->dev.speedmask = (1 << speed); |
Hans de Goede | e4b1776 | 2011-05-30 11:40:45 +0200 | [diff] [blame] | 1362 | if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) { |
| 1363 | dev->dev.speedmask |= USB_SPEED_MASK_FULL; |
| 1364 | } |
Hans de Goede | 3991c35 | 2011-05-31 11:35:18 +0200 | [diff] [blame] | 1365 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1366 | trace_usb_host_open_success(bus_num, addr); |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1367 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1368 | if (!prod_name || prod_name[0] == '\0') { |
Markus Armbruster | 0fe6d12 | 2009-12-09 17:07:51 +0100 | [diff] [blame] | 1369 | snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc), |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1370 | "host:%d.%d", bus_num, addr); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1371 | } else { |
Markus Armbruster | 0fe6d12 | 2009-12-09 17:07:51 +0100 | [diff] [blame] | 1372 | pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc), |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1373 | prod_name); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1374 | } |
bellard | 1f6e24e | 2006-06-26 21:00:51 +0000 | [diff] [blame] | 1375 | |
Hans de Goede | fa19bf8 | 2011-05-27 19:05:15 +0200 | [diff] [blame] | 1376 | ret = usb_device_attach(&dev->dev); |
| 1377 | if (ret) { |
| 1378 | goto fail; |
| 1379 | } |
| 1380 | |
aliguori | 6483817 | 2008-08-21 19:31:10 +0000 | [diff] [blame] | 1381 | /* USB devio uses 'write' flag to check for async completions */ |
| 1382 | qemu_set_fd_handler(dev->fd, NULL, async_complete, dev); |
aliguori | 1f3870a | 2008-08-21 19:27:48 +0000 | [diff] [blame] | 1383 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1384 | return 0; |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1385 | |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1386 | fail: |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1387 | trace_usb_host_open_failure(bus_num, addr); |
Gerd Hoffmann | 1f45a81 | 2011-06-06 09:45:20 +0200 | [diff] [blame] | 1388 | if (dev->fd != -1) { |
| 1389 | close(dev->fd); |
| 1390 | dev->fd = -1; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1391 | } |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1392 | return -1; |
| 1393 | } |
| 1394 | |
| 1395 | static int usb_host_close(USBHostDevice *dev) |
| 1396 | { |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 1397 | int i; |
| 1398 | |
Gerd Hoffmann | 39fba3a | 2011-10-28 16:13:50 +0200 | [diff] [blame] | 1399 | if (dev->fd == -1) { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1400 | return -1; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1401 | } |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1402 | |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1403 | trace_usb_host_close(dev->bus_num, dev->addr); |
| 1404 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1405 | qemu_set_fd_handler(dev->fd, NULL, NULL, NULL); |
| 1406 | dev->closing = 1; |
Gerd Hoffmann | d8e17ef | 2011-08-29 12:49:46 +0200 | [diff] [blame] | 1407 | for (i = 1; i <= USB_MAX_ENDPOINTS; i++) { |
Gerd Hoffmann | c0e5750 | 2011-08-26 16:27:41 +0200 | [diff] [blame] | 1408 | if (is_isoc(dev, USB_TOKEN_IN, i)) { |
| 1409 | usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i); |
| 1410 | } |
| 1411 | if (is_isoc(dev, USB_TOKEN_OUT, i)) { |
| 1412 | usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i); |
Hans de Goede | 060dc84 | 2010-11-26 11:41:08 +0100 | [diff] [blame] | 1413 | } |
| 1414 | } |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1415 | async_complete(dev); |
| 1416 | dev->closing = 0; |
Gerd Hoffmann | 39fba3a | 2011-10-28 16:13:50 +0200 | [diff] [blame] | 1417 | if (dev->dev.attached) { |
| 1418 | usb_device_detach(&dev->dev); |
| 1419 | } |
Gerd Hoffmann | c7662da | 2011-11-16 12:37:17 +0100 | [diff] [blame] | 1420 | usb_host_do_reset(dev); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1421 | close(dev->fd); |
| 1422 | dev->fd = -1; |
| 1423 | return 0; |
| 1424 | } |
| 1425 | |
Jan Kiszka | 9e8dd45 | 2011-06-20 14:06:26 +0200 | [diff] [blame] | 1426 | static void usb_host_exit_notifier(struct Notifier *n, void *data) |
Shahar Havivi | b373a63 | 2010-06-16 15:16:11 +0300 | [diff] [blame] | 1427 | { |
| 1428 | USBHostDevice *s = container_of(n, USBHostDevice, exit); |
| 1429 | |
Gerd Hoffmann | c75fead | 2012-01-05 15:49:18 +0100 | [diff] [blame] | 1430 | usb_host_release_port(s); |
Shahar Havivi | b373a63 | 2010-06-16 15:16:11 +0300 | [diff] [blame] | 1431 | if (s->fd != -1) { |
Dong Xu Wang | c7e775e | 2013-05-09 15:53:50 +0800 | [diff] [blame] | 1432 | usb_host_do_reset(s); |
Shahar Havivi | b373a63 | 2010-06-16 15:16:11 +0300 | [diff] [blame] | 1433 | } |
| 1434 | } |
| 1435 | |
Gerd Hoffmann | a229c05 | 2012-06-08 13:02:16 +0200 | [diff] [blame] | 1436 | /* |
| 1437 | * This is *NOT* about restoring state. We have absolutely no idea |
| 1438 | * what state the host device is in at the moment and whenever it is |
| 1439 | * still present in the first place. Attemping to contine where we |
| 1440 | * left off is impossible. |
| 1441 | * |
| 1442 | * What we are going to to to here is emulate a surprise removal of |
| 1443 | * the usb device passed through, then kick host scan so the device |
| 1444 | * will get re-attached (and re-initialized by the guest) in case it |
| 1445 | * is still present. |
| 1446 | * |
| 1447 | * As the device removal will change the state of other devices (usb |
| 1448 | * host controller, most likely interrupt controller too) we have to |
| 1449 | * wait with it until *all* vmstate is loaded. Thus post_load just |
| 1450 | * kicks a bottom half which then does the actual work. |
| 1451 | */ |
| 1452 | static void usb_host_post_load_bh(void *opaque) |
| 1453 | { |
| 1454 | USBHostDevice *dev = opaque; |
| 1455 | |
| 1456 | if (dev->fd != -1) { |
| 1457 | usb_host_close(dev); |
| 1458 | } |
| 1459 | if (dev->dev.attached) { |
| 1460 | usb_device_detach(&dev->dev); |
| 1461 | } |
| 1462 | usb_host_auto_check(NULL); |
| 1463 | } |
| 1464 | |
| 1465 | static int usb_host_post_load(void *opaque, int version_id) |
| 1466 | { |
| 1467 | USBHostDevice *dev = opaque; |
| 1468 | |
| 1469 | qemu_bh_schedule(dev->bh); |
| 1470 | return 0; |
| 1471 | } |
| 1472 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1473 | static int usb_host_initfn(USBDevice *dev) |
| 1474 | { |
| 1475 | USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); |
| 1476 | |
Hans de Goede | be41efd | 2012-11-17 12:47:15 +0100 | [diff] [blame] | 1477 | dev->flags |= (1 << USB_DEV_FLAG_IS_HOST); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1478 | dev->auto_attach = 0; |
| 1479 | s->fd = -1; |
Gerd Hoffmann | 9516bb4 | 2011-08-24 13:34:17 +0200 | [diff] [blame] | 1480 | s->hub_fd = -1; |
| 1481 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1482 | QTAILQ_INSERT_TAIL(&hostdevs, s, next); |
Shahar Havivi | b373a63 | 2010-06-16 15:16:11 +0300 | [diff] [blame] | 1483 | s->exit.notify = usb_host_exit_notifier; |
| 1484 | qemu_add_exit_notifier(&s->exit); |
Gerd Hoffmann | a229c05 | 2012-06-08 13:02:16 +0200 | [diff] [blame] | 1485 | s->bh = qemu_bh_new(usb_host_post_load_bh, s); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1486 | usb_host_auto_check(NULL); |
Gerd Hoffmann | 9516bb4 | 2011-08-24 13:34:17 +0200 | [diff] [blame] | 1487 | |
Gerd Hoffmann | 9516bb4 | 2011-08-24 13:34:17 +0200 | [diff] [blame] | 1488 | if (s->match.bus_num != 0 && s->match.port != NULL) { |
Gerd Hoffmann | e627472 | 2011-09-13 11:37:47 +0200 | [diff] [blame] | 1489 | usb_host_claim_port(s); |
Gerd Hoffmann | 9516bb4 | 2011-08-24 13:34:17 +0200 | [diff] [blame] | 1490 | } |
Gerd Hoffmann | 65bb3a5 | 2012-03-22 10:48:03 +0100 | [diff] [blame] | 1491 | add_boot_device_path(s->bootindex, &dev->qdev, NULL); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1492 | return 0; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1493 | } |
| 1494 | |
Gerd Hoffmann | d679157 | 2011-08-31 11:44:24 +0200 | [diff] [blame] | 1495 | static const VMStateDescription vmstate_usb_host = { |
Gerd Hoffmann | 2b2325f | 2012-11-30 16:02:11 +0100 | [diff] [blame] | 1496 | .name = DEVNAME, |
Gerd Hoffmann | a229c05 | 2012-06-08 13:02:16 +0200 | [diff] [blame] | 1497 | .version_id = 1, |
| 1498 | .minimum_version_id = 1, |
| 1499 | .post_load = usb_host_post_load, |
| 1500 | .fields = (VMStateField[]) { |
| 1501 | VMSTATE_USB_DEVICE(dev, USBHostDevice), |
| 1502 | VMSTATE_END_OF_LIST() |
| 1503 | } |
Gerd Hoffmann | d679157 | 2011-08-31 11:44:24 +0200 | [diff] [blame] | 1504 | }; |
| 1505 | |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 1506 | static Property usb_host_dev_properties[] = { |
| 1507 | DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0), |
| 1508 | DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0), |
| 1509 | DEFINE_PROP_STRING("hostport", USBHostDevice, match.port), |
| 1510 | DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0), |
| 1511 | DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0), |
| 1512 | DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4), |
Gerd Hoffmann | 65bb3a5 | 2012-03-22 10:48:03 +0100 | [diff] [blame] | 1513 | DEFINE_PROP_INT32("bootindex", USBHostDevice, bootindex, -1), |
Gerd Hoffmann | 39c2057 | 2012-03-22 15:28:45 +0100 | [diff] [blame] | 1514 | DEFINE_PROP_BIT("pipeline", USBHostDevice, options, |
| 1515 | USB_HOST_OPT_PIPELINE, true), |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 1516 | DEFINE_PROP_END_OF_LIST(), |
| 1517 | }; |
| 1518 | |
Anthony Liguori | 62aed76 | 2011-12-15 14:53:10 -0600 | [diff] [blame] | 1519 | static void usb_host_class_initfn(ObjectClass *klass, void *data) |
| 1520 | { |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 1521 | DeviceClass *dc = DEVICE_CLASS(klass); |
Anthony Liguori | 62aed76 | 2011-12-15 14:53:10 -0600 | [diff] [blame] | 1522 | USBDeviceClass *uc = USB_DEVICE_CLASS(klass); |
| 1523 | |
| 1524 | uc->init = usb_host_initfn; |
| 1525 | uc->product_desc = "USB Host Device"; |
Anthony Liguori | 62aed76 | 2011-12-15 14:53:10 -0600 | [diff] [blame] | 1526 | uc->cancel_packet = usb_host_async_cancel; |
| 1527 | uc->handle_data = usb_host_handle_data; |
| 1528 | uc->handle_control = usb_host_handle_control; |
| 1529 | uc->handle_reset = usb_host_handle_reset; |
| 1530 | uc->handle_destroy = usb_host_handle_destroy; |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 1531 | dc->vmsd = &vmstate_usb_host; |
| 1532 | dc->props = usb_host_dev_properties; |
Marcel Apfelbaum | 125ee0e | 2013-07-29 17:17:45 +0300 | [diff] [blame] | 1533 | set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories); |
Anthony Liguori | 62aed76 | 2011-12-15 14:53:10 -0600 | [diff] [blame] | 1534 | } |
| 1535 | |
Andreas Färber | 8c43a6f | 2013-01-10 16:19:07 +0100 | [diff] [blame] | 1536 | static const TypeInfo usb_host_dev_info = { |
Gerd Hoffmann | 2b2325f | 2012-11-30 16:02:11 +0100 | [diff] [blame] | 1537 | .name = DEVNAME, |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 1538 | .parent = TYPE_USB_DEVICE, |
| 1539 | .instance_size = sizeof(USBHostDevice), |
| 1540 | .class_init = usb_host_class_initfn, |
Gerd Hoffmann | 806b602 | 2009-08-31 14:23:59 +0200 | [diff] [blame] | 1541 | }; |
| 1542 | |
Andreas Färber | 83f7d43 | 2012-02-09 15:20:55 +0100 | [diff] [blame] | 1543 | static void usb_host_register_types(void) |
Gerd Hoffmann | 806b602 | 2009-08-31 14:23:59 +0200 | [diff] [blame] | 1544 | { |
Anthony Liguori | 39bffca | 2011-12-07 21:34:16 -0600 | [diff] [blame] | 1545 | type_register_static(&usb_host_dev_info); |
Gerd Hoffmann | 806b602 | 2009-08-31 14:23:59 +0200 | [diff] [blame] | 1546 | } |
Andreas Färber | 83f7d43 | 2012-02-09 15:20:55 +0100 | [diff] [blame] | 1547 | |
| 1548 | type_init(usb_host_register_types) |
Gerd Hoffmann | 806b602 | 2009-08-31 14:23:59 +0200 | [diff] [blame] | 1549 | |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1550 | /* |
| 1551 | * Read sys file-system device file |
| 1552 | * |
| 1553 | * @line address of buffer to put file contents in |
| 1554 | * @line_size size of line |
| 1555 | * @device_file path to device file (printf format string) |
| 1556 | * @device_name device being opened (inserted into device_file) |
| 1557 | * |
| 1558 | * @return 0 failed, 1 succeeded ('line' contains data) |
| 1559 | */ |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1560 | static int usb_host_read_file(char *line, size_t line_size, |
| 1561 | const char *device_file, const char *device_name) |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1562 | { |
| 1563 | FILE *f; |
| 1564 | int ret = 0; |
| 1565 | char filename[PATH_MAX]; |
| 1566 | |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 1567 | snprintf(filename, PATH_MAX, "/sys/bus/usb/devices/%s/%s", device_name, |
blueswir1 | b4e237a | 2008-12-28 15:45:20 +0000 | [diff] [blame] | 1568 | device_file); |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1569 | f = fopen(filename, "r"); |
| 1570 | if (f) { |
Kirill A. Shutemov | 9f99cee | 2010-01-20 00:56:17 +0100 | [diff] [blame] | 1571 | ret = fgets(line, line_size, f) != NULL; |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1572 | fclose(f); |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1573 | } |
| 1574 | |
| 1575 | return ret; |
| 1576 | } |
| 1577 | |
| 1578 | /* |
| 1579 | * Use /sys/bus/usb/devices/ directory to determine host's USB |
| 1580 | * devices. |
| 1581 | * |
| 1582 | * This code is based on Robert Schiele's original patches posted to |
| 1583 | * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950 |
| 1584 | */ |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 1585 | static int usb_host_scan(void *opaque, USBScanFunc *func) |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1586 | { |
Blue Swirl | 660f11b | 2009-07-31 21:16:51 +0000 | [diff] [blame] | 1587 | DIR *dir = NULL; |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1588 | char line[1024]; |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1589 | int bus_num, addr, speed, class_id, product_id, vendor_id; |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1590 | int ret = 0; |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1591 | char port[MAX_PORTLEN]; |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1592 | char product_name[512]; |
| 1593 | struct dirent *de; |
| 1594 | |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 1595 | dir = opendir("/sys/bus/usb/devices"); |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1596 | if (!dir) { |
Gerd Hoffmann | 097db43 | 2011-12-16 11:54:11 +0100 | [diff] [blame] | 1597 | perror("husb: opendir /sys/bus/usb/devices"); |
| 1598 | fprintf(stderr, "husb: please make sure sysfs is mounted at /sys\n"); |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1599 | goto the_end; |
| 1600 | } |
| 1601 | |
| 1602 | while ((de = readdir(dir))) { |
| 1603 | if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) { |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1604 | if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) { |
| 1605 | continue; |
Hans de Goede | 0f5160d | 2010-11-10 10:06:23 +0100 | [diff] [blame] | 1606 | } |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1607 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1608 | if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1609 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1610 | } |
| 1611 | if (sscanf(line, "%d", &addr) != 1) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1612 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1613 | } |
blueswir1 | b4e237a | 2008-12-28 15:45:20 +0000 | [diff] [blame] | 1614 | if (!usb_host_read_file(line, sizeof(line), "bDeviceClass", |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1615 | de->d_name)) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1616 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1617 | } |
| 1618 | if (sscanf(line, "%x", &class_id) != 1) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1619 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1620 | } |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1621 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1622 | if (!usb_host_read_file(line, sizeof(line), "idVendor", |
| 1623 | de->d_name)) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1624 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1625 | } |
| 1626 | if (sscanf(line, "%x", &vendor_id) != 1) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1627 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1628 | } |
blueswir1 | b4e237a | 2008-12-28 15:45:20 +0000 | [diff] [blame] | 1629 | if (!usb_host_read_file(line, sizeof(line), "idProduct", |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1630 | de->d_name)) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1631 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1632 | } |
| 1633 | if (sscanf(line, "%x", &product_id) != 1) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1634 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1635 | } |
blueswir1 | b4e237a | 2008-12-28 15:45:20 +0000 | [diff] [blame] | 1636 | if (!usb_host_read_file(line, sizeof(line), "product", |
| 1637 | de->d_name)) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1638 | *product_name = 0; |
| 1639 | } else { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1640 | if (strlen(line) > 0) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1641 | line[strlen(line) - 1] = '\0'; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1642 | } |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1643 | pstrcpy(product_name, sizeof(product_name), line); |
| 1644 | } |
| 1645 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1646 | if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1647 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1648 | } |
Hans de Goede | f264cfb | 2011-05-31 11:35:19 +0200 | [diff] [blame] | 1649 | if (!strcmp(line, "5000\n")) { |
| 1650 | speed = USB_SPEED_SUPER; |
| 1651 | } else if (!strcmp(line, "480\n")) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1652 | speed = USB_SPEED_HIGH; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1653 | } else if (!strcmp(line, "1.5\n")) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1654 | speed = USB_SPEED_LOW; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1655 | } else { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1656 | speed = USB_SPEED_FULL; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1657 | } |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1658 | |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1659 | ret = func(opaque, bus_num, addr, port, class_id, vendor_id, |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1660 | product_id, product_name, speed); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1661 | if (ret) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1662 | goto the_end; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1663 | } |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1664 | } |
| 1665 | } |
| 1666 | the_end: |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1667 | if (dir) { |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1668 | closedir(dir); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1669 | } |
aliguori | 0f43152 | 2008-10-07 20:06:37 +0000 | [diff] [blame] | 1670 | return ret; |
| 1671 | } |
| 1672 | |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1673 | static QEMUTimer *usb_auto_timer; |
Gerd Hoffmann | c06c68c | 2012-11-14 15:51:18 +0100 | [diff] [blame] | 1674 | static VMChangeStateEntry *usb_vmstate; |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1675 | |
Gerd Hoffmann | ba9acab | 2011-08-17 23:35:45 +0200 | [diff] [blame] | 1676 | static int usb_host_auto_scan(void *opaque, int bus_num, |
| 1677 | int addr, const char *port, |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1678 | int class_id, int vendor_id, int product_id, |
| 1679 | const char *product_name, int speed) |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1680 | { |
| 1681 | struct USBAutoFilter *f; |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1682 | struct USBHostDevice *s; |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1683 | |
| 1684 | /* Ignore hubs */ |
| 1685 | if (class_id == 9) |
| 1686 | return 0; |
| 1687 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1688 | QTAILQ_FOREACH(s, &hostdevs, next) { |
| 1689 | f = &s->match; |
| 1690 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1691 | if (f->bus_num > 0 && f->bus_num != bus_num) { |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1692 | continue; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1693 | } |
| 1694 | if (f->addr > 0 && f->addr != addr) { |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1695 | continue; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1696 | } |
Markus Armbruster | 4663530 | 2013-01-10 14:33:24 +0100 | [diff] [blame] | 1697 | if (f->port != NULL && strcmp(f->port, port) != 0) { |
Gerd Hoffmann | 9056a29 | 2011-05-10 12:07:42 +0200 | [diff] [blame] | 1698 | continue; |
| 1699 | } |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1700 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1701 | if (f->vendor_id > 0 && f->vendor_id != vendor_id) { |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1702 | continue; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1703 | } |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1704 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1705 | if (f->product_id > 0 && f->product_id != product_id) { |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1706 | continue; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1707 | } |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1708 | /* We got a match */ |
Gerd Hoffmann | 3ee886c | 2011-08-24 13:45:06 +0200 | [diff] [blame] | 1709 | s->seen++; |
| 1710 | if (s->errcount >= 3) { |
| 1711 | return 0; |
| 1712 | } |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1713 | |
Markus Armbruster | 33e66b8 | 2009-10-07 01:15:57 +0200 | [diff] [blame] | 1714 | /* Already attached ? */ |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1715 | if (s->fd != -1) { |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1716 | return 0; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1717 | } |
malc | d0f2c4c | 2010-02-07 02:03:50 +0300 | [diff] [blame] | 1718 | DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr); |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1719 | |
Gerd Hoffmann | 3ee886c | 2011-08-24 13:45:06 +0200 | [diff] [blame] | 1720 | if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) { |
| 1721 | s->errcount++; |
| 1722 | } |
Hans de Goede | 97f8616 | 2011-05-31 11:35:24 +0200 | [diff] [blame] | 1723 | break; |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1724 | } |
| 1725 | |
| 1726 | return 0; |
| 1727 | } |
| 1728 | |
Gerd Hoffmann | c06c68c | 2012-11-14 15:51:18 +0100 | [diff] [blame] | 1729 | static void usb_host_vm_state(void *unused, int running, RunState state) |
| 1730 | { |
| 1731 | if (running) { |
| 1732 | usb_host_auto_check(unused); |
| 1733 | } |
| 1734 | } |
| 1735 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1736 | static void usb_host_auto_check(void *unused) |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1737 | { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1738 | struct USBHostDevice *s; |
| 1739 | int unconnected = 0; |
| 1740 | |
Gerd Hoffmann | a844ed8 | 2012-06-08 13:02:52 +0200 | [diff] [blame] | 1741 | if (runstate_is_running()) { |
| 1742 | usb_host_scan(NULL, usb_host_auto_scan); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1743 | |
Gerd Hoffmann | a844ed8 | 2012-06-08 13:02:52 +0200 | [diff] [blame] | 1744 | QTAILQ_FOREACH(s, &hostdevs, next) { |
| 1745 | if (s->fd == -1) { |
| 1746 | unconnected++; |
| 1747 | } |
| 1748 | if (s->seen == 0) { |
| 1749 | s->errcount = 0; |
| 1750 | } |
| 1751 | s->seen = 0; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1752 | } |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1753 | |
Gerd Hoffmann | a844ed8 | 2012-06-08 13:02:52 +0200 | [diff] [blame] | 1754 | if (unconnected == 0) { |
| 1755 | /* nothing to watch */ |
| 1756 | if (usb_auto_timer) { |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 1757 | timer_del(usb_auto_timer); |
Gerd Hoffmann | a844ed8 | 2012-06-08 13:02:52 +0200 | [diff] [blame] | 1758 | trace_usb_host_auto_scan_disabled(); |
| 1759 | } |
| 1760 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1761 | } |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1762 | } |
| 1763 | |
Gerd Hoffmann | c06c68c | 2012-11-14 15:51:18 +0100 | [diff] [blame] | 1764 | if (!usb_vmstate) { |
| 1765 | usb_vmstate = qemu_add_vm_change_state_handler(usb_host_vm_state, NULL); |
| 1766 | } |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1767 | if (!usb_auto_timer) { |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 1768 | usb_auto_timer = timer_new_ms(QEMU_CLOCK_REALTIME, usb_host_auto_check, NULL); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1769 | if (!usb_auto_timer) { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1770 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1771 | } |
Gerd Hoffmann | e6a2f50 | 2011-08-22 14:13:20 +0200 | [diff] [blame] | 1772 | trace_usb_host_auto_scan_enabled(); |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1773 | } |
Alex Bligh | bc72ad6 | 2013-08-21 16:03:08 +0100 | [diff] [blame] | 1774 | timer_mod(usb_auto_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 2000); |
aliguori | 4b096fc | 2008-08-21 19:28:55 +0000 | [diff] [blame] | 1775 | } |
| 1776 | |
Gerd Hoffmann | 2b2325f | 2012-11-30 16:02:11 +0100 | [diff] [blame] | 1777 | #ifndef CONFIG_USB_LIBUSB |
| 1778 | |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1779 | /**********************/ |
| 1780 | /* USB host device info */ |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1781 | |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1782 | struct usb_class_info { |
| 1783 | int class; |
| 1784 | const char *class_name; |
| 1785 | }; |
| 1786 | |
| 1787 | static const struct usb_class_info usb_class_info[] = { |
| 1788 | { USB_CLASS_AUDIO, "Audio"}, |
| 1789 | { USB_CLASS_COMM, "Communication"}, |
| 1790 | { USB_CLASS_HID, "HID"}, |
| 1791 | { USB_CLASS_HUB, "Hub" }, |
| 1792 | { USB_CLASS_PHYSICAL, "Physical" }, |
| 1793 | { USB_CLASS_PRINTER, "Printer" }, |
| 1794 | { USB_CLASS_MASS_STORAGE, "Storage" }, |
| 1795 | { USB_CLASS_CDC_DATA, "Data" }, |
| 1796 | { USB_CLASS_APP_SPEC, "Application Specific" }, |
| 1797 | { USB_CLASS_VENDOR_SPEC, "Vendor Specific" }, |
| 1798 | { USB_CLASS_STILL_IMAGE, "Still Image" }, |
balrog | b9dc033 | 2007-10-04 22:47:34 +0000 | [diff] [blame] | 1799 | { USB_CLASS_CSCID, "Smart Card" }, |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1800 | { USB_CLASS_CONTENT_SEC, "Content Security" }, |
| 1801 | { -1, NULL } |
| 1802 | }; |
| 1803 | |
| 1804 | static const char *usb_class_str(uint8_t class) |
| 1805 | { |
| 1806 | const struct usb_class_info *p; |
| 1807 | for(p = usb_class_info; p->class != -1; p++) { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1808 | if (p->class == class) { |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1809 | break; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1810 | } |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1811 | } |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1812 | return p->class_name; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1813 | } |
| 1814 | |
Gerd Hoffmann | ba9acab | 2011-08-17 23:35:45 +0200 | [diff] [blame] | 1815 | static void usb_info_device(Monitor *mon, int bus_num, |
| 1816 | int addr, const char *port, |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1817 | int class_id, int vendor_id, int product_id, |
pbrook | 9596ebb | 2007-11-18 01:44:38 +0000 | [diff] [blame] | 1818 | const char *product_name, |
| 1819 | int speed) |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1820 | { |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1821 | const char *class_str, *speed_str; |
| 1822 | |
| 1823 | switch(speed) { |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1824 | case USB_SPEED_LOW: |
| 1825 | speed_str = "1.5"; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1826 | break; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1827 | case USB_SPEED_FULL: |
| 1828 | speed_str = "12"; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1829 | break; |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1830 | case USB_SPEED_HIGH: |
| 1831 | speed_str = "480"; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1832 | break; |
Hans de Goede | f264cfb | 2011-05-31 11:35:19 +0200 | [diff] [blame] | 1833 | case USB_SPEED_SUPER: |
| 1834 | speed_str = "5000"; |
| 1835 | break; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1836 | default: |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1837 | speed_str = "?"; |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1838 | break; |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1839 | } |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1840 | |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1841 | monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n", |
| 1842 | bus_num, addr, port, speed_str); |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1843 | class_str = usb_class_str(class_id); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1844 | if (class_str) { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1845 | monitor_printf(mon, " %s:", class_str); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1846 | } else { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1847 | monitor_printf(mon, " Class %02x:", class_id); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1848 | } |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1849 | monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1850 | if (product_name[0] != '\0') { |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1851 | monitor_printf(mon, ", %s", product_name); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1852 | } |
aliguori | 376253e | 2009-03-05 23:01:23 +0000 | [diff] [blame] | 1853 | monitor_printf(mon, "\n"); |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1854 | } |
| 1855 | |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1856 | static int usb_host_info_device(void *opaque, int bus_num, int addr, |
Gerd Hoffmann | ba9acab | 2011-08-17 23:35:45 +0200 | [diff] [blame] | 1857 | const char *path, int class_id, |
ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1858 | int vendor_id, int product_id, |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1859 | const char *product_name, |
| 1860 | int speed) |
| 1861 | { |
Blue Swirl | 179da8a | 2009-09-07 19:00:18 +0000 | [diff] [blame] | 1862 | Monitor *mon = opaque; |
| 1863 | |
Gerd Hoffmann | 5557d82 | 2011-05-10 11:43:57 +0200 | [diff] [blame] | 1864 | usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id, |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1865 | product_name, speed); |
| 1866 | return 0; |
| 1867 | } |
| 1868 | |
aliguori | ac4ffb5 | 2008-09-22 15:04:31 +0000 | [diff] [blame] | 1869 | static void dec2str(int val, char *str, size_t size) |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1870 | { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1871 | if (val == 0) { |
aliguori | ac4ffb5 | 2008-09-22 15:04:31 +0000 | [diff] [blame] | 1872 | snprintf(str, size, "*"); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1873 | } else { |
| 1874 | snprintf(str, size, "%d", val); |
| 1875 | } |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1876 | } |
| 1877 | |
aliguori | ac4ffb5 | 2008-09-22 15:04:31 +0000 | [diff] [blame] | 1878 | static void hex2str(int val, char *str, size_t size) |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1879 | { |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1880 | if (val == 0) { |
aliguori | ac4ffb5 | 2008-09-22 15:04:31 +0000 | [diff] [blame] | 1881 | snprintf(str, size, "*"); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1882 | } else { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1883 | snprintf(str, size, "%04x", val); |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1884 | } |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1885 | } |
| 1886 | |
Wenchao Xia | 84f2d0e | 2013-01-14 14:06:25 +0800 | [diff] [blame] | 1887 | void usb_host_info(Monitor *mon, const QDict *qdict) |
bellard | a594cfb | 2005-11-06 16:13:29 +0000 | [diff] [blame] | 1888 | { |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1889 | struct USBAutoFilter *f; |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1890 | struct USBHostDevice *s; |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1891 | |
Blue Swirl | 179da8a | 2009-09-07 19:00:18 +0000 | [diff] [blame] | 1892 | usb_host_scan(mon, usb_host_info_device); |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1893 | |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1894 | if (QTAILQ_EMPTY(&hostdevs)) { |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1895 | return; |
David Ahern | 2791104 | 2010-04-24 10:26:22 -0600 | [diff] [blame] | 1896 | } |
| 1897 | |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1898 | monitor_printf(mon, " Auto filters:\n"); |
| 1899 | QTAILQ_FOREACH(s, &hostdevs, next) { |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1900 | char bus[10], addr[10], vid[10], pid[10]; |
Gerd Hoffmann | 26a9e82 | 2009-10-26 15:56:50 +0100 | [diff] [blame] | 1901 | f = &s->match; |
aliguori | ac4ffb5 | 2008-09-22 15:04:31 +0000 | [diff] [blame] | 1902 | dec2str(f->bus_num, bus, sizeof(bus)); |
| 1903 | dec2str(f->addr, addr, sizeof(addr)); |
| 1904 | hex2str(f->vendor_id, vid, sizeof(vid)); |
| 1905 | hex2str(f->product_id, pid, sizeof(pid)); |
Gerd Hoffmann | 9056a29 | 2011-05-10 12:07:42 +0200 | [diff] [blame] | 1906 | monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n", |
| 1907 | bus, addr, f->port ? f->port : "*", vid, pid); |
aliguori | 5d0c575 | 2008-09-14 01:07:41 +0000 | [diff] [blame] | 1908 | } |
bellard | bb36d47 | 2005-11-05 14:22:28 +0000 | [diff] [blame] | 1909 | } |
Gerd Hoffmann | 2b2325f | 2012-11-30 16:02:11 +0100 | [diff] [blame] | 1910 | |
| 1911 | #endif |