Use dma_addr_t type for scatter/gather code
[qemu.git] / usb-linux.c
blobf086d57edbc774b7ed9ff2c5cea698259a46ca55
1 /*
2 * Linux host USB redirector
4 * Copyright (c) 2005 Fabrice Bellard
6 * Copyright (c) 2008 Max Krasnyansky
7 * Support for host device auto connect & disconnect
8 * Major rewrite to support fully async operation
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
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:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
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.
33 #include "qemu-common.h"
34 #include "qemu-timer.h"
35 #include "monitor.h"
36 #include "sysemu.h"
37 #include "trace.h"
39 #include <dirent.h>
40 #include <sys/ioctl.h>
42 #include <linux/usbdevice_fs.h>
43 #include <linux/version.h>
44 #include "hw/usb.h"
46 /* We redefine it to avoid version problems */
47 struct usb_ctrltransfer {
48 uint8_t bRequestType;
49 uint8_t bRequest;
50 uint16_t wValue;
51 uint16_t wIndex;
52 uint16_t wLength;
53 uint32_t timeout;
54 void *data;
57 typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port,
58 int class_id, int vendor_id, int product_id,
59 const char *product_name, int speed);
61 //#define DEBUG
63 #ifdef DEBUG
64 #define DPRINTF printf
65 #else
66 #define DPRINTF(...)
67 #endif
69 #define USBDBG_DEVOPENED "husb: opened %s/devices\n"
71 #define USBPROCBUS_PATH "/proc/bus/usb"
72 #define PRODUCT_NAME_SZ 32
73 #define MAX_ENDPOINTS 15
74 #define MAX_PORTLEN 16
75 #define USBDEVBUS_PATH "/dev/bus/usb"
76 #define USBSYSBUS_PATH "/sys/bus/usb"
78 static char *usb_host_device_path;
80 #define USB_FS_NONE 0
81 #define USB_FS_PROC 1
82 #define USB_FS_DEV 2
83 #define USB_FS_SYS 3
85 static int usb_fs_type;
87 /* endpoint association data */
88 #define ISO_FRAME_DESC_PER_URB 32
89 #define INVALID_EP_TYPE 255
91 /* devio.c limits single requests to 16k */
92 #define MAX_USBFS_BUFFER_SIZE 16384
94 typedef struct AsyncURB AsyncURB;
96 struct endp_data {
97 uint8_t type;
98 uint8_t halted;
99 uint8_t iso_started;
100 AsyncURB *iso_urb;
101 int iso_urb_idx;
102 int iso_buffer_used;
103 int max_packet_size;
104 int inflight;
107 struct USBAutoFilter {
108 uint32_t bus_num;
109 uint32_t addr;
110 char *port;
111 uint32_t vendor_id;
112 uint32_t product_id;
115 typedef struct USBHostDevice {
116 USBDevice dev;
117 int fd;
118 int hub_fd;
120 uint8_t descr[8192];
121 int descr_len;
122 int configuration;
123 int ninterfaces;
124 int closing;
125 uint32_t iso_urb_count;
126 Notifier exit;
128 struct endp_data ep_in[MAX_ENDPOINTS];
129 struct endp_data ep_out[MAX_ENDPOINTS];
130 QLIST_HEAD(, AsyncURB) aurbs;
132 /* Host side address */
133 int bus_num;
134 int addr;
135 char port[MAX_PORTLEN];
136 struct USBAutoFilter match;
137 int seen, errcount;
139 QTAILQ_ENTRY(USBHostDevice) next;
140 } USBHostDevice;
142 static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
144 static int usb_host_close(USBHostDevice *dev);
145 static int parse_filter(const char *spec, struct USBAutoFilter *f);
146 static void usb_host_auto_check(void *unused);
147 static int usb_host_read_file(char *line, size_t line_size,
148 const char *device_file, const char *device_name);
149 static int usb_linux_update_endp_table(USBHostDevice *s);
151 static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep)
153 struct endp_data *eps = pid == USB_TOKEN_IN ? s->ep_in : s->ep_out;
154 assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
155 assert(ep > 0 && ep <= MAX_ENDPOINTS);
156 return eps + ep - 1;
159 static int is_isoc(USBHostDevice *s, int pid, int ep)
161 return get_endp(s, pid, ep)->type == USBDEVFS_URB_TYPE_ISO;
164 static int is_valid(USBHostDevice *s, int pid, int ep)
166 return get_endp(s, pid, ep)->type != INVALID_EP_TYPE;
169 static int is_halted(USBHostDevice *s, int pid, int ep)
171 return get_endp(s, pid, ep)->halted;
174 static void clear_halt(USBHostDevice *s, int pid, int ep)
176 trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep);
177 get_endp(s, pid, ep)->halted = 0;
180 static void set_halt(USBHostDevice *s, int pid, int ep)
182 if (ep != 0) {
183 trace_usb_host_ep_set_halt(s->bus_num, s->addr, ep);
184 get_endp(s, pid, ep)->halted = 1;
188 static int is_iso_started(USBHostDevice *s, int pid, int ep)
190 return get_endp(s, pid, ep)->iso_started;
193 static void clear_iso_started(USBHostDevice *s, int pid, int ep)
195 trace_usb_host_ep_stop_iso(s->bus_num, s->addr, ep);
196 get_endp(s, pid, ep)->iso_started = 0;
199 static void set_iso_started(USBHostDevice *s, int pid, int ep)
201 struct endp_data *e = get_endp(s, pid, ep);
203 trace_usb_host_ep_start_iso(s->bus_num, s->addr, ep);
204 if (!e->iso_started) {
205 e->iso_started = 1;
206 e->inflight = 0;
210 static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value)
212 struct endp_data *e = get_endp(s, pid, ep);
214 e->inflight += value;
215 return e->inflight;
218 static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb)
220 get_endp(s, pid, ep)->iso_urb = iso_urb;
223 static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep)
225 return get_endp(s, pid, ep)->iso_urb;
228 static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i)
230 get_endp(s, pid, ep)->iso_urb_idx = i;
233 static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep)
235 return get_endp(s, pid, ep)->iso_urb_idx;
238 static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i)
240 get_endp(s, pid, ep)->iso_buffer_used = i;
243 static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep)
245 return get_endp(s, pid, ep)->iso_buffer_used;
248 static void set_max_packet_size(USBHostDevice *s, int pid, int ep,
249 uint8_t *descriptor)
251 int raw = descriptor[4] + (descriptor[5] << 8);
252 int size, microframes;
254 size = raw & 0x7ff;
255 switch ((raw >> 11) & 3) {
256 case 1: microframes = 2; break;
257 case 2: microframes = 3; break;
258 default: microframes = 1; break;
260 get_endp(s, pid, ep)->max_packet_size = size * microframes;
263 static int get_max_packet_size(USBHostDevice *s, int pid, int ep)
265 return get_endp(s, pid, ep)->max_packet_size;
269 * Async URB state.
270 * We always allocate iso packet descriptors even for bulk transfers
271 * to simplify allocation and casts.
273 struct AsyncURB
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;
280 /* For regular async urbs */
281 USBPacket *packet;
282 int more; /* large transfer, more urbs follow */
284 /* For buffered iso handling */
285 int iso_frame_idx; /* -1 means in flight */
288 static AsyncURB *async_alloc(USBHostDevice *s)
290 AsyncURB *aurb = g_malloc0(sizeof(AsyncURB));
291 aurb->hdev = s;
292 QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
293 return aurb;
296 static void async_free(AsyncURB *aurb)
298 QLIST_REMOVE(aurb, next);
299 g_free(aurb);
302 static void do_disconnect(USBHostDevice *s)
304 usb_host_close(s);
305 usb_host_auto_check(NULL);
308 static void async_complete(void *opaque)
310 USBHostDevice *s = opaque;
311 AsyncURB *aurb;
312 int urbs = 0;
314 while (1) {
315 USBPacket *p;
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);
323 return;
325 if (errno == ENODEV) {
326 if (!s->closing) {
327 trace_usb_host_disconnect(s->bus_num, s->addr);
328 do_disconnect(s);
330 return;
333 perror("USBDEVFS_REAPURBNDELAY");
334 return;
337 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
338 aurb, aurb->urb.status, aurb->urb.actual_length);
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);
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");
356 continue;
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);
363 if (p) {
364 switch (aurb->urb.status) {
365 case 0:
366 p->result += aurb->urb.actual_length;
367 break;
369 case -EPIPE:
370 set_halt(s, p->pid, p->devep);
371 p->result = USB_RET_STALL;
372 break;
374 default:
375 p->result = USB_RET_NAK;
376 break;
379 if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
380 trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
381 usb_generic_async_ctrl_complete(&s->dev, p);
382 } else if (!aurb->more) {
383 trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
384 usb_packet_complete(&s->dev, p);
388 async_free(aurb);
392 static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
394 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
395 AsyncURB *aurb;
397 QLIST_FOREACH(aurb, &s->aurbs, next) {
398 if (p != aurb->packet) {
399 continue;
402 DPRINTF("husb: async cancel: packet %p, aurb %p\n", p, aurb);
404 /* Mark it as dead (see async_complete above) */
405 aurb->packet = NULL;
407 int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
408 if (r < 0) {
409 DPRINTF("husb: async. discard urb failed errno %d\n", errno);
414 static int usb_host_claim_port(USBHostDevice *s)
416 #ifdef USBDEVFS_CLAIM_PORT
417 char *h, hub_name[64], line[1024];
418 int hub_addr, portnr, ret;
420 snprintf(hub_name, sizeof(hub_name), "%d-%s",
421 s->match.bus_num, s->match.port);
423 /* try strip off last ".$portnr" to get hub */
424 h = strrchr(hub_name, '.');
425 if (h != NULL) {
426 portnr = atoi(h+1);
427 *h = '\0';
428 } else {
429 /* no dot in there -> it is the root hub */
430 snprintf(hub_name, sizeof(hub_name), "usb%d",
431 s->match.bus_num);
432 portnr = atoi(s->match.port);
435 if (!usb_host_read_file(line, sizeof(line), "devnum",
436 hub_name)) {
437 return -1;
439 if (sscanf(line, "%d", &hub_addr) != 1) {
440 return -1;
443 if (!usb_host_device_path) {
444 return -1;
446 snprintf(line, sizeof(line), "%s/%03d/%03d",
447 usb_host_device_path, s->match.bus_num, hub_addr);
448 s->hub_fd = open(line, O_RDWR | O_NONBLOCK);
449 if (s->hub_fd < 0) {
450 return -1;
453 ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &portnr);
454 if (ret < 0) {
455 close(s->hub_fd);
456 s->hub_fd = -1;
457 return -1;
460 trace_usb_host_claim_port(s->match.bus_num, hub_addr, portnr);
461 return 0;
462 #else
463 return -1;
464 #endif
467 static int usb_host_disconnect_ifaces(USBHostDevice *dev, int nb_interfaces)
469 /* earlier Linux 2.4 do not support that */
470 #ifdef USBDEVFS_DISCONNECT
471 struct usbdevfs_ioctl ctrl;
472 int ret, interface;
474 for (interface = 0; interface < nb_interfaces; interface++) {
475 ctrl.ioctl_code = USBDEVFS_DISCONNECT;
476 ctrl.ifno = interface;
477 ctrl.data = 0;
478 ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
479 if (ret < 0 && errno != ENODATA) {
480 perror("USBDEVFS_DISCONNECT");
481 return -1;
484 #endif
485 return 0;
488 static int usb_linux_get_num_interfaces(USBHostDevice *s)
490 char device_name[64], line[1024];
491 int num_interfaces = 0;
493 if (usb_fs_type != USB_FS_SYS) {
494 return -1;
497 sprintf(device_name, "%d-%s", s->bus_num, s->port);
498 if (!usb_host_read_file(line, sizeof(line), "bNumInterfaces",
499 device_name)) {
500 return -1;
502 if (sscanf(line, "%d", &num_interfaces) != 1) {
503 return -1;
505 return num_interfaces;
508 static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
510 const char *op = NULL;
511 int dev_descr_len, config_descr_len;
512 int interface, nb_interfaces;
513 int ret, i;
515 if (configuration == 0) { /* address state - ignore */
516 dev->ninterfaces = 0;
517 dev->configuration = 0;
518 return 1;
521 DPRINTF("husb: claiming interfaces. config %d\n", configuration);
523 i = 0;
524 dev_descr_len = dev->descr[0];
525 if (dev_descr_len > dev->descr_len) {
526 fprintf(stderr, "husb: update iface failed. descr too short\n");
527 return 0;
530 i += dev_descr_len;
531 while (i < dev->descr_len) {
532 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
533 i, dev->descr_len,
534 dev->descr[i], dev->descr[i+1]);
536 if (dev->descr[i+1] != USB_DT_CONFIG) {
537 i += dev->descr[i];
538 continue;
540 config_descr_len = dev->descr[i];
542 DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
544 if (configuration == dev->descr[i + 5]) {
545 configuration = dev->descr[i + 5];
546 break;
549 i += config_descr_len;
552 if (i >= dev->descr_len) {
553 fprintf(stderr,
554 "husb: update iface failed. no matching configuration\n");
555 return 0;
557 nb_interfaces = dev->descr[i + 4];
559 if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) {
560 goto fail;
563 /* XXX: only grab if all interfaces are free */
564 for (interface = 0; interface < nb_interfaces; interface++) {
565 op = "USBDEVFS_CLAIMINTERFACE";
566 ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
567 if (ret < 0) {
568 goto fail;
572 trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
573 nb_interfaces, configuration);
575 dev->ninterfaces = nb_interfaces;
576 dev->configuration = configuration;
577 return 1;
579 fail:
580 if (errno == ENODEV) {
581 do_disconnect(dev);
583 perror(op);
584 return 0;
587 static int usb_host_release_interfaces(USBHostDevice *s)
589 int ret, i;
591 trace_usb_host_release_interfaces(s->bus_num, s->addr);
593 for (i = 0; i < s->ninterfaces; i++) {
594 ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
595 if (ret < 0) {
596 perror("USBDEVFS_RELEASEINTERFACE");
597 return 0;
600 return 1;
603 static void usb_host_handle_reset(USBDevice *dev)
605 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
607 trace_usb_host_reset(s->bus_num, s->addr);
609 ioctl(s->fd, USBDEVFS_RESET);
611 usb_host_claim_interfaces(s, 0);
612 usb_linux_update_endp_table(s);
615 static void usb_host_handle_destroy(USBDevice *dev)
617 USBHostDevice *s = (USBHostDevice *)dev;
619 usb_host_close(s);
620 if (s->hub_fd != -1) {
621 close(s->hub_fd);
623 QTAILQ_REMOVE(&hostdevs, s, next);
624 qemu_remove_exit_notifier(&s->exit);
627 /* iso data is special, we need to keep enough urbs in flight to make sure
628 that the controller never runs out of them, otherwise the device will
629 likely suffer a buffer underrun / overrun. */
630 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
632 AsyncURB *aurb;
633 int i, j, len = get_max_packet_size(s, pid, ep);
635 aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
636 for (i = 0; i < s->iso_urb_count; i++) {
637 aurb[i].urb.endpoint = ep;
638 aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
639 aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length);
640 aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO;
641 aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP;
642 aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
643 for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
644 aurb[i].urb.iso_frame_desc[j].length = len;
645 if (pid == USB_TOKEN_IN) {
646 aurb[i].urb.endpoint |= 0x80;
647 /* Mark as fully consumed (idle) */
648 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
651 set_iso_urb(s, pid, ep, aurb);
653 return aurb;
656 static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
658 AsyncURB *aurb;
659 int i, ret, killed = 0, free = 1;
661 aurb = get_iso_urb(s, pid, ep);
662 if (!aurb) {
663 return;
666 for (i = 0; i < s->iso_urb_count; i++) {
667 /* in flight? */
668 if (aurb[i].iso_frame_idx == -1) {
669 ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
670 if (ret < 0) {
671 perror("USBDEVFS_DISCARDURB");
672 free = 0;
673 continue;
675 killed++;
679 /* Make sure any urbs we've killed are reaped before we free them */
680 if (killed) {
681 async_complete(s);
684 for (i = 0; i < s->iso_urb_count; i++) {
685 g_free(aurb[i].urb.buffer);
688 if (free)
689 g_free(aurb);
690 else
691 printf("husb: leaking iso urbs because of discard failure\n");
692 set_iso_urb(s, pid, ep, NULL);
693 set_iso_urb_idx(s, pid, ep, 0);
694 clear_iso_started(s, pid, ep);
697 static int urb_status_to_usb_ret(int status)
699 switch (status) {
700 case -EPIPE:
701 return USB_RET_STALL;
702 default:
703 return USB_RET_NAK;
707 static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
709 AsyncURB *aurb;
710 int i, j, ret, max_packet_size, offset, len = 0;
711 uint8_t *buf;
713 max_packet_size = get_max_packet_size(s, p->pid, p->devep);
714 if (max_packet_size == 0)
715 return USB_RET_NAK;
717 aurb = get_iso_urb(s, p->pid, p->devep);
718 if (!aurb) {
719 aurb = usb_host_alloc_iso(s, p->pid, p->devep);
722 i = get_iso_urb_idx(s, p->pid, p->devep);
723 j = aurb[i].iso_frame_idx;
724 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
725 if (in) {
726 /* Check urb status */
727 if (aurb[i].urb.status) {
728 len = urb_status_to_usb_ret(aurb[i].urb.status);
729 /* Move to the next urb */
730 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
731 /* Check frame status */
732 } else if (aurb[i].urb.iso_frame_desc[j].status) {
733 len = urb_status_to_usb_ret(
734 aurb[i].urb.iso_frame_desc[j].status);
735 /* Check the frame fits */
736 } else if (aurb[i].urb.iso_frame_desc[j].actual_length
737 > p->iov.size) {
738 printf("husb: received iso data is larger then packet\n");
739 len = USB_RET_NAK;
740 /* All good copy data over */
741 } else {
742 len = aurb[i].urb.iso_frame_desc[j].actual_length;
743 buf = aurb[i].urb.buffer +
744 j * aurb[i].urb.iso_frame_desc[0].length;
745 usb_packet_copy(p, buf, len);
747 } else {
748 len = p->iov.size;
749 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
751 /* Check the frame fits */
752 if (len > max_packet_size) {
753 printf("husb: send iso data is larger then max packet size\n");
754 return USB_RET_NAK;
757 /* All good copy data over */
758 usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
759 aurb[i].urb.iso_frame_desc[j].length = len;
760 offset += len;
761 set_iso_buffer_used(s, p->pid, p->devep, offset);
763 /* Start the stream once we have buffered enough data */
764 if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
765 set_iso_started(s, p->pid, p->devep);
768 aurb[i].iso_frame_idx++;
769 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
770 i = (i + 1) % s->iso_urb_count;
771 set_iso_urb_idx(s, p->pid, p->devep, i);
773 } else {
774 if (in) {
775 set_iso_started(s, p->pid, p->devep);
776 } else {
777 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
781 if (is_iso_started(s, p->pid, p->devep)) {
782 /* (Re)-submit all fully consumed / filled urbs */
783 for (i = 0; i < s->iso_urb_count; i++) {
784 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
785 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
786 if (ret < 0) {
787 perror("USBDEVFS_SUBMITURB");
788 if (!in || len == 0) {
789 switch(errno) {
790 case ETIMEDOUT:
791 len = USB_RET_NAK;
792 break;
793 case EPIPE:
794 default:
795 len = USB_RET_STALL;
798 break;
800 aurb[i].iso_frame_idx = -1;
801 change_iso_inflight(s, p->pid, p->devep, 1);
806 return len;
809 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
811 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
812 struct usbdevfs_urb *urb;
813 AsyncURB *aurb;
814 int ret, rem, prem, v;
815 uint8_t *pbuf;
816 uint8_t ep;
818 trace_usb_host_req_data(s->bus_num, s->addr,
819 p->pid == USB_TOKEN_IN,
820 p->devep, p->iov.size);
822 if (!is_valid(s, p->pid, p->devep)) {
823 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
824 return USB_RET_NAK;
827 if (p->pid == USB_TOKEN_IN) {
828 ep = p->devep | 0x80;
829 } else {
830 ep = p->devep;
833 if (is_halted(s, p->pid, p->devep)) {
834 unsigned int arg = ep;
835 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
836 if (ret < 0) {
837 perror("USBDEVFS_CLEAR_HALT");
838 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
839 return USB_RET_NAK;
841 clear_halt(s, p->pid, p->devep);
844 if (is_isoc(s, p->pid, p->devep)) {
845 return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
848 v = 0;
849 prem = p->iov.iov[v].iov_len;
850 pbuf = p->iov.iov[v].iov_base;
851 rem = p->iov.size;
852 while (rem) {
853 if (prem == 0) {
854 v++;
855 assert(v < p->iov.niov);
856 prem = p->iov.iov[v].iov_len;
857 pbuf = p->iov.iov[v].iov_base;
858 assert(prem <= rem);
860 aurb = async_alloc(s);
861 aurb->packet = p;
863 urb = &aurb->urb;
864 urb->endpoint = ep;
865 urb->type = USBDEVFS_URB_TYPE_BULK;
866 urb->usercontext = s;
867 urb->buffer = pbuf;
868 urb->buffer_length = prem;
870 if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
871 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
873 pbuf += urb->buffer_length;
874 prem -= urb->buffer_length;
875 rem -= urb->buffer_length;
876 if (rem) {
877 aurb->more = 1;
880 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
881 urb->buffer_length, aurb->more);
882 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
884 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
885 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
887 if (ret < 0) {
888 perror("USBDEVFS_SUBMITURB");
889 async_free(aurb);
891 switch(errno) {
892 case ETIMEDOUT:
893 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
894 return USB_RET_NAK;
895 case EPIPE:
896 default:
897 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL);
898 return USB_RET_STALL;
903 return USB_RET_ASYNC;
906 static int ctrl_error(void)
908 if (errno == ETIMEDOUT) {
909 return USB_RET_NAK;
910 } else {
911 return USB_RET_STALL;
915 static int usb_host_set_address(USBHostDevice *s, int addr)
917 trace_usb_host_set_address(s->bus_num, s->addr, addr);
918 s->dev.addr = addr;
919 return 0;
922 static int usb_host_set_config(USBHostDevice *s, int config)
924 int ret, first = 1;
926 trace_usb_host_set_config(s->bus_num, s->addr, config);
928 usb_host_release_interfaces(s);
930 again:
931 ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
933 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
935 if (ret < 0 && errno == EBUSY && first) {
936 /* happens if usb device is in use by host drivers */
937 int count = usb_linux_get_num_interfaces(s);
938 if (count > 0) {
939 DPRINTF("husb: busy -> disconnecting %d interfaces\n", count);
940 usb_host_disconnect_ifaces(s, count);
941 first = 0;
942 goto again;
946 if (ret < 0) {
947 return ctrl_error();
949 usb_host_claim_interfaces(s, config);
950 usb_linux_update_endp_table(s);
951 return 0;
954 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
956 struct usbdevfs_setinterface si;
957 int i, ret;
959 trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
961 for (i = 1; i <= MAX_ENDPOINTS; i++) {
962 if (is_isoc(s, USB_TOKEN_IN, i)) {
963 usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i);
965 if (is_isoc(s, USB_TOKEN_OUT, i)) {
966 usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i);
970 si.interface = iface;
971 si.altsetting = alt;
972 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
974 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
975 iface, alt, ret, errno);
977 if (ret < 0) {
978 return ctrl_error();
980 usb_linux_update_endp_table(s);
981 return 0;
984 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
985 int request, int value, int index, int length, uint8_t *data)
987 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
988 struct usbdevfs_urb *urb;
989 AsyncURB *aurb;
990 int ret;
993 * Process certain standard device requests.
994 * These are infrequent and are processed synchronously.
997 /* Note request is (bRequestType << 8) | bRequest */
998 trace_usb_host_req_control(s->bus_num, s->addr, request, value, index);
1000 switch (request) {
1001 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1002 return usb_host_set_address(s, value);
1004 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1005 return usb_host_set_config(s, value & 0xff);
1007 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1008 return usb_host_set_interface(s, index, value);
1011 /* The rest are asynchronous */
1013 if (length > sizeof(dev->data_buf)) {
1014 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
1015 length, sizeof(dev->data_buf));
1016 return USB_RET_STALL;
1019 aurb = async_alloc(s);
1020 aurb->packet = p;
1023 * Setup ctrl transfer.
1025 * s->ctrl is laid out such that data buffer immediately follows
1026 * 'req' struct which is exactly what usbdevfs expects.
1028 urb = &aurb->urb;
1030 urb->type = USBDEVFS_URB_TYPE_CONTROL;
1031 urb->endpoint = p->devep;
1033 urb->buffer = &dev->setup_buf;
1034 urb->buffer_length = length + 8;
1036 urb->usercontext = s;
1038 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
1039 urb->buffer_length, aurb->more);
1040 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
1042 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
1044 if (ret < 0) {
1045 DPRINTF("husb: submit failed. errno %d\n", errno);
1046 async_free(aurb);
1048 switch(errno) {
1049 case ETIMEDOUT:
1050 return USB_RET_NAK;
1051 case EPIPE:
1052 default:
1053 return USB_RET_STALL;
1057 return USB_RET_ASYNC;
1060 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
1061 uint8_t configuration, uint8_t interface)
1063 uint8_t alt_setting;
1064 struct usb_ctrltransfer ct;
1065 int ret;
1067 if (usb_fs_type == USB_FS_SYS) {
1068 char device_name[64], line[1024];
1069 int alt_setting;
1071 sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
1072 (int)configuration, (int)interface);
1074 if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
1075 device_name)) {
1076 goto usbdevfs;
1078 if (sscanf(line, "%d", &alt_setting) != 1) {
1079 goto usbdevfs;
1081 return alt_setting;
1084 usbdevfs:
1085 ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
1086 ct.bRequest = USB_REQ_GET_INTERFACE;
1087 ct.wValue = 0;
1088 ct.wIndex = interface;
1089 ct.wLength = 1;
1090 ct.data = &alt_setting;
1091 ct.timeout = 50;
1092 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
1093 if (ret < 0) {
1094 /* Assume alt 0 on error */
1095 return 0;
1098 return alt_setting;
1101 /* returns 1 on problem encountered or 0 for success */
1102 static int usb_linux_update_endp_table(USBHostDevice *s)
1104 uint8_t *descriptors;
1105 uint8_t devep, type, alt_interface;
1106 int interface, length, i, ep, pid;
1107 struct endp_data *epd;
1109 for (i = 0; i < MAX_ENDPOINTS; i++) {
1110 s->ep_in[i].type = INVALID_EP_TYPE;
1111 s->ep_out[i].type = INVALID_EP_TYPE;
1114 if (s->configuration == 0) {
1115 /* not configured yet -- leave all endpoints disabled */
1116 return 0;
1119 /* get the desired configuration, interface, and endpoint descriptors
1120 * from device description */
1121 descriptors = &s->descr[18];
1122 length = s->descr_len - 18;
1123 i = 0;
1125 if (descriptors[i + 1] != USB_DT_CONFIG ||
1126 descriptors[i + 5] != s->configuration) {
1127 fprintf(stderr, "invalid descriptor data - configuration %d\n",
1128 s->configuration);
1129 return 1;
1131 i += descriptors[i];
1133 while (i < length) {
1134 if (descriptors[i + 1] != USB_DT_INTERFACE ||
1135 (descriptors[i + 1] == USB_DT_INTERFACE &&
1136 descriptors[i + 4] == 0)) {
1137 i += descriptors[i];
1138 continue;
1141 interface = descriptors[i + 2];
1142 alt_interface = usb_linux_get_alt_setting(s, s->configuration,
1143 interface);
1145 /* the current interface descriptor is the active interface
1146 * and has endpoints */
1147 if (descriptors[i + 3] != alt_interface) {
1148 i += descriptors[i];
1149 continue;
1152 /* advance to the endpoints */
1153 while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1154 i += descriptors[i];
1157 if (i >= length)
1158 break;
1160 while (i < length) {
1161 if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1162 break;
1165 devep = descriptors[i + 2];
1166 pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1167 ep = devep & 0xf;
1168 if (ep == 0) {
1169 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1170 return 1;
1173 switch (descriptors[i + 3] & 0x3) {
1174 case 0x00:
1175 type = USBDEVFS_URB_TYPE_CONTROL;
1176 break;
1177 case 0x01:
1178 type = USBDEVFS_URB_TYPE_ISO;
1179 set_max_packet_size(s, pid, ep, descriptors + i);
1180 break;
1181 case 0x02:
1182 type = USBDEVFS_URB_TYPE_BULK;
1183 break;
1184 case 0x03:
1185 type = USBDEVFS_URB_TYPE_INTERRUPT;
1186 break;
1187 default:
1188 DPRINTF("usb_host: malformed endpoint type\n");
1189 type = USBDEVFS_URB_TYPE_BULK;
1191 epd = get_endp(s, pid, ep);
1192 assert(epd->type == INVALID_EP_TYPE);
1193 epd->type = type;
1194 epd->halted = 0;
1196 i += descriptors[i];
1199 return 0;
1203 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1204 * this function assumes this is safe, if:
1205 * 1) There are no isoc endpoints
1206 * 2) There are no interrupt endpoints with a max_packet_size > 64
1207 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1208 * usb1 compatible, but in practice this seems to work fine.
1210 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1212 int i, packet_size;
1215 * usb_linux_update_endp_table only registers info about ep in the current
1216 * interface altsettings, so we need to parse the descriptors again.
1218 for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1219 if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1220 switch (dev->descr[i + 3] & 0x3) {
1221 case 0x00: /* CONTROL */
1222 break;
1223 case 0x01: /* ISO */
1224 return 0;
1225 case 0x02: /* BULK */
1226 break;
1227 case 0x03: /* INTERRUPT */
1228 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1229 if (packet_size > 64)
1230 return 0;
1231 break;
1235 return 1;
1238 static int usb_host_open(USBHostDevice *dev, int bus_num,
1239 int addr, const char *port,
1240 const char *prod_name, int speed)
1242 int fd = -1, ret;
1243 char buf[1024];
1245 trace_usb_host_open_started(bus_num, addr);
1247 if (dev->fd != -1) {
1248 goto fail;
1251 if (!usb_host_device_path) {
1252 perror("husb: USB Host Device Path not set");
1253 goto fail;
1255 snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1256 bus_num, addr);
1257 fd = open(buf, O_RDWR | O_NONBLOCK);
1258 if (fd < 0) {
1259 perror(buf);
1260 goto fail;
1262 DPRINTF("husb: opened %s\n", buf);
1264 dev->bus_num = bus_num;
1265 dev->addr = addr;
1266 strcpy(dev->port, port);
1267 dev->fd = fd;
1269 /* read the device description */
1270 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1271 if (dev->descr_len <= 0) {
1272 perror("husb: reading device data failed");
1273 goto fail;
1276 #ifdef DEBUG
1278 int x;
1279 printf("=== begin dumping device descriptor data ===\n");
1280 for (x = 0; x < dev->descr_len; x++) {
1281 printf("%02x ", dev->descr[x]);
1283 printf("\n=== end dumping device descriptor data ===\n");
1285 #endif
1288 /* start unconfigured -- we'll wait for the guest to set a configuration */
1289 if (!usb_host_claim_interfaces(dev, 0)) {
1290 goto fail;
1293 ret = usb_linux_update_endp_table(dev);
1294 if (ret) {
1295 goto fail;
1298 if (speed == -1) {
1299 struct usbdevfs_connectinfo ci;
1301 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1302 if (ret < 0) {
1303 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1304 goto fail;
1307 if (ci.slow) {
1308 speed = USB_SPEED_LOW;
1309 } else {
1310 speed = USB_SPEED_HIGH;
1313 dev->dev.speed = speed;
1314 dev->dev.speedmask = (1 << speed);
1315 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1316 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1319 trace_usb_host_open_success(bus_num, addr);
1321 if (!prod_name || prod_name[0] == '\0') {
1322 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1323 "host:%d.%d", bus_num, addr);
1324 } else {
1325 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1326 prod_name);
1329 ret = usb_device_attach(&dev->dev);
1330 if (ret) {
1331 goto fail;
1334 /* USB devio uses 'write' flag to check for async completions */
1335 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1337 return 0;
1339 fail:
1340 trace_usb_host_open_failure(bus_num, addr);
1341 if (dev->fd != -1) {
1342 close(dev->fd);
1343 dev->fd = -1;
1345 return -1;
1348 static int usb_host_close(USBHostDevice *dev)
1350 int i;
1352 if (dev->fd == -1) {
1353 return -1;
1356 trace_usb_host_close(dev->bus_num, dev->addr);
1358 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1359 dev->closing = 1;
1360 for (i = 1; i <= MAX_ENDPOINTS; i++) {
1361 if (is_isoc(dev, USB_TOKEN_IN, i)) {
1362 usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i);
1364 if (is_isoc(dev, USB_TOKEN_OUT, i)) {
1365 usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i);
1368 async_complete(dev);
1369 dev->closing = 0;
1370 if (dev->dev.attached) {
1371 usb_device_detach(&dev->dev);
1373 ioctl(dev->fd, USBDEVFS_RESET);
1374 close(dev->fd);
1375 dev->fd = -1;
1376 return 0;
1379 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1381 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1383 if (s->fd != -1) {
1384 ioctl(s->fd, USBDEVFS_RESET);
1388 static int usb_host_initfn(USBDevice *dev)
1390 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1392 dev->auto_attach = 0;
1393 s->fd = -1;
1394 s->hub_fd = -1;
1396 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1397 s->exit.notify = usb_host_exit_notifier;
1398 qemu_add_exit_notifier(&s->exit);
1399 usb_host_auto_check(NULL);
1401 if (s->match.bus_num != 0 && s->match.port != NULL) {
1402 usb_host_claim_port(s);
1404 return 0;
1407 static const VMStateDescription vmstate_usb_host = {
1408 .name = "usb-host",
1409 .unmigratable = 1,
1412 static struct USBDeviceInfo usb_host_dev_info = {
1413 .product_desc = "USB Host Device",
1414 .qdev.name = "usb-host",
1415 .qdev.size = sizeof(USBHostDevice),
1416 .qdev.vmsd = &vmstate_usb_host,
1417 .init = usb_host_initfn,
1418 .handle_packet = usb_generic_handle_packet,
1419 .cancel_packet = usb_host_async_cancel,
1420 .handle_data = usb_host_handle_data,
1421 .handle_control = usb_host_handle_control,
1422 .handle_reset = usb_host_handle_reset,
1423 .handle_destroy = usb_host_handle_destroy,
1424 .usbdevice_name = "host",
1425 .usbdevice_init = usb_host_device_open,
1426 .qdev.props = (Property[]) {
1427 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1428 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1429 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1430 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1431 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1432 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1433 DEFINE_PROP_END_OF_LIST(),
1437 static void usb_host_register_devices(void)
1439 usb_qdev_register(&usb_host_dev_info);
1441 device_init(usb_host_register_devices)
1443 USBDevice *usb_host_device_open(const char *devname)
1445 struct USBAutoFilter filter;
1446 USBDevice *dev;
1447 char *p;
1449 dev = usb_create(NULL /* FIXME */, "usb-host");
1451 if (strstr(devname, "auto:")) {
1452 if (parse_filter(devname, &filter) < 0) {
1453 goto fail;
1455 } else {
1456 if ((p = strchr(devname, '.'))) {
1457 filter.bus_num = strtoul(devname, NULL, 0);
1458 filter.addr = strtoul(p + 1, NULL, 0);
1459 filter.vendor_id = 0;
1460 filter.product_id = 0;
1461 } else if ((p = strchr(devname, ':'))) {
1462 filter.bus_num = 0;
1463 filter.addr = 0;
1464 filter.vendor_id = strtoul(devname, NULL, 16);
1465 filter.product_id = strtoul(p + 1, NULL, 16);
1466 } else {
1467 goto fail;
1471 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1472 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1473 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1474 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1475 qdev_init_nofail(&dev->qdev);
1476 return dev;
1478 fail:
1479 qdev_free(&dev->qdev);
1480 return NULL;
1483 int usb_host_device_close(const char *devname)
1485 #if 0
1486 char product_name[PRODUCT_NAME_SZ];
1487 int bus_num, addr;
1488 USBHostDevice *s;
1490 if (strstr(devname, "auto:")) {
1491 return usb_host_auto_del(devname);
1493 if (usb_host_find_device(&bus_num, &addr, product_name,
1494 sizeof(product_name), devname) < 0) {
1495 return -1;
1497 s = hostdev_find(bus_num, addr);
1498 if (s) {
1499 usb_device_delete_addr(s->bus_num, s->dev.addr);
1500 return 0;
1502 #endif
1504 return -1;
1507 static int get_tag_value(char *buf, int buf_size,
1508 const char *str, const char *tag,
1509 const char *stopchars)
1511 const char *p;
1512 char *q;
1513 p = strstr(str, tag);
1514 if (!p) {
1515 return -1;
1517 p += strlen(tag);
1518 while (qemu_isspace(*p)) {
1519 p++;
1521 q = buf;
1522 while (*p != '\0' && !strchr(stopchars, *p)) {
1523 if ((q - buf) < (buf_size - 1)) {
1524 *q++ = *p;
1526 p++;
1528 *q = '\0';
1529 return q - buf;
1533 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1534 * host's USB devices. This is legacy support since many distributions
1535 * are moving to /sys/bus/usb
1537 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1539 FILE *f = NULL;
1540 char line[1024];
1541 char buf[1024];
1542 int bus_num, addr, speed, device_count;
1543 int class_id, product_id, vendor_id, port;
1544 char product_name[512];
1545 int ret = 0;
1547 if (!usb_host_device_path) {
1548 perror("husb: USB Host Device Path not set");
1549 goto the_end;
1551 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1552 f = fopen(line, "r");
1553 if (!f) {
1554 perror("husb: cannot open devices file");
1555 goto the_end;
1558 device_count = 0;
1559 bus_num = addr = class_id = product_id = vendor_id = port = 0;
1560 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1561 for(;;) {
1562 if (fgets(line, sizeof(line), f) == NULL) {
1563 break;
1565 if (strlen(line) > 0) {
1566 line[strlen(line) - 1] = '\0';
1568 if (line[0] == 'T' && line[1] == ':') {
1569 if (device_count && (vendor_id || product_id)) {
1570 /* New device. Add the previously discovered device. */
1571 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1572 product_id, product_name, speed);
1573 if (ret) {
1574 goto the_end;
1577 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1578 goto fail;
1580 bus_num = atoi(buf);
1581 if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) {
1582 goto fail;
1584 port = atoi(buf);
1585 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1586 goto fail;
1588 addr = atoi(buf);
1589 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1590 goto fail;
1592 if (!strcmp(buf, "5000")) {
1593 speed = USB_SPEED_SUPER;
1594 } else if (!strcmp(buf, "480")) {
1595 speed = USB_SPEED_HIGH;
1596 } else if (!strcmp(buf, "1.5")) {
1597 speed = USB_SPEED_LOW;
1598 } else {
1599 speed = USB_SPEED_FULL;
1601 product_name[0] = '\0';
1602 class_id = 0xff;
1603 device_count++;
1604 product_id = 0;
1605 vendor_id = 0;
1606 } else if (line[0] == 'P' && line[1] == ':') {
1607 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1608 goto fail;
1610 vendor_id = strtoul(buf, NULL, 16);
1611 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1612 goto fail;
1614 product_id = strtoul(buf, NULL, 16);
1615 } else if (line[0] == 'S' && line[1] == ':') {
1616 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1617 goto fail;
1619 pstrcpy(product_name, sizeof(product_name), buf);
1620 } else if (line[0] == 'D' && line[1] == ':') {
1621 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1622 goto fail;
1624 class_id = strtoul(buf, NULL, 16);
1626 fail: ;
1628 if (device_count && (vendor_id || product_id)) {
1629 /* Add the last device. */
1630 if (port > 0) {
1631 snprintf(buf, sizeof(buf), "%d", port);
1632 } else {
1633 snprintf(buf, sizeof(buf), "?");
1635 ret = func(opaque, bus_num, addr, buf, class_id, vendor_id,
1636 product_id, product_name, speed);
1638 the_end:
1639 if (f) {
1640 fclose(f);
1642 return ret;
1646 * Read sys file-system device file
1648 * @line address of buffer to put file contents in
1649 * @line_size size of line
1650 * @device_file path to device file (printf format string)
1651 * @device_name device being opened (inserted into device_file)
1653 * @return 0 failed, 1 succeeded ('line' contains data)
1655 static int usb_host_read_file(char *line, size_t line_size,
1656 const char *device_file, const char *device_name)
1658 FILE *f;
1659 int ret = 0;
1660 char filename[PATH_MAX];
1662 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1663 device_file);
1664 f = fopen(filename, "r");
1665 if (f) {
1666 ret = fgets(line, line_size, f) != NULL;
1667 fclose(f);
1670 return ret;
1674 * Use /sys/bus/usb/devices/ directory to determine host's USB
1675 * devices.
1677 * This code is based on Robert Schiele's original patches posted to
1678 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1680 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1682 DIR *dir = NULL;
1683 char line[1024];
1684 int bus_num, addr, speed, class_id, product_id, vendor_id;
1685 int ret = 0;
1686 char port[MAX_PORTLEN];
1687 char product_name[512];
1688 struct dirent *de;
1690 dir = opendir(USBSYSBUS_PATH "/devices");
1691 if (!dir) {
1692 perror("husb: cannot open devices directory");
1693 goto the_end;
1696 while ((de = readdir(dir))) {
1697 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1698 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1699 continue;
1702 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1703 goto the_end;
1705 if (sscanf(line, "%d", &addr) != 1) {
1706 goto the_end;
1708 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1709 de->d_name)) {
1710 goto the_end;
1712 if (sscanf(line, "%x", &class_id) != 1) {
1713 goto the_end;
1716 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1717 de->d_name)) {
1718 goto the_end;
1720 if (sscanf(line, "%x", &vendor_id) != 1) {
1721 goto the_end;
1723 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1724 de->d_name)) {
1725 goto the_end;
1727 if (sscanf(line, "%x", &product_id) != 1) {
1728 goto the_end;
1730 if (!usb_host_read_file(line, sizeof(line), "product",
1731 de->d_name)) {
1732 *product_name = 0;
1733 } else {
1734 if (strlen(line) > 0) {
1735 line[strlen(line) - 1] = '\0';
1737 pstrcpy(product_name, sizeof(product_name), line);
1740 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1741 goto the_end;
1743 if (!strcmp(line, "5000\n")) {
1744 speed = USB_SPEED_SUPER;
1745 } else if (!strcmp(line, "480\n")) {
1746 speed = USB_SPEED_HIGH;
1747 } else if (!strcmp(line, "1.5\n")) {
1748 speed = USB_SPEED_LOW;
1749 } else {
1750 speed = USB_SPEED_FULL;
1753 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1754 product_id, product_name, speed);
1755 if (ret) {
1756 goto the_end;
1760 the_end:
1761 if (dir) {
1762 closedir(dir);
1764 return ret;
1768 * Determine how to access the host's USB devices and call the
1769 * specific support function.
1771 static int usb_host_scan(void *opaque, USBScanFunc *func)
1773 Monitor *mon = cur_mon;
1774 FILE *f = NULL;
1775 DIR *dir = NULL;
1776 int ret = 0;
1777 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1778 char devpath[PATH_MAX];
1780 /* only check the host once */
1781 if (!usb_fs_type) {
1782 dir = opendir(USBSYSBUS_PATH "/devices");
1783 if (dir) {
1784 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1785 strcpy(devpath, USBDEVBUS_PATH);
1786 usb_fs_type = USB_FS_SYS;
1787 closedir(dir);
1788 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1789 goto found_devices;
1791 f = fopen(USBPROCBUS_PATH "/devices", "r");
1792 if (f) {
1793 /* devices found in /proc/bus/usb/ */
1794 strcpy(devpath, USBPROCBUS_PATH);
1795 usb_fs_type = USB_FS_PROC;
1796 fclose(f);
1797 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1798 goto found_devices;
1800 /* try additional methods if an access method hasn't been found yet */
1801 f = fopen(USBDEVBUS_PATH "/devices", "r");
1802 if (f) {
1803 /* devices found in /dev/bus/usb/ */
1804 strcpy(devpath, USBDEVBUS_PATH);
1805 usb_fs_type = USB_FS_DEV;
1806 fclose(f);
1807 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1808 goto found_devices;
1810 found_devices:
1811 if (!usb_fs_type) {
1812 if (mon) {
1813 monitor_printf(mon, "husb: unable to access USB devices\n");
1815 return -ENOENT;
1818 /* the module setting (used later for opening devices) */
1819 usb_host_device_path = g_malloc0(strlen(devpath)+1);
1820 strcpy(usb_host_device_path, devpath);
1821 if (mon) {
1822 monitor_printf(mon, "husb: using %s file-system with %s\n",
1823 fs_type[usb_fs_type], usb_host_device_path);
1827 switch (usb_fs_type) {
1828 case USB_FS_PROC:
1829 case USB_FS_DEV:
1830 ret = usb_host_scan_dev(opaque, func);
1831 break;
1832 case USB_FS_SYS:
1833 ret = usb_host_scan_sys(opaque, func);
1834 break;
1835 default:
1836 ret = -EINVAL;
1837 break;
1839 return ret;
1842 static QEMUTimer *usb_auto_timer;
1844 static int usb_host_auto_scan(void *opaque, int bus_num,
1845 int addr, const char *port,
1846 int class_id, int vendor_id, int product_id,
1847 const char *product_name, int speed)
1849 struct USBAutoFilter *f;
1850 struct USBHostDevice *s;
1852 /* Ignore hubs */
1853 if (class_id == 9)
1854 return 0;
1856 QTAILQ_FOREACH(s, &hostdevs, next) {
1857 f = &s->match;
1859 if (f->bus_num > 0 && f->bus_num != bus_num) {
1860 continue;
1862 if (f->addr > 0 && f->addr != addr) {
1863 continue;
1865 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1866 continue;
1869 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1870 continue;
1873 if (f->product_id > 0 && f->product_id != product_id) {
1874 continue;
1876 /* We got a match */
1877 s->seen++;
1878 if (s->errcount >= 3) {
1879 return 0;
1882 /* Already attached ? */
1883 if (s->fd != -1) {
1884 return 0;
1886 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1888 if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1889 s->errcount++;
1891 break;
1894 return 0;
1897 static void usb_host_auto_check(void *unused)
1899 struct USBHostDevice *s;
1900 int unconnected = 0;
1902 usb_host_scan(NULL, usb_host_auto_scan);
1904 QTAILQ_FOREACH(s, &hostdevs, next) {
1905 if (s->fd == -1) {
1906 unconnected++;
1908 if (s->seen == 0) {
1909 s->errcount = 0;
1911 s->seen = 0;
1914 if (unconnected == 0) {
1915 /* nothing to watch */
1916 if (usb_auto_timer) {
1917 qemu_del_timer(usb_auto_timer);
1918 trace_usb_host_auto_scan_disabled();
1920 return;
1923 if (!usb_auto_timer) {
1924 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1925 if (!usb_auto_timer) {
1926 return;
1928 trace_usb_host_auto_scan_enabled();
1930 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1934 * Autoconnect filter
1935 * Format:
1936 * auto:bus:dev[:vid:pid]
1937 * auto:bus.dev[:vid:pid]
1939 * bus - bus number (dec, * means any)
1940 * dev - device number (dec, * means any)
1941 * vid - vendor id (hex, * means any)
1942 * pid - product id (hex, * means any)
1944 * See 'lsusb' output.
1946 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1948 enum { BUS, DEV, VID, PID, DONE };
1949 const char *p = spec;
1950 int i;
1952 f->bus_num = 0;
1953 f->addr = 0;
1954 f->vendor_id = 0;
1955 f->product_id = 0;
1957 for (i = BUS; i < DONE; i++) {
1958 p = strpbrk(p, ":.");
1959 if (!p) {
1960 break;
1962 p++;
1964 if (*p == '*') {
1965 continue;
1967 switch(i) {
1968 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1969 case DEV: f->addr = strtol(p, NULL, 10); break;
1970 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1971 case PID: f->product_id = strtol(p, NULL, 16); break;
1975 if (i < DEV) {
1976 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1977 return -1;
1980 return 0;
1983 /**********************/
1984 /* USB host device info */
1986 struct usb_class_info {
1987 int class;
1988 const char *class_name;
1991 static const struct usb_class_info usb_class_info[] = {
1992 { USB_CLASS_AUDIO, "Audio"},
1993 { USB_CLASS_COMM, "Communication"},
1994 { USB_CLASS_HID, "HID"},
1995 { USB_CLASS_HUB, "Hub" },
1996 { USB_CLASS_PHYSICAL, "Physical" },
1997 { USB_CLASS_PRINTER, "Printer" },
1998 { USB_CLASS_MASS_STORAGE, "Storage" },
1999 { USB_CLASS_CDC_DATA, "Data" },
2000 { USB_CLASS_APP_SPEC, "Application Specific" },
2001 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
2002 { USB_CLASS_STILL_IMAGE, "Still Image" },
2003 { USB_CLASS_CSCID, "Smart Card" },
2004 { USB_CLASS_CONTENT_SEC, "Content Security" },
2005 { -1, NULL }
2008 static const char *usb_class_str(uint8_t class)
2010 const struct usb_class_info *p;
2011 for(p = usb_class_info; p->class != -1; p++) {
2012 if (p->class == class) {
2013 break;
2016 return p->class_name;
2019 static void usb_info_device(Monitor *mon, int bus_num,
2020 int addr, const char *port,
2021 int class_id, int vendor_id, int product_id,
2022 const char *product_name,
2023 int speed)
2025 const char *class_str, *speed_str;
2027 switch(speed) {
2028 case USB_SPEED_LOW:
2029 speed_str = "1.5";
2030 break;
2031 case USB_SPEED_FULL:
2032 speed_str = "12";
2033 break;
2034 case USB_SPEED_HIGH:
2035 speed_str = "480";
2036 break;
2037 case USB_SPEED_SUPER:
2038 speed_str = "5000";
2039 break;
2040 default:
2041 speed_str = "?";
2042 break;
2045 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
2046 bus_num, addr, port, speed_str);
2047 class_str = usb_class_str(class_id);
2048 if (class_str) {
2049 monitor_printf(mon, " %s:", class_str);
2050 } else {
2051 monitor_printf(mon, " Class %02x:", class_id);
2053 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
2054 if (product_name[0] != '\0') {
2055 monitor_printf(mon, ", %s", product_name);
2057 monitor_printf(mon, "\n");
2060 static int usb_host_info_device(void *opaque, int bus_num, int addr,
2061 const char *path, int class_id,
2062 int vendor_id, int product_id,
2063 const char *product_name,
2064 int speed)
2066 Monitor *mon = opaque;
2068 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
2069 product_name, speed);
2070 return 0;
2073 static void dec2str(int val, char *str, size_t size)
2075 if (val == 0) {
2076 snprintf(str, size, "*");
2077 } else {
2078 snprintf(str, size, "%d", val);
2082 static void hex2str(int val, char *str, size_t size)
2084 if (val == 0) {
2085 snprintf(str, size, "*");
2086 } else {
2087 snprintf(str, size, "%04x", val);
2091 void usb_host_info(Monitor *mon)
2093 struct USBAutoFilter *f;
2094 struct USBHostDevice *s;
2096 usb_host_scan(mon, usb_host_info_device);
2098 if (QTAILQ_EMPTY(&hostdevs)) {
2099 return;
2102 monitor_printf(mon, " Auto filters:\n");
2103 QTAILQ_FOREACH(s, &hostdevs, next) {
2104 char bus[10], addr[10], vid[10], pid[10];
2105 f = &s->match;
2106 dec2str(f->bus_num, bus, sizeof(bus));
2107 dec2str(f->addr, addr, sizeof(addr));
2108 hex2str(f->vendor_id, vid, sizeof(vid));
2109 hex2str(f->product_id, pid, sizeof(pid));
2110 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
2111 bus, addr, f->port ? f->port : "*", vid, pid);