]> git.proxmox.com Git - qemu.git/blob - usb-linux.c
projects / qemu.git / blob
? search:


feb4d36d0bef320c12a5e3824b82b8b09dd6e2f0
[qemu.git] / usb-linux.c
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[1024];
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 switch (descriptors[i + 3] & 0x3) {
1033 case 0x00:
1034 type = USBDEVFS_URB_TYPE_CONTROL;
1035 break;
1036 case 0x01:
1037 type = USBDEVFS_URB_TYPE_ISO;
1038 set_max_packet_size(s, (devep & 0xf), descriptors + i);
1039 break;
1040 case 0x02:
1041 type = USBDEVFS_URB_TYPE_BULK;
1042 break;
1043 case 0x03:
1044 type = USBDEVFS_URB_TYPE_INTERRUPT;
1045 break;
1046 default:
1047 DPRINTF("usb_host: malformed endpoint type\n");
1048 type = USBDEVFS_URB_TYPE_BULK;
1049 }
1050 s->endp_table[(devep & 0xf) - 1].type = type;
1051 s->endp_table[(devep & 0xf) - 1].halted = 0;
1052
1053 i += descriptors[i];
1054 }
1055 }
1056 return 0;
1057 }
1058
1059 static int usb_host_open(USBHostDevice *dev, int bus_num,
1060 int addr, char *port, const char *prod_name, int speed)
1061 {
1062 int fd = -1, ret;
1063 char buf[1024];
1064
1065 if (dev->fd != -1) {
1066 goto fail;
1067 }
1068 printf("husb: open device %d.%d\n", bus_num, addr);
1069
1070 if (!usb_host_device_path) {
1071 perror("husb: USB Host Device Path not set");
1072 goto fail;
1073 }
1074 snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1075 bus_num, addr);
1076 fd = open(buf, O_RDWR | O_NONBLOCK);
1077 if (fd < 0) {
1078 perror(buf);
1079 goto fail;
1080 }
1081 DPRINTF("husb: opened %s\n", buf);
1082
1083 dev->bus_num = bus_num;
1084 dev->addr = addr;
1085 strcpy(dev->port, port);
1086 dev->fd = fd;
1087
1088 /* read the device description */
1089 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1090 if (dev->descr_len <= 0) {
1091 perror("husb: reading device data failed");
1092 goto fail;
1093 }
1094
1095 #ifdef DEBUG
1096 {
1097 int x;
1098 printf("=== begin dumping device descriptor data ===\n");
1099 for (x = 0; x < dev->descr_len; x++) {
1100 printf("%02x ", dev->descr[x]);
1101 }
1102 printf("\n=== end dumping device descriptor data ===\n");
1103 }
1104 #endif
1105
1106
1107 /*
1108 * Initial configuration is -1 which makes us claim first
1109 * available config. We used to start with 1, which does not
1110 * always work. I've seen devices where first config starts
1111 * with 2.
1112 */
1113 if (!usb_host_claim_interfaces(dev, -1)) {
1114 goto fail;
1115 }
1116
1117 ret = usb_linux_update_endp_table(dev);
1118 if (ret) {
1119 goto fail;
1120 }
1121
1122 if (speed == -1) {
1123 struct usbdevfs_connectinfo ci;
1124
1125 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1126 if (ret < 0) {
1127 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1128 goto fail;
1129 }
1130
1131 if (ci.slow) {
1132 speed = USB_SPEED_LOW;
1133 } else {
1134 speed = USB_SPEED_HIGH;
1135 }
1136 }
1137 dev->dev.speed = speed;
1138
1139 printf("husb: grabbed usb device %d.%d\n", bus_num, addr);
1140
1141 if (!prod_name || prod_name[0] == '\0') {
1142 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1143 "host:%d.%d", bus_num, addr);
1144 } else {
1145 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1146 prod_name);
1147 }
1148
1149 /* USB devio uses 'write' flag to check for async completions */
1150 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1151
1152 usb_device_attach(&dev->dev);
1153 return 0;
1154
1155 fail:
1156 dev->fd = -1;
1157 if (fd != -1) {
1158 close(fd);
1159 }
1160 return -1;
1161 }
1162
1163 static int usb_host_close(USBHostDevice *dev)
1164 {
1165 int i;
1166
1167 if (dev->fd == -1) {
1168 return -1;
1169 }
1170
1171 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1172 dev->closing = 1;
1173 for (i = 1; i <= MAX_ENDPOINTS; i++) {
1174 if (is_isoc(dev, i)) {
1175 usb_host_stop_n_free_iso(dev, i);
1176 }
1177 }
1178 async_complete(dev);
1179 dev->closing = 0;
1180 usb_device_detach(&dev->dev);
1181 ioctl(dev->fd, USBDEVFS_RESET);
1182 close(dev->fd);
1183 dev->fd = -1;
1184 return 0;
1185 }
1186
1187 static void usb_host_exit_notifier(struct Notifier* n)
1188 {
1189 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1190
1191 if (s->fd != -1) {
1192 ioctl(s->fd, USBDEVFS_RESET);
1193 }
1194 }
1195
1196 static int usb_host_initfn(USBDevice *dev)
1197 {
1198 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1199
1200 dev->auto_attach = 0;
1201 s->fd = -1;
1202 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1203 s->exit.notify = usb_host_exit_notifier;
1204 qemu_add_exit_notifier(&s->exit);
1205 usb_host_auto_check(NULL);
1206 return 0;
1207 }
1208
1209 static struct USBDeviceInfo usb_host_dev_info = {
1210 .product_desc = "USB Host Device",
1211 .qdev.name = "usb-host",
1212 .qdev.size = sizeof(USBHostDevice),
1213 .init = usb_host_initfn,
1214 .handle_packet = usb_generic_handle_packet,
1215 .cancel_packet = usb_host_async_cancel,
1216 .handle_data = usb_host_handle_data,
1217 .handle_control = usb_host_handle_control,
1218 .handle_reset = usb_host_handle_reset,
1219 .handle_destroy = usb_host_handle_destroy,
1220 .usbdevice_name = "host",
1221 .usbdevice_init = usb_host_device_open,
1222 .qdev.props = (Property[]) {
1223 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1224 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1225 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1226 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1227 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1228 DEFINE_PROP_END_OF_LIST(),
1229 },
1230 };
1231
1232 static void usb_host_register_devices(void)
1233 {
1234 usb_qdev_register(&usb_host_dev_info);
1235 }
1236 device_init(usb_host_register_devices)
1237
1238 USBDevice *usb_host_device_open(const char *devname)
1239 {
1240 struct USBAutoFilter filter;
1241 USBDevice *dev;
1242 char *p;
1243
1244 dev = usb_create(NULL /* FIXME */, "usb-host");
1245
1246 if (strstr(devname, "auto:")) {
1247 if (parse_filter(devname, &filter) < 0) {
1248 goto fail;
1249 }
1250 } else {
1251 if ((p = strchr(devname, '.'))) {
1252 filter.bus_num = strtoul(devname, NULL, 0);
1253 filter.addr = strtoul(p + 1, NULL, 0);
1254 filter.vendor_id = 0;
1255 filter.product_id = 0;
1256 } else if ((p = strchr(devname, ':'))) {
1257 filter.bus_num = 0;
1258 filter.addr = 0;
1259 filter.vendor_id = strtoul(devname, NULL, 16);
1260 filter.product_id = strtoul(p + 1, NULL, 16);
1261 } else {
1262 goto fail;
1263 }
1264 }
1265
1266 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1267 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1268 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1269 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1270 qdev_init_nofail(&dev->qdev);
1271 return dev;
1272
1273 fail:
1274 qdev_free(&dev->qdev);
1275 return NULL;
1276 }
1277
1278 int usb_host_device_close(const char *devname)
1279 {
1280 #if 0
1281 char product_name[PRODUCT_NAME_SZ];
1282 int bus_num, addr;
1283 USBHostDevice *s;
1284
1285 if (strstr(devname, "auto:")) {
1286 return usb_host_auto_del(devname);
1287 }
1288 if (usb_host_find_device(&bus_num, &addr, product_name,
1289 sizeof(product_name), devname) < 0) {
1290 return -1;
1291 }
1292 s = hostdev_find(bus_num, addr);
1293 if (s) {
1294 usb_device_delete_addr(s->bus_num, s->dev.addr);
1295 return 0;
1296 }
1297 #endif
1298
1299 return -1;
1300 }
1301
1302 static int get_tag_value(char *buf, int buf_size,
1303 const char *str, const char *tag,
1304 const char *stopchars)
1305 {
1306 const char *p;
1307 char *q;
1308 p = strstr(str, tag);
1309 if (!p) {
1310 return -1;
1311 }
1312 p += strlen(tag);
1313 while (qemu_isspace(*p)) {
1314 p++;
1315 }
1316 q = buf;
1317 while (*p != '\0' && !strchr(stopchars, *p)) {
1318 if ((q - buf) < (buf_size - 1)) {
1319 *q++ = *p;
1320 }
1321 p++;
1322 }
1323 *q = '\0';
1324 return q - buf;
1325 }
1326
1327 /*
1328 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1329 * host's USB devices. This is legacy support since many distributions
1330 * are moving to /sys/bus/usb
1331 */
1332 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1333 {
1334 FILE *f = NULL;
1335 char line[1024];
1336 char buf[1024];
1337 int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
1338 char product_name[512];
1339 int ret = 0;
1340
1341 if (!usb_host_device_path) {
1342 perror("husb: USB Host Device Path not set");
1343 goto the_end;
1344 }
1345 snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1346 f = fopen(line, "r");
1347 if (!f) {
1348 perror("husb: cannot open devices file");
1349 goto the_end;
1350 }
1351
1352 device_count = 0;
1353 bus_num = addr = class_id = product_id = vendor_id = 0;
1354 speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1355 for(;;) {
1356 if (fgets(line, sizeof(line), f) == NULL) {
1357 break;
1358 }
1359 if (strlen(line) > 0) {
1360 line[strlen(line) - 1] = '\0';
1361 }
1362 if (line[0] == 'T' && line[1] == ':') {
1363 if (device_count && (vendor_id || product_id)) {
1364 /* New device. Add the previously discovered device. */
1365 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1366 product_id, product_name, speed);
1367 if (ret) {
1368 goto the_end;
1369 }
1370 }
1371 if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1372 goto fail;
1373 }
1374 bus_num = atoi(buf);
1375 if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1376 goto fail;
1377 }
1378 addr = atoi(buf);
1379 if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1380 goto fail;
1381 }
1382 if (!strcmp(buf, "5000")) {
1383 speed = USB_SPEED_SUPER;
1384 } else if (!strcmp(buf, "480")) {
1385 speed = USB_SPEED_HIGH;
1386 } else if (!strcmp(buf, "1.5")) {
1387 speed = USB_SPEED_LOW;
1388 } else {
1389 speed = USB_SPEED_FULL;
1390 }
1391 product_name[0] = '\0';
1392 class_id = 0xff;
1393 device_count++;
1394 product_id = 0;
1395 vendor_id = 0;
1396 } else if (line[0] == 'P' && line[1] == ':') {
1397 if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1398 goto fail;
1399 }
1400 vendor_id = strtoul(buf, NULL, 16);
1401 if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1402 goto fail;
1403 }
1404 product_id = strtoul(buf, NULL, 16);
1405 } else if (line[0] == 'S' && line[1] == ':') {
1406 if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1407 goto fail;
1408 }
1409 pstrcpy(product_name, sizeof(product_name), buf);
1410 } else if (line[0] == 'D' && line[1] == ':') {
1411 if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1412 goto fail;
1413 }
1414 class_id = strtoul(buf, NULL, 16);
1415 }
1416 fail: ;
1417 }
1418 if (device_count && (vendor_id || product_id)) {
1419 /* Add the last device. */
1420 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1421 product_id, product_name, speed);
1422 }
1423 the_end:
1424 if (f) {
1425 fclose(f);
1426 }
1427 return ret;
1428 }
1429
1430 /*
1431 * Read sys file-system device file
1432 *
1433 * @line address of buffer to put file contents in
1434 * @line_size size of line
1435 * @device_file path to device file (printf format string)
1436 * @device_name device being opened (inserted into device_file)
1437 *
1438 * @return 0 failed, 1 succeeded ('line' contains data)
1439 */
1440 static int usb_host_read_file(char *line, size_t line_size,
1441 const char *device_file, const char *device_name)
1442 {
1443 FILE *f;
1444 int ret = 0;
1445 char filename[PATH_MAX];
1446
1447 snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1448 device_file);
1449 f = fopen(filename, "r");
1450 if (f) {
1451 ret = fgets(line, line_size, f) != NULL;
1452 fclose(f);
1453 }
1454
1455 return ret;
1456 }
1457
1458 /*
1459 * Use /sys/bus/usb/devices/ directory to determine host's USB
1460 * devices.
1461 *
1462 * This code is based on Robert Schiele's original patches posted to
1463 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1464 */
1465 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1466 {
1467 DIR *dir = NULL;
1468 char line[1024];
1469 int bus_num, addr, speed, class_id, product_id, vendor_id;
1470 int ret = 0;
1471 char port[MAX_PORTLEN];
1472 char product_name[512];
1473 struct dirent *de;
1474
1475 dir = opendir(USBSYSBUS_PATH "/devices");
1476 if (!dir) {
1477 perror("husb: cannot open devices directory");
1478 goto the_end;
1479 }
1480
1481 while ((de = readdir(dir))) {
1482 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1483 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1484 continue;
1485 }
1486
1487 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1488 goto the_end;
1489 }
1490 if (sscanf(line, "%d", &addr) != 1) {
1491 goto the_end;
1492 }
1493 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1494 de->d_name)) {
1495 goto the_end;
1496 }
1497 if (sscanf(line, "%x", &class_id) != 1) {
1498 goto the_end;
1499 }
1500
1501 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1502 de->d_name)) {
1503 goto the_end;
1504 }
1505 if (sscanf(line, "%x", &vendor_id) != 1) {
1506 goto the_end;
1507 }
1508 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1509 de->d_name)) {
1510 goto the_end;
1511 }
1512 if (sscanf(line, "%x", &product_id) != 1) {
1513 goto the_end;
1514 }
1515 if (!usb_host_read_file(line, sizeof(line), "product",
1516 de->d_name)) {
1517 *product_name = 0;
1518 } else {
1519 if (strlen(line) > 0) {
1520 line[strlen(line) - 1] = '\0';
1521 }
1522 pstrcpy(product_name, sizeof(product_name), line);
1523 }
1524
1525 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1526 goto the_end;
1527 }
1528 if (!strcmp(line, "5000\n")) {
1529 speed = USB_SPEED_SUPER;
1530 } else if (!strcmp(line, "480\n")) {
1531 speed = USB_SPEED_HIGH;
1532 } else if (!strcmp(line, "1.5\n")) {
1533 speed = USB_SPEED_LOW;
1534 } else {
1535 speed = USB_SPEED_FULL;
1536 }
1537
1538 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1539 product_id, product_name, speed);
1540 if (ret) {
1541 goto the_end;
1542 }
1543 }
1544 }
1545 the_end:
1546 if (dir) {
1547 closedir(dir);
1548 }
1549 return ret;
1550 }
1551
1552 /*
1553 * Determine how to access the host's USB devices and call the
1554 * specific support function.
1555 */
1556 static int usb_host_scan(void *opaque, USBScanFunc *func)
1557 {
1558 Monitor *mon = cur_mon;
1559 FILE *f = NULL;
1560 DIR *dir = NULL;
1561 int ret = 0;
1562 const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1563 char devpath[PATH_MAX];
1564
1565 /* only check the host once */
1566 if (!usb_fs_type) {
1567 dir = opendir(USBSYSBUS_PATH "/devices");
1568 if (dir) {
1569 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1570 strcpy(devpath, USBDEVBUS_PATH);
1571 usb_fs_type = USB_FS_SYS;
1572 closedir(dir);
1573 DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1574 goto found_devices;
1575 }
1576 f = fopen(USBPROCBUS_PATH "/devices", "r");
1577 if (f) {
1578 /* devices found in /proc/bus/usb/ */
1579 strcpy(devpath, USBPROCBUS_PATH);
1580 usb_fs_type = USB_FS_PROC;
1581 fclose(f);
1582 DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1583 goto found_devices;
1584 }
1585 /* try additional methods if an access method hasn't been found yet */
1586 f = fopen(USBDEVBUS_PATH "/devices", "r");
1587 if (f) {
1588 /* devices found in /dev/bus/usb/ */
1589 strcpy(devpath, USBDEVBUS_PATH);
1590 usb_fs_type = USB_FS_DEV;
1591 fclose(f);
1592 DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1593 goto found_devices;
1594 }
1595 found_devices:
1596 if (!usb_fs_type) {
1597 if (mon) {
1598 monitor_printf(mon, "husb: unable to access USB devices\n");
1599 }
1600 return -ENOENT;
1601 }
1602
1603 /* the module setting (used later for opening devices) */
1604 usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
1605 strcpy(usb_host_device_path, devpath);
1606 if (mon) {
1607 monitor_printf(mon, "husb: using %s file-system with %s\n",
1608 fs_type[usb_fs_type], usb_host_device_path);
1609 }
1610 }
1611
1612 switch (usb_fs_type) {
1613 case USB_FS_PROC:
1614 case USB_FS_DEV:
1615 ret = usb_host_scan_dev(opaque, func);
1616 break;
1617 case USB_FS_SYS:
1618 ret = usb_host_scan_sys(opaque, func);
1619 break;
1620 default:
1621 ret = -EINVAL;
1622 break;
1623 }
1624 return ret;
1625 }
1626
1627 static QEMUTimer *usb_auto_timer;
1628
1629 static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
1630 int class_id, int vendor_id, int product_id,
1631 const char *product_name, int speed)
1632 {
1633 struct USBAutoFilter *f;
1634 struct USBHostDevice *s;
1635
1636 /* Ignore hubs */
1637 if (class_id == 9)
1638 return 0;
1639
1640 QTAILQ_FOREACH(s, &hostdevs, next) {
1641 f = &s->match;
1642
1643 if (f->bus_num > 0 && f->bus_num != bus_num) {
1644 continue;
1645 }
1646 if (f->addr > 0 && f->addr != addr) {
1647 continue;
1648 }
1649 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1650 continue;
1651 }
1652
1653 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1654 continue;
1655 }
1656
1657 if (f->product_id > 0 && f->product_id != product_id) {
1658 continue;
1659 }
1660 /* We got a match */
1661
1662 /* Already attached ? */
1663 if (s->fd != -1) {
1664 return 0;
1665 }
1666 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1667
1668 usb_host_open(s, bus_num, addr, port, product_name, speed);
1669 }
1670
1671 return 0;
1672 }
1673
1674 static void usb_host_auto_check(void *unused)
1675 {
1676 struct USBHostDevice *s;
1677 int unconnected = 0;
1678
1679 usb_host_scan(NULL, usb_host_auto_scan);
1680
1681 QTAILQ_FOREACH(s, &hostdevs, next) {
1682 if (s->fd == -1) {
1683 unconnected++;
1684 }
1685 }
1686
1687 if (unconnected == 0) {
1688 /* nothing to watch */
1689 if (usb_auto_timer) {
1690 qemu_del_timer(usb_auto_timer);
1691 }
1692 return;
1693 }
1694
1695 if (!usb_auto_timer) {
1696 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1697 if (!usb_auto_timer) {
1698 return;
1699 }
1700 }
1701 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1702 }
1703
1704 /*
1705 * Autoconnect filter
1706 * Format:
1707 * auto:bus:dev[:vid:pid]
1708 * auto:bus.dev[:vid:pid]
1709 *
1710 * bus - bus number (dec, * means any)
1711 * dev - device number (dec, * means any)
1712 * vid - vendor id (hex, * means any)
1713 * pid - product id (hex, * means any)
1714 *
1715 * See 'lsusb' output.
1716 */
1717 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1718 {
1719 enum { BUS, DEV, VID, PID, DONE };
1720 const char *p = spec;
1721 int i;
1722
1723 f->bus_num = 0;
1724 f->addr = 0;
1725 f->vendor_id = 0;
1726 f->product_id = 0;
1727
1728 for (i = BUS; i < DONE; i++) {
1729 p = strpbrk(p, ":.");
1730 if (!p) {
1731 break;
1732 }
1733 p++;
1734
1735 if (*p == '*') {
1736 continue;
1737 }
1738 switch(i) {
1739 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1740 case DEV: f->addr = strtol(p, NULL, 10); break;
1741 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1742 case PID: f->product_id = strtol(p, NULL, 16); break;
1743 }
1744 }
1745
1746 if (i < DEV) {
1747 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1748 return -1;
1749 }
1750
1751 return 0;
1752 }
1753
1754 /**********************/
1755 /* USB host device info */
1756
1757 struct usb_class_info {
1758 int class;
1759 const char *class_name;
1760 };
1761
1762 static const struct usb_class_info usb_class_info[] = {
1763 { USB_CLASS_AUDIO, "Audio"},
1764 { USB_CLASS_COMM, "Communication"},
1765 { USB_CLASS_HID, "HID"},
1766 { USB_CLASS_HUB, "Hub" },
1767 { USB_CLASS_PHYSICAL, "Physical" },
1768 { USB_CLASS_PRINTER, "Printer" },
1769 { USB_CLASS_MASS_STORAGE, "Storage" },
1770 { USB_CLASS_CDC_DATA, "Data" },
1771 { USB_CLASS_APP_SPEC, "Application Specific" },
1772 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1773 { USB_CLASS_STILL_IMAGE, "Still Image" },
1774 { USB_CLASS_CSCID, "Smart Card" },
1775 { USB_CLASS_CONTENT_SEC, "Content Security" },
1776 { -1, NULL }
1777 };
1778
1779 static const char *usb_class_str(uint8_t class)
1780 {
1781 const struct usb_class_info *p;
1782 for(p = usb_class_info; p->class != -1; p++) {
1783 if (p->class == class) {
1784 break;
1785 }
1786 }
1787 return p->class_name;
1788 }
1789
1790 static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
1791 int class_id, int vendor_id, int product_id,
1792 const char *product_name,
1793 int speed)
1794 {
1795 const char *class_str, *speed_str;
1796
1797 switch(speed) {
1798 case USB_SPEED_LOW:
1799 speed_str = "1.5";
1800 break;
1801 case USB_SPEED_FULL:
1802 speed_str = "12";
1803 break;
1804 case USB_SPEED_HIGH:
1805 speed_str = "480";
1806 break;
1807 case USB_SPEED_SUPER:
1808 speed_str = "5000";
1809 break;
1810 default:
1811 speed_str = "?";
1812 break;
1813 }
1814
1815 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1816 bus_num, addr, port, speed_str);
1817 class_str = usb_class_str(class_id);
1818 if (class_str) {
1819 monitor_printf(mon, " %s:", class_str);
1820 } else {
1821 monitor_printf(mon, " Class %02x:", class_id);
1822 }
1823 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1824 if (product_name[0] != '\0') {
1825 monitor_printf(mon, ", %s", product_name);
1826 }
1827 monitor_printf(mon, "\n");
1828 }
1829
1830 static int usb_host_info_device(void *opaque, int bus_num, int addr,
1831 char *path, int class_id,
1832 int vendor_id, int product_id,
1833 const char *product_name,
1834 int speed)
1835 {
1836 Monitor *mon = opaque;
1837
1838 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1839 product_name, speed);
1840 return 0;
1841 }
1842
1843 static void dec2str(int val, char *str, size_t size)
1844 {
1845 if (val == 0) {
1846 snprintf(str, size, "*");
1847 } else {
1848 snprintf(str, size, "%d", val);
1849 }
1850 }
1851
1852 static void hex2str(int val, char *str, size_t size)
1853 {
1854 if (val == 0) {
1855 snprintf(str, size, "*");
1856 } else {
1857 snprintf(str, size, "%04x", val);
1858 }
1859 }
1860
1861 void usb_host_info(Monitor *mon)
1862 {
1863 struct USBAutoFilter *f;
1864 struct USBHostDevice *s;
1865
1866 usb_host_scan(mon, usb_host_info_device);
1867
1868 if (QTAILQ_EMPTY(&hostdevs)) {
1869 return;
1870 }
1871
1872 monitor_printf(mon, " Auto filters:\n");
1873 QTAILQ_FOREACH(s, &hostdevs, next) {
1874 char bus[10], addr[10], vid[10], pid[10];
1875 f = &s->match;
1876 dec2str(f->bus_num, bus, sizeof(bus));
1877 dec2str(f->addr, addr, sizeof(addr));
1878 hex2str(f->vendor_id, vid, sizeof(vid));
1879 hex2str(f->product_id, pid, sizeof(pid));
1880 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
1881 bus, addr, f->port ? f->port : "*", vid, pid);
1882 }
1883 }
Qemu copy for testing