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