qapi: dealloc visitor, support freeing of nested lists
[qemu.git] / usb-linux.c
blob2075c4c67a7823a9afdf8610c99f19f0e049b1ee
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_interfaces(USBHostDevice *dev, int configuration)
416 const char *op = NULL;
417 int dev_descr_len, config_descr_len;
418 int interface, nb_interfaces;
419 int ret, i;
421 if (configuration == 0) { /* address state - ignore */
422 dev->ninterfaces = 0;
423 dev->configuration = 0;
424 return 1;
427 DPRINTF("husb: claiming interfaces. config %d\n", configuration);
429 i = 0;
430 dev_descr_len = dev->descr[0];
431 if (dev_descr_len > dev->descr_len) {
432 fprintf(stderr, "husb: update iface failed. descr too short\n");
433 return 0;
436 i += dev_descr_len;
437 while (i < dev->descr_len) {
438 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
439 i, dev->descr_len,
440 dev->descr[i], dev->descr[i+1]);
442 if (dev->descr[i+1] != USB_DT_CONFIG) {
443 i += dev->descr[i];
444 continue;
446 config_descr_len = dev->descr[i];
448 DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
450 if (configuration == dev->descr[i + 5]) {
451 configuration = dev->descr[i + 5];
452 break;
455 i += config_descr_len;
458 if (i >= dev->descr_len) {
459 fprintf(stderr,
460 "husb: update iface failed. no matching configuration\n");
461 return 0;
463 nb_interfaces = dev->descr[i + 4];
465 #ifdef USBDEVFS_DISCONNECT
466 /* earlier Linux 2.4 do not support that */
468 struct usbdevfs_ioctl ctrl;
469 for (interface = 0; interface < nb_interfaces; interface++) {
470 ctrl.ioctl_code = USBDEVFS_DISCONNECT;
471 ctrl.ifno = interface;
472 ctrl.data = 0;
473 op = "USBDEVFS_DISCONNECT";
474 ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
475 if (ret < 0 && errno != ENODATA) {
476 goto fail;
480 #endif
482 /* XXX: only grab if all interfaces are free */
483 for (interface = 0; interface < nb_interfaces; interface++) {
484 op = "USBDEVFS_CLAIMINTERFACE";
485 ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
486 if (ret < 0) {
487 goto fail;
491 trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
492 nb_interfaces, configuration);
494 dev->ninterfaces = nb_interfaces;
495 dev->configuration = configuration;
496 return 1;
498 fail:
499 if (errno == ENODEV) {
500 do_disconnect(dev);
502 perror(op);
503 return 0;
506 static int usb_host_release_interfaces(USBHostDevice *s)
508 int ret, i;
510 trace_usb_host_release_interfaces(s->bus_num, s->addr);
512 for (i = 0; i < s->ninterfaces; i++) {
513 ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
514 if (ret < 0) {
515 perror("USBDEVFS_RELEASEINTERFACE");
516 return 0;
519 return 1;
522 static void usb_host_handle_reset(USBDevice *dev)
524 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
526 trace_usb_host_reset(s->bus_num, s->addr);
528 ioctl(s->fd, USBDEVFS_RESET);
530 usb_host_claim_interfaces(s, 0);
531 usb_linux_update_endp_table(s);
534 static void usb_host_handle_destroy(USBDevice *dev)
536 USBHostDevice *s = (USBHostDevice *)dev;
538 usb_host_close(s);
539 if (s->hub_fd != -1) {
540 close(s->hub_fd);
542 QTAILQ_REMOVE(&hostdevs, s, next);
543 qemu_remove_exit_notifier(&s->exit);
546 /* iso data is special, we need to keep enough urbs in flight to make sure
547 that the controller never runs out of them, otherwise the device will
548 likely suffer a buffer underrun / overrun. */
549 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
551 AsyncURB *aurb;
552 int i, j, len = get_max_packet_size(s, pid, ep);
554 aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
555 for (i = 0; i < s->iso_urb_count; i++) {
556 aurb[i].urb.endpoint = ep;
557 aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
558 aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length);
559 aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO;
560 aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP;
561 aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
562 for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
563 aurb[i].urb.iso_frame_desc[j].length = len;
564 if (pid == USB_TOKEN_IN) {
565 aurb[i].urb.endpoint |= 0x80;
566 /* Mark as fully consumed (idle) */
567 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
570 set_iso_urb(s, pid, ep, aurb);
572 return aurb;
575 static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
577 AsyncURB *aurb;
578 int i, ret, killed = 0, free = 1;
580 aurb = get_iso_urb(s, pid, ep);
581 if (!aurb) {
582 return;
585 for (i = 0; i < s->iso_urb_count; i++) {
586 /* in flight? */
587 if (aurb[i].iso_frame_idx == -1) {
588 ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
589 if (ret < 0) {
590 perror("USBDEVFS_DISCARDURB");
591 free = 0;
592 continue;
594 killed++;
598 /* Make sure any urbs we've killed are reaped before we free them */
599 if (killed) {
600 async_complete(s);
603 for (i = 0; i < s->iso_urb_count; i++) {
604 g_free(aurb[i].urb.buffer);
607 if (free)
608 g_free(aurb);
609 else
610 printf("husb: leaking iso urbs because of discard failure\n");
611 set_iso_urb(s, pid, ep, NULL);
612 set_iso_urb_idx(s, pid, ep, 0);
613 clear_iso_started(s, pid, ep);
616 static int urb_status_to_usb_ret(int status)
618 switch (status) {
619 case -EPIPE:
620 return USB_RET_STALL;
621 default:
622 return USB_RET_NAK;
626 static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
628 AsyncURB *aurb;
629 int i, j, ret, max_packet_size, offset, len = 0;
630 uint8_t *buf;
632 max_packet_size = get_max_packet_size(s, p->pid, p->devep);
633 if (max_packet_size == 0)
634 return USB_RET_NAK;
636 aurb = get_iso_urb(s, p->pid, p->devep);
637 if (!aurb) {
638 aurb = usb_host_alloc_iso(s, p->pid, p->devep);
641 i = get_iso_urb_idx(s, p->pid, p->devep);
642 j = aurb[i].iso_frame_idx;
643 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
644 if (in) {
645 /* Check urb status */
646 if (aurb[i].urb.status) {
647 len = urb_status_to_usb_ret(aurb[i].urb.status);
648 /* Move to the next urb */
649 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
650 /* Check frame status */
651 } else if (aurb[i].urb.iso_frame_desc[j].status) {
652 len = urb_status_to_usb_ret(
653 aurb[i].urb.iso_frame_desc[j].status);
654 /* Check the frame fits */
655 } else if (aurb[i].urb.iso_frame_desc[j].actual_length
656 > p->iov.size) {
657 printf("husb: received iso data is larger then packet\n");
658 len = USB_RET_NAK;
659 /* All good copy data over */
660 } else {
661 len = aurb[i].urb.iso_frame_desc[j].actual_length;
662 buf = aurb[i].urb.buffer +
663 j * aurb[i].urb.iso_frame_desc[0].length;
664 usb_packet_copy(p, buf, len);
666 } else {
667 len = p->iov.size;
668 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
670 /* Check the frame fits */
671 if (len > max_packet_size) {
672 printf("husb: send iso data is larger then max packet size\n");
673 return USB_RET_NAK;
676 /* All good copy data over */
677 usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
678 aurb[i].urb.iso_frame_desc[j].length = len;
679 offset += len;
680 set_iso_buffer_used(s, p->pid, p->devep, offset);
682 /* Start the stream once we have buffered enough data */
683 if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
684 set_iso_started(s, p->pid, p->devep);
687 aurb[i].iso_frame_idx++;
688 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
689 i = (i + 1) % s->iso_urb_count;
690 set_iso_urb_idx(s, p->pid, p->devep, i);
692 } else {
693 if (in) {
694 set_iso_started(s, p->pid, p->devep);
695 } else {
696 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
700 if (is_iso_started(s, p->pid, p->devep)) {
701 /* (Re)-submit all fully consumed / filled urbs */
702 for (i = 0; i < s->iso_urb_count; i++) {
703 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
704 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
705 if (ret < 0) {
706 perror("USBDEVFS_SUBMITURB");
707 if (!in || len == 0) {
708 switch(errno) {
709 case ETIMEDOUT:
710 len = USB_RET_NAK;
711 break;
712 case EPIPE:
713 default:
714 len = USB_RET_STALL;
717 break;
719 aurb[i].iso_frame_idx = -1;
720 change_iso_inflight(s, p->pid, p->devep, 1);
725 return len;
728 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
730 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
731 struct usbdevfs_urb *urb;
732 AsyncURB *aurb;
733 int ret, rem, prem, v;
734 uint8_t *pbuf;
735 uint8_t ep;
737 trace_usb_host_req_data(s->bus_num, s->addr,
738 p->pid == USB_TOKEN_IN,
739 p->devep, p->iov.size);
741 if (!is_valid(s, p->pid, p->devep)) {
742 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
743 return USB_RET_NAK;
746 if (p->pid == USB_TOKEN_IN) {
747 ep = p->devep | 0x80;
748 } else {
749 ep = p->devep;
752 if (is_halted(s, p->pid, p->devep)) {
753 unsigned int arg = ep;
754 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
755 if (ret < 0) {
756 perror("USBDEVFS_CLEAR_HALT");
757 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
758 return USB_RET_NAK;
760 clear_halt(s, p->pid, p->devep);
763 if (is_isoc(s, p->pid, p->devep)) {
764 return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
767 v = 0;
768 prem = p->iov.iov[v].iov_len;
769 pbuf = p->iov.iov[v].iov_base;
770 rem = p->iov.size;
771 while (rem) {
772 if (prem == 0) {
773 v++;
774 assert(v < p->iov.niov);
775 prem = p->iov.iov[v].iov_len;
776 pbuf = p->iov.iov[v].iov_base;
777 assert(prem <= rem);
779 aurb = async_alloc(s);
780 aurb->packet = p;
782 urb = &aurb->urb;
783 urb->endpoint = ep;
784 urb->type = USBDEVFS_URB_TYPE_BULK;
785 urb->usercontext = s;
786 urb->buffer = pbuf;
787 urb->buffer_length = prem;
789 if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
790 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
792 pbuf += urb->buffer_length;
793 prem -= urb->buffer_length;
794 rem -= urb->buffer_length;
795 if (rem) {
796 aurb->more = 1;
799 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
800 urb->buffer_length, aurb->more);
801 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
803 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
804 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
806 if (ret < 0) {
807 perror("USBDEVFS_SUBMITURB");
808 async_free(aurb);
810 switch(errno) {
811 case ETIMEDOUT:
812 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
813 return USB_RET_NAK;
814 case EPIPE:
815 default:
816 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL);
817 return USB_RET_STALL;
822 return USB_RET_ASYNC;
825 static int ctrl_error(void)
827 if (errno == ETIMEDOUT) {
828 return USB_RET_NAK;
829 } else {
830 return USB_RET_STALL;
834 static int usb_host_set_address(USBHostDevice *s, int addr)
836 trace_usb_host_set_address(s->bus_num, s->addr, addr);
837 s->dev.addr = addr;
838 return 0;
841 static int usb_host_set_config(USBHostDevice *s, int config)
843 trace_usb_host_set_config(s->bus_num, s->addr, config);
845 usb_host_release_interfaces(s);
847 int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
849 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
851 if (ret < 0) {
852 return ctrl_error();
854 usb_host_claim_interfaces(s, config);
855 usb_linux_update_endp_table(s);
856 return 0;
859 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
861 struct usbdevfs_setinterface si;
862 int i, ret;
864 trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
866 for (i = 1; i <= MAX_ENDPOINTS; i++) {
867 if (is_isoc(s, USB_TOKEN_IN, i)) {
868 usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i);
870 if (is_isoc(s, USB_TOKEN_OUT, i)) {
871 usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i);
875 si.interface = iface;
876 si.altsetting = alt;
877 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
879 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
880 iface, alt, ret, errno);
882 if (ret < 0) {
883 return ctrl_error();
885 usb_linux_update_endp_table(s);
886 return 0;
889 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
890 int request, int value, int index, int length, uint8_t *data)
892 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
893 struct usbdevfs_urb *urb;
894 AsyncURB *aurb;
895 int ret;
898 * Process certain standard device requests.
899 * These are infrequent and are processed synchronously.
902 /* Note request is (bRequestType << 8) | bRequest */
903 trace_usb_host_req_control(s->bus_num, s->addr, request, value, index);
905 switch (request) {
906 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
907 return usb_host_set_address(s, value);
909 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
910 return usb_host_set_config(s, value & 0xff);
912 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
913 return usb_host_set_interface(s, index, value);
916 /* The rest are asynchronous */
918 if (length > sizeof(dev->data_buf)) {
919 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
920 length, sizeof(dev->data_buf));
921 return USB_RET_STALL;
924 aurb = async_alloc(s);
925 aurb->packet = p;
928 * Setup ctrl transfer.
930 * s->ctrl is laid out such that data buffer immediately follows
931 * 'req' struct which is exactly what usbdevfs expects.
933 urb = &aurb->urb;
935 urb->type = USBDEVFS_URB_TYPE_CONTROL;
936 urb->endpoint = p->devep;
938 urb->buffer = &dev->setup_buf;
939 urb->buffer_length = length + 8;
941 urb->usercontext = s;
943 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
944 urb->buffer_length, aurb->more);
945 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
947 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
949 if (ret < 0) {
950 DPRINTF("husb: submit failed. errno %d\n", errno);
951 async_free(aurb);
953 switch(errno) {
954 case ETIMEDOUT:
955 return USB_RET_NAK;
956 case EPIPE:
957 default:
958 return USB_RET_STALL;
962 return USB_RET_ASYNC;
965 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
966 uint8_t configuration, uint8_t interface)
968 uint8_t alt_setting;
969 struct usb_ctrltransfer ct;
970 int ret;
972 if (usb_fs_type == USB_FS_SYS) {
973 char device_name[64], line[1024];
974 int alt_setting;
976 sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
977 (int)configuration, (int)interface);
979 if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
980 device_name)) {
981 goto usbdevfs;
983 if (sscanf(line, "%d", &alt_setting) != 1) {
984 goto usbdevfs;
986 return alt_setting;
989 usbdevfs:
990 ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
991 ct.bRequest = USB_REQ_GET_INTERFACE;
992 ct.wValue = 0;
993 ct.wIndex = interface;
994 ct.wLength = 1;
995 ct.data = &alt_setting;
996 ct.timeout = 50;
997 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
998 if (ret < 0) {
999 /* Assume alt 0 on error */
1000 return 0;
1003 return alt_setting;
1006 /* returns 1 on problem encountered or 0 for success */
1007 static int usb_linux_update_endp_table(USBHostDevice *s)
1009 uint8_t *descriptors;
1010 uint8_t devep, type, alt_interface;
1011 int interface, length, i, ep, pid;
1012 struct endp_data *epd;
1014 for (i = 0; i < MAX_ENDPOINTS; i++) {
1015 s->ep_in[i].type = INVALID_EP_TYPE;
1016 s->ep_out[i].type = INVALID_EP_TYPE;
1019 if (s->configuration == 0) {
1020 /* not configured yet -- leave all endpoints disabled */
1021 return 0;
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] != s->configuration) {
1032 fprintf(stderr, "invalid descriptor data - configuration %d\n",
1033 s->configuration);
1034 return 1;
1036 i += descriptors[i];
1038 while (i < length) {
1039 if (descriptors[i + 1] != USB_DT_INTERFACE ||
1040 (descriptors[i + 1] == USB_DT_INTERFACE &&
1041 descriptors[i + 4] == 0)) {
1042 i += descriptors[i];
1043 continue;
1046 interface = descriptors[i + 2];
1047 alt_interface = usb_linux_get_alt_setting(s, s->configuration,
1048 interface);
1050 /* the current interface descriptor is the active interface
1051 * and has endpoints */
1052 if (descriptors[i + 3] != alt_interface) {
1053 i += descriptors[i];
1054 continue;
1057 /* advance to the endpoints */
1058 while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1059 i += descriptors[i];
1062 if (i >= length)
1063 break;
1065 while (i < length) {
1066 if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1067 break;
1070 devep = descriptors[i + 2];
1071 pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1072 ep = devep & 0xf;
1073 if (ep == 0) {
1074 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1075 return 1;
1078 switch (descriptors[i + 3] & 0x3) {
1079 case 0x00:
1080 type = USBDEVFS_URB_TYPE_CONTROL;
1081 break;
1082 case 0x01:
1083 type = USBDEVFS_URB_TYPE_ISO;
1084 set_max_packet_size(s, pid, ep, descriptors + i);
1085 break;
1086 case 0x02:
1087 type = USBDEVFS_URB_TYPE_BULK;
1088 break;
1089 case 0x03:
1090 type = USBDEVFS_URB_TYPE_INTERRUPT;
1091 break;
1092 default:
1093 DPRINTF("usb_host: malformed endpoint type\n");
1094 type = USBDEVFS_URB_TYPE_BULK;
1096 epd = get_endp(s, pid, ep);
1097 assert(epd->type == INVALID_EP_TYPE);
1098 epd->type = type;
1099 epd->halted = 0;
1101 i += descriptors[i];
1104 return 0;
1108 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1109 * this function assumes this is safe, if:
1110 * 1) There are no isoc endpoints
1111 * 2) There are no interrupt endpoints with a max_packet_size > 64
1112 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1113 * usb1 compatible, but in practice this seems to work fine.
1115 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1117 int i, packet_size;
1120 * usb_linux_update_endp_table only registers info about ep in the current
1121 * interface altsettings, so we need to parse the descriptors again.
1123 for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1124 if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1125 switch (dev->descr[i + 3] & 0x3) {
1126 case 0x00: /* CONTROL */
1127 break;
1128 case 0x01: /* ISO */
1129 return 0;
1130 case 0x02: /* BULK */
1131 break;
1132 case 0x03: /* INTERRUPT */
1133 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1134 if (packet_size > 64)
1135 return 0;
1136 break;
1140 return 1;
1143 static int usb_host_open(USBHostDevice *dev, int bus_num,
1144 int addr, const char *port,
1145 const char *prod_name, int speed)
1147 int fd = -1, ret;
1148 char buf[1024];
1150 trace_usb_host_open_started(bus_num, addr);
1152 if (dev->fd != -1) {
1153 goto fail;
1156 if (!usb_host_device_path) {
1157 perror("husb: USB Host Device Path not set");
1158 goto fail;
1160 snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1161 bus_num, addr);
1162 fd = open(buf, O_RDWR | O_NONBLOCK);
1163 if (fd < 0) {
1164 perror(buf);
1165 goto fail;
1167 DPRINTF("husb: opened %s\n", buf);
1169 dev->bus_num = bus_num;
1170 dev->addr = addr;
1171 strcpy(dev->port, port);
1172 dev->fd = fd;
1174 /* read the device description */
1175 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1176 if (dev->descr_len <= 0) {
1177 perror("husb: reading device data failed");
1178 goto fail;
1181 #ifdef DEBUG
1183 int x;
1184 printf("=== begin dumping device descriptor data ===\n");
1185 for (x = 0; x < dev->descr_len; x++) {
1186 printf("%02x ", dev->descr[x]);
1188 printf("\n=== end dumping device descriptor data ===\n");
1190 #endif
1193 /* start unconfigured -- we'll wait for the guest to set a configuration */
1194 if (!usb_host_claim_interfaces(dev, 0)) {
1195 goto fail;
1198 ret = usb_linux_update_endp_table(dev);
1199 if (ret) {
1200 goto fail;
1203 if (speed == -1) {
1204 struct usbdevfs_connectinfo ci;
1206 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1207 if (ret < 0) {
1208 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1209 goto fail;
1212 if (ci.slow) {
1213 speed = USB_SPEED_LOW;
1214 } else {
1215 speed = USB_SPEED_HIGH;
1218 dev->dev.speed = speed;
1219 dev->dev.speedmask = (1 << speed);
1220 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1221 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1224 trace_usb_host_open_success(bus_num, addr);
1226 if (!prod_name || prod_name[0] == '\0') {
1227 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1228 "host:%d.%d", bus_num, addr);
1229 } else {
1230 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1231 prod_name);
1234 ret = usb_device_attach(&dev->dev);
1235 if (ret) {
1236 goto fail;
1239 /* USB devio uses 'write' flag to check for async completions */
1240 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1242 return 0;
1244 fail:
1245 trace_usb_host_open_failure(bus_num, addr);
1246 if (dev->fd != -1) {
1247 close(dev->fd);
1248 dev->fd = -1;
1250 return -1;
1253 static int usb_host_close(USBHostDevice *dev)
1255 int i;
1257 if (dev->fd == -1 || !dev->dev.attached) {
1258 return -1;
1261 trace_usb_host_close(dev->bus_num, dev->addr);
1263 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1264 dev->closing = 1;
1265 for (i = 1; i <= MAX_ENDPOINTS; i++) {
1266 if (is_isoc(dev, USB_TOKEN_IN, i)) {
1267 usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i);
1269 if (is_isoc(dev, USB_TOKEN_OUT, i)) {
1270 usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i);
1273 async_complete(dev);
1274 dev->closing = 0;
1275 usb_device_detach(&dev->dev);
1276 ioctl(dev->fd, USBDEVFS_RESET);
1277 close(dev->fd);
1278 dev->fd = -1;
1279 return 0;
1282 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1284 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1286 if (s->fd != -1) {
1287 ioctl(s->fd, USBDEVFS_RESET);
1291 static int usb_host_initfn(USBDevice *dev)
1293 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1295 dev->auto_attach = 0;
1296 s->fd = -1;
1297 s->hub_fd = -1;
1299 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1300 s->exit.notify = usb_host_exit_notifier;
1301 qemu_add_exit_notifier(&s->exit);
1302 usb_host_auto_check(NULL);
1304 #ifdef USBDEVFS_CLAIM_PORT
1305 if (s->match.bus_num != 0 && s->match.port != NULL) {
1306 char *h, hub_name[64], line[1024];
1307 int hub_addr, portnr, ret;
1309 snprintf(hub_name, sizeof(hub_name), "%d-%s",
1310 s->match.bus_num, s->match.port);
1312 /* try strip off last ".$portnr" to get hub */
1313 h = strrchr(hub_name, '.');
1314 if (h != NULL) {
1315 portnr = atoi(h+1);
1316 *h = '\0';
1317 } else {
1318 /* no dot in there -> it is the root hub */
1319 snprintf(hub_name, sizeof(hub_name), "usb%d",
1320 s->match.bus_num);
1321 portnr = atoi(s->match.port);
1324 if (!usb_host_read_file(line, sizeof(line), "devnum",
1325 hub_name)) {
1326 goto out;
1328 if (sscanf(line, "%d", &hub_addr) != 1) {
1329 goto out;
1332 if (!usb_host_device_path) {
1333 goto out;
1335 snprintf(line, sizeof(line), "%s/%03d/%03d",
1336 usb_host_device_path, s->match.bus_num, hub_addr);
1337 s->hub_fd = open(line, O_RDWR | O_NONBLOCK);
1338 if (s->hub_fd < 0) {
1339 goto out;
1342 ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &portnr);
1343 if (ret < 0) {
1344 close(s->hub_fd);
1345 s->hub_fd = -1;
1346 goto out;
1349 trace_usb_host_claim_port(s->match.bus_num, hub_addr, portnr);
1351 out:
1352 #endif
1354 return 0;
1357 static const VMStateDescription vmstate_usb_host = {
1358 .name = "usb-host",
1359 .unmigratable = 1,
1362 static struct USBDeviceInfo usb_host_dev_info = {
1363 .product_desc = "USB Host Device",
1364 .qdev.name = "usb-host",
1365 .qdev.size = sizeof(USBHostDevice),
1366 .qdev.vmsd = &vmstate_usb_host,
1367 .init = usb_host_initfn,
1368 .handle_packet = usb_generic_handle_packet,
1369 .cancel_packet = usb_host_async_cancel,
1370 .handle_data = usb_host_handle_data,
1371 .handle_control = usb_host_handle_control,
1372 .handle_reset = usb_host_handle_reset,
1373 .handle_destroy = usb_host_handle_destroy,
1374 .usbdevice_name = "host",
1375 .usbdevice_init = usb_host_device_open,
1376 .qdev.props = (Property[]) {
1377 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1378 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1379 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1380 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1381 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1382 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1383 DEFINE_PROP_END_OF_LIST(),
1387 static void usb_host_register_devices(void)
1389 usb_qdev_register(&usb_host_dev_info);
1391 device_init(usb_host_register_devices)
1393 USBDevice *usb_host_device_open(const char *devname)
1395 struct USBAutoFilter filter;
1396 USBDevice *dev;
1397 char *p;
1399 dev = usb_create(NULL /* FIXME */, "usb-host");
1401 if (strstr(devname, "auto:")) {
1402 if (parse_filter(devname, &filter) < 0) {
1403 goto fail;
1405 } else {
1406 if ((p = strchr(devname, '.'))) {
1407 filter.bus_num = strtoul(devname, NULL, 0);
1408 filter.addr = strtoul(p + 1, NULL, 0);
1409 filter.vendor_id = 0;
1410 filter.product_id = 0;
1411 } else if ((p = strchr(devname, ':'))) {
1412 filter.bus_num = 0;
1413 filter.addr = 0;
1414 filter.vendor_id = strtoul(devname, NULL, 16);
1415 filter.product_id = strtoul(p + 1, NULL, 16);
1416 } else {
1417 goto fail;
1421 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1422 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1423 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1424 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1425 qdev_init_nofail(&dev->qdev);
1426 return dev;
1428 fail:
1429 qdev_free(&dev->qdev);
1430 return NULL;
1433 int usb_host_device_close(const char *devname)
1435 #if 0
1436 char product_name[PRODUCT_NAME_SZ];
1437 int bus_num, addr;
1438 USBHostDevice *s;
1440 if (strstr(devname, "auto:")) {
1441 return usb_host_auto_del(devname);
1443 if (usb_host_find_device(&bus_num, &addr, product_name,
1444 sizeof(product_name), devname) < 0) {
1445 return -1;
1447 s = hostdev_find(bus_num, addr);
1448 if (s) {
1449 usb_device_delete_addr(s->bus_num, s->dev.addr);
1450 return 0;
1452 #endif
1454 return -1;
1457 static int get_tag_value(char *buf, int buf_size,
1458 const char *str, const char *tag,
1459 const char *stopchars)
1461 const char *p;
1462 char *q;
1463 p = strstr(str, tag);
1464 if (!p) {
1465 return -1;
1467 p += strlen(tag);
1468 while (qemu_isspace(*p)) {
1469 p++;
1471 q = buf;
1472 while (*p != '\0' && !strchr(stopchars, *p)) {
1473 if ((q - buf) < (buf_size - 1)) {
1474 *q++ = *p;
1476 p++;
1478 *q = '\0';
1479 return q - buf;
1483 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1484 * host's USB devices. This is legacy support since many distributions
1485 * are moving to /sys/bus/usb
1487 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1489 FILE *f = NULL;
1490 char line[1024];
1491 char buf[1024];
1492 int bus_num, addr, speed, device_count;
1493 int class_id, product_id, vendor_id, port;
1494 char product_name[512];
1495 int ret = 0;
1497 if (!usb_host_device_path) {
1498 perror("husb: USB Host Device Path not set");
1499 goto the_end;
1501 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1502 f = fopen(line, "r");
1503 if (!f) {
1504 perror("husb: cannot open devices file");
1505 goto the_end;
1508 device_count = 0;
1509 bus_num = addr = class_id = product_id = vendor_id = port = 0;
1510 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1511 for(;;) {
1512 if (fgets(line, sizeof(line), f) == NULL) {
1513 break;
1515 if (strlen(line) > 0) {
1516 line[strlen(line) - 1] = '\0';
1518 if (line[0] == 'T' && line[1] == ':') {
1519 if (device_count && (vendor_id || product_id)) {
1520 /* New device. Add the previously discovered device. */
1521 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1522 product_id, product_name, speed);
1523 if (ret) {
1524 goto the_end;
1527 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1528 goto fail;
1530 bus_num = atoi(buf);
1531 if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) {
1532 goto fail;
1534 port = atoi(buf);
1535 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1536 goto fail;
1538 addr = atoi(buf);
1539 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1540 goto fail;
1542 if (!strcmp(buf, "5000")) {
1543 speed = USB_SPEED_SUPER;
1544 } else if (!strcmp(buf, "480")) {
1545 speed = USB_SPEED_HIGH;
1546 } else if (!strcmp(buf, "1.5")) {
1547 speed = USB_SPEED_LOW;
1548 } else {
1549 speed = USB_SPEED_FULL;
1551 product_name[0] = '\0';
1552 class_id = 0xff;
1553 device_count++;
1554 product_id = 0;
1555 vendor_id = 0;
1556 } else if (line[0] == 'P' && line[1] == ':') {
1557 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1558 goto fail;
1560 vendor_id = strtoul(buf, NULL, 16);
1561 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1562 goto fail;
1564 product_id = strtoul(buf, NULL, 16);
1565 } else if (line[0] == 'S' && line[1] == ':') {
1566 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1567 goto fail;
1569 pstrcpy(product_name, sizeof(product_name), buf);
1570 } else if (line[0] == 'D' && line[1] == ':') {
1571 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1572 goto fail;
1574 class_id = strtoul(buf, NULL, 16);
1576 fail: ;
1578 if (device_count && (vendor_id || product_id)) {
1579 /* Add the last device. */
1580 if (port > 0) {
1581 snprintf(buf, sizeof(buf), "%d", port);
1582 } else {
1583 snprintf(buf, sizeof(buf), "?");
1585 ret = func(opaque, bus_num, addr, buf, class_id, vendor_id,
1586 product_id, product_name, speed);
1588 the_end:
1589 if (f) {
1590 fclose(f);
1592 return ret;
1596 * Read sys file-system device file
1598 * @line address of buffer to put file contents in
1599 * @line_size size of line
1600 * @device_file path to device file (printf format string)
1601 * @device_name device being opened (inserted into device_file)
1603 * @return 0 failed, 1 succeeded ('line' contains data)
1605 static int usb_host_read_file(char *line, size_t line_size,
1606 const char *device_file, const char *device_name)
1608 FILE *f;
1609 int ret = 0;
1610 char filename[PATH_MAX];
1612 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1613 device_file);
1614 f = fopen(filename, "r");
1615 if (f) {
1616 ret = fgets(line, line_size, f) != NULL;
1617 fclose(f);
1620 return ret;
1624 * Use /sys/bus/usb/devices/ directory to determine host's USB
1625 * devices.
1627 * This code is based on Robert Schiele's original patches posted to
1628 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1630 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1632 DIR *dir = NULL;
1633 char line[1024];
1634 int bus_num, addr, speed, class_id, product_id, vendor_id;
1635 int ret = 0;
1636 char port[MAX_PORTLEN];
1637 char product_name[512];
1638 struct dirent *de;
1640 dir = opendir(USBSYSBUS_PATH "/devices");
1641 if (!dir) {
1642 perror("husb: cannot open devices directory");
1643 goto the_end;
1646 while ((de = readdir(dir))) {
1647 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1648 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1649 continue;
1652 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1653 goto the_end;
1655 if (sscanf(line, "%d", &addr) != 1) {
1656 goto the_end;
1658 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1659 de->d_name)) {
1660 goto the_end;
1662 if (sscanf(line, "%x", &class_id) != 1) {
1663 goto the_end;
1666 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1667 de->d_name)) {
1668 goto the_end;
1670 if (sscanf(line, "%x", &vendor_id) != 1) {
1671 goto the_end;
1673 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1674 de->d_name)) {
1675 goto the_end;
1677 if (sscanf(line, "%x", &product_id) != 1) {
1678 goto the_end;
1680 if (!usb_host_read_file(line, sizeof(line), "product",
1681 de->d_name)) {
1682 *product_name = 0;
1683 } else {
1684 if (strlen(line) > 0) {
1685 line[strlen(line) - 1] = '\0';
1687 pstrcpy(product_name, sizeof(product_name), line);
1690 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1691 goto the_end;
1693 if (!strcmp(line, "5000\n")) {
1694 speed = USB_SPEED_SUPER;
1695 } else if (!strcmp(line, "480\n")) {
1696 speed = USB_SPEED_HIGH;
1697 } else if (!strcmp(line, "1.5\n")) {
1698 speed = USB_SPEED_LOW;
1699 } else {
1700 speed = USB_SPEED_FULL;
1703 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1704 product_id, product_name, speed);
1705 if (ret) {
1706 goto the_end;
1710 the_end:
1711 if (dir) {
1712 closedir(dir);
1714 return ret;
1718 * Determine how to access the host's USB devices and call the
1719 * specific support function.
1721 static int usb_host_scan(void *opaque, USBScanFunc *func)
1723 Monitor *mon = cur_mon;
1724 FILE *f = NULL;
1725 DIR *dir = NULL;
1726 int ret = 0;
1727 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1728 char devpath[PATH_MAX];
1730 /* only check the host once */
1731 if (!usb_fs_type) {
1732 dir = opendir(USBSYSBUS_PATH "/devices");
1733 if (dir) {
1734 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1735 strcpy(devpath, USBDEVBUS_PATH);
1736 usb_fs_type = USB_FS_SYS;
1737 closedir(dir);
1738 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1739 goto found_devices;
1741 f = fopen(USBPROCBUS_PATH "/devices", "r");
1742 if (f) {
1743 /* devices found in /proc/bus/usb/ */
1744 strcpy(devpath, USBPROCBUS_PATH);
1745 usb_fs_type = USB_FS_PROC;
1746 fclose(f);
1747 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1748 goto found_devices;
1750 /* try additional methods if an access method hasn't been found yet */
1751 f = fopen(USBDEVBUS_PATH "/devices", "r");
1752 if (f) {
1753 /* devices found in /dev/bus/usb/ */
1754 strcpy(devpath, USBDEVBUS_PATH);
1755 usb_fs_type = USB_FS_DEV;
1756 fclose(f);
1757 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1758 goto found_devices;
1760 found_devices:
1761 if (!usb_fs_type) {
1762 if (mon) {
1763 monitor_printf(mon, "husb: unable to access USB devices\n");
1765 return -ENOENT;
1768 /* the module setting (used later for opening devices) */
1769 usb_host_device_path = g_malloc0(strlen(devpath)+1);
1770 strcpy(usb_host_device_path, devpath);
1771 if (mon) {
1772 monitor_printf(mon, "husb: using %s file-system with %s\n",
1773 fs_type[usb_fs_type], usb_host_device_path);
1777 switch (usb_fs_type) {
1778 case USB_FS_PROC:
1779 case USB_FS_DEV:
1780 ret = usb_host_scan_dev(opaque, func);
1781 break;
1782 case USB_FS_SYS:
1783 ret = usb_host_scan_sys(opaque, func);
1784 break;
1785 default:
1786 ret = -EINVAL;
1787 break;
1789 return ret;
1792 static QEMUTimer *usb_auto_timer;
1794 static int usb_host_auto_scan(void *opaque, int bus_num,
1795 int addr, const char *port,
1796 int class_id, int vendor_id, int product_id,
1797 const char *product_name, int speed)
1799 struct USBAutoFilter *f;
1800 struct USBHostDevice *s;
1802 /* Ignore hubs */
1803 if (class_id == 9)
1804 return 0;
1806 QTAILQ_FOREACH(s, &hostdevs, next) {
1807 f = &s->match;
1809 if (f->bus_num > 0 && f->bus_num != bus_num) {
1810 continue;
1812 if (f->addr > 0 && f->addr != addr) {
1813 continue;
1815 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1816 continue;
1819 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1820 continue;
1823 if (f->product_id > 0 && f->product_id != product_id) {
1824 continue;
1826 /* We got a match */
1827 s->seen++;
1828 if (s->errcount >= 3) {
1829 return 0;
1832 /* Already attached ? */
1833 if (s->fd != -1) {
1834 return 0;
1836 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1838 if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1839 s->errcount++;
1841 break;
1844 return 0;
1847 static void usb_host_auto_check(void *unused)
1849 struct USBHostDevice *s;
1850 int unconnected = 0;
1852 usb_host_scan(NULL, usb_host_auto_scan);
1854 QTAILQ_FOREACH(s, &hostdevs, next) {
1855 if (s->fd == -1) {
1856 unconnected++;
1858 if (s->seen == 0) {
1859 s->errcount = 0;
1861 s->seen = 0;
1864 if (unconnected == 0) {
1865 /* nothing to watch */
1866 if (usb_auto_timer) {
1867 qemu_del_timer(usb_auto_timer);
1868 trace_usb_host_auto_scan_disabled();
1870 return;
1873 if (!usb_auto_timer) {
1874 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1875 if (!usb_auto_timer) {
1876 return;
1878 trace_usb_host_auto_scan_enabled();
1880 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1884 * Autoconnect filter
1885 * Format:
1886 * auto:bus:dev[:vid:pid]
1887 * auto:bus.dev[:vid:pid]
1889 * bus - bus number (dec, * means any)
1890 * dev - device number (dec, * means any)
1891 * vid - vendor id (hex, * means any)
1892 * pid - product id (hex, * means any)
1894 * See 'lsusb' output.
1896 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1898 enum { BUS, DEV, VID, PID, DONE };
1899 const char *p = spec;
1900 int i;
1902 f->bus_num = 0;
1903 f->addr = 0;
1904 f->vendor_id = 0;
1905 f->product_id = 0;
1907 for (i = BUS; i < DONE; i++) {
1908 p = strpbrk(p, ":.");
1909 if (!p) {
1910 break;
1912 p++;
1914 if (*p == '*') {
1915 continue;
1917 switch(i) {
1918 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1919 case DEV: f->addr = strtol(p, NULL, 10); break;
1920 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1921 case PID: f->product_id = strtol(p, NULL, 16); break;
1925 if (i < DEV) {
1926 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1927 return -1;
1930 return 0;
1933 /**********************/
1934 /* USB host device info */
1936 struct usb_class_info {
1937 int class;
1938 const char *class_name;
1941 static const struct usb_class_info usb_class_info[] = {
1942 { USB_CLASS_AUDIO, "Audio"},
1943 { USB_CLASS_COMM, "Communication"},
1944 { USB_CLASS_HID, "HID"},
1945 { USB_CLASS_HUB, "Hub" },
1946 { USB_CLASS_PHYSICAL, "Physical" },
1947 { USB_CLASS_PRINTER, "Printer" },
1948 { USB_CLASS_MASS_STORAGE, "Storage" },
1949 { USB_CLASS_CDC_DATA, "Data" },
1950 { USB_CLASS_APP_SPEC, "Application Specific" },
1951 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1952 { USB_CLASS_STILL_IMAGE, "Still Image" },
1953 { USB_CLASS_CSCID, "Smart Card" },
1954 { USB_CLASS_CONTENT_SEC, "Content Security" },
1955 { -1, NULL }
1958 static const char *usb_class_str(uint8_t class)
1960 const struct usb_class_info *p;
1961 for(p = usb_class_info; p->class != -1; p++) {
1962 if (p->class == class) {
1963 break;
1966 return p->class_name;
1969 static void usb_info_device(Monitor *mon, int bus_num,
1970 int addr, const char *port,
1971 int class_id, int vendor_id, int product_id,
1972 const char *product_name,
1973 int speed)
1975 const char *class_str, *speed_str;
1977 switch(speed) {
1978 case USB_SPEED_LOW:
1979 speed_str = "1.5";
1980 break;
1981 case USB_SPEED_FULL:
1982 speed_str = "12";
1983 break;
1984 case USB_SPEED_HIGH:
1985 speed_str = "480";
1986 break;
1987 case USB_SPEED_SUPER:
1988 speed_str = "5000";
1989 break;
1990 default:
1991 speed_str = "?";
1992 break;
1995 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1996 bus_num, addr, port, speed_str);
1997 class_str = usb_class_str(class_id);
1998 if (class_str) {
1999 monitor_printf(mon, " %s:", class_str);
2000 } else {
2001 monitor_printf(mon, " Class %02x:", class_id);
2003 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
2004 if (product_name[0] != '\0') {
2005 monitor_printf(mon, ", %s", product_name);
2007 monitor_printf(mon, "\n");
2010 static int usb_host_info_device(void *opaque, int bus_num, int addr,
2011 const char *path, int class_id,
2012 int vendor_id, int product_id,
2013 const char *product_name,
2014 int speed)
2016 Monitor *mon = opaque;
2018 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
2019 product_name, speed);
2020 return 0;
2023 static void dec2str(int val, char *str, size_t size)
2025 if (val == 0) {
2026 snprintf(str, size, "*");
2027 } else {
2028 snprintf(str, size, "%d", val);
2032 static void hex2str(int val, char *str, size_t size)
2034 if (val == 0) {
2035 snprintf(str, size, "*");
2036 } else {
2037 snprintf(str, size, "%04x", val);
2041 void usb_host_info(Monitor *mon)
2043 struct USBAutoFilter *f;
2044 struct USBHostDevice *s;
2046 usb_host_scan(mon, usb_host_info_device);
2048 if (QTAILQ_EMPTY(&hostdevs)) {
2049 return;
2052 monitor_printf(mon, " Auto filters:\n");
2053 QTAILQ_FOREACH(s, &hostdevs, next) {
2054 char bus[10], addr[10], vid[10], pid[10];
2055 f = &s->match;
2056 dec2str(f->bus_num, bus, sizeof(bus));
2057 dec2str(f->addr, addr, sizeof(addr));
2058 hex2str(f->vendor_id, vid, sizeof(vid));
2059 hex2str(f->product_id, pid, sizeof(pid));
2060 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
2061 bus, addr, f->port ? f->port : "*", vid, pid);