2 * USB redirector usb-guest
4 * Copyright (c) 2011-2012 Red Hat, Inc.
7 * Hans de Goede <hdegoede@redhat.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "qemu/osdep.h"
29 #include "qapi/error.h"
30 #include "qemu-common.h"
31 #include "qemu/timer.h"
32 #include "sysemu/sysemu.h"
33 #include "qapi/qmp/qerror.h"
34 #include "qemu/error-report.h"
36 #include "sysemu/char.h"
38 #include <sys/ioctl.h>
39 #include <usbredirparser.h>
40 #include <usbredirfilter.h>
44 #define MAX_ENDPOINTS 32
45 #define NO_INTERFACE_INFO 255 /* Valid interface_count always <= 32 */
46 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))
47 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))
48 #define USBEP2I(usb_ep) (((usb_ep)->pid == USB_TOKEN_IN) ? \
49 ((usb_ep)->nr | 0x10) : ((usb_ep)->nr))
50 #define I2USBEP(d, i) (usb_ep_get(&(d)->dev, \
51 ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \
54 #ifndef USBREDIR_VERSION /* This is not defined in older usbredir versions */
55 #define USBREDIR_VERSION 0
58 typedef struct USBRedirDevice USBRedirDevice
;
60 /* Struct to hold buffered packets */
63 void *free_on_destroy
;
67 QTAILQ_ENTRY(buf_packet
)next
;
74 uint8_t interface
; /* bInterfaceNumber this ep belongs to */
75 uint16_t max_packet_size
; /* In bytes, not wMaxPacketSize format !! */
78 uint8_t iso_error
; /* For reporting iso errors to the HC */
79 uint8_t interrupt_started
;
80 uint8_t interrupt_error
;
81 uint8_t bulk_receiving_enabled
;
82 uint8_t bulk_receiving_started
;
83 uint8_t bufpq_prefilled
;
84 uint8_t bufpq_dropping_packets
;
85 QTAILQ_HEAD(, buf_packet
) bufpq
;
87 int32_t bufpq_target_size
;
88 USBPacket
*pending_async_packet
;
91 struct PacketIdQueueEntry
{
93 QTAILQ_ENTRY(PacketIdQueueEntry
)next
;
96 struct PacketIdQueue
{
99 QTAILQ_HEAD(, PacketIdQueueEntry
) head
;
103 struct USBRedirDevice
{
110 /* Data passed from chardev the fd_read cb to the usbredirparser read cb */
111 const uint8_t *read_buf
;
113 /* Active chardev-watch-tag */
115 /* For async handling of close / reject */
116 QEMUBH
*chardev_close_bh
;
117 QEMUBH
*device_reject_bh
;
118 /* To delay the usb attach in case of quick chardev close + open */
119 QEMUTimer
*attach_timer
;
120 int64_t next_attach_time
;
121 struct usbredirparser
*parser
;
122 struct endp_data endpoint
[MAX_ENDPOINTS
];
123 struct PacketIdQueue cancelled
;
124 struct PacketIdQueue already_in_flight
;
125 void (*buffered_bulk_in_complete
)(USBRedirDevice
*, USBPacket
*, uint8_t);
126 /* Data for device filtering */
127 struct usb_redir_device_connect_header device_info
;
128 struct usb_redir_interface_info_header interface_info
;
129 struct usbredirfilter_rule
*filter_rules
;
130 int filter_rules_count
;
131 int compatible_speedmask
;
134 #define TYPE_USB_REDIR "usb-redir"
135 #define USB_REDIRECT(obj) OBJECT_CHECK(USBRedirDevice, (obj), TYPE_USB_REDIR)
137 static void usbredir_hello(void *priv
, struct usb_redir_hello_header
*h
);
138 static void usbredir_device_connect(void *priv
,
139 struct usb_redir_device_connect_header
*device_connect
);
140 static void usbredir_device_disconnect(void *priv
);
141 static void usbredir_interface_info(void *priv
,
142 struct usb_redir_interface_info_header
*interface_info
);
143 static void usbredir_ep_info(void *priv
,
144 struct usb_redir_ep_info_header
*ep_info
);
145 static void usbredir_configuration_status(void *priv
, uint64_t id
,
146 struct usb_redir_configuration_status_header
*configuration_status
);
147 static void usbredir_alt_setting_status(void *priv
, uint64_t id
,
148 struct usb_redir_alt_setting_status_header
*alt_setting_status
);
149 static void usbredir_iso_stream_status(void *priv
, uint64_t id
,
150 struct usb_redir_iso_stream_status_header
*iso_stream_status
);
151 static void usbredir_interrupt_receiving_status(void *priv
, uint64_t id
,
152 struct usb_redir_interrupt_receiving_status_header
153 *interrupt_receiving_status
);
154 static void usbredir_bulk_streams_status(void *priv
, uint64_t id
,
155 struct usb_redir_bulk_streams_status_header
*bulk_streams_status
);
156 static void usbredir_bulk_receiving_status(void *priv
, uint64_t id
,
157 struct usb_redir_bulk_receiving_status_header
*bulk_receiving_status
);
158 static void usbredir_control_packet(void *priv
, uint64_t id
,
159 struct usb_redir_control_packet_header
*control_packet
,
160 uint8_t *data
, int data_len
);
161 static void usbredir_bulk_packet(void *priv
, uint64_t id
,
162 struct usb_redir_bulk_packet_header
*bulk_packet
,
163 uint8_t *data
, int data_len
);
164 static void usbredir_iso_packet(void *priv
, uint64_t id
,
165 struct usb_redir_iso_packet_header
*iso_packet
,
166 uint8_t *data
, int data_len
);
167 static void usbredir_interrupt_packet(void *priv
, uint64_t id
,
168 struct usb_redir_interrupt_packet_header
*interrupt_header
,
169 uint8_t *data
, int data_len
);
170 static void usbredir_buffered_bulk_packet(void *priv
, uint64_t id
,
171 struct usb_redir_buffered_bulk_packet_header
*buffered_bulk_packet
,
172 uint8_t *data
, int data_len
);
174 static void usbredir_handle_status(USBRedirDevice
*dev
, USBPacket
*p
,
177 #define VERSION "qemu usb-redir guest " QEMU_VERSION
185 if (dev->debug >= usbredirparser_error) { \
186 error_report("usb-redir error: " __VA_ARGS__); \
189 #define WARNING(...) \
191 if (dev->debug >= usbredirparser_warning) { \
192 error_report("usb-redir warning: " __VA_ARGS__); \
197 if (dev->debug >= usbredirparser_info) { \
198 error_report("usb-redir: " __VA_ARGS__); \
201 #define DPRINTF(...) \
203 if (dev->debug >= usbredirparser_debug) { \
204 error_report("usb-redir: " __VA_ARGS__); \
207 #define DPRINTF2(...) \
209 if (dev->debug >= usbredirparser_debug_data) { \
210 error_report("usb-redir: " __VA_ARGS__); \
214 static void usbredir_log(void *priv
, int level
, const char *msg
)
216 USBRedirDevice
*dev
= priv
;
218 if (dev
->debug
< level
) {
222 error_report("%s", msg
);
225 static void usbredir_log_data(USBRedirDevice
*dev
, const char *desc
,
226 const uint8_t *data
, int len
)
230 if (dev
->debug
< usbredirparser_debug_data
) {
234 for (i
= 0; i
< len
; i
+= j
) {
237 n
= sprintf(buf
, "%s", desc
);
238 for (j
= 0; j
< 8 && i
+ j
< len
; j
++) {
239 n
+= sprintf(buf
+ n
, " %02X", data
[i
+ j
]);
241 error_report("%s", buf
);
246 * usbredirparser io functions
249 static int usbredir_read(void *priv
, uint8_t *data
, int count
)
251 USBRedirDevice
*dev
= priv
;
253 if (dev
->read_buf_size
< count
) {
254 count
= dev
->read_buf_size
;
257 memcpy(data
, dev
->read_buf
, count
);
259 dev
->read_buf_size
-= count
;
260 if (dev
->read_buf_size
) {
261 dev
->read_buf
+= count
;
263 dev
->read_buf
= NULL
;
269 static gboolean
usbredir_write_unblocked(GIOChannel
*chan
, GIOCondition cond
,
272 USBRedirDevice
*dev
= opaque
;
275 usbredirparser_do_write(dev
->parser
);
280 static int usbredir_write(void *priv
, uint8_t *data
, int count
)
282 USBRedirDevice
*dev
= priv
;
285 if (!dev
->cs
->be_open
) {
289 /* Don't send new data to the chardev until our state is fully synced */
290 if (!runstate_check(RUN_STATE_RUNNING
)) {
294 r
= qemu_chr_fe_write(dev
->cs
, data
, count
);
297 dev
->watch
= qemu_chr_fe_add_watch(dev
->cs
, G_IO_OUT
|G_IO_HUP
,
298 usbredir_write_unblocked
, dev
);
308 * Cancelled and buffered packets helpers
311 static void packet_id_queue_init(struct PacketIdQueue
*q
,
312 USBRedirDevice
*dev
, const char *name
)
316 QTAILQ_INIT(&q
->head
);
320 static void packet_id_queue_add(struct PacketIdQueue
*q
, uint64_t id
)
322 USBRedirDevice
*dev
= q
->dev
;
323 struct PacketIdQueueEntry
*e
;
325 DPRINTF("adding packet id %"PRIu64
" to %s queue\n", id
, q
->name
);
327 e
= g_new0(struct PacketIdQueueEntry
, 1);
329 QTAILQ_INSERT_TAIL(&q
->head
, e
, next
);
333 static int packet_id_queue_remove(struct PacketIdQueue
*q
, uint64_t id
)
335 USBRedirDevice
*dev
= q
->dev
;
336 struct PacketIdQueueEntry
*e
;
338 QTAILQ_FOREACH(e
, &q
->head
, next
) {
340 DPRINTF("removing packet id %"PRIu64
" from %s queue\n",
342 QTAILQ_REMOVE(&q
->head
, e
, next
);
351 static void packet_id_queue_empty(struct PacketIdQueue
*q
)
353 USBRedirDevice
*dev
= q
->dev
;
354 struct PacketIdQueueEntry
*e
, *next_e
;
356 DPRINTF("removing %d packet-ids from %s queue\n", q
->size
, q
->name
);
358 QTAILQ_FOREACH_SAFE(e
, &q
->head
, next
, next_e
) {
359 QTAILQ_REMOVE(&q
->head
, e
, next
);
365 static void usbredir_cancel_packet(USBDevice
*udev
, USBPacket
*p
)
367 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
368 int i
= USBEP2I(p
->ep
);
371 usb_combined_packet_cancel(udev
, p
);
375 if (dev
->endpoint
[i
].pending_async_packet
) {
376 assert(dev
->endpoint
[i
].pending_async_packet
== p
);
377 dev
->endpoint
[i
].pending_async_packet
= NULL
;
381 packet_id_queue_add(&dev
->cancelled
, p
->id
);
382 usbredirparser_send_cancel_data_packet(dev
->parser
, p
->id
);
383 usbredirparser_do_write(dev
->parser
);
386 static int usbredir_is_cancelled(USBRedirDevice
*dev
, uint64_t id
)
388 if (!dev
->dev
.attached
) {
389 return 1; /* Treat everything as cancelled after a disconnect */
391 return packet_id_queue_remove(&dev
->cancelled
, id
);
394 static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice
*dev
,
395 struct USBEndpoint
*ep
)
399 /* async handled packets for bulk receiving eps do not count as inflight */
400 if (dev
->endpoint
[USBEP2I(ep
)].bulk_receiving_started
) {
404 QTAILQ_FOREACH(p
, &ep
->queue
, queue
) {
405 /* Skip combined packets, except for the first */
406 if (p
->combined
&& p
!= p
->combined
->first
) {
409 if (p
->state
== USB_PACKET_ASYNC
) {
410 packet_id_queue_add(&dev
->already_in_flight
, p
->id
);
415 static void usbredir_fill_already_in_flight(USBRedirDevice
*dev
)
418 struct USBDevice
*udev
= &dev
->dev
;
420 usbredir_fill_already_in_flight_from_ep(dev
, &udev
->ep_ctl
);
422 for (ep
= 0; ep
< USB_MAX_ENDPOINTS
; ep
++) {
423 usbredir_fill_already_in_flight_from_ep(dev
, &udev
->ep_in
[ep
]);
424 usbredir_fill_already_in_flight_from_ep(dev
, &udev
->ep_out
[ep
]);
428 static int usbredir_already_in_flight(USBRedirDevice
*dev
, uint64_t id
)
430 return packet_id_queue_remove(&dev
->already_in_flight
, id
);
433 static USBPacket
*usbredir_find_packet_by_id(USBRedirDevice
*dev
,
434 uint8_t ep
, uint64_t id
)
438 if (usbredir_is_cancelled(dev
, id
)) {
442 p
= usb_ep_find_packet_by_id(&dev
->dev
,
443 (ep
& USB_DIR_IN
) ? USB_TOKEN_IN
: USB_TOKEN_OUT
,
446 ERROR("could not find packet with id %"PRIu64
"\n", id
);
451 static int bufp_alloc(USBRedirDevice
*dev
, uint8_t *data
, uint16_t len
,
452 uint8_t status
, uint8_t ep
, void *free_on_destroy
)
454 struct buf_packet
*bufp
;
456 if (!dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
&&
457 dev
->endpoint
[EP2I(ep
)].bufpq_size
>
458 2 * dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
459 DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep
);
460 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 1;
462 /* Since we're interupting the stream anyways, drop enough packets to get
463 back to our target buffer size */
464 if (dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
) {
465 if (dev
->endpoint
[EP2I(ep
)].bufpq_size
>
466 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
470 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
473 bufp
= g_new(struct buf_packet
, 1);
477 bufp
->status
= status
;
478 bufp
->free_on_destroy
= free_on_destroy
;
479 QTAILQ_INSERT_TAIL(&dev
->endpoint
[EP2I(ep
)].bufpq
, bufp
, next
);
480 dev
->endpoint
[EP2I(ep
)].bufpq_size
++;
484 static void bufp_free(USBRedirDevice
*dev
, struct buf_packet
*bufp
,
487 QTAILQ_REMOVE(&dev
->endpoint
[EP2I(ep
)].bufpq
, bufp
, next
);
488 dev
->endpoint
[EP2I(ep
)].bufpq_size
--;
489 free(bufp
->free_on_destroy
);
493 static void usbredir_free_bufpq(USBRedirDevice
*dev
, uint8_t ep
)
495 struct buf_packet
*buf
, *buf_next
;
497 QTAILQ_FOREACH_SAFE(buf
, &dev
->endpoint
[EP2I(ep
)].bufpq
, next
, buf_next
) {
498 bufp_free(dev
, buf
, ep
);
503 * USBDevice callbacks
506 static void usbredir_handle_reset(USBDevice
*udev
)
508 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
510 DPRINTF("reset device\n");
511 usbredirparser_send_reset(dev
->parser
);
512 usbredirparser_do_write(dev
->parser
);
515 static void usbredir_handle_iso_data(USBRedirDevice
*dev
, USBPacket
*p
,
519 if (!dev
->endpoint
[EP2I(ep
)].iso_started
&&
520 !dev
->endpoint
[EP2I(ep
)].iso_error
) {
521 struct usb_redir_start_iso_stream_header start_iso
= {
526 if (dev
->dev
.speed
== USB_SPEED_HIGH
) {
527 pkts_per_sec
= 8000 / dev
->endpoint
[EP2I(ep
)].interval
;
529 pkts_per_sec
= 1000 / dev
->endpoint
[EP2I(ep
)].interval
;
531 /* Testing has shown that we need circa 60 ms buffer */
532 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= (pkts_per_sec
* 60) / 1000;
534 /* Aim for approx 100 interrupts / second on the client to
535 balance latency and interrupt load */
536 start_iso
.pkts_per_urb
= pkts_per_sec
/ 100;
537 if (start_iso
.pkts_per_urb
< 1) {
538 start_iso
.pkts_per_urb
= 1;
539 } else if (start_iso
.pkts_per_urb
> 32) {
540 start_iso
.pkts_per_urb
= 32;
543 start_iso
.no_urbs
= (dev
->endpoint
[EP2I(ep
)].bufpq_target_size
+
544 start_iso
.pkts_per_urb
- 1) /
545 start_iso
.pkts_per_urb
;
546 /* Output endpoints pre-fill only 1/2 of the packets, keeping the rest
547 as overflow buffer. Also see the usbredir protocol documentation */
548 if (!(ep
& USB_DIR_IN
)) {
549 start_iso
.no_urbs
*= 2;
551 if (start_iso
.no_urbs
> 16) {
552 start_iso
.no_urbs
= 16;
555 /* No id, we look at the ep when receiving a status back */
556 usbredirparser_send_start_iso_stream(dev
->parser
, 0, &start_iso
);
557 usbredirparser_do_write(dev
->parser
);
558 DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n",
559 pkts_per_sec
, start_iso
.pkts_per_urb
, start_iso
.no_urbs
, ep
);
560 dev
->endpoint
[EP2I(ep
)].iso_started
= 1;
561 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 0;
562 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
565 if (ep
& USB_DIR_IN
) {
566 struct buf_packet
*isop
;
568 if (dev
->endpoint
[EP2I(ep
)].iso_started
&&
569 !dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
) {
570 if (dev
->endpoint
[EP2I(ep
)].bufpq_size
<
571 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
574 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 1;
577 isop
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
);
579 DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n",
580 ep
, dev
->endpoint
[EP2I(ep
)].iso_error
);
581 /* Re-fill the buffer */
582 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 0;
583 /* Check iso_error for stream errors, otherwise its an underrun */
584 status
= dev
->endpoint
[EP2I(ep
)].iso_error
;
585 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
586 p
->status
= status
? USB_RET_IOERROR
: USB_RET_SUCCESS
;
589 DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep
,
590 isop
->status
, isop
->len
, dev
->endpoint
[EP2I(ep
)].bufpq_size
);
592 status
= isop
->status
;
594 if (len
> p
->iov
.size
) {
595 ERROR("received iso data is larger then packet ep %02X (%d > %d)\n",
596 ep
, len
, (int)p
->iov
.size
);
598 status
= usb_redir_babble
;
600 usb_packet_copy(p
, isop
->data
, len
);
601 bufp_free(dev
, isop
, ep
);
602 usbredir_handle_status(dev
, p
, status
);
604 /* If the stream was not started because of a pending error don't
605 send the packet to the usb-host */
606 if (dev
->endpoint
[EP2I(ep
)].iso_started
) {
607 struct usb_redir_iso_packet_header iso_packet
= {
609 .length
= p
->iov
.size
611 uint8_t buf
[p
->iov
.size
];
612 /* No id, we look at the ep when receiving a status back */
613 usb_packet_copy(p
, buf
, p
->iov
.size
);
614 usbredirparser_send_iso_packet(dev
->parser
, 0, &iso_packet
,
616 usbredirparser_do_write(dev
->parser
);
618 status
= dev
->endpoint
[EP2I(ep
)].iso_error
;
619 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
620 DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep
, status
,
622 usbredir_handle_status(dev
, p
, status
);
626 static void usbredir_stop_iso_stream(USBRedirDevice
*dev
, uint8_t ep
)
628 struct usb_redir_stop_iso_stream_header stop_iso_stream
= {
631 if (dev
->endpoint
[EP2I(ep
)].iso_started
) {
632 usbredirparser_send_stop_iso_stream(dev
->parser
, 0, &stop_iso_stream
);
633 DPRINTF("iso stream stopped ep %02X\n", ep
);
634 dev
->endpoint
[EP2I(ep
)].iso_started
= 0;
636 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
637 usbredir_free_bufpq(dev
, ep
);
641 * The usb-host may poll the endpoint faster then our guest, resulting in lots
642 * of smaller bulkp-s. The below buffered_bulk_in_complete* functions combine
643 * data from multiple bulkp-s into a single packet, avoiding bufpq overflows.
645 static void usbredir_buffered_bulk_add_data_to_packet(USBRedirDevice
*dev
,
646 struct buf_packet
*bulkp
, int count
, USBPacket
*p
, uint8_t ep
)
648 usb_packet_copy(p
, bulkp
->data
+ bulkp
->offset
, count
);
649 bulkp
->offset
+= count
;
650 if (bulkp
->offset
== bulkp
->len
) {
651 /* Store status in the last packet with data from this bulkp */
652 usbredir_handle_status(dev
, p
, bulkp
->status
);
653 bufp_free(dev
, bulkp
, ep
);
657 static void usbredir_buffered_bulk_in_complete_raw(USBRedirDevice
*dev
,
658 USBPacket
*p
, uint8_t ep
)
660 struct buf_packet
*bulkp
;
663 while ((bulkp
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
)) &&
664 p
->actual_length
< p
->iov
.size
&& p
->status
== USB_RET_SUCCESS
) {
665 count
= bulkp
->len
- bulkp
->offset
;
666 if (count
> (p
->iov
.size
- p
->actual_length
)) {
667 count
= p
->iov
.size
- p
->actual_length
;
669 usbredir_buffered_bulk_add_data_to_packet(dev
, bulkp
, count
, p
, ep
);
673 static void usbredir_buffered_bulk_in_complete_ftdi(USBRedirDevice
*dev
,
674 USBPacket
*p
, uint8_t ep
)
676 const int maxp
= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
677 uint8_t header
[2] = { 0, 0 };
678 struct buf_packet
*bulkp
;
681 while ((bulkp
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
)) &&
682 p
->actual_length
< p
->iov
.size
&& p
->status
== USB_RET_SUCCESS
) {
683 if (bulkp
->len
< 2) {
684 WARNING("malformed ftdi bulk in packet\n");
685 bufp_free(dev
, bulkp
, ep
);
689 if ((p
->actual_length
% maxp
) == 0) {
690 usb_packet_copy(p
, bulkp
->data
, 2);
691 memcpy(header
, bulkp
->data
, 2);
693 if (bulkp
->data
[0] != header
[0] || bulkp
->data
[1] != header
[1]) {
694 break; /* Different header, add to next packet */
698 if (bulkp
->offset
== 0) {
699 bulkp
->offset
= 2; /* Skip header */
701 count
= bulkp
->len
- bulkp
->offset
;
702 /* Must repeat the header at maxp interval */
703 if (count
> (maxp
- (p
->actual_length
% maxp
))) {
704 count
= maxp
- (p
->actual_length
% maxp
);
706 usbredir_buffered_bulk_add_data_to_packet(dev
, bulkp
, count
, p
, ep
);
710 static void usbredir_buffered_bulk_in_complete(USBRedirDevice
*dev
,
711 USBPacket
*p
, uint8_t ep
)
713 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
714 dev
->buffered_bulk_in_complete(dev
, p
, ep
);
715 DPRINTF("bulk-token-in ep %02X status %d len %d id %"PRIu64
"\n",
716 ep
, p
->status
, p
->actual_length
, p
->id
);
719 static void usbredir_handle_buffered_bulk_in_data(USBRedirDevice
*dev
,
720 USBPacket
*p
, uint8_t ep
)
722 /* Input bulk endpoint, buffered packet input */
723 if (!dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
) {
725 struct usb_redir_start_bulk_receiving_header start
= {
730 /* Round bytes_per_transfer up to a multiple of max_packet_size */
731 bpt
= 512 + dev
->endpoint
[EP2I(ep
)].max_packet_size
- 1;
732 bpt
/= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
733 bpt
*= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
734 start
.bytes_per_transfer
= bpt
;
735 /* No id, we look at the ep when receiving a status back */
736 usbredirparser_send_start_bulk_receiving(dev
->parser
, 0, &start
);
737 usbredirparser_do_write(dev
->parser
);
738 DPRINTF("bulk receiving started bytes/transfer %u count %d ep %02X\n",
739 start
.bytes_per_transfer
, start
.no_transfers
, ep
);
740 dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
= 1;
741 /* We don't really want to drop bulk packets ever, but
742 having some upper limit to how much we buffer is good. */
743 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= 5000;
744 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
747 if (QTAILQ_EMPTY(&dev
->endpoint
[EP2I(ep
)].bufpq
)) {
748 DPRINTF("bulk-token-in ep %02X, no bulkp\n", ep
);
749 assert(dev
->endpoint
[EP2I(ep
)].pending_async_packet
== NULL
);
750 dev
->endpoint
[EP2I(ep
)].pending_async_packet
= p
;
751 p
->status
= USB_RET_ASYNC
;
754 usbredir_buffered_bulk_in_complete(dev
, p
, ep
);
757 static void usbredir_stop_bulk_receiving(USBRedirDevice
*dev
, uint8_t ep
)
759 struct usb_redir_stop_bulk_receiving_header stop_bulk
= {
763 if (dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
) {
764 usbredirparser_send_stop_bulk_receiving(dev
->parser
, 0, &stop_bulk
);
765 DPRINTF("bulk receiving stopped ep %02X\n", ep
);
766 dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
= 0;
768 usbredir_free_bufpq(dev
, ep
);
771 static void usbredir_handle_bulk_data(USBRedirDevice
*dev
, USBPacket
*p
,
774 struct usb_redir_bulk_packet_header bulk_packet
;
775 size_t size
= usb_packet_size(p
);
776 const int maxp
= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
778 if (usbredir_already_in_flight(dev
, p
->id
)) {
779 p
->status
= USB_RET_ASYNC
;
783 if (dev
->endpoint
[EP2I(ep
)].bulk_receiving_enabled
) {
784 if (size
!= 0 && (size
% maxp
) == 0) {
785 usbredir_handle_buffered_bulk_in_data(dev
, p
, ep
);
788 WARNING("bulk recv invalid size %zd ep %02x, disabling\n", size
, ep
);
789 assert(dev
->endpoint
[EP2I(ep
)].pending_async_packet
== NULL
);
790 usbredir_stop_bulk_receiving(dev
, ep
);
791 dev
->endpoint
[EP2I(ep
)].bulk_receiving_enabled
= 0;
794 DPRINTF("bulk-out ep %02X stream %u len %zd id %"PRIu64
"\n",
795 ep
, p
->stream
, size
, p
->id
);
797 bulk_packet
.endpoint
= ep
;
798 bulk_packet
.length
= size
;
799 bulk_packet
.stream_id
= p
->stream
;
800 bulk_packet
.length_high
= size
>> 16;
801 assert(bulk_packet
.length_high
== 0 ||
802 usbredirparser_peer_has_cap(dev
->parser
,
803 usb_redir_cap_32bits_bulk_length
));
805 if (ep
& USB_DIR_IN
) {
806 usbredirparser_send_bulk_packet(dev
->parser
, p
->id
,
807 &bulk_packet
, NULL
, 0);
810 usb_packet_copy(p
, buf
, size
);
811 usbredir_log_data(dev
, "bulk data out:", buf
, size
);
812 usbredirparser_send_bulk_packet(dev
->parser
, p
->id
,
813 &bulk_packet
, buf
, size
);
815 usbredirparser_do_write(dev
->parser
);
816 p
->status
= USB_RET_ASYNC
;
819 static void usbredir_handle_interrupt_in_data(USBRedirDevice
*dev
,
820 USBPacket
*p
, uint8_t ep
)
822 /* Input interrupt endpoint, buffered packet input */
823 struct buf_packet
*intp
;
826 if (!dev
->endpoint
[EP2I(ep
)].interrupt_started
&&
827 !dev
->endpoint
[EP2I(ep
)].interrupt_error
) {
828 struct usb_redir_start_interrupt_receiving_header start_int
= {
831 /* No id, we look at the ep when receiving a status back */
832 usbredirparser_send_start_interrupt_receiving(dev
->parser
, 0,
834 usbredirparser_do_write(dev
->parser
);
835 DPRINTF("interrupt recv started ep %02X\n", ep
);
836 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 1;
837 /* We don't really want to drop interrupt packets ever, but
838 having some upper limit to how much we buffer is good. */
839 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= 1000;
840 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
843 intp
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
);
845 DPRINTF2("interrupt-token-in ep %02X, no intp\n", ep
);
846 /* Check interrupt_error for stream errors */
847 status
= dev
->endpoint
[EP2I(ep
)].interrupt_error
;
848 dev
->endpoint
[EP2I(ep
)].interrupt_error
= 0;
850 usbredir_handle_status(dev
, p
, status
);
852 p
->status
= USB_RET_NAK
;
856 DPRINTF("interrupt-token-in ep %02X status %d len %d\n", ep
,
857 intp
->status
, intp
->len
);
859 status
= intp
->status
;
861 if (len
> p
->iov
.size
) {
862 ERROR("received int data is larger then packet ep %02X\n", ep
);
864 status
= usb_redir_babble
;
866 usb_packet_copy(p
, intp
->data
, len
);
867 bufp_free(dev
, intp
, ep
);
868 usbredir_handle_status(dev
, p
, status
);
872 * Handle interrupt out data, the usbredir protocol expects us to do this
873 * async, so that it can report back a completion status. But guests will
874 * expect immediate completion for an interrupt endpoint, and handling this
875 * async causes migration issues. So we report success directly, counting
876 * on the fact that output interrupt packets normally always succeed.
878 static void usbredir_handle_interrupt_out_data(USBRedirDevice
*dev
,
879 USBPacket
*p
, uint8_t ep
)
881 struct usb_redir_interrupt_packet_header interrupt_packet
;
882 uint8_t buf
[p
->iov
.size
];
884 DPRINTF("interrupt-out ep %02X len %zd id %"PRIu64
"\n", ep
,
887 interrupt_packet
.endpoint
= ep
;
888 interrupt_packet
.length
= p
->iov
.size
;
890 usb_packet_copy(p
, buf
, p
->iov
.size
);
891 usbredir_log_data(dev
, "interrupt data out:", buf
, p
->iov
.size
);
892 usbredirparser_send_interrupt_packet(dev
->parser
, p
->id
,
893 &interrupt_packet
, buf
, p
->iov
.size
);
894 usbredirparser_do_write(dev
->parser
);
897 static void usbredir_stop_interrupt_receiving(USBRedirDevice
*dev
,
900 struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv
= {
903 if (dev
->endpoint
[EP2I(ep
)].interrupt_started
) {
904 usbredirparser_send_stop_interrupt_receiving(dev
->parser
, 0,
905 &stop_interrupt_recv
);
906 DPRINTF("interrupt recv stopped ep %02X\n", ep
);
907 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 0;
909 dev
->endpoint
[EP2I(ep
)].interrupt_error
= 0;
910 usbredir_free_bufpq(dev
, ep
);
913 static void usbredir_handle_data(USBDevice
*udev
, USBPacket
*p
)
915 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
919 if (p
->pid
== USB_TOKEN_IN
) {
923 switch (dev
->endpoint
[EP2I(ep
)].type
) {
924 case USB_ENDPOINT_XFER_CONTROL
:
925 ERROR("handle_data called for control transfer on ep %02X\n", ep
);
926 p
->status
= USB_RET_NAK
;
928 case USB_ENDPOINT_XFER_BULK
:
929 if (p
->state
== USB_PACKET_SETUP
&& p
->pid
== USB_TOKEN_IN
&&
931 p
->status
= USB_RET_ADD_TO_QUEUE
;
934 usbredir_handle_bulk_data(dev
, p
, ep
);
936 case USB_ENDPOINT_XFER_ISOC
:
937 usbredir_handle_iso_data(dev
, p
, ep
);
939 case USB_ENDPOINT_XFER_INT
:
940 if (ep
& USB_DIR_IN
) {
941 usbredir_handle_interrupt_in_data(dev
, p
, ep
);
943 usbredir_handle_interrupt_out_data(dev
, p
, ep
);
947 ERROR("handle_data ep %02X has unknown type %d\n", ep
,
948 dev
->endpoint
[EP2I(ep
)].type
);
949 p
->status
= USB_RET_NAK
;
953 static void usbredir_flush_ep_queue(USBDevice
*dev
, USBEndpoint
*ep
)
955 if (ep
->pid
== USB_TOKEN_IN
&& ep
->pipeline
) {
956 usb_ep_combine_input_packets(ep
);
960 static void usbredir_stop_ep(USBRedirDevice
*dev
, int i
)
962 uint8_t ep
= I2EP(i
);
964 switch (dev
->endpoint
[i
].type
) {
965 case USB_ENDPOINT_XFER_BULK
:
966 if (ep
& USB_DIR_IN
) {
967 usbredir_stop_bulk_receiving(dev
, ep
);
970 case USB_ENDPOINT_XFER_ISOC
:
971 usbredir_stop_iso_stream(dev
, ep
);
973 case USB_ENDPOINT_XFER_INT
:
974 if (ep
& USB_DIR_IN
) {
975 usbredir_stop_interrupt_receiving(dev
, ep
);
979 usbredir_free_bufpq(dev
, ep
);
982 static void usbredir_ep_stopped(USBDevice
*udev
, USBEndpoint
*uep
)
984 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
986 usbredir_stop_ep(dev
, USBEP2I(uep
));
987 usbredirparser_do_write(dev
->parser
);
990 static void usbredir_set_config(USBRedirDevice
*dev
, USBPacket
*p
,
993 struct usb_redir_set_configuration_header set_config
;
996 DPRINTF("set config %d id %"PRIu64
"\n", config
, p
->id
);
998 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
999 usbredir_stop_ep(dev
, i
);
1002 set_config
.configuration
= config
;
1003 usbredirparser_send_set_configuration(dev
->parser
, p
->id
, &set_config
);
1004 usbredirparser_do_write(dev
->parser
);
1005 p
->status
= USB_RET_ASYNC
;
1008 static void usbredir_get_config(USBRedirDevice
*dev
, USBPacket
*p
)
1010 DPRINTF("get config id %"PRIu64
"\n", p
->id
);
1012 usbredirparser_send_get_configuration(dev
->parser
, p
->id
);
1013 usbredirparser_do_write(dev
->parser
);
1014 p
->status
= USB_RET_ASYNC
;
1017 static void usbredir_set_interface(USBRedirDevice
*dev
, USBPacket
*p
,
1018 int interface
, int alt
)
1020 struct usb_redir_set_alt_setting_header set_alt
;
1023 DPRINTF("set interface %d alt %d id %"PRIu64
"\n", interface
, alt
, p
->id
);
1025 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1026 if (dev
->endpoint
[i
].interface
== interface
) {
1027 usbredir_stop_ep(dev
, i
);
1031 set_alt
.interface
= interface
;
1033 usbredirparser_send_set_alt_setting(dev
->parser
, p
->id
, &set_alt
);
1034 usbredirparser_do_write(dev
->parser
);
1035 p
->status
= USB_RET_ASYNC
;
1038 static void usbredir_get_interface(USBRedirDevice
*dev
, USBPacket
*p
,
1041 struct usb_redir_get_alt_setting_header get_alt
;
1043 DPRINTF("get interface %d id %"PRIu64
"\n", interface
, p
->id
);
1045 get_alt
.interface
= interface
;
1046 usbredirparser_send_get_alt_setting(dev
->parser
, p
->id
, &get_alt
);
1047 usbredirparser_do_write(dev
->parser
);
1048 p
->status
= USB_RET_ASYNC
;
1051 static void usbredir_handle_control(USBDevice
*udev
, USBPacket
*p
,
1052 int request
, int value
, int index
, int length
, uint8_t *data
)
1054 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1055 struct usb_redir_control_packet_header control_packet
;
1057 if (usbredir_already_in_flight(dev
, p
->id
)) {
1058 p
->status
= USB_RET_ASYNC
;
1062 /* Special cases for certain standard device requests */
1064 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
1065 DPRINTF("set address %d\n", value
);
1066 dev
->dev
.addr
= value
;
1068 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
1069 usbredir_set_config(dev
, p
, value
& 0xff);
1071 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
1072 usbredir_get_config(dev
, p
);
1074 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
1075 usbredir_set_interface(dev
, p
, index
, value
);
1077 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
1078 usbredir_get_interface(dev
, p
, index
);
1082 /* Normal ctrl requests, note request is (bRequestType << 8) | bRequest */
1084 "ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %"PRIu64
"\n",
1085 request
>> 8, request
& 0xff, value
, index
, length
, p
->id
);
1087 control_packet
.request
= request
& 0xFF;
1088 control_packet
.requesttype
= request
>> 8;
1089 control_packet
.endpoint
= control_packet
.requesttype
& USB_DIR_IN
;
1090 control_packet
.value
= value
;
1091 control_packet
.index
= index
;
1092 control_packet
.length
= length
;
1094 if (control_packet
.requesttype
& USB_DIR_IN
) {
1095 usbredirparser_send_control_packet(dev
->parser
, p
->id
,
1096 &control_packet
, NULL
, 0);
1098 usbredir_log_data(dev
, "ctrl data out:", data
, length
);
1099 usbredirparser_send_control_packet(dev
->parser
, p
->id
,
1100 &control_packet
, data
, length
);
1102 usbredirparser_do_write(dev
->parser
);
1103 p
->status
= USB_RET_ASYNC
;
1106 static int usbredir_alloc_streams(USBDevice
*udev
, USBEndpoint
**eps
,
1107 int nr_eps
, int streams
)
1109 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1110 #if USBREDIR_VERSION >= 0x000700
1111 struct usb_redir_alloc_bulk_streams_header alloc_streams
;
1114 if (!usbredirparser_peer_has_cap(dev
->parser
,
1115 usb_redir_cap_bulk_streams
)) {
1116 ERROR("peer does not support streams\n");
1121 ERROR("request to allocate 0 streams\n");
1125 alloc_streams
.no_streams
= streams
;
1126 alloc_streams
.endpoints
= 0;
1127 for (i
= 0; i
< nr_eps
; i
++) {
1128 alloc_streams
.endpoints
|= 1 << USBEP2I(eps
[i
]);
1130 usbredirparser_send_alloc_bulk_streams(dev
->parser
, 0, &alloc_streams
);
1131 usbredirparser_do_write(dev
->parser
);
1135 ERROR("usbredir_alloc_streams not implemented\n");
1139 ERROR("streams are not available, disconnecting\n");
1140 qemu_bh_schedule(dev
->device_reject_bh
);
1144 static void usbredir_free_streams(USBDevice
*udev
, USBEndpoint
**eps
,
1147 #if USBREDIR_VERSION >= 0x000700
1148 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1149 struct usb_redir_free_bulk_streams_header free_streams
;
1152 if (!usbredirparser_peer_has_cap(dev
->parser
,
1153 usb_redir_cap_bulk_streams
)) {
1157 free_streams
.endpoints
= 0;
1158 for (i
= 0; i
< nr_eps
; i
++) {
1159 free_streams
.endpoints
|= 1 << USBEP2I(eps
[i
]);
1161 usbredirparser_send_free_bulk_streams(dev
->parser
, 0, &free_streams
);
1162 usbredirparser_do_write(dev
->parser
);
1167 * Close events can be triggered by usbredirparser_do_write which gets called
1168 * from within the USBDevice data / control packet callbacks and doing a
1169 * usb_detach from within these callbacks is not a good idea.
1171 * So we use a bh handler to take care of close events.
1173 static void usbredir_chardev_close_bh(void *opaque
)
1175 USBRedirDevice
*dev
= opaque
;
1177 qemu_bh_cancel(dev
->device_reject_bh
);
1178 usbredir_device_disconnect(dev
);
1181 DPRINTF("destroying usbredirparser\n");
1182 usbredirparser_destroy(dev
->parser
);
1186 g_source_remove(dev
->watch
);
1191 static void usbredir_create_parser(USBRedirDevice
*dev
)
1193 uint32_t caps
[USB_REDIR_CAPS_SIZE
] = { 0, };
1196 DPRINTF("creating usbredirparser\n");
1198 dev
->parser
= qemu_oom_check(usbredirparser_create());
1199 dev
->parser
->priv
= dev
;
1200 dev
->parser
->log_func
= usbredir_log
;
1201 dev
->parser
->read_func
= usbredir_read
;
1202 dev
->parser
->write_func
= usbredir_write
;
1203 dev
->parser
->hello_func
= usbredir_hello
;
1204 dev
->parser
->device_connect_func
= usbredir_device_connect
;
1205 dev
->parser
->device_disconnect_func
= usbredir_device_disconnect
;
1206 dev
->parser
->interface_info_func
= usbredir_interface_info
;
1207 dev
->parser
->ep_info_func
= usbredir_ep_info
;
1208 dev
->parser
->configuration_status_func
= usbredir_configuration_status
;
1209 dev
->parser
->alt_setting_status_func
= usbredir_alt_setting_status
;
1210 dev
->parser
->iso_stream_status_func
= usbredir_iso_stream_status
;
1211 dev
->parser
->interrupt_receiving_status_func
=
1212 usbredir_interrupt_receiving_status
;
1213 dev
->parser
->bulk_streams_status_func
= usbredir_bulk_streams_status
;
1214 dev
->parser
->bulk_receiving_status_func
= usbredir_bulk_receiving_status
;
1215 dev
->parser
->control_packet_func
= usbredir_control_packet
;
1216 dev
->parser
->bulk_packet_func
= usbredir_bulk_packet
;
1217 dev
->parser
->iso_packet_func
= usbredir_iso_packet
;
1218 dev
->parser
->interrupt_packet_func
= usbredir_interrupt_packet
;
1219 dev
->parser
->buffered_bulk_packet_func
= usbredir_buffered_bulk_packet
;
1220 dev
->read_buf
= NULL
;
1221 dev
->read_buf_size
= 0;
1223 usbredirparser_caps_set_cap(caps
, usb_redir_cap_connect_device_version
);
1224 usbredirparser_caps_set_cap(caps
, usb_redir_cap_filter
);
1225 usbredirparser_caps_set_cap(caps
, usb_redir_cap_ep_info_max_packet_size
);
1226 usbredirparser_caps_set_cap(caps
, usb_redir_cap_64bits_ids
);
1227 usbredirparser_caps_set_cap(caps
, usb_redir_cap_32bits_bulk_length
);
1228 usbredirparser_caps_set_cap(caps
, usb_redir_cap_bulk_receiving
);
1229 #if USBREDIR_VERSION >= 0x000700
1230 usbredirparser_caps_set_cap(caps
, usb_redir_cap_bulk_streams
);
1233 if (runstate_check(RUN_STATE_INMIGRATE
)) {
1234 flags
|= usbredirparser_fl_no_hello
;
1236 usbredirparser_init(dev
->parser
, VERSION
, caps
, USB_REDIR_CAPS_SIZE
,
1238 usbredirparser_do_write(dev
->parser
);
1241 static void usbredir_reject_device(USBRedirDevice
*dev
)
1243 usbredir_device_disconnect(dev
);
1244 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
)) {
1245 usbredirparser_send_filter_reject(dev
->parser
);
1246 usbredirparser_do_write(dev
->parser
);
1251 * We may need to reject the device when the hcd calls alloc_streams, doing
1252 * an usb_detach from within a hcd call is not a good idea, hence this bh.
1254 static void usbredir_device_reject_bh(void *opaque
)
1256 USBRedirDevice
*dev
= opaque
;
1258 usbredir_reject_device(dev
);
1261 static void usbredir_do_attach(void *opaque
)
1263 USBRedirDevice
*dev
= opaque
;
1264 Error
*local_err
= NULL
;
1266 /* In order to work properly with XHCI controllers we need these caps */
1267 if ((dev
->dev
.port
->speedmask
& USB_SPEED_MASK_SUPER
) && !(
1268 usbredirparser_peer_has_cap(dev
->parser
,
1269 usb_redir_cap_ep_info_max_packet_size
) &&
1270 usbredirparser_peer_has_cap(dev
->parser
,
1271 usb_redir_cap_32bits_bulk_length
) &&
1272 usbredirparser_peer_has_cap(dev
->parser
,
1273 usb_redir_cap_64bits_ids
))) {
1274 ERROR("usb-redir-host lacks capabilities needed for use with XHCI\n");
1275 usbredir_reject_device(dev
);
1279 usb_device_attach(&dev
->dev
, &local_err
);
1281 error_report_err(local_err
);
1282 WARNING("rejecting device due to speed mismatch\n");
1283 usbredir_reject_device(dev
);
1291 static int usbredir_chardev_can_read(void *opaque
)
1293 USBRedirDevice
*dev
= opaque
;
1296 WARNING("chardev_can_read called on non open chardev!\n");
1300 /* Don't read new data from the chardev until our state is fully synced */
1301 if (!runstate_check(RUN_STATE_RUNNING
)) {
1305 /* usbredir_parser_do_read will consume *all* data we give it */
1309 static void usbredir_chardev_read(void *opaque
, const uint8_t *buf
, int size
)
1311 USBRedirDevice
*dev
= opaque
;
1313 /* No recursion allowed! */
1314 assert(dev
->read_buf
== NULL
);
1316 dev
->read_buf
= buf
;
1317 dev
->read_buf_size
= size
;
1319 usbredirparser_do_read(dev
->parser
);
1320 /* Send any acks, etc. which may be queued now */
1321 usbredirparser_do_write(dev
->parser
);
1324 static void usbredir_chardev_event(void *opaque
, int event
)
1326 USBRedirDevice
*dev
= opaque
;
1329 case CHR_EVENT_OPENED
:
1330 DPRINTF("chardev open\n");
1331 /* Make sure any pending closes are handled (no-op if none pending) */
1332 usbredir_chardev_close_bh(dev
);
1333 qemu_bh_cancel(dev
->chardev_close_bh
);
1334 usbredir_create_parser(dev
);
1336 case CHR_EVENT_CLOSED
:
1337 DPRINTF("chardev close\n");
1338 qemu_bh_schedule(dev
->chardev_close_bh
);
1347 static void usbredir_vm_state_change(void *priv
, int running
, RunState state
)
1349 USBRedirDevice
*dev
= priv
;
1351 if (state
== RUN_STATE_RUNNING
&& dev
->parser
!= NULL
) {
1352 usbredirparser_do_write(dev
->parser
); /* Flush any pending writes */
1356 static void usbredir_init_endpoints(USBRedirDevice
*dev
)
1360 usb_ep_init(&dev
->dev
);
1361 memset(dev
->endpoint
, 0, sizeof(dev
->endpoint
));
1362 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1363 dev
->endpoint
[i
].dev
= dev
;
1364 QTAILQ_INIT(&dev
->endpoint
[i
].bufpq
);
1368 static void usbredir_realize(USBDevice
*udev
, Error
**errp
)
1370 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1373 if (dev
->cs
== NULL
) {
1374 error_setg(errp
, QERR_MISSING_PARAMETER
, "chardev");
1378 if (dev
->filter_str
) {
1379 i
= usbredirfilter_string_to_rules(dev
->filter_str
, ":", "|",
1381 &dev
->filter_rules_count
);
1383 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "filter",
1384 "a usb device filter string");
1389 dev
->chardev_close_bh
= qemu_bh_new(usbredir_chardev_close_bh
, dev
);
1390 dev
->device_reject_bh
= qemu_bh_new(usbredir_device_reject_bh
, dev
);
1391 dev
->attach_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, usbredir_do_attach
, dev
);
1393 packet_id_queue_init(&dev
->cancelled
, dev
, "cancelled");
1394 packet_id_queue_init(&dev
->already_in_flight
, dev
, "already-in-flight");
1395 usbredir_init_endpoints(dev
);
1397 /* We'll do the attach once we receive the speed from the usb-host */
1398 udev
->auto_attach
= 0;
1400 /* Will be cleared during setup when we find conflicts */
1401 dev
->compatible_speedmask
= USB_SPEED_MASK_FULL
| USB_SPEED_MASK_HIGH
;
1403 /* Let the backend know we are ready */
1404 qemu_chr_add_handlers(dev
->cs
, usbredir_chardev_can_read
,
1405 usbredir_chardev_read
, usbredir_chardev_event
, dev
);
1407 qemu_add_vm_change_state_handler(usbredir_vm_state_change
, dev
);
1410 static void usbredir_cleanup_device_queues(USBRedirDevice
*dev
)
1414 packet_id_queue_empty(&dev
->cancelled
);
1415 packet_id_queue_empty(&dev
->already_in_flight
);
1416 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1417 usbredir_free_bufpq(dev
, I2EP(i
));
1421 static void usbredir_handle_destroy(USBDevice
*udev
)
1423 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1425 qemu_chr_delete(dev
->cs
);
1427 /* Note must be done after qemu_chr_close, as that causes a close event */
1428 qemu_bh_delete(dev
->chardev_close_bh
);
1429 qemu_bh_delete(dev
->device_reject_bh
);
1431 timer_del(dev
->attach_timer
);
1432 timer_free(dev
->attach_timer
);
1434 usbredir_cleanup_device_queues(dev
);
1437 usbredirparser_destroy(dev
->parser
);
1440 g_source_remove(dev
->watch
);
1443 free(dev
->filter_rules
);
1446 static int usbredir_check_filter(USBRedirDevice
*dev
)
1448 if (dev
->interface_info
.interface_count
== NO_INTERFACE_INFO
) {
1449 ERROR("No interface info for device\n");
1453 if (dev
->filter_rules
) {
1454 if (!usbredirparser_peer_has_cap(dev
->parser
,
1455 usb_redir_cap_connect_device_version
)) {
1456 ERROR("Device filter specified and peer does not have the "
1457 "connect_device_version capability\n");
1461 if (usbredirfilter_check(
1463 dev
->filter_rules_count
,
1464 dev
->device_info
.device_class
,
1465 dev
->device_info
.device_subclass
,
1466 dev
->device_info
.device_protocol
,
1467 dev
->interface_info
.interface_class
,
1468 dev
->interface_info
.interface_subclass
,
1469 dev
->interface_info
.interface_protocol
,
1470 dev
->interface_info
.interface_count
,
1471 dev
->device_info
.vendor_id
,
1472 dev
->device_info
.product_id
,
1473 dev
->device_info
.device_version_bcd
,
1482 usbredir_reject_device(dev
);
1486 static void usbredir_check_bulk_receiving(USBRedirDevice
*dev
)
1490 if (!usbredirparser_peer_has_cap(dev
->parser
,
1491 usb_redir_cap_bulk_receiving
)) {
1495 for (i
= EP2I(USB_DIR_IN
); i
< MAX_ENDPOINTS
; i
++) {
1496 dev
->endpoint
[i
].bulk_receiving_enabled
= 0;
1498 for (i
= 0; i
< dev
->interface_info
.interface_count
; i
++) {
1499 quirks
= usb_get_quirks(dev
->device_info
.vendor_id
,
1500 dev
->device_info
.product_id
,
1501 dev
->interface_info
.interface_class
[i
],
1502 dev
->interface_info
.interface_subclass
[i
],
1503 dev
->interface_info
.interface_protocol
[i
]);
1504 if (!(quirks
& USB_QUIRK_BUFFER_BULK_IN
)) {
1507 if (quirks
& USB_QUIRK_IS_FTDI
) {
1508 dev
->buffered_bulk_in_complete
=
1509 usbredir_buffered_bulk_in_complete_ftdi
;
1511 dev
->buffered_bulk_in_complete
=
1512 usbredir_buffered_bulk_in_complete_raw
;
1515 for (j
= EP2I(USB_DIR_IN
); j
< MAX_ENDPOINTS
; j
++) {
1516 if (dev
->endpoint
[j
].interface
==
1517 dev
->interface_info
.interface
[i
] &&
1518 dev
->endpoint
[j
].type
== USB_ENDPOINT_XFER_BULK
&&
1519 dev
->endpoint
[j
].max_packet_size
!= 0) {
1520 dev
->endpoint
[j
].bulk_receiving_enabled
= 1;
1522 * With buffering pipelining is not necessary. Also packet
1523 * combining and bulk in buffering don't play nice together!
1525 I2USBEP(dev
, j
)->pipeline
= false;
1526 break; /* Only buffer for the first ep of each intf */
1533 * usbredirparser packet complete callbacks
1536 static void usbredir_handle_status(USBRedirDevice
*dev
, USBPacket
*p
,
1540 case usb_redir_success
:
1541 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
1543 case usb_redir_stall
:
1544 p
->status
= USB_RET_STALL
;
1546 case usb_redir_cancelled
:
1548 * When the usbredir-host unredirects a device, it will report a status
1549 * of cancelled for all pending packets, followed by a disconnect msg.
1551 p
->status
= USB_RET_IOERROR
;
1553 case usb_redir_inval
:
1554 WARNING("got invalid param error from usb-host?\n");
1555 p
->status
= USB_RET_IOERROR
;
1557 case usb_redir_babble
:
1558 p
->status
= USB_RET_BABBLE
;
1560 case usb_redir_ioerror
:
1561 case usb_redir_timeout
:
1563 p
->status
= USB_RET_IOERROR
;
1567 static void usbredir_hello(void *priv
, struct usb_redir_hello_header
*h
)
1569 USBRedirDevice
*dev
= priv
;
1571 /* Try to send the filter info now that we've the usb-host's caps */
1572 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
) &&
1573 dev
->filter_rules
) {
1574 usbredirparser_send_filter_filter(dev
->parser
, dev
->filter_rules
,
1575 dev
->filter_rules_count
);
1576 usbredirparser_do_write(dev
->parser
);
1580 static void usbredir_device_connect(void *priv
,
1581 struct usb_redir_device_connect_header
*device_connect
)
1583 USBRedirDevice
*dev
= priv
;
1586 if (timer_pending(dev
->attach_timer
) || dev
->dev
.attached
) {
1587 ERROR("Received device connect while already connected\n");
1591 switch (device_connect
->speed
) {
1592 case usb_redir_speed_low
:
1593 speed
= "low speed";
1594 dev
->dev
.speed
= USB_SPEED_LOW
;
1595 dev
->compatible_speedmask
&= ~USB_SPEED_MASK_FULL
;
1596 dev
->compatible_speedmask
&= ~USB_SPEED_MASK_HIGH
;
1598 case usb_redir_speed_full
:
1599 speed
= "full speed";
1600 dev
->dev
.speed
= USB_SPEED_FULL
;
1601 dev
->compatible_speedmask
&= ~USB_SPEED_MASK_HIGH
;
1603 case usb_redir_speed_high
:
1604 speed
= "high speed";
1605 dev
->dev
.speed
= USB_SPEED_HIGH
;
1607 case usb_redir_speed_super
:
1608 speed
= "super speed";
1609 dev
->dev
.speed
= USB_SPEED_SUPER
;
1612 speed
= "unknown speed";
1613 dev
->dev
.speed
= USB_SPEED_FULL
;
1616 if (usbredirparser_peer_has_cap(dev
->parser
,
1617 usb_redir_cap_connect_device_version
)) {
1618 INFO("attaching %s device %04x:%04x version %d.%d class %02x\n",
1619 speed
, device_connect
->vendor_id
, device_connect
->product_id
,
1620 ((device_connect
->device_version_bcd
& 0xf000) >> 12) * 10 +
1621 ((device_connect
->device_version_bcd
& 0x0f00) >> 8),
1622 ((device_connect
->device_version_bcd
& 0x00f0) >> 4) * 10 +
1623 ((device_connect
->device_version_bcd
& 0x000f) >> 0),
1624 device_connect
->device_class
);
1626 INFO("attaching %s device %04x:%04x class %02x\n", speed
,
1627 device_connect
->vendor_id
, device_connect
->product_id
,
1628 device_connect
->device_class
);
1631 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
) | dev
->compatible_speedmask
;
1632 dev
->device_info
= *device_connect
;
1634 if (usbredir_check_filter(dev
)) {
1635 WARNING("Device %04x:%04x rejected by device filter, not attaching\n",
1636 device_connect
->vendor_id
, device_connect
->product_id
);
1640 usbredir_check_bulk_receiving(dev
);
1641 timer_mod(dev
->attach_timer
, dev
->next_attach_time
);
1644 static void usbredir_device_disconnect(void *priv
)
1646 USBRedirDevice
*dev
= priv
;
1648 /* Stop any pending attaches */
1649 timer_del(dev
->attach_timer
);
1651 if (dev
->dev
.attached
) {
1652 DPRINTF("detaching device\n");
1653 usb_device_detach(&dev
->dev
);
1655 * Delay next usb device attach to give the guest a chance to see
1656 * see the detach / attach in case of quick close / open succession
1658 dev
->next_attach_time
= qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 200;
1661 /* Reset state so that the next dev connected starts with a clean slate */
1662 usbredir_cleanup_device_queues(dev
);
1663 usbredir_init_endpoints(dev
);
1664 dev
->interface_info
.interface_count
= NO_INTERFACE_INFO
;
1667 dev
->compatible_speedmask
= USB_SPEED_MASK_FULL
| USB_SPEED_MASK_HIGH
;
1670 static void usbredir_interface_info(void *priv
,
1671 struct usb_redir_interface_info_header
*interface_info
)
1673 USBRedirDevice
*dev
= priv
;
1675 dev
->interface_info
= *interface_info
;
1678 * If we receive interface info after the device has already been
1679 * connected (ie on a set_config), re-check interface dependent things.
1681 if (timer_pending(dev
->attach_timer
) || dev
->dev
.attached
) {
1682 usbredir_check_bulk_receiving(dev
);
1683 if (usbredir_check_filter(dev
)) {
1684 ERROR("Device no longer matches filter after interface info "
1685 "change, disconnecting!\n");
1690 static void usbredir_mark_speed_incompatible(USBRedirDevice
*dev
, int speed
)
1692 dev
->compatible_speedmask
&= ~(1 << speed
);
1693 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
) | dev
->compatible_speedmask
;
1696 static void usbredir_set_pipeline(USBRedirDevice
*dev
, struct USBEndpoint
*uep
)
1698 if (uep
->type
!= USB_ENDPOINT_XFER_BULK
) {
1701 if (uep
->pid
== USB_TOKEN_OUT
) {
1702 uep
->pipeline
= true;
1704 if (uep
->pid
== USB_TOKEN_IN
&& uep
->max_packet_size
!= 0 &&
1705 usbredirparser_peer_has_cap(dev
->parser
,
1706 usb_redir_cap_32bits_bulk_length
)) {
1707 uep
->pipeline
= true;
1711 static void usbredir_setup_usb_eps(USBRedirDevice
*dev
)
1713 struct USBEndpoint
*usb_ep
;
1716 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1717 usb_ep
= I2USBEP(dev
, i
);
1718 usb_ep
->type
= dev
->endpoint
[i
].type
;
1719 usb_ep
->ifnum
= dev
->endpoint
[i
].interface
;
1720 usb_ep
->max_packet_size
= dev
->endpoint
[i
].max_packet_size
;
1721 usb_ep
->max_streams
= dev
->endpoint
[i
].max_streams
;
1722 usbredir_set_pipeline(dev
, usb_ep
);
1726 static void usbredir_ep_info(void *priv
,
1727 struct usb_redir_ep_info_header
*ep_info
)
1729 USBRedirDevice
*dev
= priv
;
1732 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1733 dev
->endpoint
[i
].type
= ep_info
->type
[i
];
1734 dev
->endpoint
[i
].interval
= ep_info
->interval
[i
];
1735 dev
->endpoint
[i
].interface
= ep_info
->interface
[i
];
1736 if (usbredirparser_peer_has_cap(dev
->parser
,
1737 usb_redir_cap_ep_info_max_packet_size
)) {
1738 dev
->endpoint
[i
].max_packet_size
= ep_info
->max_packet_size
[i
];
1740 #if USBREDIR_VERSION >= 0x000700
1741 if (usbredirparser_peer_has_cap(dev
->parser
,
1742 usb_redir_cap_bulk_streams
)) {
1743 dev
->endpoint
[i
].max_streams
= ep_info
->max_streams
[i
];
1746 switch (dev
->endpoint
[i
].type
) {
1747 case usb_redir_type_invalid
:
1749 case usb_redir_type_iso
:
1750 usbredir_mark_speed_incompatible(dev
, USB_SPEED_FULL
);
1751 usbredir_mark_speed_incompatible(dev
, USB_SPEED_HIGH
);
1753 case usb_redir_type_interrupt
:
1754 if (!usbredirparser_peer_has_cap(dev
->parser
,
1755 usb_redir_cap_ep_info_max_packet_size
) ||
1756 ep_info
->max_packet_size
[i
] > 64) {
1757 usbredir_mark_speed_incompatible(dev
, USB_SPEED_FULL
);
1759 if (!usbredirparser_peer_has_cap(dev
->parser
,
1760 usb_redir_cap_ep_info_max_packet_size
) ||
1761 ep_info
->max_packet_size
[i
] > 1024) {
1762 usbredir_mark_speed_incompatible(dev
, USB_SPEED_HIGH
);
1764 if (dev
->endpoint
[i
].interval
== 0) {
1765 ERROR("Received 0 interval for isoc or irq endpoint\n");
1766 usbredir_reject_device(dev
);
1770 case usb_redir_type_control
:
1771 case usb_redir_type_bulk
:
1772 DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i
),
1773 dev
->endpoint
[i
].type
, dev
->endpoint
[i
].interface
);
1776 ERROR("Received invalid endpoint type\n");
1777 usbredir_reject_device(dev
);
1781 /* The new ep info may have caused a speed incompatibility, recheck */
1782 if (dev
->dev
.attached
&&
1783 !(dev
->dev
.port
->speedmask
& dev
->dev
.speedmask
)) {
1784 ERROR("Device no longer matches speed after endpoint info change, "
1785 "disconnecting!\n");
1786 usbredir_reject_device(dev
);
1789 usbredir_setup_usb_eps(dev
);
1790 usbredir_check_bulk_receiving(dev
);
1793 static void usbredir_configuration_status(void *priv
, uint64_t id
,
1794 struct usb_redir_configuration_status_header
*config_status
)
1796 USBRedirDevice
*dev
= priv
;
1799 DPRINTF("set config status %d config %d id %"PRIu64
"\n",
1800 config_status
->status
, config_status
->configuration
, id
);
1802 p
= usbredir_find_packet_by_id(dev
, 0, id
);
1804 if (dev
->dev
.setup_buf
[0] & USB_DIR_IN
) {
1805 dev
->dev
.data_buf
[0] = config_status
->configuration
;
1806 p
->actual_length
= 1;
1808 usbredir_handle_status(dev
, p
, config_status
->status
);
1809 usb_generic_async_ctrl_complete(&dev
->dev
, p
);
1813 static void usbredir_alt_setting_status(void *priv
, uint64_t id
,
1814 struct usb_redir_alt_setting_status_header
*alt_setting_status
)
1816 USBRedirDevice
*dev
= priv
;
1819 DPRINTF("alt status %d intf %d alt %d id: %"PRIu64
"\n",
1820 alt_setting_status
->status
, alt_setting_status
->interface
,
1821 alt_setting_status
->alt
, id
);
1823 p
= usbredir_find_packet_by_id(dev
, 0, id
);
1825 if (dev
->dev
.setup_buf
[0] & USB_DIR_IN
) {
1826 dev
->dev
.data_buf
[0] = alt_setting_status
->alt
;
1827 p
->actual_length
= 1;
1829 usbredir_handle_status(dev
, p
, alt_setting_status
->status
);
1830 usb_generic_async_ctrl_complete(&dev
->dev
, p
);
1834 static void usbredir_iso_stream_status(void *priv
, uint64_t id
,
1835 struct usb_redir_iso_stream_status_header
*iso_stream_status
)
1837 USBRedirDevice
*dev
= priv
;
1838 uint8_t ep
= iso_stream_status
->endpoint
;
1840 DPRINTF("iso status %d ep %02X id %"PRIu64
"\n", iso_stream_status
->status
,
1843 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].iso_started
) {
1847 dev
->endpoint
[EP2I(ep
)].iso_error
= iso_stream_status
->status
;
1848 if (iso_stream_status
->status
== usb_redir_stall
) {
1849 DPRINTF("iso stream stopped by peer ep %02X\n", ep
);
1850 dev
->endpoint
[EP2I(ep
)].iso_started
= 0;
1854 static void usbredir_interrupt_receiving_status(void *priv
, uint64_t id
,
1855 struct usb_redir_interrupt_receiving_status_header
1856 *interrupt_receiving_status
)
1858 USBRedirDevice
*dev
= priv
;
1859 uint8_t ep
= interrupt_receiving_status
->endpoint
;
1861 DPRINTF("interrupt recv status %d ep %02X id %"PRIu64
"\n",
1862 interrupt_receiving_status
->status
, ep
, id
);
1864 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].interrupt_started
) {
1868 dev
->endpoint
[EP2I(ep
)].interrupt_error
=
1869 interrupt_receiving_status
->status
;
1870 if (interrupt_receiving_status
->status
== usb_redir_stall
) {
1871 DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep
);
1872 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 0;
1876 static void usbredir_bulk_streams_status(void *priv
, uint64_t id
,
1877 struct usb_redir_bulk_streams_status_header
*bulk_streams_status
)
1879 #if USBREDIR_VERSION >= 0x000700
1880 USBRedirDevice
*dev
= priv
;
1882 if (bulk_streams_status
->status
== usb_redir_success
) {
1883 DPRINTF("bulk streams status %d eps %08x\n",
1884 bulk_streams_status
->status
, bulk_streams_status
->endpoints
);
1886 ERROR("bulk streams %s failed status %d eps %08x\n",
1887 (bulk_streams_status
->no_streams
== 0) ? "free" : "alloc",
1888 bulk_streams_status
->status
, bulk_streams_status
->endpoints
);
1889 ERROR("usb-redir-host does not provide streams, disconnecting\n");
1890 usbredir_reject_device(dev
);
1895 static void usbredir_bulk_receiving_status(void *priv
, uint64_t id
,
1896 struct usb_redir_bulk_receiving_status_header
*bulk_receiving_status
)
1898 USBRedirDevice
*dev
= priv
;
1899 uint8_t ep
= bulk_receiving_status
->endpoint
;
1901 DPRINTF("bulk recv status %d ep %02X id %"PRIu64
"\n",
1902 bulk_receiving_status
->status
, ep
, id
);
1904 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
) {
1908 if (bulk_receiving_status
->status
== usb_redir_stall
) {
1909 DPRINTF("bulk receiving stopped by peer ep %02X\n", ep
);
1910 dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
= 0;
1914 static void usbredir_control_packet(void *priv
, uint64_t id
,
1915 struct usb_redir_control_packet_header
*control_packet
,
1916 uint8_t *data
, int data_len
)
1918 USBRedirDevice
*dev
= priv
;
1920 int len
= control_packet
->length
;
1922 DPRINTF("ctrl-in status %d len %d id %"PRIu64
"\n", control_packet
->status
,
1925 /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices
1926 * to work redirected to a not superspeed capable hcd */
1927 if (dev
->dev
.speed
== USB_SPEED_SUPER
&&
1928 !((dev
->dev
.port
->speedmask
& USB_SPEED_MASK_SUPER
)) &&
1929 control_packet
->requesttype
== 0x80 &&
1930 control_packet
->request
== 6 &&
1931 control_packet
->value
== 0x100 && control_packet
->index
== 0 &&
1932 data_len
>= 18 && data
[7] == 9) {
1936 p
= usbredir_find_packet_by_id(dev
, 0, id
);
1938 usbredir_handle_status(dev
, p
, control_packet
->status
);
1940 usbredir_log_data(dev
, "ctrl data in:", data
, data_len
);
1941 if (data_len
> sizeof(dev
->dev
.data_buf
)) {
1942 ERROR("ctrl buffer too small (%d > %zu)\n",
1943 data_len
, sizeof(dev
->dev
.data_buf
));
1944 p
->status
= USB_RET_STALL
;
1945 data_len
= len
= sizeof(dev
->dev
.data_buf
);
1947 memcpy(dev
->dev
.data_buf
, data
, data_len
);
1949 p
->actual_length
= len
;
1950 usb_generic_async_ctrl_complete(&dev
->dev
, p
);
1955 static void usbredir_bulk_packet(void *priv
, uint64_t id
,
1956 struct usb_redir_bulk_packet_header
*bulk_packet
,
1957 uint8_t *data
, int data_len
)
1959 USBRedirDevice
*dev
= priv
;
1960 uint8_t ep
= bulk_packet
->endpoint
;
1961 int len
= (bulk_packet
->length_high
<< 16) | bulk_packet
->length
;
1964 DPRINTF("bulk-in status %d ep %02X stream %u len %d id %"PRIu64
"\n",
1965 bulk_packet
->status
, ep
, bulk_packet
->stream_id
, len
, id
);
1967 p
= usbredir_find_packet_by_id(dev
, ep
, id
);
1969 size_t size
= usb_packet_size(p
);
1970 usbredir_handle_status(dev
, p
, bulk_packet
->status
);
1972 usbredir_log_data(dev
, "bulk data in:", data
, data_len
);
1973 if (data_len
> size
) {
1974 ERROR("bulk got more data then requested (%d > %zd)\n",
1975 data_len
, p
->iov
.size
);
1976 p
->status
= USB_RET_BABBLE
;
1977 data_len
= len
= size
;
1979 usb_packet_copy(p
, data
, data_len
);
1981 p
->actual_length
= len
;
1982 if (p
->pid
== USB_TOKEN_IN
&& p
->ep
->pipeline
) {
1983 usb_combined_input_packet_complete(&dev
->dev
, p
);
1985 usb_packet_complete(&dev
->dev
, p
);
1991 static void usbredir_iso_packet(void *priv
, uint64_t id
,
1992 struct usb_redir_iso_packet_header
*iso_packet
,
1993 uint8_t *data
, int data_len
)
1995 USBRedirDevice
*dev
= priv
;
1996 uint8_t ep
= iso_packet
->endpoint
;
1998 DPRINTF2("iso-in status %d ep %02X len %d id %"PRIu64
"\n",
1999 iso_packet
->status
, ep
, data_len
, id
);
2001 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_ISOC
) {
2002 ERROR("received iso packet for non iso endpoint %02X\n", ep
);
2007 if (dev
->endpoint
[EP2I(ep
)].iso_started
== 0) {
2008 DPRINTF("received iso packet for non started stream ep %02X\n", ep
);
2013 /* bufp_alloc also adds the packet to the ep queue */
2014 bufp_alloc(dev
, data
, data_len
, iso_packet
->status
, ep
, data
);
2017 static void usbredir_interrupt_packet(void *priv
, uint64_t id
,
2018 struct usb_redir_interrupt_packet_header
*interrupt_packet
,
2019 uint8_t *data
, int data_len
)
2021 USBRedirDevice
*dev
= priv
;
2022 uint8_t ep
= interrupt_packet
->endpoint
;
2024 DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64
"\n",
2025 interrupt_packet
->status
, ep
, data_len
, id
);
2027 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_INT
) {
2028 ERROR("received int packet for non interrupt endpoint %02X\n", ep
);
2033 if (ep
& USB_DIR_IN
) {
2034 if (dev
->endpoint
[EP2I(ep
)].interrupt_started
== 0) {
2035 DPRINTF("received int packet while not started ep %02X\n", ep
);
2040 if (QTAILQ_EMPTY(&dev
->endpoint
[EP2I(ep
)].bufpq
)) {
2041 usb_wakeup(usb_ep_get(&dev
->dev
, USB_TOKEN_IN
, ep
& 0x0f), 0);
2044 /* bufp_alloc also adds the packet to the ep queue */
2045 bufp_alloc(dev
, data
, data_len
, interrupt_packet
->status
, ep
, data
);
2048 * We report output interrupt packets as completed directly upon
2049 * submission, so all we can do here if one failed is warn.
2051 if (interrupt_packet
->status
) {
2052 WARNING("interrupt output failed status %d ep %02X id %"PRIu64
"\n",
2053 interrupt_packet
->status
, ep
, id
);
2058 static void usbredir_buffered_bulk_packet(void *priv
, uint64_t id
,
2059 struct usb_redir_buffered_bulk_packet_header
*buffered_bulk_packet
,
2060 uint8_t *data
, int data_len
)
2062 USBRedirDevice
*dev
= priv
;
2063 uint8_t status
, ep
= buffered_bulk_packet
->endpoint
;
2064 void *free_on_destroy
;
2067 DPRINTF("buffered-bulk-in status %d ep %02X len %d id %"PRIu64
"\n",
2068 buffered_bulk_packet
->status
, ep
, data_len
, id
);
2070 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_BULK
) {
2071 ERROR("received buffered-bulk packet for non bulk ep %02X\n", ep
);
2076 if (dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
== 0) {
2077 DPRINTF("received buffered-bulk packet on not started ep %02X\n", ep
);
2082 /* Data must be in maxp chunks for buffered_bulk_add_*_data_to_packet */
2083 len
= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
2084 status
= usb_redir_success
;
2085 free_on_destroy
= NULL
;
2086 for (i
= 0; i
< data_len
; i
+= len
) {
2088 if (len
>= (data_len
- i
)) {
2090 status
= buffered_bulk_packet
->status
;
2091 free_on_destroy
= data
;
2093 /* bufp_alloc also adds the packet to the ep queue */
2094 r
= bufp_alloc(dev
, data
+ i
, len
, status
, ep
, free_on_destroy
);
2100 if (dev
->endpoint
[EP2I(ep
)].pending_async_packet
) {
2101 USBPacket
*p
= dev
->endpoint
[EP2I(ep
)].pending_async_packet
;
2102 dev
->endpoint
[EP2I(ep
)].pending_async_packet
= NULL
;
2103 usbredir_buffered_bulk_in_complete(dev
, p
, ep
);
2104 usb_packet_complete(&dev
->dev
, p
);
2112 static void usbredir_pre_save(void *priv
)
2114 USBRedirDevice
*dev
= priv
;
2116 usbredir_fill_already_in_flight(dev
);
2119 static int usbredir_post_load(void *priv
, int version_id
)
2121 USBRedirDevice
*dev
= priv
;
2123 if (dev
->parser
== NULL
) {
2127 switch (dev
->device_info
.speed
) {
2128 case usb_redir_speed_low
:
2129 dev
->dev
.speed
= USB_SPEED_LOW
;
2131 case usb_redir_speed_full
:
2132 dev
->dev
.speed
= USB_SPEED_FULL
;
2134 case usb_redir_speed_high
:
2135 dev
->dev
.speed
= USB_SPEED_HIGH
;
2137 case usb_redir_speed_super
:
2138 dev
->dev
.speed
= USB_SPEED_SUPER
;
2141 dev
->dev
.speed
= USB_SPEED_FULL
;
2143 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
);
2145 usbredir_setup_usb_eps(dev
);
2146 usbredir_check_bulk_receiving(dev
);
2151 /* For usbredirparser migration */
2152 static void usbredir_put_parser(QEMUFile
*f
, void *priv
, size_t unused
)
2154 USBRedirDevice
*dev
= priv
;
2158 if (dev
->parser
== NULL
) {
2159 qemu_put_be32(f
, 0);
2163 usbredirparser_serialize(dev
->parser
, &data
, &len
);
2164 qemu_oom_check(data
);
2166 qemu_put_be32(f
, len
);
2167 qemu_put_buffer(f
, data
, len
);
2172 static int usbredir_get_parser(QEMUFile
*f
, void *priv
, size_t unused
)
2174 USBRedirDevice
*dev
= priv
;
2178 len
= qemu_get_be32(f
);
2184 * If our chardev is not open already at this point the usbredir connection
2185 * has been broken (non seamless migration, or restore from disk).
2187 * In this case create a temporary parser to receive the migration data,
2188 * and schedule the close_bh to report the device as disconnected to the
2189 * guest and to destroy the parser again.
2191 if (dev
->parser
== NULL
) {
2192 WARNING("usb-redir connection broken during migration\n");
2193 usbredir_create_parser(dev
);
2194 qemu_bh_schedule(dev
->chardev_close_bh
);
2197 data
= g_malloc(len
);
2198 qemu_get_buffer(f
, data
, len
);
2200 ret
= usbredirparser_unserialize(dev
->parser
, data
, len
);
2207 static const VMStateInfo usbredir_parser_vmstate_info
= {
2208 .name
= "usb-redir-parser",
2209 .put
= usbredir_put_parser
,
2210 .get
= usbredir_get_parser
,
2214 /* For buffered packets (iso/irq) queue migration */
2215 static void usbredir_put_bufpq(QEMUFile
*f
, void *priv
, size_t unused
)
2217 struct endp_data
*endp
= priv
;
2218 USBRedirDevice
*dev
= endp
->dev
;
2219 struct buf_packet
*bufp
;
2222 qemu_put_be32(f
, endp
->bufpq_size
);
2223 QTAILQ_FOREACH(bufp
, &endp
->bufpq
, next
) {
2224 len
= bufp
->len
- bufp
->offset
;
2225 DPRINTF("put_bufpq %d/%d len %d status %d\n", i
+ 1, endp
->bufpq_size
,
2227 qemu_put_be32(f
, len
);
2228 qemu_put_be32(f
, bufp
->status
);
2229 qemu_put_buffer(f
, bufp
->data
+ bufp
->offset
, len
);
2232 assert(i
== endp
->bufpq_size
);
2235 static int usbredir_get_bufpq(QEMUFile
*f
, void *priv
, size_t unused
)
2237 struct endp_data
*endp
= priv
;
2238 USBRedirDevice
*dev
= endp
->dev
;
2239 struct buf_packet
*bufp
;
2242 endp
->bufpq_size
= qemu_get_be32(f
);
2243 for (i
= 0; i
< endp
->bufpq_size
; i
++) {
2244 bufp
= g_new(struct buf_packet
, 1);
2245 bufp
->len
= qemu_get_be32(f
);
2246 bufp
->status
= qemu_get_be32(f
);
2248 bufp
->data
= qemu_oom_check(malloc(bufp
->len
)); /* regular malloc! */
2249 bufp
->free_on_destroy
= bufp
->data
;
2250 qemu_get_buffer(f
, bufp
->data
, bufp
->len
);
2251 QTAILQ_INSERT_TAIL(&endp
->bufpq
, bufp
, next
);
2252 DPRINTF("get_bufpq %d/%d len %d status %d\n", i
+ 1, endp
->bufpq_size
,
2253 bufp
->len
, bufp
->status
);
2258 static const VMStateInfo usbredir_ep_bufpq_vmstate_info
= {
2259 .name
= "usb-redir-bufpq",
2260 .put
= usbredir_put_bufpq
,
2261 .get
= usbredir_get_bufpq
,
2265 /* For endp_data migration */
2266 static bool usbredir_bulk_receiving_needed(void *priv
)
2268 struct endp_data
*endp
= priv
;
2270 return endp
->bulk_receiving_started
;
2273 static const VMStateDescription usbredir_bulk_receiving_vmstate
= {
2274 .name
= "usb-redir-ep/bulk-receiving",
2276 .minimum_version_id
= 1,
2277 .needed
= usbredir_bulk_receiving_needed
,
2278 .fields
= (VMStateField
[]) {
2279 VMSTATE_UINT8(bulk_receiving_started
, struct endp_data
),
2280 VMSTATE_END_OF_LIST()
2284 static bool usbredir_stream_needed(void *priv
)
2286 struct endp_data
*endp
= priv
;
2288 return endp
->max_streams
;
2291 static const VMStateDescription usbredir_stream_vmstate
= {
2292 .name
= "usb-redir-ep/stream-state",
2294 .minimum_version_id
= 1,
2295 .needed
= usbredir_stream_needed
,
2296 .fields
= (VMStateField
[]) {
2297 VMSTATE_UINT32(max_streams
, struct endp_data
),
2298 VMSTATE_END_OF_LIST()
2302 static const VMStateDescription usbredir_ep_vmstate
= {
2303 .name
= "usb-redir-ep",
2305 .minimum_version_id
= 1,
2306 .fields
= (VMStateField
[]) {
2307 VMSTATE_UINT8(type
, struct endp_data
),
2308 VMSTATE_UINT8(interval
, struct endp_data
),
2309 VMSTATE_UINT8(interface
, struct endp_data
),
2310 VMSTATE_UINT16(max_packet_size
, struct endp_data
),
2311 VMSTATE_UINT8(iso_started
, struct endp_data
),
2312 VMSTATE_UINT8(iso_error
, struct endp_data
),
2313 VMSTATE_UINT8(interrupt_started
, struct endp_data
),
2314 VMSTATE_UINT8(interrupt_error
, struct endp_data
),
2315 VMSTATE_UINT8(bufpq_prefilled
, struct endp_data
),
2316 VMSTATE_UINT8(bufpq_dropping_packets
, struct endp_data
),
2320 .field_exists
= NULL
,
2322 .info
= &usbredir_ep_bufpq_vmstate_info
,
2323 .flags
= VMS_SINGLE
,
2326 VMSTATE_INT32(bufpq_target_size
, struct endp_data
),
2327 VMSTATE_END_OF_LIST()
2329 .subsections
= (const VMStateDescription
*[]) {
2330 &usbredir_bulk_receiving_vmstate
,
2331 &usbredir_stream_vmstate
,
2337 /* For PacketIdQueue migration */
2338 static void usbredir_put_packet_id_q(QEMUFile
*f
, void *priv
, size_t unused
)
2340 struct PacketIdQueue
*q
= priv
;
2341 USBRedirDevice
*dev
= q
->dev
;
2342 struct PacketIdQueueEntry
*e
;
2343 int remain
= q
->size
;
2345 DPRINTF("put_packet_id_q %s size %d\n", q
->name
, q
->size
);
2346 qemu_put_be32(f
, q
->size
);
2347 QTAILQ_FOREACH(e
, &q
->head
, next
) {
2348 qemu_put_be64(f
, e
->id
);
2351 assert(remain
== 0);
2354 static int usbredir_get_packet_id_q(QEMUFile
*f
, void *priv
, size_t unused
)
2356 struct PacketIdQueue
*q
= priv
;
2357 USBRedirDevice
*dev
= q
->dev
;
2361 size
= qemu_get_be32(f
);
2362 DPRINTF("get_packet_id_q %s size %d\n", q
->name
, size
);
2363 for (i
= 0; i
< size
; i
++) {
2364 id
= qemu_get_be64(f
);
2365 packet_id_queue_add(q
, id
);
2367 assert(q
->size
== size
);
2371 static const VMStateInfo usbredir_ep_packet_id_q_vmstate_info
= {
2372 .name
= "usb-redir-packet-id-q",
2373 .put
= usbredir_put_packet_id_q
,
2374 .get
= usbredir_get_packet_id_q
,
2377 static const VMStateDescription usbredir_ep_packet_id_queue_vmstate
= {
2378 .name
= "usb-redir-packet-id-queue",
2380 .minimum_version_id
= 1,
2381 .fields
= (VMStateField
[]) {
2385 .field_exists
= NULL
,
2387 .info
= &usbredir_ep_packet_id_q_vmstate_info
,
2388 .flags
= VMS_SINGLE
,
2391 VMSTATE_END_OF_LIST()
2396 /* For usb_redir_device_connect_header migration */
2397 static const VMStateDescription usbredir_device_info_vmstate
= {
2398 .name
= "usb-redir-device-info",
2400 .minimum_version_id
= 1,
2401 .fields
= (VMStateField
[]) {
2402 VMSTATE_UINT8(speed
, struct usb_redir_device_connect_header
),
2403 VMSTATE_UINT8(device_class
, struct usb_redir_device_connect_header
),
2404 VMSTATE_UINT8(device_subclass
, struct usb_redir_device_connect_header
),
2405 VMSTATE_UINT8(device_protocol
, struct usb_redir_device_connect_header
),
2406 VMSTATE_UINT16(vendor_id
, struct usb_redir_device_connect_header
),
2407 VMSTATE_UINT16(product_id
, struct usb_redir_device_connect_header
),
2408 VMSTATE_UINT16(device_version_bcd
,
2409 struct usb_redir_device_connect_header
),
2410 VMSTATE_END_OF_LIST()
2415 /* For usb_redir_interface_info_header migration */
2416 static const VMStateDescription usbredir_interface_info_vmstate
= {
2417 .name
= "usb-redir-interface-info",
2419 .minimum_version_id
= 1,
2420 .fields
= (VMStateField
[]) {
2421 VMSTATE_UINT32(interface_count
,
2422 struct usb_redir_interface_info_header
),
2423 VMSTATE_UINT8_ARRAY(interface
,
2424 struct usb_redir_interface_info_header
, 32),
2425 VMSTATE_UINT8_ARRAY(interface_class
,
2426 struct usb_redir_interface_info_header
, 32),
2427 VMSTATE_UINT8_ARRAY(interface_subclass
,
2428 struct usb_redir_interface_info_header
, 32),
2429 VMSTATE_UINT8_ARRAY(interface_protocol
,
2430 struct usb_redir_interface_info_header
, 32),
2431 VMSTATE_END_OF_LIST()
2436 /* And finally the USBRedirDevice vmstate itself */
2437 static const VMStateDescription usbredir_vmstate
= {
2438 .name
= "usb-redir",
2440 .minimum_version_id
= 1,
2441 .pre_save
= usbredir_pre_save
,
2442 .post_load
= usbredir_post_load
,
2443 .fields
= (VMStateField
[]) {
2444 VMSTATE_USB_DEVICE(dev
, USBRedirDevice
),
2445 VMSTATE_TIMER_PTR(attach_timer
, USBRedirDevice
),
2449 .field_exists
= NULL
,
2451 .info
= &usbredir_parser_vmstate_info
,
2452 .flags
= VMS_SINGLE
,
2455 VMSTATE_STRUCT_ARRAY(endpoint
, USBRedirDevice
, MAX_ENDPOINTS
, 1,
2456 usbredir_ep_vmstate
, struct endp_data
),
2457 VMSTATE_STRUCT(cancelled
, USBRedirDevice
, 1,
2458 usbredir_ep_packet_id_queue_vmstate
,
2459 struct PacketIdQueue
),
2460 VMSTATE_STRUCT(already_in_flight
, USBRedirDevice
, 1,
2461 usbredir_ep_packet_id_queue_vmstate
,
2462 struct PacketIdQueue
),
2463 VMSTATE_STRUCT(device_info
, USBRedirDevice
, 1,
2464 usbredir_device_info_vmstate
,
2465 struct usb_redir_device_connect_header
),
2466 VMSTATE_STRUCT(interface_info
, USBRedirDevice
, 1,
2467 usbredir_interface_info_vmstate
,
2468 struct usb_redir_interface_info_header
),
2469 VMSTATE_END_OF_LIST()
2473 static Property usbredir_properties
[] = {
2474 DEFINE_PROP_CHR("chardev", USBRedirDevice
, cs
),
2475 DEFINE_PROP_UINT8("debug", USBRedirDevice
, debug
, usbredirparser_warning
),
2476 DEFINE_PROP_STRING("filter", USBRedirDevice
, filter_str
),
2477 DEFINE_PROP_END_OF_LIST(),
2480 static void usbredir_class_initfn(ObjectClass
*klass
, void *data
)
2482 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
2483 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2485 uc
->realize
= usbredir_realize
;
2486 uc
->product_desc
= "USB Redirection Device";
2487 uc
->handle_destroy
= usbredir_handle_destroy
;
2488 uc
->cancel_packet
= usbredir_cancel_packet
;
2489 uc
->handle_reset
= usbredir_handle_reset
;
2490 uc
->handle_data
= usbredir_handle_data
;
2491 uc
->handle_control
= usbredir_handle_control
;
2492 uc
->flush_ep_queue
= usbredir_flush_ep_queue
;
2493 uc
->ep_stopped
= usbredir_ep_stopped
;
2494 uc
->alloc_streams
= usbredir_alloc_streams
;
2495 uc
->free_streams
= usbredir_free_streams
;
2496 dc
->vmsd
= &usbredir_vmstate
;
2497 dc
->props
= usbredir_properties
;
2498 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
2501 static void usbredir_instance_init(Object
*obj
)
2503 USBDevice
*udev
= USB_DEVICE(obj
);
2504 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
2506 device_add_bootindex_property(obj
, &dev
->bootindex
,
2511 static const TypeInfo usbredir_dev_info
= {
2512 .name
= TYPE_USB_REDIR
,
2513 .parent
= TYPE_USB_DEVICE
,
2514 .instance_size
= sizeof(USBRedirDevice
),
2515 .class_init
= usbredir_class_initfn
,
2516 .instance_init
= usbredir_instance_init
,
2519 static void usbredir_register_types(void)
2521 type_register_static(&usbredir_dev_info
);
2524 type_init(usbredir_register_types
)