1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "qemu/osdep.h"
29#include "qemu-common.h"
30#include "qemu/units.h"
31#include "qapi/error.h"
32#include "qemu/timer.h"
33#include "sysemu/sysemu.h"
34#include "qapi/qmp/qerror.h"
35#include "qemu/error-report.h"
36#include "qemu/iov.h"
37#include "qemu/module.h"
38#include "chardev/char-fe.h"
39
40#include <usbredirparser.h>
41#include <usbredirfilter.h>
42
43#include "hw/usb.h"
44
45
46#undef ERROR
47
48#define MAX_ENDPOINTS 32
49#define NO_INTERFACE_INFO 255
50#define EP2I(ep_address) (((ep_address & 0x80) >> 3) | (ep_address & 0x0f))
51#define I2EP(i) (((i & 0x10) << 3) | (i & 0x0f))
52#define USBEP2I(usb_ep) (((usb_ep)->pid == USB_TOKEN_IN) ? \
53 ((usb_ep)->nr | 0x10) : ((usb_ep)->nr))
54#define I2USBEP(d, i) (usb_ep_get(&(d)->dev, \
55 ((i) & 0x10) ? USB_TOKEN_IN : USB_TOKEN_OUT, \
56 (i) & 0x0f))
57
58#ifndef USBREDIR_VERSION
59#define USBREDIR_VERSION 0
60#endif
61
62typedef struct USBRedirDevice USBRedirDevice;
63
64
65struct buf_packet {
66 uint8_t *data;
67 void *free_on_destroy;
68 uint16_t len;
69 uint16_t offset;
70 uint8_t status;
71 QTAILQ_ENTRY(buf_packet)next;
72};
73
74struct endp_data {
75 USBRedirDevice *dev;
76 uint8_t type;
77 uint8_t interval;
78 uint8_t interface;
79 uint16_t max_packet_size;
80 uint32_t max_streams;
81 uint8_t iso_started;
82 uint8_t iso_error;
83 uint8_t interrupt_started;
84 uint8_t interrupt_error;
85 uint8_t bulk_receiving_enabled;
86 uint8_t bulk_receiving_started;
87 uint8_t bufpq_prefilled;
88 uint8_t bufpq_dropping_packets;
89 QTAILQ_HEAD(, buf_packet) bufpq;
90 int32_t bufpq_size;
91 int32_t bufpq_target_size;
92 USBPacket *pending_async_packet;
93};
94
95struct PacketIdQueueEntry {
96 uint64_t id;
97 QTAILQ_ENTRY(PacketIdQueueEntry)next;
98};
99
100struct PacketIdQueue {
101 USBRedirDevice *dev;
102 const char *name;
103 QTAILQ_HEAD(, PacketIdQueueEntry) head;
104 int size;
105};
106
107struct USBRedirDevice {
108 USBDevice dev;
109
110 CharBackend cs;
111 bool enable_streams;
112 uint8_t debug;
113 int32_t bootindex;
114 char *filter_str;
115
116 const uint8_t *read_buf;
117 int read_buf_size;
118
119 guint watch;
120
121 QEMUBH *chardev_close_bh;
122 QEMUBH *device_reject_bh;
123
124 QEMUTimer *attach_timer;
125 int64_t next_attach_time;
126 struct usbredirparser *parser;
127 struct endp_data endpoint[MAX_ENDPOINTS];
128 struct PacketIdQueue cancelled;
129 struct PacketIdQueue already_in_flight;
130 void (*buffered_bulk_in_complete)(USBRedirDevice *, USBPacket *, uint8_t);
131
132 struct usb_redir_device_connect_header device_info;
133 struct usb_redir_interface_info_header interface_info;
134 struct usbredirfilter_rule *filter_rules;
135 int filter_rules_count;
136 int compatible_speedmask;
137 VMChangeStateEntry *vmstate;
138};
139
140#define TYPE_USB_REDIR "usb-redir"
141#define USB_REDIRECT(obj) OBJECT_CHECK(USBRedirDevice, (obj), TYPE_USB_REDIR)
142
143static void usbredir_hello(void *priv, struct usb_redir_hello_header *h);
144static void usbredir_device_connect(void *priv,
145 struct usb_redir_device_connect_header *device_connect);
146static void usbredir_device_disconnect(void *priv);
147static void usbredir_interface_info(void *priv,
148 struct usb_redir_interface_info_header *interface_info);
149static void usbredir_ep_info(void *priv,
150 struct usb_redir_ep_info_header *ep_info);
151static void usbredir_configuration_status(void *priv, uint64_t id,
152 struct usb_redir_configuration_status_header *configuration_status);
153static void usbredir_alt_setting_status(void *priv, uint64_t id,
154 struct usb_redir_alt_setting_status_header *alt_setting_status);
155static void usbredir_iso_stream_status(void *priv, uint64_t id,
156 struct usb_redir_iso_stream_status_header *iso_stream_status);
157static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
158 struct usb_redir_interrupt_receiving_status_header
159 *interrupt_receiving_status);
160static void usbredir_bulk_streams_status(void *priv, uint64_t id,
161 struct usb_redir_bulk_streams_status_header *bulk_streams_status);
162static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
163 struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
164static void usbredir_control_packet(void *priv, uint64_t id,
165 struct usb_redir_control_packet_header *control_packet,
166 uint8_t *data, int data_len);
167static void usbredir_bulk_packet(void *priv, uint64_t id,
168 struct usb_redir_bulk_packet_header *bulk_packet,
169 uint8_t *data, int data_len);
170static void usbredir_iso_packet(void *priv, uint64_t id,
171 struct usb_redir_iso_packet_header *iso_packet,
172 uint8_t *data, int data_len);
173static void usbredir_interrupt_packet(void *priv, uint64_t id,
174 struct usb_redir_interrupt_packet_header *interrupt_header,
175 uint8_t *data, int data_len);
176static void usbredir_buffered_bulk_packet(void *priv, uint64_t id,
177 struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet,
178 uint8_t *data, int data_len);
179
180static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p,
181 int status);
182
183#define VERSION "qemu usb-redir guest " QEMU_VERSION
184
185
186
187
188
189#define ERROR(...) \
190 do { \
191 if (dev->debug >= usbredirparser_error) { \
192 error_report("usb-redir error: " __VA_ARGS__); \
193 } \
194 } while (0)
195#define WARNING(...) \
196 do { \
197 if (dev->debug >= usbredirparser_warning) { \
198 warn_report("" __VA_ARGS__); \
199 } \
200 } while (0)
201#define INFO(...) \
202 do { \
203 if (dev->debug >= usbredirparser_info) { \
204 error_report("usb-redir: " __VA_ARGS__); \
205 } \
206 } while (0)
207#define DPRINTF(...) \
208 do { \
209 if (dev->debug >= usbredirparser_debug) { \
210 error_report("usb-redir: " __VA_ARGS__); \
211 } \
212 } while (0)
213#define DPRINTF2(...) \
214 do { \
215 if (dev->debug >= usbredirparser_debug_data) { \
216 error_report("usb-redir: " __VA_ARGS__); \
217 } \
218 } while (0)
219
220static void usbredir_log(void *priv, int level, const char *msg)
221{
222 USBRedirDevice *dev = priv;
223
224 if (dev->debug < level) {
225 return;
226 }
227
228 error_report("%s", msg);
229}
230
231static void usbredir_log_data(USBRedirDevice *dev, const char *desc,
232 const uint8_t *data, int len)
233{
234 if (dev->debug < usbredirparser_debug_data) {
235 return;
236 }
237 qemu_hexdump((char *)data, stderr, desc, len);
238}
239
240
241
242
243
244static int usbredir_read(void *priv, uint8_t *data, int count)
245{
246 USBRedirDevice *dev = priv;
247
248 if (dev->read_buf_size < count) {
249 count = dev->read_buf_size;
250 }
251
252 memcpy(data, dev->read_buf, count);
253
254 dev->read_buf_size -= count;
255 if (dev->read_buf_size) {
256 dev->read_buf += count;
257 } else {
258 dev->read_buf = NULL;
259 }
260
261 return count;
262}
263
264static gboolean usbredir_write_unblocked(GIOChannel *chan, GIOCondition cond,
265 void *opaque)
266{
267 USBRedirDevice *dev = opaque;
268
269 dev->watch = 0;
270 usbredirparser_do_write(dev->parser);
271
272 return FALSE;
273}
274
275static int usbredir_write(void *priv, uint8_t *data, int count)
276{
277 USBRedirDevice *dev = priv;
278 int r;
279
280 if (!qemu_chr_fe_backend_open(&dev->cs)) {
281 return 0;
282 }
283
284
285 if (!runstate_check(RUN_STATE_RUNNING)) {
286 return 0;
287 }
288
289 r = qemu_chr_fe_write(&dev->cs, data, count);
290 if (r < count) {
291 if (!dev->watch) {
292 dev->watch = qemu_chr_fe_add_watch(&dev->cs, G_IO_OUT | G_IO_HUP,
293 usbredir_write_unblocked, dev);
294 }
295 if (r < 0) {
296 r = 0;
297 }
298 }
299 return r;
300}
301
302
303
304
305
306static void packet_id_queue_init(struct PacketIdQueue *q,
307 USBRedirDevice *dev, const char *name)
308{
309 q->dev = dev;
310 q->name = name;
311 QTAILQ_INIT(&q->head);
312 q->size = 0;
313}
314
315static void packet_id_queue_add(struct PacketIdQueue *q, uint64_t id)
316{
317 USBRedirDevice *dev = q->dev;
318 struct PacketIdQueueEntry *e;
319
320 DPRINTF("adding packet id %"PRIu64" to %s queue\n", id, q->name);
321
322 e = g_new0(struct PacketIdQueueEntry, 1);
323 e->id = id;
324 QTAILQ_INSERT_TAIL(&q->head, e, next);
325 q->size++;
326}
327
328static int packet_id_queue_remove(struct PacketIdQueue *q, uint64_t id)
329{
330 USBRedirDevice *dev = q->dev;
331 struct PacketIdQueueEntry *e;
332
333 QTAILQ_FOREACH(e, &q->head, next) {
334 if (e->id == id) {
335 DPRINTF("removing packet id %"PRIu64" from %s queue\n",
336 id, q->name);
337 QTAILQ_REMOVE(&q->head, e, next);
338 q->size--;
339 g_free(e);
340 return 1;
341 }
342 }
343 return 0;
344}
345
346static void packet_id_queue_empty(struct PacketIdQueue *q)
347{
348 USBRedirDevice *dev = q->dev;
349 struct PacketIdQueueEntry *e, *next_e;
350
351 DPRINTF("removing %d packet-ids from %s queue\n", q->size, q->name);
352
353 QTAILQ_FOREACH_SAFE(e, &q->head, next, next_e) {
354 QTAILQ_REMOVE(&q->head, e, next);
355 g_free(e);
356 }
357 q->size = 0;
358}
359
360static void usbredir_cancel_packet(USBDevice *udev, USBPacket *p)
361{
362 USBRedirDevice *dev = USB_REDIRECT(udev);
363 int i = USBEP2I(p->ep);
364
365 if (p->combined) {
366 usb_combined_packet_cancel(udev, p);
367 return;
368 }
369
370 if (dev->endpoint[i].pending_async_packet) {
371 assert(dev->endpoint[i].pending_async_packet == p);
372 dev->endpoint[i].pending_async_packet = NULL;
373 return;
374 }
375
376 packet_id_queue_add(&dev->cancelled, p->id);
377 usbredirparser_send_cancel_data_packet(dev->parser, p->id);
378 usbredirparser_do_write(dev->parser);
379}
380
381static int usbredir_is_cancelled(USBRedirDevice *dev, uint64_t id)
382{
383 if (!dev->dev.attached) {
384 return 1;
385 }
386 return packet_id_queue_remove(&dev->cancelled, id);
387}
388
389static void usbredir_fill_already_in_flight_from_ep(USBRedirDevice *dev,
390 struct USBEndpoint *ep)
391{
392 static USBPacket *p;
393
394
395 if (dev->endpoint[USBEP2I(ep)].bulk_receiving_started) {
396 return;
397 }
398
399 QTAILQ_FOREACH(p, &ep->queue, queue) {
400
401 if (p->combined && p != p->combined->first) {
402 continue;
403 }
404 if (p->state == USB_PACKET_ASYNC) {
405 packet_id_queue_add(&dev->already_in_flight, p->id);
406 }
407 }
408}
409
410static void usbredir_fill_already_in_flight(USBRedirDevice *dev)
411{
412 int ep;
413 struct USBDevice *udev = &dev->dev;
414
415 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_ctl);
416
417 for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
418 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_in[ep]);
419 usbredir_fill_already_in_flight_from_ep(dev, &udev->ep_out[ep]);
420 }
421}
422
423static int usbredir_already_in_flight(USBRedirDevice *dev, uint64_t id)
424{
425 return packet_id_queue_remove(&dev->already_in_flight, id);
426}
427
428static USBPacket *usbredir_find_packet_by_id(USBRedirDevice *dev,
429 uint8_t ep, uint64_t id)
430{
431 USBPacket *p;
432
433 if (usbredir_is_cancelled(dev, id)) {
434 return NULL;
435 }
436
437 p = usb_ep_find_packet_by_id(&dev->dev,
438 (ep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT,
439 ep & 0x0f, id);
440 if (p == NULL) {
441 ERROR("could not find packet with id %"PRIu64"\n", id);
442 }
443 return p;
444}
445
446static int bufp_alloc(USBRedirDevice *dev, uint8_t *data, uint16_t len,
447 uint8_t status, uint8_t ep, void *free_on_destroy)
448{
449 struct buf_packet *bufp;
450
451 if (!dev->endpoint[EP2I(ep)].bufpq_dropping_packets &&
452 dev->endpoint[EP2I(ep)].bufpq_size >
453 2 * dev->endpoint[EP2I(ep)].bufpq_target_size) {
454 DPRINTF("bufpq overflow, dropping packets ep %02X\n", ep);
455 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 1;
456 }
457
458
459 if (dev->endpoint[EP2I(ep)].bufpq_dropping_packets) {
460 if (dev->endpoint[EP2I(ep)].bufpq_size >
461 dev->endpoint[EP2I(ep)].bufpq_target_size) {
462 free(data);
463 return -1;
464 }
465 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
466 }
467
468 bufp = g_new(struct buf_packet, 1);
469 bufp->data = data;
470 bufp->len = len;
471 bufp->offset = 0;
472 bufp->status = status;
473 bufp->free_on_destroy = free_on_destroy;
474 QTAILQ_INSERT_TAIL(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
475 dev->endpoint[EP2I(ep)].bufpq_size++;
476 return 0;
477}
478
479static void bufp_free(USBRedirDevice *dev, struct buf_packet *bufp,
480 uint8_t ep)
481{
482 QTAILQ_REMOVE(&dev->endpoint[EP2I(ep)].bufpq, bufp, next);
483 dev->endpoint[EP2I(ep)].bufpq_size--;
484 free(bufp->free_on_destroy);
485 g_free(bufp);
486}
487
488static void usbredir_free_bufpq(USBRedirDevice *dev, uint8_t ep)
489{
490 struct buf_packet *buf, *buf_next;
491
492 QTAILQ_FOREACH_SAFE(buf, &dev->endpoint[EP2I(ep)].bufpq, next, buf_next) {
493 bufp_free(dev, buf, ep);
494 }
495}
496
497
498
499
500
501static void usbredir_handle_reset(USBDevice *udev)
502{
503 USBRedirDevice *dev = USB_REDIRECT(udev);
504
505 DPRINTF("reset device\n");
506 usbredirparser_send_reset(dev->parser);
507 usbredirparser_do_write(dev->parser);
508}
509
510static void usbredir_handle_iso_data(USBRedirDevice *dev, USBPacket *p,
511 uint8_t ep)
512{
513 int status, len;
514 if (!dev->endpoint[EP2I(ep)].iso_started &&
515 !dev->endpoint[EP2I(ep)].iso_error) {
516 struct usb_redir_start_iso_stream_header start_iso = {
517 .endpoint = ep,
518 };
519 int pkts_per_sec;
520
521 if (dev->dev.speed == USB_SPEED_HIGH) {
522 pkts_per_sec = 8000 / dev->endpoint[EP2I(ep)].interval;
523 } else {
524 pkts_per_sec = 1000 / dev->endpoint[EP2I(ep)].interval;
525 }
526
527 dev->endpoint[EP2I(ep)].bufpq_target_size = (pkts_per_sec * 60) / 1000;
528
529
530
531 start_iso.pkts_per_urb = pkts_per_sec / 100;
532 if (start_iso.pkts_per_urb < 1) {
533 start_iso.pkts_per_urb = 1;
534 } else if (start_iso.pkts_per_urb > 32) {
535 start_iso.pkts_per_urb = 32;
536 }
537
538 start_iso.no_urbs = DIV_ROUND_UP(
539 dev->endpoint[EP2I(ep)].bufpq_target_size,
540 start_iso.pkts_per_urb);
541
542
543 if (!(ep & USB_DIR_IN)) {
544 start_iso.no_urbs *= 2;
545 }
546 if (start_iso.no_urbs > 16) {
547 start_iso.no_urbs = 16;
548 }
549
550
551 usbredirparser_send_start_iso_stream(dev->parser, 0, &start_iso);
552 usbredirparser_do_write(dev->parser);
553 DPRINTF("iso stream started pkts/sec %d pkts/urb %d urbs %d ep %02X\n",
554 pkts_per_sec, start_iso.pkts_per_urb, start_iso.no_urbs, ep);
555 dev->endpoint[EP2I(ep)].iso_started = 1;
556 dev->endpoint[EP2I(ep)].bufpq_prefilled = 0;
557 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
558 }
559
560 if (ep & USB_DIR_IN) {
561 struct buf_packet *isop;
562
563 if (dev->endpoint[EP2I(ep)].iso_started &&
564 !dev->endpoint[EP2I(ep)].bufpq_prefilled) {
565 if (dev->endpoint[EP2I(ep)].bufpq_size <
566 dev->endpoint[EP2I(ep)].bufpq_target_size) {
567 return;
568 }
569 dev->endpoint[EP2I(ep)].bufpq_prefilled = 1;
570 }
571
572 isop = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq);
573 if (isop == NULL) {
574 DPRINTF("iso-token-in ep %02X, no isop, iso_error: %d\n",
575 ep, dev->endpoint[EP2I(ep)].iso_error);
576
577 dev->endpoint[EP2I(ep)].bufpq_prefilled = 0;
578
579 status = dev->endpoint[EP2I(ep)].iso_error;
580 dev->endpoint[EP2I(ep)].iso_error = 0;
581 p->status = status ? USB_RET_IOERROR : USB_RET_SUCCESS;
582 return;
583 }
584 DPRINTF2("iso-token-in ep %02X status %d len %d queue-size: %d\n", ep,
585 isop->status, isop->len, dev->endpoint[EP2I(ep)].bufpq_size);
586
587 status = isop->status;
588 len = isop->len;
589 if (len > p->iov.size) {
590 ERROR("received iso data is larger then packet ep %02X (%d > %d)\n",
591 ep, len, (int)p->iov.size);
592 len = p->iov.size;
593 status = usb_redir_babble;
594 }
595 usb_packet_copy(p, isop->data, len);
596 bufp_free(dev, isop, ep);
597 usbredir_handle_status(dev, p, status);
598 } else {
599
600
601 if (dev->endpoint[EP2I(ep)].iso_started) {
602 struct usb_redir_iso_packet_header iso_packet = {
603 .endpoint = ep,
604 .length = p->iov.size
605 };
606 uint8_t buf[p->iov.size];
607
608 usb_packet_copy(p, buf, p->iov.size);
609 usbredirparser_send_iso_packet(dev->parser, 0, &iso_packet,
610 buf, p->iov.size);
611 usbredirparser_do_write(dev->parser);
612 }
613 status = dev->endpoint[EP2I(ep)].iso_error;
614 dev->endpoint[EP2I(ep)].iso_error = 0;
615 DPRINTF2("iso-token-out ep %02X status %d len %zd\n", ep, status,
616 p->iov.size);
617 usbredir_handle_status(dev, p, status);
618 }
619}
620
621static void usbredir_stop_iso_stream(USBRedirDevice *dev, uint8_t ep)
622{
623 struct usb_redir_stop_iso_stream_header stop_iso_stream = {
624 .endpoint = ep
625 };
626 if (dev->endpoint[EP2I(ep)].iso_started) {
627 usbredirparser_send_stop_iso_stream(dev->parser, 0, &stop_iso_stream);
628 DPRINTF("iso stream stopped ep %02X\n", ep);
629 dev->endpoint[EP2I(ep)].iso_started = 0;
630 }
631 dev->endpoint[EP2I(ep)].iso_error = 0;
632 usbredir_free_bufpq(dev, ep);
633}
634
635
636
637
638
639
640static void usbredir_buffered_bulk_add_data_to_packet(USBRedirDevice *dev,
641 struct buf_packet *bulkp, int count, USBPacket *p, uint8_t ep)
642{
643 usb_packet_copy(p, bulkp->data + bulkp->offset, count);
644 bulkp->offset += count;
645 if (bulkp->offset == bulkp->len) {
646
647 usbredir_handle_status(dev, p, bulkp->status);
648 bufp_free(dev, bulkp, ep);
649 }
650}
651
652static void usbredir_buffered_bulk_in_complete_raw(USBRedirDevice *dev,
653 USBPacket *p, uint8_t ep)
654{
655 struct buf_packet *bulkp;
656 int count;
657
658 while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) &&
659 p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) {
660 count = bulkp->len - bulkp->offset;
661 if (count > (p->iov.size - p->actual_length)) {
662 count = p->iov.size - p->actual_length;
663 }
664 usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep);
665 }
666}
667
668static void usbredir_buffered_bulk_in_complete_ftdi(USBRedirDevice *dev,
669 USBPacket *p, uint8_t ep)
670{
671 const int maxp = dev->endpoint[EP2I(ep)].max_packet_size;
672 uint8_t header[2] = { 0, 0 };
673 struct buf_packet *bulkp;
674 int count;
675
676 while ((bulkp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq)) &&
677 p->actual_length < p->iov.size && p->status == USB_RET_SUCCESS) {
678 if (bulkp->len < 2) {
679 WARNING("malformed ftdi bulk in packet\n");
680 bufp_free(dev, bulkp, ep);
681 continue;
682 }
683
684 if ((p->actual_length % maxp) == 0) {
685 usb_packet_copy(p, bulkp->data, 2);
686 memcpy(header, bulkp->data, 2);
687 } else {
688 if (bulkp->data[0] != header[0] || bulkp->data[1] != header[1]) {
689 break;
690 }
691 }
692
693 if (bulkp->offset == 0) {
694 bulkp->offset = 2;
695 }
696 count = bulkp->len - bulkp->offset;
697
698 if (count > (maxp - (p->actual_length % maxp))) {
699 count = maxp - (p->actual_length % maxp);
700 }
701 usbredir_buffered_bulk_add_data_to_packet(dev, bulkp, count, p, ep);
702 }
703}
704
705static void usbredir_buffered_bulk_in_complete(USBRedirDevice *dev,
706 USBPacket *p, uint8_t ep)
707{
708 p->status = USB_RET_SUCCESS;
709 dev->buffered_bulk_in_complete(dev, p, ep);
710 DPRINTF("bulk-token-in ep %02X status %d len %d id %"PRIu64"\n",
711 ep, p->status, p->actual_length, p->id);
712}
713
714static void usbredir_handle_buffered_bulk_in_data(USBRedirDevice *dev,
715 USBPacket *p, uint8_t ep)
716{
717
718 if (!dev->endpoint[EP2I(ep)].bulk_receiving_started) {
719 int bpt;
720 struct usb_redir_start_bulk_receiving_header start = {
721 .endpoint = ep,
722 .stream_id = 0,
723 .no_transfers = 5,
724 };
725
726 bpt = 512 + dev->endpoint[EP2I(ep)].max_packet_size - 1;
727 bpt /= dev->endpoint[EP2I(ep)].max_packet_size;
728 bpt *= dev->endpoint[EP2I(ep)].max_packet_size;
729 start.bytes_per_transfer = bpt;
730
731 usbredirparser_send_start_bulk_receiving(dev->parser, 0, &start);
732 usbredirparser_do_write(dev->parser);
733 DPRINTF("bulk receiving started bytes/transfer %u count %d ep %02X\n",
734 start.bytes_per_transfer, start.no_transfers, ep);
735 dev->endpoint[EP2I(ep)].bulk_receiving_started = 1;
736
737
738 dev->endpoint[EP2I(ep)].bufpq_target_size = 5000;
739 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
740 }
741
742 if (QTAILQ_EMPTY(&dev->endpoint[EP2I(ep)].bufpq)) {
743 DPRINTF("bulk-token-in ep %02X, no bulkp\n", ep);
744 assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL);
745 dev->endpoint[EP2I(ep)].pending_async_packet = p;
746 p->status = USB_RET_ASYNC;
747 return;
748 }
749 usbredir_buffered_bulk_in_complete(dev, p, ep);
750}
751
752static void usbredir_stop_bulk_receiving(USBRedirDevice *dev, uint8_t ep)
753{
754 struct usb_redir_stop_bulk_receiving_header stop_bulk = {
755 .endpoint = ep,
756 .stream_id = 0,
757 };
758 if (dev->endpoint[EP2I(ep)].bulk_receiving_started) {
759 usbredirparser_send_stop_bulk_receiving(dev->parser, 0, &stop_bulk);
760 DPRINTF("bulk receiving stopped ep %02X\n", ep);
761 dev->endpoint[EP2I(ep)].bulk_receiving_started = 0;
762 }
763 usbredir_free_bufpq(dev, ep);
764}
765
766static void usbredir_handle_bulk_data(USBRedirDevice *dev, USBPacket *p,
767 uint8_t ep)
768{
769 struct usb_redir_bulk_packet_header bulk_packet;
770 size_t size = usb_packet_size(p);
771 const int maxp = dev->endpoint[EP2I(ep)].max_packet_size;
772
773 if (usbredir_already_in_flight(dev, p->id)) {
774 p->status = USB_RET_ASYNC;
775 return;
776 }
777
778 if (dev->endpoint[EP2I(ep)].bulk_receiving_enabled) {
779 if (size != 0 && (size % maxp) == 0) {
780 usbredir_handle_buffered_bulk_in_data(dev, p, ep);
781 return;
782 }
783 WARNING("bulk recv invalid size %zd ep %02x, disabling\n", size, ep);
784 assert(dev->endpoint[EP2I(ep)].pending_async_packet == NULL);
785 usbredir_stop_bulk_receiving(dev, ep);
786 dev->endpoint[EP2I(ep)].bulk_receiving_enabled = 0;
787 }
788
789 DPRINTF("bulk-out ep %02X stream %u len %zd id %"PRIu64"\n",
790 ep, p->stream, size, p->id);
791
792 bulk_packet.endpoint = ep;
793 bulk_packet.length = size;
794 bulk_packet.stream_id = p->stream;
795 bulk_packet.length_high = size >> 16;
796 assert(bulk_packet.length_high == 0 ||
797 usbredirparser_peer_has_cap(dev->parser,
798 usb_redir_cap_32bits_bulk_length));
799
800 if (ep & USB_DIR_IN || size == 0) {
801 usbredirparser_send_bulk_packet(dev->parser, p->id,
802 &bulk_packet, NULL, 0);
803 } else {
804 uint8_t buf[size];
805 usb_packet_copy(p, buf, size);
806 usbredir_log_data(dev, "bulk data out:", buf, size);
807 usbredirparser_send_bulk_packet(dev->parser, p->id,
808 &bulk_packet, buf, size);
809 }
810 usbredirparser_do_write(dev->parser);
811 p->status = USB_RET_ASYNC;
812}
813
814static void usbredir_handle_interrupt_in_data(USBRedirDevice *dev,
815 USBPacket *p, uint8_t ep)
816{
817
818 struct buf_packet *intp;
819 int status, len;
820
821 if (!dev->endpoint[EP2I(ep)].interrupt_started &&
822 !dev->endpoint[EP2I(ep)].interrupt_error) {
823 struct usb_redir_start_interrupt_receiving_header start_int = {
824 .endpoint = ep,
825 };
826
827 usbredirparser_send_start_interrupt_receiving(dev->parser, 0,
828 &start_int);
829 usbredirparser_do_write(dev->parser);
830 DPRINTF("interrupt recv started ep %02X\n", ep);
831 dev->endpoint[EP2I(ep)].interrupt_started = 1;
832
833
834 dev->endpoint[EP2I(ep)].bufpq_target_size = 1000;
835 dev->endpoint[EP2I(ep)].bufpq_dropping_packets = 0;
836 }
837
838 intp = QTAILQ_FIRST(&dev->endpoint[EP2I(ep)].bufpq);
839 if (intp == NULL) {
840 DPRINTF2("interrupt-token-in ep %02X, no intp\n", ep);
841
842 status = dev->endpoint[EP2I(ep)].interrupt_error;
843 dev->endpoint[EP2I(ep)].interrupt_error = 0;
844 if (status) {
845 usbredir_handle_status(dev, p, status);
846 } else {
847 p->status = USB_RET_NAK;
848 }
849 return;
850 }
851 DPRINTF("interrupt-token-in ep %02X status %d len %d\n", ep,
852 intp->status, intp->len);
853
854 status = intp->status;
855 len = intp->len;
856 if (len > p->iov.size) {
857 ERROR("received int data is larger then packet ep %02X\n", ep);
858 len = p->iov.size;
859 status = usb_redir_babble;
860 }
861 usb_packet_copy(p, intp->data, len);
862 bufp_free(dev, intp, ep);
863 usbredir_handle_status(dev, p, status);
864}
865
866
867
868
869
870
871
872
873static void usbredir_handle_interrupt_out_data(USBRedirDevice *dev,
874 USBPacket *p, uint8_t ep)
875{
876 struct usb_redir_interrupt_packet_header interrupt_packet;
877 uint8_t buf[p->iov.size];
878
879 DPRINTF("interrupt-out ep %02X len %zd id %"PRIu64"\n", ep,
880 p->iov.size, p->id);
881
882 interrupt_packet.endpoint = ep;
883 interrupt_packet.length = p->iov.size;
884
885 usb_packet_copy(p, buf, p->iov.size);
886 usbredir_log_data(dev, "interrupt data out:", buf, p->iov.size);
887 usbredirparser_send_interrupt_packet(dev->parser, p->id,
888 &interrupt_packet, buf, p->iov.size);
889 usbredirparser_do_write(dev->parser);
890}
891
892static void usbredir_stop_interrupt_receiving(USBRedirDevice *dev,
893 uint8_t ep)
894{
895 struct usb_redir_stop_interrupt_receiving_header stop_interrupt_recv = {
896 .endpoint = ep
897 };
898 if (dev->endpoint[EP2I(ep)].interrupt_started) {
899 usbredirparser_send_stop_interrupt_receiving(dev->parser, 0,
900 &stop_interrupt_recv);
901 DPRINTF("interrupt recv stopped ep %02X\n", ep);
902 dev->endpoint[EP2I(ep)].interrupt_started = 0;
903 }
904 dev->endpoint[EP2I(ep)].interrupt_error = 0;
905 usbredir_free_bufpq(dev, ep);
906}
907
908static void usbredir_handle_data(USBDevice *udev, USBPacket *p)
909{
910 USBRedirDevice *dev = USB_REDIRECT(udev);
911 uint8_t ep;
912
913 ep = p->ep->nr;
914 if (p->pid == USB_TOKEN_IN) {
915 ep |= USB_DIR_IN;
916 }
917
918 switch (dev->endpoint[EP2I(ep)].type) {
919 case USB_ENDPOINT_XFER_CONTROL:
920 ERROR("handle_data called for control transfer on ep %02X\n", ep);
921 p->status = USB_RET_NAK;
922 break;
923 case USB_ENDPOINT_XFER_BULK:
924 if (p->state == USB_PACKET_SETUP && p->pid == USB_TOKEN_IN &&
925 p->ep->pipeline) {
926 p->status = USB_RET_ADD_TO_QUEUE;
927 break;
928 }
929 usbredir_handle_bulk_data(dev, p, ep);
930 break;
931 case USB_ENDPOINT_XFER_ISOC:
932 usbredir_handle_iso_data(dev, p, ep);
933 break;
934 case USB_ENDPOINT_XFER_INT:
935 if (ep & USB_DIR_IN) {
936 usbredir_handle_interrupt_in_data(dev, p, ep);
937 } else {
938 usbredir_handle_interrupt_out_data(dev, p, ep);
939 }
940 break;
941 default:
942 ERROR("handle_data ep %02X has unknown type %d\n", ep,
943 dev->endpoint[EP2I(ep)].type);
944 p->status = USB_RET_NAK;
945 }
946}
947
948static void usbredir_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
949{
950 if (ep->pid == USB_TOKEN_IN && ep->pipeline) {
951 usb_ep_combine_input_packets(ep);
952 }
953}
954
955static void usbredir_stop_ep(USBRedirDevice *dev, int i)
956{
957 uint8_t ep = I2EP(i);
958
959 switch (dev->endpoint[i].type) {
960 case USB_ENDPOINT_XFER_BULK:
961 if (ep & USB_DIR_IN) {
962 usbredir_stop_bulk_receiving(dev, ep);
963 }
964 break;
965 case USB_ENDPOINT_XFER_ISOC:
966 usbredir_stop_iso_stream(dev, ep);
967 break;
968 case USB_ENDPOINT_XFER_INT:
969 if (ep & USB_DIR_IN) {
970 usbredir_stop_interrupt_receiving(dev, ep);
971 }
972 break;
973 }
974 usbredir_free_bufpq(dev, ep);
975}
976
977static void usbredir_ep_stopped(USBDevice *udev, USBEndpoint *uep)
978{
979 USBRedirDevice *dev = USB_REDIRECT(udev);
980
981 usbredir_stop_ep(dev, USBEP2I(uep));
982 usbredirparser_do_write(dev->parser);
983}
984
985static void usbredir_set_config(USBRedirDevice *dev, USBPacket *p,
986 int config)
987{
988 struct usb_redir_set_configuration_header set_config;
989 int i;
990
991 DPRINTF("set config %d id %"PRIu64"\n", config, p->id);
992
993 for (i = 0; i < MAX_ENDPOINTS; i++) {
994 usbredir_stop_ep(dev, i);
995 }
996
997 set_config.configuration = config;
998 usbredirparser_send_set_configuration(dev->parser, p->id, &set_config);
999 usbredirparser_do_write(dev->parser);
1000 p->status = USB_RET_ASYNC;
1001}
1002
1003static void usbredir_get_config(USBRedirDevice *dev, USBPacket *p)
1004{
1005 DPRINTF("get config id %"PRIu64"\n", p->id);
1006
1007 usbredirparser_send_get_configuration(dev->parser, p->id);
1008 usbredirparser_do_write(dev->parser);
1009 p->status = USB_RET_ASYNC;
1010}
1011
1012static void usbredir_set_interface(USBRedirDevice *dev, USBPacket *p,
1013 int interface, int alt)
1014{
1015 struct usb_redir_set_alt_setting_header set_alt;
1016 int i;
1017
1018 DPRINTF("set interface %d alt %d id %"PRIu64"\n", interface, alt, p->id);
1019
1020 for (i = 0; i < MAX_ENDPOINTS; i++) {
1021 if (dev->endpoint[i].interface == interface) {
1022 usbredir_stop_ep(dev, i);
1023 }
1024 }
1025
1026 set_alt.interface = interface;
1027 set_alt.alt = alt;
1028 usbredirparser_send_set_alt_setting(dev->parser, p->id, &set_alt);
1029 usbredirparser_do_write(dev->parser);
1030 p->status = USB_RET_ASYNC;
1031}
1032
1033static void usbredir_get_interface(USBRedirDevice *dev, USBPacket *p,
1034 int interface)
1035{
1036 struct usb_redir_get_alt_setting_header get_alt;
1037
1038 DPRINTF("get interface %d id %"PRIu64"\n", interface, p->id);
1039
1040 get_alt.interface = interface;
1041 usbredirparser_send_get_alt_setting(dev->parser, p->id, &get_alt);
1042 usbredirparser_do_write(dev->parser);
1043 p->status = USB_RET_ASYNC;
1044}
1045
1046static void usbredir_handle_control(USBDevice *udev, USBPacket *p,
1047 int request, int value, int index, int length, uint8_t *data)
1048{
1049 USBRedirDevice *dev = USB_REDIRECT(udev);
1050 struct usb_redir_control_packet_header control_packet;
1051
1052 if (usbredir_already_in_flight(dev, p->id)) {
1053 p->status = USB_RET_ASYNC;
1054 return;
1055 }
1056
1057
1058 switch (request) {
1059 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1060 DPRINTF("set address %d\n", value);
1061 dev->dev.addr = value;
1062 return;
1063 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1064 usbredir_set_config(dev, p, value & 0xff);
1065 return;
1066 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
1067 usbredir_get_config(dev, p);
1068 return;
1069 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1070 usbredir_set_interface(dev, p, index, value);
1071 return;
1072 case InterfaceRequest | USB_REQ_GET_INTERFACE:
1073 usbredir_get_interface(dev, p, index);
1074 return;
1075 }
1076
1077
1078 DPRINTF(
1079 "ctrl-out type 0x%x req 0x%x val 0x%x index %d len %d id %"PRIu64"\n",
1080 request >> 8, request & 0xff, value, index, length, p->id);
1081
1082 control_packet.request = request & 0xFF;
1083 control_packet.requesttype = request >> 8;
1084 control_packet.endpoint = control_packet.requesttype & USB_DIR_IN;
1085 control_packet.value = value;
1086 control_packet.index = index;
1087 control_packet.length = length;
1088
1089 if (control_packet.requesttype & USB_DIR_IN) {
1090 usbredirparser_send_control_packet(dev->parser, p->id,
1091 &control_packet, NULL, 0);
1092 } else {
1093 usbredir_log_data(dev, "ctrl data out:", data, length);
1094 usbredirparser_send_control_packet(dev->parser, p->id,
1095 &control_packet, data, length);
1096 }
1097 usbredirparser_do_write(dev->parser);
1098 p->status = USB_RET_ASYNC;
1099}
1100
1101static int usbredir_alloc_streams(USBDevice *udev, USBEndpoint **eps,
1102 int nr_eps, int streams)
1103{
1104 USBRedirDevice *dev = USB_REDIRECT(udev);
1105#if USBREDIR_VERSION >= 0x000700
1106 struct usb_redir_alloc_bulk_streams_header alloc_streams;
1107 int i;
1108
1109 if (!usbredirparser_peer_has_cap(dev->parser,
1110 usb_redir_cap_bulk_streams)) {
1111 ERROR("peer does not support streams\n");
1112 goto reject;
1113 }
1114
1115 if (streams == 0) {
1116 ERROR("request to allocate 0 streams\n");
1117 return -1;
1118 }
1119
1120 alloc_streams.no_streams = streams;
1121 alloc_streams.endpoints = 0;
1122 for (i = 0; i < nr_eps; i++) {
1123 alloc_streams.endpoints |= 1 << USBEP2I(eps[i]);
1124 }
1125 usbredirparser_send_alloc_bulk_streams(dev->parser, 0, &alloc_streams);
1126 usbredirparser_do_write(dev->parser);
1127
1128 return 0;
1129#else
1130 ERROR("usbredir_alloc_streams not implemented\n");
1131 goto reject;
1132#endif
1133reject:
1134 ERROR("streams are not available, disconnecting\n");
1135 qemu_bh_schedule(dev->device_reject_bh);
1136 return -1;
1137}
1138
1139static void usbredir_free_streams(USBDevice *udev, USBEndpoint **eps,
1140 int nr_eps)
1141{
1142#if USBREDIR_VERSION >= 0x000700
1143 USBRedirDevice *dev = USB_REDIRECT(udev);
1144 struct usb_redir_free_bulk_streams_header free_streams;
1145 int i;
1146
1147 if (!usbredirparser_peer_has_cap(dev->parser,
1148 usb_redir_cap_bulk_streams)) {
1149 return;
1150 }
1151
1152 free_streams.endpoints = 0;
1153 for (i = 0; i < nr_eps; i++) {
1154 free_streams.endpoints |= 1 << USBEP2I(eps[i]);
1155 }
1156 usbredirparser_send_free_bulk_streams(dev->parser, 0, &free_streams);
1157 usbredirparser_do_write(dev->parser);
1158#endif
1159}
1160
1161
1162
1163
1164
1165
1166
1167
1168static void usbredir_chardev_close_bh(void *opaque)
1169{
1170 USBRedirDevice *dev = opaque;
1171
1172 qemu_bh_cancel(dev->device_reject_bh);
1173 usbredir_device_disconnect(dev);
1174
1175 if (dev->parser) {
1176 DPRINTF("destroying usbredirparser\n");
1177 usbredirparser_destroy(dev->parser);
1178 dev->parser = NULL;
1179 }
1180 if (dev->watch) {
1181 g_source_remove(dev->watch);
1182 dev->watch = 0;
1183 }
1184}
1185
1186static void usbredir_create_parser(USBRedirDevice *dev)
1187{
1188 uint32_t caps[USB_REDIR_CAPS_SIZE] = { 0, };
1189 int flags = 0;
1190
1191 DPRINTF("creating usbredirparser\n");
1192
1193 dev->parser = qemu_oom_check(usbredirparser_create());
1194 dev->parser->priv = dev;
1195 dev->parser->log_func = usbredir_log;
1196 dev->parser->read_func = usbredir_read;
1197 dev->parser->write_func = usbredir_write;
1198 dev->parser->hello_func = usbredir_hello;
1199 dev->parser->device_connect_func = usbredir_device_connect;
1200 dev->parser->device_disconnect_func = usbredir_device_disconnect;
1201 dev->parser->interface_info_func = usbredir_interface_info;
1202 dev->parser->ep_info_func = usbredir_ep_info;
1203 dev->parser->configuration_status_func = usbredir_configuration_status;
1204 dev->parser->alt_setting_status_func = usbredir_alt_setting_status;
1205 dev->parser->iso_stream_status_func = usbredir_iso_stream_status;
1206 dev->parser->interrupt_receiving_status_func =
1207 usbredir_interrupt_receiving_status;
1208 dev->parser->bulk_streams_status_func = usbredir_bulk_streams_status;
1209 dev->parser->bulk_receiving_status_func = usbredir_bulk_receiving_status;
1210 dev->parser->control_packet_func = usbredir_control_packet;
1211 dev->parser->bulk_packet_func = usbredir_bulk_packet;
1212 dev->parser->iso_packet_func = usbredir_iso_packet;
1213 dev->parser->interrupt_packet_func = usbredir_interrupt_packet;
1214 dev->parser->buffered_bulk_packet_func = usbredir_buffered_bulk_packet;
1215 dev->read_buf = NULL;
1216 dev->read_buf_size = 0;
1217
1218 usbredirparser_caps_set_cap(caps, usb_redir_cap_connect_device_version);
1219 usbredirparser_caps_set_cap(caps, usb_redir_cap_filter);
1220 usbredirparser_caps_set_cap(caps, usb_redir_cap_ep_info_max_packet_size);
1221 usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids);
1222 usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length);
1223 usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_receiving);
1224#if USBREDIR_VERSION >= 0x000700
1225 if (dev->enable_streams) {
1226 usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_streams);
1227 }
1228#endif
1229
1230 if (runstate_check(RUN_STATE_INMIGRATE)) {
1231 flags |= usbredirparser_fl_no_hello;
1232 }
1233 usbredirparser_init(dev->parser, VERSION, caps, USB_REDIR_CAPS_SIZE,
1234 flags);
1235 usbredirparser_do_write(dev->parser);
1236}
1237
1238static void usbredir_reject_device(USBRedirDevice *dev)
1239{
1240 usbredir_device_disconnect(dev);
1241 if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter)) {
1242 usbredirparser_send_filter_reject(dev->parser);
1243 usbredirparser_do_write(dev->parser);
1244 }
1245}
1246
1247
1248
1249
1250
1251static void usbredir_device_reject_bh(void *opaque)
1252{
1253 USBRedirDevice *dev = opaque;
1254
1255 usbredir_reject_device(dev);
1256}
1257
1258static void usbredir_do_attach(void *opaque)
1259{
1260 USBRedirDevice *dev = opaque;
1261 Error *local_err = NULL;
1262
1263
1264 if ((dev->dev.port->speedmask & USB_SPEED_MASK_SUPER) && !(
1265 usbredirparser_peer_has_cap(dev->parser,
1266 usb_redir_cap_ep_info_max_packet_size) &&
1267 usbredirparser_peer_has_cap(dev->parser,
1268 usb_redir_cap_32bits_bulk_length) &&
1269 usbredirparser_peer_has_cap(dev->parser,
1270 usb_redir_cap_64bits_ids))) {
1271 ERROR("usb-redir-host lacks capabilities needed for use with XHCI\n");
1272 usbredir_reject_device(dev);
1273 return;
1274 }
1275
1276 usb_device_attach(&dev->dev, &local_err);
1277 if (local_err) {
1278 error_report_err(local_err);
1279 WARNING("rejecting device due to speed mismatch\n");
1280 usbredir_reject_device(dev);
1281 }
1282}
1283
1284
1285
1286
1287
1288static int usbredir_chardev_can_read(void *opaque)
1289{
1290 USBRedirDevice *dev = opaque;
1291
1292 if (!dev->parser) {
1293 WARNING("chardev_can_read called on non open chardev!\n");
1294 return 0;
1295 }
1296
1297
1298 if (!runstate_check(RUN_STATE_RUNNING)) {
1299 return 0;
1300 }
1301
1302
1303 return 1 * MiB;
1304}
1305
1306static void usbredir_chardev_read(void *opaque, const uint8_t *buf, int size)
1307{
1308 USBRedirDevice *dev = opaque;
1309
1310
1311 assert(dev->read_buf == NULL);
1312
1313 dev->read_buf = buf;
1314 dev->read_buf_size = size;
1315
1316 usbredirparser_do_read(dev->parser);
1317
1318 usbredirparser_do_write(dev->parser);
1319}
1320
1321static void usbredir_chardev_event(void *opaque, int event)
1322{
1323 USBRedirDevice *dev = opaque;
1324
1325 switch (event) {
1326 case CHR_EVENT_OPENED:
1327 DPRINTF("chardev open\n");
1328
1329 usbredir_chardev_close_bh(dev);
1330 qemu_bh_cancel(dev->chardev_close_bh);
1331 usbredir_create_parser(dev);
1332 break;
1333 case CHR_EVENT_CLOSED:
1334 DPRINTF("chardev close\n");
1335 qemu_bh_schedule(dev->chardev_close_bh);
1336 break;
1337 }
1338}
1339
1340
1341
1342
1343
1344static void usbredir_vm_state_change(void *priv, int running, RunState state)
1345{
1346 USBRedirDevice *dev = priv;
1347
1348 if (state == RUN_STATE_RUNNING && dev->parser != NULL) {
1349 usbredirparser_do_write(dev->parser);
1350 }
1351}
1352
1353static void usbredir_init_endpoints(USBRedirDevice *dev)
1354{
1355 int i;
1356
1357 usb_ep_init(&dev->dev);
1358 memset(dev->endpoint, 0, sizeof(dev->endpoint));
1359 for (i = 0; i < MAX_ENDPOINTS; i++) {
1360 dev->endpoint[i].dev = dev;
1361 QTAILQ_INIT(&dev->endpoint[i].bufpq);
1362 }
1363}
1364
1365static void usbredir_realize(USBDevice *udev, Error **errp)
1366{
1367 USBRedirDevice *dev = USB_REDIRECT(udev);
1368 int i;
1369
1370 if (!qemu_chr_fe_backend_connected(&dev->cs)) {
1371 error_setg(errp, QERR_MISSING_PARAMETER, "chardev");
1372 return;
1373 }
1374
1375 if (dev->filter_str) {
1376 i = usbredirfilter_string_to_rules(dev->filter_str, ":", "|",
1377 &dev->filter_rules,
1378 &dev->filter_rules_count);
1379 if (i) {
1380 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "filter",
1381 "a usb device filter string");
1382 return;
1383 }
1384 }
1385
1386 dev->chardev_close_bh = qemu_bh_new(usbredir_chardev_close_bh, dev);
1387 dev->device_reject_bh = qemu_bh_new(usbredir_device_reject_bh, dev);
1388 dev->attach_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, usbredir_do_attach, dev);
1389
1390 packet_id_queue_init(&dev->cancelled, dev, "cancelled");
1391 packet_id_queue_init(&dev->already_in_flight, dev, "already-in-flight");
1392 usbredir_init_endpoints(dev);
1393
1394
1395 udev->auto_attach = 0;
1396
1397
1398 dev->compatible_speedmask = USB_SPEED_MASK_FULL | USB_SPEED_MASK_HIGH;
1399
1400
1401 qemu_chr_fe_set_handlers(&dev->cs, usbredir_chardev_can_read,
1402 usbredir_chardev_read, usbredir_chardev_event,
1403 NULL, dev, NULL, true);
1404
1405 dev->vmstate =
1406 qemu_add_vm_change_state_handler(usbredir_vm_state_change, dev);
1407}
1408
1409static void usbredir_cleanup_device_queues(USBRedirDevice *dev)
1410{
1411 int i;
1412
1413 packet_id_queue_empty(&dev->cancelled);
1414 packet_id_queue_empty(&dev->already_in_flight);
1415 for (i = 0; i < MAX_ENDPOINTS; i++) {
1416 usbredir_free_bufpq(dev, I2EP(i));
1417 }
1418}
1419
1420static void usbredir_unrealize(USBDevice *udev, Error **errp)
1421{
1422 USBRedirDevice *dev = USB_REDIRECT(udev);
1423
1424 qemu_chr_fe_deinit(&dev->cs, true);
1425
1426
1427 qemu_bh_delete(dev->chardev_close_bh);
1428 qemu_bh_delete(dev->device_reject_bh);
1429
1430 timer_del(dev->attach_timer);
1431 timer_free(dev->attach_timer);
1432
1433 usbredir_cleanup_device_queues(dev);
1434
1435 if (dev->parser) {
1436 usbredirparser_destroy(dev->parser);
1437 }
1438 if (dev->watch) {
1439 g_source_remove(dev->watch);
1440 }
1441
1442 free(dev->filter_rules);
1443 qemu_del_vm_change_state_handler(dev->vmstate);
1444}
1445
1446static int usbredir_check_filter(USBRedirDevice *dev)
1447{
1448 if (dev->interface_info.interface_count == NO_INTERFACE_INFO) {
1449 ERROR("No interface info for device\n");
1450 goto error;
1451 }
1452
1453 if (dev->filter_rules) {
1454 if (!usbredirparser_peer_has_cap(dev->parser,
1455 usb_redir_cap_connect_device_version)) {
1456 ERROR("Device filter specified and peer does not have the "
1457 "connect_device_version capability\n");
1458 goto error;
1459 }
1460
1461 if (usbredirfilter_check(
1462 dev->filter_rules,
1463 dev->filter_rules_count,
1464 dev->device_info.device_class,
1465 dev->device_info.device_subclass,
1466 dev->device_info.device_protocol,
1467 dev->interface_info.interface_class,
1468 dev->interface_info.interface_subclass,
1469 dev->interface_info.interface_protocol,
1470 dev->interface_info.interface_count,
1471 dev->device_info.vendor_id,
1472 dev->device_info.product_id,
1473 dev->device_info.device_version_bcd,
1474 0) != 0) {
1475 goto error;
1476 }
1477 }
1478
1479 return 0;
1480
1481error:
1482 usbredir_reject_device(dev);
1483 return -1;
1484}
1485
1486static void usbredir_check_bulk_receiving(USBRedirDevice *dev)
1487{
1488 int i, j, quirks;
1489
1490 if (!usbredirparser_peer_has_cap(dev->parser,
1491 usb_redir_cap_bulk_receiving)) {
1492 return;
1493 }
1494
1495 for (i = EP2I(USB_DIR_IN); i < MAX_ENDPOINTS; i++) {
1496 dev->endpoint[i].bulk_receiving_enabled = 0;
1497 }
1498 for (i = 0; i < dev->interface_info.interface_count; i++) {
1499 quirks = usb_get_quirks(dev->device_info.vendor_id,
1500 dev->device_info.product_id,
1501 dev->interface_info.interface_class[i],
1502 dev->interface_info.interface_subclass[i],
1503 dev->interface_info.interface_protocol[i]);
1504 if (!(quirks & USB_QUIRK_BUFFER_BULK_IN)) {
1505 continue;
1506 }
1507 if (quirks & USB_QUIRK_IS_FTDI) {
1508 dev->buffered_bulk_in_complete =
1509 usbredir_buffered_bulk_in_complete_ftdi;
1510 } else {
1511 dev->buffered_bulk_in_complete =
1512 usbredir_buffered_bulk_in_complete_raw;
1513 }
1514
1515 for (j = EP2I(USB_DIR_IN); j < MAX_ENDPOINTS; j++) {
1516 if (dev->endpoint[j].interface ==
1517 dev->interface_info.interface[i] &&
1518 dev->endpoint[j].type == USB_ENDPOINT_XFER_BULK &&
1519 dev->endpoint[j].max_packet_size != 0) {
1520 dev->endpoint[j].bulk_receiving_enabled = 1;
1521
1522
1523
1524
1525 I2USBEP(dev, j)->pipeline = false;
1526 break;
1527 }
1528 }
1529 }
1530}
1531
1532
1533
1534
1535
1536static void usbredir_handle_status(USBRedirDevice *dev, USBPacket *p,
1537 int status)
1538{
1539 switch (status) {
1540 case usb_redir_success:
1541 p->status = USB_RET_SUCCESS;
1542 break;
1543 case usb_redir_stall:
1544 p->status = USB_RET_STALL;
1545 break;
1546 case usb_redir_cancelled:
1547
1548
1549
1550
1551 p->status = USB_RET_IOERROR;
1552 break;
1553 case usb_redir_inval:
1554 WARNING("got invalid param error from usb-host?\n");
1555 p->status = USB_RET_IOERROR;
1556 break;
1557 case usb_redir_babble:
1558 p->status = USB_RET_BABBLE;
1559 break;
1560 case usb_redir_ioerror:
1561 case usb_redir_timeout:
1562 default:
1563 p->status = USB_RET_IOERROR;
1564 }
1565}
1566
1567static void usbredir_hello(void *priv, struct usb_redir_hello_header *h)
1568{
1569 USBRedirDevice *dev = priv;
1570
1571
1572 if (usbredirparser_peer_has_cap(dev->parser, usb_redir_cap_filter) &&
1573 dev->filter_rules) {
1574 usbredirparser_send_filter_filter(dev->parser, dev->filter_rules,
1575 dev->filter_rules_count);
1576 usbredirparser_do_write(dev->parser);
1577 }
1578}
1579
1580static void usbredir_device_connect(void *priv,
1581 struct usb_redir_device_connect_header *device_connect)
1582{
1583 USBRedirDevice *dev = priv;
1584 const char *speed;
1585
1586 if (timer_pending(dev->attach_timer) || dev->dev.attached) {
1587 ERROR("Received device connect while already connected\n");
1588 return;
1589 }
1590
1591 switch (device_connect->speed) {
1592 case usb_redir_speed_low:
1593 speed = "low speed";
1594 dev->dev.speed = USB_SPEED_LOW;
1595 dev->compatible_speedmask &= ~USB_SPEED_MASK_FULL;
1596 dev->compatible_speedmask &= ~USB_SPEED_MASK_HIGH;
1597 break;
1598 case usb_redir_speed_full:
1599 speed = "full speed";
1600 dev->dev.speed = USB_SPEED_FULL;
1601 dev->compatible_speedmask &= ~USB_SPEED_MASK_HIGH;
1602 break;
1603 case usb_redir_speed_high:
1604 speed = "high speed";
1605 dev->dev.speed = USB_SPEED_HIGH;
1606 break;
1607 case usb_redir_speed_super:
1608 speed = "super speed";
1609 dev->dev.speed = USB_SPEED_SUPER;
1610 break;
1611 default:
1612 speed = "unknown speed";
1613 dev->dev.speed = USB_SPEED_FULL;
1614 }
1615
1616 if (usbredirparser_peer_has_cap(dev->parser,
1617 usb_redir_cap_connect_device_version)) {
1618 INFO("attaching %s device %04x:%04x version %d.%d class %02x\n",
1619 speed, device_connect->vendor_id, device_connect->product_id,
1620 ((device_connect->device_version_bcd & 0xf000) >> 12) * 10 +
1621 ((device_connect->device_version_bcd & 0x0f00) >> 8),
1622 ((device_connect->device_version_bcd & 0x00f0) >> 4) * 10 +
1623 ((device_connect->device_version_bcd & 0x000f) >> 0),
1624 device_connect->device_class);
1625 } else {
1626 INFO("attaching %s device %04x:%04x class %02x\n", speed,
1627 device_connect->vendor_id, device_connect->product_id,
1628 device_connect->device_class);
1629 }
1630
1631 dev->dev.speedmask = (1 << dev->dev.speed) | dev->compatible_speedmask;
1632 dev->device_info = *device_connect;
1633
1634 if (usbredir_check_filter(dev)) {
1635 WARNING("Device %04x:%04x rejected by device filter, not attaching\n",
1636 device_connect->vendor_id, device_connect->product_id);
1637 return;
1638 }
1639
1640 usbredir_check_bulk_receiving(dev);
1641 timer_mod(dev->attach_timer, dev->next_attach_time);
1642}
1643
1644static void usbredir_device_disconnect(void *priv)
1645{
1646 USBRedirDevice *dev = priv;
1647
1648
1649 timer_del(dev->attach_timer);
1650
1651 if (dev->dev.attached) {
1652 DPRINTF("detaching device\n");
1653 usb_device_detach(&dev->dev);
1654
1655
1656
1657
1658 dev->next_attach_time = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + 200;
1659 }
1660
1661
1662 usbredir_cleanup_device_queues(dev);
1663 usbredir_init_endpoints(dev);
1664 dev->interface_info.interface_count = NO_INTERFACE_INFO;
1665 dev->dev.addr = 0;
1666 dev->dev.speed = 0;
1667 dev->compatible_speedmask = USB_SPEED_MASK_FULL | USB_SPEED_MASK_HIGH;
1668}
1669
1670static void usbredir_interface_info(void *priv,
1671 struct usb_redir_interface_info_header *interface_info)
1672{
1673 USBRedirDevice *dev = priv;
1674
1675 dev->interface_info = *interface_info;
1676
1677
1678
1679
1680
1681 if (timer_pending(dev->attach_timer) || dev->dev.attached) {
1682 usbredir_check_bulk_receiving(dev);
1683 if (usbredir_check_filter(dev)) {
1684 ERROR("Device no longer matches filter after interface info "
1685 "change, disconnecting!\n");
1686 }
1687 }
1688}
1689
1690static void usbredir_mark_speed_incompatible(USBRedirDevice *dev, int speed)
1691{
1692 dev->compatible_speedmask &= ~(1 << speed);
1693 dev->dev.speedmask = (1 << dev->dev.speed) | dev->compatible_speedmask;
1694}
1695
1696static void usbredir_set_pipeline(USBRedirDevice *dev, struct USBEndpoint *uep)
1697{
1698 if (uep->type != USB_ENDPOINT_XFER_BULK) {
1699 return;
1700 }
1701 if (uep->pid == USB_TOKEN_OUT) {
1702 uep->pipeline = true;
1703 }
1704 if (uep->pid == USB_TOKEN_IN && uep->max_packet_size != 0 &&
1705 usbredirparser_peer_has_cap(dev->parser,
1706 usb_redir_cap_32bits_bulk_length)) {
1707 uep->pipeline = true;
1708 }
1709}
1710
1711static void usbredir_setup_usb_eps(USBRedirDevice *dev)
1712{
1713 struct USBEndpoint *usb_ep;
1714 int i;
1715
1716 for (i = 0; i < MAX_ENDPOINTS; i++) {
1717 usb_ep = I2USBEP(dev, i);
1718 usb_ep->type = dev->endpoint[i].type;
1719 usb_ep->ifnum = dev->endpoint[i].interface;
1720 usb_ep->max_packet_size = dev->endpoint[i].max_packet_size;
1721 usb_ep->max_streams = dev->endpoint[i].max_streams;
1722 usbredir_set_pipeline(dev, usb_ep);
1723 }
1724}
1725
1726static void usbredir_ep_info(void *priv,
1727 struct usb_redir_ep_info_header *ep_info)
1728{
1729 USBRedirDevice *dev = priv;
1730 int i;
1731
1732 assert(dev != NULL);
1733 for (i = 0; i < MAX_ENDPOINTS; i++) {
1734 dev->endpoint[i].type = ep_info->type[i];
1735 dev->endpoint[i].interval = ep_info->interval[i];
1736 dev->endpoint[i].interface = ep_info->interface[i];
1737 if (usbredirparser_peer_has_cap(dev->parser,
1738 usb_redir_cap_ep_info_max_packet_size)) {
1739 dev->endpoint[i].max_packet_size = ep_info->max_packet_size[i];
1740 }
1741#if USBREDIR_VERSION >= 0x000700
1742 if (usbredirparser_peer_has_cap(dev->parser,
1743 usb_redir_cap_bulk_streams)) {
1744 dev->endpoint[i].max_streams = ep_info->max_streams[i];
1745 }
1746#endif
1747 switch (dev->endpoint[i].type) {
1748 case usb_redir_type_invalid:
1749 break;
1750 case usb_redir_type_iso:
1751 usbredir_mark_speed_incompatible(dev, USB_SPEED_FULL);
1752 usbredir_mark_speed_incompatible(dev, USB_SPEED_HIGH);
1753
1754 case usb_redir_type_interrupt:
1755 if (!usbredirparser_peer_has_cap(dev->parser,
1756 usb_redir_cap_ep_info_max_packet_size) ||
1757 ep_info->max_packet_size[i] > 64) {
1758 usbredir_mark_speed_incompatible(dev, USB_SPEED_FULL);
1759 }
1760 if (!usbredirparser_peer_has_cap(dev->parser,
1761 usb_redir_cap_ep_info_max_packet_size) ||
1762 ep_info->max_packet_size[i] > 1024) {
1763 usbredir_mark_speed_incompatible(dev, USB_SPEED_HIGH);
1764 }
1765 if (dev->endpoint[i].interval == 0) {
1766 ERROR("Received 0 interval for isoc or irq endpoint\n");
1767 usbredir_reject_device(dev);
1768 return;
1769 }
1770
1771 case usb_redir_type_control:
1772 case usb_redir_type_bulk:
1773 DPRINTF("ep: %02X type: %d interface: %d\n", I2EP(i),
1774 dev->endpoint[i].type, dev->endpoint[i].interface);
1775 break;
1776 default:
1777 ERROR("Received invalid endpoint type\n");
1778 usbredir_reject_device(dev);
1779 return;
1780 }
1781 }
1782
1783 if (dev->dev.attached &&
1784 !(dev->dev.port->speedmask & dev->dev.speedmask)) {
1785 ERROR("Device no longer matches speed after endpoint info change, "
1786 "disconnecting!\n");
1787 usbredir_reject_device(dev);
1788 return;
1789 }
1790 usbredir_setup_usb_eps(dev);
1791 usbredir_check_bulk_receiving(dev);
1792}
1793
1794static void usbredir_configuration_status(void *priv, uint64_t id,
1795 struct usb_redir_configuration_status_header *config_status)
1796{
1797 USBRedirDevice *dev = priv;
1798 USBPacket *p;
1799
1800 DPRINTF("set config status %d config %d id %"PRIu64"\n",
1801 config_status->status, config_status->configuration, id);
1802
1803 p = usbredir_find_packet_by_id(dev, 0, id);
1804 if (p) {
1805 if (dev->dev.setup_buf[0] & USB_DIR_IN) {
1806 dev->dev.data_buf[0] = config_status->configuration;
1807 p->actual_length = 1;
1808 }
1809 usbredir_handle_status(dev, p, config_status->status);
1810 usb_generic_async_ctrl_complete(&dev->dev, p);
1811 }
1812}
1813
1814static void usbredir_alt_setting_status(void *priv, uint64_t id,
1815 struct usb_redir_alt_setting_status_header *alt_setting_status)
1816{
1817 USBRedirDevice *dev = priv;
1818 USBPacket *p;
1819
1820 DPRINTF("alt status %d intf %d alt %d id: %"PRIu64"\n",
1821 alt_setting_status->status, alt_setting_status->interface,
1822 alt_setting_status->alt, id);
1823
1824 p = usbredir_find_packet_by_id(dev, 0, id);
1825 if (p) {
1826 if (dev->dev.setup_buf[0] & USB_DIR_IN) {
1827 dev->dev.data_buf[0] = alt_setting_status->alt;
1828 p->actual_length = 1;
1829 }
1830 usbredir_handle_status(dev, p, alt_setting_status->status);
1831 usb_generic_async_ctrl_complete(&dev->dev, p);
1832 }
1833}
1834
1835static void usbredir_iso_stream_status(void *priv, uint64_t id,
1836 struct usb_redir_iso_stream_status_header *iso_stream_status)
1837{
1838 USBRedirDevice *dev = priv;
1839 uint8_t ep = iso_stream_status->endpoint;
1840
1841 DPRINTF("iso status %d ep %02X id %"PRIu64"\n", iso_stream_status->status,
1842 ep, id);
1843
1844 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].iso_started) {
1845 return;
1846 }
1847
1848 dev->endpoint[EP2I(ep)].iso_error = iso_stream_status->status;
1849 if (iso_stream_status->status == usb_redir_stall) {
1850 DPRINTF("iso stream stopped by peer ep %02X\n", ep);
1851 dev->endpoint[EP2I(ep)].iso_started = 0;
1852 }
1853}
1854
1855static void usbredir_interrupt_receiving_status(void *priv, uint64_t id,
1856 struct usb_redir_interrupt_receiving_status_header
1857 *interrupt_receiving_status)
1858{
1859 USBRedirDevice *dev = priv;
1860 uint8_t ep = interrupt_receiving_status->endpoint;
1861
1862 DPRINTF("interrupt recv status %d ep %02X id %"PRIu64"\n",
1863 interrupt_receiving_status->status, ep, id);
1864
1865 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].interrupt_started) {
1866 return;
1867 }
1868
1869 dev->endpoint[EP2I(ep)].interrupt_error =
1870 interrupt_receiving_status->status;
1871 if (interrupt_receiving_status->status == usb_redir_stall) {
1872 DPRINTF("interrupt receiving stopped by peer ep %02X\n", ep);
1873 dev->endpoint[EP2I(ep)].interrupt_started = 0;
1874 }
1875}
1876
1877static void usbredir_bulk_streams_status(void *priv, uint64_t id,
1878 struct usb_redir_bulk_streams_status_header *bulk_streams_status)
1879{
1880#if USBREDIR_VERSION >= 0x000700
1881 USBRedirDevice *dev = priv;
1882
1883 if (bulk_streams_status->status == usb_redir_success) {
1884 DPRINTF("bulk streams status %d eps %08x\n",
1885 bulk_streams_status->status, bulk_streams_status->endpoints);
1886 } else {
1887 ERROR("bulk streams %s failed status %d eps %08x\n",
1888 (bulk_streams_status->no_streams == 0) ? "free" : "alloc",
1889 bulk_streams_status->status, bulk_streams_status->endpoints);
1890 ERROR("usb-redir-host does not provide streams, disconnecting\n");
1891 usbredir_reject_device(dev);
1892 }
1893#endif
1894}
1895
1896static void usbredir_bulk_receiving_status(void *priv, uint64_t id,
1897 struct usb_redir_bulk_receiving_status_header *bulk_receiving_status)
1898{
1899 USBRedirDevice *dev = priv;
1900 uint8_t ep = bulk_receiving_status->endpoint;
1901
1902 DPRINTF("bulk recv status %d ep %02X id %"PRIu64"\n",
1903 bulk_receiving_status->status, ep, id);
1904
1905 if (!dev->dev.attached || !dev->endpoint[EP2I(ep)].bulk_receiving_started) {
1906 return;
1907 }
1908
1909 if (bulk_receiving_status->status == usb_redir_stall) {
1910 DPRINTF("bulk receiving stopped by peer ep %02X\n", ep);
1911 dev->endpoint[EP2I(ep)].bulk_receiving_started = 0;
1912 }
1913}
1914
1915static void usbredir_control_packet(void *priv, uint64_t id,
1916 struct usb_redir_control_packet_header *control_packet,
1917 uint8_t *data, int data_len)
1918{
1919 USBRedirDevice *dev = priv;
1920 USBPacket *p;
1921 int len = control_packet->length;
1922
1923 DPRINTF("ctrl-in status %d len %d id %"PRIu64"\n", control_packet->status,
1924 len, id);
1925
1926
1927
1928 if (dev->dev.speed == USB_SPEED_SUPER &&
1929 !((dev->dev.port->speedmask & USB_SPEED_MASK_SUPER)) &&
1930 control_packet->requesttype == 0x80 &&
1931 control_packet->request == 6 &&
1932 control_packet->value == 0x100 && control_packet->index == 0 &&
1933 data_len >= 18 && data[7] == 9) {
1934 data[7] = 64;
1935 }
1936
1937 p = usbredir_find_packet_by_id(dev, 0, id);
1938 if (p) {
1939 usbredir_handle_status(dev, p, control_packet->status);
1940 if (data_len > 0) {
1941 usbredir_log_data(dev, "ctrl data in:", data, data_len);
1942 if (data_len > sizeof(dev->dev.data_buf)) {
1943 ERROR("ctrl buffer too small (%d > %zu)\n",
1944 data_len, sizeof(dev->dev.data_buf));
1945 p->status = USB_RET_STALL;
1946 data_len = len = sizeof(dev->dev.data_buf);
1947 }
1948 memcpy(dev->dev.data_buf, data, data_len);
1949 }
1950 p->actual_length = len;
1951 usb_generic_async_ctrl_complete(&dev->dev, p);
1952 }
1953 free(data);
1954}
1955
1956static void usbredir_bulk_packet(void *priv, uint64_t id,
1957 struct usb_redir_bulk_packet_header *bulk_packet,
1958 uint8_t *data, int data_len)
1959{
1960 USBRedirDevice *dev = priv;
1961 uint8_t ep = bulk_packet->endpoint;
1962 int len = (bulk_packet->length_high << 16) | bulk_packet->length;
1963 USBPacket *p;
1964
1965 DPRINTF("bulk-in status %d ep %02X stream %u len %d id %"PRIu64"\n",
1966 bulk_packet->status, ep, bulk_packet->stream_id, len, id);
1967
1968 p = usbredir_find_packet_by_id(dev, ep, id);
1969 if (p) {
1970 size_t size = usb_packet_size(p);
1971 usbredir_handle_status(dev, p, bulk_packet->status);
1972 if (data_len > 0) {
1973 usbredir_log_data(dev, "bulk data in:", data, data_len);
1974 if (data_len > size) {
1975 ERROR("bulk got more data then requested (%d > %zd)\n",
1976 data_len, p->iov.size);
1977 p->status = USB_RET_BABBLE;
1978 data_len = len = size;
1979 }
1980 usb_packet_copy(p, data, data_len);
1981 }
1982 p->actual_length = len;
1983 if (p->pid == USB_TOKEN_IN && p->ep->pipeline) {
1984 usb_combined_input_packet_complete(&dev->dev, p);
1985 } else {
1986 usb_packet_complete(&dev->dev, p);
1987 }
1988 }
1989 free(data);
1990}
1991
1992static void usbredir_iso_packet(void *priv, uint64_t id,
1993 struct usb_redir_iso_packet_header *iso_packet,
1994 uint8_t *data, int data_len)
1995{
1996 USBRedirDevice *dev = priv;
1997 uint8_t ep = iso_packet->endpoint;
1998
1999 DPRINTF2("iso-in status %d ep %02X len %d id %"PRIu64"\n",
2000 iso_packet->status, ep, data_len, id);
2001
2002 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_ISOC) {
2003 ERROR("received iso packet for non iso endpoint %02X\n", ep);
2004 free(data);
2005 return;
2006 }
2007
2008 if (dev->endpoint[EP2I(ep)].iso_started == 0) {
2009 DPRINTF("received iso packet for non started stream ep %02X\n", ep);
2010 free(data);
2011 return;
2012 }
2013
2014
2015 bufp_alloc(dev, data, data_len, iso_packet->status, ep, data);
2016}
2017
2018static void usbredir_interrupt_packet(void *priv, uint64_t id,
2019 struct usb_redir_interrupt_packet_header *interrupt_packet,
2020 uint8_t *data, int data_len)
2021{
2022 USBRedirDevice *dev = priv;
2023 uint8_t ep = interrupt_packet->endpoint;
2024
2025 DPRINTF("interrupt-in status %d ep %02X len %d id %"PRIu64"\n",
2026 interrupt_packet->status, ep, data_len, id);
2027
2028 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_INT) {
2029 ERROR("received int packet for non interrupt endpoint %02X\n", ep);
2030 free(data);
2031 return;
2032 }
2033
2034 if (ep & USB_DIR_IN) {
2035 bool q_was_empty;
2036
2037 if (dev->endpoint[EP2I(ep)].interrupt_started == 0) {
2038 DPRINTF("received int packet while not started ep %02X\n", ep);
2039 free(data);
2040 return;
2041 }
2042
2043 q_was_empty = QTAILQ_EMPTY(&dev->endpoint[EP2I(ep)].bufpq);
2044
2045
2046 bufp_alloc(dev, data, data_len, interrupt_packet->status, ep, data);
2047
2048 if (q_was_empty) {
2049 usb_wakeup(usb_ep_get(&dev->dev, USB_TOKEN_IN, ep & 0x0f), 0);
2050 }
2051 } else {
2052
2053
2054
2055
2056 if (interrupt_packet->status) {
2057 WARNING("interrupt output failed status %d ep %02X id %"PRIu64"\n",
2058 interrupt_packet->status, ep, id);
2059 }
2060 }
2061}
2062
2063static void usbredir_buffered_bulk_packet(void *priv, uint64_t id,
2064 struct usb_redir_buffered_bulk_packet_header *buffered_bulk_packet,
2065 uint8_t *data, int data_len)
2066{
2067 USBRedirDevice *dev = priv;
2068 uint8_t status, ep = buffered_bulk_packet->endpoint;
2069 void *free_on_destroy;
2070 int i, len;
2071
2072 DPRINTF("buffered-bulk-in status %d ep %02X len %d id %"PRIu64"\n",
2073 buffered_bulk_packet->status, ep, data_len, id);
2074
2075 if (dev->endpoint[EP2I(ep)].type != USB_ENDPOINT_XFER_BULK) {
2076 ERROR("received buffered-bulk packet for non bulk ep %02X\n", ep);
2077 free(data);
2078 return;
2079 }
2080
2081 if (dev->endpoint[EP2I(ep)].bulk_receiving_started == 0) {
2082 DPRINTF("received buffered-bulk packet on not started ep %02X\n", ep);
2083 free(data);
2084 return;
2085 }
2086
2087
2088 len = dev->endpoint[EP2I(ep)].max_packet_size;
2089 status = usb_redir_success;
2090 free_on_destroy = NULL;
2091 for (i = 0; i < data_len; i += len) {
2092 int r;
2093 if (len >= (data_len - i)) {
2094 len = data_len - i;
2095 status = buffered_bulk_packet->status;
2096 free_on_destroy = data;
2097 }
2098
2099 r = bufp_alloc(dev, data + i, len, status, ep, free_on_destroy);
2100 if (r) {
2101 break;
2102 }
2103 }
2104
2105 if (dev->endpoint[EP2I(ep)].pending_async_packet) {
2106 USBPacket *p = dev->endpoint[EP2I(ep)].pending_async_packet;
2107 dev->endpoint[EP2I(ep)].pending_async_packet = NULL;
2108 usbredir_buffered_bulk_in_complete(dev, p, ep);
2109 usb_packet_complete(&dev->dev, p);
2110 }
2111}
2112
2113
2114
2115
2116
2117static int usbredir_pre_save(void *priv)
2118{
2119 USBRedirDevice *dev = priv;
2120
2121 usbredir_fill_already_in_flight(dev);
2122
2123 return 0;
2124}
2125
2126static int usbredir_post_load(void *priv, int version_id)
2127{
2128 USBRedirDevice *dev = priv;
2129
2130 if (dev == NULL || dev->parser == NULL) {
2131 return 0;
2132 }
2133
2134 switch (dev->device_info.speed) {
2135 case usb_redir_speed_low:
2136 dev->dev.speed = USB_SPEED_LOW;
2137 break;
2138 case usb_redir_speed_full:
2139 dev->dev.speed = USB_SPEED_FULL;
2140 break;
2141 case usb_redir_speed_high:
2142 dev->dev.speed = USB_SPEED_HIGH;
2143 break;
2144 case usb_redir_speed_super:
2145 dev->dev.speed = USB_SPEED_SUPER;
2146 break;
2147 default:
2148 dev->dev.speed = USB_SPEED_FULL;
2149 }
2150 dev->dev.speedmask = (1 << dev->dev.speed);
2151
2152 usbredir_setup_usb_eps(dev);
2153 usbredir_check_bulk_receiving(dev);
2154
2155 return 0;
2156}
2157
2158
2159static int usbredir_put_parser(QEMUFile *f, void *priv, size_t unused,
2160 const VMStateField *field, QJSON *vmdesc)
2161{
2162 USBRedirDevice *dev = priv;
2163 uint8_t *data;
2164 int len;
2165
2166 if (dev->parser == NULL) {
2167 qemu_put_be32(f, 0);
2168 return 0;
2169 }
2170
2171 usbredirparser_serialize(dev->parser, &data, &len);
2172 qemu_oom_check(data);
2173
2174 qemu_put_be32(f, len);
2175 qemu_put_buffer(f, data, len);
2176
2177 free(data);
2178
2179 return 0;
2180}
2181
2182static int usbredir_get_parser(QEMUFile *f, void *priv, size_t unused,
2183 const VMStateField *field)
2184{
2185 USBRedirDevice *dev = priv;
2186 uint8_t *data;
2187 int len, ret;
2188
2189 len = qemu_get_be32(f);
2190 if (len == 0) {
2191 return 0;
2192 }
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202 if (dev->parser == NULL) {
2203 WARNING("usb-redir connection broken during migration\n");
2204 usbredir_create_parser(dev);
2205 qemu_bh_schedule(dev->chardev_close_bh);
2206 }
2207
2208 data = g_malloc(len);
2209 qemu_get_buffer(f, data, len);
2210
2211 ret = usbredirparser_unserialize(dev->parser, data, len);
2212
2213 g_free(data);
2214
2215 return ret;
2216}
2217
2218static const VMStateInfo usbredir_parser_vmstate_info = {
2219 .name = "usb-redir-parser",
2220 .put = usbredir_put_parser,
2221 .get = usbredir_get_parser,
2222};
2223
2224
2225
2226static int usbredir_put_bufpq(QEMUFile *f, void *priv, size_t unused,
2227 const VMStateField *field, QJSON *vmdesc)
2228{
2229 struct endp_data *endp = priv;
2230 USBRedirDevice *dev = endp->dev;
2231 struct buf_packet *bufp;
2232 int len, i = 0;
2233
2234 qemu_put_be32(f, endp->bufpq_size);
2235 QTAILQ_FOREACH(bufp, &endp->bufpq, next) {
2236 len = bufp->len - bufp->offset;
2237 DPRINTF("put_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
2238 len, bufp->status);
2239 qemu_put_be32(f, len);
2240 qemu_put_be32(f, bufp->status);
2241 qemu_put_buffer(f, bufp->data + bufp->offset, len);
2242 i++;
2243 }
2244 assert(i == endp->bufpq_size);
2245
2246 return 0;
2247}
2248
2249static int usbredir_get_bufpq(QEMUFile *f, void *priv, size_t unused,
2250 const VMStateField *field)
2251{
2252 struct endp_data *endp = priv;
2253 USBRedirDevice *dev = endp->dev;
2254 struct buf_packet *bufp;
2255 int i;
2256
2257 endp->bufpq_size = qemu_get_be32(f);
2258 for (i = 0; i < endp->bufpq_size; i++) {
2259 bufp = g_new(struct buf_packet, 1);
2260 bufp->len = qemu_get_be32(f);
2261 bufp->status = qemu_get_be32(f);
2262 bufp->offset = 0;
2263 bufp->data = qemu_oom_check(malloc(bufp->len));
2264 bufp->free_on_destroy = bufp->data;
2265 qemu_get_buffer(f, bufp->data, bufp->len);
2266 QTAILQ_INSERT_TAIL(&endp->bufpq, bufp, next);
2267 DPRINTF("get_bufpq %d/%d len %d status %d\n", i + 1, endp->bufpq_size,
2268 bufp->len, bufp->status);
2269 }
2270 return 0;
2271}
2272
2273static const VMStateInfo usbredir_ep_bufpq_vmstate_info = {
2274 .name = "usb-redir-bufpq",
2275 .put = usbredir_put_bufpq,
2276 .get = usbredir_get_bufpq,
2277};
2278
2279
2280
2281static bool usbredir_bulk_receiving_needed(void *priv)
2282{
2283 struct endp_data *endp = priv;
2284
2285 return endp->bulk_receiving_started;
2286}
2287
2288static const VMStateDescription usbredir_bulk_receiving_vmstate = {
2289 .name = "usb-redir-ep/bulk-receiving",
2290 .version_id = 1,
2291 .minimum_version_id = 1,
2292 .needed = usbredir_bulk_receiving_needed,
2293 .fields = (VMStateField[]) {
2294 VMSTATE_UINT8(bulk_receiving_started, struct endp_data),
2295 VMSTATE_END_OF_LIST()
2296 }
2297};
2298
2299static bool usbredir_stream_needed(void *priv)
2300{
2301 struct endp_data *endp = priv;
2302
2303 return endp->max_streams;
2304}
2305
2306static const VMStateDescription usbredir_stream_vmstate = {
2307 .name = "usb-redir-ep/stream-state",
2308 .version_id = 1,
2309 .minimum_version_id = 1,
2310 .needed = usbredir_stream_needed,
2311 .fields = (VMStateField[]) {
2312 VMSTATE_UINT32(max_streams, struct endp_data),
2313 VMSTATE_END_OF_LIST()
2314 }
2315};
2316
2317static const VMStateDescription usbredir_ep_vmstate = {
2318 .name = "usb-redir-ep",
2319 .version_id = 1,
2320 .minimum_version_id = 1,
2321 .fields = (VMStateField[]) {
2322 VMSTATE_UINT8(type, struct endp_data),
2323 VMSTATE_UINT8(interval, struct endp_data),
2324 VMSTATE_UINT8(interface, struct endp_data),
2325 VMSTATE_UINT16(max_packet_size, struct endp_data),
2326 VMSTATE_UINT8(iso_started, struct endp_data),
2327 VMSTATE_UINT8(iso_error, struct endp_data),
2328 VMSTATE_UINT8(interrupt_started, struct endp_data),
2329 VMSTATE_UINT8(interrupt_error, struct endp_data),
2330 VMSTATE_UINT8(bufpq_prefilled, struct endp_data),
2331 VMSTATE_UINT8(bufpq_dropping_packets, struct endp_data),
2332 {
2333 .name = "bufpq",
2334 .version_id = 0,
2335 .field_exists = NULL,
2336 .size = 0,
2337 .info = &usbredir_ep_bufpq_vmstate_info,
2338 .flags = VMS_SINGLE,
2339 .offset = 0,
2340 },
2341 VMSTATE_INT32(bufpq_target_size, struct endp_data),
2342 VMSTATE_END_OF_LIST()
2343 },
2344 .subsections = (const VMStateDescription*[]) {
2345 &usbredir_bulk_receiving_vmstate,
2346 &usbredir_stream_vmstate,
2347 NULL
2348 }
2349};
2350
2351
2352
2353static int usbredir_put_packet_id_q(QEMUFile *f, void *priv, size_t unused,
2354 const VMStateField *field, QJSON *vmdesc)
2355{
2356 struct PacketIdQueue *q = priv;
2357 USBRedirDevice *dev = q->dev;
2358 struct PacketIdQueueEntry *e;
2359 int remain = q->size;
2360
2361 DPRINTF("put_packet_id_q %s size %d\n", q->name, q->size);
2362 qemu_put_be32(f, q->size);
2363 QTAILQ_FOREACH(e, &q->head, next) {
2364 qemu_put_be64(f, e->id);
2365 remain--;
2366 }
2367 assert(remain == 0);
2368
2369 return 0;
2370}
2371
2372static int usbredir_get_packet_id_q(QEMUFile *f, void *priv, size_t unused,
2373 const VMStateField *field)
2374{
2375 struct PacketIdQueue *q = priv;
2376 USBRedirDevice *dev = q->dev;
2377 int i, size;
2378 uint64_t id;
2379
2380 size = qemu_get_be32(f);
2381 DPRINTF("get_packet_id_q %s size %d\n", q->name, size);
2382 for (i = 0; i < size; i++) {
2383 id = qemu_get_be64(f);
2384 packet_id_queue_add(q, id);
2385 }
2386 assert(q->size == size);
2387 return 0;
2388}
2389
2390static const VMStateInfo usbredir_ep_packet_id_q_vmstate_info = {
2391 .name = "usb-redir-packet-id-q",
2392 .put = usbredir_put_packet_id_q,
2393 .get = usbredir_get_packet_id_q,
2394};
2395
2396static const VMStateDescription usbredir_ep_packet_id_queue_vmstate = {
2397 .name = "usb-redir-packet-id-queue",
2398 .version_id = 1,
2399 .minimum_version_id = 1,
2400 .fields = (VMStateField[]) {
2401 {
2402 .name = "queue",
2403 .version_id = 0,
2404 .field_exists = NULL,
2405 .size = 0,
2406 .info = &usbredir_ep_packet_id_q_vmstate_info,
2407 .flags = VMS_SINGLE,
2408 .offset = 0,
2409 },
2410 VMSTATE_END_OF_LIST()
2411 }
2412};
2413
2414
2415
2416static const VMStateDescription usbredir_device_info_vmstate = {
2417 .name = "usb-redir-device-info",
2418 .version_id = 1,
2419 .minimum_version_id = 1,
2420 .fields = (VMStateField[]) {
2421 VMSTATE_UINT8(speed, struct usb_redir_device_connect_header),
2422 VMSTATE_UINT8(device_class, struct usb_redir_device_connect_header),
2423 VMSTATE_UINT8(device_subclass, struct usb_redir_device_connect_header),
2424 VMSTATE_UINT8(device_protocol, struct usb_redir_device_connect_header),
2425 VMSTATE_UINT16(vendor_id, struct usb_redir_device_connect_header),
2426 VMSTATE_UINT16(product_id, struct usb_redir_device_connect_header),
2427 VMSTATE_UINT16(device_version_bcd,
2428 struct usb_redir_device_connect_header),
2429 VMSTATE_END_OF_LIST()
2430 }
2431};
2432
2433
2434
2435static const VMStateDescription usbredir_interface_info_vmstate = {
2436 .name = "usb-redir-interface-info",
2437 .version_id = 1,
2438 .minimum_version_id = 1,
2439 .fields = (VMStateField[]) {
2440 VMSTATE_UINT32(interface_count,
2441 struct usb_redir_interface_info_header),
2442 VMSTATE_UINT8_ARRAY(interface,
2443 struct usb_redir_interface_info_header, 32),
2444 VMSTATE_UINT8_ARRAY(interface_class,
2445 struct usb_redir_interface_info_header, 32),
2446 VMSTATE_UINT8_ARRAY(interface_subclass,
2447 struct usb_redir_interface_info_header, 32),
2448 VMSTATE_UINT8_ARRAY(interface_protocol,
2449 struct usb_redir_interface_info_header, 32),
2450 VMSTATE_END_OF_LIST()
2451 }
2452};
2453
2454
2455
2456static const VMStateDescription usbredir_vmstate = {
2457 .name = "usb-redir",
2458 .version_id = 1,
2459 .minimum_version_id = 1,
2460 .pre_save = usbredir_pre_save,
2461 .post_load = usbredir_post_load,
2462 .fields = (VMStateField[]) {
2463 VMSTATE_USB_DEVICE(dev, USBRedirDevice),
2464 VMSTATE_TIMER_PTR(attach_timer, USBRedirDevice),
2465 {
2466 .name = "parser",
2467 .version_id = 0,
2468 .field_exists = NULL,
2469 .size = 0,
2470 .info = &usbredir_parser_vmstate_info,
2471 .flags = VMS_SINGLE,
2472 .offset = 0,
2473 },
2474 VMSTATE_STRUCT_ARRAY(endpoint, USBRedirDevice, MAX_ENDPOINTS, 1,
2475 usbredir_ep_vmstate, struct endp_data),
2476 VMSTATE_STRUCT(cancelled, USBRedirDevice, 1,
2477 usbredir_ep_packet_id_queue_vmstate,
2478 struct PacketIdQueue),
2479 VMSTATE_STRUCT(already_in_flight, USBRedirDevice, 1,
2480 usbredir_ep_packet_id_queue_vmstate,
2481 struct PacketIdQueue),
2482 VMSTATE_STRUCT(device_info, USBRedirDevice, 1,
2483 usbredir_device_info_vmstate,
2484 struct usb_redir_device_connect_header),
2485 VMSTATE_STRUCT(interface_info, USBRedirDevice, 1,
2486 usbredir_interface_info_vmstate,
2487 struct usb_redir_interface_info_header),
2488 VMSTATE_END_OF_LIST()
2489 }
2490};
2491
2492static Property usbredir_properties[] = {
2493 DEFINE_PROP_CHR("chardev", USBRedirDevice, cs),
2494 DEFINE_PROP_UINT8("debug", USBRedirDevice, debug, usbredirparser_warning),
2495 DEFINE_PROP_STRING("filter", USBRedirDevice, filter_str),
2496 DEFINE_PROP_BOOL("streams", USBRedirDevice, enable_streams, true),
2497 DEFINE_PROP_END_OF_LIST(),
2498};
2499
2500static void usbredir_class_initfn(ObjectClass *klass, void *data)
2501{
2502 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
2503 DeviceClass *dc = DEVICE_CLASS(klass);
2504
2505 uc->realize = usbredir_realize;
2506 uc->product_desc = "USB Redirection Device";
2507 uc->unrealize = usbredir_unrealize;
2508 uc->cancel_packet = usbredir_cancel_packet;
2509 uc->handle_reset = usbredir_handle_reset;
2510 uc->handle_data = usbredir_handle_data;
2511 uc->handle_control = usbredir_handle_control;
2512 uc->flush_ep_queue = usbredir_flush_ep_queue;
2513 uc->ep_stopped = usbredir_ep_stopped;
2514 uc->alloc_streams = usbredir_alloc_streams;
2515 uc->free_streams = usbredir_free_streams;
2516 dc->vmsd = &usbredir_vmstate;
2517 dc->props = usbredir_properties;
2518 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
2519}
2520
2521static void usbredir_instance_init(Object *obj)
2522{
2523 USBDevice *udev = USB_DEVICE(obj);
2524 USBRedirDevice *dev = USB_REDIRECT(udev);
2525
2526 device_add_bootindex_property(obj, &dev->bootindex,
2527 "bootindex", NULL,
2528 &udev->qdev, NULL);
2529}
2530
2531static const TypeInfo usbredir_dev_info = {
2532 .name = TYPE_USB_REDIR,
2533 .parent = TYPE_USB_DEVICE,
2534 .instance_size = sizeof(USBRedirDevice),
2535 .class_init = usbredir_class_initfn,
2536 .instance_init = usbredir_instance_init,
2537};
2538
2539static void usbredir_register_types(void)
2540{
2541 type_register_static(&usbredir_dev_info);
2542}
2543
2544type_init(usbredir_register_types)
2545