?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
slirp: Fix unusual "comments" in unused code
[qemu/qmp-unstable.git] / usb-linux.c
blob53cc5fc00eba5b2a361939c7abf58ac960709eee
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->len += aurb->urb.actual_length;
345 break;
346
347 case -EPIPE:
348 set_halt(s, p->devep);
349 p->len = USB_RET_STALL;
350 break;
351
352 default:
353 p->len = 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
608 max_packet_size = get_max_packet_size(s, p->devep);
609 if (max_packet_size == 0)
610 return USB_RET_NAK;
611
612 aurb = get_iso_urb(s, p->devep);
613 if (!aurb) {
614 aurb = usb_host_alloc_iso(s, p->devep, in);
615 }
616
617 i = get_iso_urb_idx(s, p->devep);
618 j = aurb[i].iso_frame_idx;
619 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
620 if (in) {
621 /* Check urb status */
622 if (aurb[i].urb.status) {
623 len = urb_status_to_usb_ret(aurb[i].urb.status);
624 /* Move to the next urb */
625 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
626 /* Check frame status */
627 } else if (aurb[i].urb.iso_frame_desc[j].status) {
628 len = urb_status_to_usb_ret(
629 aurb[i].urb.iso_frame_desc[j].status);
630 /* Check the frame fits */
631 } else if (aurb[i].urb.iso_frame_desc[j].actual_length > p->len) {
632 printf("husb: received iso data is larger then packet\n");
633 len = USB_RET_NAK;
634 /* All good copy data over */
635 } else {
636 len = aurb[i].urb.iso_frame_desc[j].actual_length;
637 memcpy(p->data,
638 aurb[i].urb.buffer +
639 j * aurb[i].urb.iso_frame_desc[0].length,
640 len);
641 }
642 } else {
643 len = p->len;
644 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->devep);
645
646 /* Check the frame fits */
647 if (len > max_packet_size) {
648 printf("husb: send iso data is larger then max packet size\n");
649 return USB_RET_NAK;
650 }
651
652 /* All good copy data over */
653 memcpy(aurb[i].urb.buffer + offset, p->data, len);
654 aurb[i].urb.iso_frame_desc[j].length = len;
655 offset += len;
656 set_iso_buffer_used(s, p->devep, offset);
657
658 /* Start the stream once we have buffered enough data */
659 if (!is_iso_started(s, p->devep) && i == 1 && j == 8) {
660 set_iso_started(s, p->devep);
661 }
662 }
663 aurb[i].iso_frame_idx++;
664 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
665 i = (i + 1) % s->iso_urb_count;
666 set_iso_urb_idx(s, p->devep, i);
667 }
668 } else {
669 if (in) {
670 set_iso_started(s, p->devep);
671 } else {
672 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
673 }
674 }
675
676 if (is_iso_started(s, p->devep)) {
677 /* (Re)-submit all fully consumed / filled urbs */
678 for (i = 0; i < s->iso_urb_count; i++) {
679 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
680 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
681 if (ret < 0) {
682 printf("husb error submitting iso urb %d: %d\n", i, errno);
683 if (!in || len == 0) {
684 switch(errno) {
685 case ETIMEDOUT:
686 len = USB_RET_NAK;
687 break;
688 case EPIPE:
689 default:
690 len = USB_RET_STALL;
691 }
692 }
693 break;
694 }
695 aurb[i].iso_frame_idx = -1;
696 change_iso_inflight(s, p->devep, +1);
697 }
698 }
699 }
700
701 return len;
702 }
703
704 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
705 {
706 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
707 struct usbdevfs_urb *urb;
708 AsyncURB *aurb;
709 int ret, rem;
710 uint8_t *pbuf;
711 uint8_t ep;
712
713 if (!is_valid(s, p->devep)) {
714 return USB_RET_NAK;
715 }
716
717 if (p->pid == USB_TOKEN_IN) {
718 ep = p->devep | 0x80;
719 } else {
720 ep = p->devep;
721 }
722
723 if (is_halted(s, p->devep)) {
724 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &ep);
725 if (ret < 0) {
726 DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",
727 ep, errno);
728 return USB_RET_NAK;
729 }
730 clear_halt(s, p->devep);
731 }
732
733 if (is_isoc(s, p->devep)) {
734 return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
735 }
736
737 rem = p->len;
738 pbuf = p->data;
739 p->len = 0;
740 while (rem) {
741 aurb = async_alloc(s);
742 aurb->packet = p;
743
744 urb = &aurb->urb;
745 urb->endpoint = ep;
746 urb->type = USBDEVFS_URB_TYPE_BULK;
747 urb->usercontext = s;
748 urb->buffer = pbuf;
749
750 if (rem > MAX_USBFS_BUFFER_SIZE) {
751 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
752 aurb->more = 1;
753 } else {
754 urb->buffer_length = rem;
755 aurb->more = 0;
756 }
757 pbuf += urb->buffer_length;
758 rem -= urb->buffer_length;
759
760 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
761
762 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
763 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
764
765 if (ret < 0) {
766 DPRINTF("husb: submit failed. errno %d\n", errno);
767 async_free(aurb);
768
769 switch(errno) {
770 case ETIMEDOUT:
771 return USB_RET_NAK;
772 case EPIPE:
773 default:
774 return USB_RET_STALL;
775 }
776 }
777 }
778
779 return USB_RET_ASYNC;
780 }
781
782 static int ctrl_error(void)
783 {
784 if (errno == ETIMEDOUT) {
785 return USB_RET_NAK;
786 } else {
787 return USB_RET_STALL;
788 }
789 }
790
791 static int usb_host_set_address(USBHostDevice *s, int addr)
792 {
793 DPRINTF("husb: ctrl set addr %u\n", addr);
794 s->dev.addr = addr;
795 return 0;
796 }
797
798 static int usb_host_set_config(USBHostDevice *s, int config)
799 {
800 usb_host_release_interfaces(s);
801
802 int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
803
804 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
805
806 if (ret < 0) {
807 return ctrl_error();
808 }
809 usb_host_claim_interfaces(s, config);
810 return 0;
811 }
812
813 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
814 {
815 struct usbdevfs_setinterface si;
816 int i, ret;
817
818 for (i = 1; i <= MAX_ENDPOINTS; i++) {
819 if (is_isoc(s, i)) {
820 usb_host_stop_n_free_iso(s, i);
821 }
822 }
823
824 si.interface = iface;
825 si.altsetting = alt;
826 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
827
828 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
829 iface, alt, ret, errno);
830
831 if (ret < 0) {
832 return ctrl_error();
833 }
834 usb_linux_update_endp_table(s);
835 return 0;
836 }
837
838 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
839 int request, int value, int index, int length, uint8_t *data)
840 {
841 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
842 struct usbdevfs_urb *urb;
843 AsyncURB *aurb;
844 int ret;
845
846 /*
847 * Process certain standard device requests.
848 * These are infrequent and are processed synchronously.
849 */
850
851 /* Note request is (bRequestType << 8) | bRequest */
852 DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",
853 request >> 8, request & 0xff, value, index, length);
854
855 switch (request) {
856 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
857 return usb_host_set_address(s, value);
858
859 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
860 return usb_host_set_config(s, value & 0xff);
861
862 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
863 return usb_host_set_interface(s, index, value);
864 }
865
866 /* The rest are asynchronous */
867
868 if (length > sizeof(dev->data_buf)) {
869 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
870 length, sizeof(dev->data_buf));
871 return USB_RET_STALL;
872 }
873
874 aurb = async_alloc(s);
875 aurb->packet = p;
876
877 /*
878 * Setup ctrl transfer.
879 *
880 * s->ctrl is laid out such that data buffer immediately follows
881 * 'req' struct which is exactly what usbdevfs expects.
882 */
883 urb = &aurb->urb;
884
885 urb->type = USBDEVFS_URB_TYPE_CONTROL;
886 urb->endpoint = p->devep;
887
888 urb->buffer = &dev->setup_buf;
889 urb->buffer_length = length + 8;
890
891 urb->usercontext = s;
892
893 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
894
895 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
896
897 if (ret < 0) {
898 DPRINTF("husb: submit failed. errno %d\n", errno);
899 async_free(aurb);
900
901 switch(errno) {
902 case ETIMEDOUT:
903 return USB_RET_NAK;
904 case EPIPE:
905 default:
906 return USB_RET_STALL;
907 }
908 }
909
910 return USB_RET_ASYNC;
911 }
912
913 static int usb_linux_get_configuration(USBHostDevice *s)
914 {
915 uint8_t configuration;
916 struct usb_ctrltransfer ct;
917 int ret;
918
919 if (usb_fs_type == USB_FS_SYS) {
920 char device_name[32], line[1024];
921 int configuration;
922
923 sprintf(device_name, "%d-%s", s->bus_num, s->port);
924
925 if (!usb_host_read_file(line, sizeof(line), "bConfigurationValue",
926 device_name)) {
927 goto usbdevfs;
928 }
929 if (sscanf(line, "%d", &configuration) != 1) {
930 goto usbdevfs;
931 }
932 return configuration;
933 }
934
935 usbdevfs:
936 ct.bRequestType = USB_DIR_IN;
937 ct.bRequest = USB_REQ_GET_CONFIGURATION;
938 ct.wValue = 0;
939 ct.wIndex = 0;
940 ct.wLength = 1;
941 ct.data = &configuration;
942 ct.timeout = 50;
943
944 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
945 if (ret < 0) {
946 perror("usb_linux_get_configuration");
947 return -1;
948 }
949
950 /* in address state */
951 if (configuration == 0) {
952 return -1;
953 }
954
955 return configuration;
956 }
957
958 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
959 uint8_t configuration, uint8_t interface)
960 {
961 uint8_t alt_setting;
962 struct usb_ctrltransfer ct;
963 int ret;
964
965 if (usb_fs_type == USB_FS_SYS) {
966 char device_name[64], line[1024];
967 int alt_setting;
968
969 sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
970 (int)configuration, (int)interface);
971
972 if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
973 device_name)) {
974 goto usbdevfs;
975 }
976 if (sscanf(line, "%d", &alt_setting) != 1) {
977 goto usbdevfs;
978 }
979 return alt_setting;
980 }
981
982 usbdevfs:
983 ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
984 ct.bRequest = USB_REQ_GET_INTERFACE;
985 ct.wValue = 0;
986 ct.wIndex = interface;
987 ct.wLength = 1;
988 ct.data = &alt_setting;
989 ct.timeout = 50;
990 ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
991 if (ret < 0) {
992 /* Assume alt 0 on error */
993 return 0;
994 }
995
996 return alt_setting;
997 }
998
999 /* returns 1 on problem encountered or 0 for success */
1000 static int usb_linux_update_endp_table(USBHostDevice *s)
1001 {
1002 uint8_t *descriptors;
1003 uint8_t devep, type, configuration, alt_interface;
1004 int interface, length, i;
1005
1006 for (i = 0; i < MAX_ENDPOINTS; i++)
1007 s->endp_table[i].type = INVALID_EP_TYPE;
1008
1009 i = usb_linux_get_configuration(s);
1010 if (i < 0)
1011 return 1;
1012 configuration = i;
1013
1014 /* get the desired configuration, interface, and endpoint descriptors
1015 * from device description */
1016 descriptors = &s->descr[18];
1017 length = s->descr_len - 18;
1018 i = 0;
1019
1020 if (descriptors[i + 1] != USB_DT_CONFIG ||
1021 descriptors[i + 5] != configuration) {
1022 DPRINTF("invalid descriptor data - configuration\n");
1023 return 1;
1024 }
1025 i += descriptors[i];
1026
1027 while (i < length) {
1028 if (descriptors[i + 1] != USB_DT_INTERFACE ||
1029 (descriptors[i + 1] == USB_DT_INTERFACE &&
1030 descriptors[i + 4] == 0)) {
1031 i += descriptors[i];
1032 continue;
1033 }
1034
1035 interface = descriptors[i + 2];
1036 alt_interface = usb_linux_get_alt_setting(s, configuration, interface);
1037
1038 /* the current interface descriptor is the active interface
1039 * and has endpoints */
1040 if (descriptors[i + 3] != alt_interface) {
1041 i += descriptors[i];
1042 continue;
1043 }
1044
1045 /* advance to the endpoints */
1046 while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1047 i += descriptors[i];
1048 }
1049
1050 if (i >= length)
1051 break;
1052
1053 while (i < length) {
1054 if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1055 break;
1056 }
1057
1058 devep = descriptors[i + 2];
1059 if ((devep & 0x0f) == 0) {
1060 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1061 return 1;
1062 }
1063
1064 switch (descriptors[i + 3] & 0x3) {
1065 case 0x00:
1066 type = USBDEVFS_URB_TYPE_CONTROL;
1067 break;
1068 case 0x01:
1069 type = USBDEVFS_URB_TYPE_ISO;
1070 set_max_packet_size(s, (devep & 0xf), descriptors + i);
1071 break;
1072 case 0x02:
1073 type = USBDEVFS_URB_TYPE_BULK;
1074 break;
1075 case 0x03:
1076 type = USBDEVFS_URB_TYPE_INTERRUPT;
1077 break;
1078 default:
1079 DPRINTF("usb_host: malformed endpoint type\n");
1080 type = USBDEVFS_URB_TYPE_BULK;
1081 }
1082 s->endp_table[(devep & 0xf) - 1].type = type;
1083 s->endp_table[(devep & 0xf) - 1].halted = 0;
1084
1085 i += descriptors[i];
1086 }
1087 }
1088 return 0;
1089 }
1090
1091 /*
1092 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1093 * this function assumes this is safe, if:
1094 * 1) There are no isoc endpoints
1095 * 2) There are no interrupt endpoints with a max_packet_size > 64
1096 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1097 * usb1 compatible, but in practice this seems to work fine.
1098 */
1099 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1100 {
1101 int i, packet_size;
1102
1103 /*
1104 * usb_linux_update_endp_table only registers info about ep in the current
1105 * interface altsettings, so we need to parse the descriptors again.
1106 */
1107 for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1108 if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1109 switch (dev->descr[i + 3] & 0x3) {
1110 case 0x00: /* CONTROL */
1111 break;
1112 case 0x01: /* ISO */
1113 return 0;
1114 case 0x02: /* BULK */
1115 break;
1116 case 0x03: /* INTERRUPT */
1117 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1118 if (packet_size > 64)
1119 return 0;
1120 break;
1121 }
1122 }
1123 }
1124 return 1;
1125 }
1126
1127 static int usb_host_open(USBHostDevice *dev, int bus_num,
1128 int addr, char *port, const char *prod_name, int speed)
1129 {
1130 int fd = -1, ret;
1131 char buf[1024];
1132
1133 if (dev->fd != -1) {
1134 goto fail;
1135 }
1136 printf("husb: open device %d.%d\n", bus_num, addr);
1137
1138 if (!usb_host_device_path) {
1139 perror("husb: USB Host Device Path not set");
1140 goto fail;
1141 }
1142 snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1143 bus_num, addr);
1144 fd = open(buf, O_RDWR | O_NONBLOCK);
1145 if (fd < 0) {
1146 perror(buf);
1147 goto fail;
1148 }
1149 DPRINTF("husb: opened %s\n", buf);
1150
1151 dev->bus_num = bus_num;
1152 dev->addr = addr;
1153 strcpy(dev->port, port);
1154 dev->fd = fd;
1155
1156 /* read the device description */
1157 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1158 if (dev->descr_len <= 0) {
1159 perror("husb: reading device data failed");
1160 goto fail;
1161 }
1162
1163 #ifdef DEBUG
1164 {
1165 int x;
1166 printf("=== begin dumping device descriptor data ===\n");
1167 for (x = 0; x < dev->descr_len; x++) {
1168 printf("%02x ", dev->descr[x]);
1169 }
1170 printf("\n=== end dumping device descriptor data ===\n");
1171 }
1172 #endif
1173
1174
1175 /*
1176 * Initial configuration is -1 which makes us claim first
1177 * available config. We used to start with 1, which does not
1178 * always work. I've seen devices where first config starts
1179 * with 2.
1180 */
1181 if (!usb_host_claim_interfaces(dev, -1)) {
1182 goto fail;
1183 }
1184
1185 ret = usb_linux_update_endp_table(dev);
1186 if (ret) {
1187 goto fail;
1188 }
1189
1190 if (speed == -1) {
1191 struct usbdevfs_connectinfo ci;
1192
1193 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1194 if (ret < 0) {
1195 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1196 goto fail;
1197 }
1198
1199 if (ci.slow) {
1200 speed = USB_SPEED_LOW;
1201 } else {
1202 speed = USB_SPEED_HIGH;
1203 }
1204 }
1205 dev->dev.speed = speed;
1206 dev->dev.speedmask = (1 << speed);
1207 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1208 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1209 }
1210
1211 printf("husb: grabbed usb device %d.%d\n", bus_num, addr);
1212
1213 if (!prod_name || prod_name[0] == '\0') {
1214 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1215 "host:%d.%d", bus_num, addr);
1216 } else {
1217 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1218 prod_name);
1219 }
1220
1221 ret = usb_device_attach(&dev->dev);
1222 if (ret) {
1223 goto fail;
1224 }
1225
1226 /* USB devio uses 'write' flag to check for async completions */
1227 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1228
1229 return 0;
1230
1231 fail:
1232 if (dev->fd != -1) {
1233 close(dev->fd);
1234 dev->fd = -1;
1235 }
1236 return -1;
1237 }
1238
1239 static int usb_host_close(USBHostDevice *dev)
1240 {
1241 int i;
1242
1243 if (dev->fd == -1 || !dev->dev.attached) {
1244 return -1;
1245 }
1246
1247 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1248 dev->closing = 1;
1249 for (i = 1; i <= MAX_ENDPOINTS; i++) {
1250 if (is_isoc(dev, i)) {
1251 usb_host_stop_n_free_iso(dev, i);
1252 }
1253 }
1254 async_complete(dev);
1255 dev->closing = 0;
1256 usb_device_detach(&dev->dev);
1257 ioctl(dev->fd, USBDEVFS_RESET);
1258 close(dev->fd);
1259 dev->fd = -1;
1260 return 0;
1261 }
1262
1263 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1264 {
1265 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1266
1267 if (s->fd != -1) {
1268 ioctl(s->fd, USBDEVFS_RESET);
1269 }
1270 }
1271
1272 static int usb_host_initfn(USBDevice *dev)
1273 {
1274 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1275
1276 dev->auto_attach = 0;
1277 s->fd = -1;
1278 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1279 s->exit.notify = usb_host_exit_notifier;
1280 qemu_add_exit_notifier(&s->exit);
1281 usb_host_auto_check(NULL);
1282 return 0;
1283 }
1284
1285 static struct USBDeviceInfo usb_host_dev_info = {
1286 .product_desc = "USB Host Device",
1287 .qdev.name = "usb-host",
1288 .qdev.size = sizeof(USBHostDevice),
1289 .init = usb_host_initfn,
1290 .handle_packet = usb_generic_handle_packet,
1291 .cancel_packet = usb_host_async_cancel,
1292 .handle_data = usb_host_handle_data,
1293 .handle_control = usb_host_handle_control,
1294 .handle_reset = usb_host_handle_reset,
1295 .handle_destroy = usb_host_handle_destroy,
1296 .usbdevice_name = "host",
1297 .usbdevice_init = usb_host_device_open,
1298 .qdev.props = (Property[]) {
1299 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1300 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1301 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1302 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1303 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1304 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1305 DEFINE_PROP_END_OF_LIST(),
1306 },
1307 };
1308
1309 static void usb_host_register_devices(void)
1310 {
1311 usb_qdev_register(&usb_host_dev_info);
1312 }
1313 device_init(usb_host_register_devices)
1314
1315 USBDevice *usb_host_device_open(const char *devname)
1316 {
1317 struct USBAutoFilter filter;
1318 USBDevice *dev;
1319 char *p;
1320
1321 dev = usb_create(NULL /* FIXME */, "usb-host");
1322
1323 if (strstr(devname, "auto:")) {
1324 if (parse_filter(devname, &filter) < 0) {
1325 goto fail;
1326 }
1327 } else {
1328 if ((p = strchr(devname, '.'))) {
1329 filter.bus_num = strtoul(devname, NULL, 0);
1330 filter.addr = strtoul(p + 1, NULL, 0);
1331 filter.vendor_id = 0;
1332 filter.product_id = 0;
1333 } else if ((p = strchr(devname, ':'))) {
1334 filter.bus_num = 0;
1335 filter.addr = 0;
1336 filter.vendor_id = strtoul(devname, NULL, 16);
1337 filter.product_id = strtoul(p + 1, NULL, 16);
1338 } else {
1339 goto fail;
1340 }
1341 }
1342
1343 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1344 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1345 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1346 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1347 qdev_init_nofail(&dev->qdev);
1348 return dev;
1349
1350 fail:
1351 qdev_free(&dev->qdev);
1352 return NULL;
1353 }
1354
1355 int usb_host_device_close(const char *devname)
1356 {
1357 #if 0
1358 char product_name[PRODUCT_NAME_SZ];
1359 int bus_num, addr;
1360 USBHostDevice *s;
1361
1362 if (strstr(devname, "auto:")) {
1363 return usb_host_auto_del(devname);
1364 }
1365 if (usb_host_find_device(&bus_num, &addr, product_name,
1366 sizeof(product_name), devname) < 0) {
1367 return -1;
1368 }
1369 s = hostdev_find(bus_num, addr);
1370 if (s) {
1371 usb_device_delete_addr(s->bus_num, s->dev.addr);
1372 return 0;
1373 }
1374 #endif
1375
1376 return -1;
1377 }
1378
1379 static int get_tag_value(char *buf, int buf_size,
1380 const char *str, const char *tag,
1381 const char *stopchars)
1382 {
1383 const char *p;
1384 char *q;
1385 p = strstr(str, tag);
1386 if (!p) {
1387 return -1;
1388 }
1389 p += strlen(tag);
1390 while (qemu_isspace(*p)) {
1391 p++;
1392 }
1393 q = buf;
1394 while (*p != '\0' && !strchr(stopchars, *p)) {
1395 if ((q - buf) < (buf_size - 1)) {
1396 *q++ = *p;
1397 }
1398 p++;
1399 }
1400 *q = '\0';
1401 return q - buf;
1402 }
1403
1404 /*
1405 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1406 * host's USB devices. This is legacy support since many distributions
1407 * are moving to /sys/bus/usb
1408 */
1409 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1410 {
1411 FILE *f = NULL;
1412 char line[1024];
1413 char buf[1024];
1414 int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
1415 char product_name[512];
1416 int ret = 0;
1417
1418 if (!usb_host_device_path) {
1419 perror("husb: USB Host Device Path not set");
1420 goto the_end;
1421 }
1422 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1423 f = fopen(line, "r");
1424 if (!f) {
1425 perror("husb: cannot open devices file");
1426 goto the_end;
1427 }
1428
1429 device_count = 0;
1430 bus_num = addr = class_id = product_id = vendor_id = 0;
1431 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1432 for(;;) {
1433 if (fgets(line, sizeof(line), f) == NULL) {
1434 break;
1435 }
1436 if (strlen(line) > 0) {
1437 line[strlen(line) - 1] = '\0';
1438 }
1439 if (line[0] == 'T' && line[1] == ':') {
1440 if (device_count && (vendor_id || product_id)) {
1441 /* New device. Add the previously discovered device. */
1442 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1443 product_id, product_name, speed);
1444 if (ret) {
1445 goto the_end;
1446 }
1447 }
1448 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1449 goto fail;
1450 }
1451 bus_num = atoi(buf);
1452 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1453 goto fail;
1454 }
1455 addr = atoi(buf);
1456 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1457 goto fail;
1458 }
1459 if (!strcmp(buf, "5000")) {
1460 speed = USB_SPEED_SUPER;
1461 } else if (!strcmp(buf, "480")) {
1462 speed = USB_SPEED_HIGH;
1463 } else if (!strcmp(buf, "1.5")) {
1464 speed = USB_SPEED_LOW;
1465 } else {
1466 speed = USB_SPEED_FULL;
1467 }
1468 product_name[0] = '\0';
1469 class_id = 0xff;
1470 device_count++;
1471 product_id = 0;
1472 vendor_id = 0;
1473 } else if (line[0] == 'P' && line[1] == ':') {
1474 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1475 goto fail;
1476 }
1477 vendor_id = strtoul(buf, NULL, 16);
1478 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1479 goto fail;
1480 }
1481 product_id = strtoul(buf, NULL, 16);
1482 } else if (line[0] == 'S' && line[1] == ':') {
1483 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1484 goto fail;
1485 }
1486 pstrcpy(product_name, sizeof(product_name), buf);
1487 } else if (line[0] == 'D' && line[1] == ':') {
1488 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1489 goto fail;
1490 }
1491 class_id = strtoul(buf, NULL, 16);
1492 }
1493 fail: ;
1494 }
1495 if (device_count && (vendor_id || product_id)) {
1496 /* Add the last device. */
1497 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1498 product_id, product_name, speed);
1499 }
1500 the_end:
1501 if (f) {
1502 fclose(f);
1503 }
1504 return ret;
1505 }
1506
1507 /*
1508 * Read sys file-system device file
1509 *
1510 * @line address of buffer to put file contents in
1511 * @line_size size of line
1512 * @device_file path to device file (printf format string)
1513 * @device_name device being opened (inserted into device_file)
1514 *
1515 * @return 0 failed, 1 succeeded ('line' contains data)
1516 */
1517 static int usb_host_read_file(char *line, size_t line_size,
1518 const char *device_file, const char *device_name)
1519 {
1520 FILE *f;
1521 int ret = 0;
1522 char filename[PATH_MAX];
1523
1524 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1525 device_file);
1526 f = fopen(filename, "r");
1527 if (f) {
1528 ret = fgets(line, line_size, f) != NULL;
1529 fclose(f);
1530 }
1531
1532 return ret;
1533 }
1534
1535 /*
1536 * Use /sys/bus/usb/devices/ directory to determine host's USB
1537 * devices.
1538 *
1539 * This code is based on Robert Schiele's original patches posted to
1540 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1541 */
1542 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1543 {
1544 DIR *dir = NULL;
1545 char line[1024];
1546 int bus_num, addr, speed, class_id, product_id, vendor_id;
1547 int ret = 0;
1548 char port[MAX_PORTLEN];
1549 char product_name[512];
1550 struct dirent *de;
1551
1552 dir = opendir(USBSYSBUS_PATH "/devices");
1553 if (!dir) {
1554 perror("husb: cannot open devices directory");
1555 goto the_end;
1556 }
1557
1558 while ((de = readdir(dir))) {
1559 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1560 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1561 continue;
1562 }
1563
1564 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1565 goto the_end;
1566 }
1567 if (sscanf(line, "%d", &addr) != 1) {
1568 goto the_end;
1569 }
1570 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1571 de->d_name)) {
1572 goto the_end;
1573 }
1574 if (sscanf(line, "%x", &class_id) != 1) {
1575 goto the_end;
1576 }
1577
1578 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1579 de->d_name)) {
1580 goto the_end;
1581 }
1582 if (sscanf(line, "%x", &vendor_id) != 1) {
1583 goto the_end;
1584 }
1585 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1586 de->d_name)) {
1587 goto the_end;
1588 }
1589 if (sscanf(line, "%x", &product_id) != 1) {
1590 goto the_end;
1591 }
1592 if (!usb_host_read_file(line, sizeof(line), "product",
1593 de->d_name)) {
1594 *product_name = 0;
1595 } else {
1596 if (strlen(line) > 0) {
1597 line[strlen(line) - 1] = '\0';
1598 }
1599 pstrcpy(product_name, sizeof(product_name), line);
1600 }
1601
1602 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1603 goto the_end;
1604 }
1605 if (!strcmp(line, "5000\n")) {
1606 speed = USB_SPEED_SUPER;
1607 } else if (!strcmp(line, "480\n")) {
1608 speed = USB_SPEED_HIGH;
1609 } else if (!strcmp(line, "1.5\n")) {
1610 speed = USB_SPEED_LOW;
1611 } else {
1612 speed = USB_SPEED_FULL;
1613 }
1614
1615 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1616 product_id, product_name, speed);
1617 if (ret) {
1618 goto the_end;
1619 }
1620 }
1621 }
1622 the_end:
1623 if (dir) {
1624 closedir(dir);
1625 }
1626 return ret;
1627 }
1628
1629 /*
1630 * Determine how to access the host's USB devices and call the
1631 * specific support function.
1632 */
1633 static int usb_host_scan(void *opaque, USBScanFunc *func)
1634 {
1635 Monitor *mon = cur_mon;
1636 FILE *f = NULL;
1637 DIR *dir = NULL;
1638 int ret = 0;
1639 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1640 char devpath[PATH_MAX];
1641
1642 /* only check the host once */
1643 if (!usb_fs_type) {
1644 dir = opendir(USBSYSBUS_PATH "/devices");
1645 if (dir) {
1646 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1647 strcpy(devpath, USBDEVBUS_PATH);
1648 usb_fs_type = USB_FS_SYS;
1649 closedir(dir);
1650 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1651 goto found_devices;
1652 }
1653 f = fopen(USBPROCBUS_PATH "/devices", "r");
1654 if (f) {
1655 /* devices found in /proc/bus/usb/ */
1656 strcpy(devpath, USBPROCBUS_PATH);
1657 usb_fs_type = USB_FS_PROC;
1658 fclose(f);
1659 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1660 goto found_devices;
1661 }
1662 /* try additional methods if an access method hasn't been found yet */
1663 f = fopen(USBDEVBUS_PATH "/devices", "r");
1664 if (f) {
1665 /* devices found in /dev/bus/usb/ */
1666 strcpy(devpath, USBDEVBUS_PATH);
1667 usb_fs_type = USB_FS_DEV;
1668 fclose(f);
1669 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1670 goto found_devices;
1671 }
1672 found_devices:
1673 if (!usb_fs_type) {
1674 if (mon) {
1675 monitor_printf(mon, "husb: unable to access USB devices\n");
1676 }
1677 return -ENOENT;
1678 }
1679
1680 /* the module setting (used later for opening devices) */
1681 usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
1682 strcpy(usb_host_device_path, devpath);
1683 if (mon) {
1684 monitor_printf(mon, "husb: using %s file-system with %s\n",
1685 fs_type[usb_fs_type], usb_host_device_path);
1686 }
1687 }
1688
1689 switch (usb_fs_type) {
1690 case USB_FS_PROC:
1691 case USB_FS_DEV:
1692 ret = usb_host_scan_dev(opaque, func);
1693 break;
1694 case USB_FS_SYS:
1695 ret = usb_host_scan_sys(opaque, func);
1696 break;
1697 default:
1698 ret = -EINVAL;
1699 break;
1700 }
1701 return ret;
1702 }
1703
1704 static QEMUTimer *usb_auto_timer;
1705
1706 static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
1707 int class_id, int vendor_id, int product_id,
1708 const char *product_name, int speed)
1709 {
1710 struct USBAutoFilter *f;
1711 struct USBHostDevice *s;
1712
1713 /* Ignore hubs */
1714 if (class_id == 9)
1715 return 0;
1716
1717 QTAILQ_FOREACH(s, &hostdevs, next) {
1718 f = &s->match;
1719
1720 if (f->bus_num > 0 && f->bus_num != bus_num) {
1721 continue;
1722 }
1723 if (f->addr > 0 && f->addr != addr) {
1724 continue;
1725 }
1726 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1727 continue;
1728 }
1729
1730 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1731 continue;
1732 }
1733
1734 if (f->product_id > 0 && f->product_id != product_id) {
1735 continue;
1736 }
1737 /* We got a match */
1738
1739 /* Already attached ? */
1740 if (s->fd != -1) {
1741 return 0;
1742 }
1743 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1744
1745 usb_host_open(s, bus_num, addr, port, product_name, speed);
1746 break;
1747 }
1748
1749 return 0;
1750 }
1751
1752 static void usb_host_auto_check(void *unused)
1753 {
1754 struct USBHostDevice *s;
1755 int unconnected = 0;
1756
1757 usb_host_scan(NULL, usb_host_auto_scan);
1758
1759 QTAILQ_FOREACH(s, &hostdevs, next) {
1760 if (s->fd == -1) {
1761 unconnected++;
1762 }
1763 }
1764
1765 if (unconnected == 0) {
1766 /* nothing to watch */
1767 if (usb_auto_timer) {
1768 qemu_del_timer(usb_auto_timer);
1769 }
1770 return;
1771 }
1772
1773 if (!usb_auto_timer) {
1774 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1775 if (!usb_auto_timer) {
1776 return;
1777 }
1778 }
1779 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1780 }
1781
1782 /*
1783 * Autoconnect filter
1784 * Format:
1785 * auto:bus:dev[:vid:pid]
1786 * auto:bus.dev[:vid:pid]
1787 *
1788 * bus - bus number (dec, * means any)
1789 * dev - device number (dec, * means any)
1790 * vid - vendor id (hex, * means any)
1791 * pid - product id (hex, * means any)
1792 *
1793 * See 'lsusb' output.
1794 */
1795 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1796 {
1797 enum { BUS, DEV, VID, PID, DONE };
1798 const char *p = spec;
1799 int i;
1800
1801 f->bus_num = 0;
1802 f->addr = 0;
1803 f->vendor_id = 0;
1804 f->product_id = 0;
1805
1806 for (i = BUS; i < DONE; i++) {
1807 p = strpbrk(p, ":.");
1808 if (!p) {
1809 break;
1810 }
1811 p++;
1812
1813 if (*p == '*') {
1814 continue;
1815 }
1816 switch(i) {
1817 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1818 case DEV: f->addr = strtol(p, NULL, 10); break;
1819 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1820 case PID: f->product_id = strtol(p, NULL, 16); break;
1821 }
1822 }
1823
1824 if (i < DEV) {
1825 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1826 return -1;
1827 }
1828
1829 return 0;
1830 }
1831
1832 /**********************/
1833 /* USB host device info */
1834
1835 struct usb_class_info {
1836 int class;
1837 const char *class_name;
1838 };
1839
1840 static const struct usb_class_info usb_class_info[] = {
1841 { USB_CLASS_AUDIO, "Audio"},
1842 { USB_CLASS_COMM, "Communication"},
1843 { USB_CLASS_HID, "HID"},
1844 { USB_CLASS_HUB, "Hub" },
1845 { USB_CLASS_PHYSICAL, "Physical" },
1846 { USB_CLASS_PRINTER, "Printer" },
1847 { USB_CLASS_MASS_STORAGE, "Storage" },
1848 { USB_CLASS_CDC_DATA, "Data" },
1849 { USB_CLASS_APP_SPEC, "Application Specific" },
1850 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1851 { USB_CLASS_STILL_IMAGE, "Still Image" },
1852 { USB_CLASS_CSCID, "Smart Card" },
1853 { USB_CLASS_CONTENT_SEC, "Content Security" },
1854 { -1, NULL }
1855 };
1856
1857 static const char *usb_class_str(uint8_t class)
1858 {
1859 const struct usb_class_info *p;
1860 for(p = usb_class_info; p->class != -1; p++) {
1861 if (p->class == class) {
1862 break;
1863 }
1864 }
1865 return p->class_name;
1866 }
1867
1868 static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
1869 int class_id, int vendor_id, int product_id,
1870 const char *product_name,
1871 int speed)
1872 {
1873 const char *class_str, *speed_str;
1874
1875 switch(speed) {
1876 case USB_SPEED_LOW:
1877 speed_str = "1.5";
1878 break;
1879 case USB_SPEED_FULL:
1880 speed_str = "12";
1881 break;
1882 case USB_SPEED_HIGH:
1883 speed_str = "480";
1884 break;
1885 case USB_SPEED_SUPER:
1886 speed_str = "5000";
1887 break;
1888 default:
1889 speed_str = "?";
1890 break;
1891 }
1892
1893 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1894 bus_num, addr, port, speed_str);
1895 class_str = usb_class_str(class_id);
1896 if (class_str) {
1897 monitor_printf(mon, " %s:", class_str);
1898 } else {
1899 monitor_printf(mon, " Class %02x:", class_id);
1900 }
1901 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1902 if (product_name[0] != '\0') {
1903 monitor_printf(mon, ", %s", product_name);
1904 }
1905 monitor_printf(mon, "\n");
1906 }
1907
1908 static int usb_host_info_device(void *opaque, int bus_num, int addr,
1909 char *path, int class_id,
1910 int vendor_id, int product_id,
1911 const char *product_name,
1912 int speed)
1913 {
1914 Monitor *mon = opaque;
1915
1916 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1917 product_name, speed);
1918 return 0;
1919 }
1920
1921 static void dec2str(int val, char *str, size_t size)
1922 {
1923 if (val == 0) {
1924 snprintf(str, size, "*");
1925 } else {
1926 snprintf(str, size, "%d", val);
1927 }
1928 }
1929
1930 static void hex2str(int val, char *str, size_t size)
1931 {
1932 if (val == 0) {
1933 snprintf(str, size, "*");
1934 } else {
1935 snprintf(str, size, "%04x", val);
1936 }
1937 }
1938
1939 void usb_host_info(Monitor *mon)
1940 {
1941 struct USBAutoFilter *f;
1942 struct USBHostDevice *s;
1943
1944 usb_host_scan(mon, usb_host_info_device);
1945
1946 if (QTAILQ_EMPTY(&hostdevs)) {
1947 return;
1948 }
1949
1950 monitor_printf(mon, " Auto filters:\n");
1951 QTAILQ_FOREACH(s, &hostdevs, next) {
1952 char bus[10], addr[10], vid[10], pid[10];
1953 f = &s->match;
1954 dec2str(f->bus_num, bus, sizeof(bus));
1955 dec2str(f->addr, addr, sizeof(addr));
1956 hex2str(f->vendor_id, vid, sizeof(vid));
1957 hex2str(f->product_id, pid, sizeof(pid));
1958 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
1959 bus, addr, f->port ? f->port : "*", vid, pid);
1960 }
1961 }
QEMU Monitor Protocol