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 * Major rewrite to support fully async operation
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
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:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
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
33 #include "qemu-common.h"
34 #include "qemu-timer.h"
39 #include <sys/ioctl.h>
41 #include <linux/usbdevice_fs.h>
42 #include <linux/version.h>
45 /* We redefine it to avoid version problems */
46 struct usb_ctrltransfer
{
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
);
63 #define DPRINTF printf
68 #define USBDBG_DEVOPENED "husb: opened %s/devices\n"
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"
77 static char *usb_host_device_path
;
84 static int usb_fs_type
;
86 /* endpoint association data */
87 #define ISO_FRAME_DESC_PER_URB 32
88 #define INVALID_EP_TYPE 255
90 /* devio.c limits single requests to 16k */
91 #define MAX_USBFS_BUFFER_SIZE 16384
93 typedef struct AsyncURB AsyncURB
;
106 struct USBAutoFilter
{
114 typedef struct USBHostDevice
{
123 uint32_t iso_urb_count
;
126 struct endp_data endp_table
[MAX_ENDPOINTS
];
127 QLIST_HEAD(, AsyncURB
) aurbs
;
129 /* Host side address */
132 char port
[MAX_PORTLEN
];
133 struct USBAutoFilter match
;
135 QTAILQ_ENTRY(USBHostDevice
) next
;
138 static QTAILQ_HEAD(, USBHostDevice
) hostdevs
= QTAILQ_HEAD_INITIALIZER(hostdevs
);
140 static int usb_host_close(USBHostDevice
*dev
);
141 static int parse_filter(const char *spec
, struct USBAutoFilter
*f
);
142 static void usb_host_auto_check(void *unused
);
143 static int usb_host_read_file(char *line
, size_t line_size
,
144 const char *device_file
, const char *device_name
);
146 static struct endp_data
*get_endp(USBHostDevice
*s
, int ep
)
148 return s
->endp_table
+ ep
- 1;
151 static int is_isoc(USBHostDevice
*s
, int ep
)
153 return get_endp(s
, ep
)->type
== USBDEVFS_URB_TYPE_ISO
;
156 static int is_valid(USBHostDevice
*s
, int ep
)
158 return get_endp(s
, ep
)->type
!= INVALID_EP_TYPE
;
161 static int is_halted(USBHostDevice
*s
, int ep
)
163 return get_endp(s
, ep
)->halted
;
166 static void clear_halt(USBHostDevice
*s
, int ep
)
168 get_endp(s
, ep
)->halted
= 0;
171 static void set_halt(USBHostDevice
*s
, int ep
)
173 get_endp(s
, ep
)->halted
= 1;
176 static int is_iso_started(USBHostDevice
*s
, int ep
)
178 return get_endp(s
, ep
)->iso_started
;
181 static void clear_iso_started(USBHostDevice
*s
, int ep
)
183 get_endp(s
, ep
)->iso_started
= 0;
186 static void set_iso_started(USBHostDevice
*s
, int ep
)
188 struct endp_data
*e
= get_endp(s
, ep
);
189 if (!e
->iso_started
) {
195 static int change_iso_inflight(USBHostDevice
*s
, int ep
, int value
)
197 struct endp_data
*e
= get_endp(s
, ep
);
199 e
->inflight
+= value
;
203 static void set_iso_urb(USBHostDevice
*s
, int ep
, AsyncURB
*iso_urb
)
205 get_endp(s
, ep
)->iso_urb
= iso_urb
;
208 static AsyncURB
*get_iso_urb(USBHostDevice
*s
, int ep
)
210 return get_endp(s
, ep
)->iso_urb
;
213 static void set_iso_urb_idx(USBHostDevice
*s
, int ep
, int i
)
215 get_endp(s
, ep
)->iso_urb_idx
= i
;
218 static int get_iso_urb_idx(USBHostDevice
*s
, int ep
)
220 return get_endp(s
, ep
)->iso_urb_idx
;
223 static void set_iso_buffer_used(USBHostDevice
*s
, int ep
, int i
)
225 get_endp(s
, ep
)->iso_buffer_used
= i
;
228 static int get_iso_buffer_used(USBHostDevice
*s
, int ep
)
230 return get_endp(s
, ep
)->iso_buffer_used
;
233 static void set_max_packet_size(USBHostDevice
*s
, int ep
, uint8_t *descriptor
)
235 int raw
= descriptor
[4] + (descriptor
[5] << 8);
236 int size
, microframes
;
239 switch ((raw
>> 11) & 3) {
240 case 1: microframes
= 2; break;
241 case 2: microframes
= 3; break;
242 default: microframes
= 1; break;
244 get_endp(s
, ep
)->max_packet_size
= size
* microframes
;
247 static int get_max_packet_size(USBHostDevice
*s
, int ep
)
249 return get_endp(s
, ep
)->max_packet_size
;
254 * We always allocate iso packet descriptors even for bulk transfers
255 * to simplify allocation and casts.
259 struct usbdevfs_urb urb
;
260 struct usbdevfs_iso_packet_desc isocpd
[ISO_FRAME_DESC_PER_URB
];
262 QLIST_ENTRY(AsyncURB
) next
;
264 /* For regular async urbs */
266 int more
; /* large transfer, more urbs follow */
268 /* For buffered iso handling */
269 int iso_frame_idx
; /* -1 means in flight */
272 static AsyncURB
*async_alloc(USBHostDevice
*s
)
274 AsyncURB
*aurb
= qemu_mallocz(sizeof(AsyncURB
));
276 QLIST_INSERT_HEAD(&s
->aurbs
, aurb
, next
);
280 static void async_free(AsyncURB
*aurb
)
282 QLIST_REMOVE(aurb
, next
);
286 static void do_disconnect(USBHostDevice
*s
)
288 printf("husb: device %d.%d disconnected\n",
289 s
->bus_num
, s
->addr
);
291 usb_host_auto_check(NULL
);
294 static void async_complete(void *opaque
)
296 USBHostDevice
*s
= opaque
;
303 int r
= ioctl(s
->fd
, USBDEVFS_REAPURBNDELAY
, &aurb
);
305 if (errno
== EAGAIN
) {
307 fprintf(stderr
, "husb: %d iso urbs finished at once\n", urbs
);
311 if (errno
== ENODEV
&& !s
->closing
) {
316 DPRINTF("husb: async. reap urb failed errno %d\n", errno
);
320 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
321 aurb
, aurb
->urb
.status
, aurb
->urb
.actual_length
);
323 /* If this is a buffered iso urb mark it as complete and don't do
324 anything else (it is handled further in usb_host_handle_iso_data) */
325 if (aurb
->iso_frame_idx
== -1) {
327 if (aurb
->urb
.status
== -EPIPE
) {
328 set_halt(s
, aurb
->urb
.endpoint
& 0xf);
330 aurb
->iso_frame_idx
= 0;
332 inflight
= change_iso_inflight(s
, aurb
->urb
.endpoint
& 0xf, -1);
333 if (inflight
== 0 && is_iso_started(s
, aurb
->urb
.endpoint
& 0xf)) {
334 fprintf(stderr
, "husb: out of buffers for iso stream\n");
342 switch (aurb
->urb
.status
) {
344 p
->len
+= aurb
->urb
.actual_length
;
348 set_halt(s
, p
->devep
);
349 p
->len
= USB_RET_STALL
;
353 p
->len
= USB_RET_NAK
;
357 if (aurb
->urb
.type
== USBDEVFS_URB_TYPE_CONTROL
) {
358 usb_generic_async_ctrl_complete(&s
->dev
, p
);
359 } else if (!aurb
->more
) {
360 usb_packet_complete(&s
->dev
, p
);
368 static void usb_host_async_cancel(USBDevice
*dev
, USBPacket
*p
)
370 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
373 QLIST_FOREACH(aurb
, &s
->aurbs
, next
) {
374 if (p
!= aurb
->packet
) {
378 DPRINTF("husb: async cancel: packet %p, aurb %p\n", p
, aurb
);
380 /* Mark it as dead (see async_complete above) */
383 int r
= ioctl(s
->fd
, USBDEVFS_DISCARDURB
, aurb
);
385 DPRINTF("husb: async. discard urb failed errno %d\n", errno
);
390 static int usb_host_claim_interfaces(USBHostDevice
*dev
, int configuration
)
392 const char *op
= NULL
;
393 int dev_descr_len
, config_descr_len
;
394 int interface
, nb_interfaces
;
397 if (configuration
== 0) /* address state - ignore */
400 DPRINTF("husb: claiming interfaces. config %d\n", configuration
);
403 dev_descr_len
= dev
->descr
[0];
404 if (dev_descr_len
> dev
->descr_len
) {
405 fprintf(stderr
, "husb: update iface failed. descr too short\n");
410 while (i
< dev
->descr_len
) {
411 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
413 dev
->descr
[i
], dev
->descr
[i
+1]);
415 if (dev
->descr
[i
+1] != USB_DT_CONFIG
) {
419 config_descr_len
= dev
->descr
[i
];
421 printf("husb: config #%d need %d\n", dev
->descr
[i
+ 5], configuration
);
423 if (configuration
< 0 || configuration
== dev
->descr
[i
+ 5]) {
424 configuration
= dev
->descr
[i
+ 5];
428 i
+= config_descr_len
;
431 if (i
>= dev
->descr_len
) {
433 "husb: update iface failed. no matching configuration\n");
436 nb_interfaces
= dev
->descr
[i
+ 4];
438 #ifdef USBDEVFS_DISCONNECT
439 /* earlier Linux 2.4 do not support that */
441 struct usbdevfs_ioctl ctrl
;
442 for (interface
= 0; interface
< nb_interfaces
; interface
++) {
443 ctrl
.ioctl_code
= USBDEVFS_DISCONNECT
;
444 ctrl
.ifno
= interface
;
446 op
= "USBDEVFS_DISCONNECT";
447 ret
= ioctl(dev
->fd
, USBDEVFS_IOCTL
, &ctrl
);
448 if (ret
< 0 && errno
!= ENODATA
) {
455 /* XXX: only grab if all interfaces are free */
456 for (interface
= 0; interface
< nb_interfaces
; interface
++) {
457 op
= "USBDEVFS_CLAIMINTERFACE";
458 ret
= ioctl(dev
->fd
, USBDEVFS_CLAIMINTERFACE
, &interface
);
460 if (errno
== EBUSY
) {
461 printf("husb: update iface. device already grabbed\n");
463 perror("husb: failed to claim interface");
469 printf("husb: %d interfaces claimed for configuration %d\n",
470 nb_interfaces
, configuration
);
472 dev
->ninterfaces
= nb_interfaces
;
473 dev
->configuration
= configuration
;
477 if (errno
== ENODEV
) {
484 static int usb_host_release_interfaces(USBHostDevice
*s
)
488 DPRINTF("husb: releasing interfaces\n");
490 for (i
= 0; i
< s
->ninterfaces
; i
++) {
491 ret
= ioctl(s
->fd
, USBDEVFS_RELEASEINTERFACE
, &i
);
493 perror("husb: failed to release interface");
501 static void usb_host_handle_reset(USBDevice
*dev
)
503 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
505 DPRINTF("husb: reset device %u.%u\n", s
->bus_num
, s
->addr
);
507 ioctl(s
->fd
, USBDEVFS_RESET
);
509 usb_host_claim_interfaces(s
, s
->configuration
);
512 static void usb_host_handle_destroy(USBDevice
*dev
)
514 USBHostDevice
*s
= (USBHostDevice
*)dev
;
517 QTAILQ_REMOVE(&hostdevs
, s
, next
);
518 qemu_remove_exit_notifier(&s
->exit
);
521 static int usb_linux_update_endp_table(USBHostDevice
*s
);
523 /* iso data is special, we need to keep enough urbs in flight to make sure
524 that the controller never runs out of them, otherwise the device will
525 likely suffer a buffer underrun / overrun. */
526 static AsyncURB
*usb_host_alloc_iso(USBHostDevice
*s
, uint8_t ep
, int in
)
529 int i
, j
, len
= get_max_packet_size(s
, ep
);
531 aurb
= qemu_mallocz(s
->iso_urb_count
* sizeof(*aurb
));
532 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
533 aurb
[i
].urb
.endpoint
= ep
;
534 aurb
[i
].urb
.buffer_length
= ISO_FRAME_DESC_PER_URB
* len
;
535 aurb
[i
].urb
.buffer
= qemu_malloc(aurb
[i
].urb
.buffer_length
);
536 aurb
[i
].urb
.type
= USBDEVFS_URB_TYPE_ISO
;
537 aurb
[i
].urb
.flags
= USBDEVFS_URB_ISO_ASAP
;
538 aurb
[i
].urb
.number_of_packets
= ISO_FRAME_DESC_PER_URB
;
539 for (j
= 0 ; j
< ISO_FRAME_DESC_PER_URB
; j
++)
540 aurb
[i
].urb
.iso_frame_desc
[j
].length
= len
;
542 aurb
[i
].urb
.endpoint
|= 0x80;
543 /* Mark as fully consumed (idle) */
544 aurb
[i
].iso_frame_idx
= ISO_FRAME_DESC_PER_URB
;
547 set_iso_urb(s
, ep
, aurb
);
552 static void usb_host_stop_n_free_iso(USBHostDevice
*s
, uint8_t ep
)
555 int i
, ret
, killed
= 0, free
= 1;
557 aurb
= get_iso_urb(s
, ep
);
562 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
564 if (aurb
[i
].iso_frame_idx
== -1) {
565 ret
= ioctl(s
->fd
, USBDEVFS_DISCARDURB
, &aurb
[i
]);
567 printf("husb: discard isoc in urb failed errno %d\n", errno
);
575 /* Make sure any urbs we've killed are reaped before we free them */
580 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
581 qemu_free(aurb
[i
].urb
.buffer
);
587 printf("husb: leaking iso urbs because of discard failure\n");
588 set_iso_urb(s
, ep
, NULL
);
589 set_iso_urb_idx(s
, ep
, 0);
590 clear_iso_started(s
, ep
);
593 static int urb_status_to_usb_ret(int status
)
597 return USB_RET_STALL
;
603 static int usb_host_handle_iso_data(USBHostDevice
*s
, USBPacket
*p
, int in
)
606 int i
, j
, ret
, max_packet_size
, offset
, len
= 0;
608 max_packet_size
= get_max_packet_size(s
, p
->devep
);
609 if (max_packet_size
== 0)
612 aurb
= get_iso_urb(s
, p
->devep
);
614 aurb
= usb_host_alloc_iso(s
, p
->devep
, in
);
617 i
= get_iso_urb_idx(s
, p
->devep
);
618 j
= aurb
[i
].iso_frame_idx
;
619 if (j
>= 0 && j
< ISO_FRAME_DESC_PER_URB
) {
621 /* Check urb status */
622 if (aurb
[i
].urb
.status
) {
623 len
= urb_status_to_usb_ret(aurb
[i
].urb
.status
);
624 /* Move to the next urb */
625 aurb
[i
].iso_frame_idx
= ISO_FRAME_DESC_PER_URB
- 1;
626 /* Check frame status */
627 } else if (aurb
[i
].urb
.iso_frame_desc
[j
].status
) {
628 len
= urb_status_to_usb_ret(
629 aurb
[i
].urb
.iso_frame_desc
[j
].status
);
630 /* Check the frame fits */
631 } else if (aurb
[i
].urb
.iso_frame_desc
[j
].actual_length
> p
->len
) {
632 printf("husb: received iso data is larger then packet\n");
634 /* All good copy data over */
636 len
= aurb
[i
].urb
.iso_frame_desc
[j
].actual_length
;
639 j
* aurb
[i
].urb
.iso_frame_desc
[0].length
,
644 offset
= (j
== 0) ? 0 : get_iso_buffer_used(s
, p
->devep
);
646 /* Check the frame fits */
647 if (len
> max_packet_size
) {
648 printf("husb: send iso data is larger then max packet size\n");
652 /* All good copy data over */
653 memcpy(aurb
[i
].urb
.buffer
+ offset
, p
->data
, len
);
654 aurb
[i
].urb
.iso_frame_desc
[j
].length
= len
;
656 set_iso_buffer_used(s
, p
->devep
, offset
);
658 /* Start the stream once we have buffered enough data */
659 if (!is_iso_started(s
, p
->devep
) && i
== 1 && j
== 8) {
660 set_iso_started(s
, p
->devep
);
663 aurb
[i
].iso_frame_idx
++;
664 if (aurb
[i
].iso_frame_idx
== ISO_FRAME_DESC_PER_URB
) {
665 i
= (i
+ 1) % s
->iso_urb_count
;
666 set_iso_urb_idx(s
, p
->devep
, i
);
670 set_iso_started(s
, p
->devep
);
672 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
676 if (is_iso_started(s
, p
->devep
)) {
677 /* (Re)-submit all fully consumed / filled urbs */
678 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
679 if (aurb
[i
].iso_frame_idx
== ISO_FRAME_DESC_PER_URB
) {
680 ret
= ioctl(s
->fd
, USBDEVFS_SUBMITURB
, &aurb
[i
]);
682 printf("husb error submitting iso urb %d: %d\n", i
, errno
);
683 if (!in
|| len
== 0) {
695 aurb
[i
].iso_frame_idx
= -1;
696 change_iso_inflight(s
, p
->devep
, +1);
704 static int usb_host_handle_data(USBDevice
*dev
, USBPacket
*p
)
706 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
707 struct usbdevfs_urb
*urb
;
713 if (!is_valid(s
, p
->devep
)) {
717 if (p
->pid
== USB_TOKEN_IN
) {
718 ep
= p
->devep
| 0x80;
723 if (is_halted(s
, p
->devep
)) {
724 ret
= ioctl(s
->fd
, USBDEVFS_CLEAR_HALT
, &ep
);
726 DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",
730 clear_halt(s
, p
->devep
);
733 if (is_isoc(s
, p
->devep
)) {
734 return usb_host_handle_iso_data(s
, p
, p
->pid
== USB_TOKEN_IN
);
741 aurb
= async_alloc(s
);
746 urb
->type
= USBDEVFS_URB_TYPE_BULK
;
747 urb
->usercontext
= s
;
750 if (rem
> MAX_USBFS_BUFFER_SIZE
) {
751 urb
->buffer_length
= MAX_USBFS_BUFFER_SIZE
;
754 urb
->buffer_length
= rem
;
757 pbuf
+= urb
->buffer_length
;
758 rem
-= urb
->buffer_length
;
760 ret
= ioctl(s
->fd
, USBDEVFS_SUBMITURB
, urb
);
762 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
763 urb
->endpoint
, urb
->buffer_length
, aurb
->more
, p
, aurb
);
766 DPRINTF("husb: submit failed. errno %d\n", errno
);
774 return USB_RET_STALL
;
779 return USB_RET_ASYNC
;
782 static int ctrl_error(void)
784 if (errno
== ETIMEDOUT
) {
787 return USB_RET_STALL
;
791 static int usb_host_set_address(USBHostDevice
*s
, int addr
)
793 DPRINTF("husb: ctrl set addr %u\n", addr
);
798 static int usb_host_set_config(USBHostDevice
*s
, int config
)
800 usb_host_release_interfaces(s
);
802 int ret
= ioctl(s
->fd
, USBDEVFS_SETCONFIGURATION
, &config
);
804 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config
, ret
, errno
);
809 usb_host_claim_interfaces(s
, config
);
813 static int usb_host_set_interface(USBHostDevice
*s
, int iface
, int alt
)
815 struct usbdevfs_setinterface si
;
818 for (i
= 1; i
<= MAX_ENDPOINTS
; i
++) {
820 usb_host_stop_n_free_iso(s
, i
);
824 si
.interface
= iface
;
826 ret
= ioctl(s
->fd
, USBDEVFS_SETINTERFACE
, &si
);
828 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
829 iface
, alt
, ret
, errno
);
834 usb_linux_update_endp_table(s
);
838 static int usb_host_handle_control(USBDevice
*dev
, USBPacket
*p
,
839 int request
, int value
, int index
, int length
, uint8_t *data
)
841 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
842 struct usbdevfs_urb
*urb
;
847 * Process certain standard device requests.
848 * These are infrequent and are processed synchronously.
851 /* Note request is (bRequestType << 8) | bRequest */
852 DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",
853 request
>> 8, request
& 0xff, value
, index
, length
);
856 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
857 return usb_host_set_address(s
, value
);
859 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
860 return usb_host_set_config(s
, value
& 0xff);
862 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
863 return usb_host_set_interface(s
, index
, value
);
866 /* The rest are asynchronous */
868 if (length
> sizeof(dev
->data_buf
)) {
869 fprintf(stderr
, "husb: ctrl buffer too small (%d > %zu)\n",
870 length
, sizeof(dev
->data_buf
));
871 return USB_RET_STALL
;
874 aurb
= async_alloc(s
);
878 * Setup ctrl transfer.
880 * s->ctrl is laid out such that data buffer immediately follows
881 * 'req' struct which is exactly what usbdevfs expects.
885 urb
->type
= USBDEVFS_URB_TYPE_CONTROL
;
886 urb
->endpoint
= p
->devep
;
888 urb
->buffer
= &dev
->setup_buf
;
889 urb
->buffer_length
= length
+ 8;
891 urb
->usercontext
= s
;
893 ret
= ioctl(s
->fd
, USBDEVFS_SUBMITURB
, urb
);
895 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb
->buffer_length
, aurb
);
898 DPRINTF("husb: submit failed. errno %d\n", errno
);
906 return USB_RET_STALL
;
910 return USB_RET_ASYNC
;
913 static int usb_linux_get_configuration(USBHostDevice
*s
)
915 uint8_t configuration
;
916 struct usb_ctrltransfer ct
;
919 if (usb_fs_type
== USB_FS_SYS
) {
920 char device_name
[32], line
[1024];
923 sprintf(device_name
, "%d-%s", s
->bus_num
, s
->port
);
925 if (!usb_host_read_file(line
, sizeof(line
), "bConfigurationValue",
929 if (sscanf(line
, "%d", &configuration
) != 1) {
932 return configuration
;
936 ct
.bRequestType
= USB_DIR_IN
;
937 ct
.bRequest
= USB_REQ_GET_CONFIGURATION
;
941 ct
.data
= &configuration
;
944 ret
= ioctl(s
->fd
, USBDEVFS_CONTROL
, &ct
);
946 perror("usb_linux_get_configuration");
950 /* in address state */
951 if (configuration
== 0) {
955 return configuration
;
958 static uint8_t usb_linux_get_alt_setting(USBHostDevice
*s
,
959 uint8_t configuration
, uint8_t interface
)
962 struct usb_ctrltransfer ct
;
965 if (usb_fs_type
== USB_FS_SYS
) {
966 char device_name
[64], line
[1024];
969 sprintf(device_name
, "%d-%s:%d.%d", s
->bus_num
, s
->port
,
970 (int)configuration
, (int)interface
);
972 if (!usb_host_read_file(line
, sizeof(line
), "bAlternateSetting",
976 if (sscanf(line
, "%d", &alt_setting
) != 1) {
983 ct
.bRequestType
= USB_DIR_IN
| USB_RECIP_INTERFACE
;
984 ct
.bRequest
= USB_REQ_GET_INTERFACE
;
986 ct
.wIndex
= interface
;
988 ct
.data
= &alt_setting
;
990 ret
= ioctl(s
->fd
, USBDEVFS_CONTROL
, &ct
);
992 /* Assume alt 0 on error */
999 /* returns 1 on problem encountered or 0 for success */
1000 static int usb_linux_update_endp_table(USBHostDevice
*s
)
1002 uint8_t *descriptors
;
1003 uint8_t devep
, type
, configuration
, alt_interface
;
1004 int interface
, length
, i
;
1006 for (i
= 0; i
< MAX_ENDPOINTS
; i
++)
1007 s
->endp_table
[i
].type
= INVALID_EP_TYPE
;
1009 i
= usb_linux_get_configuration(s
);
1014 /* get the desired configuration, interface, and endpoint descriptors
1015 * from device description */
1016 descriptors
= &s
->descr
[18];
1017 length
= s
->descr_len
- 18;
1020 if (descriptors
[i
+ 1] != USB_DT_CONFIG
||
1021 descriptors
[i
+ 5] != configuration
) {
1022 DPRINTF("invalid descriptor data - configuration\n");
1025 i
+= descriptors
[i
];
1027 while (i
< length
) {
1028 if (descriptors
[i
+ 1] != USB_DT_INTERFACE
||
1029 (descriptors
[i
+ 1] == USB_DT_INTERFACE
&&
1030 descriptors
[i
+ 4] == 0)) {
1031 i
+= descriptors
[i
];
1035 interface
= descriptors
[i
+ 2];
1036 alt_interface
= usb_linux_get_alt_setting(s
, configuration
, interface
);
1038 /* the current interface descriptor is the active interface
1039 * and has endpoints */
1040 if (descriptors
[i
+ 3] != alt_interface
) {
1041 i
+= descriptors
[i
];
1045 /* advance to the endpoints */
1046 while (i
< length
&& descriptors
[i
+1] != USB_DT_ENDPOINT
) {
1047 i
+= descriptors
[i
];
1053 while (i
< length
) {
1054 if (descriptors
[i
+ 1] != USB_DT_ENDPOINT
) {
1058 devep
= descriptors
[i
+ 2];
1059 if ((devep
& 0x0f) == 0) {
1060 fprintf(stderr
, "usb-linux: invalid ep descriptor, ep == 0\n");
1064 switch (descriptors
[i
+ 3] & 0x3) {
1066 type
= USBDEVFS_URB_TYPE_CONTROL
;
1069 type
= USBDEVFS_URB_TYPE_ISO
;
1070 set_max_packet_size(s
, (devep
& 0xf), descriptors
+ i
);
1073 type
= USBDEVFS_URB_TYPE_BULK
;
1076 type
= USBDEVFS_URB_TYPE_INTERRUPT
;
1079 DPRINTF("usb_host: malformed endpoint type\n");
1080 type
= USBDEVFS_URB_TYPE_BULK
;
1082 s
->endp_table
[(devep
& 0xf) - 1].type
= type
;
1083 s
->endp_table
[(devep
& 0xf) - 1].halted
= 0;
1085 i
+= descriptors
[i
];
1091 static int usb_host_open(USBHostDevice
*dev
, int bus_num
,
1092 int addr
, char *port
, const char *prod_name
, int speed
)
1097 if (dev
->fd
!= -1) {
1100 printf("husb: open device %d.%d\n", bus_num
, addr
);
1102 if (!usb_host_device_path
) {
1103 perror("husb: USB Host Device Path not set");
1106 snprintf(buf
, sizeof(buf
), "%s/%03d/%03d", usb_host_device_path
,
1108 fd
= open(buf
, O_RDWR
| O_NONBLOCK
);
1113 DPRINTF("husb: opened %s\n", buf
);
1115 dev
->bus_num
= bus_num
;
1117 strcpy(dev
->port
, port
);
1120 /* read the device description */
1121 dev
->descr_len
= read(fd
, dev
->descr
, sizeof(dev
->descr
));
1122 if (dev
->descr_len
<= 0) {
1123 perror("husb: reading device data failed");
1130 printf("=== begin dumping device descriptor data ===\n");
1131 for (x
= 0; x
< dev
->descr_len
; x
++) {
1132 printf("%02x ", dev
->descr
[x
]);
1134 printf("\n=== end dumping device descriptor data ===\n");
1140 * Initial configuration is -1 which makes us claim first
1141 * available config. We used to start with 1, which does not
1142 * always work. I've seen devices where first config starts
1145 if (!usb_host_claim_interfaces(dev
, -1)) {
1149 ret
= usb_linux_update_endp_table(dev
);
1155 struct usbdevfs_connectinfo ci
;
1157 ret
= ioctl(fd
, USBDEVFS_CONNECTINFO
, &ci
);
1159 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1164 speed
= USB_SPEED_LOW
;
1166 speed
= USB_SPEED_HIGH
;
1169 dev
->dev
.speed
= speed
;
1170 dev
->dev
.speedmask
= (1 << speed
);
1172 printf("husb: grabbed usb device %d.%d\n", bus_num
, addr
);
1174 if (!prod_name
|| prod_name
[0] == '\0') {
1175 snprintf(dev
->dev
.product_desc
, sizeof(dev
->dev
.product_desc
),
1176 "host:%d.%d", bus_num
, addr
);
1178 pstrcpy(dev
->dev
.product_desc
, sizeof(dev
->dev
.product_desc
),
1182 ret
= usb_device_attach(&dev
->dev
);
1187 /* USB devio uses 'write' flag to check for async completions */
1188 qemu_set_fd_handler(dev
->fd
, NULL
, async_complete
, dev
);
1193 if (dev
->fd
!= -1) {
1200 static int usb_host_close(USBHostDevice
*dev
)
1204 if (dev
->fd
== -1 || !dev
->dev
.attached
) {
1208 qemu_set_fd_handler(dev
->fd
, NULL
, NULL
, NULL
);
1210 for (i
= 1; i
<= MAX_ENDPOINTS
; i
++) {
1211 if (is_isoc(dev
, i
)) {
1212 usb_host_stop_n_free_iso(dev
, i
);
1215 async_complete(dev
);
1217 usb_device_detach(&dev
->dev
);
1218 ioctl(dev
->fd
, USBDEVFS_RESET
);
1224 static void usb_host_exit_notifier(struct Notifier
* n
)
1226 USBHostDevice
*s
= container_of(n
, USBHostDevice
, exit
);
1229 ioctl(s
->fd
, USBDEVFS_RESET
);
1233 static int usb_host_initfn(USBDevice
*dev
)
1235 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
1237 dev
->auto_attach
= 0;
1239 QTAILQ_INSERT_TAIL(&hostdevs
, s
, next
);
1240 s
->exit
.notify
= usb_host_exit_notifier
;
1241 qemu_add_exit_notifier(&s
->exit
);
1242 usb_host_auto_check(NULL
);
1246 static struct USBDeviceInfo usb_host_dev_info
= {
1247 .product_desc
= "USB Host Device",
1248 .qdev
.name
= "usb-host",
1249 .qdev
.size
= sizeof(USBHostDevice
),
1250 .init
= usb_host_initfn
,
1251 .handle_packet
= usb_generic_handle_packet
,
1252 .cancel_packet
= usb_host_async_cancel
,
1253 .handle_data
= usb_host_handle_data
,
1254 .handle_control
= usb_host_handle_control
,
1255 .handle_reset
= usb_host_handle_reset
,
1256 .handle_destroy
= usb_host_handle_destroy
,
1257 .usbdevice_name
= "host",
1258 .usbdevice_init
= usb_host_device_open
,
1259 .qdev
.props
= (Property
[]) {
1260 DEFINE_PROP_UINT32("hostbus", USBHostDevice
, match
.bus_num
, 0),
1261 DEFINE_PROP_UINT32("hostaddr", USBHostDevice
, match
.addr
, 0),
1262 DEFINE_PROP_STRING("hostport", USBHostDevice
, match
.port
),
1263 DEFINE_PROP_HEX32("vendorid", USBHostDevice
, match
.vendor_id
, 0),
1264 DEFINE_PROP_HEX32("productid", USBHostDevice
, match
.product_id
, 0),
1265 DEFINE_PROP_UINT32("isobufs", USBHostDevice
, iso_urb_count
, 4),
1266 DEFINE_PROP_END_OF_LIST(),
1270 static void usb_host_register_devices(void)
1272 usb_qdev_register(&usb_host_dev_info
);
1274 device_init(usb_host_register_devices
)
1276 USBDevice
*usb_host_device_open(const char *devname
)
1278 struct USBAutoFilter filter
;
1282 dev
= usb_create(NULL
/* FIXME */, "usb-host");
1284 if (strstr(devname
, "auto:")) {
1285 if (parse_filter(devname
, &filter
) < 0) {
1289 if ((p
= strchr(devname
, '.'))) {
1290 filter
.bus_num
= strtoul(devname
, NULL
, 0);
1291 filter
.addr
= strtoul(p
+ 1, NULL
, 0);
1292 filter
.vendor_id
= 0;
1293 filter
.product_id
= 0;
1294 } else if ((p
= strchr(devname
, ':'))) {
1297 filter
.vendor_id
= strtoul(devname
, NULL
, 16);
1298 filter
.product_id
= strtoul(p
+ 1, NULL
, 16);
1304 qdev_prop_set_uint32(&dev
->qdev
, "hostbus", filter
.bus_num
);
1305 qdev_prop_set_uint32(&dev
->qdev
, "hostaddr", filter
.addr
);
1306 qdev_prop_set_uint32(&dev
->qdev
, "vendorid", filter
.vendor_id
);
1307 qdev_prop_set_uint32(&dev
->qdev
, "productid", filter
.product_id
);
1308 qdev_init_nofail(&dev
->qdev
);
1312 qdev_free(&dev
->qdev
);
1316 int usb_host_device_close(const char *devname
)
1319 char product_name
[PRODUCT_NAME_SZ
];
1323 if (strstr(devname
, "auto:")) {
1324 return usb_host_auto_del(devname
);
1326 if (usb_host_find_device(&bus_num
, &addr
, product_name
,
1327 sizeof(product_name
), devname
) < 0) {
1330 s
= hostdev_find(bus_num
, addr
);
1332 usb_device_delete_addr(s
->bus_num
, s
->dev
.addr
);
1340 static int get_tag_value(char *buf
, int buf_size
,
1341 const char *str
, const char *tag
,
1342 const char *stopchars
)
1346 p
= strstr(str
, tag
);
1351 while (qemu_isspace(*p
)) {
1355 while (*p
!= '\0' && !strchr(stopchars
, *p
)) {
1356 if ((q
- buf
) < (buf_size
- 1)) {
1366 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1367 * host's USB devices. This is legacy support since many distributions
1368 * are moving to /sys/bus/usb
1370 static int usb_host_scan_dev(void *opaque
, USBScanFunc
*func
)
1375 int bus_num
, addr
, speed
, device_count
, class_id
, product_id
, vendor_id
;
1376 char product_name
[512];
1379 if (!usb_host_device_path
) {
1380 perror("husb: USB Host Device Path not set");
1383 snprintf(line
, sizeof(line
), "%s/devices", usb_host_device_path
);
1384 f
= fopen(line
, "r");
1386 perror("husb: cannot open devices file");
1391 bus_num
= addr
= class_id
= product_id
= vendor_id
= 0;
1392 speed
= -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1394 if (fgets(line
, sizeof(line
), f
) == NULL
) {
1397 if (strlen(line
) > 0) {
1398 line
[strlen(line
) - 1] = '\0';
1400 if (line
[0] == 'T' && line
[1] == ':') {
1401 if (device_count
&& (vendor_id
|| product_id
)) {
1402 /* New device. Add the previously discovered device. */
1403 ret
= func(opaque
, bus_num
, addr
, 0, class_id
, vendor_id
,
1404 product_id
, product_name
, speed
);
1409 if (get_tag_value(buf
, sizeof(buf
), line
, "Bus=", " ") < 0) {
1412 bus_num
= atoi(buf
);
1413 if (get_tag_value(buf
, sizeof(buf
), line
, "Dev#=", " ") < 0) {
1417 if (get_tag_value(buf
, sizeof(buf
), line
, "Spd=", " ") < 0) {
1420 if (!strcmp(buf
, "5000")) {
1421 speed
= USB_SPEED_SUPER
;
1422 } else if (!strcmp(buf
, "480")) {
1423 speed
= USB_SPEED_HIGH
;
1424 } else if (!strcmp(buf
, "1.5")) {
1425 speed
= USB_SPEED_LOW
;
1427 speed
= USB_SPEED_FULL
;
1429 product_name
[0] = '\0';
1434 } else if (line
[0] == 'P' && line
[1] == ':') {
1435 if (get_tag_value(buf
, sizeof(buf
), line
, "Vendor=", " ") < 0) {
1438 vendor_id
= strtoul(buf
, NULL
, 16);
1439 if (get_tag_value(buf
, sizeof(buf
), line
, "ProdID=", " ") < 0) {
1442 product_id
= strtoul(buf
, NULL
, 16);
1443 } else if (line
[0] == 'S' && line
[1] == ':') {
1444 if (get_tag_value(buf
, sizeof(buf
), line
, "Product=", "") < 0) {
1447 pstrcpy(product_name
, sizeof(product_name
), buf
);
1448 } else if (line
[0] == 'D' && line
[1] == ':') {
1449 if (get_tag_value(buf
, sizeof(buf
), line
, "Cls=", " (") < 0) {
1452 class_id
= strtoul(buf
, NULL
, 16);
1456 if (device_count
&& (vendor_id
|| product_id
)) {
1457 /* Add the last device. */
1458 ret
= func(opaque
, bus_num
, addr
, 0, class_id
, vendor_id
,
1459 product_id
, product_name
, speed
);
1469 * Read sys file-system device file
1471 * @line address of buffer to put file contents in
1472 * @line_size size of line
1473 * @device_file path to device file (printf format string)
1474 * @device_name device being opened (inserted into device_file)
1476 * @return 0 failed, 1 succeeded ('line' contains data)
1478 static int usb_host_read_file(char *line
, size_t line_size
,
1479 const char *device_file
, const char *device_name
)
1483 char filename
[PATH_MAX
];
1485 snprintf(filename
, PATH_MAX
, USBSYSBUS_PATH
"/devices/%s/%s", device_name
,
1487 f
= fopen(filename
, "r");
1489 ret
= fgets(line
, line_size
, f
) != NULL
;
1497 * Use /sys/bus/usb/devices/ directory to determine host's USB
1500 * This code is based on Robert Schiele's original patches posted to
1501 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1503 static int usb_host_scan_sys(void *opaque
, USBScanFunc
*func
)
1507 int bus_num
, addr
, speed
, class_id
, product_id
, vendor_id
;
1509 char port
[MAX_PORTLEN
];
1510 char product_name
[512];
1513 dir
= opendir(USBSYSBUS_PATH
"/devices");
1515 perror("husb: cannot open devices directory");
1519 while ((de
= readdir(dir
))) {
1520 if (de
->d_name
[0] != '.' && !strchr(de
->d_name
, ':')) {
1521 if (sscanf(de
->d_name
, "%d-%7[0-9.]", &bus_num
, port
) < 2) {
1525 if (!usb_host_read_file(line
, sizeof(line
), "devnum", de
->d_name
)) {
1528 if (sscanf(line
, "%d", &addr
) != 1) {
1531 if (!usb_host_read_file(line
, sizeof(line
), "bDeviceClass",
1535 if (sscanf(line
, "%x", &class_id
) != 1) {
1539 if (!usb_host_read_file(line
, sizeof(line
), "idVendor",
1543 if (sscanf(line
, "%x", &vendor_id
) != 1) {
1546 if (!usb_host_read_file(line
, sizeof(line
), "idProduct",
1550 if (sscanf(line
, "%x", &product_id
) != 1) {
1553 if (!usb_host_read_file(line
, sizeof(line
), "product",
1557 if (strlen(line
) > 0) {
1558 line
[strlen(line
) - 1] = '\0';
1560 pstrcpy(product_name
, sizeof(product_name
), line
);
1563 if (!usb_host_read_file(line
, sizeof(line
), "speed", de
->d_name
)) {
1566 if (!strcmp(line
, "5000\n")) {
1567 speed
= USB_SPEED_SUPER
;
1568 } else if (!strcmp(line
, "480\n")) {
1569 speed
= USB_SPEED_HIGH
;
1570 } else if (!strcmp(line
, "1.5\n")) {
1571 speed
= USB_SPEED_LOW
;
1573 speed
= USB_SPEED_FULL
;
1576 ret
= func(opaque
, bus_num
, addr
, port
, class_id
, vendor_id
,
1577 product_id
, product_name
, speed
);
1591 * Determine how to access the host's USB devices and call the
1592 * specific support function.
1594 static int usb_host_scan(void *opaque
, USBScanFunc
*func
)
1596 Monitor
*mon
= cur_mon
;
1600 const char *fs_type
[] = {"unknown", "proc", "dev", "sys"};
1601 char devpath
[PATH_MAX
];
1603 /* only check the host once */
1605 dir
= opendir(USBSYSBUS_PATH
"/devices");
1607 /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1608 strcpy(devpath
, USBDEVBUS_PATH
);
1609 usb_fs_type
= USB_FS_SYS
;
1611 DPRINTF(USBDBG_DEVOPENED
, USBSYSBUS_PATH
);
1614 f
= fopen(USBPROCBUS_PATH
"/devices", "r");
1616 /* devices found in /proc/bus/usb/ */
1617 strcpy(devpath
, USBPROCBUS_PATH
);
1618 usb_fs_type
= USB_FS_PROC
;
1620 DPRINTF(USBDBG_DEVOPENED
, USBPROCBUS_PATH
);
1623 /* try additional methods if an access method hasn't been found yet */
1624 f
= fopen(USBDEVBUS_PATH
"/devices", "r");
1626 /* devices found in /dev/bus/usb/ */
1627 strcpy(devpath
, USBDEVBUS_PATH
);
1628 usb_fs_type
= USB_FS_DEV
;
1630 DPRINTF(USBDBG_DEVOPENED
, USBDEVBUS_PATH
);
1636 monitor_printf(mon
, "husb: unable to access USB devices\n");
1641 /* the module setting (used later for opening devices) */
1642 usb_host_device_path
= qemu_mallocz(strlen(devpath
)+1);
1643 strcpy(usb_host_device_path
, devpath
);
1645 monitor_printf(mon
, "husb: using %s file-system with %s\n",
1646 fs_type
[usb_fs_type
], usb_host_device_path
);
1650 switch (usb_fs_type
) {
1653 ret
= usb_host_scan_dev(opaque
, func
);
1656 ret
= usb_host_scan_sys(opaque
, func
);
1665 static QEMUTimer
*usb_auto_timer
;
1667 static int usb_host_auto_scan(void *opaque
, int bus_num
, int addr
, char *port
,
1668 int class_id
, int vendor_id
, int product_id
,
1669 const char *product_name
, int speed
)
1671 struct USBAutoFilter
*f
;
1672 struct USBHostDevice
*s
;
1678 QTAILQ_FOREACH(s
, &hostdevs
, next
) {
1681 if (f
->bus_num
> 0 && f
->bus_num
!= bus_num
) {
1684 if (f
->addr
> 0 && f
->addr
!= addr
) {
1687 if (f
->port
!= NULL
&& (port
== NULL
|| strcmp(f
->port
, port
) != 0)) {
1691 if (f
->vendor_id
> 0 && f
->vendor_id
!= vendor_id
) {
1695 if (f
->product_id
> 0 && f
->product_id
!= product_id
) {
1698 /* We got a match */
1700 /* Already attached ? */
1704 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num
, addr
);
1706 usb_host_open(s
, bus_num
, addr
, port
, product_name
, speed
);
1713 static void usb_host_auto_check(void *unused
)
1715 struct USBHostDevice
*s
;
1716 int unconnected
= 0;
1718 usb_host_scan(NULL
, usb_host_auto_scan
);
1720 QTAILQ_FOREACH(s
, &hostdevs
, next
) {
1726 if (unconnected
== 0) {
1727 /* nothing to watch */
1728 if (usb_auto_timer
) {
1729 qemu_del_timer(usb_auto_timer
);
1734 if (!usb_auto_timer
) {
1735 usb_auto_timer
= qemu_new_timer_ms(rt_clock
, usb_host_auto_check
, NULL
);
1736 if (!usb_auto_timer
) {
1740 qemu_mod_timer(usb_auto_timer
, qemu_get_clock_ms(rt_clock
) + 2000);
1744 * Autoconnect filter
1746 * auto:bus:dev[:vid:pid]
1747 * auto:bus.dev[:vid:pid]
1749 * bus - bus number (dec, * means any)
1750 * dev - device number (dec, * means any)
1751 * vid - vendor id (hex, * means any)
1752 * pid - product id (hex, * means any)
1754 * See 'lsusb' output.
1756 static int parse_filter(const char *spec
, struct USBAutoFilter
*f
)
1758 enum { BUS
, DEV
, VID
, PID
, DONE
};
1759 const char *p
= spec
;
1767 for (i
= BUS
; i
< DONE
; i
++) {
1768 p
= strpbrk(p
, ":.");
1778 case BUS
: f
->bus_num
= strtol(p
, NULL
, 10); break;
1779 case DEV
: f
->addr
= strtol(p
, NULL
, 10); break;
1780 case VID
: f
->vendor_id
= strtol(p
, NULL
, 16); break;
1781 case PID
: f
->product_id
= strtol(p
, NULL
, 16); break;
1786 fprintf(stderr
, "husb: invalid auto filter spec %s\n", spec
);
1793 /**********************/
1794 /* USB host device info */
1796 struct usb_class_info
{
1798 const char *class_name
;
1801 static const struct usb_class_info usb_class_info
[] = {
1802 { USB_CLASS_AUDIO
, "Audio"},
1803 { USB_CLASS_COMM
, "Communication"},
1804 { USB_CLASS_HID
, "HID"},
1805 { USB_CLASS_HUB
, "Hub" },
1806 { USB_CLASS_PHYSICAL
, "Physical" },
1807 { USB_CLASS_PRINTER
, "Printer" },
1808 { USB_CLASS_MASS_STORAGE
, "Storage" },
1809 { USB_CLASS_CDC_DATA
, "Data" },
1810 { USB_CLASS_APP_SPEC
, "Application Specific" },
1811 { USB_CLASS_VENDOR_SPEC
, "Vendor Specific" },
1812 { USB_CLASS_STILL_IMAGE
, "Still Image" },
1813 { USB_CLASS_CSCID
, "Smart Card" },
1814 { USB_CLASS_CONTENT_SEC
, "Content Security" },
1818 static const char *usb_class_str(uint8_t class)
1820 const struct usb_class_info
*p
;
1821 for(p
= usb_class_info
; p
->class != -1; p
++) {
1822 if (p
->class == class) {
1826 return p
->class_name
;
1829 static void usb_info_device(Monitor
*mon
, int bus_num
, int addr
, char *port
,
1830 int class_id
, int vendor_id
, int product_id
,
1831 const char *product_name
,
1834 const char *class_str
, *speed_str
;
1840 case USB_SPEED_FULL
:
1843 case USB_SPEED_HIGH
:
1846 case USB_SPEED_SUPER
:
1854 monitor_printf(mon
, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1855 bus_num
, addr
, port
, speed_str
);
1856 class_str
= usb_class_str(class_id
);
1858 monitor_printf(mon
, " %s:", class_str
);
1860 monitor_printf(mon
, " Class %02x:", class_id
);
1862 monitor_printf(mon
, " USB device %04x:%04x", vendor_id
, product_id
);
1863 if (product_name
[0] != '\0') {
1864 monitor_printf(mon
, ", %s", product_name
);
1866 monitor_printf(mon
, "\n");
1869 static int usb_host_info_device(void *opaque
, int bus_num
, int addr
,
1870 char *path
, int class_id
,
1871 int vendor_id
, int product_id
,
1872 const char *product_name
,
1875 Monitor
*mon
= opaque
;
1877 usb_info_device(mon
, bus_num
, addr
, path
, class_id
, vendor_id
, product_id
,
1878 product_name
, speed
);
1882 static void dec2str(int val
, char *str
, size_t size
)
1885 snprintf(str
, size
, "*");
1887 snprintf(str
, size
, "%d", val
);
1891 static void hex2str(int val
, char *str
, size_t size
)
1894 snprintf(str
, size
, "*");
1896 snprintf(str
, size
, "%04x", val
);
1900 void usb_host_info(Monitor
*mon
)
1902 struct USBAutoFilter
*f
;
1903 struct USBHostDevice
*s
;
1905 usb_host_scan(mon
, usb_host_info_device
);
1907 if (QTAILQ_EMPTY(&hostdevs
)) {
1911 monitor_printf(mon
, " Auto filters:\n");
1912 QTAILQ_FOREACH(s
, &hostdevs
, next
) {
1913 char bus
[10], addr
[10], vid
[10], pid
[10];
1915 dec2str(f
->bus_num
, bus
, sizeof(bus
));
1916 dec2str(f
->addr
, addr
, sizeof(addr
));
1917 hex2str(f
->vendor_id
, vid
, sizeof(vid
));
1918 hex2str(f
->product_id
, pid
, sizeof(pid
));
1919 monitor_printf(mon
, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
1920 bus
, addr
, f
->port
? f
->port
: "*", vid
, pid
);