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