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