2 * Linux host USB redirector
4 * Copyright (c) 2005 Fabrice Bellard
6 * Copyright (c) 2008 Max Krasnyansky
7 * Support for host device auto connect & disconnect
8 * Magor rewrite to support fully async operation
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "qemu-common.h"
29 #include "qemu-timer.h"
33 #if defined(__linux__)
35 #include <sys/ioctl.h>
36 #include <linux/usbdevice_fs.h>
37 #include <linux/version.h>
40 /* We redefine it to avoid version problems */
41 struct usb_ctrltransfer
{
51 typedef int USBScanFunc(void *opaque
, int bus_num
, int addr
, int class_id
,
52 int vendor_id
, int product_id
,
53 const char *product_name
, int speed
);
54 static int usb_host_find_device(int *pbus_num
, int *paddr
,
55 char *product_name
, int product_name_size
,
61 #define dprintf printf
66 #define USBDEVFS_PATH "/proc/bus/usb"
67 #define PRODUCT_NAME_SZ 32
68 #define MAX_ENDPOINTS 16
70 struct sigaction sigact
;
72 /* endpoint association data */
78 typedef struct USBHostDevice
{
87 struct endp_data endp_table
[MAX_ENDPOINTS
];
89 /* Host side address */
93 struct USBHostDevice
*next
;
96 static int is_isoc(USBHostDevice
*s
, int ep
)
98 return s
->endp_table
[ep
- 1].type
== USBDEVFS_URB_TYPE_ISO
;
101 static int is_halted(USBHostDevice
*s
, int ep
)
103 return s
->endp_table
[ep
- 1].halted
;
106 static void clear_halt(USBHostDevice
*s
, int ep
)
108 s
->endp_table
[ep
- 1].halted
= 0;
111 static void set_halt(USBHostDevice
*s
, int ep
)
113 s
->endp_table
[ep
- 1].halted
= 1;
116 static USBHostDevice
*hostdev_list
;
118 static void hostdev_link(USBHostDevice
*dev
)
120 dev
->next
= hostdev_list
;
124 static void hostdev_unlink(USBHostDevice
*dev
)
126 USBHostDevice
*pdev
= hostdev_list
;
127 USBHostDevice
**prev
= &hostdev_list
;
140 static USBHostDevice
*hostdev_find(int bus_num
, int addr
)
142 USBHostDevice
*s
= hostdev_list
;
144 if (s
->bus_num
== bus_num
&& s
->addr
== addr
)
153 * We always allocate one isoc descriptor even for bulk transfers
154 * to simplify allocation and casts.
156 typedef struct AsyncURB
158 struct usbdevfs_urb urb
;
159 struct usbdevfs_iso_packet_desc isocpd
;
165 static AsyncURB
*async_alloc(void)
167 return (AsyncURB
*) qemu_mallocz(sizeof(AsyncURB
));
170 static void async_free(AsyncURB
*aurb
)
175 static void async_complete(void *opaque
)
177 USBHostDevice
*s
= opaque
;
183 int r
= ioctl(s
->fd
, USBDEVFS_REAPURBNDELAY
, &aurb
);
188 if (errno
== ENODEV
&& !s
->closing
) {
189 printf("husb: device %d.%d disconnected\n", s
->bus_num
, s
->addr
);
190 usb_device_del_addr(0, s
->dev
.addr
);
194 dprintf("husb: async. reap urb failed errno %d\n", errno
);
200 dprintf("husb: async completed. aurb %p status %d alen %d\n",
201 aurb
, aurb
->urb
.status
, aurb
->urb
.actual_length
);
204 switch (aurb
->urb
.status
) {
206 p
->len
= aurb
->urb
.actual_length
;
210 set_halt(s
, p
->devep
);
213 p
->len
= USB_RET_NAK
;
217 usb_packet_complete(p
);
224 static void async_cancel(USBPacket
*unused
, void *opaque
)
226 AsyncURB
*aurb
= opaque
;
227 USBHostDevice
*s
= aurb
->hdev
;
229 dprintf("husb: async cancel. aurb %p\n", aurb
);
231 /* Mark it as dead (see async_complete above) */
234 int r
= ioctl(s
->fd
, USBDEVFS_DISCARDURB
, aurb
);
236 dprintf("husb: async. discard urb failed errno %d\n", errno
);
240 static int usb_host_update_interfaces(USBHostDevice
*dev
, int configuration
)
242 int dev_descr_len
, config_descr_len
;
243 int interface
, nb_interfaces
, nb_configurations
;
246 if (configuration
== 0) /* address state - ignore */
250 dev_descr_len
= dev
->descr
[0];
251 if (dev_descr_len
> dev
->descr_len
)
253 nb_configurations
= dev
->descr
[17];
256 while (i
< dev
->descr_len
) {
257 dprintf("husb: i is %d, descr_len is %d, dl %d, dt %d\n", i
, dev
->descr_len
,
258 dev
->descr
[i
], dev
->descr
[i
+1]);
260 if (dev
->descr
[i
+1] != USB_DT_CONFIG
) {
264 config_descr_len
= dev
->descr
[i
];
266 printf("husb: config #%d need %d\n", dev
->descr
[i
+ 5], configuration
);
268 if (configuration
< 0 || configuration
== dev
->descr
[i
+ 5])
271 i
+= config_descr_len
;
274 if (i
>= dev
->descr_len
) {
275 fprintf(stderr
, "husb: update iface failed. no matching configuration\n");
278 nb_interfaces
= dev
->descr
[i
+ 4];
280 #ifdef USBDEVFS_DISCONNECT
281 /* earlier Linux 2.4 do not support that */
283 struct usbdevfs_ioctl ctrl
;
284 for (interface
= 0; interface
< nb_interfaces
; interface
++) {
285 ctrl
.ioctl_code
= USBDEVFS_DISCONNECT
;
286 ctrl
.ifno
= interface
;
287 ret
= ioctl(dev
->fd
, USBDEVFS_IOCTL
, &ctrl
);
288 if (ret
< 0 && errno
!= ENODATA
) {
289 perror("USBDEVFS_DISCONNECT");
296 /* XXX: only grab if all interfaces are free */
297 for (interface
= 0; interface
< nb_interfaces
; interface
++) {
298 ret
= ioctl(dev
->fd
, USBDEVFS_CLAIMINTERFACE
, &interface
);
300 if (errno
== EBUSY
) {
301 printf("husb: update iface. device already grabbed\n");
303 perror("husb: failed to claim interface");
310 printf("husb: %d interfaces claimed for configuration %d\n",
311 nb_interfaces
, configuration
);
316 static void usb_host_handle_reset(USBDevice
*dev
)
318 USBHostDevice
*s
= (USBHostDevice
*)dev
;
320 dprintf("husb: reset device %u.%u\n", s
->bus_num
, s
->addr
);
322 ioctl(s
->fd
, USBDEVFS_RESET
);
323 usb_host_update_interfaces(s
, s
->configuration
);
326 static void usb_host_handle_destroy(USBDevice
*dev
)
328 USBHostDevice
*s
= (USBHostDevice
*)dev
;
332 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
344 static int usb_linux_update_endp_table(USBHostDevice
*s
);
346 static int usb_host_handle_control(USBDevice
*dev
,
353 USBHostDevice
*s
= (USBHostDevice
*)dev
;
354 struct usb_ctrltransfer ct
;
355 struct usbdevfs_setinterface si
;
356 int intf_update_required
= 0;
359 if (request
== (DeviceOutRequest
| USB_REQ_SET_ADDRESS
)) {
360 /* specific SET_ADDRESS support */
363 } else if (request
== ((USB_RECIP_INTERFACE
<< 8) |
364 USB_REQ_SET_INTERFACE
)) {
365 /* set alternate setting for the interface */
366 si
.interface
= index
;
367 si
.altsetting
= value
;
368 ret
= ioctl(s
->fd
, USBDEVFS_SETINTERFACE
, &si
);
369 usb_linux_update_endp_table(s
);
370 } else if (request
== (DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
)) {
371 dprintf("husb: ctrl set config %d\n", value
& 0xff);
372 if (s
->configuration
!= (value
& 0xff)) {
373 s
->configuration
= (value
& 0xff);
374 intf_update_required
= 1;
379 ct
.bRequestType
= request
>> 8;
380 ct
.bRequest
= request
;
386 ret
= ioctl(s
->fd
, USBDEVFS_CONTROL
, &ct
);
388 dprintf("husb: ctrl req 0x%x val 0x%x index %u len %u ret %d\n",
389 ct
.bRequest
, ct
.wValue
, ct
.wIndex
, ct
.wLength
, ret
);
397 return USB_RET_STALL
;
400 if (intf_update_required
) {
401 dprintf("husb: updating interfaces\n");
402 usb_host_update_interfaces(s
, value
& 0xff);
408 static int usb_host_handle_data(USBDevice
*dev
, USBPacket
*p
)
410 USBHostDevice
*s
= (USBHostDevice
*) dev
;
412 struct usbdevfs_urb
*urb
;
415 aurb
= async_alloc();
417 dprintf("husb: async malloc failed\n");
425 if (p
->pid
== USB_TOKEN_IN
)
426 urb
->endpoint
= p
->devep
| 0x80;
428 urb
->endpoint
= p
->devep
;
430 if (is_halted(s
, p
->devep
)) {
431 ret
= ioctl(s
->fd
, USBDEVFS_CLEAR_HALT
, &urb
->endpoint
);
433 dprintf("husb: failed to clear halt. ep 0x%x errno %d\n",
434 urb
->endpoint
, errno
);
437 clear_halt(s
, p
->devep
);
440 urb
->buffer
= p
->data
;
441 urb
->buffer_length
= p
->len
;
443 if (is_isoc(s
, p
->devep
)) {
444 /* Setup ISOC transfer */
445 urb
->type
= USBDEVFS_URB_TYPE_ISO
;
446 urb
->flags
= USBDEVFS_URB_ISO_ASAP
;
447 urb
->number_of_packets
= 1;
448 urb
->iso_frame_desc
[0].length
= p
->len
;
450 /* Setup bulk transfer */
451 urb
->type
= USBDEVFS_URB_TYPE_BULK
;
454 urb
->usercontext
= s
;
456 ret
= ioctl(s
->fd
, USBDEVFS_SUBMITURB
, urb
);
458 dprintf("husb: data submit. ep 0x%x len %u aurb %p\n", urb
->endpoint
, p
->len
, aurb
);
461 dprintf("husb: submit failed. errno %d\n", errno
);
469 return USB_RET_STALL
;
473 usb_defer_packet(p
, async_cancel
, aurb
);
474 return USB_RET_ASYNC
;
477 /* returns 1 on problem encountered or 0 for success */
478 static int usb_linux_update_endp_table(USBHostDevice
*s
)
480 uint8_t *descriptors
;
481 uint8_t devep
, type
, configuration
, alt_interface
;
482 struct usb_ctrltransfer ct
;
483 int interface
, ret
, length
, i
;
485 ct
.bRequestType
= USB_DIR_IN
;
486 ct
.bRequest
= USB_REQ_GET_CONFIGURATION
;
490 ct
.data
= &configuration
;
493 ret
= ioctl(s
->fd
, USBDEVFS_CONTROL
, &ct
);
495 perror("usb_linux_update_endp_table");
499 /* in address state */
500 if (configuration
== 0)
503 /* get the desired configuration, interface, and endpoint descriptors
504 * from device description */
505 descriptors
= &s
->descr
[18];
506 length
= s
->descr_len
- 18;
509 if (descriptors
[i
+ 1] != USB_DT_CONFIG
||
510 descriptors
[i
+ 5] != configuration
) {
511 dprintf("invalid descriptor data - configuration\n");
517 if (descriptors
[i
+ 1] != USB_DT_INTERFACE
||
518 (descriptors
[i
+ 1] == USB_DT_INTERFACE
&&
519 descriptors
[i
+ 4] == 0)) {
524 interface
= descriptors
[i
+ 2];
526 ct
.bRequestType
= USB_DIR_IN
| USB_RECIP_INTERFACE
;
527 ct
.bRequest
= USB_REQ_GET_INTERFACE
;
529 ct
.wIndex
= interface
;
531 ct
.data
= &alt_interface
;
534 ret
= ioctl(s
->fd
, USBDEVFS_CONTROL
, &ct
);
536 perror("usb_linux_update_endp_table");
540 /* the current interface descriptor is the active interface
541 * and has endpoints */
542 if (descriptors
[i
+ 3] != alt_interface
) {
547 /* advance to the endpoints */
548 while (i
< length
&& descriptors
[i
+1] != USB_DT_ENDPOINT
)
555 if (descriptors
[i
+ 1] != USB_DT_ENDPOINT
)
558 devep
= descriptors
[i
+ 2];
559 switch (descriptors
[i
+ 3] & 0x3) {
561 type
= USBDEVFS_URB_TYPE_CONTROL
;
564 type
= USBDEVFS_URB_TYPE_ISO
;
567 type
= USBDEVFS_URB_TYPE_BULK
;
570 type
= USBDEVFS_URB_TYPE_INTERRUPT
;
573 dprintf("usb_host: malformed endpoint type\n");
574 type
= USBDEVFS_URB_TYPE_BULK
;
576 s
->endp_table
[(devep
& 0xf) - 1].type
= type
;
577 s
->endp_table
[(devep
& 0xf) - 1].halted
= 0;
585 static USBDevice
*usb_host_device_open_addr(int bus_num
, int addr
, const char *prod_name
)
588 USBHostDevice
*dev
= NULL
;
589 struct usbdevfs_connectinfo ci
;
592 dev
= qemu_mallocz(sizeof(USBHostDevice
));
596 dev
->bus_num
= bus_num
;
599 printf("husb: open device %d.%d\n", bus_num
, addr
);
601 snprintf(buf
, sizeof(buf
), USBDEVFS_PATH
"/%03d/%03d",
603 fd
= open(buf
, O_RDWR
| O_NONBLOCK
);
609 /* read the device description */
610 dev
->descr_len
= read(fd
, dev
->descr
, sizeof(dev
->descr
));
611 if (dev
->descr_len
<= 0) {
612 perror("husb: reading device data failed");
619 printf("=== begin dumping device descriptor data ===\n");
620 for (x
= 0; x
< dev
->descr_len
; x
++)
621 printf("%02x ", dev
->descr
[x
]);
622 printf("\n=== end dumping device descriptor data ===\n");
627 dev
->configuration
= 1;
629 /* XXX - do something about initial configuration */
630 if (!usb_host_update_interfaces(dev
, -1))
633 ret
= ioctl(fd
, USBDEVFS_CONNECTINFO
, &ci
);
635 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
639 printf("husb: grabbed usb device %d.%d\n", bus_num
, addr
);
641 ret
= usb_linux_update_endp_table(dev
);
646 dev
->dev
.speed
= USB_SPEED_LOW
;
648 dev
->dev
.speed
= USB_SPEED_HIGH
;
649 dev
->dev
.handle_packet
= usb_generic_handle_packet
;
651 dev
->dev
.handle_reset
= usb_host_handle_reset
;
652 dev
->dev
.handle_control
= usb_host_handle_control
;
653 dev
->dev
.handle_data
= usb_host_handle_data
;
654 dev
->dev
.handle_destroy
= usb_host_handle_destroy
;
656 if (!prod_name
|| prod_name
[0] == '\0')
657 snprintf(dev
->dev
.devname
, sizeof(dev
->dev
.devname
),
658 "host:%d.%d", bus_num
, addr
);
660 pstrcpy(dev
->dev
.devname
, sizeof(dev
->dev
.devname
),
663 /* USB devio uses 'write' flag to check for async completions */
664 qemu_set_fd_handler(dev
->fd
, NULL
, async_complete
, dev
);
668 return (USBDevice
*) dev
;
678 USBDevice
*usb_host_device_open(const char *devname
)
681 char product_name
[PRODUCT_NAME_SZ
];
683 if (usb_host_find_device(&bus_num
, &addr
,
684 product_name
, sizeof(product_name
),
688 if (hostdev_find(bus_num
, addr
)) {
689 term_printf("husb: host usb device %d.%d is already open\n", bus_num
, addr
);
693 return usb_host_device_open_addr(bus_num
, addr
, product_name
);
696 static int get_tag_value(char *buf
, int buf_size
,
697 const char *str
, const char *tag
,
698 const char *stopchars
)
702 p
= strstr(str
, tag
);
709 while (*p
!= '\0' && !strchr(stopchars
, *p
)) {
710 if ((q
- buf
) < (buf_size
- 1))
718 static int usb_host_scan(void *opaque
, USBScanFunc
*func
)
723 int bus_num
, addr
, speed
, device_count
, class_id
, product_id
, vendor_id
;
725 char product_name
[512];
727 f
= fopen(USBDEVFS_PATH
"/devices", "r");
729 term_printf("husb: could not open %s\n", USBDEVFS_PATH
"/devices");
733 bus_num
= addr
= speed
= class_id
= product_id
= vendor_id
= 0;
736 if (fgets(line
, sizeof(line
), f
) == NULL
)
738 if (strlen(line
) > 0)
739 line
[strlen(line
) - 1] = '\0';
740 if (line
[0] == 'T' && line
[1] == ':') {
741 if (device_count
&& (vendor_id
|| product_id
)) {
742 /* New device. Add the previously discovered device. */
743 ret
= func(opaque
, bus_num
, addr
, class_id
, vendor_id
,
744 product_id
, product_name
, speed
);
748 if (get_tag_value(buf
, sizeof(buf
), line
, "Bus=", " ") < 0)
751 if (get_tag_value(buf
, sizeof(buf
), line
, "Dev#=", " ") < 0)
754 if (get_tag_value(buf
, sizeof(buf
), line
, "Spd=", " ") < 0)
756 if (!strcmp(buf
, "480"))
757 speed
= USB_SPEED_HIGH
;
758 else if (!strcmp(buf
, "1.5"))
759 speed
= USB_SPEED_LOW
;
761 speed
= USB_SPEED_FULL
;
762 product_name
[0] = '\0';
767 } else if (line
[0] == 'P' && line
[1] == ':') {
768 if (get_tag_value(buf
, sizeof(buf
), line
, "Vendor=", " ") < 0)
770 vendor_id
= strtoul(buf
, NULL
, 16);
771 if (get_tag_value(buf
, sizeof(buf
), line
, "ProdID=", " ") < 0)
773 product_id
= strtoul(buf
, NULL
, 16);
774 } else if (line
[0] == 'S' && line
[1] == ':') {
775 if (get_tag_value(buf
, sizeof(buf
), line
, "Product=", "") < 0)
777 pstrcpy(product_name
, sizeof(product_name
), buf
);
778 } else if (line
[0] == 'D' && line
[1] == ':') {
779 if (get_tag_value(buf
, sizeof(buf
), line
, "Cls=", " (") < 0)
781 class_id
= strtoul(buf
, NULL
, 16);
785 if (device_count
&& (vendor_id
|| product_id
)) {
786 /* Add the last device. */
787 ret
= func(opaque
, bus_num
, addr
, class_id
, vendor_id
,
788 product_id
, product_name
, speed
);
795 struct USBAutoFilter
{
796 struct USBAutoFilter
*next
;
803 static QEMUTimer
*usb_auto_timer
;
804 static struct USBAutoFilter
*usb_auto_filter
;
806 static int usb_host_auto_scan(void *opaque
, int bus_num
, int addr
,
807 int class_id
, int vendor_id
, int product_id
,
808 const char *product_name
, int speed
)
810 struct USBAutoFilter
*f
;
811 struct USBDevice
*dev
;
817 for (f
= usb_auto_filter
; f
; f
= f
->next
) {
818 if (f
->bus_num
>= 0 && f
->bus_num
!= bus_num
)
821 if (f
->addr
>= 0 && f
->addr
!= addr
)
824 if (f
->vendor_id
>= 0 && f
->vendor_id
!= vendor_id
)
827 if (f
->product_id
>= 0 && f
->product_id
!= product_id
)
832 /* Allredy attached ? */
833 if (hostdev_find(bus_num
, addr
))
836 dprintf("husb: auto open: bus_num %d addr %d\n", bus_num
, addr
);
838 dev
= usb_host_device_open_addr(bus_num
, addr
, product_name
);
840 usb_device_add_dev(dev
);
846 static void usb_host_auto_timer(void *unused
)
848 usb_host_scan(NULL
, usb_host_auto_scan
);
849 qemu_mod_timer(usb_auto_timer
, qemu_get_clock(rt_clock
) + 2000);
853 * Add autoconnect filter
854 * -1 means 'any' (device, vendor, etc)
856 static void usb_host_auto_add(int bus_num
, int addr
, int vendor_id
, int product_id
)
858 struct USBAutoFilter
*f
= qemu_mallocz(sizeof(*f
));
860 fprintf(stderr
, "husb: failed to allocate auto filter\n");
864 f
->bus_num
= bus_num
;
866 f
->vendor_id
= vendor_id
;
867 f
->product_id
= product_id
;
869 if (!usb_auto_filter
) {
871 * First entry. Init and start the monitor.
872 * Right now we're using timer to check for new devices.
873 * If this turns out to be too expensive we can move that into a
876 usb_auto_timer
= qemu_new_timer(rt_clock
, usb_host_auto_timer
, NULL
);
877 if (!usb_auto_timer
) {
878 fprintf(stderr
, "husb: failed to allocate auto scan timer\n");
883 /* Check for new devices every two seconds */
884 qemu_mod_timer(usb_auto_timer
, qemu_get_clock(rt_clock
) + 2000);
887 dprintf("husb: auto filter: bus_num %d addr %d vid %d pid %d\n",
888 bus_num
, addr
, vendor_id
, product_id
);
890 f
->next
= usb_auto_filter
;
894 typedef struct FindDeviceState
{
899 char product_name
[PRODUCT_NAME_SZ
];
902 static int usb_host_find_device_scan(void *opaque
, int bus_num
, int addr
,
904 int vendor_id
, int product_id
,
905 const char *product_name
, int speed
)
907 FindDeviceState
*s
= opaque
;
908 if ((vendor_id
== s
->vendor_id
&&
909 product_id
== s
->product_id
) ||
910 (bus_num
== s
->bus_num
&&
912 pstrcpy(s
->product_name
, PRODUCT_NAME_SZ
, product_name
);
913 s
->bus_num
= bus_num
;
922 'bus.addr' (decimal numbers) or
923 'vendor_id:product_id' (hexa numbers) */
924 static int usb_host_find_device(int *pbus_num
, int *paddr
,
925 char *product_name
, int product_name_size
,
932 p
= strchr(devname
, '.');
934 *pbus_num
= strtoul(devname
, NULL
, 0);
936 if (*(p
+ 1) == '*') {
937 usb_host_auto_add(*pbus_num
, -1, -1, -1);
941 *paddr
= strtoul(p
+ 1, NULL
, 0);
942 fs
.bus_num
= *pbus_num
;
944 ret
= usb_host_scan(&fs
, usb_host_find_device_scan
);
946 pstrcpy(product_name
, product_name_size
, fs
.product_name
);
949 p
= strchr(devname
, ':');
951 fs
.vendor_id
= strtoul(devname
, NULL
, 16);
953 if (*(p
+ 1) == '*') {
954 usb_host_auto_add(-1, -1, fs
.vendor_id
, -1);
958 fs
.product_id
= strtoul(p
+ 1, NULL
, 16);
959 ret
= usb_host_scan(&fs
, usb_host_find_device_scan
);
961 *pbus_num
= fs
.bus_num
;
963 pstrcpy(product_name
, product_name_size
, fs
.product_name
);
970 /**********************/
971 /* USB host device info */
973 struct usb_class_info
{
975 const char *class_name
;
978 static const struct usb_class_info usb_class_info
[] = {
979 { USB_CLASS_AUDIO
, "Audio"},
980 { USB_CLASS_COMM
, "Communication"},
981 { USB_CLASS_HID
, "HID"},
982 { USB_CLASS_HUB
, "Hub" },
983 { USB_CLASS_PHYSICAL
, "Physical" },
984 { USB_CLASS_PRINTER
, "Printer" },
985 { USB_CLASS_MASS_STORAGE
, "Storage" },
986 { USB_CLASS_CDC_DATA
, "Data" },
987 { USB_CLASS_APP_SPEC
, "Application Specific" },
988 { USB_CLASS_VENDOR_SPEC
, "Vendor Specific" },
989 { USB_CLASS_STILL_IMAGE
, "Still Image" },
990 { USB_CLASS_CSCID
, "Smart Card" },
991 { USB_CLASS_CONTENT_SEC
, "Content Security" },
995 static const char *usb_class_str(uint8_t class)
997 const struct usb_class_info
*p
;
998 for(p
= usb_class_info
; p
->class != -1; p
++) {
999 if (p
->class == class)
1002 return p
->class_name
;
1005 static void usb_info_device(int bus_num
, int addr
, int class_id
,
1006 int vendor_id
, int product_id
,
1007 const char *product_name
,
1010 const char *class_str
, *speed_str
;
1016 case USB_SPEED_FULL
:
1019 case USB_SPEED_HIGH
:
1027 term_printf(" Device %d.%d, speed %s Mb/s\n",
1028 bus_num
, addr
, speed_str
);
1029 class_str
= usb_class_str(class_id
);
1031 term_printf(" %s:", class_str
);
1033 term_printf(" Class %02x:", class_id
);
1034 term_printf(" USB device %04x:%04x", vendor_id
, product_id
);
1035 if (product_name
[0] != '\0')
1036 term_printf(", %s", product_name
);
1040 static int usb_host_info_device(void *opaque
, int bus_num
, int addr
,
1042 int vendor_id
, int product_id
,
1043 const char *product_name
,
1046 usb_info_device(bus_num
, addr
, class_id
, vendor_id
, product_id
,
1047 product_name
, speed
);
1051 void usb_host_info(void)
1053 usb_host_scan(NULL
, usb_host_info_device
);
1058 void usb_host_info(void)
1060 term_printf("USB host devices not supported\n");
1063 /* XXX: modify configure to compile the right host driver */
1064 USBDevice
*usb_host_device_open(const char *devname
)