2 * USB redirector usb-guest
4 * Copyright (c) 2011 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-common.h"
29 #include "qemu-timer.h"
34 #include <sys/ioctl.h>
36 #include <usbredirparser.h>
37 #include <usbredirfilter.h>
41 #define MAX_ENDPOINTS 32
42 #define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))
43 #define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))
45 typedef struct AsyncURB AsyncURB
;
46 typedef struct USBRedirDevice USBRedirDevice
;
48 /* Struct to hold buffered packets (iso or int input packets) */
53 QTAILQ_ENTRY(buf_packet
)next
;
59 uint8_t interface
; /* bInterfaceNumber this ep belongs to */
61 uint8_t iso_error
; /* For reporting iso errors to the HC */
62 uint8_t interrupt_started
;
63 uint8_t interrupt_error
;
64 uint8_t bufpq_prefilled
;
65 uint8_t bufpq_dropping_packets
;
66 QTAILQ_HEAD(, buf_packet
) bufpq
;
68 int bufpq_target_size
;
71 struct USBRedirDevice
{
78 /* Data passed from chardev the fd_read cb to the usbredirparser read cb */
79 const uint8_t *read_buf
;
81 /* For async handling of open/close */
82 QEMUBH
*open_close_bh
;
83 /* To delay the usb attach in case of quick chardev close + open */
84 QEMUTimer
*attach_timer
;
85 int64_t next_attach_time
;
86 struct usbredirparser
*parser
;
87 struct endp_data endpoint
[MAX_ENDPOINTS
];
89 QTAILQ_HEAD(, AsyncURB
) asyncq
;
90 /* Data for device filtering */
91 struct usb_redir_device_connect_header device_info
;
92 struct usb_redir_interface_info_header interface_info
;
93 struct usbredirfilter_rule
*filter_rules
;
94 int filter_rules_count
;
103 struct usb_redir_control_packet_header control_packet
;
104 struct usb_redir_bulk_packet_header bulk_packet
;
105 struct usb_redir_interrupt_packet_header interrupt_packet
;
107 QTAILQ_ENTRY(AsyncURB
)next
;
110 static void usbredir_hello(void *priv
, struct usb_redir_hello_header
*h
);
111 static void usbredir_device_connect(void *priv
,
112 struct usb_redir_device_connect_header
*device_connect
);
113 static void usbredir_device_disconnect(void *priv
);
114 static void usbredir_interface_info(void *priv
,
115 struct usb_redir_interface_info_header
*interface_info
);
116 static void usbredir_ep_info(void *priv
,
117 struct usb_redir_ep_info_header
*ep_info
);
118 static void usbredir_configuration_status(void *priv
, uint32_t id
,
119 struct usb_redir_configuration_status_header
*configuration_status
);
120 static void usbredir_alt_setting_status(void *priv
, uint32_t id
,
121 struct usb_redir_alt_setting_status_header
*alt_setting_status
);
122 static void usbredir_iso_stream_status(void *priv
, uint32_t id
,
123 struct usb_redir_iso_stream_status_header
*iso_stream_status
);
124 static void usbredir_interrupt_receiving_status(void *priv
, uint32_t id
,
125 struct usb_redir_interrupt_receiving_status_header
126 *interrupt_receiving_status
);
127 static void usbredir_bulk_streams_status(void *priv
, uint32_t id
,
128 struct usb_redir_bulk_streams_status_header
*bulk_streams_status
);
129 static void usbredir_control_packet(void *priv
, uint32_t id
,
130 struct usb_redir_control_packet_header
*control_packet
,
131 uint8_t *data
, int data_len
);
132 static void usbredir_bulk_packet(void *priv
, uint32_t id
,
133 struct usb_redir_bulk_packet_header
*bulk_packet
,
134 uint8_t *data
, int data_len
);
135 static void usbredir_iso_packet(void *priv
, uint32_t id
,
136 struct usb_redir_iso_packet_header
*iso_packet
,
137 uint8_t *data
, int data_len
);
138 static void usbredir_interrupt_packet(void *priv
, uint32_t id
,
139 struct usb_redir_interrupt_packet_header
*interrupt_header
,
140 uint8_t *data
, int data_len
);
142 static int usbredir_handle_status(USBRedirDevice
*dev
,
143 int status
, int actual_len
);
145 #define VERSION "qemu usb-redir guest " QEMU_VERSION
153 if (dev->debug >= usbredirparser_error) { \
154 error_report("usb-redir error: " __VA_ARGS__); \
157 #define WARNING(...) \
159 if (dev->debug >= usbredirparser_warning) { \
160 error_report("usb-redir warning: " __VA_ARGS__); \
165 if (dev->debug >= usbredirparser_info) { \
166 error_report("usb-redir: " __VA_ARGS__); \
169 #define DPRINTF(...) \
171 if (dev->debug >= usbredirparser_debug) { \
172 error_report("usb-redir: " __VA_ARGS__); \
175 #define DPRINTF2(...) \
177 if (dev->debug >= usbredirparser_debug_data) { \
178 error_report("usb-redir: " __VA_ARGS__); \
182 static void usbredir_log(void *priv
, int level
, const char *msg
)
184 USBRedirDevice
*dev
= priv
;
186 if (dev
->debug
< level
) {
190 error_report("%s", msg
);
193 static void usbredir_log_data(USBRedirDevice
*dev
, const char *desc
,
194 const uint8_t *data
, int len
)
198 if (dev
->debug
< usbredirparser_debug_data
) {
202 for (i
= 0; i
< len
; i
+= j
) {
205 n
= sprintf(buf
, "%s", desc
);
206 for (j
= 0; j
< 8 && i
+ j
< len
; j
++) {
207 n
+= sprintf(buf
+ n
, " %02X", data
[i
+ j
]);
209 error_report("%s", buf
);
214 * usbredirparser io functions
217 static int usbredir_read(void *priv
, uint8_t *data
, int count
)
219 USBRedirDevice
*dev
= priv
;
221 if (dev
->read_buf_size
< count
) {
222 count
= dev
->read_buf_size
;
225 memcpy(data
, dev
->read_buf
, count
);
227 dev
->read_buf_size
-= count
;
228 if (dev
->read_buf_size
) {
229 dev
->read_buf
+= count
;
231 dev
->read_buf
= NULL
;
237 static int usbredir_write(void *priv
, uint8_t *data
, int count
)
239 USBRedirDevice
*dev
= priv
;
241 if (!dev
->cs
->opened
) {
245 return qemu_chr_fe_write(dev
->cs
, data
, count
);
249 * Async and buffered packets helpers
252 static AsyncURB
*async_alloc(USBRedirDevice
*dev
, USBPacket
*p
)
254 AsyncURB
*aurb
= (AsyncURB
*) g_malloc0(sizeof(AsyncURB
));
257 aurb
->packet_id
= dev
->packet_id
;
258 QTAILQ_INSERT_TAIL(&dev
->asyncq
, aurb
, next
);
264 static void async_free(USBRedirDevice
*dev
, AsyncURB
*aurb
)
266 QTAILQ_REMOVE(&dev
->asyncq
, aurb
, next
);
270 static AsyncURB
*async_find(USBRedirDevice
*dev
, uint32_t packet_id
)
274 QTAILQ_FOREACH(aurb
, &dev
->asyncq
, next
) {
275 if (aurb
->packet_id
== packet_id
) {
279 ERROR("could not find async urb for packet_id %u\n", packet_id
);
283 static void usbredir_cancel_packet(USBDevice
*udev
, USBPacket
*p
)
285 USBRedirDevice
*dev
= DO_UPCAST(USBRedirDevice
, dev
, udev
);
288 QTAILQ_FOREACH(aurb
, &dev
->asyncq
, next
) {
289 if (p
!= aurb
->packet
) {
293 DPRINTF("async cancel id %u\n", aurb
->packet_id
);
294 usbredirparser_send_cancel_data_packet(dev
->parser
, aurb
->packet_id
);
295 usbredirparser_do_write(dev
->parser
);
297 /* Mark it as dead */
303 static void bufp_alloc(USBRedirDevice
*dev
,
304 uint8_t *data
, int len
, int status
, uint8_t ep
)
306 struct buf_packet
*bufp
;
308 if (!dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
&&
309 dev
->endpoint
[EP2I(ep
)].bufpq_size
>
310 2 * dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
311 DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep
);
312 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 1;
314 /* Since we're interupting the stream anyways, drop enough packets to get
315 back to our target buffer size */
316 if (dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
) {
317 if (dev
->endpoint
[EP2I(ep
)].bufpq_size
>
318 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
322 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
325 bufp
= g_malloc(sizeof(struct buf_packet
));
328 bufp
->status
= status
;
329 QTAILQ_INSERT_TAIL(&dev
->endpoint
[EP2I(ep
)].bufpq
, bufp
, next
);
330 dev
->endpoint
[EP2I(ep
)].bufpq_size
++;
333 static void bufp_free(USBRedirDevice
*dev
, struct buf_packet
*bufp
,
336 QTAILQ_REMOVE(&dev
->endpoint
[EP2I(ep
)].bufpq
, bufp
, next
);
337 dev
->endpoint
[EP2I(ep
)].bufpq_size
--;
342 static void usbredir_free_bufpq(USBRedirDevice
*dev
, uint8_t ep
)
344 struct buf_packet
*buf
, *buf_next
;
346 QTAILQ_FOREACH_SAFE(buf
, &dev
->endpoint
[EP2I(ep
)].bufpq
, next
, buf_next
) {
347 bufp_free(dev
, buf
, ep
);
352 * USBDevice callbacks
355 static void usbredir_handle_reset(USBDevice
*udev
)
357 USBRedirDevice
*dev
= DO_UPCAST(USBRedirDevice
, dev
, udev
);
359 DPRINTF("reset device\n");
360 usbredirparser_send_reset(dev
->parser
);
361 usbredirparser_do_write(dev
->parser
);
364 static int usbredir_handle_iso_data(USBRedirDevice
*dev
, USBPacket
*p
,
368 if (!dev
->endpoint
[EP2I(ep
)].iso_started
&&
369 !dev
->endpoint
[EP2I(ep
)].iso_error
) {
370 struct usb_redir_start_iso_stream_header start_iso
= {
375 if (dev
->dev
.speed
== USB_SPEED_HIGH
) {
376 pkts_per_sec
= 8000 / dev
->endpoint
[EP2I(ep
)].interval
;
378 pkts_per_sec
= 1000 / dev
->endpoint
[EP2I(ep
)].interval
;
380 /* Testing has shown that we need circa 60 ms buffer */
381 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= (pkts_per_sec
* 60) / 1000;
383 /* Aim for approx 100 interrupts / second on the client to
384 balance latency and interrupt load */
385 start_iso
.pkts_per_urb
= pkts_per_sec
/ 100;
386 if (start_iso
.pkts_per_urb
< 1) {
387 start_iso
.pkts_per_urb
= 1;
388 } else if (start_iso
.pkts_per_urb
> 32) {
389 start_iso
.pkts_per_urb
= 32;
392 start_iso
.no_urbs
= (dev
->endpoint
[EP2I(ep
)].bufpq_target_size
+
393 start_iso
.pkts_per_urb
- 1) /
394 start_iso
.pkts_per_urb
;
395 /* Output endpoints pre-fill only 1/2 of the packets, keeping the rest
396 as overflow buffer. Also see the usbredir protocol documentation */
397 if (!(ep
& USB_DIR_IN
)) {
398 start_iso
.no_urbs
*= 2;
400 if (start_iso
.no_urbs
> 16) {
401 start_iso
.no_urbs
= 16;
404 /* No id, we look at the ep when receiving a status back */
405 usbredirparser_send_start_iso_stream(dev
->parser
, 0, &start_iso
);
406 usbredirparser_do_write(dev
->parser
);
407 DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n",
408 pkts_per_sec
, start_iso
.pkts_per_urb
, start_iso
.no_urbs
, ep
);
409 dev
->endpoint
[EP2I(ep
)].iso_started
= 1;
410 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 0;
411 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
414 if (ep
& USB_DIR_IN
) {
415 struct buf_packet
*isop
;
417 if (dev
->endpoint
[EP2I(ep
)].iso_started
&&
418 !dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
) {
419 if (dev
->endpoint
[EP2I(ep
)].bufpq_size
<
420 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
) {
421 return usbredir_handle_status(dev
, 0, 0);
423 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 1;
426 isop
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
);
428 DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n",
429 ep
, dev
->endpoint
[EP2I(ep
)].iso_error
);
430 /* Re-fill the buffer */
431 dev
->endpoint
[EP2I(ep
)].bufpq_prefilled
= 0;
432 /* Check iso_error for stream errors, otherwise its an underrun */
433 status
= dev
->endpoint
[EP2I(ep
)].iso_error
;
434 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
435 return status
? USB_RET_IOERROR
: 0;
437 DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep
,
438 isop
->status
, isop
->len
, dev
->endpoint
[EP2I(ep
)].bufpq_size
);
440 status
= isop
->status
;
441 if (status
!= usb_redir_success
) {
442 bufp_free(dev
, isop
, ep
);
443 return USB_RET_IOERROR
;
447 if (len
> p
->iov
.size
) {
448 ERROR("received iso data is larger then packet ep %02X (%d > %d)\n",
449 ep
, len
, (int)p
->iov
.size
);
450 bufp_free(dev
, isop
, ep
);
451 return USB_RET_BABBLE
;
453 usb_packet_copy(p
, isop
->data
, len
);
454 bufp_free(dev
, isop
, ep
);
457 /* If the stream was not started because of a pending error don't
458 send the packet to the usb-host */
459 if (dev
->endpoint
[EP2I(ep
)].iso_started
) {
460 struct usb_redir_iso_packet_header iso_packet
= {
462 .length
= p
->iov
.size
464 uint8_t buf
[p
->iov
.size
];
465 /* No id, we look at the ep when receiving a status back */
466 usb_packet_copy(p
, buf
, p
->iov
.size
);
467 usbredirparser_send_iso_packet(dev
->parser
, 0, &iso_packet
,
469 usbredirparser_do_write(dev
->parser
);
471 status
= dev
->endpoint
[EP2I(ep
)].iso_error
;
472 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
473 DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep
, status
,
475 return usbredir_handle_status(dev
, status
, p
->iov
.size
);
479 static void usbredir_stop_iso_stream(USBRedirDevice
*dev
, uint8_t ep
)
481 struct usb_redir_stop_iso_stream_header stop_iso_stream
= {
484 if (dev
->endpoint
[EP2I(ep
)].iso_started
) {
485 usbredirparser_send_stop_iso_stream(dev
->parser
, 0, &stop_iso_stream
);
486 DPRINTF("iso stream stopped ep %02X\n", ep
);
487 dev
->endpoint
[EP2I(ep
)].iso_started
= 0;
489 dev
->endpoint
[EP2I(ep
)].iso_error
= 0;
490 usbredir_free_bufpq(dev
, ep
);
493 static int usbredir_handle_bulk_data(USBRedirDevice
*dev
, USBPacket
*p
,
496 AsyncURB
*aurb
= async_alloc(dev
, p
);
497 struct usb_redir_bulk_packet_header bulk_packet
;
499 DPRINTF("bulk-out ep %02X len %zd id %u\n", ep
,
500 p
->iov
.size
, aurb
->packet_id
);
502 bulk_packet
.endpoint
= ep
;
503 bulk_packet
.length
= p
->iov
.size
;
504 bulk_packet
.stream_id
= 0;
505 aurb
->bulk_packet
= bulk_packet
;
507 if (ep
& USB_DIR_IN
) {
508 usbredirparser_send_bulk_packet(dev
->parser
, aurb
->packet_id
,
509 &bulk_packet
, NULL
, 0);
511 uint8_t buf
[p
->iov
.size
];
512 usb_packet_copy(p
, buf
, p
->iov
.size
);
513 usbredir_log_data(dev
, "bulk data out:", buf
, p
->iov
.size
);
514 usbredirparser_send_bulk_packet(dev
->parser
, aurb
->packet_id
,
515 &bulk_packet
, buf
, p
->iov
.size
);
517 usbredirparser_do_write(dev
->parser
);
518 return USB_RET_ASYNC
;
521 static int usbredir_handle_interrupt_data(USBRedirDevice
*dev
,
522 USBPacket
*p
, uint8_t ep
)
524 if (ep
& USB_DIR_IN
) {
525 /* Input interrupt endpoint, buffered packet input */
526 struct buf_packet
*intp
;
529 if (!dev
->endpoint
[EP2I(ep
)].interrupt_started
&&
530 !dev
->endpoint
[EP2I(ep
)].interrupt_error
) {
531 struct usb_redir_start_interrupt_receiving_header start_int
= {
534 /* No id, we look at the ep when receiving a status back */
535 usbredirparser_send_start_interrupt_receiving(dev
->parser
, 0,
537 usbredirparser_do_write(dev
->parser
);
538 DPRINTF("interrupt recv started ep %02X\n", ep
);
539 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 1;
540 /* We don't really want to drop interrupt packets ever, but
541 having some upper limit to how much we buffer is good. */
542 dev
->endpoint
[EP2I(ep
)].bufpq_target_size
= 1000;
543 dev
->endpoint
[EP2I(ep
)].bufpq_dropping_packets
= 0;
546 intp
= QTAILQ_FIRST(&dev
->endpoint
[EP2I(ep
)].bufpq
);
548 DPRINTF2("interrupt-token-in ep %02X, no intp\n", ep
);
549 /* Check interrupt_error for stream errors */
550 status
= dev
->endpoint
[EP2I(ep
)].interrupt_error
;
551 dev
->endpoint
[EP2I(ep
)].interrupt_error
= 0;
553 return usbredir_handle_status(dev
, status
, 0);
557 DPRINTF("interrupt-token-in ep %02X status %d len %d\n", ep
,
558 intp
->status
, intp
->len
);
560 status
= intp
->status
;
561 if (status
!= usb_redir_success
) {
562 bufp_free(dev
, intp
, ep
);
563 return usbredir_handle_status(dev
, status
, 0);
567 if (len
> p
->iov
.size
) {
568 ERROR("received int data is larger then packet ep %02X\n", ep
);
569 bufp_free(dev
, intp
, ep
);
570 return USB_RET_BABBLE
;
572 usb_packet_copy(p
, intp
->data
, len
);
573 bufp_free(dev
, intp
, ep
);
576 /* Output interrupt endpoint, normal async operation */
577 AsyncURB
*aurb
= async_alloc(dev
, p
);
578 struct usb_redir_interrupt_packet_header interrupt_packet
;
579 uint8_t buf
[p
->iov
.size
];
581 DPRINTF("interrupt-out ep %02X len %zd id %u\n", ep
, p
->iov
.size
,
584 interrupt_packet
.endpoint
= ep
;
585 interrupt_packet
.length
= p
->iov
.size
;
586 aurb
->interrupt_packet
= interrupt_packet
;
588 usb_packet_copy(p
, buf
, p
->iov
.size
);
589 usbredir_log_data(dev
, "interrupt data out:", buf
, p
->iov
.size
);
590 usbredirparser_send_interrupt_packet(dev
->parser
, aurb
->packet_id
,
591 &interrupt_packet
, buf
, p
->iov
.size
);
592 usbredirparser_do_write(dev
->parser
);
593 return USB_RET_ASYNC
;
597 static void usbredir_stop_interrupt_receiving(USBRedirDevice
*dev
,
600 struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv
= {
603 if (dev
->endpoint
[EP2I(ep
)].interrupt_started
) {
604 usbredirparser_send_stop_interrupt_receiving(dev
->parser
, 0,
605 &stop_interrupt_recv
);
606 DPRINTF("interrupt recv stopped ep %02X\n", ep
);
607 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 0;
609 dev
->endpoint
[EP2I(ep
)].interrupt_error
= 0;
610 usbredir_free_bufpq(dev
, ep
);
613 static int usbredir_handle_data(USBDevice
*udev
, USBPacket
*p
)
615 USBRedirDevice
*dev
= DO_UPCAST(USBRedirDevice
, dev
, udev
);
619 if (p
->pid
== USB_TOKEN_IN
) {
623 switch (dev
->endpoint
[EP2I(ep
)].type
) {
624 case USB_ENDPOINT_XFER_CONTROL
:
625 ERROR("handle_data called for control transfer on ep %02X\n", ep
);
627 case USB_ENDPOINT_XFER_ISOC
:
628 return usbredir_handle_iso_data(dev
, p
, ep
);
629 case USB_ENDPOINT_XFER_BULK
:
630 return usbredir_handle_bulk_data(dev
, p
, ep
);
631 case USB_ENDPOINT_XFER_INT
:
632 return usbredir_handle_interrupt_data(dev
, p
, ep
);
634 ERROR("handle_data ep %02X has unknown type %d\n", ep
,
635 dev
->endpoint
[EP2I(ep
)].type
);
640 static int usbredir_set_config(USBRedirDevice
*dev
, USBPacket
*p
,
643 struct usb_redir_set_configuration_header set_config
;
644 AsyncURB
*aurb
= async_alloc(dev
, p
);
647 DPRINTF("set config %d id %u\n", config
, aurb
->packet_id
);
649 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
650 switch (dev
->endpoint
[i
].type
) {
651 case USB_ENDPOINT_XFER_ISOC
:
652 usbredir_stop_iso_stream(dev
, I2EP(i
));
654 case USB_ENDPOINT_XFER_INT
:
656 usbredir_stop_interrupt_receiving(dev
, I2EP(i
));
660 usbredir_free_bufpq(dev
, I2EP(i
));
663 set_config
.configuration
= config
;
664 usbredirparser_send_set_configuration(dev
->parser
, aurb
->packet_id
,
666 usbredirparser_do_write(dev
->parser
);
667 return USB_RET_ASYNC
;
670 static int usbredir_get_config(USBRedirDevice
*dev
, USBPacket
*p
)
672 AsyncURB
*aurb
= async_alloc(dev
, p
);
674 DPRINTF("get config id %u\n", aurb
->packet_id
);
677 usbredirparser_send_get_configuration(dev
->parser
, aurb
->packet_id
);
678 usbredirparser_do_write(dev
->parser
);
679 return USB_RET_ASYNC
;
682 static int usbredir_set_interface(USBRedirDevice
*dev
, USBPacket
*p
,
683 int interface
, int alt
)
685 struct usb_redir_set_alt_setting_header set_alt
;
686 AsyncURB
*aurb
= async_alloc(dev
, p
);
689 DPRINTF("set interface %d alt %d id %u\n", interface
, alt
,
692 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
693 if (dev
->endpoint
[i
].interface
== interface
) {
694 switch (dev
->endpoint
[i
].type
) {
695 case USB_ENDPOINT_XFER_ISOC
:
696 usbredir_stop_iso_stream(dev
, I2EP(i
));
698 case USB_ENDPOINT_XFER_INT
:
700 usbredir_stop_interrupt_receiving(dev
, I2EP(i
));
704 usbredir_free_bufpq(dev
, I2EP(i
));
708 set_alt
.interface
= interface
;
710 usbredirparser_send_set_alt_setting(dev
->parser
, aurb
->packet_id
,
712 usbredirparser_do_write(dev
->parser
);
713 return USB_RET_ASYNC
;
716 static int usbredir_get_interface(USBRedirDevice
*dev
, USBPacket
*p
,
719 struct usb_redir_get_alt_setting_header get_alt
;
720 AsyncURB
*aurb
= async_alloc(dev
, p
);
722 DPRINTF("get interface %d id %u\n", interface
, aurb
->packet_id
);
724 get_alt
.interface
= interface
;
726 usbredirparser_send_get_alt_setting(dev
->parser
, aurb
->packet_id
,
728 usbredirparser_do_write(dev
->parser
);
729 return USB_RET_ASYNC
;
732 static int usbredir_handle_control(USBDevice
*udev
, USBPacket
*p
,
733 int request
, int value
, int index
, int length
, uint8_t *data
)
735 USBRedirDevice
*dev
= DO_UPCAST(USBRedirDevice
, dev
, udev
);
736 struct usb_redir_control_packet_header control_packet
;
739 /* Special cases for certain standard device requests */
741 case DeviceOutRequest
| USB_REQ_SET_ADDRESS
:
742 DPRINTF("set address %d\n", value
);
743 dev
->dev
.addr
= value
;
745 case DeviceOutRequest
| USB_REQ_SET_CONFIGURATION
:
746 return usbredir_set_config(dev
, p
, value
& 0xff);
747 case DeviceRequest
| USB_REQ_GET_CONFIGURATION
:
748 return usbredir_get_config(dev
, p
);
749 case InterfaceOutRequest
| USB_REQ_SET_INTERFACE
:
750 return usbredir_set_interface(dev
, p
, index
, value
);
751 case InterfaceRequest
| USB_REQ_GET_INTERFACE
:
752 return usbredir_get_interface(dev
, p
, index
);
755 /* "Normal" ctrl requests */
756 aurb
= async_alloc(dev
, p
);
758 /* Note request is (bRequestType << 8) | bRequest */
759 DPRINTF("ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %u\n",
760 request
>> 8, request
& 0xff, value
, index
, length
,
763 control_packet
.request
= request
& 0xFF;
764 control_packet
.requesttype
= request
>> 8;
765 control_packet
.endpoint
= control_packet
.requesttype
& USB_DIR_IN
;
766 control_packet
.value
= value
;
767 control_packet
.index
= index
;
768 control_packet
.length
= length
;
769 aurb
->control_packet
= control_packet
;
771 if (control_packet
.requesttype
& USB_DIR_IN
) {
772 usbredirparser_send_control_packet(dev
->parser
, aurb
->packet_id
,
773 &control_packet
, NULL
, 0);
775 usbredir_log_data(dev
, "ctrl data out:", data
, length
);
776 usbredirparser_send_control_packet(dev
->parser
, aurb
->packet_id
,
777 &control_packet
, data
, length
);
779 usbredirparser_do_write(dev
->parser
);
780 return USB_RET_ASYNC
;
784 * Close events can be triggered by usbredirparser_do_write which gets called
785 * from within the USBDevice data / control packet callbacks and doing a
786 * usb_detach from within these callbacks is not a good idea.
788 * So we use a bh handler to take care of close events. We also handle
789 * open events from this callback to make sure that a close directly followed
790 * by an open gets handled in the right order.
792 static void usbredir_open_close_bh(void *opaque
)
794 USBRedirDevice
*dev
= opaque
;
795 uint32_t caps
[USB_REDIR_CAPS_SIZE
] = { 0, };
797 usbredir_device_disconnect(dev
);
800 usbredirparser_destroy(dev
->parser
);
804 if (dev
->cs
->opened
) {
805 dev
->parser
= qemu_oom_check(usbredirparser_create());
806 dev
->parser
->priv
= dev
;
807 dev
->parser
->log_func
= usbredir_log
;
808 dev
->parser
->read_func
= usbredir_read
;
809 dev
->parser
->write_func
= usbredir_write
;
810 dev
->parser
->hello_func
= usbredir_hello
;
811 dev
->parser
->device_connect_func
= usbredir_device_connect
;
812 dev
->parser
->device_disconnect_func
= usbredir_device_disconnect
;
813 dev
->parser
->interface_info_func
= usbredir_interface_info
;
814 dev
->parser
->ep_info_func
= usbredir_ep_info
;
815 dev
->parser
->configuration_status_func
= usbredir_configuration_status
;
816 dev
->parser
->alt_setting_status_func
= usbredir_alt_setting_status
;
817 dev
->parser
->iso_stream_status_func
= usbredir_iso_stream_status
;
818 dev
->parser
->interrupt_receiving_status_func
=
819 usbredir_interrupt_receiving_status
;
820 dev
->parser
->bulk_streams_status_func
= usbredir_bulk_streams_status
;
821 dev
->parser
->control_packet_func
= usbredir_control_packet
;
822 dev
->parser
->bulk_packet_func
= usbredir_bulk_packet
;
823 dev
->parser
->iso_packet_func
= usbredir_iso_packet
;
824 dev
->parser
->interrupt_packet_func
= usbredir_interrupt_packet
;
825 dev
->read_buf
= NULL
;
826 dev
->read_buf_size
= 0;
828 usbredirparser_caps_set_cap(caps
, usb_redir_cap_connect_device_version
);
829 usbredirparser_caps_set_cap(caps
, usb_redir_cap_filter
);
830 usbredirparser_init(dev
->parser
, VERSION
, caps
, USB_REDIR_CAPS_SIZE
, 0);
831 usbredirparser_do_write(dev
->parser
);
835 static void usbredir_do_attach(void *opaque
)
837 USBRedirDevice
*dev
= opaque
;
839 if (usb_device_attach(&dev
->dev
) != 0) {
840 usbredir_device_disconnect(dev
);
841 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
)) {
842 usbredirparser_send_filter_reject(dev
->parser
);
843 usbredirparser_do_write(dev
->parser
);
852 static int usbredir_chardev_can_read(void *opaque
)
854 USBRedirDevice
*dev
= opaque
;
857 /* usbredir_parser_do_read will consume *all* data we give it */
860 /* usbredir_open_close_bh hasn't handled the open event yet */
865 static void usbredir_chardev_read(void *opaque
, const uint8_t *buf
, int size
)
867 USBRedirDevice
*dev
= opaque
;
869 /* No recursion allowed! */
870 assert(dev
->read_buf
== NULL
);
873 dev
->read_buf_size
= size
;
875 usbredirparser_do_read(dev
->parser
);
876 /* Send any acks, etc. which may be queued now */
877 usbredirparser_do_write(dev
->parser
);
880 static void usbredir_chardev_event(void *opaque
, int event
)
882 USBRedirDevice
*dev
= opaque
;
885 case CHR_EVENT_OPENED
:
886 case CHR_EVENT_CLOSED
:
887 qemu_bh_schedule(dev
->open_close_bh
);
896 static int usbredir_initfn(USBDevice
*udev
)
898 USBRedirDevice
*dev
= DO_UPCAST(USBRedirDevice
, dev
, udev
);
901 if (dev
->cs
== NULL
) {
902 qerror_report(QERR_MISSING_PARAMETER
, "chardev");
906 if (dev
->filter_str
) {
907 i
= usbredirfilter_string_to_rules(dev
->filter_str
, ":", "|",
909 &dev
->filter_rules_count
);
911 qerror_report(QERR_INVALID_PARAMETER_VALUE
, "filter",
912 "a usb device filter string");
917 dev
->open_close_bh
= qemu_bh_new(usbredir_open_close_bh
, dev
);
918 dev
->attach_timer
= qemu_new_timer_ms(vm_clock
, usbredir_do_attach
, dev
);
920 QTAILQ_INIT(&dev
->asyncq
);
921 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
922 QTAILQ_INIT(&dev
->endpoint
[i
].bufpq
);
925 /* We'll do the attach once we receive the speed from the usb-host */
926 udev
->auto_attach
= 0;
928 /* Let the backend know we are ready */
929 qemu_chr_fe_open(dev
->cs
);
930 qemu_chr_add_handlers(dev
->cs
, usbredir_chardev_can_read
,
931 usbredir_chardev_read
, usbredir_chardev_event
, dev
);
933 add_boot_device_path(dev
->bootindex
, &udev
->qdev
, NULL
);
937 static void usbredir_cleanup_device_queues(USBRedirDevice
*dev
)
939 AsyncURB
*aurb
, *next_aurb
;
942 QTAILQ_FOREACH_SAFE(aurb
, &dev
->asyncq
, next
, next_aurb
) {
943 async_free(dev
, aurb
);
945 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
946 usbredir_free_bufpq(dev
, I2EP(i
));
950 static void usbredir_handle_destroy(USBDevice
*udev
)
952 USBRedirDevice
*dev
= DO_UPCAST(USBRedirDevice
, dev
, udev
);
954 qemu_chr_fe_close(dev
->cs
);
955 qemu_chr_delete(dev
->cs
);
956 /* Note must be done after qemu_chr_close, as that causes a close event */
957 qemu_bh_delete(dev
->open_close_bh
);
959 qemu_del_timer(dev
->attach_timer
);
960 qemu_free_timer(dev
->attach_timer
);
962 usbredir_cleanup_device_queues(dev
);
965 usbredirparser_destroy(dev
->parser
);
968 free(dev
->filter_rules
);
971 static int usbredir_check_filter(USBRedirDevice
*dev
)
973 if (dev
->interface_info
.interface_count
== 0) {
974 ERROR("No interface info for device\n");
978 if (dev
->filter_rules
) {
979 if (!usbredirparser_peer_has_cap(dev
->parser
,
980 usb_redir_cap_connect_device_version
)) {
981 ERROR("Device filter specified and peer does not have the "
982 "connect_device_version capability\n");
986 if (usbredirfilter_check(
988 dev
->filter_rules_count
,
989 dev
->device_info
.device_class
,
990 dev
->device_info
.device_subclass
,
991 dev
->device_info
.device_protocol
,
992 dev
->interface_info
.interface_class
,
993 dev
->interface_info
.interface_subclass
,
994 dev
->interface_info
.interface_protocol
,
995 dev
->interface_info
.interface_count
,
996 dev
->device_info
.vendor_id
,
997 dev
->device_info
.product_id
,
998 dev
->device_info
.device_version_bcd
,
1007 usbredir_device_disconnect(dev
);
1008 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
)) {
1009 usbredirparser_send_filter_reject(dev
->parser
);
1010 usbredirparser_do_write(dev
->parser
);
1016 * usbredirparser packet complete callbacks
1019 static int usbredir_handle_status(USBRedirDevice
*dev
,
1020 int status
, int actual_len
)
1023 case usb_redir_success
:
1025 case usb_redir_stall
:
1026 return USB_RET_STALL
;
1027 case usb_redir_cancelled
:
1028 WARNING("returning cancelled packet to HC?\n");
1030 case usb_redir_inval
:
1031 WARNING("got invalid param error from usb-host?\n");
1033 case usb_redir_ioerror
:
1034 case usb_redir_timeout
:
1036 return USB_RET_IOERROR
;
1040 static void usbredir_hello(void *priv
, struct usb_redir_hello_header
*h
)
1042 USBRedirDevice
*dev
= priv
;
1044 /* Try to send the filter info now that we've the usb-host's caps */
1045 if (usbredirparser_peer_has_cap(dev
->parser
, usb_redir_cap_filter
) &&
1046 dev
->filter_rules
) {
1047 usbredirparser_send_filter_filter(dev
->parser
, dev
->filter_rules
,
1048 dev
->filter_rules_count
);
1049 usbredirparser_do_write(dev
->parser
);
1053 static void usbredir_device_connect(void *priv
,
1054 struct usb_redir_device_connect_header
*device_connect
)
1056 USBRedirDevice
*dev
= priv
;
1059 if (qemu_timer_pending(dev
->attach_timer
) || dev
->dev
.attached
) {
1060 ERROR("Received device connect while already connected\n");
1064 switch (device_connect
->speed
) {
1065 case usb_redir_speed_low
:
1066 speed
= "low speed";
1067 dev
->dev
.speed
= USB_SPEED_LOW
;
1069 case usb_redir_speed_full
:
1070 speed
= "full speed";
1071 dev
->dev
.speed
= USB_SPEED_FULL
;
1073 case usb_redir_speed_high
:
1074 speed
= "high speed";
1075 dev
->dev
.speed
= USB_SPEED_HIGH
;
1077 case usb_redir_speed_super
:
1078 speed
= "super speed";
1079 dev
->dev
.speed
= USB_SPEED_SUPER
;
1082 speed
= "unknown speed";
1083 dev
->dev
.speed
= USB_SPEED_FULL
;
1086 if (usbredirparser_peer_has_cap(dev
->parser
,
1087 usb_redir_cap_connect_device_version
)) {
1088 INFO("attaching %s device %04x:%04x version %d.%d class %02x\n",
1089 speed
, device_connect
->vendor_id
, device_connect
->product_id
,
1090 ((device_connect
->device_version_bcd
& 0xf000) >> 12) * 10 +
1091 ((device_connect
->device_version_bcd
& 0x0f00) >> 8),
1092 ((device_connect
->device_version_bcd
& 0x00f0) >> 4) * 10 +
1093 ((device_connect
->device_version_bcd
& 0x000f) >> 0),
1094 device_connect
->device_class
);
1096 INFO("attaching %s device %04x:%04x class %02x\n", speed
,
1097 device_connect
->vendor_id
, device_connect
->product_id
,
1098 device_connect
->device_class
);
1101 dev
->dev
.speedmask
= (1 << dev
->dev
.speed
);
1102 dev
->device_info
= *device_connect
;
1104 if (usbredir_check_filter(dev
)) {
1105 WARNING("Device %04x:%04x rejected by device filter, not attaching\n",
1106 device_connect
->vendor_id
, device_connect
->product_id
);
1110 qemu_mod_timer(dev
->attach_timer
, dev
->next_attach_time
);
1113 static void usbredir_device_disconnect(void *priv
)
1115 USBRedirDevice
*dev
= priv
;
1118 /* Stop any pending attaches */
1119 qemu_del_timer(dev
->attach_timer
);
1121 if (dev
->dev
.attached
) {
1122 usb_device_detach(&dev
->dev
);
1124 * Delay next usb device attach to give the guest a chance to see
1125 * see the detach / attach in case of quick close / open succession
1127 dev
->next_attach_time
= qemu_get_clock_ms(vm_clock
) + 200;
1130 /* Reset state so that the next dev connected starts with a clean slate */
1131 usbredir_cleanup_device_queues(dev
);
1132 memset(dev
->endpoint
, 0, sizeof(dev
->endpoint
));
1133 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1134 QTAILQ_INIT(&dev
->endpoint
[i
].bufpq
);
1136 usb_ep_init(&dev
->dev
);
1137 dev
->interface_info
.interface_count
= 0;
1140 static void usbredir_interface_info(void *priv
,
1141 struct usb_redir_interface_info_header
*interface_info
)
1143 USBRedirDevice
*dev
= priv
;
1145 dev
->interface_info
= *interface_info
;
1148 * If we receive interface info after the device has already been
1149 * connected (ie on a set_config), re-check the filter.
1151 if (qemu_timer_pending(dev
->attach_timer
) || dev
->dev
.attached
) {
1152 if (usbredir_check_filter(dev
)) {
1153 ERROR("Device no longer matches filter after interface info "
1154 "change, disconnecting!\n");
1159 static void usbredir_ep_info(void *priv
,
1160 struct usb_redir_ep_info_header
*ep_info
)
1162 USBRedirDevice
*dev
= priv
;
1163 struct USBEndpoint
*usb_ep
;
1166 for (i
= 0; i
< MAX_ENDPOINTS
; i
++) {
1167 dev
->endpoint
[i
].type
= ep_info
->type
[i
];
1168 dev
->endpoint
[i
].interval
= ep_info
->interval
[i
];
1169 dev
->endpoint
[i
].interface
= ep_info
->interface
[i
];
1170 switch (dev
->endpoint
[i
].type
) {
1171 case usb_redir_type_invalid
:
1173 case usb_redir_type_iso
:
1174 case usb_redir_type_interrupt
:
1175 if (dev
->endpoint
[i
].interval
== 0) {
1176 ERROR("Received 0 interval for isoc or irq endpoint\n");
1177 usbredir_device_disconnect(dev
);
1180 case usb_redir_type_control
:
1181 case usb_redir_type_bulk
:
1182 DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i
),
1183 dev
->endpoint
[i
].type
, dev
->endpoint
[i
].interface
);
1186 ERROR("Received invalid endpoint type\n");
1187 usbredir_device_disconnect(dev
);
1190 usb_ep
= usb_ep_get(&dev
->dev
,
1191 (i
& 0x10) ? USB_TOKEN_IN
: USB_TOKEN_OUT
,
1193 usb_ep
->type
= dev
->endpoint
[i
].type
;
1194 usb_ep
->ifnum
= dev
->endpoint
[i
].interface
;
1198 static void usbredir_configuration_status(void *priv
, uint32_t id
,
1199 struct usb_redir_configuration_status_header
*config_status
)
1201 USBRedirDevice
*dev
= priv
;
1205 DPRINTF("set config status %d config %d id %u\n", config_status
->status
,
1206 config_status
->configuration
, id
);
1208 aurb
= async_find(dev
, id
);
1214 dev
->dev
.data_buf
[0] = config_status
->configuration
;
1217 aurb
->packet
->result
=
1218 usbredir_handle_status(dev
, config_status
->status
, len
);
1219 usb_generic_async_ctrl_complete(&dev
->dev
, aurb
->packet
);
1221 async_free(dev
, aurb
);
1224 static void usbredir_alt_setting_status(void *priv
, uint32_t id
,
1225 struct usb_redir_alt_setting_status_header
*alt_setting_status
)
1227 USBRedirDevice
*dev
= priv
;
1231 DPRINTF("alt status %d intf %d alt %d id: %u\n",
1232 alt_setting_status
->status
,
1233 alt_setting_status
->interface
,
1234 alt_setting_status
->alt
, id
);
1236 aurb
= async_find(dev
, id
);
1242 dev
->dev
.data_buf
[0] = alt_setting_status
->alt
;
1245 aurb
->packet
->result
=
1246 usbredir_handle_status(dev
, alt_setting_status
->status
, len
);
1247 usb_generic_async_ctrl_complete(&dev
->dev
, aurb
->packet
);
1249 async_free(dev
, aurb
);
1252 static void usbredir_iso_stream_status(void *priv
, uint32_t id
,
1253 struct usb_redir_iso_stream_status_header
*iso_stream_status
)
1255 USBRedirDevice
*dev
= priv
;
1256 uint8_t ep
= iso_stream_status
->endpoint
;
1258 DPRINTF("iso status %d ep %02X id %u\n", iso_stream_status
->status
,
1261 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].iso_started
) {
1265 dev
->endpoint
[EP2I(ep
)].iso_error
= iso_stream_status
->status
;
1266 if (iso_stream_status
->status
== usb_redir_stall
) {
1267 DPRINTF("iso stream stopped by peer ep %02X\n", ep
);
1268 dev
->endpoint
[EP2I(ep
)].iso_started
= 0;
1272 static void usbredir_interrupt_receiving_status(void *priv
, uint32_t id
,
1273 struct usb_redir_interrupt_receiving_status_header
1274 *interrupt_receiving_status
)
1276 USBRedirDevice
*dev
= priv
;
1277 uint8_t ep
= interrupt_receiving_status
->endpoint
;
1279 DPRINTF("interrupt recv status %d ep %02X id %u\n",
1280 interrupt_receiving_status
->status
, ep
, id
);
1282 if (!dev
->dev
.attached
|| !dev
->endpoint
[EP2I(ep
)].interrupt_started
) {
1286 dev
->endpoint
[EP2I(ep
)].interrupt_error
=
1287 interrupt_receiving_status
->status
;
1288 if (interrupt_receiving_status
->status
== usb_redir_stall
) {
1289 DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep
);
1290 dev
->endpoint
[EP2I(ep
)].interrupt_started
= 0;
1294 static void usbredir_bulk_streams_status(void *priv
, uint32_t id
,
1295 struct usb_redir_bulk_streams_status_header
*bulk_streams_status
)
1299 static void usbredir_control_packet(void *priv
, uint32_t id
,
1300 struct usb_redir_control_packet_header
*control_packet
,
1301 uint8_t *data
, int data_len
)
1303 USBRedirDevice
*dev
= priv
;
1304 int len
= control_packet
->length
;
1307 DPRINTF("ctrl-in status %d len %d id %u\n", control_packet
->status
,
1310 aurb
= async_find(dev
, id
);
1316 aurb
->control_packet
.status
= control_packet
->status
;
1317 aurb
->control_packet
.length
= control_packet
->length
;
1318 if (memcmp(&aurb
->control_packet
, control_packet
,
1319 sizeof(*control_packet
))) {
1320 ERROR("return control packet mismatch, please report this!\n");
1325 len
= usbredir_handle_status(dev
, control_packet
->status
, len
);
1327 usbredir_log_data(dev
, "ctrl data in:", data
, data_len
);
1328 if (data_len
<= sizeof(dev
->dev
.data_buf
)) {
1329 memcpy(dev
->dev
.data_buf
, data
, data_len
);
1331 ERROR("ctrl buffer too small (%d > %zu)\n",
1332 data_len
, sizeof(dev
->dev
.data_buf
));
1333 len
= USB_RET_STALL
;
1336 aurb
->packet
->result
= len
;
1337 usb_generic_async_ctrl_complete(&dev
->dev
, aurb
->packet
);
1339 async_free(dev
, aurb
);
1343 static void usbredir_bulk_packet(void *priv
, uint32_t id
,
1344 struct usb_redir_bulk_packet_header
*bulk_packet
,
1345 uint8_t *data
, int data_len
)
1347 USBRedirDevice
*dev
= priv
;
1348 uint8_t ep
= bulk_packet
->endpoint
;
1349 int len
= bulk_packet
->length
;
1352 DPRINTF("bulk-in status %d ep %02X len %d id %u\n", bulk_packet
->status
,
1355 aurb
= async_find(dev
, id
);
1361 if (aurb
->bulk_packet
.endpoint
!= bulk_packet
->endpoint
||
1362 aurb
->bulk_packet
.stream_id
!= bulk_packet
->stream_id
) {
1363 ERROR("return bulk packet mismatch, please report this!\n");
1368 len
= usbredir_handle_status(dev
, bulk_packet
->status
, len
);
1370 usbredir_log_data(dev
, "bulk data in:", data
, data_len
);
1371 if (data_len
<= aurb
->packet
->iov
.size
) {
1372 usb_packet_copy(aurb
->packet
, data
, data_len
);
1374 ERROR("bulk buffer too small (%d > %zd)\n", data_len
,
1375 aurb
->packet
->iov
.size
);
1376 len
= USB_RET_STALL
;
1379 aurb
->packet
->result
= len
;
1380 usb_packet_complete(&dev
->dev
, aurb
->packet
);
1382 async_free(dev
, aurb
);
1386 static void usbredir_iso_packet(void *priv
, uint32_t id
,
1387 struct usb_redir_iso_packet_header
*iso_packet
,
1388 uint8_t *data
, int data_len
)
1390 USBRedirDevice
*dev
= priv
;
1391 uint8_t ep
= iso_packet
->endpoint
;
1393 DPRINTF2("iso-in status %d ep %02X len %d id %u\n", iso_packet
->status
, ep
,
1396 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_ISOC
) {
1397 ERROR("received iso packet for non iso endpoint %02X\n", ep
);
1402 if (dev
->endpoint
[EP2I(ep
)].iso_started
== 0) {
1403 DPRINTF("received iso packet for non started stream ep %02X\n", ep
);
1408 /* bufp_alloc also adds the packet to the ep queue */
1409 bufp_alloc(dev
, data
, data_len
, iso_packet
->status
, ep
);
1412 static void usbredir_interrupt_packet(void *priv
, uint32_t id
,
1413 struct usb_redir_interrupt_packet_header
*interrupt_packet
,
1414 uint8_t *data
, int data_len
)
1416 USBRedirDevice
*dev
= priv
;
1417 uint8_t ep
= interrupt_packet
->endpoint
;
1419 DPRINTF("interrupt-in status %d ep %02X len %d id %u\n",
1420 interrupt_packet
->status
, ep
, data_len
, id
);
1422 if (dev
->endpoint
[EP2I(ep
)].type
!= USB_ENDPOINT_XFER_INT
) {
1423 ERROR("received int packet for non interrupt endpoint %02X\n", ep
);
1428 if (ep
& USB_DIR_IN
) {
1429 if (dev
->endpoint
[EP2I(ep
)].interrupt_started
== 0) {
1430 DPRINTF("received int packet while not started ep %02X\n", ep
);
1435 /* bufp_alloc also adds the packet to the ep queue */
1436 bufp_alloc(dev
, data
, data_len
, interrupt_packet
->status
, ep
);
1438 int len
= interrupt_packet
->length
;
1440 AsyncURB
*aurb
= async_find(dev
, id
);
1445 if (aurb
->interrupt_packet
.endpoint
!= interrupt_packet
->endpoint
) {
1446 ERROR("return int packet mismatch, please report this!\n");
1451 aurb
->packet
->result
= usbredir_handle_status(dev
,
1452 interrupt_packet
->status
, len
);
1453 usb_packet_complete(&dev
->dev
, aurb
->packet
);
1455 async_free(dev
, aurb
);
1459 static Property usbredir_properties
[] = {
1460 DEFINE_PROP_CHR("chardev", USBRedirDevice
, cs
),
1461 DEFINE_PROP_UINT8("debug", USBRedirDevice
, debug
, 0),
1462 DEFINE_PROP_STRING("filter", USBRedirDevice
, filter_str
),
1463 DEFINE_PROP_INT32("bootindex", USBRedirDevice
, bootindex
, -1),
1464 DEFINE_PROP_END_OF_LIST(),
1467 static void usbredir_class_initfn(ObjectClass
*klass
, void *data
)
1469 USBDeviceClass
*uc
= USB_DEVICE_CLASS(klass
);
1470 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1472 uc
->init
= usbredir_initfn
;
1473 uc
->product_desc
= "USB Redirection Device";
1474 uc
->handle_destroy
= usbredir_handle_destroy
;
1475 uc
->cancel_packet
= usbredir_cancel_packet
;
1476 uc
->handle_reset
= usbredir_handle_reset
;
1477 uc
->handle_data
= usbredir_handle_data
;
1478 uc
->handle_control
= usbredir_handle_control
;
1479 dc
->props
= usbredir_properties
;
1482 static TypeInfo usbredir_dev_info
= {
1483 .name
= "usb-redir",
1484 .parent
= TYPE_USB_DEVICE
,
1485 .instance_size
= sizeof(USBRedirDevice
),
1486 .class_init
= usbredir_class_initfn
,
1489 static void usbredir_register_types(void)
1491 type_register_static(&usbredir_dev_info
);
1494 type_init(usbredir_register_types
)