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