?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'kraxel/chardev.6' into staging
[qemu.git] / hw / usb / host-linux.c
blobca09a891eed20d314f2585317bb637d5c734d4e1
1 /*
2 * Linux host USB redirector
3 *
4 * Copyright (c) 2005 Fabrice Bellard
5 *
6 * Copyright (c) 2008 Max Krasnyansky
7 * Support for host device auto connect & disconnect
8 * Major rewrite to support fully async operation
9 *
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 *
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 */
32
33 #include "qemu-common.h"
34 #include "qemu/timer.h"
35 #include "monitor/monitor.h"
36 #include "sysemu/sysemu.h"
37 #include "trace.h"
38
39 #include <dirent.h>
40 #include <sys/ioctl.h>
41
42 #include <linux/usbdevice_fs.h>
43 #include <linux/version.h>
44 #include "hw/usb.h"
45 #include "hw/usb/desc.h"
46 #include "hw/usb/host.h"
47
48 #ifdef CONFIG_USB_LIBUSB
49 # define DEVNAME "usb-host-linux"
50 #else
51 # define DEVNAME "usb-host"
52 #endif
53
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
65 typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port,
66 int class_id, int vendor_id, int product_id,
67 const char *product_name, int speed);
68
69 //#define DEBUG
70
71 #ifdef DEBUG
72 #define DPRINTF printf
73 #else
74 #define DPRINTF(...)
75 #endif
76
77 #define PRODUCT_NAME_SZ 32
78 #define MAX_PORTLEN 16
79
80 /* endpoint association data */
81 #define ISO_FRAME_DESC_PER_URB 32
82
83 /* devio.c limits single requests to 16k */
84 #define MAX_USBFS_BUFFER_SIZE 16384
85
86 typedef struct AsyncURB AsyncURB;
87
88 struct endp_data {
89 uint8_t halted;
90 uint8_t iso_started;
91 AsyncURB *iso_urb;
92 int iso_urb_idx;
93 int iso_buffer_used;
94 int inflight;
95 };
96
97 enum USBHostDeviceOptions {
98 USB_HOST_OPT_PIPELINE,
99 };
100
101 typedef struct USBHostDevice {
102 USBDevice dev;
103 int fd;
104 int hub_fd;
105 int hub_port;
106
107 uint8_t descr[8192];
108 int descr_len;
109 int closing;
110 uint32_t iso_urb_count;
111 uint32_t options;
112 Notifier exit;
113 QEMUBH *bh;
114
115 struct endp_data ep_in[USB_MAX_ENDPOINTS];
116 struct endp_data ep_out[USB_MAX_ENDPOINTS];
117 QLIST_HEAD(, AsyncURB) aurbs;
118
119 /* Host side address */
120 int bus_num;
121 int addr;
122 char port[MAX_PORTLEN];
123 struct USBAutoFilter match;
124 int32_t bootindex;
125 int seen, errcount;
126
127 QTAILQ_ENTRY(USBHostDevice) next;
128 } USBHostDevice;
129
130 static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
131
132 static int usb_host_close(USBHostDevice *dev);
133 static void usb_host_auto_check(void *unused);
134 static int usb_host_read_file(char *line, size_t line_size,
135 const char *device_file, const char *device_name);
136 static void usb_linux_update_endp_table(USBHostDevice *s);
137
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 };
146 uint8_t type = p->ep->type;
147 assert(type < ARRAY_SIZE(usbfs));
148 return usbfs[type];
149 }
150
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
170 static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep)
171 {
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);
174 assert(ep > 0 && ep <= USB_MAX_ENDPOINTS);
175 return eps + ep - 1;
176 }
177
178 static int is_isoc(USBHostDevice *s, int pid, int ep)
179 {
180 return usb_ep_get_type(&s->dev, pid, ep) == USB_ENDPOINT_XFER_ISOC;
181 }
182
183 static int is_valid(USBHostDevice *s, int pid, int ep)
184 {
185 return usb_ep_get_type(&s->dev, pid, ep) != USB_ENDPOINT_XFER_INVALID;
186 }
187
188 static int is_halted(USBHostDevice *s, int pid, int ep)
189 {
190 return get_endp(s, pid, ep)->halted;
191 }
192
193 static void clear_halt(USBHostDevice *s, int pid, int ep)
194 {
195 trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep);
196 get_endp(s, pid, ep)->halted = 0;
197 }
198
199 static void set_halt(USBHostDevice *s, int pid, int ep)
200 {
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 }
205 }
206
207 static int is_iso_started(USBHostDevice *s, int pid, int ep)
208 {
209 return get_endp(s, pid, ep)->iso_started;
210 }
211
212 static void clear_iso_started(USBHostDevice *s, int pid, int ep)
213 {
214 trace_usb_host_iso_stop(s->bus_num, s->addr, ep);
215 get_endp(s, pid, ep)->iso_started = 0;
216 }
217
218 static void set_iso_started(USBHostDevice *s, int pid, int ep)
219 {
220 struct endp_data *e = get_endp(s, pid, ep);
221
222 trace_usb_host_iso_start(s->bus_num, s->addr, ep);
223 if (!e->iso_started) {
224 e->iso_started = 1;
225 e->inflight = 0;
226 }
227 }
228
229 static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value)
230 {
231 struct endp_data *e = get_endp(s, pid, ep);
232
233 e->inflight += value;
234 return e->inflight;
235 }
236
237 static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb)
238 {
239 get_endp(s, pid, ep)->iso_urb = iso_urb;
240 }
241
242 static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep)
243 {
244 return get_endp(s, pid, ep)->iso_urb;
245 }
246
247 static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i)
248 {
249 get_endp(s, pid, ep)->iso_urb_idx = i;
250 }
251
252 static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep)
253 {
254 return get_endp(s, pid, ep)->iso_urb_idx;
255 }
256
257 static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i)
258 {
259 get_endp(s, pid, ep)->iso_buffer_used = i;
260 }
261
262 static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep)
263 {
264 return get_endp(s, pid, ep)->iso_buffer_used;
265 }
266
267 /*
268 * Async URB state.
269 * We always allocate iso packet descriptors even for bulk transfers
270 * to simplify allocation and casts.
271 */
272 struct AsyncURB
273 {
274 struct usbdevfs_urb urb;
275 struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB];
276 USBHostDevice *hdev;
277 QLIST_ENTRY(AsyncURB) next;
278
279 /* For regular async urbs */
280 USBPacket *packet;
281 int more; /* large transfer, more urbs follow */
282
283 /* For buffered iso handling */
284 int iso_frame_idx; /* -1 means in flight */
285 };
286
287 static AsyncURB *async_alloc(USBHostDevice *s)
288 {
289 AsyncURB *aurb = g_malloc0(sizeof(AsyncURB));
290 aurb->hdev = s;
291 QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
292 return aurb;
293 }
294
295 static void async_free(AsyncURB *aurb)
296 {
297 QLIST_REMOVE(aurb, next);
298 g_free(aurb);
299 }
300
301 static void do_disconnect(USBHostDevice *s)
302 {
303 usb_host_close(s);
304 usb_host_auto_check(NULL);
305 }
306
307 static void async_complete(void *opaque)
308 {
309 USBHostDevice *s = opaque;
310 AsyncURB *aurb;
311 int urbs = 0;
312
313 while (1) {
314 USBPacket *p;
315
316 int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
317 if (r < 0) {
318 if (errno == EAGAIN) {
319 if (urbs > 2) {
320 /* indicates possible latency issues */
321 trace_usb_host_iso_many_urbs(s->bus_num, s->addr, urbs);
322 }
323 return;
324 }
325 if (errno == ENODEV) {
326 if (!s->closing) {
327 trace_usb_host_disconnect(s->bus_num, s->addr);
328 do_disconnect(s);
329 }
330 return;
331 }
332
333 perror("USBDEVFS_REAPURBNDELAY");
334 return;
335 }
336
337 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
338 aurb, aurb->urb.status, aurb->urb.actual_length);
339
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) {
343 int inflight;
344 int pid = (aurb->urb.endpoint & USB_DIR_IN) ?
345 USB_TOKEN_IN : USB_TOKEN_OUT;
346 int ep = aurb->urb.endpoint & 0xf;
347 if (aurb->urb.status == -EPIPE) {
348 set_halt(s, pid, ep);
349 }
350 aurb->iso_frame_idx = 0;
351 urbs++;
352 inflight = change_iso_inflight(s, pid, ep, -1);
353 if (inflight == 0 && is_iso_started(s, pid, ep)) {
354 /* can be latency issues, or simply end of stream */
355 trace_usb_host_iso_out_of_bufs(s->bus_num, s->addr, ep);
356 }
357 continue;
358 }
359
360 p = aurb->packet;
361 trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status,
362 aurb->urb.actual_length, aurb->more);
363
364 if (p) {
365 switch (aurb->urb.status) {
366 case 0:
367 p->actual_length += aurb->urb.actual_length;
368 if (!aurb->more) {
369 /* Clear previous ASYNC status */
370 p->status = USB_RET_SUCCESS;
371 }
372 break;
373
374 case -EPIPE:
375 set_halt(s, p->pid, p->ep->nr);
376 p->status = USB_RET_STALL;
377 break;
378
379 case -EOVERFLOW:
380 p->status = USB_RET_BABBLE;
381 break;
382
383 default:
384 p->status = USB_RET_IOERROR;
385 break;
386 }
387
388 if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
389 trace_usb_host_req_complete(s->bus_num, s->addr, p,
390 p->status, aurb->urb.actual_length);
391 usb_generic_async_ctrl_complete(&s->dev, p);
392 } else if (!aurb->more) {
393 trace_usb_host_req_complete(s->bus_num, s->addr, p,
394 p->status, aurb->urb.actual_length);
395 usb_packet_complete(&s->dev, p);
396 }
397 }
398
399 async_free(aurb);
400 }
401 }
402
403 static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
404 {
405 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
406 AsyncURB *aurb;
407
408 trace_usb_host_req_canceled(s->bus_num, s->addr, p);
409
410 QLIST_FOREACH(aurb, &s->aurbs, next) {
411 if (p != aurb->packet) {
412 continue;
413 }
414
415 trace_usb_host_urb_canceled(s->bus_num, s->addr, aurb);
416
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 }
424 }
425 }
426
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
452 static int usb_host_claim_port(USBHostDevice *s)
453 {
454 #ifdef USBDEVFS_CLAIM_PORT
455 char *h, hub_name[64], line[1024];
456 int hub_addr, ret;
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) {
464 s->hub_port = atoi(h+1);
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);
470 s->hub_port = atoi(s->match.port);
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
481 s->hub_fd = usb_host_open_device(s->match.bus_num, hub_addr);
482 if (s->hub_fd < 0) {
483 return -1;
484 }
485
486 ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &s->hub_port);
487 if (ret < 0) {
488 close(s->hub_fd);
489 s->hub_fd = -1;
490 return -1;
491 }
492
493 trace_usb_host_claim_port(s->match.bus_num, hub_addr, s->hub_port);
494 return 0;
495 #else
496 return -1;
497 #endif
498 }
499
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
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
533 static int usb_linux_get_num_interfaces(USBHostDevice *s)
534 {
535 char device_name[64], line[1024];
536 int num_interfaces = 0;
537
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
549 static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
550 {
551 const char *op = NULL;
552 int dev_descr_len, config_descr_len;
553 int interface, nb_interfaces;
554 int ret, i;
555
556 for (i = 0; i < USB_MAX_INTERFACES; i++) {
557 dev->dev.altsetting[i] = 0;
558 }
559
560 if (configuration == 0) { /* address state - ignore */
561 dev->dev.ninterfaces = 0;
562 dev->dev.configuration = 0;
563 return 1;
564 }
565
566 DPRINTF("husb: claiming interfaces. config %d\n", configuration);
567
568 i = 0;
569 dev_descr_len = dev->descr[0];
570 if (dev_descr_len > dev->descr_len) {
571 fprintf(stderr, "husb: update iface failed. descr too short\n");
572 return 0;
573 }
574
575 i += dev_descr_len;
576 while (i < dev->descr_len) {
577 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
578 i, dev->descr_len,
579 dev->descr[i], dev->descr[i+1]);
580
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
587 DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
588
589 if (configuration == dev->descr[i + 5]) {
590 configuration = dev->descr[i + 5];
591 break;
592 }
593
594 i += config_descr_len;
595 }
596
597 if (i >= dev->descr_len) {
598 fprintf(stderr,
599 "husb: update iface failed. no matching configuration\n");
600 return 0;
601 }
602 nb_interfaces = dev->descr[i + 4];
603
604 if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) {
605 goto fail;
606 }
607
608 /* XXX: only grab if all interfaces are free */
609 for (interface = 0; interface < nb_interfaces; interface++) {
610 op = "USBDEVFS_CLAIMINTERFACE";
611 ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
612 if (ret < 0) {
613 goto fail;
614 }
615 }
616
617 trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
618 nb_interfaces, configuration);
619
620 dev->dev.ninterfaces = nb_interfaces;
621 dev->dev.configuration = configuration;
622 return 1;
623
624 fail:
625 if (errno == ENODEV) {
626 do_disconnect(dev);
627 }
628 perror(op);
629 return 0;
630 }
631
632 static int usb_host_release_interfaces(USBHostDevice *s)
633 {
634 int ret, i;
635
636 trace_usb_host_release_interfaces(s->bus_num, s->addr);
637
638 for (i = 0; i < s->dev.ninterfaces; i++) {
639 ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
640 if (ret < 0) {
641 perror("USBDEVFS_RELEASEINTERFACE");
642 return 0;
643 }
644 }
645 return 1;
646 }
647
648 static void usb_host_handle_reset(USBDevice *dev)
649 {
650 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
651
652 trace_usb_host_reset(s->bus_num, s->addr);
653
654 usb_host_do_reset(s);
655
656 usb_host_claim_interfaces(s, 0);
657 usb_linux_update_endp_table(s);
658 }
659
660 static void usb_host_handle_destroy(USBDevice *dev)
661 {
662 USBHostDevice *s = (USBHostDevice *)dev;
663
664 usb_host_release_port(s);
665 usb_host_close(s);
666 QTAILQ_REMOVE(&hostdevs, s, next);
667 qemu_remove_exit_notifier(&s->exit);
668 }
669
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. */
673 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
674 {
675 AsyncURB *aurb;
676 int i, j, len = usb_ep_get_max_packet_size(&s->dev, pid, ep);
677
678 aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
679 for (i = 0; i < s->iso_urb_count; i++) {
680 aurb[i].urb.endpoint = ep;
681 aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
682 aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length);
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;
688 if (pid == USB_TOKEN_IN) {
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 }
694 set_iso_urb(s, pid, ep, aurb);
695
696 return aurb;
697 }
698
699 static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
700 {
701 AsyncURB *aurb;
702 int i, ret, killed = 0, free = 1;
703
704 aurb = get_iso_urb(s, pid, ep);
705 if (!aurb) {
706 return;
707 }
708
709 for (i = 0; i < s->iso_urb_count; i++) {
710 /* in flight? */
711 if (aurb[i].iso_frame_idx == -1) {
712 ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
713 if (ret < 0) {
714 perror("USBDEVFS_DISCARDURB");
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
727 for (i = 0; i < s->iso_urb_count; i++) {
728 g_free(aurb[i].urb.buffer);
729 }
730
731 if (free)
732 g_free(aurb);
733 else
734 printf("husb: leaking iso urbs because of discard failure\n");
735 set_iso_urb(s, pid, ep, NULL);
736 set_iso_urb_idx(s, pid, ep, 0);
737 clear_iso_started(s, pid, ep);
738 }
739
740 static void urb_status_to_usb_ret(int status, USBPacket *p)
741 {
742 switch (status) {
743 case -EPIPE:
744 p->status = USB_RET_STALL;
745 break;
746 case -EOVERFLOW:
747 p->status = USB_RET_BABBLE;
748 break;
749 default:
750 p->status = USB_RET_IOERROR;
751 }
752 }
753
754 static void usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
755 {
756 AsyncURB *aurb;
757 int i, j, max_packet_size, offset, len;
758 uint8_t *buf;
759
760 max_packet_size = p->ep->max_packet_size;
761 if (max_packet_size == 0) {
762 p->status = USB_RET_NAK;
763 return;
764 }
765
766 aurb = get_iso_urb(s, p->pid, p->ep->nr);
767 if (!aurb) {
768 aurb = usb_host_alloc_iso(s, p->pid, p->ep->nr);
769 }
770
771 i = get_iso_urb_idx(s, p->pid, p->ep->nr);
772 j = aurb[i].iso_frame_idx;
773 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
774 if (in) {
775 /* Check urb status */
776 if (aurb[i].urb.status) {
777 urb_status_to_usb_ret(aurb[i].urb.status, p);
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) {
782 urb_status_to_usb_ret(aurb[i].urb.iso_frame_desc[j].status, p);
783 /* Check the frame fits */
784 } else if (aurb[i].urb.iso_frame_desc[j].actual_length
785 > p->iov.size) {
786 printf("husb: received iso data is larger then packet\n");
787 p->status = USB_RET_BABBLE;
788 /* All good copy data over */
789 } else {
790 len = aurb[i].urb.iso_frame_desc[j].actual_length;
791 buf = aurb[i].urb.buffer +
792 j * aurb[i].urb.iso_frame_desc[0].length;
793 usb_packet_copy(p, buf, len);
794 }
795 } else {
796 len = p->iov.size;
797 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->ep->nr);
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");
802 p->status = USB_RET_NAK;
803 return;
804 }
805
806 /* All good copy data over */
807 usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
808 aurb[i].urb.iso_frame_desc[j].length = len;
809 offset += len;
810 set_iso_buffer_used(s, p->pid, p->ep->nr, offset);
811
812 /* Start the stream once we have buffered enough data */
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);
815 }
816 }
817 aurb[i].iso_frame_idx++;
818 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
819 i = (i + 1) % s->iso_urb_count;
820 set_iso_urb_idx(s, p->pid, p->ep->nr, i);
821 }
822 } else {
823 if (in) {
824 set_iso_started(s, p->pid, p->ep->nr);
825 } else {
826 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
827 }
828 }
829
830 if (is_iso_started(s, p->pid, p->ep->nr)) {
831 /* (Re)-submit all fully consumed / filled urbs */
832 for (i = 0; i < s->iso_urb_count; i++) {
833 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
834 if (ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]) < 0) {
835 perror("USBDEVFS_SUBMITURB");
836 if (!in || p->status == USB_RET_SUCCESS) {
837 switch(errno) {
838 case ETIMEDOUT:
839 p->status = USB_RET_NAK;
840 break;
841 case EPIPE:
842 default:
843 p->status = USB_RET_STALL;
844 }
845 }
846 break;
847 }
848 aurb[i].iso_frame_idx = -1;
849 change_iso_inflight(s, p->pid, p->ep->nr, 1);
850 }
851 }
852 }
853 }
854
855 static void usb_host_handle_data(USBDevice *dev, USBPacket *p)
856 {
857 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
858 struct usbdevfs_urb *urb;
859 AsyncURB *aurb;
860 int ret, rem, prem, v;
861 uint8_t *pbuf;
862 uint8_t ep;
863
864 trace_usb_host_req_data(s->bus_num, s->addr, p,
865 p->pid == USB_TOKEN_IN,
866 p->ep->nr, p->iov.size);
867
868 if (!is_valid(s, p->pid, p->ep->nr)) {
869 p->status = USB_RET_NAK;
870 trace_usb_host_req_complete(s->bus_num, s->addr, p,
871 p->status, p->actual_length);
872 return;
873 }
874
875 if (p->pid == USB_TOKEN_IN) {
876 ep = p->ep->nr | 0x80;
877 } else {
878 ep = p->ep->nr;
879 }
880
881 if (is_halted(s, p->pid, p->ep->nr)) {
882 unsigned int arg = ep;
883 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
884 if (ret < 0) {
885 perror("USBDEVFS_CLEAR_HALT");
886 p->status = USB_RET_NAK;
887 trace_usb_host_req_complete(s->bus_num, s->addr, p,
888 p->status, p->actual_length);
889 return;
890 }
891 clear_halt(s, p->pid, p->ep->nr);
892 }
893
894 if (is_isoc(s, p->pid, p->ep->nr)) {
895 usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
896 return;
897 }
898
899 v = 0;
900 prem = 0;
901 pbuf = NULL;
902 rem = p->iov.size;
903 do {
904 if (prem == 0 && rem > 0) {
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);
909 v++;
910 }
911 aurb = async_alloc(s);
912 aurb->packet = p;
913
914 urb = &aurb->urb;
915 urb->endpoint = ep;
916 urb->type = usb_host_usbfs_type(s, p);
917 urb->usercontext = s;
918 urb->buffer = pbuf;
919 urb->buffer_length = prem;
920
921 if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
922 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
923 }
924 pbuf += urb->buffer_length;
925 prem -= urb->buffer_length;
926 rem -= urb->buffer_length;
927 if (rem) {
928 aurb->more = 1;
929 }
930
931 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
932 urb->buffer_length, aurb->more);
933 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
934
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);
937
938 if (ret < 0) {
939 perror("USBDEVFS_SUBMITURB");
940 async_free(aurb);
941
942 switch(errno) {
943 case ETIMEDOUT:
944 p->status = USB_RET_NAK;
945 trace_usb_host_req_complete(s->bus_num, s->addr, p,
946 p->status, p->actual_length);
947 break;
948 case EPIPE:
949 default:
950 p->status = USB_RET_STALL;
951 trace_usb_host_req_complete(s->bus_num, s->addr, p,
952 p->status, p->actual_length);
953 }
954 return;
955 }
956 } while (rem > 0);
957
958 p->status = USB_RET_ASYNC;
959 }
960
961 static int ctrl_error(void)
962 {
963 if (errno == ETIMEDOUT) {
964 return USB_RET_NAK;
965 } else {
966 return USB_RET_STALL;
967 }
968 }
969
970 static void usb_host_set_address(USBHostDevice *s, int addr)
971 {
972 trace_usb_host_set_address(s->bus_num, s->addr, addr);
973 s->dev.addr = addr;
974 }
975
976 static void usb_host_set_config(USBHostDevice *s, int config, USBPacket *p)
977 {
978 int ret, first = 1;
979
980 trace_usb_host_set_config(s->bus_num, s->addr, config);
981
982 usb_host_release_interfaces(s);
983
984 again:
985 ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
986
987 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
988
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
1000 if (ret < 0) {
1001 p->status = ctrl_error();
1002 return;
1003 }
1004 usb_host_claim_interfaces(s, config);
1005 usb_linux_update_endp_table(s);
1006 }
1007
1008 static void usb_host_set_interface(USBHostDevice *s, int iface, int alt,
1009 USBPacket *p)
1010 {
1011 struct usbdevfs_setinterface si;
1012 int i, ret;
1013
1014 trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
1015
1016 for (i = 1; i <= USB_MAX_ENDPOINTS; i++) {
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);
1022 }
1023 }
1024
1025 if (iface >= USB_MAX_INTERFACES) {
1026 p->status = USB_RET_STALL;
1027 return;
1028 }
1029
1030 si.interface = iface;
1031 si.altsetting = alt;
1032 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
1033
1034 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
1035 iface, alt, ret, errno);
1036
1037 if (ret < 0) {
1038 p->status = ctrl_error();
1039 return;
1040 }
1041
1042 s->dev.altsetting[iface] = alt;
1043 usb_linux_update_endp_table(s);
1044 }
1045
1046 static void usb_host_handle_control(USBDevice *dev, USBPacket *p,
1047 int request, int value, int index, int length, uint8_t *data)
1048 {
1049 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1050 struct usbdevfs_urb *urb;
1051 AsyncURB *aurb;
1052 int ret;
1053
1054 /*
1055 * Process certain standard device requests.
1056 * These are infrequent and are processed synchronously.
1057 */
1058
1059 /* Note request is (bRequestType << 8) | bRequest */
1060 trace_usb_host_req_control(s->bus_num, s->addr, p, request, value, index);
1061
1062 switch (request) {
1063 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1064 usb_host_set_address(s, value);
1065 trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1066 return;
1067
1068 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
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;
1072
1073 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
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;
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);
1084 return;
1085 }
1086 }
1087
1088 /* The rest are asynchronous */
1089 if (length > sizeof(dev->data_buf)) {
1090 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
1091 length, sizeof(dev->data_buf));
1092 p->status = USB_RET_STALL;
1093 return;
1094 }
1095
1096 aurb = async_alloc(s);
1097 aurb->packet = p;
1098
1099 /*
1100 * Setup ctrl transfer.
1101 *
1102 * s->ctrl is laid out such that data buffer immediately follows
1103 * 'req' struct which is exactly what usbdevfs expects.
1104 */
1105 urb = &aurb->urb;
1106
1107 urb->type = USBDEVFS_URB_TYPE_CONTROL;
1108 urb->endpoint = p->ep->nr;
1109
1110 urb->buffer = &dev->setup_buf;
1111 urb->buffer_length = length + 8;
1112
1113 urb->usercontext = s;
1114
1115 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
1116 urb->buffer_length, aurb->more);
1117 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
1118
1119 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
1120
1121 if (ret < 0) {
1122 DPRINTF("husb: submit failed. errno %d\n", errno);
1123 async_free(aurb);
1124
1125 switch(errno) {
1126 case ETIMEDOUT:
1127 p->status = USB_RET_NAK;
1128 break;
1129 case EPIPE:
1130 default:
1131 p->status = USB_RET_STALL;
1132 break;
1133 }
1134 return;
1135 }
1136
1137 p->status = USB_RET_ASYNC;
1138 }
1139
1140 static void usb_linux_update_endp_table(USBHostDevice *s)
1141 {
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;
1152 struct endp_data *epd;
1153 USBDescriptor *d;
1154 bool active = false;
1155
1156 usb_ep_reset(&s->dev);
1157
1158 for (i = 0;; i += d->bLength) {
1159 if (i+2 >= s->descr_len) {
1160 break;
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");
1166 return;
1167 }
1168 if (i + d->bLength > s->descr_len) {
1169 trace_usb_host_parse_error(s->bus_num, s->addr,
1170 "descriptor too long");
1171 return;
1172 }
1173 switch (d->bDescriptorType) {
1174 case 0:
1175 trace_usb_host_parse_error(s->bus_num, s->addr,
1176 "invalid descriptor type");
1177 return;
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");
1182 return;
1183 }
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");
1192 return;
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");
1203 return;
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");
1216 return;
1217 }
1218 devep = d->u.endpoint.bEndpointAddress;
1219 pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1220 ep = devep & 0xf;
1221 if (ep == 0) {
1222 trace_usb_host_parse_error(s->bus_num, s->addr,
1223 "invalid endpoint address");
1224 return;
1225 }
1226
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)) &&
1241 (type == USB_ENDPOINT_XFER_BULK) &&
1242 (pid == USB_TOKEN_OUT)) {
1243 usb_ep_set_pipeline(&s->dev, pid, ep, true);
1244 }
1245
1246 epd = get_endp(s, pid, ep);
1247 epd->halted = 0;
1248 }
1249
1250 break;
1251 default:
1252 trace_usb_host_parse_unknown(s->bus_num, s->addr,
1253 d->bLength, d->bDescriptorType);
1254 break;
1255 }
1256 }
1257 }
1258
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
1295 static int usb_host_open(USBHostDevice *dev, int bus_num,
1296 int addr, const char *port,
1297 const char *prod_name, int speed)
1298 {
1299 int fd = -1, ret;
1300
1301 trace_usb_host_open_started(bus_num, addr);
1302
1303 if (dev->fd != -1) {
1304 goto fail;
1305 }
1306
1307 fd = usb_host_open_device(bus_num, addr);
1308 if (fd < 0) {
1309 goto fail;
1310 }
1311 DPRINTF("husb: opened %s\n", buf);
1312
1313 dev->bus_num = bus_num;
1314 dev->addr = addr;
1315 pstrcpy(dev->port, sizeof(dev->port), port);
1316 dev->fd = fd;
1317
1318 /* read the device description */
1319 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1320 if (dev->descr_len <= 0) {
1321 perror("husb: reading device data failed");
1322 goto fail;
1323 }
1324
1325 #ifdef DEBUG
1326 {
1327 int x;
1328 printf("=== begin dumping device descriptor data ===\n");
1329 for (x = 0; x < dev->descr_len; x++) {
1330 printf("%02x ", dev->descr[x]);
1331 }
1332 printf("\n=== end dumping device descriptor data ===\n");
1333 }
1334 #endif
1335
1336
1337 /* start unconfigured -- we'll wait for the guest to set a configuration */
1338 if (!usb_host_claim_interfaces(dev, 0)) {
1339 goto fail;
1340 }
1341
1342 usb_ep_init(&dev->dev);
1343 usb_linux_update_endp_table(dev);
1344
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 }
1359 }
1360 dev->dev.speed = speed;
1361 dev->dev.speedmask = (1 << speed);
1362 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1363 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1364 }
1365
1366 trace_usb_host_open_success(bus_num, addr);
1367
1368 if (!prod_name || prod_name[0] == '\0') {
1369 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1370 "host:%d.%d", bus_num, addr);
1371 } else {
1372 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1373 prod_name);
1374 }
1375
1376 ret = usb_device_attach(&dev->dev);
1377 if (ret) {
1378 goto fail;
1379 }
1380
1381 /* USB devio uses 'write' flag to check for async completions */
1382 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1383
1384 return 0;
1385
1386 fail:
1387 trace_usb_host_open_failure(bus_num, addr);
1388 if (dev->fd != -1) {
1389 close(dev->fd);
1390 dev->fd = -1;
1391 }
1392 return -1;
1393 }
1394
1395 static int usb_host_close(USBHostDevice *dev)
1396 {
1397 int i;
1398
1399 if (dev->fd == -1) {
1400 return -1;
1401 }
1402
1403 trace_usb_host_close(dev->bus_num, dev->addr);
1404
1405 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1406 dev->closing = 1;
1407 for (i = 1; i <= USB_MAX_ENDPOINTS; i++) {
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);
1413 }
1414 }
1415 async_complete(dev);
1416 dev->closing = 0;
1417 if (dev->dev.attached) {
1418 usb_device_detach(&dev->dev);
1419 }
1420 usb_host_do_reset(dev);
1421 close(dev->fd);
1422 dev->fd = -1;
1423 return 0;
1424 }
1425
1426 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1427 {
1428 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1429
1430 usb_host_release_port(s);
1431 if (s->fd != -1) {
1432 usb_host_do_reset(s);
1433 }
1434 }
1435
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
1473 static int usb_host_initfn(USBDevice *dev)
1474 {
1475 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1476
1477 dev->flags |= (1 << USB_DEV_FLAG_IS_HOST);
1478 dev->auto_attach = 0;
1479 s->fd = -1;
1480 s->hub_fd = -1;
1481
1482 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1483 s->exit.notify = usb_host_exit_notifier;
1484 qemu_add_exit_notifier(&s->exit);
1485 s->bh = qemu_bh_new(usb_host_post_load_bh, s);
1486 usb_host_auto_check(NULL);
1487
1488 if (s->match.bus_num != 0 && s->match.port != NULL) {
1489 usb_host_claim_port(s);
1490 }
1491 add_boot_device_path(s->bootindex, &dev->qdev, NULL);
1492 return 0;
1493 }
1494
1495 static const VMStateDescription vmstate_usb_host = {
1496 .name = DEVNAME,
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 }
1504 };
1505
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),
1513 DEFINE_PROP_INT32("bootindex", USBHostDevice, bootindex, -1),
1514 DEFINE_PROP_BIT("pipeline", USBHostDevice, options,
1515 USB_HOST_OPT_PIPELINE, true),
1516 DEFINE_PROP_END_OF_LIST(),
1517 };
1518
1519 static void usb_host_class_initfn(ObjectClass *klass, void *data)
1520 {
1521 DeviceClass *dc = DEVICE_CLASS(klass);
1522 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
1523
1524 uc->init = usb_host_initfn;
1525 uc->product_desc = "USB Host Device";
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;
1531 dc->vmsd = &vmstate_usb_host;
1532 dc->props = usb_host_dev_properties;
1533 }
1534
1535 static const TypeInfo usb_host_dev_info = {
1536 .name = DEVNAME,
1537 .parent = TYPE_USB_DEVICE,
1538 .instance_size = sizeof(USBHostDevice),
1539 .class_init = usb_host_class_initfn,
1540 };
1541
1542 static void usb_host_register_types(void)
1543 {
1544 type_register_static(&usb_host_dev_info);
1545 }
1546
1547 type_init(usb_host_register_types)
1548
1549 /*
1550 * Read sys file-system device file
1551 *
1552 * @line address of buffer to put file contents in
1553 * @line_size size of line
1554 * @device_file path to device file (printf format string)
1555 * @device_name device being opened (inserted into device_file)
1556 *
1557 * @return 0 failed, 1 succeeded ('line' contains data)
1558 */
1559 static int usb_host_read_file(char *line, size_t line_size,
1560 const char *device_file, const char *device_name)
1561 {
1562 FILE *f;
1563 int ret = 0;
1564 char filename[PATH_MAX];
1565
1566 snprintf(filename, PATH_MAX, "/sys/bus/usb/devices/%s/%s", device_name,
1567 device_file);
1568 f = fopen(filename, "r");
1569 if (f) {
1570 ret = fgets(line, line_size, f) != NULL;
1571 fclose(f);
1572 }
1573
1574 return ret;
1575 }
1576
1577 /*
1578 * Use /sys/bus/usb/devices/ directory to determine host's USB
1579 * devices.
1580 *
1581 * This code is based on Robert Schiele's original patches posted to
1582 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1583 */
1584 static int usb_host_scan(void *opaque, USBScanFunc *func)
1585 {
1586 DIR *dir = NULL;
1587 char line[1024];
1588 int bus_num, addr, speed, class_id, product_id, vendor_id;
1589 int ret = 0;
1590 char port[MAX_PORTLEN];
1591 char product_name[512];
1592 struct dirent *de;
1593
1594 dir = opendir("/sys/bus/usb/devices");
1595 if (!dir) {
1596 perror("husb: opendir /sys/bus/usb/devices");
1597 fprintf(stderr, "husb: please make sure sysfs is mounted at /sys\n");
1598 goto the_end;
1599 }
1600
1601 while ((de = readdir(dir))) {
1602 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1603 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1604 continue;
1605 }
1606
1607 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1608 goto the_end;
1609 }
1610 if (sscanf(line, "%d", &addr) != 1) {
1611 goto the_end;
1612 }
1613 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1614 de->d_name)) {
1615 goto the_end;
1616 }
1617 if (sscanf(line, "%x", &class_id) != 1) {
1618 goto the_end;
1619 }
1620
1621 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1622 de->d_name)) {
1623 goto the_end;
1624 }
1625 if (sscanf(line, "%x", &vendor_id) != 1) {
1626 goto the_end;
1627 }
1628 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1629 de->d_name)) {
1630 goto the_end;
1631 }
1632 if (sscanf(line, "%x", &product_id) != 1) {
1633 goto the_end;
1634 }
1635 if (!usb_host_read_file(line, sizeof(line), "product",
1636 de->d_name)) {
1637 *product_name = 0;
1638 } else {
1639 if (strlen(line) > 0) {
1640 line[strlen(line) - 1] = '\0';
1641 }
1642 pstrcpy(product_name, sizeof(product_name), line);
1643 }
1644
1645 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1646 goto the_end;
1647 }
1648 if (!strcmp(line, "5000\n")) {
1649 speed = USB_SPEED_SUPER;
1650 } else if (!strcmp(line, "480\n")) {
1651 speed = USB_SPEED_HIGH;
1652 } else if (!strcmp(line, "1.5\n")) {
1653 speed = USB_SPEED_LOW;
1654 } else {
1655 speed = USB_SPEED_FULL;
1656 }
1657
1658 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1659 product_id, product_name, speed);
1660 if (ret) {
1661 goto the_end;
1662 }
1663 }
1664 }
1665 the_end:
1666 if (dir) {
1667 closedir(dir);
1668 }
1669 return ret;
1670 }
1671
1672 static QEMUTimer *usb_auto_timer;
1673 static VMChangeStateEntry *usb_vmstate;
1674
1675 static int usb_host_auto_scan(void *opaque, int bus_num,
1676 int addr, const char *port,
1677 int class_id, int vendor_id, int product_id,
1678 const char *product_name, int speed)
1679 {
1680 struct USBAutoFilter *f;
1681 struct USBHostDevice *s;
1682
1683 /* Ignore hubs */
1684 if (class_id == 9)
1685 return 0;
1686
1687 QTAILQ_FOREACH(s, &hostdevs, next) {
1688 f = &s->match;
1689
1690 if (f->bus_num > 0 && f->bus_num != bus_num) {
1691 continue;
1692 }
1693 if (f->addr > 0 && f->addr != addr) {
1694 continue;
1695 }
1696 if (f->port != NULL && strcmp(f->port, port) != 0) {
1697 continue;
1698 }
1699
1700 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1701 continue;
1702 }
1703
1704 if (f->product_id > 0 && f->product_id != product_id) {
1705 continue;
1706 }
1707 /* We got a match */
1708 s->seen++;
1709 if (s->errcount >= 3) {
1710 return 0;
1711 }
1712
1713 /* Already attached ? */
1714 if (s->fd != -1) {
1715 return 0;
1716 }
1717 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1718
1719 if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1720 s->errcount++;
1721 }
1722 break;
1723 }
1724
1725 return 0;
1726 }
1727
1728 static void usb_host_vm_state(void *unused, int running, RunState state)
1729 {
1730 if (running) {
1731 usb_host_auto_check(unused);
1732 }
1733 }
1734
1735 static void usb_host_auto_check(void *unused)
1736 {
1737 struct USBHostDevice *s;
1738 int unconnected = 0;
1739
1740 if (runstate_is_running()) {
1741 usb_host_scan(NULL, usb_host_auto_scan);
1742
1743 QTAILQ_FOREACH(s, &hostdevs, next) {
1744 if (s->fd == -1) {
1745 unconnected++;
1746 }
1747 if (s->seen == 0) {
1748 s->errcount = 0;
1749 }
1750 s->seen = 0;
1751 }
1752
1753 if (unconnected == 0) {
1754 /* nothing to watch */
1755 if (usb_auto_timer) {
1756 qemu_del_timer(usb_auto_timer);
1757 trace_usb_host_auto_scan_disabled();
1758 }
1759 return;
1760 }
1761 }
1762
1763 if (!usb_vmstate) {
1764 usb_vmstate = qemu_add_vm_change_state_handler(usb_host_vm_state, NULL);
1765 }
1766 if (!usb_auto_timer) {
1767 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1768 if (!usb_auto_timer) {
1769 return;
1770 }
1771 trace_usb_host_auto_scan_enabled();
1772 }
1773 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1774 }
1775
1776 #ifndef CONFIG_USB_LIBUSB
1777
1778 /**********************/
1779 /* USB host device info */
1780
1781 struct usb_class_info {
1782 int class;
1783 const char *class_name;
1784 };
1785
1786 static const struct usb_class_info usb_class_info[] = {
1787 { USB_CLASS_AUDIO, "Audio"},
1788 { USB_CLASS_COMM, "Communication"},
1789 { USB_CLASS_HID, "HID"},
1790 { USB_CLASS_HUB, "Hub" },
1791 { USB_CLASS_PHYSICAL, "Physical" },
1792 { USB_CLASS_PRINTER, "Printer" },
1793 { USB_CLASS_MASS_STORAGE, "Storage" },
1794 { USB_CLASS_CDC_DATA, "Data" },
1795 { USB_CLASS_APP_SPEC, "Application Specific" },
1796 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1797 { USB_CLASS_STILL_IMAGE, "Still Image" },
1798 { USB_CLASS_CSCID, "Smart Card" },
1799 { USB_CLASS_CONTENT_SEC, "Content Security" },
1800 { -1, NULL }
1801 };
1802
1803 static const char *usb_class_str(uint8_t class)
1804 {
1805 const struct usb_class_info *p;
1806 for(p = usb_class_info; p->class != -1; p++) {
1807 if (p->class == class) {
1808 break;
1809 }
1810 }
1811 return p->class_name;
1812 }
1813
1814 static void usb_info_device(Monitor *mon, int bus_num,
1815 int addr, const char *port,
1816 int class_id, int vendor_id, int product_id,
1817 const char *product_name,
1818 int speed)
1819 {
1820 const char *class_str, *speed_str;
1821
1822 switch(speed) {
1823 case USB_SPEED_LOW:
1824 speed_str = "1.5";
1825 break;
1826 case USB_SPEED_FULL:
1827 speed_str = "12";
1828 break;
1829 case USB_SPEED_HIGH:
1830 speed_str = "480";
1831 break;
1832 case USB_SPEED_SUPER:
1833 speed_str = "5000";
1834 break;
1835 default:
1836 speed_str = "?";
1837 break;
1838 }
1839
1840 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1841 bus_num, addr, port, speed_str);
1842 class_str = usb_class_str(class_id);
1843 if (class_str) {
1844 monitor_printf(mon, " %s:", class_str);
1845 } else {
1846 monitor_printf(mon, " Class %02x:", class_id);
1847 }
1848 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1849 if (product_name[0] != '\0') {
1850 monitor_printf(mon, ", %s", product_name);
1851 }
1852 monitor_printf(mon, "\n");
1853 }
1854
1855 static int usb_host_info_device(void *opaque, int bus_num, int addr,
1856 const char *path, int class_id,
1857 int vendor_id, int product_id,
1858 const char *product_name,
1859 int speed)
1860 {
1861 Monitor *mon = opaque;
1862
1863 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1864 product_name, speed);
1865 return 0;
1866 }
1867
1868 static void dec2str(int val, char *str, size_t size)
1869 {
1870 if (val == 0) {
1871 snprintf(str, size, "*");
1872 } else {
1873 snprintf(str, size, "%d", val);
1874 }
1875 }
1876
1877 static void hex2str(int val, char *str, size_t size)
1878 {
1879 if (val == 0) {
1880 snprintf(str, size, "*");
1881 } else {
1882 snprintf(str, size, "%04x", val);
1883 }
1884 }
1885
1886 void usb_host_info(Monitor *mon, const QDict *qdict)
1887 {
1888 struct USBAutoFilter *f;
1889 struct USBHostDevice *s;
1890
1891 usb_host_scan(mon, usb_host_info_device);
1892
1893 if (QTAILQ_EMPTY(&hostdevs)) {
1894 return;
1895 }
1896
1897 monitor_printf(mon, " Auto filters:\n");
1898 QTAILQ_FOREACH(s, &hostdevs, next) {
1899 char bus[10], addr[10], vid[10], pid[10];
1900 f = &s->match;
1901 dec2str(f->bus_num, bus, sizeof(bus));
1902 dec2str(f->addr, addr, sizeof(addr));
1903 hex2str(f->vendor_id, vid, sizeof(vid));
1904 hex2str(f->product_id, pid, sizeof(pid));
1905 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
1906 bus, addr, f->port ? f->port : "*", vid, pid);
1907 }
1908 }
1909
1910 #endif
QEmu