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"
40 #include <sys/ioctl.h>
42 #include <linux/usbdevice_fs.h>
43 #include <linux/version.h>
45 #include "hw/usb/desc.h"
47 /* We redefine it to avoid version problems */
48 struct usb_ctrltransfer
{
58 typedef int USBScanFunc(void *opaque
, int bus_num
, int addr
, const char *port
,
59 int class_id
, int vendor_id
, int product_id
,
60 const char *product_name
, int speed
);
65 #define DPRINTF printf
70 #define PRODUCT_NAME_SZ 32
71 #define MAX_PORTLEN 16
73 /* endpoint association data */
74 #define ISO_FRAME_DESC_PER_URB 32
76 /* devio.c limits single requests to 16k */
77 #define MAX_USBFS_BUFFER_SIZE 16384
79 typedef struct AsyncURB AsyncURB
;
90 struct USBAutoFilter
{
98 enum USBHostDeviceOptions
{
99 USB_HOST_OPT_PIPELINE
,
102 typedef struct USBHostDevice
{
111 uint32_t iso_urb_count
;
116 struct endp_data ep_in
[USB_MAX_ENDPOINTS
];
117 struct endp_data ep_out
[USB_MAX_ENDPOINTS
];
118 QLIST_HEAD(, AsyncURB
) aurbs
;
120 /* Host side address */
123 char port
[MAX_PORTLEN
];
124 struct USBAutoFilter match
;
128 QTAILQ_ENTRY(USBHostDevice
) next
;
131 static QTAILQ_HEAD(, USBHostDevice
) hostdevs
= QTAILQ_HEAD_INITIALIZER(hostdevs
);
133 static int usb_host_close(USBHostDevice
*dev
);
134 static int parse_filter(const char *spec
, struct USBAutoFilter
*f
);
135 static void usb_host_auto_check(void *unused
);
136 static int usb_host_read_file(char *line
, size_t line_size
,
137 const char *device_file
, const char *device_name
);
138 static void usb_linux_update_endp_table(USBHostDevice
*s
);
140 static int usb_host_usbfs_type(USBHostDevice
*s
, USBPacket
*p
)
142 static const int usbfs
[] = {
143 [USB_ENDPOINT_XFER_CONTROL
] = USBDEVFS_URB_TYPE_CONTROL
,
144 [USB_ENDPOINT_XFER_ISOC
] = USBDEVFS_URB_TYPE_ISO
,
145 [USB_ENDPOINT_XFER_BULK
] = USBDEVFS_URB_TYPE_BULK
,
146 [USB_ENDPOINT_XFER_INT
] = USBDEVFS_URB_TYPE_INTERRUPT
,
148 uint8_t type
= p
->ep
->type
;
149 assert(type
< ARRAY_SIZE(usbfs
));
153 static int usb_host_do_reset(USBHostDevice
*dev
)
159 gettimeofday(&s
, NULL
);
160 ret
= ioctl(dev
->fd
, USBDEVFS_RESET
);
161 gettimeofday(&e
, NULL
);
162 usecs
= (e
.tv_sec
- s
.tv_sec
) * 1000000;
163 usecs
+= e
.tv_usec
- s
.tv_usec
;
164 if (usecs
> 1000000) {
165 /* more than a second, something is fishy, broken usb device? */
166 fprintf(stderr
, "husb: device %d:%d reset took %d.%06d seconds\n",
167 dev
->bus_num
, dev
->addr
, usecs
/ 1000000, usecs
% 1000000);
172 static struct endp_data
*get_endp(USBHostDevice
*s
, int pid
, int ep
)
174 struct endp_data
*eps
= pid
== USB_TOKEN_IN
? s
->ep_in
: s
->ep_out
;
175 assert(pid
== USB_TOKEN_IN
|| pid
== USB_TOKEN_OUT
);
176 assert(ep
> 0 && ep
<= USB_MAX_ENDPOINTS
);
180 static int is_isoc(USBHostDevice
*s
, int pid
, int ep
)
182 return usb_ep_get_type(&s
->dev
, pid
, ep
) == USB_ENDPOINT_XFER_ISOC
;
185 static int is_valid(USBHostDevice
*s
, int pid
, int ep
)
187 return usb_ep_get_type(&s
->dev
, pid
, ep
) != USB_ENDPOINT_XFER_INVALID
;
190 static int is_halted(USBHostDevice
*s
, int pid
, int ep
)
192 return get_endp(s
, pid
, ep
)->halted
;
195 static void clear_halt(USBHostDevice
*s
, int pid
, int ep
)
197 trace_usb_host_ep_clear_halt(s
->bus_num
, s
->addr
, ep
);
198 get_endp(s
, pid
, ep
)->halted
= 0;
201 static void set_halt(USBHostDevice
*s
, int pid
, int ep
)
204 trace_usb_host_ep_set_halt(s
->bus_num
, s
->addr
, ep
);
205 get_endp(s
, pid
, ep
)->halted
= 1;
209 static int is_iso_started(USBHostDevice
*s
, int pid
, int ep
)
211 return get_endp(s
, pid
, ep
)->iso_started
;
214 static void clear_iso_started(USBHostDevice
*s
, int pid
, int ep
)
216 trace_usb_host_iso_stop(s
->bus_num
, s
->addr
, ep
);
217 get_endp(s
, pid
, ep
)->iso_started
= 0;
220 static void set_iso_started(USBHostDevice
*s
, int pid
, int ep
)
222 struct endp_data
*e
= get_endp(s
, pid
, ep
);
224 trace_usb_host_iso_start(s
->bus_num
, s
->addr
, ep
);
225 if (!e
->iso_started
) {
231 static int change_iso_inflight(USBHostDevice
*s
, int pid
, int ep
, int value
)
233 struct endp_data
*e
= get_endp(s
, pid
, ep
);
235 e
->inflight
+= value
;
239 static void set_iso_urb(USBHostDevice
*s
, int pid
, int ep
, AsyncURB
*iso_urb
)
241 get_endp(s
, pid
, ep
)->iso_urb
= iso_urb
;
244 static AsyncURB
*get_iso_urb(USBHostDevice
*s
, int pid
, int ep
)
246 return get_endp(s
, pid
, ep
)->iso_urb
;
249 static void set_iso_urb_idx(USBHostDevice
*s
, int pid
, int ep
, int i
)
251 get_endp(s
, pid
, ep
)->iso_urb_idx
= i
;
254 static int get_iso_urb_idx(USBHostDevice
*s
, int pid
, int ep
)
256 return get_endp(s
, pid
, ep
)->iso_urb_idx
;
259 static void set_iso_buffer_used(USBHostDevice
*s
, int pid
, int ep
, int i
)
261 get_endp(s
, pid
, ep
)->iso_buffer_used
= i
;
264 static int get_iso_buffer_used(USBHostDevice
*s
, int pid
, int ep
)
266 return get_endp(s
, pid
, ep
)->iso_buffer_used
;
271 * We always allocate iso packet descriptors even for bulk transfers
272 * to simplify allocation and casts.
276 struct usbdevfs_urb urb
;
277 struct usbdevfs_iso_packet_desc isocpd
[ISO_FRAME_DESC_PER_URB
];
279 QLIST_ENTRY(AsyncURB
) next
;
281 /* For regular async urbs */
283 int more
; /* large transfer, more urbs follow */
285 /* For buffered iso handling */
286 int iso_frame_idx
; /* -1 means in flight */
289 static AsyncURB
*async_alloc(USBHostDevice
*s
)
291 AsyncURB
*aurb
= g_malloc0(sizeof(AsyncURB
));
293 QLIST_INSERT_HEAD(&s
->aurbs
, aurb
, next
);
297 static void async_free(AsyncURB
*aurb
)
299 QLIST_REMOVE(aurb
, next
);
303 static void do_disconnect(USBHostDevice
*s
)
306 usb_host_auto_check(NULL
);
309 static void async_complete(void *opaque
)
311 USBHostDevice
*s
= opaque
;
318 int r
= ioctl(s
->fd
, USBDEVFS_REAPURBNDELAY
, &aurb
);
320 if (errno
== EAGAIN
) {
322 /* indicates possible latency issues */
323 trace_usb_host_iso_many_urbs(s
->bus_num
, s
->addr
, urbs
);
327 if (errno
== ENODEV
) {
329 trace_usb_host_disconnect(s
->bus_num
, s
->addr
);
335 perror("USBDEVFS_REAPURBNDELAY");
339 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
340 aurb
, aurb
->urb
.status
, aurb
->urb
.actual_length
);
342 /* If this is a buffered iso urb mark it as complete and don't do
343 anything else (it is handled further in usb_host_handle_iso_data) */
344 if (aurb
->iso_frame_idx
== -1) {
346 int pid
= (aurb
->urb
.endpoint
& USB_DIR_IN
) ?
347 USB_TOKEN_IN
: USB_TOKEN_OUT
;
348 int ep
= aurb
->urb
.endpoint
& 0xf;
349 if (aurb
->urb
.status
== -EPIPE
) {
350 set_halt(s
, pid
, ep
);
352 aurb
->iso_frame_idx
= 0;
354 inflight
= change_iso_inflight(s
, pid
, ep
, -1);
355 if (inflight
== 0 && is_iso_started(s
, pid
, ep
)) {
356 /* can be latency issues, or simply end of stream */
357 trace_usb_host_iso_out_of_bufs(s
->bus_num
, s
->addr
, ep
);
363 trace_usb_host_urb_complete(s
->bus_num
, s
->addr
, aurb
, aurb
->urb
.status
,
364 aurb
->urb
.actual_length
, aurb
->more
);
367 switch (aurb
->urb
.status
) {
369 p
->actual_length
= aurb
->urb
.actual_length
;
370 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
374 set_halt(s
, p
->pid
, p
->ep
->nr
);
375 p
->status
= USB_RET_STALL
;
379 p
->status
= USB_RET_BABBLE
;
383 p
->status
= USB_RET_IOERROR
;
387 if (aurb
->urb
.type
== USBDEVFS_URB_TYPE_CONTROL
) {
388 trace_usb_host_req_complete(s
->bus_num
, s
->addr
, p
,
389 p
->status
, aurb
->urb
.actual_length
);
390 usb_generic_async_ctrl_complete(&s
->dev
, p
);
391 } else if (!aurb
->more
) {
392 trace_usb_host_req_complete(s
->bus_num
, s
->addr
, p
,
393 p
->status
, aurb
->urb
.actual_length
);
394 usb_packet_complete(&s
->dev
, p
);
402 static void usb_host_async_cancel(USBDevice
*dev
, USBPacket
*p
)
404 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
407 trace_usb_host_req_canceled(s
->bus_num
, s
->addr
, p
);
409 QLIST_FOREACH(aurb
, &s
->aurbs
, next
) {
410 if (p
!= aurb
->packet
) {
414 trace_usb_host_urb_canceled(s
->bus_num
, s
->addr
, aurb
);
416 /* Mark it as dead (see async_complete above) */
419 int r
= ioctl(s
->fd
, USBDEVFS_DISCARDURB
, aurb
);
421 DPRINTF("husb: async. discard urb failed errno %d\n", errno
);
426 static int usb_host_open_device(int bus
, int addr
)
428 const char *usbfs
= NULL
;
433 rc
= stat("/dev/bus/usb", &st
);
434 if (rc
== 0 && S_ISDIR(st
.st_mode
)) {
435 /* udev-created device nodes available */
436 usbfs
= "/dev/bus/usb";
438 /* fallback: usbfs mounted below /proc */
439 usbfs
= "/proc/bus/usb";
442 snprintf(filename
, sizeof(filename
), "%s/%03d/%03d",
444 fd
= open(filename
, O_RDWR
| O_NONBLOCK
);
446 fprintf(stderr
, "husb: open %s: %s\n", filename
, strerror(errno
));
451 static int usb_host_claim_port(USBHostDevice
*s
)
453 #ifdef USBDEVFS_CLAIM_PORT
454 char *h
, hub_name
[64], line
[1024];
457 snprintf(hub_name
, sizeof(hub_name
), "%d-%s",
458 s
->match
.bus_num
, s
->match
.port
);
460 /* try strip off last ".$portnr" to get hub */
461 h
= strrchr(hub_name
, '.');
463 s
->hub_port
= atoi(h
+1);
466 /* no dot in there -> it is the root hub */
467 snprintf(hub_name
, sizeof(hub_name
), "usb%d",
469 s
->hub_port
= atoi(s
->match
.port
);
472 if (!usb_host_read_file(line
, sizeof(line
), "devnum",
476 if (sscanf(line
, "%d", &hub_addr
) != 1) {
480 s
->hub_fd
= usb_host_open_device(s
->match
.bus_num
, hub_addr
);
485 ret
= ioctl(s
->hub_fd
, USBDEVFS_CLAIM_PORT
, &s
->hub_port
);
492 trace_usb_host_claim_port(s
->match
.bus_num
, hub_addr
, s
->hub_port
);
499 static void usb_host_release_port(USBHostDevice
*s
)
501 if (s
->hub_fd
== -1) {
504 #ifdef USBDEVFS_RELEASE_PORT
505 ioctl(s
->hub_fd
, USBDEVFS_RELEASE_PORT
, &s
->hub_port
);
511 static int usb_host_disconnect_ifaces(USBHostDevice
*dev
, int nb_interfaces
)
513 /* earlier Linux 2.4 do not support that */
514 #ifdef USBDEVFS_DISCONNECT
515 struct usbdevfs_ioctl ctrl
;
518 for (interface
= 0; interface
< nb_interfaces
; interface
++) {
519 ctrl
.ioctl_code
= USBDEVFS_DISCONNECT
;
520 ctrl
.ifno
= interface
;
522 ret
= ioctl(dev
->fd
, USBDEVFS_IOCTL
, &ctrl
);
523 if (ret
< 0 && errno
!= ENODATA
) {
524 perror("USBDEVFS_DISCONNECT");
532 static int usb_linux_get_num_interfaces(USBHostDevice
*s
)
534 char device_name
[64], line
[1024];
535 int num_interfaces
= 0;
537 sprintf(device_name
, "%d-%s", s
->bus_num
, s
->port
);
538 if (!usb_host_read_file(line
, sizeof(line
), "bNumInterfaces",
542 if (sscanf(line
, "%d", &num_interfaces
) != 1) {
545 return num_interfaces
;
548 static int usb_host_claim_interfaces(USBHostDevice
*dev
, int configuration
)
550 const char *op
= NULL
;
551 int dev_descr_len
, config_descr_len
;
552 int interface
, nb_interfaces
;
555 for (i
= 0; i
< USB_MAX_INTERFACES
; i
++) {
556 dev
->dev
.altsetting
[i
] = 0;
559 if (configuration
== 0) { /* address state - ignore */
560 dev
->dev
.ninterfaces
= 0;
561 dev
->dev
.configuration
= 0;
565 DPRINTF("husb: claiming interfaces. config %d\n", configuration
);
568 dev_descr_len
= dev
->descr
[0];
569 if (dev_descr_len
> dev
->descr_len
) {
570 fprintf(stderr
, "husb: update iface failed. descr too short\n");
575 while (i
< dev
->descr_len
) {
576 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
578 dev
->descr
[i
], dev
->descr
[i
+1]);
580 if (dev
->descr
[i
+1] != USB_DT_CONFIG
) {
584 config_descr_len
= dev
->descr
[i
];
586 DPRINTF("husb: config #%d need %d\n", dev
->descr
[i
+ 5], configuration
);
588 if (configuration
== dev
->descr
[i
+ 5]) {
589 configuration
= dev
->descr
[i
+ 5];
593 i
+= config_descr_len
;
596 if (i
>= dev
->descr_len
) {
598 "husb: update iface failed. no matching configuration\n");
601 nb_interfaces
= dev
->descr
[i
+ 4];
603 if (usb_host_disconnect_ifaces(dev
, nb_interfaces
) < 0) {
607 /* XXX: only grab if all interfaces are free */
608 for (interface
= 0; interface
< nb_interfaces
; interface
++) {
609 op
= "USBDEVFS_CLAIMINTERFACE";
610 ret
= ioctl(dev
->fd
, USBDEVFS_CLAIMINTERFACE
, &interface
);
616 trace_usb_host_claim_interfaces(dev
->bus_num
, dev
->addr
,
617 nb_interfaces
, configuration
);
619 dev
->dev
.ninterfaces
= nb_interfaces
;
620 dev
->dev
.configuration
= configuration
;
624 if (errno
== ENODEV
) {
631 static int usb_host_release_interfaces(USBHostDevice
*s
)
635 trace_usb_host_release_interfaces(s
->bus_num
, s
->addr
);
637 for (i
= 0; i
< s
->dev
.ninterfaces
; i
++) {
638 ret
= ioctl(s
->fd
, USBDEVFS_RELEASEINTERFACE
, &i
);
640 perror("USBDEVFS_RELEASEINTERFACE");
647 static void usb_host_handle_reset(USBDevice
*dev
)
649 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
651 trace_usb_host_reset(s
->bus_num
, s
->addr
);
653 usb_host_do_reset(s
);;
655 usb_host_claim_interfaces(s
, 0);
656 usb_linux_update_endp_table(s
);
659 static void usb_host_handle_destroy(USBDevice
*dev
)
661 USBHostDevice
*s
= (USBHostDevice
*)dev
;
663 usb_host_release_port(s
);
665 QTAILQ_REMOVE(&hostdevs
, s
, next
);
666 qemu_remove_exit_notifier(&s
->exit
);
669 /* iso data is special, we need to keep enough urbs in flight to make sure
670 that the controller never runs out of them, otherwise the device will
671 likely suffer a buffer underrun / overrun. */
672 static AsyncURB
*usb_host_alloc_iso(USBHostDevice
*s
, int pid
, uint8_t ep
)
675 int i
, j
, len
= usb_ep_get_max_packet_size(&s
->dev
, pid
, ep
);
677 aurb
= g_malloc0(s
->iso_urb_count
* sizeof(*aurb
));
678 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
679 aurb
[i
].urb
.endpoint
= ep
;
680 aurb
[i
].urb
.buffer_length
= ISO_FRAME_DESC_PER_URB
* len
;
681 aurb
[i
].urb
.buffer
= g_malloc(aurb
[i
].urb
.buffer_length
);
682 aurb
[i
].urb
.type
= USBDEVFS_URB_TYPE_ISO
;
683 aurb
[i
].urb
.flags
= USBDEVFS_URB_ISO_ASAP
;
684 aurb
[i
].urb
.number_of_packets
= ISO_FRAME_DESC_PER_URB
;
685 for (j
= 0 ; j
< ISO_FRAME_DESC_PER_URB
; j
++)
686 aurb
[i
].urb
.iso_frame_desc
[j
].length
= len
;
687 if (pid
== USB_TOKEN_IN
) {
688 aurb
[i
].urb
.endpoint
|= 0x80;
689 /* Mark as fully consumed (idle) */
690 aurb
[i
].iso_frame_idx
= ISO_FRAME_DESC_PER_URB
;
693 set_iso_urb(s
, pid
, ep
, aurb
);
698 static void usb_host_stop_n_free_iso(USBHostDevice
*s
, int pid
, uint8_t ep
)
701 int i
, ret
, killed
= 0, free
= 1;
703 aurb
= get_iso_urb(s
, pid
, ep
);
708 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
710 if (aurb
[i
].iso_frame_idx
== -1) {
711 ret
= ioctl(s
->fd
, USBDEVFS_DISCARDURB
, &aurb
[i
]);
713 perror("USBDEVFS_DISCARDURB");
721 /* Make sure any urbs we've killed are reaped before we free them */
726 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
727 g_free(aurb
[i
].urb
.buffer
);
733 printf("husb: leaking iso urbs because of discard failure\n");
734 set_iso_urb(s
, pid
, ep
, NULL
);
735 set_iso_urb_idx(s
, pid
, ep
, 0);
736 clear_iso_started(s
, pid
, ep
);
739 static void urb_status_to_usb_ret(int status
, USBPacket
*p
)
743 p
->status
= USB_RET_STALL
;
746 p
->status
= USB_RET_BABBLE
;
749 p
->status
= USB_RET_IOERROR
;
753 static void usb_host_handle_iso_data(USBHostDevice
*s
, USBPacket
*p
, int in
)
756 int i
, j
, max_packet_size
, offset
, len
;
759 max_packet_size
= p
->ep
->max_packet_size
;
760 if (max_packet_size
== 0) {
761 p
->status
= USB_RET_NAK
;
765 aurb
= get_iso_urb(s
, p
->pid
, p
->ep
->nr
);
767 aurb
= usb_host_alloc_iso(s
, p
->pid
, p
->ep
->nr
);
770 i
= get_iso_urb_idx(s
, p
->pid
, p
->ep
->nr
);
771 j
= aurb
[i
].iso_frame_idx
;
772 if (j
>= 0 && j
< ISO_FRAME_DESC_PER_URB
) {
774 /* Check urb status */
775 if (aurb
[i
].urb
.status
) {
776 urb_status_to_usb_ret(aurb
[i
].urb
.status
, p
);
777 /* Move to the next urb */
778 aurb
[i
].iso_frame_idx
= ISO_FRAME_DESC_PER_URB
- 1;
779 /* Check frame status */
780 } else if (aurb
[i
].urb
.iso_frame_desc
[j
].status
) {
781 urb_status_to_usb_ret(aurb
[i
].urb
.iso_frame_desc
[j
].status
, p
);
782 /* Check the frame fits */
783 } else if (aurb
[i
].urb
.iso_frame_desc
[j
].actual_length
785 printf("husb: received iso data is larger then packet\n");
786 p
->status
= USB_RET_BABBLE
;
787 /* All good copy data over */
789 len
= aurb
[i
].urb
.iso_frame_desc
[j
].actual_length
;
790 buf
= aurb
[i
].urb
.buffer
+
791 j
* aurb
[i
].urb
.iso_frame_desc
[0].length
;
792 usb_packet_copy(p
, buf
, len
);
796 offset
= (j
== 0) ? 0 : get_iso_buffer_used(s
, p
->pid
, p
->ep
->nr
);
798 /* Check the frame fits */
799 if (len
> max_packet_size
) {
800 printf("husb: send iso data is larger then max packet size\n");
801 p
->status
= USB_RET_NAK
;
805 /* All good copy data over */
806 usb_packet_copy(p
, aurb
[i
].urb
.buffer
+ offset
, len
);
807 aurb
[i
].urb
.iso_frame_desc
[j
].length
= len
;
809 set_iso_buffer_used(s
, p
->pid
, p
->ep
->nr
, offset
);
811 /* Start the stream once we have buffered enough data */
812 if (!is_iso_started(s
, p
->pid
, p
->ep
->nr
) && i
== 1 && j
== 8) {
813 set_iso_started(s
, p
->pid
, p
->ep
->nr
);
816 aurb
[i
].iso_frame_idx
++;
817 if (aurb
[i
].iso_frame_idx
== ISO_FRAME_DESC_PER_URB
) {
818 i
= (i
+ 1) % s
->iso_urb_count
;
819 set_iso_urb_idx(s
, p
->pid
, p
->ep
->nr
, i
);
823 set_iso_started(s
, p
->pid
, p
->ep
->nr
);
825 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
829 if (is_iso_started(s
, p
->pid
, p
->ep
->nr
)) {
830 /* (Re)-submit all fully consumed / filled urbs */
831 for (i
= 0; i
< s
->iso_urb_count
; i
++) {
832 if (aurb
[i
].iso_frame_idx
== ISO_FRAME_DESC_PER_URB
) {
833 if (ioctl(s
->fd
, USBDEVFS_SUBMITURB
, &aurb
[i
]) < 0) {
834 perror("USBDEVFS_SUBMITURB");
835 if (!in
|| p
->status
== USB_RET_SUCCESS
) {
838 p
->status
= USB_RET_NAK
;
842 p
->status
= USB_RET_STALL
;
847 aurb
[i
].iso_frame_idx
= -1;
848 change_iso_inflight(s
, p
->pid
, p
->ep
->nr
, 1);
854 static void usb_host_handle_data(USBDevice
*dev
, USBPacket
*p
)
856 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
857 struct usbdevfs_urb
*urb
;
859 int ret
, rem
, prem
, v
;
863 trace_usb_host_req_data(s
->bus_num
, s
->addr
, p
,
864 p
->pid
== USB_TOKEN_IN
,
865 p
->ep
->nr
, p
->iov
.size
);
867 if (!is_valid(s
, p
->pid
, p
->ep
->nr
)) {
868 p
->status
= USB_RET_NAK
;
869 trace_usb_host_req_complete(s
->bus_num
, s
->addr
, p
,
870 p
->status
, p
->actual_length
);
874 if (p
->pid
== USB_TOKEN_IN
) {
875 ep
= p
->ep
->nr
| 0x80;
880 if (is_halted(s
, p
->pid
, p
->ep
->nr
)) {
881 unsigned int arg
= ep
;
882 ret
= ioctl(s
->fd
, USBDEVFS_CLEAR_HALT
, &arg
);
884 perror("USBDEVFS_CLEAR_HALT");
885 p
->status
= USB_RET_NAK
;
886 trace_usb_host_req_complete(s
->bus_num
, s
->addr
, p
,
887 p
->status
, p
->actual_length
);
890 clear_halt(s
, p
->pid
, p
->ep
->nr
);
893 if (is_isoc(s
, p
->pid
, p
->ep
->nr
)) {
894 usb_host_handle_iso_data(s
, p
, p
->pid
== USB_TOKEN_IN
);
903 if (prem
== 0 && rem
> 0) {
904 assert(v
< p
->iov
.niov
);
905 prem
= p
->iov
.iov
[v
].iov_len
;
906 pbuf
= p
->iov
.iov
[v
].iov_base
;
910 aurb
= async_alloc(s
);
915 urb
->type
= usb_host_usbfs_type(s
, p
);
916 urb
->usercontext
= s
;
918 urb
->buffer_length
= prem
;
920 if (urb
->buffer_length
> MAX_USBFS_BUFFER_SIZE
) {
921 urb
->buffer_length
= MAX_USBFS_BUFFER_SIZE
;
923 pbuf
+= urb
->buffer_length
;
924 prem
-= urb
->buffer_length
;
925 rem
-= urb
->buffer_length
;
930 trace_usb_host_urb_submit(s
->bus_num
, s
->addr
, aurb
,
931 urb
->buffer_length
, aurb
->more
);
932 ret
= ioctl(s
->fd
, USBDEVFS_SUBMITURB
, urb
);
934 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
935 urb
->endpoint
, urb
->buffer_length
, aurb
->more
, p
, aurb
);
938 perror("USBDEVFS_SUBMITURB");
943 p
->status
= USB_RET_NAK
;
944 trace_usb_host_req_complete(s
->bus_num
, s
->addr
, p
,
945 p
->status
, p
->actual_length
);
949 p
->status
= USB_RET_STALL
;
950 trace_usb_host_req_complete(s
->bus_num
, s
->addr
, p
,
951 p
->status
, p
->actual_length
);
957 p
->status
= USB_RET_ASYNC
;
960 static int ctrl_error(void)
962 if (errno
== ETIMEDOUT
) {
965 return USB_RET_STALL
;
969 static void usb_host_set_address(USBHostDevice
*s
, int addr
)
971 trace_usb_host_set_address(s
->bus_num
, s
->addr
, addr
);
975 static void usb_host_set_config(USBHostDevice
*s
, int config
, USBPacket
*p
)
979 trace_usb_host_set_config(s
->bus_num
, s
->addr
, config
);
981 usb_host_release_interfaces(s
);
984 ret
= ioctl(s
->fd
, USBDEVFS_SETCONFIGURATION
, &config
);
986 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config
, ret
, errno
);
988 if (ret
< 0 && errno
== EBUSY
&& first
) {
989 /* happens if usb device is in use by host drivers */
990 int count
= usb_linux_get_num_interfaces(s
);
992 DPRINTF("husb: busy -> disconnecting %d interfaces\n", count
);
993 usb_host_disconnect_ifaces(s
, count
);
1000 p
->status
= ctrl_error();
1003 usb_host_claim_interfaces(s
, config
);
1004 usb_linux_update_endp_table(s
);
1007 static void usb_host_set_interface(USBHostDevice
*s
, int iface
, int alt
,
1010 struct usbdevfs_setinterface si
;
1013 trace_usb_host_set_interface(s
->bus_num
, s
->addr
, iface
, alt
);
1015 for (i
= 1; i
<= USB_MAX_ENDPOINTS
; i
++) {
1016 if (is_isoc(s
, USB_TOKEN_IN
, i
)) {
1017 usb_host_stop_n_free_iso(s
, USB_TOKEN_IN
, i
);
1019 if (is_isoc(s
, USB_TOKEN_OUT
, i
)) {
1020 usb_host_stop_n_free_iso(s
, USB_TOKEN_OUT
, i
);
1024 if (iface
>= USB_MAX_INTERFACES
) {
1025 p
->status
= USB_RET_STALL
;
1029 si
.interface
= iface
;
1030 si
.altsetting
= alt
;
1031 ret
= ioctl(s
->fd
, USBDEVFS_SETINTERFACE
, &si
);
1033 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
1034 iface
, alt
, ret
, errno
);
1037 p
->status
= ctrl_error();
1041 s
->dev
.altsetting
[iface
] = alt
;
1042 usb_linux_update_endp_table(s
);
1045 static void usb_host_handle_control(USBDevice
*dev
, USBPacket
*p
,
1046 int request
, int value
, int index
, int length
, uint8_t *data
)
1048 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
1049 struct usbdevfs_urb
*urb
;
1054 * Process certain standard device requests.
1055 * These are infrequent and are processed synchronously.
1058 /* Note request is (bRequestType << 8) | bRequest */
1059 trace_usb_host_req_control(s
->bus_num
, s
->addr
, p
, request
, value
, index
);
1062 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
1063 usb_host_set_address(s
, value
);
1064 trace_usb_host_req_emulated(s
->bus_num
, s
->addr
, p
, p
->status
);
1067 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
1068 usb_host_set_config(s
, value
& 0xff, p
);
1069 trace_usb_host_req_emulated(s
->bus_num
, s
->addr
, p
, p
->status
);
1072 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
1073 usb_host_set_interface(s
, index
, value
, p
);
1074 trace_usb_host_req_emulated(s
->bus_num
, s
->addr
, p
, p
->status
);
1077 case EndpointOutRequest
| USB_REQ_CLEAR_FEATURE
:
1078 if (value
== 0) { /* clear halt */
1079 int pid
= (index
& USB_DIR_IN
) ? USB_TOKEN_IN
: USB_TOKEN_OUT
;
1080 ioctl(s
->fd
, USBDEVFS_CLEAR_HALT
, &index
);
1081 clear_halt(s
, pid
, index
& 0x0f);
1082 trace_usb_host_req_emulated(s
->bus_num
, s
->addr
, p
, 0);
1087 /* The rest are asynchronous */
1088 if (length
> sizeof(dev
->data_buf
)) {
1089 fprintf(stderr
, "husb: ctrl buffer too small (%d > %zu)\n",
1090 length
, sizeof(dev
->data_buf
));
1091 p
->status
= USB_RET_STALL
;
1095 aurb
= async_alloc(s
);
1099 * Setup ctrl transfer.
1101 * s->ctrl is laid out such that data buffer immediately follows
1102 * 'req' struct which is exactly what usbdevfs expects.
1106 urb
->type
= USBDEVFS_URB_TYPE_CONTROL
;
1107 urb
->endpoint
= p
->ep
->nr
;
1109 urb
->buffer
= &dev
->setup_buf
;
1110 urb
->buffer_length
= length
+ 8;
1112 urb
->usercontext
= s
;
1114 trace_usb_host_urb_submit(s
->bus_num
, s
->addr
, aurb
,
1115 urb
->buffer_length
, aurb
->more
);
1116 ret
= ioctl(s
->fd
, USBDEVFS_SUBMITURB
, urb
);
1118 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb
->buffer_length
, aurb
);
1121 DPRINTF("husb: submit failed. errno %d\n", errno
);
1126 p
->status
= USB_RET_NAK
;
1130 p
->status
= USB_RET_STALL
;
1136 p
->status
= USB_RET_ASYNC
;
1139 static void usb_linux_update_endp_table(USBHostDevice
*s
)
1141 static const char *tname
[] = {
1142 [USB_ENDPOINT_XFER_CONTROL
] = "control",
1143 [USB_ENDPOINT_XFER_ISOC
] = "isoc",
1144 [USB_ENDPOINT_XFER_BULK
] = "bulk",
1145 [USB_ENDPOINT_XFER_INT
] = "int",
1147 uint8_t devep
, type
;
1150 unsigned int i
, configuration
= -1, interface
= -1, altsetting
= -1;
1151 struct endp_data
*epd
;
1153 bool active
= false;
1155 usb_ep_reset(&s
->dev
);
1157 for (i
= 0;; i
+= d
->bLength
) {
1158 if (i
+2 >= s
->descr_len
) {
1161 d
= (void *)(s
->descr
+ i
);
1162 if (d
->bLength
< 2) {
1163 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1164 "descriptor too short");
1167 if (i
+ d
->bLength
> s
->descr_len
) {
1168 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1169 "descriptor too long");
1172 switch (d
->bDescriptorType
) {
1174 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1175 "invalid descriptor type");
1178 if (d
->bLength
< 0x12) {
1179 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1180 "device descriptor too short");
1183 v
= (d
->u
.device
.idVendor_hi
<< 8) | d
->u
.device
.idVendor_lo
;
1184 p
= (d
->u
.device
.idProduct_hi
<< 8) | d
->u
.device
.idProduct_lo
;
1185 trace_usb_host_parse_device(s
->bus_num
, s
->addr
, v
, p
);
1188 if (d
->bLength
< 0x09) {
1189 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1190 "config descriptor too short");
1193 configuration
= d
->u
.config
.bConfigurationValue
;
1194 active
= (configuration
== s
->dev
.configuration
);
1195 trace_usb_host_parse_config(s
->bus_num
, s
->addr
,
1196 configuration
, active
);
1198 case USB_DT_INTERFACE
:
1199 if (d
->bLength
< 0x09) {
1200 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1201 "interface descriptor too short");
1204 interface
= d
->u
.interface
.bInterfaceNumber
;
1205 altsetting
= d
->u
.interface
.bAlternateSetting
;
1206 active
= (configuration
== s
->dev
.configuration
) &&
1207 (altsetting
== s
->dev
.altsetting
[interface
]);
1208 trace_usb_host_parse_interface(s
->bus_num
, s
->addr
,
1209 interface
, altsetting
, active
);
1211 case USB_DT_ENDPOINT
:
1212 if (d
->bLength
< 0x07) {
1213 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1214 "endpoint descriptor too short");
1217 devep
= d
->u
.endpoint
.bEndpointAddress
;
1218 pid
= (devep
& USB_DIR_IN
) ? USB_TOKEN_IN
: USB_TOKEN_OUT
;
1221 trace_usb_host_parse_error(s
->bus_num
, s
->addr
,
1222 "invalid endpoint address");
1226 type
= d
->u
.endpoint
.bmAttributes
& 0x3;
1227 mps
= d
->u
.endpoint
.wMaxPacketSize_lo
|
1228 (d
->u
.endpoint
.wMaxPacketSize_hi
<< 8);
1229 trace_usb_host_parse_endpoint(s
->bus_num
, s
->addr
, ep
,
1230 (devep
& USB_DIR_IN
) ? "in" : "out",
1231 tname
[type
], active
);
1234 usb_ep_set_max_packet_size(&s
->dev
, pid
, ep
, mps
);
1235 assert(usb_ep_get_type(&s
->dev
, pid
, ep
) ==
1236 USB_ENDPOINT_XFER_INVALID
);
1237 usb_ep_set_type(&s
->dev
, pid
, ep
, type
);
1238 usb_ep_set_ifnum(&s
->dev
, pid
, ep
, interface
);
1239 if ((s
->options
& (1 << USB_HOST_OPT_PIPELINE
)) &&
1240 (type
== USB_ENDPOINT_XFER_BULK
) &&
1241 (pid
== USB_TOKEN_OUT
)) {
1242 usb_ep_set_pipeline(&s
->dev
, pid
, ep
, true);
1245 epd
= get_endp(s
, pid
, ep
);
1251 trace_usb_host_parse_unknown(s
->bus_num
, s
->addr
,
1252 d
->bLength
, d
->bDescriptorType
);
1259 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1260 * this function assumes this is safe, if:
1261 * 1) There are no isoc endpoints
1262 * 2) There are no interrupt endpoints with a max_packet_size > 64
1263 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1264 * usb1 compatible, but in practice this seems to work fine.
1266 static int usb_linux_full_speed_compat(USBHostDevice
*dev
)
1271 * usb_linux_update_endp_table only registers info about ep in the current
1272 * interface altsettings, so we need to parse the descriptors again.
1274 for (i
= 0; (i
+ 5) < dev
->descr_len
; i
+= dev
->descr
[i
]) {
1275 if (dev
->descr
[i
+ 1] == USB_DT_ENDPOINT
) {
1276 switch (dev
->descr
[i
+ 3] & 0x3) {
1277 case 0x00: /* CONTROL */
1279 case 0x01: /* ISO */
1281 case 0x02: /* BULK */
1283 case 0x03: /* INTERRUPT */
1284 packet_size
= dev
->descr
[i
+ 4] + (dev
->descr
[i
+ 5] << 8);
1285 if (packet_size
> 64)
1294 static int usb_host_open(USBHostDevice
*dev
, int bus_num
,
1295 int addr
, const char *port
,
1296 const char *prod_name
, int speed
)
1300 trace_usb_host_open_started(bus_num
, addr
);
1302 if (dev
->fd
!= -1) {
1306 fd
= usb_host_open_device(bus_num
, addr
);
1310 DPRINTF("husb: opened %s\n", buf
);
1312 dev
->bus_num
= bus_num
;
1314 strcpy(dev
->port
, port
);
1317 /* read the device description */
1318 dev
->descr_len
= read(fd
, dev
->descr
, sizeof(dev
->descr
));
1319 if (dev
->descr_len
<= 0) {
1320 perror("husb: reading device data failed");
1327 printf("=== begin dumping device descriptor data ===\n");
1328 for (x
= 0; x
< dev
->descr_len
; x
++) {
1329 printf("%02x ", dev
->descr
[x
]);
1331 printf("\n=== end dumping device descriptor data ===\n");
1336 /* start unconfigured -- we'll wait for the guest to set a configuration */
1337 if (!usb_host_claim_interfaces(dev
, 0)) {
1341 usb_ep_init(&dev
->dev
);
1342 usb_linux_update_endp_table(dev
);
1345 struct usbdevfs_connectinfo ci
;
1347 ret
= ioctl(fd
, USBDEVFS_CONNECTINFO
, &ci
);
1349 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1354 speed
= USB_SPEED_LOW
;
1356 speed
= USB_SPEED_HIGH
;
1359 dev
->dev
.speed
= speed
;
1360 dev
->dev
.speedmask
= (1 << speed
);
1361 if (dev
->dev
.speed
== USB_SPEED_HIGH
&& usb_linux_full_speed_compat(dev
)) {
1362 dev
->dev
.speedmask
|= USB_SPEED_MASK_FULL
;
1365 trace_usb_host_open_success(bus_num
, addr
);
1367 if (!prod_name
|| prod_name
[0] == '\0') {
1368 snprintf(dev
->dev
.product_desc
, sizeof(dev
->dev
.product_desc
),
1369 "host:%d.%d", bus_num
, addr
);
1371 pstrcpy(dev
->dev
.product_desc
, sizeof(dev
->dev
.product_desc
),
1375 ret
= usb_device_attach(&dev
->dev
);
1380 /* USB devio uses 'write' flag to check for async completions */
1381 qemu_set_fd_handler(dev
->fd
, NULL
, async_complete
, dev
);
1386 trace_usb_host_open_failure(bus_num
, addr
);
1387 if (dev
->fd
!= -1) {
1394 static int usb_host_close(USBHostDevice
*dev
)
1398 if (dev
->fd
== -1) {
1402 trace_usb_host_close(dev
->bus_num
, dev
->addr
);
1404 qemu_set_fd_handler(dev
->fd
, NULL
, NULL
, NULL
);
1406 for (i
= 1; i
<= USB_MAX_ENDPOINTS
; i
++) {
1407 if (is_isoc(dev
, USB_TOKEN_IN
, i
)) {
1408 usb_host_stop_n_free_iso(dev
, USB_TOKEN_IN
, i
);
1410 if (is_isoc(dev
, USB_TOKEN_OUT
, i
)) {
1411 usb_host_stop_n_free_iso(dev
, USB_TOKEN_OUT
, i
);
1414 async_complete(dev
);
1416 if (dev
->dev
.attached
) {
1417 usb_device_detach(&dev
->dev
);
1419 usb_host_do_reset(dev
);
1425 static void usb_host_exit_notifier(struct Notifier
*n
, void *data
)
1427 USBHostDevice
*s
= container_of(n
, USBHostDevice
, exit
);
1429 usb_host_release_port(s
);
1431 usb_host_do_reset(s
);;
1436 * This is *NOT* about restoring state. We have absolutely no idea
1437 * what state the host device is in at the moment and whenever it is
1438 * still present in the first place. Attemping to contine where we
1439 * left off is impossible.
1441 * What we are going to to to here is emulate a surprise removal of
1442 * the usb device passed through, then kick host scan so the device
1443 * will get re-attached (and re-initialized by the guest) in case it
1446 * As the device removal will change the state of other devices (usb
1447 * host controller, most likely interrupt controller too) we have to
1448 * wait with it until *all* vmstate is loaded. Thus post_load just
1449 * kicks a bottom half which then does the actual work.
1451 static void usb_host_post_load_bh(void *opaque
)
1453 USBHostDevice
*dev
= opaque
;
1455 if (dev
->fd
!= -1) {
1456 usb_host_close(dev
);
1458 if (dev
->dev
.attached
) {
1459 usb_device_detach(&dev
->dev
);
1461 usb_host_auto_check(NULL
);
1464 static int usb_host_post_load(void *opaque
, int version_id
)
1466 USBHostDevice
*dev
= opaque
;
1468 qemu_bh_schedule(dev
->bh
);
1472 static int usb_host_initfn(USBDevice
*dev
)
1474 USBHostDevice
*s
= DO_UPCAST(USBHostDevice
, dev
, dev
);
1476 dev
->auto_attach
= 0;
1480 QTAILQ_INSERT_TAIL(&hostdevs
, s
, next
);
1481 s
->exit
.notify
= usb_host_exit_notifier
;
1482 qemu_add_exit_notifier(&s
->exit
);
1483 s
->bh
= qemu_bh_new(usb_host_post_load_bh
, s
);
1484 usb_host_auto_check(NULL
);
1486 if (s
->match
.bus_num
!= 0 && s
->match
.port
!= NULL
) {
1487 usb_host_claim_port(s
);
1489 add_boot_device_path(s
->bootindex
, &dev
->qdev
, NULL
);
1493 static const VMStateDescription vmstate_usb_host
= {
1496 .minimum_version_id
= 1,
1497 .post_load
= usb_host_post_load
,
1498 .fields
= (VMStateField
[]) {
1499 VMSTATE_USB_DEVICE(dev
, USBHostDevice
),
1500 VMSTATE_END_OF_LIST()
1504 static Property usb_host_dev_properties
[] = {
1505 DEFINE_PROP_UINT32("hostbus", USBHostDevice
, match
.bus_num
, 0),
1506 DEFINE_PROP_UINT32("hostaddr", USBHostDevice
, match
.addr
, 0),
1507 DEFINE_PROP_STRING("hostport", USBHostDevice
, match
.port
),
1508 DEFINE_PROP_HEX32("vendorid", USBHostDevice
, match
.vendor_id
, 0),
1509 DEFINE_PROP_HEX32("productid", USBHostDevice
, match
.product_id
, 0),
1510 DEFINE_PROP_UINT32("isobufs", USBHostDevice
, iso_urb_count
, 4),
1511 DEFINE_PROP_INT32("bootindex", USBHostDevice
, bootindex
, -1),
1512 DEFINE_PROP_BIT("pipeline", USBHostDevice
, options
,
1513 USB_HOST_OPT_PIPELINE
, true),
1514 DEFINE_PROP_END_OF_LIST(),
1517 static void usb_host_class_initfn(ObjectClass
*klass
, void *data
)
1519 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1520 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1522 uc
->init
= usb_host_initfn
;
1523 uc
->product_desc
= "USB Host Device";
1524 uc
->cancel_packet
= usb_host_async_cancel
;
1525 uc
->handle_data
= usb_host_handle_data
;
1526 uc
->handle_control
= usb_host_handle_control
;
1527 uc
->handle_reset
= usb_host_handle_reset
;
1528 uc
->handle_destroy
= usb_host_handle_destroy
;
1529 dc
->vmsd
= &vmstate_usb_host
;
1530 dc
->props
= usb_host_dev_properties
;
1533 static TypeInfo usb_host_dev_info
= {
1535 .parent
= TYPE_USB_DEVICE
,
1536 .instance_size
= sizeof(USBHostDevice
),
1537 .class_init
= usb_host_class_initfn
,
1540 static void usb_host_register_types(void)
1542 type_register_static(&usb_host_dev_info
);
1543 usb_legacy_register("usb-host", "host", usb_host_device_open
);
1546 type_init(usb_host_register_types
)
1548 USBDevice
*usb_host_device_open(USBBus
*bus
, const char *devname
)
1550 struct USBAutoFilter filter
;
1554 dev
= usb_create(bus
, "usb-host");
1556 if (strstr(devname
, "auto:")) {
1557 if (parse_filter(devname
, &filter
) < 0) {
1561 if ((p
= strchr(devname
, '.'))) {
1562 filter
.bus_num
= strtoul(devname
, NULL
, 0);
1563 filter
.addr
= strtoul(p
+ 1, NULL
, 0);
1564 filter
.vendor_id
= 0;
1565 filter
.product_id
= 0;
1566 } else if ((p
= strchr(devname
, ':'))) {
1569 filter
.vendor_id
= strtoul(devname
, NULL
, 16);
1570 filter
.product_id
= strtoul(p
+ 1, NULL
, 16);
1576 qdev_prop_set_uint32(&dev
->qdev
, "hostbus", filter
.bus_num
);
1577 qdev_prop_set_uint32(&dev
->qdev
, "hostaddr", filter
.addr
);
1578 qdev_prop_set_uint32(&dev
->qdev
, "vendorid", filter
.vendor_id
);
1579 qdev_prop_set_uint32(&dev
->qdev
, "productid", filter
.product_id
);
1580 qdev_init_nofail(&dev
->qdev
);
1584 qdev_free(&dev
->qdev
);
1588 int usb_host_device_close(const char *devname
)
1591 char product_name
[PRODUCT_NAME_SZ
];
1595 if (strstr(devname
, "auto:")) {
1596 return usb_host_auto_del(devname
);
1598 if (usb_host_find_device(&bus_num
, &addr
, product_name
,
1599 sizeof(product_name
), devname
) < 0) {
1602 s
= hostdev_find(bus_num
, addr
);
1604 usb_device_delete_addr(s
->bus_num
, s
->dev
.addr
);
1613 * Read sys file-system device file
1615 * @line address of buffer to put file contents in
1616 * @line_size size of line
1617 * @device_file path to device file (printf format string)
1618 * @device_name device being opened (inserted into device_file)
1620 * @return 0 failed, 1 succeeded ('line' contains data)
1622 static int usb_host_read_file(char *line
, size_t line_size
,
1623 const char *device_file
, const char *device_name
)
1627 char filename
[PATH_MAX
];
1629 snprintf(filename
, PATH_MAX
, "/sys/bus/usb/devices/%s/%s", device_name
,
1631 f
= fopen(filename
, "r");
1633 ret
= fgets(line
, line_size
, f
) != NULL
;
1641 * Use /sys/bus/usb/devices/ directory to determine host's USB
1644 * This code is based on Robert Schiele's original patches posted to
1645 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1647 static int usb_host_scan(void *opaque
, USBScanFunc
*func
)
1651 int bus_num
, addr
, speed
, class_id
, product_id
, vendor_id
;
1653 char port
[MAX_PORTLEN
];
1654 char product_name
[512];
1657 dir
= opendir("/sys/bus/usb/devices");
1659 perror("husb: opendir /sys/bus/usb/devices");
1660 fprintf(stderr
, "husb: please make sure sysfs is mounted at /sys\n");
1664 while ((de
= readdir(dir
))) {
1665 if (de
->d_name
[0] != '.' && !strchr(de
->d_name
, ':')) {
1666 if (sscanf(de
->d_name
, "%d-%7[0-9.]", &bus_num
, port
) < 2) {
1670 if (!usb_host_read_file(line
, sizeof(line
), "devnum", de
->d_name
)) {
1673 if (sscanf(line
, "%d", &addr
) != 1) {
1676 if (!usb_host_read_file(line
, sizeof(line
), "bDeviceClass",
1680 if (sscanf(line
, "%x", &class_id
) != 1) {
1684 if (!usb_host_read_file(line
, sizeof(line
), "idVendor",
1688 if (sscanf(line
, "%x", &vendor_id
) != 1) {
1691 if (!usb_host_read_file(line
, sizeof(line
), "idProduct",
1695 if (sscanf(line
, "%x", &product_id
) != 1) {
1698 if (!usb_host_read_file(line
, sizeof(line
), "product",
1702 if (strlen(line
) > 0) {
1703 line
[strlen(line
) - 1] = '\0';
1705 pstrcpy(product_name
, sizeof(product_name
), line
);
1708 if (!usb_host_read_file(line
, sizeof(line
), "speed", de
->d_name
)) {
1711 if (!strcmp(line
, "5000\n")) {
1712 speed
= USB_SPEED_SUPER
;
1713 } else if (!strcmp(line
, "480\n")) {
1714 speed
= USB_SPEED_HIGH
;
1715 } else if (!strcmp(line
, "1.5\n")) {
1716 speed
= USB_SPEED_LOW
;
1718 speed
= USB_SPEED_FULL
;
1721 ret
= func(opaque
, bus_num
, addr
, port
, class_id
, vendor_id
,
1722 product_id
, product_name
, speed
);
1735 static QEMUTimer
*usb_auto_timer
;
1736 static VMChangeStateEntry
*usb_vmstate
;
1738 static int usb_host_auto_scan(void *opaque
, int bus_num
,
1739 int addr
, const char *port
,
1740 int class_id
, int vendor_id
, int product_id
,
1741 const char *product_name
, int speed
)
1743 struct USBAutoFilter
*f
;
1744 struct USBHostDevice
*s
;
1750 QTAILQ_FOREACH(s
, &hostdevs
, next
) {
1753 if (f
->bus_num
> 0 && f
->bus_num
!= bus_num
) {
1756 if (f
->addr
> 0 && f
->addr
!= addr
) {
1759 if (f
->port
!= NULL
&& (port
== NULL
|| strcmp(f
->port
, port
) != 0)) {
1763 if (f
->vendor_id
> 0 && f
->vendor_id
!= vendor_id
) {
1767 if (f
->product_id
> 0 && f
->product_id
!= product_id
) {
1770 /* We got a match */
1772 if (s
->errcount
>= 3) {
1776 /* Already attached ? */
1780 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num
, addr
);
1782 if (usb_host_open(s
, bus_num
, addr
, port
, product_name
, speed
) < 0) {
1791 static void usb_host_vm_state(void *unused
, int running
, RunState state
)
1794 usb_host_auto_check(unused
);
1798 static void usb_host_auto_check(void *unused
)
1800 struct USBHostDevice
*s
;
1801 int unconnected
= 0;
1803 if (runstate_is_running()) {
1804 usb_host_scan(NULL
, usb_host_auto_scan
);
1806 QTAILQ_FOREACH(s
, &hostdevs
, next
) {
1816 if (unconnected
== 0) {
1817 /* nothing to watch */
1818 if (usb_auto_timer
) {
1819 qemu_del_timer(usb_auto_timer
);
1820 trace_usb_host_auto_scan_disabled();
1827 usb_vmstate
= qemu_add_vm_change_state_handler(usb_host_vm_state
, NULL
);
1829 if (!usb_auto_timer
) {
1830 usb_auto_timer
= qemu_new_timer_ms(rt_clock
, usb_host_auto_check
, NULL
);
1831 if (!usb_auto_timer
) {
1834 trace_usb_host_auto_scan_enabled();
1836 qemu_mod_timer(usb_auto_timer
, qemu_get_clock_ms(rt_clock
) + 2000);
1840 * Autoconnect filter
1842 * auto:bus:dev[:vid:pid]
1843 * auto:bus.dev[:vid:pid]
1845 * bus - bus number (dec, * means any)
1846 * dev - device number (dec, * means any)
1847 * vid - vendor id (hex, * means any)
1848 * pid - product id (hex, * means any)
1850 * See 'lsusb' output.
1852 static int parse_filter(const char *spec
, struct USBAutoFilter
*f
)
1854 enum { BUS
, DEV
, VID
, PID
, DONE
};
1855 const char *p
= spec
;
1863 for (i
= BUS
; i
< DONE
; i
++) {
1864 p
= strpbrk(p
, ":.");
1874 case BUS
: f
->bus_num
= strtol(p
, NULL
, 10); break;
1875 case DEV
: f
->addr
= strtol(p
, NULL
, 10); break;
1876 case VID
: f
->vendor_id
= strtol(p
, NULL
, 16); break;
1877 case PID
: f
->product_id
= strtol(p
, NULL
, 16); break;
1882 fprintf(stderr
, "husb: invalid auto filter spec %s\n", spec
);
1889 /**********************/
1890 /* USB host device info */
1892 struct usb_class_info
{
1894 const char *class_name
;
1897 static const struct usb_class_info usb_class_info
[] = {
1898 { USB_CLASS_AUDIO
, "Audio"},
1899 { USB_CLASS_COMM
, "Communication"},
1900 { USB_CLASS_HID
, "HID"},
1901 { USB_CLASS_HUB
, "Hub" },
1902 { USB_CLASS_PHYSICAL
, "Physical" },
1903 { USB_CLASS_PRINTER
, "Printer" },
1904 { USB_CLASS_MASS_STORAGE
, "Storage" },
1905 { USB_CLASS_CDC_DATA
, "Data" },
1906 { USB_CLASS_APP_SPEC
, "Application Specific" },
1907 { USB_CLASS_VENDOR_SPEC
, "Vendor Specific" },
1908 { USB_CLASS_STILL_IMAGE
, "Still Image" },
1909 { USB_CLASS_CSCID
, "Smart Card" },
1910 { USB_CLASS_CONTENT_SEC
, "Content Security" },
1914 static const char *usb_class_str(uint8_t class)
1916 const struct usb_class_info
*p
;
1917 for(p
= usb_class_info
; p
->class != -1; p
++) {
1918 if (p
->class == class) {
1922 return p
->class_name
;
1925 static void usb_info_device(Monitor
*mon
, int bus_num
,
1926 int addr
, const char *port
,
1927 int class_id
, int vendor_id
, int product_id
,
1928 const char *product_name
,
1931 const char *class_str
, *speed_str
;
1937 case USB_SPEED_FULL
:
1940 case USB_SPEED_HIGH
:
1943 case USB_SPEED_SUPER
:
1951 monitor_printf(mon
, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1952 bus_num
, addr
, port
, speed_str
);
1953 class_str
= usb_class_str(class_id
);
1955 monitor_printf(mon
, " %s:", class_str
);
1957 monitor_printf(mon
, " Class %02x:", class_id
);
1959 monitor_printf(mon
, " USB device %04x:%04x", vendor_id
, product_id
);
1960 if (product_name
[0] != '\0') {
1961 monitor_printf(mon
, ", %s", product_name
);
1963 monitor_printf(mon
, "\n");
1966 static int usb_host_info_device(void *opaque
, int bus_num
, int addr
,
1967 const char *path
, int class_id
,
1968 int vendor_id
, int product_id
,
1969 const char *product_name
,
1972 Monitor
*mon
= opaque
;
1974 usb_info_device(mon
, bus_num
, addr
, path
, class_id
, vendor_id
, product_id
,
1975 product_name
, speed
);
1979 static void dec2str(int val
, char *str
, size_t size
)
1982 snprintf(str
, size
, "*");
1984 snprintf(str
, size
, "%d", val
);
1988 static void hex2str(int val
, char *str
, size_t size
)
1991 snprintf(str
, size
, "*");
1993 snprintf(str
, size
, "%04x", val
);
1997 void usb_host_info(Monitor
*mon
)
1999 struct USBAutoFilter
*f
;
2000 struct USBHostDevice
*s
;
2002 usb_host_scan(mon
, usb_host_info_device
);
2004 if (QTAILQ_EMPTY(&hostdevs
)) {
2008 monitor_printf(mon
, " Auto filters:\n");
2009 QTAILQ_FOREACH(s
, &hostdevs
, next
) {
2010 char bus
[10], addr
[10], vid
[10], pid
[10];
2012 dec2str(f
->bus_num
, bus
, sizeof(bus
));
2013 dec2str(f
->addr
, addr
, sizeof(addr
));
2014 hex2str(f
->vendor_id
, vid
, sizeof(vid
));
2015 hex2str(f
->product_id
, pid
, sizeof(pid
));
2016 monitor_printf(mon
, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
2017 bus
, addr
, f
->port
? f
->port
: "*", vid
, pid
);