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