?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hw/omap_dss.c: Fix !-vs-~ bug in handling DISPC_CONTROL
[qemu/qmp-unstable.git] / usb-linux.c
blobf086d57edbc774b7ed9ff2c5cea698259a46ca55
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) {
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 if (dev->dev.attached) {
1371 usb_device_detach(&dev->dev);
1372 }
1373 ioctl(dev->fd, USBDEVFS_RESET);
1374 close(dev->fd);
1375 dev->fd = -1;
1376 return 0;
1377 }
1378
1379 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1380 {
1381 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1382
1383 if (s->fd != -1) {
1384 ioctl(s->fd, USBDEVFS_RESET);
1385 }
1386 }
1387
1388 static int usb_host_initfn(USBDevice *dev)
1389 {
1390 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1391
1392 dev->auto_attach = 0;
1393 s->fd = -1;
1394 s->hub_fd = -1;
1395
1396 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1397 s->exit.notify = usb_host_exit_notifier;
1398 qemu_add_exit_notifier(&s->exit);
1399 usb_host_auto_check(NULL);
1400
1401 if (s->match.bus_num != 0 && s->match.port != NULL) {
1402 usb_host_claim_port(s);
1403 }
1404 return 0;
1405 }
1406
1407 static const VMStateDescription vmstate_usb_host = {
1408 .name = "usb-host",
1409 .unmigratable = 1,
1410 };
1411
1412 static struct USBDeviceInfo usb_host_dev_info = {
1413 .product_desc = "USB Host Device",
1414 .qdev.name = "usb-host",
1415 .qdev.size = sizeof(USBHostDevice),
1416 .qdev.vmsd = &vmstate_usb_host,
1417 .init = usb_host_initfn,
1418 .handle_packet = usb_generic_handle_packet,
1419 .cancel_packet = usb_host_async_cancel,
1420 .handle_data = usb_host_handle_data,
1421 .handle_control = usb_host_handle_control,
1422 .handle_reset = usb_host_handle_reset,
1423 .handle_destroy = usb_host_handle_destroy,
1424 .usbdevice_name = "host",
1425 .usbdevice_init = usb_host_device_open,
1426 .qdev.props = (Property[]) {
1427 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1428 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1429 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1430 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1431 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1432 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1433 DEFINE_PROP_END_OF_LIST(),
1434 },
1435 };
1436
1437 static void usb_host_register_devices(void)
1438 {
1439 usb_qdev_register(&usb_host_dev_info);
1440 }
1441 device_init(usb_host_register_devices)
1442
1443 USBDevice *usb_host_device_open(const char *devname)
1444 {
1445 struct USBAutoFilter filter;
1446 USBDevice *dev;
1447 char *p;
1448
1449 dev = usb_create(NULL /* FIXME */, "usb-host");
1450
1451 if (strstr(devname, "auto:")) {
1452 if (parse_filter(devname, &filter) < 0) {
1453 goto fail;
1454 }
1455 } else {
1456 if ((p = strchr(devname, '.'))) {
1457 filter.bus_num = strtoul(devname, NULL, 0);
1458 filter.addr = strtoul(p + 1, NULL, 0);
1459 filter.vendor_id = 0;
1460 filter.product_id = 0;
1461 } else if ((p = strchr(devname, ':'))) {
1462 filter.bus_num = 0;
1463 filter.addr = 0;
1464 filter.vendor_id = strtoul(devname, NULL, 16);
1465 filter.product_id = strtoul(p + 1, NULL, 16);
1466 } else {
1467 goto fail;
1468 }
1469 }
1470
1471 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1472 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1473 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1474 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1475 qdev_init_nofail(&dev->qdev);
1476 return dev;
1477
1478 fail:
1479 qdev_free(&dev->qdev);
1480 return NULL;
1481 }
1482
1483 int usb_host_device_close(const char *devname)
1484 {
1485 #if 0
1486 char product_name[PRODUCT_NAME_SZ];
1487 int bus_num, addr;
1488 USBHostDevice *s;
1489
1490 if (strstr(devname, "auto:")) {
1491 return usb_host_auto_del(devname);
1492 }
1493 if (usb_host_find_device(&bus_num, &addr, product_name,
1494 sizeof(product_name), devname) < 0) {
1495 return -1;
1496 }
1497 s = hostdev_find(bus_num, addr);
1498 if (s) {
1499 usb_device_delete_addr(s->bus_num, s->dev.addr);
1500 return 0;
1501 }
1502 #endif
1503
1504 return -1;
1505 }
1506
1507 static int get_tag_value(char *buf, int buf_size,
1508 const char *str, const char *tag,
1509 const char *stopchars)
1510 {
1511 const char *p;
1512 char *q;
1513 p = strstr(str, tag);
1514 if (!p) {
1515 return -1;
1516 }
1517 p += strlen(tag);
1518 while (qemu_isspace(*p)) {
1519 p++;
1520 }
1521 q = buf;
1522 while (*p != '\0' && !strchr(stopchars, *p)) {
1523 if ((q - buf) < (buf_size - 1)) {
1524 *q++ = *p;
1525 }
1526 p++;
1527 }
1528 *q = '\0';
1529 return q - buf;
1530 }
1531
1532 /*
1533 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1534 * host's USB devices. This is legacy support since many distributions
1535 * are moving to /sys/bus/usb
1536 */
1537 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1538 {
1539 FILE *f = NULL;
1540 char line[1024];
1541 char buf[1024];
1542 int bus_num, addr, speed, device_count;
1543 int class_id, product_id, vendor_id, port;
1544 char product_name[512];
1545 int ret = 0;
1546
1547 if (!usb_host_device_path) {
1548 perror("husb: USB Host Device Path not set");
1549 goto the_end;
1550 }
1551 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1552 f = fopen(line, "r");
1553 if (!f) {
1554 perror("husb: cannot open devices file");
1555 goto the_end;
1556 }
1557
1558 device_count = 0;
1559 bus_num = addr = class_id = product_id = vendor_id = port = 0;
1560 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1561 for(;;) {
1562 if (fgets(line, sizeof(line), f) == NULL) {
1563 break;
1564 }
1565 if (strlen(line) > 0) {
1566 line[strlen(line) - 1] = '\0';
1567 }
1568 if (line[0] == 'T' && line[1] == ':') {
1569 if (device_count && (vendor_id || product_id)) {
1570 /* New device. Add the previously discovered device. */
1571 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1572 product_id, product_name, speed);
1573 if (ret) {
1574 goto the_end;
1575 }
1576 }
1577 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1578 goto fail;
1579 }
1580 bus_num = atoi(buf);
1581 if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) {
1582 goto fail;
1583 }
1584 port = atoi(buf);
1585 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1586 goto fail;
1587 }
1588 addr = atoi(buf);
1589 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1590 goto fail;
1591 }
1592 if (!strcmp(buf, "5000")) {
1593 speed = USB_SPEED_SUPER;
1594 } else if (!strcmp(buf, "480")) {
1595 speed = USB_SPEED_HIGH;
1596 } else if (!strcmp(buf, "1.5")) {
1597 speed = USB_SPEED_LOW;
1598 } else {
1599 speed = USB_SPEED_FULL;
1600 }
1601 product_name[0] = '\0';
1602 class_id = 0xff;
1603 device_count++;
1604 product_id = 0;
1605 vendor_id = 0;
1606 } else if (line[0] == 'P' && line[1] == ':') {
1607 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1608 goto fail;
1609 }
1610 vendor_id = strtoul(buf, NULL, 16);
1611 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1612 goto fail;
1613 }
1614 product_id = strtoul(buf, NULL, 16);
1615 } else if (line[0] == 'S' && line[1] == ':') {
1616 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1617 goto fail;
1618 }
1619 pstrcpy(product_name, sizeof(product_name), buf);
1620 } else if (line[0] == 'D' && line[1] == ':') {
1621 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1622 goto fail;
1623 }
1624 class_id = strtoul(buf, NULL, 16);
1625 }
1626 fail: ;
1627 }
1628 if (device_count && (vendor_id || product_id)) {
1629 /* Add the last device. */
1630 if (port > 0) {
1631 snprintf(buf, sizeof(buf), "%d", port);
1632 } else {
1633 snprintf(buf, sizeof(buf), "?");
1634 }
1635 ret = func(opaque, bus_num, addr, buf, class_id, vendor_id,
1636 product_id, product_name, speed);
1637 }
1638 the_end:
1639 if (f) {
1640 fclose(f);
1641 }
1642 return ret;
1643 }
1644
1645 /*
1646 * Read sys file-system device file
1647 *
1648 * @line address of buffer to put file contents in
1649 * @line_size size of line
1650 * @device_file path to device file (printf format string)
1651 * @device_name device being opened (inserted into device_file)
1652 *
1653 * @return 0 failed, 1 succeeded ('line' contains data)
1654 */
1655 static int usb_host_read_file(char *line, size_t line_size,
1656 const char *device_file, const char *device_name)
1657 {
1658 FILE *f;
1659 int ret = 0;
1660 char filename[PATH_MAX];
1661
1662 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1663 device_file);
1664 f = fopen(filename, "r");
1665 if (f) {
1666 ret = fgets(line, line_size, f) != NULL;
1667 fclose(f);
1668 }
1669
1670 return ret;
1671 }
1672
1673 /*
1674 * Use /sys/bus/usb/devices/ directory to determine host's USB
1675 * devices.
1676 *
1677 * This code is based on Robert Schiele's original patches posted to
1678 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1679 */
1680 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1681 {
1682 DIR *dir = NULL;
1683 char line[1024];
1684 int bus_num, addr, speed, class_id, product_id, vendor_id;
1685 int ret = 0;
1686 char port[MAX_PORTLEN];
1687 char product_name[512];
1688 struct dirent *de;
1689
1690 dir = opendir(USBSYSBUS_PATH "/devices");
1691 if (!dir) {
1692 perror("husb: cannot open devices directory");
1693 goto the_end;
1694 }
1695
1696 while ((de = readdir(dir))) {
1697 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1698 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1699 continue;
1700 }
1701
1702 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1703 goto the_end;
1704 }
1705 if (sscanf(line, "%d", &addr) != 1) {
1706 goto the_end;
1707 }
1708 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1709 de->d_name)) {
1710 goto the_end;
1711 }
1712 if (sscanf(line, "%x", &class_id) != 1) {
1713 goto the_end;
1714 }
1715
1716 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1717 de->d_name)) {
1718 goto the_end;
1719 }
1720 if (sscanf(line, "%x", &vendor_id) != 1) {
1721 goto the_end;
1722 }
1723 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1724 de->d_name)) {
1725 goto the_end;
1726 }
1727 if (sscanf(line, "%x", &product_id) != 1) {
1728 goto the_end;
1729 }
1730 if (!usb_host_read_file(line, sizeof(line), "product",
1731 de->d_name)) {
1732 *product_name = 0;
1733 } else {
1734 if (strlen(line) > 0) {
1735 line[strlen(line) - 1] = '\0';
1736 }
1737 pstrcpy(product_name, sizeof(product_name), line);
1738 }
1739
1740 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1741 goto the_end;
1742 }
1743 if (!strcmp(line, "5000\n")) {
1744 speed = USB_SPEED_SUPER;
1745 } else if (!strcmp(line, "480\n")) {
1746 speed = USB_SPEED_HIGH;
1747 } else if (!strcmp(line, "1.5\n")) {
1748 speed = USB_SPEED_LOW;
1749 } else {
1750 speed = USB_SPEED_FULL;
1751 }
1752
1753 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1754 product_id, product_name, speed);
1755 if (ret) {
1756 goto the_end;
1757 }
1758 }
1759 }
1760 the_end:
1761 if (dir) {
1762 closedir(dir);
1763 }
1764 return ret;
1765 }
1766
1767 /*
1768 * Determine how to access the host's USB devices and call the
1769 * specific support function.
1770 */
1771 static int usb_host_scan(void *opaque, USBScanFunc *func)
1772 {
1773 Monitor *mon = cur_mon;
1774 FILE *f = NULL;
1775 DIR *dir = NULL;
1776 int ret = 0;
1777 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1778 char devpath[PATH_MAX];
1779
1780 /* only check the host once */
1781 if (!usb_fs_type) {
1782 dir = opendir(USBSYSBUS_PATH "/devices");
1783 if (dir) {
1784 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1785 strcpy(devpath, USBDEVBUS_PATH);
1786 usb_fs_type = USB_FS_SYS;
1787 closedir(dir);
1788 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1789 goto found_devices;
1790 }
1791 f = fopen(USBPROCBUS_PATH "/devices", "r");
1792 if (f) {
1793 /* devices found in /proc/bus/usb/ */
1794 strcpy(devpath, USBPROCBUS_PATH);
1795 usb_fs_type = USB_FS_PROC;
1796 fclose(f);
1797 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1798 goto found_devices;
1799 }
1800 /* try additional methods if an access method hasn't been found yet */
1801 f = fopen(USBDEVBUS_PATH "/devices", "r");
1802 if (f) {
1803 /* devices found in /dev/bus/usb/ */
1804 strcpy(devpath, USBDEVBUS_PATH);
1805 usb_fs_type = USB_FS_DEV;
1806 fclose(f);
1807 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1808 goto found_devices;
1809 }
1810 found_devices:
1811 if (!usb_fs_type) {
1812 if (mon) {
1813 monitor_printf(mon, "husb: unable to access USB devices\n");
1814 }
1815 return -ENOENT;
1816 }
1817
1818 /* the module setting (used later for opening devices) */
1819 usb_host_device_path = g_malloc0(strlen(devpath)+1);
1820 strcpy(usb_host_device_path, devpath);
1821 if (mon) {
1822 monitor_printf(mon, "husb: using %s file-system with %s\n",
1823 fs_type[usb_fs_type], usb_host_device_path);
1824 }
1825 }
1826
1827 switch (usb_fs_type) {
1828 case USB_FS_PROC:
1829 case USB_FS_DEV:
1830 ret = usb_host_scan_dev(opaque, func);
1831 break;
1832 case USB_FS_SYS:
1833 ret = usb_host_scan_sys(opaque, func);
1834 break;
1835 default:
1836 ret = -EINVAL;
1837 break;
1838 }
1839 return ret;
1840 }
1841
1842 static QEMUTimer *usb_auto_timer;
1843
1844 static int usb_host_auto_scan(void *opaque, int bus_num,
1845 int addr, const char *port,
1846 int class_id, int vendor_id, int product_id,
1847 const char *product_name, int speed)
1848 {
1849 struct USBAutoFilter *f;
1850 struct USBHostDevice *s;
1851
1852 /* Ignore hubs */
1853 if (class_id == 9)
1854 return 0;
1855
1856 QTAILQ_FOREACH(s, &hostdevs, next) {
1857 f = &s->match;
1858
1859 if (f->bus_num > 0 && f->bus_num != bus_num) {
1860 continue;
1861 }
1862 if (f->addr > 0 && f->addr != addr) {
1863 continue;
1864 }
1865 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1866 continue;
1867 }
1868
1869 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1870 continue;
1871 }
1872
1873 if (f->product_id > 0 && f->product_id != product_id) {
1874 continue;
1875 }
1876 /* We got a match */
1877 s->seen++;
1878 if (s->errcount >= 3) {
1879 return 0;
1880 }
1881
1882 /* Already attached ? */
1883 if (s->fd != -1) {
1884 return 0;
1885 }
1886 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1887
1888 if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1889 s->errcount++;
1890 }
1891 break;
1892 }
1893
1894 return 0;
1895 }
1896
1897 static void usb_host_auto_check(void *unused)
1898 {
1899 struct USBHostDevice *s;
1900 int unconnected = 0;
1901
1902 usb_host_scan(NULL, usb_host_auto_scan);
1903
1904 QTAILQ_FOREACH(s, &hostdevs, next) {
1905 if (s->fd == -1) {
1906 unconnected++;
1907 }
1908 if (s->seen == 0) {
1909 s->errcount = 0;
1910 }
1911 s->seen = 0;
1912 }
1913
1914 if (unconnected == 0) {
1915 /* nothing to watch */
1916 if (usb_auto_timer) {
1917 qemu_del_timer(usb_auto_timer);
1918 trace_usb_host_auto_scan_disabled();
1919 }
1920 return;
1921 }
1922
1923 if (!usb_auto_timer) {
1924 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1925 if (!usb_auto_timer) {
1926 return;
1927 }
1928 trace_usb_host_auto_scan_enabled();
1929 }
1930 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1931 }
1932
1933 /*
1934 * Autoconnect filter
1935 * Format:
1936 * auto:bus:dev[:vid:pid]
1937 * auto:bus.dev[:vid:pid]
1938 *
1939 * bus - bus number (dec, * means any)
1940 * dev - device number (dec, * means any)
1941 * vid - vendor id (hex, * means any)
1942 * pid - product id (hex, * means any)
1943 *
1944 * See 'lsusb' output.
1945 */
1946 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1947 {
1948 enum { BUS, DEV, VID, PID, DONE };
1949 const char *p = spec;
1950 int i;
1951
1952 f->bus_num = 0;
1953 f->addr = 0;
1954 f->vendor_id = 0;
1955 f->product_id = 0;
1956
1957 for (i = BUS; i < DONE; i++) {
1958 p = strpbrk(p, ":.");
1959 if (!p) {
1960 break;
1961 }
1962 p++;
1963
1964 if (*p == '*') {
1965 continue;
1966 }
1967 switch(i) {
1968 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1969 case DEV: f->addr = strtol(p, NULL, 10); break;
1970 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1971 case PID: f->product_id = strtol(p, NULL, 16); break;
1972 }
1973 }
1974
1975 if (i < DEV) {
1976 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1977 return -1;
1978 }
1979
1980 return 0;
1981 }
1982
1983 /**********************/
1984 /* USB host device info */
1985
1986 struct usb_class_info {
1987 int class;
1988 const char *class_name;
1989 };
1990
1991 static const struct usb_class_info usb_class_info[] = {
1992 { USB_CLASS_AUDIO, "Audio"},
1993 { USB_CLASS_COMM, "Communication"},
1994 { USB_CLASS_HID, "HID"},
1995 { USB_CLASS_HUB, "Hub" },
1996 { USB_CLASS_PHYSICAL, "Physical" },
1997 { USB_CLASS_PRINTER, "Printer" },
1998 { USB_CLASS_MASS_STORAGE, "Storage" },
1999 { USB_CLASS_CDC_DATA, "Data" },
2000 { USB_CLASS_APP_SPEC, "Application Specific" },
2001 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
2002 { USB_CLASS_STILL_IMAGE, "Still Image" },
2003 { USB_CLASS_CSCID, "Smart Card" },
2004 { USB_CLASS_CONTENT_SEC, "Content Security" },
2005 { -1, NULL }
2006 };
2007
2008 static const char *usb_class_str(uint8_t class)
2009 {
2010 const struct usb_class_info *p;
2011 for(p = usb_class_info; p->class != -1; p++) {
2012 if (p->class == class) {
2013 break;
2014 }
2015 }
2016 return p->class_name;
2017 }
2018
2019 static void usb_info_device(Monitor *mon, int bus_num,
2020 int addr, const char *port,
2021 int class_id, int vendor_id, int product_id,
2022 const char *product_name,
2023 int speed)
2024 {
2025 const char *class_str, *speed_str;
2026
2027 switch(speed) {
2028 case USB_SPEED_LOW:
2029 speed_str = "1.5";
2030 break;
2031 case USB_SPEED_FULL:
2032 speed_str = "12";
2033 break;
2034 case USB_SPEED_HIGH:
2035 speed_str = "480";
2036 break;
2037 case USB_SPEED_SUPER:
2038 speed_str = "5000";
2039 break;
2040 default:
2041 speed_str = "?";
2042 break;
2043 }
2044
2045 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
2046 bus_num, addr, port, speed_str);
2047 class_str = usb_class_str(class_id);
2048 if (class_str) {
2049 monitor_printf(mon, " %s:", class_str);
2050 } else {
2051 monitor_printf(mon, " Class %02x:", class_id);
2052 }
2053 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
2054 if (product_name[0] != '\0') {
2055 monitor_printf(mon, ", %s", product_name);
2056 }
2057 monitor_printf(mon, "\n");
2058 }
2059
2060 static int usb_host_info_device(void *opaque, int bus_num, int addr,
2061 const char *path, int class_id,
2062 int vendor_id, int product_id,
2063 const char *product_name,
2064 int speed)
2065 {
2066 Monitor *mon = opaque;
2067
2068 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
2069 product_name, speed);
2070 return 0;
2071 }
2072
2073 static void dec2str(int val, char *str, size_t size)
2074 {
2075 if (val == 0) {
2076 snprintf(str, size, "*");
2077 } else {
2078 snprintf(str, size, "%d", val);
2079 }
2080 }
2081
2082 static void hex2str(int val, char *str, size_t size)
2083 {
2084 if (val == 0) {
2085 snprintf(str, size, "*");
2086 } else {
2087 snprintf(str, size, "%04x", val);
2088 }
2089 }
2090
2091 void usb_host_info(Monitor *mon)
2092 {
2093 struct USBAutoFilter *f;
2094 struct USBHostDevice *s;
2095
2096 usb_host_scan(mon, usb_host_info_device);
2097
2098 if (QTAILQ_EMPTY(&hostdevs)) {
2099 return;
2100 }
2101
2102 monitor_printf(mon, " Auto filters:\n");
2103 QTAILQ_FOREACH(s, &hostdevs, next) {
2104 char bus[10], addr[10], vid[10], pid[10];
2105 f = &s->match;
2106 dec2str(f->bus_num, bus, sizeof(bus));
2107 dec2str(f->addr, addr, sizeof(addr));
2108 hex2str(f->vendor_id, vid, sizeof(vid));
2109 hex2str(f->product_id, pid, sizeof(pid));
2110 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
2111 bus, addr, f->port ? f->port : "*", vid, pid);
2112 }
2113 }
QEMU Monitor Protocol