strongarm ioctl rename fallout
[qemu/aliguori.git] / usb-linux.c
blob5562187bd50a6e65e34df1c8aa3a1711be75c315
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"
38 #include <dirent.h>
39 #include <sys/ioctl.h>
41 #include <linux/usbdevice_fs.h>
42 #include <linux/version.h>
43 #include "hw/usb.h"
45 /* We redefine it to avoid version problems */
46 struct usb_ctrltransfer {
47 uint8_t bRequestType;
48 uint8_t bRequest;
49 uint16_t wValue;
50 uint16_t wIndex;
51 uint16_t wLength;
52 uint32_t timeout;
53 void *data;
56 typedef int USBScanFunc(void *opaque, int bus_num, int addr, char *port,
57 int class_id, int vendor_id, int product_id,
58 const char *product_name, int speed);
60 //#define DEBUG
62 #ifdef DEBUG
63 #define DPRINTF printf
64 #else
65 #define DPRINTF(...)
66 #endif
68 #define USBDBG_DEVOPENED "husb: opened %s/devices\n"
70 #define USBPROCBUS_PATH "/proc/bus/usb"
71 #define PRODUCT_NAME_SZ 32
72 #define MAX_ENDPOINTS 15
73 #define MAX_PORTLEN 16
74 #define USBDEVBUS_PATH "/dev/bus/usb"
75 #define USBSYSBUS_PATH "/sys/bus/usb"
77 static char *usb_host_device_path;
79 #define USB_FS_NONE 0
80 #define USB_FS_PROC 1
81 #define USB_FS_DEV 2
82 #define USB_FS_SYS 3
84 static int usb_fs_type;
86 /* endpoint association data */
87 #define ISO_FRAME_DESC_PER_URB 32
88 #define INVALID_EP_TYPE 255
90 /* devio.c limits single requests to 16k */
91 #define MAX_USBFS_BUFFER_SIZE 16384
93 typedef struct AsyncURB AsyncURB;
95 struct endp_data {
96 uint8_t type;
97 uint8_t halted;
98 uint8_t iso_started;
99 AsyncURB *iso_urb;
100 int iso_urb_idx;
101 int iso_buffer_used;
102 int max_packet_size;
103 int inflight;
106 struct USBAutoFilter {
107 uint32_t bus_num;
108 uint32_t addr;
109 char *port;
110 uint32_t vendor_id;
111 uint32_t product_id;
114 typedef struct USBHostDevice {
115 USBDevice dev;
116 int fd;
118 uint8_t descr[8192];
119 int descr_len;
120 int configuration;
121 int ninterfaces;
122 int closing;
123 uint32_t iso_urb_count;
124 Notifier exit;
126 struct endp_data endp_table[MAX_ENDPOINTS];
127 QLIST_HEAD(, AsyncURB) aurbs;
129 /* Host side address */
130 int bus_num;
131 int addr;
132 char port[MAX_PORTLEN];
133 struct USBAutoFilter match;
135 QTAILQ_ENTRY(USBHostDevice) next;
136 } USBHostDevice;
138 static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
140 static int usb_host_close(USBHostDevice *dev);
141 static int parse_filter(const char *spec, struct USBAutoFilter *f);
142 static void usb_host_auto_check(void *unused);
143 static int usb_host_read_file(char *line, size_t line_size,
144 const char *device_file, const char *device_name);
146 static struct endp_data *get_endp(USBHostDevice *s, int ep)
148 return s->endp_table + ep - 1;
151 static int is_isoc(USBHostDevice *s, int ep)
153 return get_endp(s, ep)->type == USBDEVFS_URB_TYPE_ISO;
156 static int is_valid(USBHostDevice *s, int ep)
158 return get_endp(s, ep)->type != INVALID_EP_TYPE;
161 static int is_halted(USBHostDevice *s, int ep)
163 return get_endp(s, ep)->halted;
166 static void clear_halt(USBHostDevice *s, int ep)
168 get_endp(s, ep)->halted = 0;
171 static void set_halt(USBHostDevice *s, int ep)
173 get_endp(s, ep)->halted = 1;
176 static int is_iso_started(USBHostDevice *s, int ep)
178 return get_endp(s, ep)->iso_started;
181 static void clear_iso_started(USBHostDevice *s, int ep)
183 get_endp(s, ep)->iso_started = 0;
186 static void set_iso_started(USBHostDevice *s, int ep)
188 struct endp_data *e = get_endp(s, ep);
189 if (!e->iso_started) {
190 e->iso_started = 1;
191 e->inflight = 0;
195 static int change_iso_inflight(USBHostDevice *s, int ep, int value)
197 struct endp_data *e = get_endp(s, ep);
199 e->inflight += value;
200 return e->inflight;
203 static void set_iso_urb(USBHostDevice *s, int ep, AsyncURB *iso_urb)
205 get_endp(s, ep)->iso_urb = iso_urb;
208 static AsyncURB *get_iso_urb(USBHostDevice *s, int ep)
210 return get_endp(s, ep)->iso_urb;
213 static void set_iso_urb_idx(USBHostDevice *s, int ep, int i)
215 get_endp(s, ep)->iso_urb_idx = i;
218 static int get_iso_urb_idx(USBHostDevice *s, int ep)
220 return get_endp(s, ep)->iso_urb_idx;
223 static void set_iso_buffer_used(USBHostDevice *s, int ep, int i)
225 get_endp(s, ep)->iso_buffer_used = i;
228 static int get_iso_buffer_used(USBHostDevice *s, int ep)
230 return get_endp(s, ep)->iso_buffer_used;
233 static void set_max_packet_size(USBHostDevice *s, int ep, uint8_t *descriptor)
235 int raw = descriptor[4] + (descriptor[5] << 8);
236 int size, microframes;
238 size = raw & 0x7ff;
239 switch ((raw >> 11) & 3) {
240 case 1: microframes = 2; break;
241 case 2: microframes = 3; break;
242 default: microframes = 1; break;
244 get_endp(s, ep)->max_packet_size = size * microframes;
247 static int get_max_packet_size(USBHostDevice *s, int ep)
249 return get_endp(s, ep)->max_packet_size;
253 * Async URB state.
254 * We always allocate iso packet descriptors even for bulk transfers
255 * to simplify allocation and casts.
257 struct AsyncURB
259 struct usbdevfs_urb urb;
260 struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB];
261 USBHostDevice *hdev;
262 QLIST_ENTRY(AsyncURB) next;
264 /* For regular async urbs */
265 USBPacket *packet;
266 int more; /* large transfer, more urbs follow */
268 /* For buffered iso handling */
269 int iso_frame_idx; /* -1 means in flight */
272 static AsyncURB *async_alloc(USBHostDevice *s)
274 AsyncURB *aurb = qemu_mallocz(sizeof(AsyncURB));
275 aurb->hdev = s;
276 QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
277 return aurb;
280 static void async_free(AsyncURB *aurb)
282 QLIST_REMOVE(aurb, next);
283 qemu_free(aurb);
286 static void do_disconnect(USBHostDevice *s)
288 printf("husb: device %d.%d disconnected\n",
289 s->bus_num, s->addr);
290 usb_host_close(s);
291 usb_host_auto_check(NULL);
294 static void async_complete(void *opaque)
296 USBHostDevice *s = opaque;
297 AsyncURB *aurb;
298 int urbs = 0;
300 while (1) {
301 USBPacket *p;
303 int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
304 if (r < 0) {
305 if (errno == EAGAIN) {
306 if (urbs > 2) {
307 fprintf(stderr, "husb: %d iso urbs finished at once\n", urbs);
309 return;
311 if (errno == ENODEV && !s->closing) {
312 do_disconnect(s);
313 return;
316 DPRINTF("husb: async. reap urb failed errno %d\n", errno);
317 return;
320 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
321 aurb, aurb->urb.status, aurb->urb.actual_length);
323 /* If this is a buffered iso urb mark it as complete and don't do
324 anything else (it is handled further in usb_host_handle_iso_data) */
325 if (aurb->iso_frame_idx == -1) {
326 int inflight;
327 if (aurb->urb.status == -EPIPE) {
328 set_halt(s, aurb->urb.endpoint & 0xf);
330 aurb->iso_frame_idx = 0;
331 urbs++;
332 inflight = change_iso_inflight(s, aurb->urb.endpoint & 0xf, -1);
333 if (inflight == 0 && is_iso_started(s, aurb->urb.endpoint & 0xf)) {
334 fprintf(stderr, "husb: out of buffers for iso stream\n");
336 continue;
339 p = aurb->packet;
341 if (p) {
342 switch (aurb->urb.status) {
343 case 0:
344 p->result += aurb->urb.actual_length;
345 break;
347 case -EPIPE:
348 set_halt(s, p->devep);
349 p->result = USB_RET_STALL;
350 break;
352 default:
353 p->result = USB_RET_NAK;
354 break;
357 if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
358 usb_generic_async_ctrl_complete(&s->dev, p);
359 } else if (!aurb->more) {
360 usb_packet_complete(&s->dev, p);
364 async_free(aurb);
368 static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
370 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
371 AsyncURB *aurb;
373 QLIST_FOREACH(aurb, &s->aurbs, next) {
374 if (p != aurb->packet) {
375 continue;
378 DPRINTF("husb: async cancel: packet %p, aurb %p\n", p, aurb);
380 /* Mark it as dead (see async_complete above) */
381 aurb->packet = NULL;
383 int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
384 if (r < 0) {
385 DPRINTF("husb: async. discard urb failed errno %d\n", errno);
390 static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
392 const char *op = NULL;
393 int dev_descr_len, config_descr_len;
394 int interface, nb_interfaces;
395 int ret, i;
397 if (configuration == 0) /* address state - ignore */
398 return 1;
400 DPRINTF("husb: claiming interfaces. config %d\n", configuration);
402 i = 0;
403 dev_descr_len = dev->descr[0];
404 if (dev_descr_len > dev->descr_len) {
405 fprintf(stderr, "husb: update iface failed. descr too short\n");
406 return 0;
409 i += dev_descr_len;
410 while (i < dev->descr_len) {
411 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
412 i, dev->descr_len,
413 dev->descr[i], dev->descr[i+1]);
415 if (dev->descr[i+1] != USB_DT_CONFIG) {
416 i += dev->descr[i];
417 continue;
419 config_descr_len = dev->descr[i];
421 printf("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
423 if (configuration < 0 || configuration == dev->descr[i + 5]) {
424 configuration = dev->descr[i + 5];
425 break;
428 i += config_descr_len;
431 if (i >= dev->descr_len) {
432 fprintf(stderr,
433 "husb: update iface failed. no matching configuration\n");
434 return 0;
436 nb_interfaces = dev->descr[i + 4];
438 #ifdef USBDEVFS_DISCONNECT
439 /* earlier Linux 2.4 do not support that */
441 struct usbdevfs_ioctl ctrl;
442 for (interface = 0; interface < nb_interfaces; interface++) {
443 ctrl.ioctl_code = USBDEVFS_DISCONNECT;
444 ctrl.ifno = interface;
445 ctrl.data = 0;
446 op = "USBDEVFS_DISCONNECT";
447 ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
448 if (ret < 0 && errno != ENODATA) {
449 goto fail;
453 #endif
455 /* XXX: only grab if all interfaces are free */
456 for (interface = 0; interface < nb_interfaces; interface++) {
457 op = "USBDEVFS_CLAIMINTERFACE";
458 ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
459 if (ret < 0) {
460 if (errno == EBUSY) {
461 printf("husb: update iface. device already grabbed\n");
462 } else {
463 perror("husb: failed to claim interface");
465 goto fail;
469 printf("husb: %d interfaces claimed for configuration %d\n",
470 nb_interfaces, configuration);
472 dev->ninterfaces = nb_interfaces;
473 dev->configuration = configuration;
474 return 1;
476 fail:
477 if (errno == ENODEV) {
478 do_disconnect(dev);
480 perror(op);
481 return 0;
484 static int usb_host_release_interfaces(USBHostDevice *s)
486 int ret, i;
488 DPRINTF("husb: releasing interfaces\n");
490 for (i = 0; i < s->ninterfaces; i++) {
491 ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
492 if (ret < 0) {
493 perror("husb: failed to release interface");
494 return 0;
498 return 1;
501 static void usb_host_handle_reset(USBDevice *dev)
503 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
505 DPRINTF("husb: reset device %u.%u\n", s->bus_num, s->addr);
507 ioctl(s->fd, USBDEVFS_RESET);
509 usb_host_claim_interfaces(s, s->configuration);
512 static void usb_host_handle_destroy(USBDevice *dev)
514 USBHostDevice *s = (USBHostDevice *)dev;
516 usb_host_close(s);
517 QTAILQ_REMOVE(&hostdevs, s, next);
518 qemu_remove_exit_notifier(&s->exit);
521 static int usb_linux_update_endp_table(USBHostDevice *s);
523 /* iso data is special, we need to keep enough urbs in flight to make sure
524 that the controller never runs out of them, otherwise the device will
525 likely suffer a buffer underrun / overrun. */
526 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, uint8_t ep, int in)
528 AsyncURB *aurb;
529 int i, j, len = get_max_packet_size(s, ep);
531 aurb = qemu_mallocz(s->iso_urb_count * sizeof(*aurb));
532 for (i = 0; i < s->iso_urb_count; i++) {
533 aurb[i].urb.endpoint = ep;
534 aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
535 aurb[i].urb.buffer = qemu_malloc(aurb[i].urb.buffer_length);
536 aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO;
537 aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP;
538 aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
539 for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
540 aurb[i].urb.iso_frame_desc[j].length = len;
541 if (in) {
542 aurb[i].urb.endpoint |= 0x80;
543 /* Mark as fully consumed (idle) */
544 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
547 set_iso_urb(s, ep, aurb);
549 return aurb;
552 static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep)
554 AsyncURB *aurb;
555 int i, ret, killed = 0, free = 1;
557 aurb = get_iso_urb(s, ep);
558 if (!aurb) {
559 return;
562 for (i = 0; i < s->iso_urb_count; i++) {
563 /* in flight? */
564 if (aurb[i].iso_frame_idx == -1) {
565 ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
566 if (ret < 0) {
567 printf("husb: discard isoc in urb failed errno %d\n", errno);
568 free = 0;
569 continue;
571 killed++;
575 /* Make sure any urbs we've killed are reaped before we free them */
576 if (killed) {
577 async_complete(s);
580 for (i = 0; i < s->iso_urb_count; i++) {
581 qemu_free(aurb[i].urb.buffer);
584 if (free)
585 qemu_free(aurb);
586 else
587 printf("husb: leaking iso urbs because of discard failure\n");
588 set_iso_urb(s, ep, NULL);
589 set_iso_urb_idx(s, ep, 0);
590 clear_iso_started(s, ep);
593 static int urb_status_to_usb_ret(int status)
595 switch (status) {
596 case -EPIPE:
597 return USB_RET_STALL;
598 default:
599 return USB_RET_NAK;
603 static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
605 AsyncURB *aurb;
606 int i, j, ret, max_packet_size, offset, len = 0;
607 uint8_t *buf;
609 max_packet_size = get_max_packet_size(s, p->devep);
610 if (max_packet_size == 0)
611 return USB_RET_NAK;
613 aurb = get_iso_urb(s, p->devep);
614 if (!aurb) {
615 aurb = usb_host_alloc_iso(s, p->devep, in);
618 i = get_iso_urb_idx(s, p->devep);
619 j = aurb[i].iso_frame_idx;
620 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
621 if (in) {
622 /* Check urb status */
623 if (aurb[i].urb.status) {
624 len = urb_status_to_usb_ret(aurb[i].urb.status);
625 /* Move to the next urb */
626 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
627 /* Check frame status */
628 } else if (aurb[i].urb.iso_frame_desc[j].status) {
629 len = urb_status_to_usb_ret(
630 aurb[i].urb.iso_frame_desc[j].status);
631 /* Check the frame fits */
632 } else if (aurb[i].urb.iso_frame_desc[j].actual_length
633 > p->iov.size) {
634 printf("husb: received iso data is larger then packet\n");
635 len = USB_RET_NAK;
636 /* All good copy data over */
637 } else {
638 len = aurb[i].urb.iso_frame_desc[j].actual_length;
639 buf = aurb[i].urb.buffer +
640 j * aurb[i].urb.iso_frame_desc[0].length;
641 usb_packet_copy(p, buf, len);
643 } else {
644 len = p->iov.size;
645 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->devep);
647 /* Check the frame fits */
648 if (len > max_packet_size) {
649 printf("husb: send iso data is larger then max packet size\n");
650 return USB_RET_NAK;
653 /* All good copy data over */
654 usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
655 aurb[i].urb.iso_frame_desc[j].length = len;
656 offset += len;
657 set_iso_buffer_used(s, p->devep, offset);
659 /* Start the stream once we have buffered enough data */
660 if (!is_iso_started(s, p->devep) && i == 1 && j == 8) {
661 set_iso_started(s, p->devep);
664 aurb[i].iso_frame_idx++;
665 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
666 i = (i + 1) % s->iso_urb_count;
667 set_iso_urb_idx(s, p->devep, i);
669 } else {
670 if (in) {
671 set_iso_started(s, p->devep);
672 } else {
673 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
677 if (is_iso_started(s, p->devep)) {
678 /* (Re)-submit all fully consumed / filled urbs */
679 for (i = 0; i < s->iso_urb_count; i++) {
680 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
681 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
682 if (ret < 0) {
683 printf("husb error submitting iso urb %d: %d\n", i, errno);
684 if (!in || len == 0) {
685 switch(errno) {
686 case ETIMEDOUT:
687 len = USB_RET_NAK;
688 break;
689 case EPIPE:
690 default:
691 len = USB_RET_STALL;
694 break;
696 aurb[i].iso_frame_idx = -1;
697 change_iso_inflight(s, p->devep, +1);
702 return len;
705 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
707 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
708 struct usbdevfs_urb *urb;
709 AsyncURB *aurb;
710 int ret, rem, prem, v;
711 uint8_t *pbuf;
712 uint8_t ep;
714 if (!is_valid(s, p->devep)) {
715 return USB_RET_NAK;
718 if (p->pid == USB_TOKEN_IN) {
719 ep = p->devep | 0x80;
720 } else {
721 ep = p->devep;
724 if (is_halted(s, p->devep)) {
725 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &ep);
726 if (ret < 0) {
727 DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",
728 ep, errno);
729 return USB_RET_NAK;
731 clear_halt(s, p->devep);
734 if (is_isoc(s, p->devep)) {
735 return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
738 v = 0;
739 prem = p->iov.iov[v].iov_len;
740 pbuf = p->iov.iov[v].iov_base;
741 rem = p->iov.size;
742 while (rem) {
743 if (prem == 0) {
744 v++;
745 assert(v < p->iov.niov);
746 prem = p->iov.iov[v].iov_len;
747 pbuf = p->iov.iov[v].iov_base;
748 assert(prem <= rem);
750 aurb = async_alloc(s);
751 aurb->packet = p;
753 urb = &aurb->urb;
754 urb->endpoint = ep;
755 urb->type = USBDEVFS_URB_TYPE_BULK;
756 urb->usercontext = s;
757 urb->buffer = pbuf;
758 urb->buffer_length = prem;
760 if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
761 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
763 pbuf += urb->buffer_length;
764 prem -= urb->buffer_length;
765 rem -= urb->buffer_length;
766 if (rem) {
767 aurb->more = 1;
770 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
772 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
773 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
775 if (ret < 0) {
776 DPRINTF("husb: submit failed. errno %d\n", errno);
777 async_free(aurb);
779 switch(errno) {
780 case ETIMEDOUT:
781 return USB_RET_NAK;
782 case EPIPE:
783 default:
784 return USB_RET_STALL;
789 return USB_RET_ASYNC;
792 static int ctrl_error(void)
794 if (errno == ETIMEDOUT) {
795 return USB_RET_NAK;
796 } else {
797 return USB_RET_STALL;
801 static int usb_host_set_address(USBHostDevice *s, int addr)
803 DPRINTF("husb: ctrl set addr %u\n", addr);
804 s->dev.addr = addr;
805 return 0;
808 static int usb_host_set_config(USBHostDevice *s, int config)
810 usb_host_release_interfaces(s);
812 int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
814 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
816 if (ret < 0) {
817 return ctrl_error();
819 usb_host_claim_interfaces(s, config);
820 return 0;
823 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
825 struct usbdevfs_setinterface si;
826 int i, ret;
828 for (i = 1; i <= MAX_ENDPOINTS; i++) {
829 if (is_isoc(s, i)) {
830 usb_host_stop_n_free_iso(s, i);
834 si.interface = iface;
835 si.altsetting = alt;
836 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
838 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
839 iface, alt, ret, errno);
841 if (ret < 0) {
842 return ctrl_error();
844 usb_linux_update_endp_table(s);
845 return 0;
848 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
849 int request, int value, int index, int length, uint8_t *data)
851 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
852 struct usbdevfs_urb *urb;
853 AsyncURB *aurb;
854 int ret;
857 * Process certain standard device requests.
858 * These are infrequent and are processed synchronously.
861 /* Note request is (bRequestType << 8) | bRequest */
862 DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",
863 request >> 8, request & 0xff, value, index, length);
865 switch (request) {
866 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
867 return usb_host_set_address(s, value);
869 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
870 return usb_host_set_config(s, value & 0xff);
872 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
873 return usb_host_set_interface(s, index, value);
876 /* The rest are asynchronous */
878 if (length > sizeof(dev->data_buf)) {
879 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
880 length, sizeof(dev->data_buf));
881 return USB_RET_STALL;
884 aurb = async_alloc(s);
885 aurb->packet = p;
888 * Setup ctrl transfer.
890 * s->ctrl is laid out such that data buffer immediately follows
891 * 'req' struct which is exactly what usbdevfs expects.
893 urb = &aurb->urb;
895 urb->type = USBDEVFS_URB_TYPE_CONTROL;
896 urb->endpoint = p->devep;
898 urb->buffer = &dev->setup_buf;
899 urb->buffer_length = length + 8;
901 urb->usercontext = s;
903 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
905 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
907 if (ret < 0) {
908 DPRINTF("husb: submit failed. errno %d\n", errno);
909 async_free(aurb);
911 switch(errno) {
912 case ETIMEDOUT:
913 return USB_RET_NAK;
914 case EPIPE:
915 default:
916 return USB_RET_STALL;
920 return USB_RET_ASYNC;
923 static int usb_linux_get_configuration(USBHostDevice *s)
925 uint8_t configuration;
926 struct usb_ctrltransfer ct;
927 int ret;
929 if (usb_fs_type == USB_FS_SYS) {
930 char device_name[32], line[1024];
931 int configuration;
933 sprintf(device_name, "%d-%s", s->bus_num, s->port);
935 if (!usb_host_read_file(line, sizeof(line), "bConfigurationValue",
936 device_name)) {
937 goto usbdevfs;
939 if (sscanf(line, "%d", &configuration) != 1) {
940 goto usbdevfs;
942 return configuration;
945 usbdevfs:
946 ct.bRequestType = USB_DIR_IN;
947 ct.bRequest = USB_REQ_GET_CONFIGURATION;
948 ct.wValue = 0;
949 ct.wIndex = 0;
950 ct.wLength = 1;
951 ct.data = &configuration;
952 ct.timeout = 50;
954 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
955 if (ret < 0) {
956 perror("usb_linux_get_configuration");
957 return -1;
960 /* in address state */
961 if (configuration == 0) {
962 return -1;
965 return configuration;
968 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
969 uint8_t configuration, uint8_t interface)
971 uint8_t alt_setting;
972 struct usb_ctrltransfer ct;
973 int ret;
975 if (usb_fs_type == USB_FS_SYS) {
976 char device_name[64], line[1024];
977 int alt_setting;
979 sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
980 (int)configuration, (int)interface);
982 if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
983 device_name)) {
984 goto usbdevfs;
986 if (sscanf(line, "%d", &alt_setting) != 1) {
987 goto usbdevfs;
989 return alt_setting;
992 usbdevfs:
993 ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
994 ct.bRequest = USB_REQ_GET_INTERFACE;
995 ct.wValue = 0;
996 ct.wIndex = interface;
997 ct.wLength = 1;
998 ct.data = &alt_setting;
999 ct.timeout = 50;
1000 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
1001 if (ret < 0) {
1002 /* Assume alt 0 on error */
1003 return 0;
1006 return alt_setting;
1009 /* returns 1 on problem encountered or 0 for success */
1010 static int usb_linux_update_endp_table(USBHostDevice *s)
1012 uint8_t *descriptors;
1013 uint8_t devep, type, configuration, alt_interface;
1014 int interface, length, i;
1016 for (i = 0; i < MAX_ENDPOINTS; i++)
1017 s->endp_table[i].type = INVALID_EP_TYPE;
1019 i = usb_linux_get_configuration(s);
1020 if (i < 0)
1021 return 1;
1022 configuration = i;
1024 /* get the desired configuration, interface, and endpoint descriptors
1025 * from device description */
1026 descriptors = &s->descr[18];
1027 length = s->descr_len - 18;
1028 i = 0;
1030 if (descriptors[i + 1] != USB_DT_CONFIG ||
1031 descriptors[i + 5] != configuration) {
1032 DPRINTF("invalid descriptor data - configuration\n");
1033 return 1;
1035 i += descriptors[i];
1037 while (i < length) {
1038 if (descriptors[i + 1] != USB_DT_INTERFACE ||
1039 (descriptors[i + 1] == USB_DT_INTERFACE &&
1040 descriptors[i + 4] == 0)) {
1041 i += descriptors[i];
1042 continue;
1045 interface = descriptors[i + 2];
1046 alt_interface = usb_linux_get_alt_setting(s, configuration, interface);
1048 /* the current interface descriptor is the active interface
1049 * and has endpoints */
1050 if (descriptors[i + 3] != alt_interface) {
1051 i += descriptors[i];
1052 continue;
1055 /* advance to the endpoints */
1056 while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1057 i += descriptors[i];
1060 if (i >= length)
1061 break;
1063 while (i < length) {
1064 if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1065 break;
1068 devep = descriptors[i + 2];
1069 if ((devep & 0x0f) == 0) {
1070 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1071 return 1;
1074 switch (descriptors[i + 3] & 0x3) {
1075 case 0x00:
1076 type = USBDEVFS_URB_TYPE_CONTROL;
1077 break;
1078 case 0x01:
1079 type = USBDEVFS_URB_TYPE_ISO;
1080 set_max_packet_size(s, (devep & 0xf), descriptors + i);
1081 break;
1082 case 0x02:
1083 type = USBDEVFS_URB_TYPE_BULK;
1084 break;
1085 case 0x03:
1086 type = USBDEVFS_URB_TYPE_INTERRUPT;
1087 break;
1088 default:
1089 DPRINTF("usb_host: malformed endpoint type\n");
1090 type = USBDEVFS_URB_TYPE_BULK;
1092 s->endp_table[(devep & 0xf) - 1].type = type;
1093 s->endp_table[(devep & 0xf) - 1].halted = 0;
1095 i += descriptors[i];
1098 return 0;
1102 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1103 * this function assumes this is safe, if:
1104 * 1) There are no isoc endpoints
1105 * 2) There are no interrupt endpoints with a max_packet_size > 64
1106 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1107 * usb1 compatible, but in practice this seems to work fine.
1109 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1111 int i, packet_size;
1114 * usb_linux_update_endp_table only registers info about ep in the current
1115 * interface altsettings, so we need to parse the descriptors again.
1117 for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1118 if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1119 switch (dev->descr[i + 3] & 0x3) {
1120 case 0x00: /* CONTROL */
1121 break;
1122 case 0x01: /* ISO */
1123 return 0;
1124 case 0x02: /* BULK */
1125 break;
1126 case 0x03: /* INTERRUPT */
1127 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1128 if (packet_size > 64)
1129 return 0;
1130 break;
1134 return 1;
1137 static int usb_host_open(USBHostDevice *dev, int bus_num,
1138 int addr, char *port, const char *prod_name, int speed)
1140 int fd = -1, ret;
1141 char buf[1024];
1143 if (dev->fd != -1) {
1144 goto fail;
1146 printf("husb: open device %d.%d\n", bus_num, addr);
1148 if (!usb_host_device_path) {
1149 perror("husb: USB Host Device Path not set");
1150 goto fail;
1152 snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1153 bus_num, addr);
1154 fd = open(buf, O_RDWR | O_NONBLOCK);
1155 if (fd < 0) {
1156 perror(buf);
1157 goto fail;
1159 DPRINTF("husb: opened %s\n", buf);
1161 dev->bus_num = bus_num;
1162 dev->addr = addr;
1163 strcpy(dev->port, port);
1164 dev->fd = fd;
1166 /* read the device description */
1167 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1168 if (dev->descr_len <= 0) {
1169 perror("husb: reading device data failed");
1170 goto fail;
1173 #ifdef DEBUG
1175 int x;
1176 printf("=== begin dumping device descriptor data ===\n");
1177 for (x = 0; x < dev->descr_len; x++) {
1178 printf("%02x ", dev->descr[x]);
1180 printf("\n=== end dumping device descriptor data ===\n");
1182 #endif
1186 * Initial configuration is -1 which makes us claim first
1187 * available config. We used to start with 1, which does not
1188 * always work. I've seen devices where first config starts
1189 * with 2.
1191 if (!usb_host_claim_interfaces(dev, -1)) {
1192 goto fail;
1195 ret = usb_linux_update_endp_table(dev);
1196 if (ret) {
1197 goto fail;
1200 if (speed == -1) {
1201 struct usbdevfs_connectinfo ci;
1203 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1204 if (ret < 0) {
1205 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1206 goto fail;
1209 if (ci.slow) {
1210 speed = USB_SPEED_LOW;
1211 } else {
1212 speed = USB_SPEED_HIGH;
1215 dev->dev.speed = speed;
1216 dev->dev.speedmask = (1 << speed);
1217 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1218 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1221 printf("husb: grabbed usb device %d.%d\n", bus_num, addr);
1223 if (!prod_name || prod_name[0] == '\0') {
1224 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1225 "host:%d.%d", bus_num, addr);
1226 } else {
1227 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1228 prod_name);
1231 ret = usb_device_attach(&dev->dev);
1232 if (ret) {
1233 goto fail;
1236 /* USB devio uses 'write' flag to check for async completions */
1237 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1239 return 0;
1241 fail:
1242 if (dev->fd != -1) {
1243 close(dev->fd);
1244 dev->fd = -1;
1246 return -1;
1249 static int usb_host_close(USBHostDevice *dev)
1251 int i;
1253 if (dev->fd == -1 || !dev->dev.attached) {
1254 return -1;
1257 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1258 dev->closing = 1;
1259 for (i = 1; i <= MAX_ENDPOINTS; i++) {
1260 if (is_isoc(dev, i)) {
1261 usb_host_stop_n_free_iso(dev, i);
1264 async_complete(dev);
1265 dev->closing = 0;
1266 usb_device_detach(&dev->dev);
1267 ioctl(dev->fd, USBDEVFS_RESET);
1268 close(dev->fd);
1269 dev->fd = -1;
1270 return 0;
1273 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1275 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1277 if (s->fd != -1) {
1278 ioctl(s->fd, USBDEVFS_RESET);
1282 static int usb_host_initfn(USBDevice *dev)
1284 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1286 dev->auto_attach = 0;
1287 s->fd = -1;
1288 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1289 s->exit.notify = usb_host_exit_notifier;
1290 qemu_add_exit_notifier(&s->exit);
1291 usb_host_auto_check(NULL);
1292 return 0;
1295 static struct USBDeviceInfo usb_host_dev_info = {
1296 .product_desc = "USB Host Device",
1297 .qdev.name = "usb-host",
1298 .qdev.size = sizeof(USBHostDevice),
1299 .init = usb_host_initfn,
1300 .handle_packet = usb_generic_handle_packet,
1301 .cancel_packet = usb_host_async_cancel,
1302 .handle_data = usb_host_handle_data,
1303 .handle_control = usb_host_handle_control,
1304 .handle_reset = usb_host_handle_reset,
1305 .handle_destroy = usb_host_handle_destroy,
1306 .usbdevice_name = "host",
1307 .usbdevice_init = usb_host_device_open,
1308 .qdev.props = (Property[]) {
1309 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1310 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1311 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1312 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1313 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1314 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1315 DEFINE_PROP_END_OF_LIST(),
1319 static void usb_host_register_devices(void)
1321 usb_qdev_register(&usb_host_dev_info);
1323 device_init(usb_host_register_devices)
1325 USBDevice *usb_host_device_open(const char *devname)
1327 struct USBAutoFilter filter;
1328 USBDevice *dev;
1329 char *p;
1331 dev = usb_create(NULL /* FIXME */, "usb-host");
1333 if (strstr(devname, "auto:")) {
1334 if (parse_filter(devname, &filter) < 0) {
1335 goto fail;
1337 } else {
1338 if ((p = strchr(devname, '.'))) {
1339 filter.bus_num = strtoul(devname, NULL, 0);
1340 filter.addr = strtoul(p + 1, NULL, 0);
1341 filter.vendor_id = 0;
1342 filter.product_id = 0;
1343 } else if ((p = strchr(devname, ':'))) {
1344 filter.bus_num = 0;
1345 filter.addr = 0;
1346 filter.vendor_id = strtoul(devname, NULL, 16);
1347 filter.product_id = strtoul(p + 1, NULL, 16);
1348 } else {
1349 goto fail;
1353 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1354 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1355 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1356 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1357 qdev_init_nofail(&dev->qdev);
1358 return dev;
1360 fail:
1361 qdev_free(&dev->qdev);
1362 return NULL;
1365 int usb_host_device_close(const char *devname)
1367 #if 0
1368 char product_name[PRODUCT_NAME_SZ];
1369 int bus_num, addr;
1370 USBHostDevice *s;
1372 if (strstr(devname, "auto:")) {
1373 return usb_host_auto_del(devname);
1375 if (usb_host_find_device(&bus_num, &addr, product_name,
1376 sizeof(product_name), devname) < 0) {
1377 return -1;
1379 s = hostdev_find(bus_num, addr);
1380 if (s) {
1381 usb_device_delete_addr(s->bus_num, s->dev.addr);
1382 return 0;
1384 #endif
1386 return -1;
1389 static int get_tag_value(char *buf, int buf_size,
1390 const char *str, const char *tag,
1391 const char *stopchars)
1393 const char *p;
1394 char *q;
1395 p = strstr(str, tag);
1396 if (!p) {
1397 return -1;
1399 p += strlen(tag);
1400 while (qemu_isspace(*p)) {
1401 p++;
1403 q = buf;
1404 while (*p != '\0' && !strchr(stopchars, *p)) {
1405 if ((q - buf) < (buf_size - 1)) {
1406 *q++ = *p;
1408 p++;
1410 *q = '\0';
1411 return q - buf;
1415 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1416 * host's USB devices. This is legacy support since many distributions
1417 * are moving to /sys/bus/usb
1419 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1421 FILE *f = NULL;
1422 char line[1024];
1423 char buf[1024];
1424 int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
1425 char product_name[512];
1426 int ret = 0;
1428 if (!usb_host_device_path) {
1429 perror("husb: USB Host Device Path not set");
1430 goto the_end;
1432 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1433 f = fopen(line, "r");
1434 if (!f) {
1435 perror("husb: cannot open devices file");
1436 goto the_end;
1439 device_count = 0;
1440 bus_num = addr = class_id = product_id = vendor_id = 0;
1441 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1442 for(;;) {
1443 if (fgets(line, sizeof(line), f) == NULL) {
1444 break;
1446 if (strlen(line) > 0) {
1447 line[strlen(line) - 1] = '\0';
1449 if (line[0] == 'T' && line[1] == ':') {
1450 if (device_count && (vendor_id || product_id)) {
1451 /* New device. Add the previously discovered device. */
1452 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1453 product_id, product_name, speed);
1454 if (ret) {
1455 goto the_end;
1458 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1459 goto fail;
1461 bus_num = atoi(buf);
1462 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1463 goto fail;
1465 addr = atoi(buf);
1466 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1467 goto fail;
1469 if (!strcmp(buf, "5000")) {
1470 speed = USB_SPEED_SUPER;
1471 } else if (!strcmp(buf, "480")) {
1472 speed = USB_SPEED_HIGH;
1473 } else if (!strcmp(buf, "1.5")) {
1474 speed = USB_SPEED_LOW;
1475 } else {
1476 speed = USB_SPEED_FULL;
1478 product_name[0] = '\0';
1479 class_id = 0xff;
1480 device_count++;
1481 product_id = 0;
1482 vendor_id = 0;
1483 } else if (line[0] == 'P' && line[1] == ':') {
1484 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1485 goto fail;
1487 vendor_id = strtoul(buf, NULL, 16);
1488 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1489 goto fail;
1491 product_id = strtoul(buf, NULL, 16);
1492 } else if (line[0] == 'S' && line[1] == ':') {
1493 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1494 goto fail;
1496 pstrcpy(product_name, sizeof(product_name), buf);
1497 } else if (line[0] == 'D' && line[1] == ':') {
1498 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1499 goto fail;
1501 class_id = strtoul(buf, NULL, 16);
1503 fail: ;
1505 if (device_count && (vendor_id || product_id)) {
1506 /* Add the last device. */
1507 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1508 product_id, product_name, speed);
1510 the_end:
1511 if (f) {
1512 fclose(f);
1514 return ret;
1518 * Read sys file-system device file
1520 * @line address of buffer to put file contents in
1521 * @line_size size of line
1522 * @device_file path to device file (printf format string)
1523 * @device_name device being opened (inserted into device_file)
1525 * @return 0 failed, 1 succeeded ('line' contains data)
1527 static int usb_host_read_file(char *line, size_t line_size,
1528 const char *device_file, const char *device_name)
1530 FILE *f;
1531 int ret = 0;
1532 char filename[PATH_MAX];
1534 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1535 device_file);
1536 f = fopen(filename, "r");
1537 if (f) {
1538 ret = fgets(line, line_size, f) != NULL;
1539 fclose(f);
1542 return ret;
1546 * Use /sys/bus/usb/devices/ directory to determine host's USB
1547 * devices.
1549 * This code is based on Robert Schiele's original patches posted to
1550 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1552 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1554 DIR *dir = NULL;
1555 char line[1024];
1556 int bus_num, addr, speed, class_id, product_id, vendor_id;
1557 int ret = 0;
1558 char port[MAX_PORTLEN];
1559 char product_name[512];
1560 struct dirent *de;
1562 dir = opendir(USBSYSBUS_PATH "/devices");
1563 if (!dir) {
1564 perror("husb: cannot open devices directory");
1565 goto the_end;
1568 while ((de = readdir(dir))) {
1569 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1570 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1571 continue;
1574 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1575 goto the_end;
1577 if (sscanf(line, "%d", &addr) != 1) {
1578 goto the_end;
1580 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1581 de->d_name)) {
1582 goto the_end;
1584 if (sscanf(line, "%x", &class_id) != 1) {
1585 goto the_end;
1588 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1589 de->d_name)) {
1590 goto the_end;
1592 if (sscanf(line, "%x", &vendor_id) != 1) {
1593 goto the_end;
1595 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1596 de->d_name)) {
1597 goto the_end;
1599 if (sscanf(line, "%x", &product_id) != 1) {
1600 goto the_end;
1602 if (!usb_host_read_file(line, sizeof(line), "product",
1603 de->d_name)) {
1604 *product_name = 0;
1605 } else {
1606 if (strlen(line) > 0) {
1607 line[strlen(line) - 1] = '\0';
1609 pstrcpy(product_name, sizeof(product_name), line);
1612 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1613 goto the_end;
1615 if (!strcmp(line, "5000\n")) {
1616 speed = USB_SPEED_SUPER;
1617 } else if (!strcmp(line, "480\n")) {
1618 speed = USB_SPEED_HIGH;
1619 } else if (!strcmp(line, "1.5\n")) {
1620 speed = USB_SPEED_LOW;
1621 } else {
1622 speed = USB_SPEED_FULL;
1625 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1626 product_id, product_name, speed);
1627 if (ret) {
1628 goto the_end;
1632 the_end:
1633 if (dir) {
1634 closedir(dir);
1636 return ret;
1640 * Determine how to access the host's USB devices and call the
1641 * specific support function.
1643 static int usb_host_scan(void *opaque, USBScanFunc *func)
1645 Monitor *mon = cur_mon;
1646 FILE *f = NULL;
1647 DIR *dir = NULL;
1648 int ret = 0;
1649 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1650 char devpath[PATH_MAX];
1652 /* only check the host once */
1653 if (!usb_fs_type) {
1654 dir = opendir(USBSYSBUS_PATH "/devices");
1655 if (dir) {
1656 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1657 strcpy(devpath, USBDEVBUS_PATH);
1658 usb_fs_type = USB_FS_SYS;
1659 closedir(dir);
1660 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1661 goto found_devices;
1663 f = fopen(USBPROCBUS_PATH "/devices", "r");
1664 if (f) {
1665 /* devices found in /proc/bus/usb/ */
1666 strcpy(devpath, USBPROCBUS_PATH);
1667 usb_fs_type = USB_FS_PROC;
1668 fclose(f);
1669 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1670 goto found_devices;
1672 /* try additional methods if an access method hasn't been found yet */
1673 f = fopen(USBDEVBUS_PATH "/devices", "r");
1674 if (f) {
1675 /* devices found in /dev/bus/usb/ */
1676 strcpy(devpath, USBDEVBUS_PATH);
1677 usb_fs_type = USB_FS_DEV;
1678 fclose(f);
1679 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1680 goto found_devices;
1682 found_devices:
1683 if (!usb_fs_type) {
1684 if (mon) {
1685 monitor_printf(mon, "husb: unable to access USB devices\n");
1687 return -ENOENT;
1690 /* the module setting (used later for opening devices) */
1691 usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
1692 strcpy(usb_host_device_path, devpath);
1693 if (mon) {
1694 monitor_printf(mon, "husb: using %s file-system with %s\n",
1695 fs_type[usb_fs_type], usb_host_device_path);
1699 switch (usb_fs_type) {
1700 case USB_FS_PROC:
1701 case USB_FS_DEV:
1702 ret = usb_host_scan_dev(opaque, func);
1703 break;
1704 case USB_FS_SYS:
1705 ret = usb_host_scan_sys(opaque, func);
1706 break;
1707 default:
1708 ret = -EINVAL;
1709 break;
1711 return ret;
1714 static QEMUTimer *usb_auto_timer;
1716 static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
1717 int class_id, int vendor_id, int product_id,
1718 const char *product_name, int speed)
1720 struct USBAutoFilter *f;
1721 struct USBHostDevice *s;
1723 /* Ignore hubs */
1724 if (class_id == 9)
1725 return 0;
1727 QTAILQ_FOREACH(s, &hostdevs, next) {
1728 f = &s->match;
1730 if (f->bus_num > 0 && f->bus_num != bus_num) {
1731 continue;
1733 if (f->addr > 0 && f->addr != addr) {
1734 continue;
1736 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1737 continue;
1740 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1741 continue;
1744 if (f->product_id > 0 && f->product_id != product_id) {
1745 continue;
1747 /* We got a match */
1749 /* Already attached ? */
1750 if (s->fd != -1) {
1751 return 0;
1753 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1755 usb_host_open(s, bus_num, addr, port, product_name, speed);
1756 break;
1759 return 0;
1762 static void usb_host_auto_check(void *unused)
1764 struct USBHostDevice *s;
1765 int unconnected = 0;
1767 usb_host_scan(NULL, usb_host_auto_scan);
1769 QTAILQ_FOREACH(s, &hostdevs, next) {
1770 if (s->fd == -1) {
1771 unconnected++;
1775 if (unconnected == 0) {
1776 /* nothing to watch */
1777 if (usb_auto_timer) {
1778 qemu_del_timer(usb_auto_timer);
1780 return;
1783 if (!usb_auto_timer) {
1784 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1785 if (!usb_auto_timer) {
1786 return;
1789 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1793 * Autoconnect filter
1794 * Format:
1795 * auto:bus:dev[:vid:pid]
1796 * auto:bus.dev[:vid:pid]
1798 * bus - bus number (dec, * means any)
1799 * dev - device number (dec, * means any)
1800 * vid - vendor id (hex, * means any)
1801 * pid - product id (hex, * means any)
1803 * See 'lsusb' output.
1805 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1807 enum { BUS, DEV, VID, PID, DONE };
1808 const char *p = spec;
1809 int i;
1811 f->bus_num = 0;
1812 f->addr = 0;
1813 f->vendor_id = 0;
1814 f->product_id = 0;
1816 for (i = BUS; i < DONE; i++) {
1817 p = strpbrk(p, ":.");
1818 if (!p) {
1819 break;
1821 p++;
1823 if (*p == '*') {
1824 continue;
1826 switch(i) {
1827 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1828 case DEV: f->addr = strtol(p, NULL, 10); break;
1829 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1830 case PID: f->product_id = strtol(p, NULL, 16); break;
1834 if (i < DEV) {
1835 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1836 return -1;
1839 return 0;
1842 /**********************/
1843 /* USB host device info */
1845 struct usb_class_info {
1846 int class;
1847 const char *class_name;
1850 static const struct usb_class_info usb_class_info[] = {
1851 { USB_CLASS_AUDIO, "Audio"},
1852 { USB_CLASS_COMM, "Communication"},
1853 { USB_CLASS_HID, "HID"},
1854 { USB_CLASS_HUB, "Hub" },
1855 { USB_CLASS_PHYSICAL, "Physical" },
1856 { USB_CLASS_PRINTER, "Printer" },
1857 { USB_CLASS_MASS_STORAGE, "Storage" },
1858 { USB_CLASS_CDC_DATA, "Data" },
1859 { USB_CLASS_APP_SPEC, "Application Specific" },
1860 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1861 { USB_CLASS_STILL_IMAGE, "Still Image" },
1862 { USB_CLASS_CSCID, "Smart Card" },
1863 { USB_CLASS_CONTENT_SEC, "Content Security" },
1864 { -1, NULL }
1867 static const char *usb_class_str(uint8_t class)
1869 const struct usb_class_info *p;
1870 for(p = usb_class_info; p->class != -1; p++) {
1871 if (p->class == class) {
1872 break;
1875 return p->class_name;
1878 static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
1879 int class_id, int vendor_id, int product_id,
1880 const char *product_name,
1881 int speed)
1883 const char *class_str, *speed_str;
1885 switch(speed) {
1886 case USB_SPEED_LOW:
1887 speed_str = "1.5";
1888 break;
1889 case USB_SPEED_FULL:
1890 speed_str = "12";
1891 break;
1892 case USB_SPEED_HIGH:
1893 speed_str = "480";
1894 break;
1895 case USB_SPEED_SUPER:
1896 speed_str = "5000";
1897 break;
1898 default:
1899 speed_str = "?";
1900 break;
1903 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1904 bus_num, addr, port, speed_str);
1905 class_str = usb_class_str(class_id);
1906 if (class_str) {
1907 monitor_printf(mon, " %s:", class_str);
1908 } else {
1909 monitor_printf(mon, " Class %02x:", class_id);
1911 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1912 if (product_name[0] != '\0') {
1913 monitor_printf(mon, ", %s", product_name);
1915 monitor_printf(mon, "\n");
1918 static int usb_host_info_device(void *opaque, int bus_num, int addr,
1919 char *path, int class_id,
1920 int vendor_id, int product_id,
1921 const char *product_name,
1922 int speed)
1924 Monitor *mon = opaque;
1926 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1927 product_name, speed);
1928 return 0;
1931 static void dec2str(int val, char *str, size_t size)
1933 if (val == 0) {
1934 snprintf(str, size, "*");
1935 } else {
1936 snprintf(str, size, "%d", val);
1940 static void hex2str(int val, char *str, size_t size)
1942 if (val == 0) {
1943 snprintf(str, size, "*");
1944 } else {
1945 snprintf(str, size, "%04x", val);
1949 void usb_host_info(Monitor *mon)
1951 struct USBAutoFilter *f;
1952 struct USBHostDevice *s;
1954 usb_host_scan(mon, usb_host_info_device);
1956 if (QTAILQ_EMPTY(&hostdevs)) {
1957 return;
1960 monitor_printf(mon, " Auto filters:\n");
1961 QTAILQ_FOREACH(s, &hostdevs, next) {
1962 char bus[10], addr[10], vid[10], pid[10];
1963 f = &s->match;
1964 dec2str(f->bus_num, bus, sizeof(bus));
1965 dec2str(f->addr, addr, sizeof(addr));
1966 hex2str(f->vendor_id, vid, sizeof(vid));
1967 hex2str(f->product_id, pid, sizeof(pid));
1968 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
1969 bus, addr, f->port ? f->port : "*", vid, pid);