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