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