?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
move checks to separate variable
[qemu/qmp-unstable.git] / usb-linux.c
blob7d4d1d7bcf9ad8f70239df63fb47eaa00bb6d612
1 /*
2 * Linux host USB redirector
3 *
4 * Copyright (c) 2005 Fabrice Bellard
5 *
6 * Copyright (c) 2008 Max Krasnyansky
7 * Support for host device auto connect & disconnect
8 * Major rewrite to support fully async operation
9 *
10 * Copyright 2008 TJ <linux@tjworld.net>
11 * Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition
12 * to the legacy /proc/bus/usb USB device discovery and handling
13 *
14 * Permission is hereby granted, free of charge, to any person obtaining a copy
15 * of this software and associated documentation files (the "Software"), to deal
16 * in the Software without restriction, including without limitation the rights
17 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18 * copies of the Software, and to permit persons to whom the Software is
19 * furnished to do so, subject to the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
30 * THE SOFTWARE.
31 */
32
33 #include "qemu-common.h"
34 #include "qemu-timer.h"
35 #include "monitor.h"
36 #include "sysemu.h"
37 #include "trace.h"
38
39 #include <dirent.h>
40 #include <sys/ioctl.h>
41
42 #include <linux/usbdevice_fs.h>
43 #include <linux/version.h>
44 #include "hw/usb.h"
45
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;
55 };
56
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);
60
61 //#define DEBUG
62
63 #ifdef DEBUG
64 #define DPRINTF printf
65 #else
66 #define DPRINTF(...)
67 #endif
68
69 #define USBDBG_DEVOPENED "husb: opened %s/devices\n"
70
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"
77
78 static char *usb_host_device_path;
79
80 #define USB_FS_NONE 0
81 #define USB_FS_PROC 1
82 #define USB_FS_DEV 2
83 #define USB_FS_SYS 3
84
85 static int usb_fs_type;
86
87 /* endpoint association data */
88 #define ISO_FRAME_DESC_PER_URB 32
89 #define INVALID_EP_TYPE 255
90
91 /* devio.c limits single requests to 16k */
92 #define MAX_USBFS_BUFFER_SIZE 16384
93
94 typedef struct AsyncURB AsyncURB;
95
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;
105 };
106
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;
113 };
114
115 typedef struct USBHostDevice {
116 USBDevice dev;
117 int fd;
118 int hub_fd;
119
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;
127
128 struct endp_data ep_in[MAX_ENDPOINTS];
129 struct endp_data ep_out[MAX_ENDPOINTS];
130 QLIST_HEAD(, AsyncURB) aurbs;
131
132 /* Host side address */
133 int bus_num;
134 int addr;
135 char port[MAX_PORTLEN];
136 struct USBAutoFilter match;
137 int seen, errcount;
138
139 QTAILQ_ENTRY(USBHostDevice) next;
140 } USBHostDevice;
141
142 static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
143
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);
150
151 static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep)
152 {
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;
157 }
158
159 static int is_isoc(USBHostDevice *s, int pid, int ep)
160 {
161 return get_endp(s, pid, ep)->type == USBDEVFS_URB_TYPE_ISO;
162 }
163
164 static int is_valid(USBHostDevice *s, int pid, int ep)
165 {
166 return get_endp(s, pid, ep)->type != INVALID_EP_TYPE;
167 }
168
169 static int is_halted(USBHostDevice *s, int pid, int ep)
170 {
171 return get_endp(s, pid, ep)->halted;
172 }
173
174 static void clear_halt(USBHostDevice *s, int pid, int ep)
175 {
176 trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep);
177 get_endp(s, pid, ep)->halted = 0;
178 }
179
180 static void set_halt(USBHostDevice *s, int pid, int ep)
181 {
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;
185 }
186 }
187
188 static int is_iso_started(USBHostDevice *s, int pid, int ep)
189 {
190 return get_endp(s, pid, ep)->iso_started;
191 }
192
193 static void clear_iso_started(USBHostDevice *s, int pid, int ep)
194 {
195 trace_usb_host_ep_stop_iso(s->bus_num, s->addr, ep);
196 get_endp(s, pid, ep)->iso_started = 0;
197 }
198
199 static void set_iso_started(USBHostDevice *s, int pid, int ep)
200 {
201 struct endp_data *e = get_endp(s, pid, ep);
202
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;
207 }
208 }
209
210 static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value)
211 {
212 struct endp_data *e = get_endp(s, pid, ep);
213
214 e->inflight += value;
215 return e->inflight;
216 }
217
218 static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb)
219 {
220 get_endp(s, pid, ep)->iso_urb = iso_urb;
221 }
222
223 static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep)
224 {
225 return get_endp(s, pid, ep)->iso_urb;
226 }
227
228 static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i)
229 {
230 get_endp(s, pid, ep)->iso_urb_idx = i;
231 }
232
233 static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep)
234 {
235 return get_endp(s, pid, ep)->iso_urb_idx;
236 }
237
238 static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i)
239 {
240 get_endp(s, pid, ep)->iso_buffer_used = i;
241 }
242
243 static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep)
244 {
245 return get_endp(s, pid, ep)->iso_buffer_used;
246 }
247
248 static void set_max_packet_size(USBHostDevice *s, int pid, int ep,
249 uint8_t *descriptor)
250 {
251 int raw = descriptor[4] + (descriptor[5] << 8);
252 int size, microframes;
253
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;
259 }
260 get_endp(s, pid, ep)->max_packet_size = size * microframes;
261 }
262
263 static int get_max_packet_size(USBHostDevice *s, int pid, int ep)
264 {
265 return get_endp(s, pid, ep)->max_packet_size;
266 }
267
268 /*
269 * Async URB state.
270 * We always allocate iso packet descriptors even for bulk transfers
271 * to simplify allocation and casts.
272 */
273 struct AsyncURB
274 {
275 struct usbdevfs_urb urb;
276 struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB];
277 USBHostDevice *hdev;
278 QLIST_ENTRY(AsyncURB) next;
279
280 /* For regular async urbs */
281 USBPacket *packet;
282 int more; /* large transfer, more urbs follow */
283
284 /* For buffered iso handling */
285 int iso_frame_idx; /* -1 means in flight */
286 };
287
288 static AsyncURB *async_alloc(USBHostDevice *s)
289 {
290 AsyncURB *aurb = g_malloc0(sizeof(AsyncURB));
291 aurb->hdev = s;
292 QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
293 return aurb;
294 }
295
296 static void async_free(AsyncURB *aurb)
297 {
298 QLIST_REMOVE(aurb, next);
299 g_free(aurb);
300 }
301
302 static void do_disconnect(USBHostDevice *s)
303 {
304 usb_host_close(s);
305 usb_host_auto_check(NULL);
306 }
307
308 static void async_complete(void *opaque)
309 {
310 USBHostDevice *s = opaque;
311 AsyncURB *aurb;
312 int urbs = 0;
313
314 while (1) {
315 USBPacket *p;
316
317 int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
318 if (r < 0) {
319 if (errno == EAGAIN) {
320 if (urbs > 2) {
321 fprintf(stderr, "husb: %d iso urbs finished at once\n", urbs);
322 }
323 return;
324 }
325 if (errno == ENODEV) {
326 if (!s->closing) {
327 trace_usb_host_disconnect(s->bus_num, s->addr);
328 do_disconnect(s);
329 }
330 return;
331 }
332
333 perror("USBDEVFS_REAPURBNDELAY");
334 return;
335 }
336
337 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
338 aurb, aurb->urb.status, aurb->urb.actual_length);
339
340 /* If this is a buffered iso urb mark it as complete and don't do
341 anything else (it is handled further in usb_host_handle_iso_data) */
342 if (aurb->iso_frame_idx == -1) {
343 int inflight;
344 int pid = (aurb->urb.endpoint & USB_DIR_IN) ?
345 USB_TOKEN_IN : USB_TOKEN_OUT;
346 int ep = aurb->urb.endpoint & 0xf;
347 if (aurb->urb.status == -EPIPE) {
348 set_halt(s, pid, ep);
349 }
350 aurb->iso_frame_idx = 0;
351 urbs++;
352 inflight = change_iso_inflight(s, pid, ep, -1);
353 if (inflight == 0 && is_iso_started(s, pid, ep)) {
354 fprintf(stderr, "husb: out of buffers for iso stream\n");
355 }
356 continue;
357 }
358
359 p = aurb->packet;
360 trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status,
361 aurb->urb.actual_length, aurb->more);
362
363 if (p) {
364 switch (aurb->urb.status) {
365 case 0:
366 p->result += aurb->urb.actual_length;
367 break;
368
369 case -EPIPE:
370 set_halt(s, p->pid, p->devep);
371 p->result = USB_RET_STALL;
372 break;
373
374 default:
375 p->result = USB_RET_NAK;
376 break;
377 }
378
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);
385 }
386 }
387
388 async_free(aurb);
389 }
390 }
391
392 static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
393 {
394 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
395 AsyncURB *aurb;
396
397 QLIST_FOREACH(aurb, &s->aurbs, next) {
398 if (p != aurb->packet) {
399 continue;
400 }
401
402 DPRINTF("husb: async cancel: packet %p, aurb %p\n", p, aurb);
403
404 /* Mark it as dead (see async_complete above) */
405 aurb->packet = NULL;
406
407 int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
408 if (r < 0) {
409 DPRINTF("husb: async. discard urb failed errno %d\n", errno);
410 }
411 }
412 }
413
414 static int usb_host_claim_port(USBHostDevice *s)
415 {
416 #ifdef USBDEVFS_CLAIM_PORT
417 char *h, hub_name[64], line[1024];
418 int hub_addr, portnr, ret;
419
420 snprintf(hub_name, sizeof(hub_name), "%d-%s",
421 s->match.bus_num, s->match.port);
422
423 /* try strip off last ".$portnr" to get hub */
424 h = strrchr(hub_name, '.');
425 if (h != NULL) {
426 portnr = atoi(h+1);
427 *h = '\0';
428 } else {
429 /* no dot in there -> it is the root hub */
430 snprintf(hub_name, sizeof(hub_name), "usb%d",
431 s->match.bus_num);
432 portnr = atoi(s->match.port);
433 }
434
435 if (!usb_host_read_file(line, sizeof(line), "devnum",
436 hub_name)) {
437 return -1;
438 }
439 if (sscanf(line, "%d", &hub_addr) != 1) {
440 return -1;
441 }
442
443 if (!usb_host_device_path) {
444 return -1;
445 }
446 snprintf(line, sizeof(line), "%s/%03d/%03d",
447 usb_host_device_path, s->match.bus_num, hub_addr);
448 s->hub_fd = open(line, O_RDWR | O_NONBLOCK);
449 if (s->hub_fd < 0) {
450 return -1;
451 }
452
453 ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &portnr);
454 if (ret < 0) {
455 close(s->hub_fd);
456 s->hub_fd = -1;
457 return -1;
458 }
459
460 trace_usb_host_claim_port(s->match.bus_num, hub_addr, portnr);
461 return 0;
462 #else
463 return -1;
464 #endif
465 }
466
467 static int usb_host_disconnect_ifaces(USBHostDevice *dev, int nb_interfaces)
468 {
469 /* earlier Linux 2.4 do not support that */
470 #ifdef USBDEVFS_DISCONNECT
471 struct usbdevfs_ioctl ctrl;
472 int ret, interface;
473
474 for (interface = 0; interface < nb_interfaces; interface++) {
475 ctrl.ioctl_code = USBDEVFS_DISCONNECT;
476 ctrl.ifno = interface;
477 ctrl.data = 0;
478 ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
479 if (ret < 0 && errno != ENODATA) {
480 perror("USBDEVFS_DISCONNECT");
481 return -1;
482 }
483 }
484 #endif
485 return 0;
486 }
487
488 static int usb_linux_get_num_interfaces(USBHostDevice *s)
489 {
490 char device_name[64], line[1024];
491 int num_interfaces = 0;
492
493 if (usb_fs_type != USB_FS_SYS) {
494 return -1;
495 }
496
497 sprintf(device_name, "%d-%s", s->bus_num, s->port);
498 if (!usb_host_read_file(line, sizeof(line), "bNumInterfaces",
499 device_name)) {
500 return -1;
501 }
502 if (sscanf(line, "%d", &num_interfaces) != 1) {
503 return -1;
504 }
505 return num_interfaces;
506 }
507
508 static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
509 {
510 const char *op = NULL;
511 int dev_descr_len, config_descr_len;
512 int interface, nb_interfaces;
513 int ret, i;
514
515 if (configuration == 0) { /* address state - ignore */
516 dev->ninterfaces = 0;
517 dev->configuration = 0;
518 return 1;
519 }
520
521 DPRINTF("husb: claiming interfaces. config %d\n", configuration);
522
523 i = 0;
524 dev_descr_len = dev->descr[0];
525 if (dev_descr_len > dev->descr_len) {
526 fprintf(stderr, "husb: update iface failed. descr too short\n");
527 return 0;
528 }
529
530 i += dev_descr_len;
531 while (i < dev->descr_len) {
532 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
533 i, dev->descr_len,
534 dev->descr[i], dev->descr[i+1]);
535
536 if (dev->descr[i+1] != USB_DT_CONFIG) {
537 i += dev->descr[i];
538 continue;
539 }
540 config_descr_len = dev->descr[i];
541
542 DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
543
544 if (configuration == dev->descr[i + 5]) {
545 configuration = dev->descr[i + 5];
546 break;
547 }
548
549 i += config_descr_len;
550 }
551
552 if (i >= dev->descr_len) {
553 fprintf(stderr,
554 "husb: update iface failed. no matching configuration\n");
555 return 0;
556 }
557 nb_interfaces = dev->descr[i + 4];
558
559 if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) {
560 goto fail;
561 }
562
563 /* XXX: only grab if all interfaces are free */
564 for (interface = 0; interface < nb_interfaces; interface++) {
565 op = "USBDEVFS_CLAIMINTERFACE";
566 ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
567 if (ret < 0) {
568 goto fail;
569 }
570 }
571
572 trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
573 nb_interfaces, configuration);
574
575 dev->ninterfaces = nb_interfaces;
576 dev->configuration = configuration;
577 return 1;
578
579 fail:
580 if (errno == ENODEV) {
581 do_disconnect(dev);
582 }
583 perror(op);
584 return 0;
585 }
586
587 static int usb_host_release_interfaces(USBHostDevice *s)
588 {
589 int ret, i;
590
591 trace_usb_host_release_interfaces(s->bus_num, s->addr);
592
593 for (i = 0; i < s->ninterfaces; i++) {
594 ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
595 if (ret < 0) {
596 perror("USBDEVFS_RELEASEINTERFACE");
597 return 0;
598 }
599 }
600 return 1;
601 }
602
603 static void usb_host_handle_reset(USBDevice *dev)
604 {
605 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
606
607 trace_usb_host_reset(s->bus_num, s->addr);
608
609 ioctl(s->fd, USBDEVFS_RESET);
610
611 usb_host_claim_interfaces(s, 0);
612 usb_linux_update_endp_table(s);
613 }
614
615 static void usb_host_handle_destroy(USBDevice *dev)
616 {
617 USBHostDevice *s = (USBHostDevice *)dev;
618
619 usb_host_close(s);
620 if (s->hub_fd != -1) {
621 close(s->hub_fd);
622 }
623 QTAILQ_REMOVE(&hostdevs, s, next);
624 qemu_remove_exit_notifier(&s->exit);
625 }
626
627 /* iso data is special, we need to keep enough urbs in flight to make sure
628 that the controller never runs out of them, otherwise the device will
629 likely suffer a buffer underrun / overrun. */
630 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
631 {
632 AsyncURB *aurb;
633 int i, j, len = get_max_packet_size(s, pid, ep);
634
635 aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
636 for (i = 0; i < s->iso_urb_count; i++) {
637 aurb[i].urb.endpoint = ep;
638 aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
639 aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length);
640 aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO;
641 aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP;
642 aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
643 for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
644 aurb[i].urb.iso_frame_desc[j].length = len;
645 if (pid == USB_TOKEN_IN) {
646 aurb[i].urb.endpoint |= 0x80;
647 /* Mark as fully consumed (idle) */
648 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
649 }
650 }
651 set_iso_urb(s, pid, ep, aurb);
652
653 return aurb;
654 }
655
656 static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
657 {
658 AsyncURB *aurb;
659 int i, ret, killed = 0, free = 1;
660
661 aurb = get_iso_urb(s, pid, ep);
662 if (!aurb) {
663 return;
664 }
665
666 for (i = 0; i < s->iso_urb_count; i++) {
667 /* in flight? */
668 if (aurb[i].iso_frame_idx == -1) {
669 ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
670 if (ret < 0) {
671 perror("USBDEVFS_DISCARDURB");
672 free = 0;
673 continue;
674 }
675 killed++;
676 }
677 }
678
679 /* Make sure any urbs we've killed are reaped before we free them */
680 if (killed) {
681 async_complete(s);
682 }
683
684 for (i = 0; i < s->iso_urb_count; i++) {
685 g_free(aurb[i].urb.buffer);
686 }
687
688 if (free)
689 g_free(aurb);
690 else
691 printf("husb: leaking iso urbs because of discard failure\n");
692 set_iso_urb(s, pid, ep, NULL);
693 set_iso_urb_idx(s, pid, ep, 0);
694 clear_iso_started(s, pid, ep);
695 }
696
697 static int urb_status_to_usb_ret(int status)
698 {
699 switch (status) {
700 case -EPIPE:
701 return USB_RET_STALL;
702 default:
703 return USB_RET_NAK;
704 }
705 }
706
707 static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
708 {
709 AsyncURB *aurb;
710 int i, j, ret, max_packet_size, offset, len = 0;
711 uint8_t *buf;
712
713 max_packet_size = get_max_packet_size(s, p->pid, p->devep);
714 if (max_packet_size == 0)
715 return USB_RET_NAK;
716
717 aurb = get_iso_urb(s, p->pid, p->devep);
718 if (!aurb) {
719 aurb = usb_host_alloc_iso(s, p->pid, p->devep);
720 }
721
722 i = get_iso_urb_idx(s, p->pid, p->devep);
723 j = aurb[i].iso_frame_idx;
724 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
725 if (in) {
726 /* Check urb status */
727 if (aurb[i].urb.status) {
728 len = urb_status_to_usb_ret(aurb[i].urb.status);
729 /* Move to the next urb */
730 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
731 /* Check frame status */
732 } else if (aurb[i].urb.iso_frame_desc[j].status) {
733 len = urb_status_to_usb_ret(
734 aurb[i].urb.iso_frame_desc[j].status);
735 /* Check the frame fits */
736 } else if (aurb[i].urb.iso_frame_desc[j].actual_length
737 > p->iov.size) {
738 printf("husb: received iso data is larger then packet\n");
739 len = USB_RET_NAK;
740 /* All good copy data over */
741 } else {
742 len = aurb[i].urb.iso_frame_desc[j].actual_length;
743 buf = aurb[i].urb.buffer +
744 j * aurb[i].urb.iso_frame_desc[0].length;
745 usb_packet_copy(p, buf, len);
746 }
747 } else {
748 len = p->iov.size;
749 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
750
751 /* Check the frame fits */
752 if (len > max_packet_size) {
753 printf("husb: send iso data is larger then max packet size\n");
754 return USB_RET_NAK;
755 }
756
757 /* All good copy data over */
758 usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
759 aurb[i].urb.iso_frame_desc[j].length = len;
760 offset += len;
761 set_iso_buffer_used(s, p->pid, p->devep, offset);
762
763 /* Start the stream once we have buffered enough data */
764 if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
765 set_iso_started(s, p->pid, p->devep);
766 }
767 }
768 aurb[i].iso_frame_idx++;
769 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
770 i = (i + 1) % s->iso_urb_count;
771 set_iso_urb_idx(s, p->pid, p->devep, i);
772 }
773 } else {
774 if (in) {
775 set_iso_started(s, p->pid, p->devep);
776 } else {
777 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
778 }
779 }
780
781 if (is_iso_started(s, p->pid, p->devep)) {
782 /* (Re)-submit all fully consumed / filled urbs */
783 for (i = 0; i < s->iso_urb_count; i++) {
784 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
785 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
786 if (ret < 0) {
787 perror("USBDEVFS_SUBMITURB");
788 if (!in || len == 0) {
789 switch(errno) {
790 case ETIMEDOUT:
791 len = USB_RET_NAK;
792 break;
793 case EPIPE:
794 default:
795 len = USB_RET_STALL;
796 }
797 }
798 break;
799 }
800 aurb[i].iso_frame_idx = -1;
801 change_iso_inflight(s, p->pid, p->devep, 1);
802 }
803 }
804 }
805
806 return len;
807 }
808
809 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
810 {
811 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
812 struct usbdevfs_urb *urb;
813 AsyncURB *aurb;
814 int ret, rem, prem, v;
815 uint8_t *pbuf;
816 uint8_t ep;
817
818 trace_usb_host_req_data(s->bus_num, s->addr,
819 p->pid == USB_TOKEN_IN,
820 p->devep, p->iov.size);
821
822 if (!is_valid(s, p->pid, p->devep)) {
823 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
824 return USB_RET_NAK;
825 }
826
827 if (p->pid == USB_TOKEN_IN) {
828 ep = p->devep | 0x80;
829 } else {
830 ep = p->devep;
831 }
832
833 if (is_halted(s, p->pid, p->devep)) {
834 unsigned int arg = ep;
835 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
836 if (ret < 0) {
837 perror("USBDEVFS_CLEAR_HALT");
838 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
839 return USB_RET_NAK;
840 }
841 clear_halt(s, p->pid, p->devep);
842 }
843
844 if (is_isoc(s, p->pid, p->devep)) {
845 return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
846 }
847
848 v = 0;
849 prem = p->iov.iov[v].iov_len;
850 pbuf = p->iov.iov[v].iov_base;
851 rem = p->iov.size;
852 while (rem) {
853 if (prem == 0) {
854 v++;
855 assert(v < p->iov.niov);
856 prem = p->iov.iov[v].iov_len;
857 pbuf = p->iov.iov[v].iov_base;
858 assert(prem <= rem);
859 }
860 aurb = async_alloc(s);
861 aurb->packet = p;
862
863 urb = &aurb->urb;
864 urb->endpoint = ep;
865 urb->type = USBDEVFS_URB_TYPE_BULK;
866 urb->usercontext = s;
867 urb->buffer = pbuf;
868 urb->buffer_length = prem;
869
870 if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
871 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
872 }
873 pbuf += urb->buffer_length;
874 prem -= urb->buffer_length;
875 rem -= urb->buffer_length;
876 if (rem) {
877 aurb->more = 1;
878 }
879
880 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
881 urb->buffer_length, aurb->more);
882 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
883
884 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
885 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
886
887 if (ret < 0) {
888 perror("USBDEVFS_SUBMITURB");
889 async_free(aurb);
890
891 switch(errno) {
892 case ETIMEDOUT:
893 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
894 return USB_RET_NAK;
895 case EPIPE:
896 default:
897 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL);
898 return USB_RET_STALL;
899 }
900 }
901 }
902
903 return USB_RET_ASYNC;
904 }
905
906 static int ctrl_error(void)
907 {
908 if (errno == ETIMEDOUT) {
909 return USB_RET_NAK;
910 } else {
911 return USB_RET_STALL;
912 }
913 }
914
915 static int usb_host_set_address(USBHostDevice *s, int addr)
916 {
917 trace_usb_host_set_address(s->bus_num, s->addr, addr);
918 s->dev.addr = addr;
919 return 0;
920 }
921
922 static int usb_host_set_config(USBHostDevice *s, int config)
923 {
924 int ret, first = 1;
925
926 trace_usb_host_set_config(s->bus_num, s->addr, config);
927
928 usb_host_release_interfaces(s);
929
930 again:
931 ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
932
933 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
934
935 if (ret < 0 && errno == EBUSY && first) {
936 /* happens if usb device is in use by host drivers */
937 int count = usb_linux_get_num_interfaces(s);
938 if (count > 0) {
939 DPRINTF("husb: busy -> disconnecting %d interfaces\n", count);
940 usb_host_disconnect_ifaces(s, count);
941 first = 0;
942 goto again;
943 }
944 }
945
946 if (ret < 0) {
947 return ctrl_error();
948 }
949 usb_host_claim_interfaces(s, config);
950 usb_linux_update_endp_table(s);
951 return 0;
952 }
953
954 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
955 {
956 struct usbdevfs_setinterface si;
957 int i, ret;
958
959 trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
960
961 for (i = 1; i <= MAX_ENDPOINTS; i++) {
962 if (is_isoc(s, USB_TOKEN_IN, i)) {
963 usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i);
964 }
965 if (is_isoc(s, USB_TOKEN_OUT, i)) {
966 usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i);
967 }
968 }
969
970 si.interface = iface;
971 si.altsetting = alt;
972 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
973
974 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
975 iface, alt, ret, errno);
976
977 if (ret < 0) {
978 return ctrl_error();
979 }
980 usb_linux_update_endp_table(s);
981 return 0;
982 }
983
984 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
985 int request, int value, int index, int length, uint8_t *data)
986 {
987 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
988 struct usbdevfs_urb *urb;
989 AsyncURB *aurb;
990 int ret;
991
992 /*
993 * Process certain standard device requests.
994 * These are infrequent and are processed synchronously.
995 */
996
997 /* Note request is (bRequestType << 8) | bRequest */
998 trace_usb_host_req_control(s->bus_num, s->addr, request, value, index);
999
1000 switch (request) {
1001 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1002 return usb_host_set_address(s, value);
1003
1004 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1005 return usb_host_set_config(s, value & 0xff);
1006
1007 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1008 return usb_host_set_interface(s, index, value);
1009 }
1010
1011 /* The rest are asynchronous */
1012
1013 if (length > sizeof(dev->data_buf)) {
1014 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
1015 length, sizeof(dev->data_buf));
1016 return USB_RET_STALL;
1017 }
1018
1019 aurb = async_alloc(s);
1020 aurb->packet = p;
1021
1022 /*
1023 * Setup ctrl transfer.
1024 *
1025 * s->ctrl is laid out such that data buffer immediately follows
1026 * 'req' struct which is exactly what usbdevfs expects.
1027 */
1028 urb = &aurb->urb;
1029
1030 urb->type = USBDEVFS_URB_TYPE_CONTROL;
1031 urb->endpoint = p->devep;
1032
1033 urb->buffer = &dev->setup_buf;
1034 urb->buffer_length = length + 8;
1035
1036 urb->usercontext = s;
1037
1038 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
1039 urb->buffer_length, aurb->more);
1040 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
1041
1042 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
1043
1044 if (ret < 0) {
1045 DPRINTF("husb: submit failed. errno %d\n", errno);
1046 async_free(aurb);
1047
1048 switch(errno) {
1049 case ETIMEDOUT:
1050 return USB_RET_NAK;
1051 case EPIPE:
1052 default:
1053 return USB_RET_STALL;
1054 }
1055 }
1056
1057 return USB_RET_ASYNC;
1058 }
1059
1060 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
1061 uint8_t configuration, uint8_t interface)
1062 {
1063 uint8_t alt_setting;
1064 struct usb_ctrltransfer ct;
1065 int ret;
1066
1067 if (usb_fs_type == USB_FS_SYS) {
1068 char device_name[64], line[1024];
1069 int alt_setting;
1070
1071 sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
1072 (int)configuration, (int)interface);
1073
1074 if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
1075 device_name)) {
1076 goto usbdevfs;
1077 }
1078 if (sscanf(line, "%d", &alt_setting) != 1) {
1079 goto usbdevfs;
1080 }
1081 return alt_setting;
1082 }
1083
1084 usbdevfs:
1085 ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
1086 ct.bRequest = USB_REQ_GET_INTERFACE;
1087 ct.wValue = 0;
1088 ct.wIndex = interface;
1089 ct.wLength = 1;
1090 ct.data = &alt_setting;
1091 ct.timeout = 50;
1092 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
1093 if (ret < 0) {
1094 /* Assume alt 0 on error */
1095 return 0;
1096 }
1097
1098 return alt_setting;
1099 }
1100
1101 /* returns 1 on problem encountered or 0 for success */
1102 static int usb_linux_update_endp_table(USBHostDevice *s)
1103 {
1104 uint8_t *descriptors;
1105 uint8_t devep, type, alt_interface;
1106 int interface, length, i, ep, pid;
1107 struct endp_data *epd;
1108
1109 for (i = 0; i < MAX_ENDPOINTS; i++) {
1110 s->ep_in[i].type = INVALID_EP_TYPE;
1111 s->ep_out[i].type = INVALID_EP_TYPE;
1112 }
1113
1114 if (s->configuration == 0) {
1115 /* not configured yet -- leave all endpoints disabled */
1116 return 0;
1117 }
1118
1119 /* get the desired configuration, interface, and endpoint descriptors
1120 * from device description */
1121 descriptors = &s->descr[18];
1122 length = s->descr_len - 18;
1123 i = 0;
1124
1125 if (descriptors[i + 1] != USB_DT_CONFIG ||
1126 descriptors[i + 5] != s->configuration) {
1127 fprintf(stderr, "invalid descriptor data - configuration %d\n",
1128 s->configuration);
1129 return 1;
1130 }
1131 i += descriptors[i];
1132
1133 while (i < length) {
1134 if (descriptors[i + 1] != USB_DT_INTERFACE ||
1135 (descriptors[i + 1] == USB_DT_INTERFACE &&
1136 descriptors[i + 4] == 0)) {
1137 i += descriptors[i];
1138 continue;
1139 }
1140
1141 interface = descriptors[i + 2];
1142 alt_interface = usb_linux_get_alt_setting(s, s->configuration,
1143 interface);
1144
1145 /* the current interface descriptor is the active interface
1146 * and has endpoints */
1147 if (descriptors[i + 3] != alt_interface) {
1148 i += descriptors[i];
1149 continue;
1150 }
1151
1152 /* advance to the endpoints */
1153 while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1154 i += descriptors[i];
1155 }
1156
1157 if (i >= length)
1158 break;
1159
1160 while (i < length) {
1161 if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1162 break;
1163 }
1164
1165 devep = descriptors[i + 2];
1166 pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1167 ep = devep & 0xf;
1168 if (ep == 0) {
1169 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1170 return 1;
1171 }
1172
1173 switch (descriptors[i + 3] & 0x3) {
1174 case 0x00:
1175 type = USBDEVFS_URB_TYPE_CONTROL;
1176 break;
1177 case 0x01:
1178 type = USBDEVFS_URB_TYPE_ISO;
1179 set_max_packet_size(s, pid, ep, descriptors + i);
1180 break;
1181 case 0x02:
1182 type = USBDEVFS_URB_TYPE_BULK;
1183 break;
1184 case 0x03:
1185 type = USBDEVFS_URB_TYPE_INTERRUPT;
1186 break;
1187 default:
1188 DPRINTF("usb_host: malformed endpoint type\n");
1189 type = USBDEVFS_URB_TYPE_BULK;
1190 }
1191 epd = get_endp(s, pid, ep);
1192 assert(epd->type == INVALID_EP_TYPE);
1193 epd->type = type;
1194 epd->halted = 0;
1195
1196 i += descriptors[i];
1197 }
1198 }
1199 return 0;
1200 }
1201
1202 /*
1203 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1204 * this function assumes this is safe, if:
1205 * 1) There are no isoc endpoints
1206 * 2) There are no interrupt endpoints with a max_packet_size > 64
1207 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1208 * usb1 compatible, but in practice this seems to work fine.
1209 */
1210 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1211 {
1212 int i, packet_size;
1213
1214 /*
1215 * usb_linux_update_endp_table only registers info about ep in the current
1216 * interface altsettings, so we need to parse the descriptors again.
1217 */
1218 for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1219 if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1220 switch (dev->descr[i + 3] & 0x3) {
1221 case 0x00: /* CONTROL */
1222 break;
1223 case 0x01: /* ISO */
1224 return 0;
1225 case 0x02: /* BULK */
1226 break;
1227 case 0x03: /* INTERRUPT */
1228 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1229 if (packet_size > 64)
1230 return 0;
1231 break;
1232 }
1233 }
1234 }
1235 return 1;
1236 }
1237
1238 static int usb_host_open(USBHostDevice *dev, int bus_num,
1239 int addr, const char *port,
1240 const char *prod_name, int speed)
1241 {
1242 int fd = -1, ret;
1243 char buf[1024];
1244
1245 trace_usb_host_open_started(bus_num, addr);
1246
1247 if (dev->fd != -1) {
1248 goto fail;
1249 }
1250
1251 if (!usb_host_device_path) {
1252 perror("husb: USB Host Device Path not set");
1253 goto fail;
1254 }
1255 snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1256 bus_num, addr);
1257 fd = open(buf, O_RDWR | O_NONBLOCK);
1258 if (fd < 0) {
1259 perror(buf);
1260 goto fail;
1261 }
1262 DPRINTF("husb: opened %s\n", buf);
1263
1264 dev->bus_num = bus_num;
1265 dev->addr = addr;
1266 strcpy(dev->port, port);
1267 dev->fd = fd;
1268
1269 /* read the device description */
1270 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1271 if (dev->descr_len <= 0) {
1272 perror("husb: reading device data failed");
1273 goto fail;
1274 }
1275
1276 #ifdef DEBUG
1277 {
1278 int x;
1279 printf("=== begin dumping device descriptor data ===\n");
1280 for (x = 0; x < dev->descr_len; x++) {
1281 printf("%02x ", dev->descr[x]);
1282 }
1283 printf("\n=== end dumping device descriptor data ===\n");
1284 }
1285 #endif
1286
1287
1288 /* start unconfigured -- we'll wait for the guest to set a configuration */
1289 if (!usb_host_claim_interfaces(dev, 0)) {
1290 goto fail;
1291 }
1292
1293 ret = usb_linux_update_endp_table(dev);
1294 if (ret) {
1295 goto fail;
1296 }
1297
1298 if (speed == -1) {
1299 struct usbdevfs_connectinfo ci;
1300
1301 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1302 if (ret < 0) {
1303 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1304 goto fail;
1305 }
1306
1307 if (ci.slow) {
1308 speed = USB_SPEED_LOW;
1309 } else {
1310 speed = USB_SPEED_HIGH;
1311 }
1312 }
1313 dev->dev.speed = speed;
1314 dev->dev.speedmask = (1 << speed);
1315 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1316 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1317 }
1318
1319 trace_usb_host_open_success(bus_num, addr);
1320
1321 if (!prod_name || prod_name[0] == '\0') {
1322 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1323 "host:%d.%d", bus_num, addr);
1324 } else {
1325 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1326 prod_name);
1327 }
1328
1329 ret = usb_device_attach(&dev->dev);
1330 if (ret) {
1331 goto fail;
1332 }
1333
1334 /* USB devio uses 'write' flag to check for async completions */
1335 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1336
1337 return 0;
1338
1339 fail:
1340 trace_usb_host_open_failure(bus_num, addr);
1341 if (dev->fd != -1) {
1342 close(dev->fd);
1343 dev->fd = -1;
1344 }
1345 return -1;
1346 }
1347
1348 static int usb_host_close(USBHostDevice *dev)
1349 {
1350 int i;
1351
1352 if (dev->fd == -1 || !dev->dev.attached) {
1353 return -1;
1354 }
1355
1356 trace_usb_host_close(dev->bus_num, dev->addr);
1357
1358 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1359 dev->closing = 1;
1360 for (i = 1; i <= MAX_ENDPOINTS; i++) {
1361 if (is_isoc(dev, USB_TOKEN_IN, i)) {
1362 usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i);
1363 }
1364 if (is_isoc(dev, USB_TOKEN_OUT, i)) {
1365 usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i);
1366 }
1367 }
1368 async_complete(dev);
1369 dev->closing = 0;
1370 usb_device_detach(&dev->dev);
1371 ioctl(dev->fd, USBDEVFS_RESET);
1372 close(dev->fd);
1373 dev->fd = -1;
1374 return 0;
1375 }
1376
1377 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1378 {
1379 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1380
1381 if (s->fd != -1) {
1382 ioctl(s->fd, USBDEVFS_RESET);
1383 }
1384 }
1385
1386 static int usb_host_initfn(USBDevice *dev)
1387 {
1388 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1389
1390 dev->auto_attach = 0;
1391 s->fd = -1;
1392 s->hub_fd = -1;
1393
1394 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1395 s->exit.notify = usb_host_exit_notifier;
1396 qemu_add_exit_notifier(&s->exit);
1397 usb_host_auto_check(NULL);
1398
1399 if (s->match.bus_num != 0 && s->match.port != NULL) {
1400 usb_host_claim_port(s);
1401 }
1402 return 0;
1403 }
1404
1405 static const VMStateDescription vmstate_usb_host = {
1406 .name = "usb-host",
1407 .unmigratable = 1,
1408 };
1409
1410 static struct USBDeviceInfo usb_host_dev_info = {
1411 .product_desc = "USB Host Device",
1412 .qdev.name = "usb-host",
1413 .qdev.size = sizeof(USBHostDevice),
1414 .qdev.vmsd = &vmstate_usb_host,
1415 .init = usb_host_initfn,
1416 .handle_packet = usb_generic_handle_packet,
1417 .cancel_packet = usb_host_async_cancel,
1418 .handle_data = usb_host_handle_data,
1419 .handle_control = usb_host_handle_control,
1420 .handle_reset = usb_host_handle_reset,
1421 .handle_destroy = usb_host_handle_destroy,
1422 .usbdevice_name = "host",
1423 .usbdevice_init = usb_host_device_open,
1424 .qdev.props = (Property[]) {
1425 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1426 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1427 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1428 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1429 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1430 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1431 DEFINE_PROP_END_OF_LIST(),
1432 },
1433 };
1434
1435 static void usb_host_register_devices(void)
1436 {
1437 usb_qdev_register(&usb_host_dev_info);
1438 }
1439 device_init(usb_host_register_devices)
1440
1441 USBDevice *usb_host_device_open(const char *devname)
1442 {
1443 struct USBAutoFilter filter;
1444 USBDevice *dev;
1445 char *p;
1446
1447 dev = usb_create(NULL /* FIXME */, "usb-host");
1448
1449 if (strstr(devname, "auto:")) {
1450 if (parse_filter(devname, &filter) < 0) {
1451 goto fail;
1452 }
1453 } else {
1454 if ((p = strchr(devname, '.'))) {
1455 filter.bus_num = strtoul(devname, NULL, 0);
1456 filter.addr = strtoul(p + 1, NULL, 0);
1457 filter.vendor_id = 0;
1458 filter.product_id = 0;
1459 } else if ((p = strchr(devname, ':'))) {
1460 filter.bus_num = 0;
1461 filter.addr = 0;
1462 filter.vendor_id = strtoul(devname, NULL, 16);
1463 filter.product_id = strtoul(p + 1, NULL, 16);
1464 } else {
1465 goto fail;
1466 }
1467 }
1468
1469 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1470 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1471 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1472 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1473 qdev_init_nofail(&dev->qdev);
1474 return dev;
1475
1476 fail:
1477 qdev_free(&dev->qdev);
1478 return NULL;
1479 }
1480
1481 int usb_host_device_close(const char *devname)
1482 {
1483 #if 0
1484 char product_name[PRODUCT_NAME_SZ];
1485 int bus_num, addr;
1486 USBHostDevice *s;
1487
1488 if (strstr(devname, "auto:")) {
1489 return usb_host_auto_del(devname);
1490 }
1491 if (usb_host_find_device(&bus_num, &addr, product_name,
1492 sizeof(product_name), devname) < 0) {
1493 return -1;
1494 }
1495 s = hostdev_find(bus_num, addr);
1496 if (s) {
1497 usb_device_delete_addr(s->bus_num, s->dev.addr);
1498 return 0;
1499 }
1500 #endif
1501
1502 return -1;
1503 }
1504
1505 static int get_tag_value(char *buf, int buf_size,
1506 const char *str, const char *tag,
1507 const char *stopchars)
1508 {
1509 const char *p;
1510 char *q;
1511 p = strstr(str, tag);
1512 if (!p) {
1513 return -1;
1514 }
1515 p += strlen(tag);
1516 while (qemu_isspace(*p)) {
1517 p++;
1518 }
1519 q = buf;
1520 while (*p != '\0' && !strchr(stopchars, *p)) {
1521 if ((q - buf) < (buf_size - 1)) {
1522 *q++ = *p;
1523 }
1524 p++;
1525 }
1526 *q = '\0';
1527 return q - buf;
1528 }
1529
1530 /*
1531 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1532 * host's USB devices. This is legacy support since many distributions
1533 * are moving to /sys/bus/usb
1534 */
1535 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1536 {
1537 FILE *f = NULL;
1538 char line[1024];
1539 char buf[1024];
1540 int bus_num, addr, speed, device_count;
1541 int class_id, product_id, vendor_id, port;
1542 char product_name[512];
1543 int ret = 0;
1544
1545 if (!usb_host_device_path) {
1546 perror("husb: USB Host Device Path not set");
1547 goto the_end;
1548 }
1549 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1550 f = fopen(line, "r");
1551 if (!f) {
1552 perror("husb: cannot open devices file");
1553 goto the_end;
1554 }
1555
1556 device_count = 0;
1557 bus_num = addr = class_id = product_id = vendor_id = port = 0;
1558 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1559 for(;;) {
1560 if (fgets(line, sizeof(line), f) == NULL) {
1561 break;
1562 }
1563 if (strlen(line) > 0) {
1564 line[strlen(line) - 1] = '\0';
1565 }
1566 if (line[0] == 'T' && line[1] == ':') {
1567 if (device_count && (vendor_id || product_id)) {
1568 /* New device. Add the previously discovered device. */
1569 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1570 product_id, product_name, speed);
1571 if (ret) {
1572 goto the_end;
1573 }
1574 }
1575 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1576 goto fail;
1577 }
1578 bus_num = atoi(buf);
1579 if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) {
1580 goto fail;
1581 }
1582 port = atoi(buf);
1583 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1584 goto fail;
1585 }
1586 addr = atoi(buf);
1587 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1588 goto fail;
1589 }
1590 if (!strcmp(buf, "5000")) {
1591 speed = USB_SPEED_SUPER;
1592 } else if (!strcmp(buf, "480")) {
1593 speed = USB_SPEED_HIGH;
1594 } else if (!strcmp(buf, "1.5")) {
1595 speed = USB_SPEED_LOW;
1596 } else {
1597 speed = USB_SPEED_FULL;
1598 }
1599 product_name[0] = '\0';
1600 class_id = 0xff;
1601 device_count++;
1602 product_id = 0;
1603 vendor_id = 0;
1604 } else if (line[0] == 'P' && line[1] == ':') {
1605 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1606 goto fail;
1607 }
1608 vendor_id = strtoul(buf, NULL, 16);
1609 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1610 goto fail;
1611 }
1612 product_id = strtoul(buf, NULL, 16);
1613 } else if (line[0] == 'S' && line[1] == ':') {
1614 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1615 goto fail;
1616 }
1617 pstrcpy(product_name, sizeof(product_name), buf);
1618 } else if (line[0] == 'D' && line[1] == ':') {
1619 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1620 goto fail;
1621 }
1622 class_id = strtoul(buf, NULL, 16);
1623 }
1624 fail: ;
1625 }
1626 if (device_count && (vendor_id || product_id)) {
1627 /* Add the last device. */
1628 if (port > 0) {
1629 snprintf(buf, sizeof(buf), "%d", port);
1630 } else {
1631 snprintf(buf, sizeof(buf), "?");
1632 }
1633 ret = func(opaque, bus_num, addr, buf, class_id, vendor_id,
1634 product_id, product_name, speed);
1635 }
1636 the_end:
1637 if (f) {
1638 fclose(f);
1639 }
1640 return ret;
1641 }
1642
1643 /*
1644 * Read sys file-system device file
1645 *
1646 * @line address of buffer to put file contents in
1647 * @line_size size of line
1648 * @device_file path to device file (printf format string)
1649 * @device_name device being opened (inserted into device_file)
1650 *
1651 * @return 0 failed, 1 succeeded ('line' contains data)
1652 */
1653 static int usb_host_read_file(char *line, size_t line_size,
1654 const char *device_file, const char *device_name)
1655 {
1656 FILE *f;
1657 int ret = 0;
1658 char filename[PATH_MAX];
1659
1660 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1661 device_file);
1662 f = fopen(filename, "r");
1663 if (f) {
1664 ret = fgets(line, line_size, f) != NULL;
1665 fclose(f);
1666 }
1667
1668 return ret;
1669 }
1670
1671 /*
1672 * Use /sys/bus/usb/devices/ directory to determine host's USB
1673 * devices.
1674 *
1675 * This code is based on Robert Schiele's original patches posted to
1676 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1677 */
1678 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1679 {
1680 DIR *dir = NULL;
1681 char line[1024];
1682 int bus_num, addr, speed, class_id, product_id, vendor_id;
1683 int ret = 0;
1684 char port[MAX_PORTLEN];
1685 char product_name[512];
1686 struct dirent *de;
1687
1688 dir = opendir(USBSYSBUS_PATH "/devices");
1689 if (!dir) {
1690 perror("husb: cannot open devices directory");
1691 goto the_end;
1692 }
1693
1694 while ((de = readdir(dir))) {
1695 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1696 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1697 continue;
1698 }
1699
1700 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1701 goto the_end;
1702 }
1703 if (sscanf(line, "%d", &addr) != 1) {
1704 goto the_end;
1705 }
1706 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1707 de->d_name)) {
1708 goto the_end;
1709 }
1710 if (sscanf(line, "%x", &class_id) != 1) {
1711 goto the_end;
1712 }
1713
1714 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1715 de->d_name)) {
1716 goto the_end;
1717 }
1718 if (sscanf(line, "%x", &vendor_id) != 1) {
1719 goto the_end;
1720 }
1721 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1722 de->d_name)) {
1723 goto the_end;
1724 }
1725 if (sscanf(line, "%x", &product_id) != 1) {
1726 goto the_end;
1727 }
1728 if (!usb_host_read_file(line, sizeof(line), "product",
1729 de->d_name)) {
1730 *product_name = 0;
1731 } else {
1732 if (strlen(line) > 0) {
1733 line[strlen(line) - 1] = '\0';
1734 }
1735 pstrcpy(product_name, sizeof(product_name), line);
1736 }
1737
1738 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1739 goto the_end;
1740 }
1741 if (!strcmp(line, "5000\n")) {
1742 speed = USB_SPEED_SUPER;
1743 } else if (!strcmp(line, "480\n")) {
1744 speed = USB_SPEED_HIGH;
1745 } else if (!strcmp(line, "1.5\n")) {
1746 speed = USB_SPEED_LOW;
1747 } else {
1748 speed = USB_SPEED_FULL;
1749 }
1750
1751 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1752 product_id, product_name, speed);
1753 if (ret) {
1754 goto the_end;
1755 }
1756 }
1757 }
1758 the_end:
1759 if (dir) {
1760 closedir(dir);
1761 }
1762 return ret;
1763 }
1764
1765 /*
1766 * Determine how to access the host's USB devices and call the
1767 * specific support function.
1768 */
1769 static int usb_host_scan(void *opaque, USBScanFunc *func)
1770 {
1771 Monitor *mon = cur_mon;
1772 FILE *f = NULL;
1773 DIR *dir = NULL;
1774 int ret = 0;
1775 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1776 char devpath[PATH_MAX];
1777
1778 /* only check the host once */
1779 if (!usb_fs_type) {
1780 dir = opendir(USBSYSBUS_PATH "/devices");
1781 if (dir) {
1782 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1783 strcpy(devpath, USBDEVBUS_PATH);
1784 usb_fs_type = USB_FS_SYS;
1785 closedir(dir);
1786 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1787 goto found_devices;
1788 }
1789 f = fopen(USBPROCBUS_PATH "/devices", "r");
1790 if (f) {
1791 /* devices found in /proc/bus/usb/ */
1792 strcpy(devpath, USBPROCBUS_PATH);
1793 usb_fs_type = USB_FS_PROC;
1794 fclose(f);
1795 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1796 goto found_devices;
1797 }
1798 /* try additional methods if an access method hasn't been found yet */
1799 f = fopen(USBDEVBUS_PATH "/devices", "r");
1800 if (f) {
1801 /* devices found in /dev/bus/usb/ */
1802 strcpy(devpath, USBDEVBUS_PATH);
1803 usb_fs_type = USB_FS_DEV;
1804 fclose(f);
1805 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1806 goto found_devices;
1807 }
1808 found_devices:
1809 if (!usb_fs_type) {
1810 if (mon) {
1811 monitor_printf(mon, "husb: unable to access USB devices\n");
1812 }
1813 return -ENOENT;
1814 }
1815
1816 /* the module setting (used later for opening devices) */
1817 usb_host_device_path = g_malloc0(strlen(devpath)+1);
1818 strcpy(usb_host_device_path, devpath);
1819 if (mon) {
1820 monitor_printf(mon, "husb: using %s file-system with %s\n",
1821 fs_type[usb_fs_type], usb_host_device_path);
1822 }
1823 }
1824
1825 switch (usb_fs_type) {
1826 case USB_FS_PROC:
1827 case USB_FS_DEV:
1828 ret = usb_host_scan_dev(opaque, func);
1829 break;
1830 case USB_FS_SYS:
1831 ret = usb_host_scan_sys(opaque, func);
1832 break;
1833 default:
1834 ret = -EINVAL;
1835 break;
1836 }
1837 return ret;
1838 }
1839
1840 static QEMUTimer *usb_auto_timer;
1841
1842 static int usb_host_auto_scan(void *opaque, int bus_num,
1843 int addr, const char *port,
1844 int class_id, int vendor_id, int product_id,
1845 const char *product_name, int speed)
1846 {
1847 struct USBAutoFilter *f;
1848 struct USBHostDevice *s;
1849
1850 /* Ignore hubs */
1851 if (class_id == 9)
1852 return 0;
1853
1854 QTAILQ_FOREACH(s, &hostdevs, next) {
1855 f = &s->match;
1856
1857 if (f->bus_num > 0 && f->bus_num != bus_num) {
1858 continue;
1859 }
1860 if (f->addr > 0 && f->addr != addr) {
1861 continue;
1862 }
1863 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1864 continue;
1865 }
1866
1867 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1868 continue;
1869 }
1870
1871 if (f->product_id > 0 && f->product_id != product_id) {
1872 continue;
1873 }
1874 /* We got a match */
1875 s->seen++;
1876 if (s->errcount >= 3) {
1877 return 0;
1878 }
1879
1880 /* Already attached ? */
1881 if (s->fd != -1) {
1882 return 0;
1883 }
1884 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1885
1886 if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1887 s->errcount++;
1888 }
1889 break;
1890 }
1891
1892 return 0;
1893 }
1894
1895 static void usb_host_auto_check(void *unused)
1896 {
1897 struct USBHostDevice *s;
1898 int unconnected = 0;
1899
1900 usb_host_scan(NULL, usb_host_auto_scan);
1901
1902 QTAILQ_FOREACH(s, &hostdevs, next) {
1903 if (s->fd == -1) {
1904 unconnected++;
1905 }
1906 if (s->seen == 0) {
1907 s->errcount = 0;
1908 }
1909 s->seen = 0;
1910 }
1911
1912 if (unconnected == 0) {
1913 /* nothing to watch */
1914 if (usb_auto_timer) {
1915 qemu_del_timer(usb_auto_timer);
1916 trace_usb_host_auto_scan_disabled();
1917 }
1918 return;
1919 }
1920
1921 if (!usb_auto_timer) {
1922 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1923 if (!usb_auto_timer) {
1924 return;
1925 }
1926 trace_usb_host_auto_scan_enabled();
1927 }
1928 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1929 }
1930
1931 /*
1932 * Autoconnect filter
1933 * Format:
1934 * auto:bus:dev[:vid:pid]
1935 * auto:bus.dev[:vid:pid]
1936 *
1937 * bus - bus number (dec, * means any)
1938 * dev - device number (dec, * means any)
1939 * vid - vendor id (hex, * means any)
1940 * pid - product id (hex, * means any)
1941 *
1942 * See 'lsusb' output.
1943 */
1944 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1945 {
1946 enum { BUS, DEV, VID, PID, DONE };
1947 const char *p = spec;
1948 int i;
1949
1950 f->bus_num = 0;
1951 f->addr = 0;
1952 f->vendor_id = 0;
1953 f->product_id = 0;
1954
1955 for (i = BUS; i < DONE; i++) {
1956 p = strpbrk(p, ":.");
1957 if (!p) {
1958 break;
1959 }
1960 p++;
1961
1962 if (*p == '*') {
1963 continue;
1964 }
1965 switch(i) {
1966 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1967 case DEV: f->addr = strtol(p, NULL, 10); break;
1968 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1969 case PID: f->product_id = strtol(p, NULL, 16); break;
1970 }
1971 }
1972
1973 if (i < DEV) {
1974 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1975 return -1;
1976 }
1977
1978 return 0;
1979 }
1980
1981 /**********************/
1982 /* USB host device info */
1983
1984 struct usb_class_info {
1985 int class;
1986 const char *class_name;
1987 };
1988
1989 static const struct usb_class_info usb_class_info[] = {
1990 { USB_CLASS_AUDIO, "Audio"},
1991 { USB_CLASS_COMM, "Communication"},
1992 { USB_CLASS_HID, "HID"},
1993 { USB_CLASS_HUB, "Hub" },
1994 { USB_CLASS_PHYSICAL, "Physical" },
1995 { USB_CLASS_PRINTER, "Printer" },
1996 { USB_CLASS_MASS_STORAGE, "Storage" },
1997 { USB_CLASS_CDC_DATA, "Data" },
1998 { USB_CLASS_APP_SPEC, "Application Specific" },
1999 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
2000 { USB_CLASS_STILL_IMAGE, "Still Image" },
2001 { USB_CLASS_CSCID, "Smart Card" },
2002 { USB_CLASS_CONTENT_SEC, "Content Security" },
2003 { -1, NULL }
2004 };
2005
2006 static const char *usb_class_str(uint8_t class)
2007 {
2008 const struct usb_class_info *p;
2009 for(p = usb_class_info; p->class != -1; p++) {
2010 if (p->class == class) {
2011 break;
2012 }
2013 }
2014 return p->class_name;
2015 }
2016
2017 static void usb_info_device(Monitor *mon, int bus_num,
2018 int addr, const char *port,
2019 int class_id, int vendor_id, int product_id,
2020 const char *product_name,
2021 int speed)
2022 {
2023 const char *class_str, *speed_str;
2024
2025 switch(speed) {
2026 case USB_SPEED_LOW:
2027 speed_str = "1.5";
2028 break;
2029 case USB_SPEED_FULL:
2030 speed_str = "12";
2031 break;
2032 case USB_SPEED_HIGH:
2033 speed_str = "480";
2034 break;
2035 case USB_SPEED_SUPER:
2036 speed_str = "5000";
2037 break;
2038 default:
2039 speed_str = "?";
2040 break;
2041 }
2042
2043 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
2044 bus_num, addr, port, speed_str);
2045 class_str = usb_class_str(class_id);
2046 if (class_str) {
2047 monitor_printf(mon, " %s:", class_str);
2048 } else {
2049 monitor_printf(mon, " Class %02x:", class_id);
2050 }
2051 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
2052 if (product_name[0] != '\0') {
2053 monitor_printf(mon, ", %s", product_name);
2054 }
2055 monitor_printf(mon, "\n");
2056 }
2057
2058 static int usb_host_info_device(void *opaque, int bus_num, int addr,
2059 const char *path, int class_id,
2060 int vendor_id, int product_id,
2061 const char *product_name,
2062 int speed)
2063 {
2064 Monitor *mon = opaque;
2065
2066 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
2067 product_name, speed);
2068 return 0;
2069 }
2070
2071 static void dec2str(int val, char *str, size_t size)
2072 {
2073 if (val == 0) {
2074 snprintf(str, size, "*");
2075 } else {
2076 snprintf(str, size, "%d", val);
2077 }
2078 }
2079
2080 static void hex2str(int val, char *str, size_t size)
2081 {
2082 if (val == 0) {
2083 snprintf(str, size, "*");
2084 } else {
2085 snprintf(str, size, "%04x", val);
2086 }
2087 }
2088
2089 void usb_host_info(Monitor *mon)
2090 {
2091 struct USBAutoFilter *f;
2092 struct USBHostDevice *s;
2093
2094 usb_host_scan(mon, usb_host_info_device);
2095
2096 if (QTAILQ_EMPTY(&hostdevs)) {
2097 return;
2098 }
2099
2100 monitor_printf(mon, " Auto filters:\n");
2101 QTAILQ_FOREACH(s, &hostdevs, next) {
2102 char bus[10], addr[10], vid[10], pid[10];
2103 f = &s->match;
2104 dec2str(f->bus_num, bus, sizeof(bus));
2105 dec2str(f->addr, addr, sizeof(addr));
2106 hex2str(f->vendor_id, vid, sizeof(vid));
2107 hex2str(f->product_id, pid, sizeof(pid));
2108 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
2109 bus, addr, f->port ? f->port : "*", vid, pid);
2110 }
2111 }
QEMU Monitor Protocol