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