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 "qemu/cutils.h"
30 #include "qemu/units.h"
31 #include "qapi/error.h"
32 #include "qemu/timer.h"
33 #include "sysemu/runstate.h"
34 #include "sysemu/sysemu.h"
35 #include "qapi/qmp/qerror.h"
36 #include "qemu/error-report.h"
38 #include "qemu/module.h"
39 #include "chardev/char-fe.h"
41 #include <usbredirparser.h>
42 #include <usbredirfilter.h>
44 #include "hw/qdev-properties.h"
45 #include "hw/qdev-properties-system.h"
47 #include "migration/qemu-file-types.h"
48 #include "migration/vmstate.h"
49 #include "qom/object.h"
51 /* ERROR is defined below. Remove any previous definition. */
54 #define MAX_ENDPOINTS 32
55 #define NO_INTERFACE_INFO 255 /* Valid interface_count always <= 32 */
56 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))
57 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))
58 #define USBEP2I(usb_ep) (((usb_ep)->pid == USB_TOKEN_IN) ? \
59 ((usb_ep)->nr | 0x10) : ((usb_ep)->nr))
60 #define I2USBEP(d, i) (usb_ep_get(&(d)->dev, \
61 ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \
64 #ifndef USBREDIR_VERSION /* This is not defined in older usbredir versions */
65 #define USBREDIR_VERSION 0
68 typedef struct USBRedirDevice USBRedirDevice
;
70 /* Struct to hold buffered packets */
73 void *free_on_destroy
;
77 QTAILQ_ENTRY(buf_packet
)next
;
84 uint8_t interface
; /* bInterfaceNumber this ep belongs to */
85 uint16_t max_packet_size
; /* In bytes, not wMaxPacketSize format !! */
88 uint8_t iso_error
; /* For reporting iso errors to the HC */
89 uint8_t interrupt_started
;
90 uint8_t interrupt_error
;
91 uint8_t bulk_receiving_enabled
;
92 uint8_t bulk_receiving_started
;
93 uint8_t bufpq_prefilled
;
94 uint8_t bufpq_dropping_packets
;
95 QTAILQ_HEAD(, buf_packet
) bufpq
;
97 int32_t bufpq_target_size
;
98 USBPacket
*pending_async_packet
;
101 struct PacketIdQueueEntry
{
103 QTAILQ_ENTRY(PacketIdQueueEntry
)next
;
106 struct PacketIdQueue
{
109 QTAILQ_HEAD(, PacketIdQueueEntry
) head
;
113 struct USBRedirDevice
{
118 bool suppress_remote_wake
;
123 /* Data passed from chardev the fd_read cb to the usbredirparser read cb */
124 const uint8_t *read_buf
;
126 /* Active chardev-watch-tag */
128 /* For async handling of close / reject */
129 QEMUBH
*chardev_close_bh
;
130 QEMUBH
*device_reject_bh
;
131 /* To delay the usb attach in case of quick chardev close + open */
132 QEMUTimer
*attach_timer
;
133 int64_t next_attach_time
;
134 struct usbredirparser
*parser
;
135 struct endp_data endpoint
[MAX_ENDPOINTS
];
136 struct PacketIdQueue cancelled
;
137 struct PacketIdQueue already_in_flight
;
138 void (*buffered_bulk_in_complete
)(USBRedirDevice
*, USBPacket
*, uint8_t);
139 /* Data for device filtering */
140 struct usb_redir_device_connect_header device_info
;
141 struct usb_redir_interface_info_header interface_info
;
142 struct usbredirfilter_rule
*filter_rules
;
143 int filter_rules_count
;
144 int compatible_speedmask
;
145 VMChangeStateEntry
*vmstate
;
148 #define TYPE_USB_REDIR "usb-redir"
149 DECLARE_INSTANCE_CHECKER(USBRedirDevice
, USB_REDIRECT
,
152 static void usbredir_hello(void *priv
, struct usb_redir_hello_header
*h
);
153 static void usbredir_device_connect(void *priv
,
154 struct usb_redir_device_connect_header
*device_connect
);
155 static void usbredir_device_disconnect(void *priv
);
156 static void usbredir_interface_info(void *priv
,
157 struct usb_redir_interface_info_header
*interface_info
);
158 static void usbredir_ep_info(void *priv
,
159 struct usb_redir_ep_info_header
*ep_info
);
160 static void usbredir_configuration_status(void *priv
, uint64_t id
,
161 struct usb_redir_configuration_status_header
*configuration_status
);
162 static void usbredir_alt_setting_status(void *priv
, uint64_t id
,
163 struct usb_redir_alt_setting_status_header
*alt_setting_status
);
164 static void usbredir_iso_stream_status(void *priv
, uint64_t id
,
165 struct usb_redir_iso_stream_status_header
*iso_stream_status
);
166 static void usbredir_interrupt_receiving_status(void *priv
, uint64_t id
,
167 struct usb_redir_interrupt_receiving_status_header
168 *interrupt_receiving_status
);
169 static void usbredir_bulk_streams_status(void *priv
, uint64_t id
,
170 struct usb_redir_bulk_streams_status_header
*bulk_streams_status
);
171 static void usbredir_bulk_receiving_status(void *priv
, uint64_t id
,
172 struct usb_redir_bulk_receiving_status_header
*bulk_receiving_status
);
173 static void usbredir_control_packet(void *priv
, uint64_t id
,
174 struct usb_redir_control_packet_header
*control_packet
,
175 uint8_t *data
, int data_len
);
176 static void usbredir_bulk_packet(void *priv
, uint64_t id
,
177 struct usb_redir_bulk_packet_header
*bulk_packet
,
178 uint8_t *data
, int data_len
);
179 static void usbredir_iso_packet(void *priv
, uint64_t id
,
180 struct usb_redir_iso_packet_header
*iso_packet
,
181 uint8_t *data
, int data_len
);
182 static void usbredir_interrupt_packet(void *priv
, uint64_t id
,
183 struct usb_redir_interrupt_packet_header
*interrupt_header
,
184 uint8_t *data
, int data_len
);
185 static void usbredir_buffered_bulk_packet(void *priv
, uint64_t id
,
186 struct usb_redir_buffered_bulk_packet_header
*buffered_bulk_packet
,
187 uint8_t *data
, int data_len
);
189 static void usbredir_handle_status(USBRedirDevice
*dev
, USBPacket
*p
,
192 #define VERSION "qemu usb-redir guest " QEMU_VERSION
200 if (dev->debug >= usbredirparser_error) { \
201 error_report("usb-redir error: " __VA_ARGS__); \
204 #define WARNING(...) \
206 if (dev->debug >= usbredirparser_warning) { \
207 warn_report("" __VA_ARGS__); \
212 if (dev->debug >= usbredirparser_info) { \
213 error_report("usb-redir: " __VA_ARGS__); \
216 #define DPRINTF(...) \
218 if (dev->debug >= usbredirparser_debug) { \
219 error_report("usb-redir: " __VA_ARGS__); \
222 #define DPRINTF2(...) \
224 if (dev->debug >= usbredirparser_debug_data) { \
225 error_report("usb-redir: " __VA_ARGS__); \
229 static void usbredir_log(void *priv
, int level
, const char *msg
)
231 USBRedirDevice
*dev
= priv
;
233 if (dev
->debug
< level
) {
237 error_report("%s", msg
);
240 static void usbredir_log_data(USBRedirDevice
*dev
, const char *desc
,
241 const uint8_t *data
, int len
)
243 if (dev
->debug
< usbredirparser_debug_data
) {
246 qemu_hexdump(stderr
, desc
, data
, len
);
250 * usbredirparser io functions
253 static int usbredir_read(void *priv
, uint8_t *data
, int count
)
255 USBRedirDevice
*dev
= priv
;
257 if (dev
->read_buf_size
< count
) {
258 count
= dev
->read_buf_size
;
261 memcpy(data
, dev
->read_buf
, count
);
263 dev
->read_buf_size
-= count
;
264 if (dev
->read_buf_size
) {
265 dev
->read_buf
+= count
;
267 dev
->read_buf
= NULL
;
273 static gboolean
usbredir_write_unblocked(void *do_not_use
, GIOCondition cond
,
276 USBRedirDevice
*dev
= opaque
;
279 usbredirparser_do_write(dev
->parser
);
284 static int usbredir_write(void *priv
, uint8_t *data
, int count
)
286 USBRedirDevice
*dev
= priv
;
289 if (!qemu_chr_fe_backend_open(&dev
->cs
)) {
293 /* Don't send new data to the chardev until our state is fully synced */
294 if (!runstate_check(RUN_STATE_RUNNING
)) {
298 /* Recursion check */
300 DPRINTF("usbredir_write recursion\n");
303 dev
->in_write
= true;
305 r
= qemu_chr_fe_write(&dev
->cs
, data
, count
);
308 dev
->watch
= qemu_chr_fe_add_watch(&dev
->cs
, G_IO_OUT
| G_IO_HUP
,
309 usbredir_write_unblocked
, dev
);
315 dev
->in_write
= false;
320 * Cancelled and buffered packets helpers
323 static void packet_id_queue_init(struct PacketIdQueue
*q
,
324 USBRedirDevice
*dev
, const char *name
)
328 QTAILQ_INIT(&q
->head
);
332 static void packet_id_queue_add(struct PacketIdQueue
*q
, uint64_t id
)
334 USBRedirDevice
*dev
= q
->dev
;
335 struct PacketIdQueueEntry
*e
;
337 DPRINTF("adding packet id %"PRIu64
" to %s queue\n", id
, q
->name
);
339 e
= g_new0(struct PacketIdQueueEntry
, 1);
341 QTAILQ_INSERT_TAIL(&q
->head
, e
, next
);
345 static int packet_id_queue_remove(struct PacketIdQueue
*q
, uint64_t id
)
347 USBRedirDevice
*dev
= q
->dev
;
348 struct PacketIdQueueEntry
*e
;
350 QTAILQ_FOREACH(e
, &q
->head
, next
) {
352 DPRINTF("removing packet id %"PRIu64
" from %s queue\n",
354 QTAILQ_REMOVE(&q
->head
, e
, next
);
363 static void packet_id_queue_empty(struct PacketIdQueue
*q
)
365 USBRedirDevice
*dev
= q
->dev
;
366 struct PacketIdQueueEntry
*e
, *next_e
;
368 DPRINTF("removing %d packet-ids from %s queue\n", q
->size
, q
->name
);
370 QTAILQ_FOREACH_SAFE(e
, &q
->head
, next
, next_e
) {
371 QTAILQ_REMOVE(&q
->head
, e
, next
);
377 static void usbredir_cancel_packet(USBDevice
*udev
, USBPacket
*p
)
379 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
380 int i
= USBEP2I(p
->ep
);
383 usb_combined_packet_cancel(udev
, p
);
387 if (dev
->endpoint
[i
].pending_async_packet
) {
388 assert(dev
->endpoint
[i
].pending_async_packet
== p
);
389 dev
->endpoint
[i
].pending_async_packet
= NULL
;
393 packet_id_queue_add(&dev
->cancelled
, p
->id
);
394 usbredirparser_send_cancel_data_packet(dev
->parser
, p
->id
);
395 usbredirparser_do_write(dev
->parser
);
398 static int usbredir_is_cancelled(USBRedirDevice
*dev
, uint64_t id
)
400 if (!dev
->dev
.attached
) {
401 return 1; /* Treat everything as cancelled after a disconnect */
403 return packet_id_queue_remove(&dev
->cancelled
, id
);
406 static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice
*dev
,
407 struct USBEndpoint
*ep
)
411 /* async handled packets for bulk receiving eps do not count as inflight */
412 if (dev
->endpoint
[USBEP2I(ep
)].bulk_receiving_started
) {
416 QTAILQ_FOREACH(p
, &ep
->queue
, queue
) {
417 /* Skip combined packets, except for the first */
418 if (p
->combined
&& p
!= p
->combined
->first
) {
421 if (p
->state
== USB_PACKET_ASYNC
) {
422 packet_id_queue_add(&dev
->already_in_flight
, p
->id
);
427 static void usbredir_fill_already_in_flight(USBRedirDevice
*dev
)
430 struct USBDevice
*udev
= &dev
->dev
;
432 usbredir_fill_already_in_flight_from_ep(dev
, &udev
->ep_ctl
);
434 for (ep
= 0; ep
< USB_MAX_ENDPOINTS
; ep
++) {
435 usbredir_fill_already_in_flight_from_ep(dev
, &udev
->ep_in
[ep
]);
436 usbredir_fill_already_in_flight_from_ep(dev
, &udev
->ep_out
[ep
]);
440 static int usbredir_already_in_flight(USBRedirDevice
*dev
, uint64_t id
)
442 return packet_id_queue_remove(&dev
->already_in_flight
, id
);
445 static USBPacket
*usbredir_find_packet_by_id(USBRedirDevice
*dev
,
446 uint8_t ep
, uint64_t id
)
450 if (usbredir_is_cancelled(dev
, id
)) {
454 p
= usb_ep_find_packet_by_id(&dev
->dev
,
455 (ep
& USB_DIR_IN
) ? USB_TOKEN_IN
: USB_TOKEN_OUT
,
458 ERROR("could not find packet with id %"PRIu64
"\n", id
);
463 static int bufp_alloc(USBRedirDevice
*dev
, uint8_t *data
, uint16_t len
,
464 uint8_t status
, uint8_t ep
, void *free_on_destroy
)
466 struct buf_packet
*bufp
;
468 if (!dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
&&
469 dev
->endpoint
[EP2I(ep
)].bufpq_size
>
470 2 * dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
471 DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep
);
472 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 1;
474 /* Since we're interupting the stream anyways, drop enough packets to get
475 back to our target buffer size */
476 if (dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
) {
477 if (dev
->endpoint
[EP2I(ep
)].bufpq_size
>
478 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
479 free(free_on_destroy
);
482 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
485 bufp
= g_new(struct buf_packet
, 1);
489 bufp
->status
= status
;
490 bufp
->free_on_destroy
= free_on_destroy
;
491 QTAILQ_INSERT_TAIL(&dev
->endpoint
[EP2I(ep
)].bufpq
, bufp
, next
);
492 dev
->endpoint
[EP2I(ep
)].bufpq_size
++;
496 static void bufp_free(USBRedirDevice
*dev
, struct buf_packet
*bufp
,
499 QTAILQ_REMOVE(&dev
->endpoint
[EP2I(ep
)].bufpq
, bufp
, next
);
500 dev
->endpoint
[EP2I(ep
)].bufpq_size
--;
501 free(bufp
->free_on_destroy
);
505 static void usbredir_free_bufpq(USBRedirDevice
*dev
, uint8_t ep
)
507 struct buf_packet
*buf
, *buf_next
;
509 QTAILQ_FOREACH_SAFE(buf
, &dev
->endpoint
[EP2I(ep
)].bufpq
, next
, buf_next
) {
510 bufp_free(dev
, buf
, ep
);
515 * USBDevice callbacks
518 static void usbredir_handle_reset(USBDevice
*udev
)
520 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
522 DPRINTF("reset device\n");
523 usbredirparser_send_reset(dev
->parser
);
524 usbredirparser_do_write(dev
->parser
);
527 static void usbredir_handle_iso_data(USBRedirDevice
*dev
, USBPacket
*p
,
531 if (!dev
->endpoint
[EP2I(ep
)].iso_started
&&
532 !dev
->endpoint
[EP2I(ep
)].iso_error
) {
533 struct usb_redir_start_iso_stream_header start_iso
= {
538 if (dev
->dev
.speed
== USB_SPEED_HIGH
) {
539 pkts_per_sec
= 8000 / dev
->endpoint
[EP2I(ep
)].interval
;
541 pkts_per_sec
= 1000 / dev
->endpoint
[EP2I(ep
)].interval
;
543 /* Testing has shown that we need circa 60 ms buffer */
544 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= (pkts_per_sec
* 60) / 1000;
546 /* Aim for approx 100 interrupts / second on the client to
547 balance latency and interrupt load */
548 start_iso
.pkts_per_urb
= pkts_per_sec
/ 100;
549 if (start_iso
.pkts_per_urb
< 1) {
550 start_iso
.pkts_per_urb
= 1;
551 } else if (start_iso
.pkts_per_urb
> 32) {
552 start_iso
.pkts_per_urb
= 32;
555 start_iso
.no_urbs
= DIV_ROUND_UP(
556 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
,
557 start_iso
.pkts_per_urb
);
558 /* Output endpoints pre-fill only 1/2 of the packets, keeping the rest
559 as overflow buffer. Also see the usbredir protocol documentation */
560 if (!(ep
& USB_DIR_IN
)) {
561 start_iso
.no_urbs
*= 2;
563 if (start_iso
.no_urbs
> 16) {
564 start_iso
.no_urbs
= 16;
567 /* No id, we look at the ep when receiving a status back */
568 usbredirparser_send_start_iso_stream(dev
->parser
, 0, &start_iso
);
569 usbredirparser_do_write(dev
->parser
);
570 DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n",
571 pkts_per_sec
, start_iso
.pkts_per_urb
, start_iso
.no_urbs
, ep
);
572 dev
->endpoint
[EP2I(ep
)].iso_started
= 1;
573 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 0;
574 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
577 if (ep
& USB_DIR_IN
) {
578 struct buf_packet
*isop
;
580 if (dev
->endpoint
[EP2I(ep
)].iso_started
&&
581 !dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
) {
582 if (dev
->endpoint
[EP2I(ep
)].bufpq_size
<
583 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
586 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 1;
589 isop
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
);
591 DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n",
592 ep
, dev
->endpoint
[EP2I(ep
)].iso_error
);
593 /* Re-fill the buffer */
594 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 0;
595 /* Check iso_error for stream errors, otherwise its an underrun */
596 status
= dev
->endpoint
[EP2I(ep
)].iso_error
;
597 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
598 p
->status
= status
? USB_RET_IOERROR
: USB_RET_SUCCESS
;
601 DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep
,
602 isop
->status
, isop
->len
, dev
->endpoint
[EP2I(ep
)].bufpq_size
);
604 status
= isop
->status
;
606 if (len
> p
->iov
.size
) {
607 ERROR("received iso data is larger then packet ep %02X (%d > %d)\n",
608 ep
, len
, (int)p
->iov
.size
);
610 status
= usb_redir_babble
;
612 usb_packet_copy(p
, isop
->data
, len
);
613 bufp_free(dev
, isop
, ep
);
614 usbredir_handle_status(dev
, p
, status
);
616 /* If the stream was not started because of a pending error don't
617 send the packet to the usb-host */
618 if (dev
->endpoint
[EP2I(ep
)].iso_started
) {
619 struct usb_redir_iso_packet_header iso_packet
= {
621 .length
= p
->iov
.size
623 g_autofree
uint8_t *buf
= g_malloc(p
->iov
.size
);
624 /* No id, we look at the ep when receiving a status back */
625 usb_packet_copy(p
, buf
, p
->iov
.size
);
626 usbredirparser_send_iso_packet(dev
->parser
, 0, &iso_packet
,
628 usbredirparser_do_write(dev
->parser
);
630 status
= dev
->endpoint
[EP2I(ep
)].iso_error
;
631 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
632 DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep
, status
,
634 usbredir_handle_status(dev
, p
, status
);
638 static void usbredir_stop_iso_stream(USBRedirDevice
*dev
, uint8_t ep
)
640 struct usb_redir_stop_iso_stream_header stop_iso_stream
= {
643 if (dev
->endpoint
[EP2I(ep
)].iso_started
) {
644 usbredirparser_send_stop_iso_stream(dev
->parser
, 0, &stop_iso_stream
);
645 DPRINTF("iso stream stopped ep %02X\n", ep
);
646 dev
->endpoint
[EP2I(ep
)].iso_started
= 0;
648 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
649 usbredir_free_bufpq(dev
, ep
);
653 * The usb-host may poll the endpoint faster then our guest, resulting in lots
654 * of smaller bulkp-s. The below buffered_bulk_in_complete* functions combine
655 * data from multiple bulkp-s into a single packet, avoiding bufpq overflows.
657 static void usbredir_buffered_bulk_add_data_to_packet(USBRedirDevice
*dev
,
658 struct buf_packet
*bulkp
, int count
, USBPacket
*p
, uint8_t ep
)
660 usb_packet_copy(p
, bulkp
->data
+ bulkp
->offset
, count
);
661 bulkp
->offset
+= count
;
662 if (bulkp
->offset
== bulkp
->len
) {
663 /* Store status in the last packet with data from this bulkp */
664 usbredir_handle_status(dev
, p
, bulkp
->status
);
665 bufp_free(dev
, bulkp
, ep
);
669 static void usbredir_buffered_bulk_in_complete_raw(USBRedirDevice
*dev
,
670 USBPacket
*p
, uint8_t ep
)
672 struct buf_packet
*bulkp
;
675 while ((bulkp
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
)) &&
676 p
->actual_length
< p
->iov
.size
&& p
->status
== USB_RET_SUCCESS
) {
677 count
= bulkp
->len
- bulkp
->offset
;
678 if (count
> (p
->iov
.size
- p
->actual_length
)) {
679 count
= p
->iov
.size
- p
->actual_length
;
681 usbredir_buffered_bulk_add_data_to_packet(dev
, bulkp
, count
, p
, ep
);
685 static void usbredir_buffered_bulk_in_complete_ftdi(USBRedirDevice
*dev
,
686 USBPacket
*p
, uint8_t ep
)
688 const int maxp
= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
689 uint8_t header
[2] = { 0, 0 };
690 struct buf_packet
*bulkp
;
693 while ((bulkp
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
)) &&
694 p
->actual_length
< p
->iov
.size
&& p
->status
== USB_RET_SUCCESS
) {
695 if (bulkp
->len
< 2) {
696 WARNING("malformed ftdi bulk in packet\n");
697 bufp_free(dev
, bulkp
, ep
);
701 if ((p
->actual_length
% maxp
) == 0) {
702 usb_packet_copy(p
, bulkp
->data
, 2);
703 memcpy(header
, bulkp
->data
, 2);
705 if (bulkp
->data
[0] != header
[0] || bulkp
->data
[1] != header
[1]) {
706 break; /* Different header, add to next packet */
710 if (bulkp
->offset
== 0) {
711 bulkp
->offset
= 2; /* Skip header */
713 count
= bulkp
->len
- bulkp
->offset
;
714 /* Must repeat the header at maxp interval */
715 if (count
> (maxp
- (p
->actual_length
% maxp
))) {
716 count
= maxp
- (p
->actual_length
% maxp
);
718 usbredir_buffered_bulk_add_data_to_packet(dev
, bulkp
, count
, p
, ep
);
722 static void usbredir_buffered_bulk_in_complete(USBRedirDevice
*dev
,
723 USBPacket
*p
, uint8_t ep
)
725 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
726 dev
->buffered_bulk_in_complete(dev
, p
, ep
);
727 DPRINTF("bulk-token-in ep %02X status %d len %d id %"PRIu64
"\n",
728 ep
, p
->status
, p
->actual_length
, p
->id
);
731 static void usbredir_handle_buffered_bulk_in_data(USBRedirDevice
*dev
,
732 USBPacket
*p
, uint8_t ep
)
734 /* Input bulk endpoint, buffered packet input */
735 if (!dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
) {
737 struct usb_redir_start_bulk_receiving_header start
= {
742 /* Round bytes_per_transfer up to a multiple of max_packet_size */
743 bpt
= 512 + dev
->endpoint
[EP2I(ep
)].max_packet_size
- 1;
744 bpt
/= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
745 bpt
*= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
746 start
.bytes_per_transfer
= bpt
;
747 /* No id, we look at the ep when receiving a status back */
748 usbredirparser_send_start_bulk_receiving(dev
->parser
, 0, &start
);
749 usbredirparser_do_write(dev
->parser
);
750 DPRINTF("bulk receiving started bytes/transfer %u count %d ep %02X\n",
751 start
.bytes_per_transfer
, start
.no_transfers
, ep
);
752 dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
= 1;
753 /* We don't really want to drop bulk packets ever, but
754 having some upper limit to how much we buffer is good. */
755 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= 5000;
756 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
759 if (QTAILQ_EMPTY(&dev
->endpoint
[EP2I(ep
)].bufpq
)) {
760 DPRINTF("bulk-token-in ep %02X, no bulkp\n", ep
);
761 assert(dev
->endpoint
[EP2I(ep
)].pending_async_packet
== NULL
);
762 dev
->endpoint
[EP2I(ep
)].pending_async_packet
= p
;
763 p
->status
= USB_RET_ASYNC
;
766 usbredir_buffered_bulk_in_complete(dev
, p
, ep
);
769 static void usbredir_stop_bulk_receiving(USBRedirDevice
*dev
, uint8_t ep
)
771 struct usb_redir_stop_bulk_receiving_header stop_bulk
= {
775 if (dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
) {
776 usbredirparser_send_stop_bulk_receiving(dev
->parser
, 0, &stop_bulk
);
777 DPRINTF("bulk receiving stopped ep %02X\n", ep
);
778 dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
= 0;
780 usbredir_free_bufpq(dev
, ep
);
783 static void usbredir_handle_bulk_data(USBRedirDevice
*dev
, USBPacket
*p
,
786 struct usb_redir_bulk_packet_header bulk_packet
;
787 size_t size
= usb_packet_size(p
);
788 const int maxp
= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
790 if (usbredir_already_in_flight(dev
, p
->id
)) {
791 p
->status
= USB_RET_ASYNC
;
795 if (dev
->endpoint
[EP2I(ep
)].bulk_receiving_enabled
) {
796 if (size
!= 0 && (size
% maxp
) == 0) {
797 usbredir_handle_buffered_bulk_in_data(dev
, p
, ep
);
800 WARNING("bulk recv invalid size %zd ep %02x, disabling\n", size
, ep
);
801 assert(dev
->endpoint
[EP2I(ep
)].pending_async_packet
== NULL
);
802 usbredir_stop_bulk_receiving(dev
, ep
);
803 dev
->endpoint
[EP2I(ep
)].bulk_receiving_enabled
= 0;
806 DPRINTF("bulk-out ep %02X stream %u len %zd id %"PRIu64
"\n",
807 ep
, p
->stream
, size
, p
->id
);
809 bulk_packet
.endpoint
= ep
;
810 bulk_packet
.length
= size
;
811 bulk_packet
.stream_id
= p
->stream
;
812 bulk_packet
.length_high
= size
>> 16;
813 assert(bulk_packet
.length_high
== 0 ||
814 usbredirparser_peer_has_cap(dev
->parser
,
815 usb_redir_cap_32bits_bulk_length
));
817 if (ep
& USB_DIR_IN
|| size
== 0) {
818 usbredirparser_send_bulk_packet(dev
->parser
, p
->id
,
819 &bulk_packet
, NULL
, 0);
821 g_autofree
uint8_t *buf
= g_malloc(size
);
822 usb_packet_copy(p
, buf
, size
);
823 usbredir_log_data(dev
, "bulk data out:", buf
, size
);
824 usbredirparser_send_bulk_packet(dev
->parser
, p
->id
,
825 &bulk_packet
, buf
, size
);
827 usbredirparser_do_write(dev
->parser
);
828 p
->status
= USB_RET_ASYNC
;
831 static void usbredir_handle_interrupt_in_data(USBRedirDevice
*dev
,
832 USBPacket
*p
, uint8_t ep
)
834 /* Input interrupt endpoint, buffered packet input */
835 struct buf_packet
*intp
, *intp_to_free
;
836 int status
, len
, sum
;
838 if (!dev
->endpoint
[EP2I(ep
)].interrupt_started
&&
839 !dev
->endpoint
[EP2I(ep
)].interrupt_error
) {
840 struct usb_redir_start_interrupt_receiving_header start_int
= {
843 /* No id, we look at the ep when receiving a status back */
844 usbredirparser_send_start_interrupt_receiving(dev
->parser
, 0,
846 usbredirparser_do_write(dev
->parser
);
847 DPRINTF("interrupt recv started ep %02X\n", ep
);
848 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 1;
849 /* We don't really want to drop interrupt packets ever, but
850 having some upper limit to how much we buffer is good. */
851 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= 1000;
852 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
855 /* check for completed interrupt message (with all fragments) */
857 QTAILQ_FOREACH(intp
, &dev
->endpoint
[EP2I(ep
)].bufpq
, next
) {
859 if (intp
->len
< dev
->endpoint
[EP2I(ep
)].max_packet_size
||
865 DPRINTF2("interrupt-token-in ep %02X, no intp, buffered %d\n", ep
, sum
);
866 /* Check interrupt_error for stream errors */
867 status
= dev
->endpoint
[EP2I(ep
)].interrupt_error
;
868 dev
->endpoint
[EP2I(ep
)].interrupt_error
= 0;
870 usbredir_handle_status(dev
, p
, status
);
872 p
->status
= USB_RET_NAK
;
877 /* copy of completed interrupt message */
879 status
= usb_redir_success
;
881 QTAILQ_FOREACH(intp
, &dev
->endpoint
[EP2I(ep
)].bufpq
, next
) {
883 bufp_free(dev
, intp_to_free
, ep
);
885 DPRINTF("interrupt-token-in ep %02X fragment status %d len %d\n", ep
,
886 intp
->status
, intp
->len
);
890 if (status
== usb_redir_success
) {
891 status
= intp
->status
;
893 if (sum
> p
->iov
.size
) {
894 ERROR("received int data is larger then packet ep %02X\n", ep
);
895 len
-= (sum
- p
->iov
.size
);
897 status
= usb_redir_babble
;
900 usb_packet_copy(p
, intp
->data
, len
);
903 if (intp
->len
< dev
->endpoint
[EP2I(ep
)].max_packet_size
||
908 bufp_free(dev
, intp_to_free
, ep
);
910 DPRINTF("interrupt-token-in ep %02X summary status %d len %d\n", ep
,
912 usbredir_handle_status(dev
, p
, status
);
916 * Handle interrupt out data, the usbredir protocol expects us to do this
917 * async, so that it can report back a completion status. But guests will
918 * expect immediate completion for an interrupt endpoint, and handling this
919 * async causes migration issues. So we report success directly, counting
920 * on the fact that output interrupt packets normally always succeed.
922 static void usbredir_handle_interrupt_out_data(USBRedirDevice
*dev
,
923 USBPacket
*p
, uint8_t ep
)
925 struct usb_redir_interrupt_packet_header interrupt_packet
;
926 g_autofree
uint8_t *buf
= g_malloc(p
->iov
.size
);
928 DPRINTF("interrupt-out ep %02X len %zd id %"PRIu64
"\n", ep
,
931 interrupt_packet
.endpoint
= ep
;
932 interrupt_packet
.length
= p
->iov
.size
;
934 usb_packet_copy(p
, buf
, p
->iov
.size
);
935 usbredir_log_data(dev
, "interrupt data out:", buf
, p
->iov
.size
);
936 usbredirparser_send_interrupt_packet(dev
->parser
, p
->id
,
937 &interrupt_packet
, buf
, p
->iov
.size
);
938 usbredirparser_do_write(dev
->parser
);
941 static void usbredir_stop_interrupt_receiving(USBRedirDevice
*dev
,
944 struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv
= {
947 if (dev
->endpoint
[EP2I(ep
)].interrupt_started
) {
948 usbredirparser_send_stop_interrupt_receiving(dev
->parser
, 0,
949 &stop_interrupt_recv
);
950 DPRINTF("interrupt recv stopped ep %02X\n", ep
);
951 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 0;
953 dev
->endpoint
[EP2I(ep
)].interrupt_error
= 0;
954 usbredir_free_bufpq(dev
, ep
);
957 static void usbredir_handle_data(USBDevice
*udev
, USBPacket
*p
)
959 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
963 if (p
->pid
== USB_TOKEN_IN
) {
967 switch (dev
->endpoint
[EP2I(ep
)].type
) {
968 case USB_ENDPOINT_XFER_CONTROL
:
969 ERROR("handle_data called for control transfer on ep %02X\n", ep
);
970 p
->status
= USB_RET_NAK
;
972 case USB_ENDPOINT_XFER_BULK
:
973 if (p
->state
== USB_PACKET_SETUP
&& p
->pid
== USB_TOKEN_IN
&&
975 p
->status
= USB_RET_ADD_TO_QUEUE
;
978 usbredir_handle_bulk_data(dev
, p
, ep
);
980 case USB_ENDPOINT_XFER_ISOC
:
981 usbredir_handle_iso_data(dev
, p
, ep
);
983 case USB_ENDPOINT_XFER_INT
:
984 if (ep
& USB_DIR_IN
) {
985 usbredir_handle_interrupt_in_data(dev
, p
, ep
);
987 usbredir_handle_interrupt_out_data(dev
, p
, ep
);
991 ERROR("handle_data ep %02X has unknown type %d\n", ep
,
992 dev
->endpoint
[EP2I(ep
)].type
);
993 p
->status
= USB_RET_NAK
;
997 static void usbredir_flush_ep_queue(USBDevice
*dev
, USBEndpoint
*ep
)
999 if (ep
->pid
== USB_TOKEN_IN
&& ep
->pipeline
) {
1000 usb_ep_combine_input_packets(ep
);
1004 static void usbredir_stop_ep(USBRedirDevice
*dev
, int i
)
1006 uint8_t ep
= I2EP(i
);
1008 switch (dev
->endpoint
[i
].type
) {
1009 case USB_ENDPOINT_XFER_BULK
:
1010 if (ep
& USB_DIR_IN
) {
1011 usbredir_stop_bulk_receiving(dev
, ep
);
1014 case USB_ENDPOINT_XFER_ISOC
:
1015 usbredir_stop_iso_stream(dev
, ep
);
1017 case USB_ENDPOINT_XFER_INT
:
1018 if (ep
& USB_DIR_IN
) {
1019 usbredir_stop_interrupt_receiving(dev
, ep
);
1023 usbredir_free_bufpq(dev
, ep
);
1026 static void usbredir_ep_stopped(USBDevice
*udev
, USBEndpoint
*uep
)
1028 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1030 usbredir_stop_ep(dev
, USBEP2I(uep
));
1031 usbredirparser_do_write(dev
->parser
);
1034 static void usbredir_set_config(USBRedirDevice
*dev
, USBPacket
*p
,
1037 struct usb_redir_set_configuration_header set_config
;
1040 DPRINTF("set config %d id %"PRIu64
"\n", config
, p
->id
);
1042 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1043 usbredir_stop_ep(dev
, i
);
1046 set_config
.configuration
= config
;
1047 usbredirparser_send_set_configuration(dev
->parser
, p
->id
, &set_config
);
1048 usbredirparser_do_write(dev
->parser
);
1049 p
->status
= USB_RET_ASYNC
;
1052 static void usbredir_get_config(USBRedirDevice
*dev
, USBPacket
*p
)
1054 DPRINTF("get config id %"PRIu64
"\n", p
->id
);
1056 usbredirparser_send_get_configuration(dev
->parser
, p
->id
);
1057 usbredirparser_do_write(dev
->parser
);
1058 p
->status
= USB_RET_ASYNC
;
1061 static void usbredir_set_interface(USBRedirDevice
*dev
, USBPacket
*p
,
1062 int interface
, int alt
)
1064 struct usb_redir_set_alt_setting_header set_alt
;
1067 DPRINTF("set interface %d alt %d id %"PRIu64
"\n", interface
, alt
, p
->id
);
1069 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1070 if (dev
->endpoint
[i
].interface
== interface
) {
1071 usbredir_stop_ep(dev
, i
);
1075 set_alt
.interface
= interface
;
1077 usbredirparser_send_set_alt_setting(dev
->parser
, p
->id
, &set_alt
);
1078 usbredirparser_do_write(dev
->parser
);
1079 p
->status
= USB_RET_ASYNC
;
1082 static void usbredir_get_interface(USBRedirDevice
*dev
, USBPacket
*p
,
1085 struct usb_redir_get_alt_setting_header get_alt
;
1087 DPRINTF("get interface %d id %"PRIu64
"\n", interface
, p
->id
);
1089 get_alt
.interface
= interface
;
1090 usbredirparser_send_get_alt_setting(dev
->parser
, p
->id
, &get_alt
);
1091 usbredirparser_do_write(dev
->parser
);
1092 p
->status
= USB_RET_ASYNC
;
1095 static void usbredir_handle_control(USBDevice
*udev
, USBPacket
*p
,
1096 int request
, int value
, int index
, int length
, uint8_t *data
)
1098 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1099 struct usb_redir_control_packet_header control_packet
;
1101 if (usbredir_already_in_flight(dev
, p
->id
)) {
1102 p
->status
= USB_RET_ASYNC
;
1106 /* Special cases for certain standard device requests */
1108 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
1109 DPRINTF("set address %d\n", value
);
1110 dev
->dev
.addr
= value
;
1112 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
1113 usbredir_set_config(dev
, p
, value
& 0xff);
1115 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
1116 usbredir_get_config(dev
, p
);
1118 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
1119 usbredir_set_interface(dev
, p
, index
, value
);
1121 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
1122 usbredir_get_interface(dev
, p
, index
);
1126 /* Normal ctrl requests, note request is (bRequestType << 8) | bRequest */
1128 "ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %"PRIu64
"\n",
1129 request
>> 8, request
& 0xff, value
, index
, length
, p
->id
);
1131 control_packet
.request
= request
& 0xFF;
1132 control_packet
.requesttype
= request
>> 8;
1133 control_packet
.endpoint
= control_packet
.requesttype
& USB_DIR_IN
;
1134 control_packet
.value
= value
;
1135 control_packet
.index
= index
;
1136 control_packet
.length
= length
;
1138 if (control_packet
.requesttype
& USB_DIR_IN
) {
1139 usbredirparser_send_control_packet(dev
->parser
, p
->id
,
1140 &control_packet
, NULL
, 0);
1142 usbredir_log_data(dev
, "ctrl data out:", data
, length
);
1143 usbredirparser_send_control_packet(dev
->parser
, p
->id
,
1144 &control_packet
, data
, length
);
1146 usbredirparser_do_write(dev
->parser
);
1147 p
->status
= USB_RET_ASYNC
;
1150 static int usbredir_alloc_streams(USBDevice
*udev
, USBEndpoint
**eps
,
1151 int nr_eps
, int streams
)
1153 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1154 #if USBREDIR_VERSION >= 0x000700
1155 struct usb_redir_alloc_bulk_streams_header alloc_streams
;
1158 if (!usbredirparser_peer_has_cap(dev
->parser
,
1159 usb_redir_cap_bulk_streams
)) {
1160 ERROR("peer does not support streams\n");
1165 ERROR("request to allocate 0 streams\n");
1169 alloc_streams
.no_streams
= streams
;
1170 alloc_streams
.endpoints
= 0;
1171 for (i
= 0; i
< nr_eps
; i
++) {
1172 alloc_streams
.endpoints
|= 1 << USBEP2I(eps
[i
]);
1174 usbredirparser_send_alloc_bulk_streams(dev
->parser
, 0, &alloc_streams
);
1175 usbredirparser_do_write(dev
->parser
);
1179 ERROR("usbredir_alloc_streams not implemented\n");
1183 ERROR("streams are not available, disconnecting\n");
1184 qemu_bh_schedule(dev
->device_reject_bh
);
1188 static void usbredir_free_streams(USBDevice
*udev
, USBEndpoint
**eps
,
1191 #if USBREDIR_VERSION >= 0x000700
1192 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1193 struct usb_redir_free_bulk_streams_header free_streams
;
1196 if (!usbredirparser_peer_has_cap(dev
->parser
,
1197 usb_redir_cap_bulk_streams
)) {
1201 free_streams
.endpoints
= 0;
1202 for (i
= 0; i
< nr_eps
; i
++) {
1203 free_streams
.endpoints
|= 1 << USBEP2I(eps
[i
]);
1205 usbredirparser_send_free_bulk_streams(dev
->parser
, 0, &free_streams
);
1206 usbredirparser_do_write(dev
->parser
);
1211 * Close events can be triggered by usbredirparser_do_write which gets called
1212 * from within the USBDevice data / control packet callbacks and doing a
1213 * usb_detach from within these callbacks is not a good idea.
1215 * So we use a bh handler to take care of close events.
1217 static void usbredir_chardev_close_bh(void *opaque
)
1219 USBRedirDevice
*dev
= opaque
;
1221 qemu_bh_cancel(dev
->device_reject_bh
);
1222 usbredir_device_disconnect(dev
);
1225 DPRINTF("destroying usbredirparser\n");
1226 usbredirparser_destroy(dev
->parser
);
1230 g_source_remove(dev
->watch
);
1235 static void usbredir_create_parser(USBRedirDevice
*dev
)
1237 uint32_t caps
[USB_REDIR_CAPS_SIZE
] = { 0, };
1240 DPRINTF("creating usbredirparser\n");
1242 dev
->parser
= usbredirparser_create();
1244 error_report("usbredirparser_create() failed");
1247 dev
->parser
->priv
= dev
;
1248 dev
->parser
->log_func
= usbredir_log
;
1249 dev
->parser
->read_func
= usbredir_read
;
1250 dev
->parser
->write_func
= usbredir_write
;
1251 dev
->parser
->hello_func
= usbredir_hello
;
1252 dev
->parser
->device_connect_func
= usbredir_device_connect
;
1253 dev
->parser
->device_disconnect_func
= usbredir_device_disconnect
;
1254 dev
->parser
->interface_info_func
= usbredir_interface_info
;
1255 dev
->parser
->ep_info_func
= usbredir_ep_info
;
1256 dev
->parser
->configuration_status_func
= usbredir_configuration_status
;
1257 dev
->parser
->alt_setting_status_func
= usbredir_alt_setting_status
;
1258 dev
->parser
->iso_stream_status_func
= usbredir_iso_stream_status
;
1259 dev
->parser
->interrupt_receiving_status_func
=
1260 usbredir_interrupt_receiving_status
;
1261 dev
->parser
->bulk_streams_status_func
= usbredir_bulk_streams_status
;
1262 dev
->parser
->bulk_receiving_status_func
= usbredir_bulk_receiving_status
;
1263 dev
->parser
->control_packet_func
= usbredir_control_packet
;
1264 dev
->parser
->bulk_packet_func
= usbredir_bulk_packet
;
1265 dev
->parser
->iso_packet_func
= usbredir_iso_packet
;
1266 dev
->parser
->interrupt_packet_func
= usbredir_interrupt_packet
;
1267 dev
->parser
->buffered_bulk_packet_func
= usbredir_buffered_bulk_packet
;
1268 dev
->read_buf
= NULL
;
1269 dev
->read_buf_size
= 0;
1271 usbredirparser_caps_set_cap(caps
, usb_redir_cap_connect_device_version
);
1272 usbredirparser_caps_set_cap(caps
, usb_redir_cap_filter
);
1273 usbredirparser_caps_set_cap(caps
, usb_redir_cap_ep_info_max_packet_size
);
1274 usbredirparser_caps_set_cap(caps
, usb_redir_cap_64bits_ids
);
1275 usbredirparser_caps_set_cap(caps
, usb_redir_cap_32bits_bulk_length
);
1276 usbredirparser_caps_set_cap(caps
, usb_redir_cap_bulk_receiving
);
1277 #if USBREDIR_VERSION >= 0x000700
1278 if (dev
->enable_streams
) {
1279 usbredirparser_caps_set_cap(caps
, usb_redir_cap_bulk_streams
);
1283 if (runstate_check(RUN_STATE_INMIGRATE
) ||
1284 runstate_check(RUN_STATE_PRELAUNCH
)) {
1285 flags
|= usbredirparser_fl_no_hello
;
1287 usbredirparser_init(dev
->parser
, VERSION
, caps
, USB_REDIR_CAPS_SIZE
,
1289 usbredirparser_do_write(dev
->parser
);
1292 static void usbredir_reject_device(USBRedirDevice
*dev
)
1294 usbredir_device_disconnect(dev
);
1295 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
)) {
1296 usbredirparser_send_filter_reject(dev
->parser
);
1297 usbredirparser_do_write(dev
->parser
);
1302 * We may need to reject the device when the hcd calls alloc_streams, doing
1303 * an usb_detach from within a hcd call is not a good idea, hence this bh.
1305 static void usbredir_device_reject_bh(void *opaque
)
1307 USBRedirDevice
*dev
= opaque
;
1309 usbredir_reject_device(dev
);
1312 static void usbredir_do_attach(void *opaque
)
1314 USBRedirDevice
*dev
= opaque
;
1315 Error
*local_err
= NULL
;
1317 /* In order to work properly with XHCI controllers we need these caps */
1318 if ((dev
->dev
.port
->speedmask
& USB_SPEED_MASK_SUPER
) && !(
1319 usbredirparser_peer_has_cap(dev
->parser
,
1320 usb_redir_cap_ep_info_max_packet_size
) &&
1321 usbredirparser_peer_has_cap(dev
->parser
,
1322 usb_redir_cap_32bits_bulk_length
) &&
1323 usbredirparser_peer_has_cap(dev
->parser
,
1324 usb_redir_cap_64bits_ids
))) {
1325 ERROR("usb-redir-host lacks capabilities needed for use with XHCI\n");
1326 usbredir_reject_device(dev
);
1330 usb_device_attach(&dev
->dev
, &local_err
);
1332 error_report_err(local_err
);
1333 WARNING("rejecting device due to speed mismatch\n");
1334 usbredir_reject_device(dev
);
1342 static int usbredir_chardev_can_read(void *opaque
)
1344 USBRedirDevice
*dev
= opaque
;
1347 WARNING("chardev_can_read called on non open chardev!\n");
1351 /* Don't read new data from the chardev until our state is fully synced */
1352 if (!runstate_check(RUN_STATE_RUNNING
)) {
1356 /* usbredir_parser_do_read will consume *all* data we give it */
1360 static void usbredir_chardev_read(void *opaque
, const uint8_t *buf
, int size
)
1362 USBRedirDevice
*dev
= opaque
;
1364 /* No recursion allowed! */
1365 assert(dev
->read_buf
== NULL
);
1367 dev
->read_buf
= buf
;
1368 dev
->read_buf_size
= size
;
1370 usbredirparser_do_read(dev
->parser
);
1371 /* Send any acks, etc. which may be queued now */
1372 usbredirparser_do_write(dev
->parser
);
1375 static void usbredir_chardev_event(void *opaque
, QEMUChrEvent event
)
1377 USBRedirDevice
*dev
= opaque
;
1380 case CHR_EVENT_OPENED
:
1381 DPRINTF("chardev open\n");
1382 /* Make sure any pending closes are handled (no-op if none pending) */
1383 usbredir_chardev_close_bh(dev
);
1384 qemu_bh_cancel(dev
->chardev_close_bh
);
1385 usbredir_create_parser(dev
);
1387 case CHR_EVENT_CLOSED
:
1388 DPRINTF("chardev close\n");
1389 qemu_bh_schedule(dev
->chardev_close_bh
);
1391 case CHR_EVENT_BREAK
:
1392 case CHR_EVENT_MUX_IN
:
1393 case CHR_EVENT_MUX_OUT
:
1403 static void usbredir_vm_state_change(void *priv
, bool running
, RunState state
)
1405 USBRedirDevice
*dev
= priv
;
1407 if (state
== RUN_STATE_RUNNING
&& dev
->parser
!= NULL
) {
1408 usbredirparser_do_write(dev
->parser
); /* Flush any pending writes */
1412 static void usbredir_init_endpoints(USBRedirDevice
*dev
)
1416 usb_ep_init(&dev
->dev
);
1417 memset(dev
->endpoint
, 0, sizeof(dev
->endpoint
));
1418 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1419 dev
->endpoint
[i
].dev
= dev
;
1420 QTAILQ_INIT(&dev
->endpoint
[i
].bufpq
);
1424 static void usbredir_realize(USBDevice
*udev
, Error
**errp
)
1426 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1429 if (!qemu_chr_fe_backend_connected(&dev
->cs
)) {
1430 error_setg(errp
, QERR_MISSING_PARAMETER
, "chardev");
1434 if (dev
->filter_str
) {
1435 i
= usbredirfilter_string_to_rules(dev
->filter_str
, ":", "|",
1437 &dev
->filter_rules_count
);
1439 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "filter",
1440 "a usb device filter string");
1445 dev
->chardev_close_bh
= qemu_bh_new(usbredir_chardev_close_bh
, dev
);
1446 dev
->device_reject_bh
= qemu_bh_new(usbredir_device_reject_bh
, dev
);
1447 dev
->attach_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
, usbredir_do_attach
, dev
);
1449 packet_id_queue_init(&dev
->cancelled
, dev
, "cancelled");
1450 packet_id_queue_init(&dev
->already_in_flight
, dev
, "already-in-flight");
1451 usbredir_init_endpoints(dev
);
1453 /* We'll do the attach once we receive the speed from the usb-host */
1454 udev
->auto_attach
= 0;
1456 /* Will be cleared during setup when we find conflicts */
1457 dev
->compatible_speedmask
= USB_SPEED_MASK_FULL
| USB_SPEED_MASK_HIGH
;
1459 /* Let the backend know we are ready */
1460 qemu_chr_fe_set_handlers(&dev
->cs
, usbredir_chardev_can_read
,
1461 usbredir_chardev_read
, usbredir_chardev_event
,
1462 NULL
, dev
, NULL
, true);
1465 qemu_add_vm_change_state_handler(usbredir_vm_state_change
, dev
);
1468 static void usbredir_cleanup_device_queues(USBRedirDevice
*dev
)
1472 packet_id_queue_empty(&dev
->cancelled
);
1473 packet_id_queue_empty(&dev
->already_in_flight
);
1474 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1475 usbredir_free_bufpq(dev
, I2EP(i
));
1479 static void usbredir_unrealize(USBDevice
*udev
)
1481 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
1483 qemu_chr_fe_deinit(&dev
->cs
, true);
1485 /* Note must be done after qemu_chr_close, as that causes a close event */
1486 qemu_bh_delete(dev
->chardev_close_bh
);
1487 qemu_bh_delete(dev
->device_reject_bh
);
1489 timer_free(dev
->attach_timer
);
1491 usbredir_cleanup_device_queues(dev
);
1494 usbredirparser_destroy(dev
->parser
);
1497 g_source_remove(dev
->watch
);
1500 free(dev
->filter_rules
);
1501 qemu_del_vm_change_state_handler(dev
->vmstate
);
1504 static int usbredir_check_filter(USBRedirDevice
*dev
)
1506 if (dev
->interface_info
.interface_count
== NO_INTERFACE_INFO
) {
1507 ERROR("No interface info for device\n");
1511 if (dev
->filter_rules
) {
1512 if (!usbredirparser_peer_has_cap(dev
->parser
,
1513 usb_redir_cap_connect_device_version
)) {
1514 ERROR("Device filter specified and peer does not have the "
1515 "connect_device_version capability\n");
1519 if (usbredirfilter_check(
1521 dev
->filter_rules_count
,
1522 dev
->device_info
.device_class
,
1523 dev
->device_info
.device_subclass
,
1524 dev
->device_info
.device_protocol
,
1525 dev
->interface_info
.interface_class
,
1526 dev
->interface_info
.interface_subclass
,
1527 dev
->interface_info
.interface_protocol
,
1528 dev
->interface_info
.interface_count
,
1529 dev
->device_info
.vendor_id
,
1530 dev
->device_info
.product_id
,
1531 dev
->device_info
.device_version_bcd
,
1540 usbredir_reject_device(dev
);
1544 static void usbredir_check_bulk_receiving(USBRedirDevice
*dev
)
1548 if (!usbredirparser_peer_has_cap(dev
->parser
,
1549 usb_redir_cap_bulk_receiving
)) {
1553 for (i
= EP2I(USB_DIR_IN
); i
< MAX_ENDPOINTS
; i
++) {
1554 dev
->endpoint
[i
].bulk_receiving_enabled
= 0;
1557 if (dev
->interface_info
.interface_count
== NO_INTERFACE_INFO
) {
1561 for (i
= 0; i
< dev
->interface_info
.interface_count
; i
++) {
1562 quirks
= usb_get_quirks(dev
->device_info
.vendor_id
,
1563 dev
->device_info
.product_id
,
1564 dev
->interface_info
.interface_class
[i
],
1565 dev
->interface_info
.interface_subclass
[i
],
1566 dev
->interface_info
.interface_protocol
[i
]);
1567 if (!(quirks
& USB_QUIRK_BUFFER_BULK_IN
)) {
1570 if (quirks
& USB_QUIRK_IS_FTDI
) {
1571 dev
->buffered_bulk_in_complete
=
1572 usbredir_buffered_bulk_in_complete_ftdi
;
1574 dev
->buffered_bulk_in_complete
=
1575 usbredir_buffered_bulk_in_complete_raw
;
1578 for (j
= EP2I(USB_DIR_IN
); j
< MAX_ENDPOINTS
; j
++) {
1579 if (dev
->endpoint
[j
].interface
==
1580 dev
->interface_info
.interface
[i
] &&
1581 dev
->endpoint
[j
].type
== USB_ENDPOINT_XFER_BULK
&&
1582 dev
->endpoint
[j
].max_packet_size
!= 0) {
1583 dev
->endpoint
[j
].bulk_receiving_enabled
= 1;
1585 * With buffering pipelining is not necessary. Also packet
1586 * combining and bulk in buffering don't play nice together!
1588 I2USBEP(dev
, j
)->pipeline
= false;
1589 break; /* Only buffer for the first ep of each intf */
1596 * usbredirparser packet complete callbacks
1599 static void usbredir_handle_status(USBRedirDevice
*dev
, USBPacket
*p
,
1603 case usb_redir_success
:
1604 p
->status
= USB_RET_SUCCESS
; /* Clear previous ASYNC status */
1606 case usb_redir_stall
:
1607 p
->status
= USB_RET_STALL
;
1609 case usb_redir_cancelled
:
1611 * When the usbredir-host unredirects a device, it will report a status
1612 * of cancelled for all pending packets, followed by a disconnect msg.
1614 p
->status
= USB_RET_IOERROR
;
1616 case usb_redir_inval
:
1617 WARNING("got invalid param error from usb-host?\n");
1618 p
->status
= USB_RET_IOERROR
;
1620 case usb_redir_babble
:
1621 p
->status
= USB_RET_BABBLE
;
1623 case usb_redir_ioerror
:
1624 case usb_redir_timeout
:
1626 p
->status
= USB_RET_IOERROR
;
1630 static void usbredir_hello(void *priv
, struct usb_redir_hello_header
*h
)
1632 USBRedirDevice
*dev
= priv
;
1634 /* Try to send the filter info now that we've the usb-host's caps */
1635 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
) &&
1636 dev
->filter_rules
) {
1637 usbredirparser_send_filter_filter(dev
->parser
, dev
->filter_rules
,
1638 dev
->filter_rules_count
);
1639 usbredirparser_do_write(dev
->parser
);
1643 static void usbredir_device_connect(void *priv
,
1644 struct usb_redir_device_connect_header
*device_connect
)
1646 USBRedirDevice
*dev
= priv
;
1649 if (timer_pending(dev
->attach_timer
) || dev
->dev
.attached
) {
1650 ERROR("Received device connect while already connected\n");
1654 switch (device_connect
->speed
) {
1655 case usb_redir_speed_low
:
1656 speed
= "low speed";
1657 dev
->dev
.speed
= USB_SPEED_LOW
;
1658 dev
->compatible_speedmask
&= ~USB_SPEED_MASK_FULL
;
1659 dev
->compatible_speedmask
&= ~USB_SPEED_MASK_HIGH
;
1661 case usb_redir_speed_full
:
1662 speed
= "full speed";
1663 dev
->dev
.speed
= USB_SPEED_FULL
;
1664 dev
->compatible_speedmask
&= ~USB_SPEED_MASK_HIGH
;
1666 case usb_redir_speed_high
:
1667 speed
= "high speed";
1668 dev
->dev
.speed
= USB_SPEED_HIGH
;
1670 case usb_redir_speed_super
:
1671 speed
= "super speed";
1672 dev
->dev
.speed
= USB_SPEED_SUPER
;
1675 speed
= "unknown speed";
1676 dev
->dev
.speed
= USB_SPEED_FULL
;
1679 if (usbredirparser_peer_has_cap(dev
->parser
,
1680 usb_redir_cap_connect_device_version
)) {
1681 INFO("attaching %s device %04x:%04x version %d.%d class %02x\n",
1682 speed
, device_connect
->vendor_id
, device_connect
->product_id
,
1683 ((device_connect
->device_version_bcd
& 0xf000) >> 12) * 10 +
1684 ((device_connect
->device_version_bcd
& 0x0f00) >> 8),
1685 ((device_connect
->device_version_bcd
& 0x00f0) >> 4) * 10 +
1686 ((device_connect
->device_version_bcd
& 0x000f) >> 0),
1687 device_connect
->device_class
);
1689 INFO("attaching %s device %04x:%04x class %02x\n", speed
,
1690 device_connect
->vendor_id
, device_connect
->product_id
,
1691 device_connect
->device_class
);
1694 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
) | dev
->compatible_speedmask
;
1695 dev
->device_info
= *device_connect
;
1697 if (usbredir_check_filter(dev
)) {
1698 WARNING("Device %04x:%04x rejected by device filter, not attaching\n",
1699 device_connect
->vendor_id
, device_connect
->product_id
);
1703 usbredir_check_bulk_receiving(dev
);
1704 timer_mod(dev
->attach_timer
, dev
->next_attach_time
);
1707 static void usbredir_device_disconnect(void *priv
)
1709 USBRedirDevice
*dev
= priv
;
1711 /* Stop any pending attaches */
1712 timer_del(dev
->attach_timer
);
1714 if (dev
->dev
.attached
) {
1715 DPRINTF("detaching device\n");
1716 usb_device_detach(&dev
->dev
);
1718 * Delay next usb device attach to give the guest a chance to see
1719 * see the detach / attach in case of quick close / open succession
1721 dev
->next_attach_time
= qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + 200;
1724 /* Reset state so that the next dev connected starts with a clean slate */
1725 usbredir_cleanup_device_queues(dev
);
1726 usbredir_init_endpoints(dev
);
1727 dev
->interface_info
.interface_count
= NO_INTERFACE_INFO
;
1730 dev
->compatible_speedmask
= USB_SPEED_MASK_FULL
| USB_SPEED_MASK_HIGH
;
1733 static void usbredir_interface_info(void *priv
,
1734 struct usb_redir_interface_info_header
*interface_info
)
1736 USBRedirDevice
*dev
= priv
;
1738 dev
->interface_info
= *interface_info
;
1741 * If we receive interface info after the device has already been
1742 * connected (ie on a set_config), re-check interface dependent things.
1744 if (timer_pending(dev
->attach_timer
) || dev
->dev
.attached
) {
1745 usbredir_check_bulk_receiving(dev
);
1746 if (usbredir_check_filter(dev
)) {
1747 ERROR("Device no longer matches filter after interface info "
1748 "change, disconnecting!\n");
1753 static void usbredir_mark_speed_incompatible(USBRedirDevice
*dev
, int speed
)
1755 dev
->compatible_speedmask
&= ~(1 << speed
);
1756 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
) | dev
->compatible_speedmask
;
1759 static void usbredir_set_pipeline(USBRedirDevice
*dev
, struct USBEndpoint
*uep
)
1761 if (uep
->type
!= USB_ENDPOINT_XFER_BULK
) {
1764 if (uep
->pid
== USB_TOKEN_OUT
) {
1765 uep
->pipeline
= true;
1767 if (uep
->pid
== USB_TOKEN_IN
&& uep
->max_packet_size
!= 0 &&
1768 usbredirparser_peer_has_cap(dev
->parser
,
1769 usb_redir_cap_32bits_bulk_length
)) {
1770 uep
->pipeline
= true;
1774 static void usbredir_setup_usb_eps(USBRedirDevice
*dev
)
1776 struct USBEndpoint
*usb_ep
;
1779 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1780 usb_ep
= I2USBEP(dev
, i
);
1781 usb_ep
->type
= dev
->endpoint
[i
].type
;
1782 usb_ep
->ifnum
= dev
->endpoint
[i
].interface
;
1783 usb_ep
->max_packet_size
= dev
->endpoint
[i
].max_packet_size
;
1784 usb_ep
->max_streams
= dev
->endpoint
[i
].max_streams
;
1785 usbredir_set_pipeline(dev
, usb_ep
);
1789 static void usbredir_ep_info(void *priv
,
1790 struct usb_redir_ep_info_header
*ep_info
)
1792 USBRedirDevice
*dev
= priv
;
1795 assert(dev
!= NULL
);
1796 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1797 dev
->endpoint
[i
].type
= ep_info
->type
[i
];
1798 dev
->endpoint
[i
].interval
= ep_info
->interval
[i
];
1799 dev
->endpoint
[i
].interface
= ep_info
->interface
[i
];
1800 if (usbredirparser_peer_has_cap(dev
->parser
,
1801 usb_redir_cap_ep_info_max_packet_size
)) {
1802 dev
->endpoint
[i
].max_packet_size
= ep_info
->max_packet_size
[i
];
1804 #if USBREDIR_VERSION >= 0x000700
1805 if (usbredirparser_peer_has_cap(dev
->parser
,
1806 usb_redir_cap_bulk_streams
)) {
1807 dev
->endpoint
[i
].max_streams
= ep_info
->max_streams
[i
];
1810 switch (dev
->endpoint
[i
].type
) {
1811 case usb_redir_type_invalid
:
1813 case usb_redir_type_iso
:
1814 usbredir_mark_speed_incompatible(dev
, USB_SPEED_FULL
);
1815 usbredir_mark_speed_incompatible(dev
, USB_SPEED_HIGH
);
1817 case usb_redir_type_interrupt
:
1818 if (!usbredirparser_peer_has_cap(dev
->parser
,
1819 usb_redir_cap_ep_info_max_packet_size
) ||
1820 ep_info
->max_packet_size
[i
] > 64) {
1821 usbredir_mark_speed_incompatible(dev
, USB_SPEED_FULL
);
1823 if (!usbredirparser_peer_has_cap(dev
->parser
,
1824 usb_redir_cap_ep_info_max_packet_size
) ||
1825 ep_info
->max_packet_size
[i
] > 1024) {
1826 usbredir_mark_speed_incompatible(dev
, USB_SPEED_HIGH
);
1828 if (dev
->endpoint
[i
].interval
== 0) {
1829 ERROR("Received 0 interval for isoc or irq endpoint\n");
1830 usbredir_reject_device(dev
);
1834 case usb_redir_type_control
:
1835 case usb_redir_type_bulk
:
1836 DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i
),
1837 dev
->endpoint
[i
].type
, dev
->endpoint
[i
].interface
);
1840 ERROR("Received invalid endpoint type\n");
1841 usbredir_reject_device(dev
);
1845 /* The new ep info may have caused a speed incompatibility, recheck */
1846 if (dev
->dev
.attached
&&
1847 !(dev
->dev
.port
->speedmask
& dev
->dev
.speedmask
)) {
1848 ERROR("Device no longer matches speed after endpoint info change, "
1849 "disconnecting!\n");
1850 usbredir_reject_device(dev
);
1853 usbredir_setup_usb_eps(dev
);
1854 usbredir_check_bulk_receiving(dev
);
1857 static void usbredir_configuration_status(void *priv
, uint64_t id
,
1858 struct usb_redir_configuration_status_header
*config_status
)
1860 USBRedirDevice
*dev
= priv
;
1863 DPRINTF("set config status %d config %d id %"PRIu64
"\n",
1864 config_status
->status
, config_status
->configuration
, id
);
1866 p
= usbredir_find_packet_by_id(dev
, 0, id
);
1868 if (dev
->dev
.setup_buf
[0] & USB_DIR_IN
) {
1869 dev
->dev
.data_buf
[0] = config_status
->configuration
;
1870 p
->actual_length
= 1;
1872 usbredir_handle_status(dev
, p
, config_status
->status
);
1873 usb_generic_async_ctrl_complete(&dev
->dev
, p
);
1877 static void usbredir_alt_setting_status(void *priv
, uint64_t id
,
1878 struct usb_redir_alt_setting_status_header
*alt_setting_status
)
1880 USBRedirDevice
*dev
= priv
;
1883 DPRINTF("alt status %d intf %d alt %d id: %"PRIu64
"\n",
1884 alt_setting_status
->status
, alt_setting_status
->interface
,
1885 alt_setting_status
->alt
, id
);
1887 p
= usbredir_find_packet_by_id(dev
, 0, id
);
1889 if (dev
->dev
.setup_buf
[0] & USB_DIR_IN
) {
1890 dev
->dev
.data_buf
[0] = alt_setting_status
->alt
;
1891 p
->actual_length
= 1;
1893 usbredir_handle_status(dev
, p
, alt_setting_status
->status
);
1894 usb_generic_async_ctrl_complete(&dev
->dev
, p
);
1898 static void usbredir_iso_stream_status(void *priv
, uint64_t id
,
1899 struct usb_redir_iso_stream_status_header
*iso_stream_status
)
1901 USBRedirDevice
*dev
= priv
;
1902 uint8_t ep
= iso_stream_status
->endpoint
;
1904 DPRINTF("iso status %d ep %02X id %"PRIu64
"\n", iso_stream_status
->status
,
1907 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].iso_started
) {
1911 dev
->endpoint
[EP2I(ep
)].iso_error
= iso_stream_status
->status
;
1912 if (iso_stream_status
->status
== usb_redir_stall
) {
1913 DPRINTF("iso stream stopped by peer ep %02X\n", ep
);
1914 dev
->endpoint
[EP2I(ep
)].iso_started
= 0;
1918 static void usbredir_interrupt_receiving_status(void *priv
, uint64_t id
,
1919 struct usb_redir_interrupt_receiving_status_header
1920 *interrupt_receiving_status
)
1922 USBRedirDevice
*dev
= priv
;
1923 uint8_t ep
= interrupt_receiving_status
->endpoint
;
1925 DPRINTF("interrupt recv status %d ep %02X id %"PRIu64
"\n",
1926 interrupt_receiving_status
->status
, ep
, id
);
1928 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].interrupt_started
) {
1932 dev
->endpoint
[EP2I(ep
)].interrupt_error
=
1933 interrupt_receiving_status
->status
;
1934 if (interrupt_receiving_status
->status
== usb_redir_stall
) {
1935 DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep
);
1936 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 0;
1940 static void usbredir_bulk_streams_status(void *priv
, uint64_t id
,
1941 struct usb_redir_bulk_streams_status_header
*bulk_streams_status
)
1943 #if USBREDIR_VERSION >= 0x000700
1944 USBRedirDevice
*dev
= priv
;
1946 if (bulk_streams_status
->status
== usb_redir_success
) {
1947 DPRINTF("bulk streams status %d eps %08x\n",
1948 bulk_streams_status
->status
, bulk_streams_status
->endpoints
);
1950 ERROR("bulk streams %s failed status %d eps %08x\n",
1951 (bulk_streams_status
->no_streams
== 0) ? "free" : "alloc",
1952 bulk_streams_status
->status
, bulk_streams_status
->endpoints
);
1953 ERROR("usb-redir-host does not provide streams, disconnecting\n");
1954 usbredir_reject_device(dev
);
1959 static void usbredir_bulk_receiving_status(void *priv
, uint64_t id
,
1960 struct usb_redir_bulk_receiving_status_header
*bulk_receiving_status
)
1962 USBRedirDevice
*dev
= priv
;
1963 uint8_t ep
= bulk_receiving_status
->endpoint
;
1965 DPRINTF("bulk recv status %d ep %02X id %"PRIu64
"\n",
1966 bulk_receiving_status
->status
, ep
, id
);
1968 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
) {
1972 if (bulk_receiving_status
->status
== usb_redir_stall
) {
1973 DPRINTF("bulk receiving stopped by peer ep %02X\n", ep
);
1974 dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
= 0;
1978 static void usbredir_control_packet(void *priv
, uint64_t id
,
1979 struct usb_redir_control_packet_header
*control_packet
,
1980 uint8_t *data
, int data_len
)
1982 USBRedirDevice
*dev
= priv
;
1984 int len
= control_packet
->length
;
1986 DPRINTF("ctrl-in status %d len %d id %"PRIu64
"\n", control_packet
->status
,
1989 /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices
1990 * to work redirected to a not superspeed capable hcd */
1991 if (dev
->dev
.speed
== USB_SPEED_SUPER
&&
1992 !((dev
->dev
.port
->speedmask
& USB_SPEED_MASK_SUPER
)) &&
1993 control_packet
->requesttype
== 0x80 &&
1994 control_packet
->request
== 6 &&
1995 control_packet
->value
== 0x100 && control_packet
->index
== 0 &&
1996 data_len
>= 18 && data
[7] == 9) {
2000 p
= usbredir_find_packet_by_id(dev
, 0, id
);
2002 usbredir_handle_status(dev
, p
, control_packet
->status
);
2004 usbredir_log_data(dev
, "ctrl data in:", data
, data_len
);
2005 if (data_len
> sizeof(dev
->dev
.data_buf
)) {
2006 ERROR("ctrl buffer too small (%d > %zu)\n",
2007 data_len
, sizeof(dev
->dev
.data_buf
));
2008 p
->status
= USB_RET_STALL
;
2009 data_len
= len
= sizeof(dev
->dev
.data_buf
);
2011 memcpy(dev
->dev
.data_buf
, data
, data_len
);
2013 p
->actual_length
= len
;
2015 * If this is GET_DESCRIPTOR request for configuration descriptor,
2016 * remove 'remote wakeup' flag from it to prevent idle power down
2019 if (dev
->suppress_remote_wake
&&
2020 control_packet
->requesttype
== USB_DIR_IN
&&
2021 control_packet
->request
== USB_REQ_GET_DESCRIPTOR
&&
2022 control_packet
->value
== (USB_DT_CONFIG
<< 8) &&
2023 control_packet
->index
== 0 &&
2024 /* bmAttributes field of config descriptor */
2025 len
> 7 && (dev
->dev
.data_buf
[7] & USB_CFG_ATT_WAKEUP
)) {
2026 DPRINTF("Removed remote wake %04X:%04X\n",
2027 dev
->device_info
.vendor_id
,
2028 dev
->device_info
.product_id
);
2029 dev
->dev
.data_buf
[7] &= ~USB_CFG_ATT_WAKEUP
;
2031 usb_generic_async_ctrl_complete(&dev
->dev
, p
);
2036 static void usbredir_bulk_packet(void *priv
, uint64_t id
,
2037 struct usb_redir_bulk_packet_header
*bulk_packet
,
2038 uint8_t *data
, int data_len
)
2040 USBRedirDevice
*dev
= priv
;
2041 uint8_t ep
= bulk_packet
->endpoint
;
2042 int len
= (bulk_packet
->length_high
<< 16) | bulk_packet
->length
;
2045 DPRINTF("bulk-in status %d ep %02X stream %u len %d id %"PRIu64
"\n",
2046 bulk_packet
->status
, ep
, bulk_packet
->stream_id
, len
, id
);
2048 p
= usbredir_find_packet_by_id(dev
, ep
, id
);
2050 size_t size
= usb_packet_size(p
);
2051 usbredir_handle_status(dev
, p
, bulk_packet
->status
);
2053 usbredir_log_data(dev
, "bulk data in:", data
, data_len
);
2054 if (data_len
> size
) {
2055 ERROR("bulk got more data then requested (%d > %zd)\n",
2056 data_len
, p
->iov
.size
);
2057 p
->status
= USB_RET_BABBLE
;
2058 data_len
= len
= size
;
2060 usb_packet_copy(p
, data
, data_len
);
2062 p
->actual_length
= len
;
2063 if (p
->pid
== USB_TOKEN_IN
&& p
->ep
->pipeline
) {
2064 usb_combined_input_packet_complete(&dev
->dev
, p
);
2066 usb_packet_complete(&dev
->dev
, p
);
2072 static void usbredir_iso_packet(void *priv
, uint64_t id
,
2073 struct usb_redir_iso_packet_header
*iso_packet
,
2074 uint8_t *data
, int data_len
)
2076 USBRedirDevice
*dev
= priv
;
2077 uint8_t ep
= iso_packet
->endpoint
;
2079 DPRINTF2("iso-in status %d ep %02X len %d id %"PRIu64
"\n",
2080 iso_packet
->status
, ep
, data_len
, id
);
2082 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_ISOC
) {
2083 ERROR("received iso packet for non iso endpoint %02X\n", ep
);
2088 if (dev
->endpoint
[EP2I(ep
)].iso_started
== 0) {
2089 DPRINTF("received iso packet for non started stream ep %02X\n", ep
);
2094 /* bufp_alloc also adds the packet to the ep queue */
2095 bufp_alloc(dev
, data
, data_len
, iso_packet
->status
, ep
, data
);
2098 static void usbredir_interrupt_packet(void *priv
, uint64_t id
,
2099 struct usb_redir_interrupt_packet_header
*interrupt_packet
,
2100 uint8_t *data
, int data_len
)
2102 USBRedirDevice
*dev
= priv
;
2103 uint8_t ep
= interrupt_packet
->endpoint
;
2105 DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64
"\n",
2106 interrupt_packet
->status
, ep
, data_len
, id
);
2108 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_INT
) {
2109 ERROR("received int packet for non interrupt endpoint %02X\n", ep
);
2114 if (ep
& USB_DIR_IN
) {
2115 if (dev
->endpoint
[EP2I(ep
)].interrupt_started
== 0) {
2116 DPRINTF("received int packet while not started ep %02X\n", ep
);
2121 /* bufp_alloc also adds the packet to the ep queue */
2122 bufp_alloc(dev
, data
, data_len
, interrupt_packet
->status
, ep
, data
);
2124 /* insufficient data solved with USB_RET_NAK */
2125 usb_wakeup(usb_ep_get(&dev
->dev
, USB_TOKEN_IN
, ep
& 0x0f), 0);
2128 * We report output interrupt packets as completed directly upon
2129 * submission, so all we can do here if one failed is warn.
2131 if (interrupt_packet
->status
) {
2132 WARNING("interrupt output failed status %d ep %02X id %"PRIu64
"\n",
2133 interrupt_packet
->status
, ep
, id
);
2138 static void usbredir_buffered_bulk_packet(void *priv
, uint64_t id
,
2139 struct usb_redir_buffered_bulk_packet_header
*buffered_bulk_packet
,
2140 uint8_t *data
, int data_len
)
2142 USBRedirDevice
*dev
= priv
;
2143 uint8_t status
, ep
= buffered_bulk_packet
->endpoint
;
2144 void *free_on_destroy
;
2147 DPRINTF("buffered-bulk-in status %d ep %02X len %d id %"PRIu64
"\n",
2148 buffered_bulk_packet
->status
, ep
, data_len
, id
);
2150 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_BULK
) {
2151 ERROR("received buffered-bulk packet for non bulk ep %02X\n", ep
);
2156 if (dev
->endpoint
[EP2I(ep
)].bulk_receiving_started
== 0) {
2157 DPRINTF("received buffered-bulk packet on not started ep %02X\n", ep
);
2162 /* Data must be in maxp chunks for buffered_bulk_add_*_data_to_packet */
2163 len
= dev
->endpoint
[EP2I(ep
)].max_packet_size
;
2164 status
= usb_redir_success
;
2165 free_on_destroy
= NULL
;
2166 for (i
= 0; i
< data_len
; i
+= len
) {
2168 if (len
>= (data_len
- i
)) {
2170 status
= buffered_bulk_packet
->status
;
2171 free_on_destroy
= data
;
2173 /* bufp_alloc also adds the packet to the ep queue */
2174 r
= bufp_alloc(dev
, data
+ i
, len
, status
, ep
, free_on_destroy
);
2180 if (dev
->endpoint
[EP2I(ep
)].pending_async_packet
) {
2181 USBPacket
*p
= dev
->endpoint
[EP2I(ep
)].pending_async_packet
;
2182 dev
->endpoint
[EP2I(ep
)].pending_async_packet
= NULL
;
2183 usbredir_buffered_bulk_in_complete(dev
, p
, ep
);
2184 usb_packet_complete(&dev
->dev
, p
);
2192 static int usbredir_pre_save(void *priv
)
2194 USBRedirDevice
*dev
= priv
;
2196 usbredir_fill_already_in_flight(dev
);
2201 static int usbredir_post_load(void *priv
, int version_id
)
2203 USBRedirDevice
*dev
= priv
;
2205 if (dev
== NULL
|| dev
->parser
== NULL
) {
2209 switch (dev
->device_info
.speed
) {
2210 case usb_redir_speed_low
:
2211 dev
->dev
.speed
= USB_SPEED_LOW
;
2213 case usb_redir_speed_full
:
2214 dev
->dev
.speed
= USB_SPEED_FULL
;
2216 case usb_redir_speed_high
:
2217 dev
->dev
.speed
= USB_SPEED_HIGH
;
2219 case usb_redir_speed_super
:
2220 dev
->dev
.speed
= USB_SPEED_SUPER
;
2223 dev
->dev
.speed
= USB_SPEED_FULL
;
2225 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
);
2227 usbredir_setup_usb_eps(dev
);
2228 usbredir_check_bulk_receiving(dev
);
2233 /* For usbredirparser migration */
2234 static int usbredir_put_parser(QEMUFile
*f
, void *priv
, size_t unused
,
2235 const VMStateField
*field
, JSONWriter
*vmdesc
)
2237 USBRedirDevice
*dev
= priv
;
2241 if (dev
->parser
== NULL
) {
2242 qemu_put_be32(f
, 0);
2246 usbredirparser_serialize(dev
->parser
, &data
, &len
);
2248 error_report("usbredirparser_serialize failed");
2252 qemu_put_be32(f
, len
);
2253 qemu_put_buffer(f
, data
, len
);
2260 static int usbredir_get_parser(QEMUFile
*f
, void *priv
, size_t unused
,
2261 const VMStateField
*field
)
2263 USBRedirDevice
*dev
= priv
;
2267 len
= qemu_get_be32(f
);
2273 * If our chardev is not open already at this point the usbredir connection
2274 * has been broken (non seamless migration, or restore from disk).
2276 * In this case create a temporary parser to receive the migration data,
2277 * and schedule the close_bh to report the device as disconnected to the
2278 * guest and to destroy the parser again.
2280 if (dev
->parser
== NULL
) {
2281 WARNING("usb-redir connection broken during migration\n");
2282 usbredir_create_parser(dev
);
2283 qemu_bh_schedule(dev
->chardev_close_bh
);
2286 data
= g_malloc(len
);
2287 qemu_get_buffer(f
, data
, len
);
2289 ret
= usbredirparser_unserialize(dev
->parser
, data
, len
);
2296 static const VMStateInfo usbredir_parser_vmstate_info
= {
2297 .name
= "usb-redir-parser",
2298 .put
= usbredir_put_parser
,
2299 .get
= usbredir_get_parser
,
2303 /* For buffered packets (iso/irq) queue migration */
2304 static int usbredir_put_bufpq(QEMUFile
*f
, void *priv
, size_t unused
,
2305 const VMStateField
*field
, JSONWriter
*vmdesc
)
2307 struct endp_data
*endp
= priv
;
2308 USBRedirDevice
*dev
= endp
->dev
;
2309 struct buf_packet
*bufp
;
2312 qemu_put_be32(f
, endp
->bufpq_size
);
2313 QTAILQ_FOREACH(bufp
, &endp
->bufpq
, next
) {
2314 len
= bufp
->len
- bufp
->offset
;
2315 DPRINTF("put_bufpq %d/%d len %d status %d\n", i
+ 1, endp
->bufpq_size
,
2317 qemu_put_be32(f
, len
);
2318 qemu_put_be32(f
, bufp
->status
);
2319 qemu_put_buffer(f
, bufp
->data
+ bufp
->offset
, len
);
2322 assert(i
== endp
->bufpq_size
);
2327 static int usbredir_get_bufpq(QEMUFile
*f
, void *priv
, size_t unused
,
2328 const VMStateField
*field
)
2330 struct endp_data
*endp
= priv
;
2331 USBRedirDevice
*dev
= endp
->dev
;
2332 struct buf_packet
*bufp
;
2335 endp
->bufpq_size
= qemu_get_be32(f
);
2336 for (i
= 0; i
< endp
->bufpq_size
; i
++) {
2337 bufp
= g_new(struct buf_packet
, 1);
2338 bufp
->len
= qemu_get_be32(f
);
2339 bufp
->status
= qemu_get_be32(f
);
2341 bufp
->data
= malloc(bufp
->len
); /* regular malloc! */
2343 error_report("usbredir_get_bufpq: out of memory");
2346 bufp
->free_on_destroy
= bufp
->data
;
2347 qemu_get_buffer(f
, bufp
->data
, bufp
->len
);
2348 QTAILQ_INSERT_TAIL(&endp
->bufpq
, bufp
, next
);
2349 DPRINTF("get_bufpq %d/%d len %d status %d\n", i
+ 1, endp
->bufpq_size
,
2350 bufp
->len
, bufp
->status
);
2355 static const VMStateInfo usbredir_ep_bufpq_vmstate_info
= {
2356 .name
= "usb-redir-bufpq",
2357 .put
= usbredir_put_bufpq
,
2358 .get
= usbredir_get_bufpq
,
2362 /* For endp_data migration */
2363 static bool usbredir_bulk_receiving_needed(void *priv
)
2365 struct endp_data
*endp
= priv
;
2367 return endp
->bulk_receiving_started
;
2370 static const VMStateDescription usbredir_bulk_receiving_vmstate
= {
2371 .name
= "usb-redir-ep/bulk-receiving",
2373 .minimum_version_id
= 1,
2374 .needed
= usbredir_bulk_receiving_needed
,
2375 .fields
= (VMStateField
[]) {
2376 VMSTATE_UINT8(bulk_receiving_started
, struct endp_data
),
2377 VMSTATE_END_OF_LIST()
2381 static bool usbredir_stream_needed(void *priv
)
2383 struct endp_data
*endp
= priv
;
2385 return endp
->max_streams
;
2388 static const VMStateDescription usbredir_stream_vmstate
= {
2389 .name
= "usb-redir-ep/stream-state",
2391 .minimum_version_id
= 1,
2392 .needed
= usbredir_stream_needed
,
2393 .fields
= (VMStateField
[]) {
2394 VMSTATE_UINT32(max_streams
, struct endp_data
),
2395 VMSTATE_END_OF_LIST()
2399 static const VMStateDescription usbredir_ep_vmstate
= {
2400 .name
= "usb-redir-ep",
2402 .minimum_version_id
= 1,
2403 .fields
= (VMStateField
[]) {
2404 VMSTATE_UINT8(type
, struct endp_data
),
2405 VMSTATE_UINT8(interval
, struct endp_data
),
2406 VMSTATE_UINT8(interface
, struct endp_data
),
2407 VMSTATE_UINT16(max_packet_size
, struct endp_data
),
2408 VMSTATE_UINT8(iso_started
, struct endp_data
),
2409 VMSTATE_UINT8(iso_error
, struct endp_data
),
2410 VMSTATE_UINT8(interrupt_started
, struct endp_data
),
2411 VMSTATE_UINT8(interrupt_error
, struct endp_data
),
2412 VMSTATE_UINT8(bufpq_prefilled
, struct endp_data
),
2413 VMSTATE_UINT8(bufpq_dropping_packets
, struct endp_data
),
2417 .field_exists
= NULL
,
2419 .info
= &usbredir_ep_bufpq_vmstate_info
,
2420 .flags
= VMS_SINGLE
,
2423 VMSTATE_INT32(bufpq_target_size
, struct endp_data
),
2424 VMSTATE_END_OF_LIST()
2426 .subsections
= (const VMStateDescription
*[]) {
2427 &usbredir_bulk_receiving_vmstate
,
2428 &usbredir_stream_vmstate
,
2434 /* For PacketIdQueue migration */
2435 static int usbredir_put_packet_id_q(QEMUFile
*f
, void *priv
, size_t unused
,
2436 const VMStateField
*field
,
2439 struct PacketIdQueue
*q
= priv
;
2440 USBRedirDevice
*dev
= q
->dev
;
2441 struct PacketIdQueueEntry
*e
;
2442 int remain
= q
->size
;
2444 DPRINTF("put_packet_id_q %s size %d\n", q
->name
, q
->size
);
2445 qemu_put_be32(f
, q
->size
);
2446 QTAILQ_FOREACH(e
, &q
->head
, next
) {
2447 qemu_put_be64(f
, e
->id
);
2450 assert(remain
== 0);
2455 static int usbredir_get_packet_id_q(QEMUFile
*f
, void *priv
, size_t unused
,
2456 const VMStateField
*field
)
2458 struct PacketIdQueue
*q
= priv
;
2459 USBRedirDevice
*dev
= q
->dev
;
2463 size
= qemu_get_be32(f
);
2464 DPRINTF("get_packet_id_q %s size %d\n", q
->name
, size
);
2465 for (i
= 0; i
< size
; i
++) {
2466 id
= qemu_get_be64(f
);
2467 packet_id_queue_add(q
, id
);
2469 assert(q
->size
== size
);
2473 static const VMStateInfo usbredir_ep_packet_id_q_vmstate_info
= {
2474 .name
= "usb-redir-packet-id-q",
2475 .put
= usbredir_put_packet_id_q
,
2476 .get
= usbredir_get_packet_id_q
,
2479 static const VMStateDescription usbredir_ep_packet_id_queue_vmstate
= {
2480 .name
= "usb-redir-packet-id-queue",
2482 .minimum_version_id
= 1,
2483 .fields
= (VMStateField
[]) {
2487 .field_exists
= NULL
,
2489 .info
= &usbredir_ep_packet_id_q_vmstate_info
,
2490 .flags
= VMS_SINGLE
,
2493 VMSTATE_END_OF_LIST()
2498 /* For usb_redir_device_connect_header migration */
2499 static const VMStateDescription usbredir_device_info_vmstate
= {
2500 .name
= "usb-redir-device-info",
2502 .minimum_version_id
= 1,
2503 .fields
= (VMStateField
[]) {
2504 VMSTATE_UINT8(speed
, struct usb_redir_device_connect_header
),
2505 VMSTATE_UINT8(device_class
, struct usb_redir_device_connect_header
),
2506 VMSTATE_UINT8(device_subclass
, struct usb_redir_device_connect_header
),
2507 VMSTATE_UINT8(device_protocol
, struct usb_redir_device_connect_header
),
2508 VMSTATE_UINT16(vendor_id
, struct usb_redir_device_connect_header
),
2509 VMSTATE_UINT16(product_id
, struct usb_redir_device_connect_header
),
2510 VMSTATE_UINT16(device_version_bcd
,
2511 struct usb_redir_device_connect_header
),
2512 VMSTATE_END_OF_LIST()
2517 /* For usb_redir_interface_info_header migration */
2518 static const VMStateDescription usbredir_interface_info_vmstate
= {
2519 .name
= "usb-redir-interface-info",
2521 .minimum_version_id
= 1,
2522 .fields
= (VMStateField
[]) {
2523 VMSTATE_UINT32(interface_count
,
2524 struct usb_redir_interface_info_header
),
2525 VMSTATE_UINT8_ARRAY(interface
,
2526 struct usb_redir_interface_info_header
, 32),
2527 VMSTATE_UINT8_ARRAY(interface_class
,
2528 struct usb_redir_interface_info_header
, 32),
2529 VMSTATE_UINT8_ARRAY(interface_subclass
,
2530 struct usb_redir_interface_info_header
, 32),
2531 VMSTATE_UINT8_ARRAY(interface_protocol
,
2532 struct usb_redir_interface_info_header
, 32),
2533 VMSTATE_END_OF_LIST()
2538 /* And finally the USBRedirDevice vmstate itself */
2539 static const VMStateDescription usbredir_vmstate
= {
2540 .name
= "usb-redir",
2542 .minimum_version_id
= 1,
2543 .pre_save
= usbredir_pre_save
,
2544 .post_load
= usbredir_post_load
,
2545 .fields
= (VMStateField
[]) {
2546 VMSTATE_USB_DEVICE(dev
, USBRedirDevice
),
2547 VMSTATE_TIMER_PTR(attach_timer
, USBRedirDevice
),
2551 .field_exists
= NULL
,
2553 .info
= &usbredir_parser_vmstate_info
,
2554 .flags
= VMS_SINGLE
,
2557 VMSTATE_STRUCT_ARRAY(endpoint
, USBRedirDevice
, MAX_ENDPOINTS
, 1,
2558 usbredir_ep_vmstate
, struct endp_data
),
2559 VMSTATE_STRUCT(cancelled
, USBRedirDevice
, 1,
2560 usbredir_ep_packet_id_queue_vmstate
,
2561 struct PacketIdQueue
),
2562 VMSTATE_STRUCT(already_in_flight
, USBRedirDevice
, 1,
2563 usbredir_ep_packet_id_queue_vmstate
,
2564 struct PacketIdQueue
),
2565 VMSTATE_STRUCT(device_info
, USBRedirDevice
, 1,
2566 usbredir_device_info_vmstate
,
2567 struct usb_redir_device_connect_header
),
2568 VMSTATE_STRUCT(interface_info
, USBRedirDevice
, 1,
2569 usbredir_interface_info_vmstate
,
2570 struct usb_redir_interface_info_header
),
2571 VMSTATE_END_OF_LIST()
2575 static Property usbredir_properties
[] = {
2576 DEFINE_PROP_CHR("chardev", USBRedirDevice
, cs
),
2577 DEFINE_PROP_UINT8("debug", USBRedirDevice
, debug
, usbredirparser_warning
),
2578 DEFINE_PROP_STRING("filter", USBRedirDevice
, filter_str
),
2579 DEFINE_PROP_BOOL("streams", USBRedirDevice
, enable_streams
, true),
2580 DEFINE_PROP_BOOL("suppress-remote-wake", USBRedirDevice
,
2581 suppress_remote_wake
, true),
2582 DEFINE_PROP_END_OF_LIST(),
2585 static void usbredir_class_initfn(ObjectClass
*klass
, void *data
)
2587 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
2588 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2590 uc
->realize
= usbredir_realize
;
2591 uc
->product_desc
= "USB Redirection Device";
2592 uc
->unrealize
= usbredir_unrealize
;
2593 uc
->cancel_packet
= usbredir_cancel_packet
;
2594 uc
->handle_reset
= usbredir_handle_reset
;
2595 uc
->handle_data
= usbredir_handle_data
;
2596 uc
->handle_control
= usbredir_handle_control
;
2597 uc
->flush_ep_queue
= usbredir_flush_ep_queue
;
2598 uc
->ep_stopped
= usbredir_ep_stopped
;
2599 uc
->alloc_streams
= usbredir_alloc_streams
;
2600 uc
->free_streams
= usbredir_free_streams
;
2601 dc
->vmsd
= &usbredir_vmstate
;
2602 device_class_set_props(dc
, usbredir_properties
);
2603 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
2606 static void usbredir_instance_init(Object
*obj
)
2608 USBDevice
*udev
= USB_DEVICE(obj
);
2609 USBRedirDevice
*dev
= USB_REDIRECT(udev
);
2611 device_add_bootindex_property(obj
, &dev
->bootindex
,
2616 static const TypeInfo usbredir_dev_info
= {
2617 .name
= TYPE_USB_REDIR
,
2618 .parent
= TYPE_USB_DEVICE
,
2619 .instance_size
= sizeof(USBRedirDevice
),
2620 .class_init
= usbredir_class_initfn
,
2621 .instance_init
= usbredir_instance_init
,
2623 module_obj(TYPE_USB_REDIR
);
2624 module_kconfig(USB
);
2626 static void usbredir_register_types(void)
2628 type_register_static(&usbredir_dev_info
);
2631 type_init(usbredir_register_types
)