qemu

1
/*
2
 * Linux host USB redirector
3
 *
4
 * Copyright (c) 2005 Fabrice Bellard
5
 *
6
 * Copyright (c) 2008 Max Krasnyansky
7
 *      Support for host device auto connect & disconnect
8
 *      Major rewrite to support fully async operation
9
 *
10
 * Copyright 2008 TJ <linux@tjworld.net>
11
 *      Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition
12
 *      to the legacy /proc/bus/usb USB device discovery and handling
13
 *
14
 * (c) 2012 Gerd Hoffmann <kraxel@redhat.com>
15
 *      Completely rewritten to use libusb instead of usbfs ioctls.
16
 *
17
 * Permission is hereby granted, free of charge, to any person obtaining a copy
18
 * of this software and associated documentation files (the "Software"), to deal
19
 * in the Software without restriction, including without limitation the rights
20
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
21
 * copies of the Software, and to permit persons to whom the Software is
22
 * furnished to do so, subject to the following conditions:
23
 *
24
 * The above copyright notice and this permission notice shall be included in
25
 * all copies or substantial portions of the Software.
26
 *
27
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
30
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
31
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
32
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
33
 * THE SOFTWARE.
34
 */
35

36
#include "qemu/osdep.h"
37
#include "qom/object.h"
38
#ifndef CONFIG_WIN32
39
#include <poll.h>
40
#endif
41
#include <libusb.h>
42

43
#ifdef CONFIG_LINUX
44
#include <sys/ioctl.h>
45
#include <linux/usbdevice_fs.h>
46
#endif
47

48
#include "qapi/error.h"
49
#include "migration/vmstate.h"
50
#include "monitor/monitor.h"
51
#include "qemu/error-report.h"
52
#include "qemu/main-loop.h"
53
#include "qemu/module.h"
54
#include "sysemu/runstate.h"
55
#include "sysemu/sysemu.h"
56
#include "trace.h"
57

58
#include "hw/qdev-properties.h"
59
#include "hw/usb.h"
60

61
/* ------------------------------------------------------------------------ */
62

63
#define TYPE_USB_HOST_DEVICE "usb-host"
64
OBJECT_DECLARE_SIMPLE_TYPE(USBHostDevice, USB_HOST_DEVICE)
65

66
typedef struct USBHostRequest USBHostRequest;
67
typedef struct USBHostIsoXfer USBHostIsoXfer;
68
typedef struct USBHostIsoRing USBHostIsoRing;
69

70
struct USBAutoFilter {
71
    uint32_t bus_num;
72
    uint32_t addr;
73
    char     *port;
74
    uint32_t vendor_id;
75
    uint32_t product_id;
76
};
77

78
enum USBHostDeviceOptions {
79
    USB_HOST_OPT_PIPELINE,
80
};
81

82
struct USBHostDevice {
83
    USBDevice parent_obj;
84

85
    /* properties */
86
    struct USBAutoFilter             match;
87
    char                             *hostdevice;
88
    int32_t                          bootindex;
89
    uint32_t                         iso_urb_count;
90
    uint32_t                         iso_urb_frames;
91
    uint32_t                         options;
92
    uint32_t                         loglevel;
93
    bool                             needs_autoscan;
94
    bool                             allow_one_guest_reset;
95
    bool                             allow_all_guest_resets;
96
    bool                             suppress_remote_wake;
97

98
    /* state */
99
    QTAILQ_ENTRY(USBHostDevice)      next;
100
    int                              seen, errcount;
101
    int                              bus_num;
102
    int                              addr;
103
    char                             port[16];
104

105
    int                              hostfd;
106
    libusb_device                    *dev;
107
    libusb_device_handle             *dh;
108
    struct libusb_device_descriptor  ddesc;
109

110
    struct {
111
        bool                         detached;
112
        bool                         claimed;
113
    } ifs[USB_MAX_INTERFACES];
114

115
    /* callbacks & friends */
116
    QEMUBH                           *bh_nodev;
117
    QEMUBH                           *bh_postld;
118
    bool                             bh_postld_pending;
119
    Notifier                         exit;
120

121
    /* request queues */
122
    QTAILQ_HEAD(, USBHostRequest)    requests;
123
    QTAILQ_HEAD(, USBHostIsoRing)    isorings;
124
};
125

126
struct USBHostRequest {
127
    USBHostDevice                    *host;
128
    USBPacket                        *p;
129
    bool                             in;
130
    struct libusb_transfer           *xfer;
131
    unsigned char                    *buffer;
132
    unsigned char                    *cbuf;
133
    unsigned int                     clen;
134
    bool                             usb3ep0quirk;
135
    QTAILQ_ENTRY(USBHostRequest)     next;
136
};
137

138
struct USBHostIsoXfer {
139
    USBHostIsoRing                   *ring;
140
    struct libusb_transfer           *xfer;
141
    bool                             copy_complete;
142
    unsigned int                     packet;
143
    QTAILQ_ENTRY(USBHostIsoXfer)     next;
144
};
145

146
struct USBHostIsoRing {
147
    USBHostDevice                    *host;
148
    USBEndpoint                      *ep;
149
    QTAILQ_HEAD(, USBHostIsoXfer)    unused;
150
    QTAILQ_HEAD(, USBHostIsoXfer)    inflight;
151
    QTAILQ_HEAD(, USBHostIsoXfer)    copy;
152
    QTAILQ_ENTRY(USBHostIsoRing)     next;
153
};
154

155
static QTAILQ_HEAD(, USBHostDevice) hostdevs =
156
    QTAILQ_HEAD_INITIALIZER(hostdevs);
157

158
static void usb_host_auto_check(void *unused);
159
static void usb_host_release_interfaces(USBHostDevice *s);
160
static void usb_host_nodev(USBHostDevice *s);
161
static void usb_host_detach_kernel(USBHostDevice *s);
162
static void usb_host_attach_kernel(USBHostDevice *s);
163

164
/* ------------------------------------------------------------------------ */
165

166
#ifndef LIBUSB_LOG_LEVEL_WARNING /* older libusb didn't define these */
167
#define LIBUSB_LOG_LEVEL_WARNING 2
168
#endif
169

170
/* ------------------------------------------------------------------------ */
171

172
#define CONTROL_TIMEOUT  10000        /* 10 sec    */
173
#define BULK_TIMEOUT         0        /* unlimited */
174
#define INTR_TIMEOUT         0        /* unlimited */
175

176
#ifndef LIBUSB_API_VERSION
177
# define LIBUSB_API_VERSION LIBUSBX_API_VERSION
178
#endif
179
#if LIBUSB_API_VERSION >= 0x01000103
180
# define HAVE_STREAMS 1
181
#endif
182
#if LIBUSB_API_VERSION >= 0x01000106
183
# define HAVE_SUPER_PLUS 1
184
#endif
185

186
static const char *speed_name[] = {
187
    [LIBUSB_SPEED_UNKNOWN] = "?",
188
    [LIBUSB_SPEED_LOW]     = "1.5",
189
    [LIBUSB_SPEED_FULL]    = "12",
190
    [LIBUSB_SPEED_HIGH]    = "480",
191
    [LIBUSB_SPEED_SUPER]   = "5000",
192
#ifdef HAVE_SUPER_PLUS
193
    [LIBUSB_SPEED_SUPER_PLUS] = "5000+",
194
#endif
195
};
196

197
static const unsigned int speed_map[] = {
198
    [LIBUSB_SPEED_LOW]     = USB_SPEED_LOW,
199
    [LIBUSB_SPEED_FULL]    = USB_SPEED_FULL,
200
    [LIBUSB_SPEED_HIGH]    = USB_SPEED_HIGH,
201
    [LIBUSB_SPEED_SUPER]   = USB_SPEED_SUPER,
202
#ifdef HAVE_SUPER_PLUS
203
    [LIBUSB_SPEED_SUPER_PLUS] = USB_SPEED_SUPER,
204
#endif
205
};
206

207
static const unsigned int status_map[] = {
208
    [LIBUSB_TRANSFER_COMPLETED] = USB_RET_SUCCESS,
209
    [LIBUSB_TRANSFER_ERROR]     = USB_RET_IOERROR,
210
    [LIBUSB_TRANSFER_TIMED_OUT] = USB_RET_IOERROR,
211
    [LIBUSB_TRANSFER_CANCELLED] = USB_RET_IOERROR,
212
    [LIBUSB_TRANSFER_STALL]     = USB_RET_STALL,
213
    [LIBUSB_TRANSFER_NO_DEVICE] = USB_RET_NODEV,
214
    [LIBUSB_TRANSFER_OVERFLOW]  = USB_RET_BABBLE,
215
};
216

217
static const char *err_names[] = {
218
    [-LIBUSB_ERROR_IO]               = "IO",
219
    [-LIBUSB_ERROR_INVALID_PARAM]    = "INVALID_PARAM",
220
    [-LIBUSB_ERROR_ACCESS]           = "ACCESS",
221
    [-LIBUSB_ERROR_NO_DEVICE]        = "NO_DEVICE",
222
    [-LIBUSB_ERROR_NOT_FOUND]        = "NOT_FOUND",
223
    [-LIBUSB_ERROR_BUSY]             = "BUSY",
224
    [-LIBUSB_ERROR_TIMEOUT]          = "TIMEOUT",
225
    [-LIBUSB_ERROR_OVERFLOW]         = "OVERFLOW",
226
    [-LIBUSB_ERROR_PIPE]             = "PIPE",
227
    [-LIBUSB_ERROR_INTERRUPTED]      = "INTERRUPTED",
228
    [-LIBUSB_ERROR_NO_MEM]           = "NO_MEM",
229
    [-LIBUSB_ERROR_NOT_SUPPORTED]    = "NOT_SUPPORTED",
230
    [-LIBUSB_ERROR_OTHER]            = "OTHER",
231
};
232

233
static libusb_context *ctx;
234
static uint32_t loglevel;
235

236
#ifndef CONFIG_WIN32
237

238
static void usb_host_handle_fd(void *opaque)
239
{
240
    struct timeval tv = { 0, 0 };
241
    libusb_handle_events_timeout(ctx, &tv);
242
}
243

244
static void usb_host_add_fd(int fd, short events, void *user_data)
245
{
246
    qemu_set_fd_handler(fd,
247
                        (events & POLLIN)  ? usb_host_handle_fd : NULL,
248
                        (events & POLLOUT) ? usb_host_handle_fd : NULL,
249
                        ctx);
250
}
251

252
static void usb_host_del_fd(int fd, void *user_data)
253
{
254
    qemu_set_fd_handler(fd, NULL, NULL, NULL);
255
}
256

257
#else
258

259
static QEMUTimer *poll_timer;
260
static uint32_t request_count;
261

262
static void usb_host_timer_kick(void)
263
{
264
    int64_t delay_ns;
265

266
    delay_ns = request_count
267
        ? (NANOSECONDS_PER_SECOND / 100)  /* 10 ms interval with active req */
268
        : (NANOSECONDS_PER_SECOND);       /* 1 sec interval otherwise */
269
    timer_mod(poll_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + delay_ns);
270
}
271

272
static void usb_host_timer(void *opaque)
273
{
274
    struct timeval tv = { 0, 0 };
275

276
    libusb_handle_events_timeout(ctx, &tv);
277
    usb_host_timer_kick();
278
}
279

280
#endif /* !CONFIG_WIN32 */
281

282
static int usb_host_init(void)
283
{
284
#ifndef CONFIG_WIN32
285
    const struct libusb_pollfd **poll;
286
#endif
287
    int rc;
288

289
    if (ctx) {
290
        return 0;
291
    }
292
    rc = libusb_init(&ctx);
293
    if (rc != 0) {
294
        return -1;
295
    }
296
#if LIBUSB_API_VERSION >= 0x01000106
297
    libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, loglevel);
298
#else
299
    libusb_set_debug(ctx, loglevel);
300
#endif
301
#ifdef CONFIG_WIN32
302
    poll_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, usb_host_timer, NULL);
303
    usb_host_timer_kick();
304
#else
305
    libusb_set_pollfd_notifiers(ctx, usb_host_add_fd,
306
                                usb_host_del_fd,
307
                                ctx);
308
    poll = libusb_get_pollfds(ctx);
309
    if (poll) {
310
        int i;
311
        for (i = 0; poll[i] != NULL; i++) {
312
            usb_host_add_fd(poll[i]->fd, poll[i]->events, ctx);
313
        }
314
    }
315
    free(poll);
316
#endif
317
    return 0;
318
}
319

320
static int usb_host_get_port(libusb_device *dev, char *port, size_t len)
321
{
322
    uint8_t path[7];
323
    size_t off;
324
    int rc, i;
325

326
#if LIBUSB_API_VERSION >= 0x01000102
327
    rc = libusb_get_port_numbers(dev, path, 7);
328
#else
329
    rc = libusb_get_port_path(ctx, dev, path, 7);
330
#endif
331
    if (rc < 0) {
332
        return 0;
333
    }
334
    off = snprintf(port, len, "%d", path[0]);
335
    for (i = 1; i < rc; i++) {
336
        off += snprintf(port+off, len-off, ".%d", path[i]);
337
    }
338
    return off;
339
}
340

341
static void usb_host_libusb_error(const char *func, int rc)
342
{
343
    const char *errname;
344

345
    if (rc >= 0) {
346
        return;
347
    }
348

349
    if (-rc < ARRAY_SIZE(err_names) && err_names[-rc]) {
350
        errname = err_names[-rc];
351
    } else {
352
        errname = "?";
353
    }
354
    error_report("%s: %d [%s]", func, rc, errname);
355
}
356

357
/* ------------------------------------------------------------------------ */
358

359
static bool usb_host_use_combining(USBEndpoint *ep)
360
{
361
    int type;
362

363
    if (!ep->pipeline) {
364
        return false;
365
    }
366
    if (ep->pid != USB_TOKEN_IN) {
367
        return false;
368
    }
369
    type = usb_ep_get_type(ep->dev, ep->pid, ep->nr);
370
    if (type != USB_ENDPOINT_XFER_BULK) {
371
        return false;
372
    }
373
    return true;
374
}
375

376
/* ------------------------------------------------------------------------ */
377

378
static USBHostRequest *usb_host_req_alloc(USBHostDevice *s, USBPacket *p,
379
                                          bool in, size_t bufsize)
380
{
381
    USBHostRequest *r = g_new0(USBHostRequest, 1);
382

383
    r->host = s;
384
    r->p = p;
385
    r->in = in;
386
    r->xfer = libusb_alloc_transfer(0);
387
    if (bufsize) {
388
        r->buffer = g_malloc(bufsize);
389
    }
390
    QTAILQ_INSERT_TAIL(&s->requests, r, next);
391
#ifdef CONFIG_WIN32
392
    request_count++;
393
    usb_host_timer_kick();
394
#endif
395
    return r;
396
}
397

398
static void usb_host_req_free(USBHostRequest *r)
399
{
400
#ifdef CONFIG_WIN32
401
    request_count--;
402
#endif
403
    QTAILQ_REMOVE(&r->host->requests, r, next);
404
    libusb_free_transfer(r->xfer);
405
    g_free(r->buffer);
406
    g_free(r);
407
}
408

409
static USBHostRequest *usb_host_req_find(USBHostDevice *s, USBPacket *p)
410
{
411
    USBHostRequest *r;
412

413
    QTAILQ_FOREACH(r, &s->requests, next) {
414
        if (r->p == p) {
415
            return r;
416
        }
417
    }
418
    return NULL;
419
}
420

421
static void LIBUSB_CALL usb_host_req_complete_ctrl(struct libusb_transfer *xfer)
422
{
423
    USBHostRequest *r = xfer->user_data;
424
    USBHostDevice  *s = r->host;
425
    bool disconnect = (xfer->status == LIBUSB_TRANSFER_NO_DEVICE);
426

427
    if (r->p == NULL) {
428
        goto out; /* request was canceled */
429
    }
430

431
    r->p->status = status_map[xfer->status];
432
    r->p->actual_length = xfer->actual_length;
433
    if (r->in && xfer->actual_length) {
434
        USBDevice *udev = USB_DEVICE(s);
435
        struct libusb_config_descriptor *conf = (void *)r->cbuf;
436
        memcpy(r->cbuf, r->buffer + 8, xfer->actual_length);
437

438
        /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices
439
         * to work redirected to a not superspeed capable hcd */
440
        if (r->usb3ep0quirk && xfer->actual_length >= 18 &&
441
            r->cbuf[7] == 9) {
442
            r->cbuf[7] = 64;
443
        }
444
        /*
445
         *If this is GET_DESCRIPTOR request for configuration descriptor,
446
         * remove 'remote wakeup' flag from it to prevent idle power down
447
         * in Windows guest
448
         */
449
        if (s->suppress_remote_wake &&
450
            udev->setup_buf[0] == USB_DIR_IN &&
451
            udev->setup_buf[1] == USB_REQ_GET_DESCRIPTOR &&
452
            udev->setup_buf[3] == USB_DT_CONFIG && udev->setup_buf[2] == 0 &&
453
            xfer->actual_length >
454
                offsetof(struct libusb_config_descriptor, bmAttributes) &&
455
            (conf->bmAttributes & USB_CFG_ATT_WAKEUP)) {
456
                trace_usb_host_remote_wakeup_removed(s->bus_num, s->addr);
457
                conf->bmAttributes &= ~USB_CFG_ATT_WAKEUP;
458
        }
459
    }
460
    trace_usb_host_req_complete(s->bus_num, s->addr, r->p,
461
                                r->p->status, r->p->actual_length);
462
    usb_generic_async_ctrl_complete(USB_DEVICE(s), r->p);
463

464
out:
465
    usb_host_req_free(r);
466
    if (disconnect) {
467
        usb_host_nodev(s);
468
    }
469
}
470

471
static void LIBUSB_CALL usb_host_req_complete_data(struct libusb_transfer *xfer)
472
{
473
    USBHostRequest *r = xfer->user_data;
474
    USBHostDevice  *s = r->host;
475
    bool disconnect = (xfer->status == LIBUSB_TRANSFER_NO_DEVICE);
476

477
    if (r->p == NULL) {
478
        goto out; /* request was canceled */
479
    }
480

481
    r->p->status = status_map[xfer->status];
482
    if (r->in && xfer->actual_length) {
483
        usb_packet_copy(r->p, r->buffer, xfer->actual_length);
484
    }
485
    trace_usb_host_req_complete(s->bus_num, s->addr, r->p,
486
                                r->p->status, r->p->actual_length);
487
    if (usb_host_use_combining(r->p->ep)) {
488
        usb_combined_input_packet_complete(USB_DEVICE(s), r->p);
489
    } else {
490
        usb_packet_complete(USB_DEVICE(s), r->p);
491
    }
492

493
out:
494
    usb_host_req_free(r);
495
    if (disconnect) {
496
        usb_host_nodev(s);
497
    }
498
}
499

500
static void usb_host_req_abort(USBHostRequest *r)
501
{
502
    USBHostDevice  *s = r->host;
503
    bool inflight = (r->p && r->p->state == USB_PACKET_ASYNC);
504

505
    if (inflight) {
506
        r->p->status = USB_RET_NODEV;
507
        trace_usb_host_req_complete(s->bus_num, s->addr, r->p,
508
                                    r->p->status, r->p->actual_length);
509
        if (r->p->ep->nr == 0) {
510
            usb_generic_async_ctrl_complete(USB_DEVICE(s), r->p);
511
        } else {
512
            usb_packet_complete(USB_DEVICE(s), r->p);
513
        }
514
        r->p = NULL;
515

516
        libusb_cancel_transfer(r->xfer);
517
    }
518
}
519

520
/* ------------------------------------------------------------------------ */
521

522
static void LIBUSB_CALL
523
usb_host_req_complete_iso(struct libusb_transfer *transfer)
524
{
525
    USBHostIsoXfer *xfer = transfer->user_data;
526

527
    if (!xfer) {
528
        /* USBHostIsoXfer released while inflight */
529
        g_free(transfer->buffer);
530
        libusb_free_transfer(transfer);
531
        return;
532
    }
533

534
    QTAILQ_REMOVE(&xfer->ring->inflight, xfer, next);
535
    if (QTAILQ_EMPTY(&xfer->ring->inflight)) {
536
        USBHostDevice *s = xfer->ring->host;
537
        trace_usb_host_iso_stop(s->bus_num, s->addr, xfer->ring->ep->nr);
538
    }
539
    if (xfer->ring->ep->pid == USB_TOKEN_IN) {
540
        QTAILQ_INSERT_TAIL(&xfer->ring->copy, xfer, next);
541
        usb_wakeup(xfer->ring->ep, 0);
542
    } else {
543
        QTAILQ_INSERT_TAIL(&xfer->ring->unused, xfer, next);
544
    }
545
}
546

547
static USBHostIsoRing *usb_host_iso_alloc(USBHostDevice *s, USBEndpoint *ep)
548
{
549
    USBHostIsoRing *ring = g_new0(USBHostIsoRing, 1);
550
    USBHostIsoXfer *xfer;
551
    /* FIXME: check interval (for now assume one xfer per frame) */
552
    int packets = s->iso_urb_frames;
553
    int i;
554

555
    ring->host = s;
556
    ring->ep = ep;
557
    QTAILQ_INIT(&ring->unused);
558
    QTAILQ_INIT(&ring->inflight);
559
    QTAILQ_INIT(&ring->copy);
560
    QTAILQ_INSERT_TAIL(&s->isorings, ring, next);
561

562
    for (i = 0; i < s->iso_urb_count; i++) {
563
        xfer = g_new0(USBHostIsoXfer, 1);
564
        xfer->ring = ring;
565
        xfer->xfer = libusb_alloc_transfer(packets);
566
        xfer->xfer->dev_handle = s->dh;
567
        xfer->xfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
568

569
        xfer->xfer->endpoint = ring->ep->nr;
570
        if (ring->ep->pid == USB_TOKEN_IN) {
571
            xfer->xfer->endpoint |= USB_DIR_IN;
572
        }
573
        xfer->xfer->callback = usb_host_req_complete_iso;
574
        xfer->xfer->user_data = xfer;
575

576
        xfer->xfer->num_iso_packets = packets;
577
        xfer->xfer->length = ring->ep->max_packet_size * packets;
578
        xfer->xfer->buffer = g_malloc0(xfer->xfer->length);
579

580
        QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
581
    }
582

583
    return ring;
584
}
585

586
static USBHostIsoRing *usb_host_iso_find(USBHostDevice *s, USBEndpoint *ep)
587
{
588
    USBHostIsoRing *ring;
589

590
    QTAILQ_FOREACH(ring, &s->isorings, next) {
591
        if (ring->ep == ep) {
592
            return ring;
593
        }
594
    }
595
    return NULL;
596
}
597

598
static void usb_host_iso_reset_xfer(USBHostIsoXfer *xfer)
599
{
600
    libusb_set_iso_packet_lengths(xfer->xfer,
601
                                  xfer->ring->ep->max_packet_size);
602
    xfer->packet = 0;
603
    xfer->copy_complete = false;
604
}
605

606
static void usb_host_iso_free_xfer(USBHostIsoXfer *xfer, bool inflight)
607
{
608
    if (inflight) {
609
        xfer->xfer->user_data = NULL;
610
    } else {
611
        g_free(xfer->xfer->buffer);
612
        libusb_free_transfer(xfer->xfer);
613
    }
614
    g_free(xfer);
615
}
616

617
static void usb_host_iso_free(USBHostIsoRing *ring)
618
{
619
    USBHostIsoXfer *xfer;
620

621
    while ((xfer = QTAILQ_FIRST(&ring->inflight)) != NULL) {
622
        QTAILQ_REMOVE(&ring->inflight, xfer, next);
623
        usb_host_iso_free_xfer(xfer, true);
624
    }
625
    while ((xfer = QTAILQ_FIRST(&ring->unused)) != NULL) {
626
        QTAILQ_REMOVE(&ring->unused, xfer, next);
627
        usb_host_iso_free_xfer(xfer, false);
628
    }
629
    while ((xfer = QTAILQ_FIRST(&ring->copy)) != NULL) {
630
        QTAILQ_REMOVE(&ring->copy, xfer, next);
631
        usb_host_iso_free_xfer(xfer, false);
632
    }
633

634
    QTAILQ_REMOVE(&ring->host->isorings, ring, next);
635
    g_free(ring);
636
}
637

638
static void usb_host_iso_free_all(USBHostDevice *s)
639
{
640
    USBHostIsoRing *ring;
641

642
    while ((ring = QTAILQ_FIRST(&s->isorings)) != NULL) {
643
        usb_host_iso_free(ring);
644
    }
645
}
646

647
static bool usb_host_iso_data_copy(USBHostIsoXfer *xfer, USBPacket *p)
648
{
649
    unsigned int psize;
650
    unsigned char *buf;
651

652
    buf = libusb_get_iso_packet_buffer_simple(xfer->xfer, xfer->packet);
653
    if (p->pid == USB_TOKEN_OUT) {
654
        psize = p->iov.size;
655
        if (psize > xfer->ring->ep->max_packet_size) {
656
            /* should not happen (guest bug) */
657
            psize = xfer->ring->ep->max_packet_size;
658
        }
659
        xfer->xfer->iso_packet_desc[xfer->packet].length = psize;
660
    } else {
661
        psize = xfer->xfer->iso_packet_desc[xfer->packet].actual_length;
662
        if (psize > p->iov.size) {
663
            /* should not happen (guest bug) */
664
            psize = p->iov.size;
665
        }
666
    }
667
    usb_packet_copy(p, buf, psize);
668
    xfer->packet++;
669
    xfer->copy_complete = (xfer->packet == xfer->xfer->num_iso_packets);
670
    return xfer->copy_complete;
671
}
672

673
static void usb_host_iso_data_in(USBHostDevice *s, USBPacket *p)
674
{
675
    USBHostIsoRing *ring;
676
    USBHostIsoXfer *xfer;
677
    bool disconnect = false;
678
    int rc;
679

680
    ring = usb_host_iso_find(s, p->ep);
681
    if (ring == NULL) {
682
        ring = usb_host_iso_alloc(s, p->ep);
683
    }
684

685
    /* copy data to guest */
686
    xfer = QTAILQ_FIRST(&ring->copy);
687
    if (xfer != NULL) {
688
        if (usb_host_iso_data_copy(xfer, p)) {
689
            QTAILQ_REMOVE(&ring->copy, xfer, next);
690
            QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
691
        }
692
    }
693

694
    /* submit empty bufs to host */
695
    while ((xfer = QTAILQ_FIRST(&ring->unused)) != NULL) {
696
        QTAILQ_REMOVE(&ring->unused, xfer, next);
697
        usb_host_iso_reset_xfer(xfer);
698
        rc = libusb_submit_transfer(xfer->xfer);
699
        if (rc != 0) {
700
            usb_host_libusb_error("libusb_submit_transfer [iso]", rc);
701
            QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
702
            if (rc == LIBUSB_ERROR_NO_DEVICE) {
703
                disconnect = true;
704
            }
705
            break;
706
        }
707
        if (QTAILQ_EMPTY(&ring->inflight)) {
708
            trace_usb_host_iso_start(s->bus_num, s->addr, p->ep->nr);
709
        }
710
        QTAILQ_INSERT_TAIL(&ring->inflight, xfer, next);
711
    }
712

713
    if (disconnect) {
714
        usb_host_nodev(s);
715
    }
716
}
717

718
static void usb_host_iso_data_out(USBHostDevice *s, USBPacket *p)
719
{
720
    USBHostIsoRing *ring;
721
    USBHostIsoXfer *xfer;
722
    bool disconnect = false;
723
    int rc, filled = 0;
724

725
    ring = usb_host_iso_find(s, p->ep);
726
    if (ring == NULL) {
727
        ring = usb_host_iso_alloc(s, p->ep);
728
    }
729

730
    /* copy data from guest */
731
    xfer = QTAILQ_FIRST(&ring->copy);
732
    while (xfer != NULL && xfer->copy_complete) {
733
        filled++;
734
        xfer = QTAILQ_NEXT(xfer, next);
735
    }
736
    if (xfer == NULL) {
737
        xfer = QTAILQ_FIRST(&ring->unused);
738
        if (xfer == NULL) {
739
            trace_usb_host_iso_out_of_bufs(s->bus_num, s->addr, p->ep->nr);
740
            return;
741
        }
742
        QTAILQ_REMOVE(&ring->unused, xfer, next);
743
        usb_host_iso_reset_xfer(xfer);
744
        QTAILQ_INSERT_TAIL(&ring->copy, xfer, next);
745
    }
746
    usb_host_iso_data_copy(xfer, p);
747

748
    if (QTAILQ_EMPTY(&ring->inflight)) {
749
        /* wait until half of our buffers are filled
750
           before kicking the iso out stream */
751
        if (filled*2 < s->iso_urb_count) {
752
            return;
753
        }
754
    }
755

756
    /* submit filled bufs to host */
757
    while ((xfer = QTAILQ_FIRST(&ring->copy)) != NULL &&
758
           xfer->copy_complete) {
759
        QTAILQ_REMOVE(&ring->copy, xfer, next);
760
        rc = libusb_submit_transfer(xfer->xfer);
761
        if (rc != 0) {
762
            usb_host_libusb_error("libusb_submit_transfer [iso]", rc);
763
            QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
764
            if (rc == LIBUSB_ERROR_NO_DEVICE) {
765
                disconnect = true;
766
            }
767
            break;
768
        }
769
        if (QTAILQ_EMPTY(&ring->inflight)) {
770
            trace_usb_host_iso_start(s->bus_num, s->addr, p->ep->nr);
771
        }
772
        QTAILQ_INSERT_TAIL(&ring->inflight, xfer, next);
773
    }
774

775
    if (disconnect) {
776
        usb_host_nodev(s);
777
    }
778
}
779

780
/* ------------------------------------------------------------------------ */
781

782
static void usb_host_speed_compat(USBHostDevice *s)
783
{
784
    USBDevice *udev = USB_DEVICE(s);
785
    struct libusb_config_descriptor *conf;
786
    const struct libusb_interface_descriptor *intf;
787
    const struct libusb_endpoint_descriptor *endp;
788
#ifdef HAVE_STREAMS
789
    struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
790
#endif
791
    bool compat_high = true;
792
    bool compat_full = true;
793
    uint8_t type;
794
    int rc, c, i, a, e;
795

796
    for (c = 0;; c++) {
797
        rc = libusb_get_config_descriptor(s->dev, c, &conf);
798
        if (rc != 0) {
799
            break;
800
        }
801
        for (i = 0; i < conf->bNumInterfaces; i++) {
802
            for (a = 0; a < conf->interface[i].num_altsetting; a++) {
803
                intf = &conf->interface[i].altsetting[a];
804

805
                if (intf->bInterfaceClass == LIBUSB_CLASS_MASS_STORAGE &&
806
                    intf->bInterfaceSubClass == 6) { /* SCSI */
807
                    udev->flags |= (1 << USB_DEV_FLAG_IS_SCSI_STORAGE);
808
                    break;
809
                }
810

811
                for (e = 0; e < intf->bNumEndpoints; e++) {
812
                    endp = &intf->endpoint[e];
813
                    type = endp->bmAttributes & 0x3;
814
                    switch (type) {
815
                    case 0x01: /* ISO */
816
                        compat_full = false;
817
                        compat_high = false;
818
                        break;
819
                    case 0x02: /* BULK */
820
#ifdef HAVE_STREAMS
821
                        rc = libusb_get_ss_endpoint_companion_descriptor
822
                            (ctx, endp, &endp_ss_comp);
823
                        if (rc == LIBUSB_SUCCESS) {
824
                            int streams = endp_ss_comp->bmAttributes & 0x1f;
825
                            if (streams) {
826
                                compat_full = false;
827
                                compat_high = false;
828
                            }
829
                            libusb_free_ss_endpoint_companion_descriptor
830
                                (endp_ss_comp);
831
                        }
832
#endif
833
                        break;
834
                    case 0x03: /* INTERRUPT */
835
                        if (endp->wMaxPacketSize > 64) {
836
                            compat_full = false;
837
                        }
838
                        if (endp->wMaxPacketSize > 1024) {
839
                            compat_high = false;
840
                        }
841
                        break;
842
                    }
843
                }
844
            }
845
        }
846
        libusb_free_config_descriptor(conf);
847
    }
848

849
    udev->speedmask = (1 << udev->speed);
850
    if (udev->speed == USB_SPEED_SUPER && compat_high) {
851
        udev->speedmask |= USB_SPEED_MASK_HIGH;
852
    }
853
    if (udev->speed == USB_SPEED_SUPER && compat_full) {
854
        udev->speedmask |= USB_SPEED_MASK_FULL;
855
    }
856
    if (udev->speed == USB_SPEED_HIGH && compat_full) {
857
        udev->speedmask |= USB_SPEED_MASK_FULL;
858
    }
859
}
860

861
static void usb_host_ep_update(USBHostDevice *s)
862
{
863
    static const char *tname[] = {
864
        [USB_ENDPOINT_XFER_CONTROL] = "control",
865
        [USB_ENDPOINT_XFER_ISOC]    = "isoc",
866
        [USB_ENDPOINT_XFER_BULK]    = "bulk",
867
        [USB_ENDPOINT_XFER_INT]     = "int",
868
    };
869
    USBDevice *udev = USB_DEVICE(s);
870
    struct libusb_config_descriptor *conf;
871
    const struct libusb_interface_descriptor *intf;
872
    const struct libusb_endpoint_descriptor *endp;
873
#ifdef HAVE_STREAMS
874
    struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
875
#endif
876
    uint8_t devep, type;
877
    int pid, ep, alt;
878
    int rc, i, e;
879

880
    usb_ep_reset(udev);
881
    rc = libusb_get_active_config_descriptor(s->dev, &conf);
882
    if (rc != 0) {
883
        return;
884
    }
885
    trace_usb_host_parse_config(s->bus_num, s->addr,
886
                                conf->bConfigurationValue, true);
887

888
    for (i = 0; i < conf->bNumInterfaces; i++) {
889
        /*
890
         * The udev->altsetting array indexes alternate settings
891
         * by the interface number. Get the 0th alternate setting
892
         * first so that we can grab the interface number, and
893
         * then correct the alternate setting value if necessary.
894
         */
895
        intf = &conf->interface[i].altsetting[0];
896
        alt = udev->altsetting[intf->bInterfaceNumber];
897

898
        if (alt != 0) {
899
            assert(alt < conf->interface[i].num_altsetting);
900
            intf = &conf->interface[i].altsetting[alt];
901
        }
902

903
        trace_usb_host_parse_interface(s->bus_num, s->addr,
904
                                       intf->bInterfaceNumber,
905
                                       intf->bAlternateSetting, true);
906
        for (e = 0; e < intf->bNumEndpoints; e++) {
907
            endp = &intf->endpoint[e];
908

909
            devep = endp->bEndpointAddress;
910
            pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
911
            ep = devep & 0xf;
912
            type = endp->bmAttributes & 0x3;
913

914
            if (ep == 0) {
915
                trace_usb_host_parse_error(s->bus_num, s->addr,
916
                                           "invalid endpoint address");
917
                return;
918
            }
919
            if (usb_ep_get_type(udev, pid, ep) != USB_ENDPOINT_XFER_INVALID) {
920
                trace_usb_host_parse_error(s->bus_num, s->addr,
921
                                           "duplicate endpoint address");
922
                return;
923
            }
924

925
            trace_usb_host_parse_endpoint(s->bus_num, s->addr, ep,
926
                                          (devep & USB_DIR_IN) ? "in" : "out",
927
                                          tname[type], true);
928
            usb_ep_set_max_packet_size(udev, pid, ep,
929
                                       endp->wMaxPacketSize);
930
            usb_ep_set_type(udev, pid, ep, type);
931
            usb_ep_set_ifnum(udev, pid, ep, i);
932
            usb_ep_set_halted(udev, pid, ep, 0);
933
#ifdef HAVE_STREAMS
934
            if (type == LIBUSB_TRANSFER_TYPE_BULK &&
935
                    libusb_get_ss_endpoint_companion_descriptor(ctx, endp,
936
                        &endp_ss_comp) == LIBUSB_SUCCESS) {
937
                usb_ep_set_max_streams(udev, pid, ep,
938
                                       endp_ss_comp->bmAttributes);
939
                libusb_free_ss_endpoint_companion_descriptor(endp_ss_comp);
940
            }
941
#endif
942
        }
943
    }
944

945
    libusb_free_config_descriptor(conf);
946
}
947

948
static int usb_host_open(USBHostDevice *s, libusb_device *dev, int hostfd)
949
{
950
    USBDevice *udev = USB_DEVICE(s);
951
    int libusb_speed;
952
    int bus_num = 0;
953
    int addr = 0;
954
    int rc;
955
    Error *local_err = NULL;
956

957
    if (s->bh_postld_pending) {
958
        return -1;
959
    }
960
    if (s->dh != NULL) {
961
        goto fail;
962
    }
963

964
    if (dev) {
965
        bus_num = libusb_get_bus_number(dev);
966
        addr = libusb_get_device_address(dev);
967
        trace_usb_host_open_started(bus_num, addr);
968

969
        rc = libusb_open(dev, &s->dh);
970
        if (rc != 0) {
971
            goto fail;
972
        }
973
    } else {
974
#if LIBUSB_API_VERSION >= 0x01000107 && !defined(CONFIG_WIN32)
975
        trace_usb_host_open_hostfd(hostfd);
976

977
        rc = libusb_wrap_sys_device(ctx, hostfd, &s->dh);
978
        if (rc != 0) {
979
            goto fail;
980
        }
981
        s->hostfd  = hostfd;
982
        dev = libusb_get_device(s->dh);
983
        bus_num = libusb_get_bus_number(dev);
984
        addr = libusb_get_device_address(dev);
985
#else
986
        g_assert_not_reached();
987
#endif
988
    }
989

990
    s->dev     = dev;
991
    s->bus_num = bus_num;
992
    s->addr    = addr;
993

994
    usb_host_detach_kernel(s);
995

996
    libusb_get_device_descriptor(dev, &s->ddesc);
997
    usb_host_get_port(s->dev, s->port, sizeof(s->port));
998

999
    usb_ep_init(udev);
1000
    usb_host_ep_update(s);
1001

1002
    libusb_speed = libusb_get_device_speed(dev);
1003
#if LIBUSB_API_VERSION >= 0x01000107 && defined(CONFIG_LINUX) && \
1004
        defined(USBDEVFS_GET_SPEED)
1005
    if (hostfd && libusb_speed == 0) {
1006
        /*
1007
         * Workaround libusb bug: libusb_get_device_speed() does not
1008
         * work for libusb_wrap_sys_device() devices in v1.0.23.
1009
         *
1010
         * Speeds are defined in linux/usb/ch9.h, file not included
1011
         * due to name conflicts.
1012
         */
1013
        rc = ioctl(hostfd, USBDEVFS_GET_SPEED, NULL);
1014
        switch (rc) {
1015
        case 1: /* low */
1016
            libusb_speed = LIBUSB_SPEED_LOW;
1017
            break;
1018
        case 2: /* full */
1019
            libusb_speed = LIBUSB_SPEED_FULL;
1020
            break;
1021
        case 3: /* high */
1022
        case 4: /* wireless */
1023
            libusb_speed = LIBUSB_SPEED_HIGH;
1024
            break;
1025
        case 5: /* super */
1026
            libusb_speed = LIBUSB_SPEED_SUPER;
1027
            break;
1028
        case 6: /* super plus */
1029
#ifdef HAVE_SUPER_PLUS
1030
            libusb_speed = LIBUSB_SPEED_SUPER_PLUS;
1031
#else
1032
            libusb_speed = LIBUSB_SPEED_SUPER;
1033
#endif
1034
            break;
1035
        }
1036
    }
1037
#endif
1038
    udev->speed = speed_map[libusb_speed];
1039
    usb_host_speed_compat(s);
1040

1041
    if (s->ddesc.iProduct) {
1042
        libusb_get_string_descriptor_ascii(s->dh, s->ddesc.iProduct,
1043
                                           (unsigned char *)udev->product_desc,
1044
                                           sizeof(udev->product_desc));
1045
    } else {
1046
        snprintf(udev->product_desc, sizeof(udev->product_desc),
1047
                 "host:%d.%d", bus_num, addr);
1048
    }
1049

1050
    usb_device_attach(udev, &local_err);
1051
    if (local_err) {
1052
        error_report_err(local_err);
1053
        goto fail;
1054
    }
1055

1056
    trace_usb_host_open_success(bus_num, addr);
1057
    return 0;
1058

1059
fail:
1060
    trace_usb_host_open_failure(bus_num, addr);
1061
    if (s->dh != NULL) {
1062
        usb_host_release_interfaces(s);
1063
        libusb_reset_device(s->dh);
1064
        usb_host_attach_kernel(s);
1065
        libusb_close(s->dh);
1066
        s->dh = NULL;
1067
        s->dev = NULL;
1068
    }
1069
    return -1;
1070
}
1071

1072
static void usb_host_abort_xfers(USBHostDevice *s)
1073
{
1074
    USBHostRequest *r, *rtmp;
1075
    int limit = 100;
1076

1077
    QTAILQ_FOREACH_SAFE(r, &s->requests, next, rtmp) {
1078
        usb_host_req_abort(r);
1079
    }
1080

1081
    while (QTAILQ_FIRST(&s->requests) != NULL) {
1082
        struct timeval tv;
1083
        memset(&tv, 0, sizeof(tv));
1084
        tv.tv_usec = 2500;
1085
        libusb_handle_events_timeout(ctx, &tv);
1086
        if (--limit == 0) {
1087
            /*
1088
             * Don't wait forever for libusb calling the complete
1089
             * callback (which will unlink and free the request).
1090
             *
1091
             * Leaking memory here, to make sure libusb will not
1092
             * access memory which we have released already.
1093
             */
1094
            QTAILQ_FOREACH_SAFE(r, &s->requests, next, rtmp) {
1095
                QTAILQ_REMOVE(&s->requests, r, next);
1096
            }
1097
            return;
1098
        }
1099
    }
1100
}
1101

1102
static int usb_host_close(USBHostDevice *s)
1103
{
1104
    USBDevice *udev = USB_DEVICE(s);
1105

1106
    if (s->dh == NULL) {
1107
        return -1;
1108
    }
1109

1110
    trace_usb_host_close(s->bus_num, s->addr);
1111

1112
    usb_host_abort_xfers(s);
1113
    usb_host_iso_free_all(s);
1114

1115
    if (udev->attached) {
1116
        usb_device_detach(udev);
1117
    }
1118

1119
    usb_host_release_interfaces(s);
1120
    libusb_reset_device(s->dh);
1121
    usb_host_attach_kernel(s);
1122
    libusb_close(s->dh);
1123
    s->dh = NULL;
1124
    s->dev = NULL;
1125

1126
    if (s->hostfd != -1) {
1127
        close(s->hostfd);
1128
        s->hostfd = -1;
1129
    }
1130

1131
    usb_host_auto_check(NULL);
1132
    return 0;
1133
}
1134

1135
static void usb_host_nodev_bh(void *opaque)
1136
{
1137
    USBHostDevice *s = opaque;
1138
    usb_host_close(s);
1139
}
1140

1141
static void usb_host_nodev(USBHostDevice *s)
1142
{
1143
    if (!s->bh_nodev) {
1144
        s->bh_nodev = qemu_bh_new_guarded(usb_host_nodev_bh, s,
1145
                                          &DEVICE(s)->mem_reentrancy_guard);
1146
    }
1147
    qemu_bh_schedule(s->bh_nodev);
1148
}
1149

1150
static void usb_host_exit_notifier(struct Notifier *n, void *data)
1151
{
1152
    USBHostDevice *s = container_of(n, USBHostDevice, exit);
1153

1154
    if (s->dh) {
1155
        usb_host_abort_xfers(s);
1156
        usb_host_release_interfaces(s);
1157
        libusb_reset_device(s->dh);
1158
        usb_host_attach_kernel(s);
1159
        libusb_close(s->dh);
1160
    }
1161
}
1162

1163
static libusb_device *usb_host_find_ref(int bus, int addr)
1164
{
1165
    libusb_device **devs = NULL;
1166
    libusb_device *ret = NULL;
1167
    int i, n;
1168

1169
    n = libusb_get_device_list(ctx, &devs);
1170
    for (i = 0; i < n; i++) {
1171
        if (libusb_get_bus_number(devs[i]) == bus &&
1172
            libusb_get_device_address(devs[i]) == addr) {
1173
            ret = libusb_ref_device(devs[i]);
1174
            break;
1175
        }
1176
    }
1177
    libusb_free_device_list(devs, 1);
1178
    return ret;
1179
}
1180

1181
static void usb_host_realize(USBDevice *udev, Error **errp)
1182
{
1183
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1184
    libusb_device *ldev;
1185
    int rc;
1186

1187
    if (usb_host_init() != 0) {
1188
        error_setg(errp, "failed to init libusb");
1189
        return;
1190
    }
1191
    if (s->match.vendor_id > 0xffff) {
1192
        error_setg(errp, "vendorid out of range");
1193
        return;
1194
    }
1195
    if (s->match.product_id > 0xffff) {
1196
        error_setg(errp, "productid out of range");
1197
        return;
1198
    }
1199
    if (s->match.addr > 127) {
1200
        error_setg(errp, "hostaddr out of range");
1201
        return;
1202
    }
1203

1204
    loglevel = s->loglevel;
1205
    udev->flags |= (1 << USB_DEV_FLAG_IS_HOST);
1206
    udev->auto_attach = 0;
1207
    QTAILQ_INIT(&s->requests);
1208
    QTAILQ_INIT(&s->isorings);
1209
    s->hostfd = -1;
1210

1211
#if LIBUSB_API_VERSION >= 0x01000107 && !defined(CONFIG_WIN32)
1212
    if (s->hostdevice) {
1213
        int fd;
1214
        s->needs_autoscan = false;
1215
        fd = qemu_open(s->hostdevice, O_RDWR, errp);
1216
        if (fd < 0) {
1217
            return;
1218
        }
1219
        rc = usb_host_open(s, NULL, fd);
1220
        if (rc < 0) {
1221
            error_setg(errp, "failed to open host usb device %s", s->hostdevice);
1222
            return;
1223
        }
1224
    } else
1225
#endif
1226
    if (s->match.addr && s->match.bus_num &&
1227
        !s->match.vendor_id &&
1228
        !s->match.product_id &&
1229
        !s->match.port) {
1230
        s->needs_autoscan = false;
1231
        ldev = usb_host_find_ref(s->match.bus_num,
1232
                                 s->match.addr);
1233
        if (!ldev) {
1234
            error_setg(errp, "failed to find host usb device %d:%d",
1235
                       s->match.bus_num, s->match.addr);
1236
            return;
1237
        }
1238
        rc = usb_host_open(s, ldev, 0);
1239
        libusb_unref_device(ldev);
1240
        if (rc < 0) {
1241
            error_setg(errp, "failed to open host usb device %d:%d",
1242
                       s->match.bus_num, s->match.addr);
1243
            return;
1244
        }
1245
    } else {
1246
        s->needs_autoscan = true;
1247
        QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1248
        usb_host_auto_check(NULL);
1249
    }
1250

1251
    s->exit.notify = usb_host_exit_notifier;
1252
    qemu_add_exit_notifier(&s->exit);
1253
}
1254

1255
static void usb_host_instance_init(Object *obj)
1256
{
1257
    USBDevice *udev = USB_DEVICE(obj);
1258
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1259

1260
    device_add_bootindex_property(obj, &s->bootindex,
1261
                                  "bootindex", NULL,
1262
                                  &udev->qdev);
1263
}
1264

1265
static void usb_host_unrealize(USBDevice *udev)
1266
{
1267
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1268

1269
    qemu_remove_exit_notifier(&s->exit);
1270
    if (s->needs_autoscan) {
1271
        QTAILQ_REMOVE(&hostdevs, s, next);
1272
    }
1273
    usb_host_close(s);
1274
}
1275

1276
static void usb_host_cancel_packet(USBDevice *udev, USBPacket *p)
1277
{
1278
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1279
    USBHostRequest *r;
1280

1281
    if (p->combined) {
1282
        usb_combined_packet_cancel(udev, p);
1283
        return;
1284
    }
1285

1286
    trace_usb_host_req_canceled(s->bus_num, s->addr, p);
1287

1288
    r = usb_host_req_find(s, p);
1289
    if (r && r->p) {
1290
        r->p = NULL; /* mark as dead */
1291
        libusb_cancel_transfer(r->xfer);
1292
    }
1293
}
1294

1295
static void usb_host_detach_kernel(USBHostDevice *s)
1296
{
1297
    struct libusb_config_descriptor *conf;
1298
    int rc, i;
1299

1300
    rc = libusb_get_active_config_descriptor(s->dev, &conf);
1301
    if (rc != 0) {
1302
        return;
1303
    }
1304
    for (i = 0; i < USB_MAX_INTERFACES; i++) {
1305
        rc = libusb_kernel_driver_active(s->dh, i);
1306
        usb_host_libusb_error("libusb_kernel_driver_active", rc);
1307
        if (rc != 1) {
1308
            if (rc == 0) {
1309
                s->ifs[i].detached = true;
1310
            }
1311
            continue;
1312
        }
1313
        trace_usb_host_detach_kernel(s->bus_num, s->addr, i);
1314
        rc = libusb_detach_kernel_driver(s->dh, i);
1315
        usb_host_libusb_error("libusb_detach_kernel_driver", rc);
1316
        s->ifs[i].detached = true;
1317
    }
1318
    libusb_free_config_descriptor(conf);
1319
}
1320

1321
static void usb_host_attach_kernel(USBHostDevice *s)
1322
{
1323
    struct libusb_config_descriptor *conf;
1324
    int rc, i;
1325

1326
    rc = libusb_get_active_config_descriptor(s->dev, &conf);
1327
    if (rc != 0) {
1328
        return;
1329
    }
1330
    for (i = 0; i < USB_MAX_INTERFACES; i++) {
1331
        if (!s->ifs[i].detached) {
1332
            continue;
1333
        }
1334
        trace_usb_host_attach_kernel(s->bus_num, s->addr, i);
1335
        libusb_attach_kernel_driver(s->dh, i);
1336
        s->ifs[i].detached = false;
1337
    }
1338
    libusb_free_config_descriptor(conf);
1339
}
1340

1341
static int usb_host_claim_interfaces(USBHostDevice *s, int configuration)
1342
{
1343
    USBDevice *udev = USB_DEVICE(s);
1344
    struct libusb_config_descriptor *conf;
1345
    int rc, i, claimed;
1346

1347
    for (i = 0; i < USB_MAX_INTERFACES; i++) {
1348
        udev->altsetting[i] = 0;
1349
    }
1350
    udev->ninterfaces   = 0;
1351
    udev->configuration = 0;
1352

1353
    usb_host_detach_kernel(s);
1354

1355
    rc = libusb_get_active_config_descriptor(s->dev, &conf);
1356
    if (rc != 0) {
1357
        if (rc == LIBUSB_ERROR_NOT_FOUND) {
1358
            /* address state - ignore */
1359
            return USB_RET_SUCCESS;
1360
        }
1361
        return USB_RET_STALL;
1362
    }
1363

1364
    claimed = 0;
1365
    for (i = 0; i < USB_MAX_INTERFACES; i++) {
1366
        trace_usb_host_claim_interface(s->bus_num, s->addr, configuration, i);
1367
        rc = libusb_claim_interface(s->dh, i);
1368
        if (rc == 0) {
1369
            s->ifs[i].claimed = true;
1370
            if (++claimed == conf->bNumInterfaces) {
1371
                break;
1372
            }
1373
        }
1374
    }
1375
    if (claimed != conf->bNumInterfaces) {
1376
        return USB_RET_STALL;
1377
    }
1378

1379
    udev->ninterfaces   = conf->bNumInterfaces;
1380
    udev->configuration = configuration;
1381

1382
    libusb_free_config_descriptor(conf);
1383
    return USB_RET_SUCCESS;
1384
}
1385

1386
static void usb_host_release_interfaces(USBHostDevice *s)
1387
{
1388
    int i, rc;
1389

1390
    for (i = 0; i < USB_MAX_INTERFACES; i++) {
1391
        if (!s->ifs[i].claimed) {
1392
            continue;
1393
        }
1394
        trace_usb_host_release_interface(s->bus_num, s->addr, i);
1395
        rc = libusb_release_interface(s->dh, i);
1396
        usb_host_libusb_error("libusb_release_interface", rc);
1397
        s->ifs[i].claimed = false;
1398
    }
1399
}
1400

1401
static void usb_host_set_address(USBHostDevice *s, int addr)
1402
{
1403
    USBDevice *udev = USB_DEVICE(s);
1404

1405
    trace_usb_host_set_address(s->bus_num, s->addr, addr);
1406
    udev->addr = addr;
1407
}
1408

1409
static void usb_host_set_config(USBHostDevice *s, int config, USBPacket *p)
1410
{
1411
    int rc = 0;
1412

1413
    trace_usb_host_set_config(s->bus_num, s->addr, config);
1414

1415
    usb_host_release_interfaces(s);
1416
    if (s->ddesc.bNumConfigurations != 1) {
1417
        rc = libusb_set_configuration(s->dh, config);
1418
        if (rc != 0) {
1419
            usb_host_libusb_error("libusb_set_configuration", rc);
1420
            p->status = USB_RET_STALL;
1421
            if (rc == LIBUSB_ERROR_NO_DEVICE) {
1422
                usb_host_nodev(s);
1423
            }
1424
            return;
1425
        }
1426
    }
1427
    p->status = usb_host_claim_interfaces(s, config);
1428
    if (p->status != USB_RET_SUCCESS) {
1429
        return;
1430
    }
1431
    usb_host_ep_update(s);
1432
}
1433

1434
static void usb_host_set_interface(USBHostDevice *s, int iface, int alt,
1435
                                   USBPacket *p)
1436
{
1437
    USBDevice *udev = USB_DEVICE(s);
1438
    int rc;
1439

1440
    trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
1441

1442
    usb_host_iso_free_all(s);
1443

1444
    if (iface >= USB_MAX_INTERFACES) {
1445
        p->status = USB_RET_STALL;
1446
        return;
1447
    }
1448

1449
    rc = libusb_set_interface_alt_setting(s->dh, iface, alt);
1450
    if (rc != 0) {
1451
        usb_host_libusb_error("libusb_set_interface_alt_setting", rc);
1452
        p->status = USB_RET_STALL;
1453
        if (rc == LIBUSB_ERROR_NO_DEVICE) {
1454
            usb_host_nodev(s);
1455
        }
1456
        return;
1457
    }
1458

1459
    udev->altsetting[iface] = alt;
1460
    usb_host_ep_update(s);
1461
}
1462

1463
static void usb_host_handle_control(USBDevice *udev, USBPacket *p,
1464
                                    int request, int value, int index,
1465
                                    int length, uint8_t *data)
1466
{
1467
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1468
    USBHostRequest *r;
1469
    int rc;
1470

1471
    trace_usb_host_req_control(s->bus_num, s->addr, p, request, value, index);
1472

1473
    if (s->dh == NULL) {
1474
        p->status = USB_RET_NODEV;
1475
        trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1476
        return;
1477
    }
1478

1479
    switch (request) {
1480
    case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1481
        usb_host_set_address(s, value);
1482
        trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1483
        return;
1484

1485
    case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1486
        usb_host_set_config(s, value & 0xff, p);
1487
        trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1488
        return;
1489

1490
    case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1491
        usb_host_set_interface(s, index, value, p);
1492
        trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1493
        return;
1494

1495
    case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
1496
        if (value == 0) { /* clear halt */
1497
            int pid = (index & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1498
            libusb_clear_halt(s->dh, index);
1499
            usb_ep_set_halted(udev, pid, index & 0x0f, 0);
1500
            trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1501
            return;
1502
        }
1503
    }
1504

1505
    r = usb_host_req_alloc(s, p, (request >> 8) & USB_DIR_IN, length + 8);
1506
    r->cbuf = data;
1507
    r->clen = length;
1508
    memcpy(r->buffer, udev->setup_buf, 8);
1509
    if (!r->in) {
1510
        memcpy(r->buffer + 8, r->cbuf, r->clen);
1511
    }
1512

1513
    /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices
1514
     * to work redirected to a not superspeed capable hcd */
1515
    if ((udev->speedmask & USB_SPEED_MASK_SUPER) &&
1516
        !(udev->port->speedmask & USB_SPEED_MASK_SUPER) &&
1517
        request == 0x8006 && value == 0x100 && index == 0) {
1518
        r->usb3ep0quirk = true;
1519
    }
1520

1521
    libusb_fill_control_transfer(r->xfer, s->dh, r->buffer,
1522
                                 usb_host_req_complete_ctrl, r,
1523
                                 CONTROL_TIMEOUT);
1524
    rc = libusb_submit_transfer(r->xfer);
1525
    if (rc != 0) {
1526
        p->status = USB_RET_NODEV;
1527
        trace_usb_host_req_complete(s->bus_num, s->addr, p,
1528
                                    p->status, p->actual_length);
1529
        if (rc == LIBUSB_ERROR_NO_DEVICE) {
1530
            usb_host_nodev(s);
1531
        }
1532
        return;
1533
    }
1534

1535
    p->status = USB_RET_ASYNC;
1536
}
1537

1538
static void usb_host_handle_data(USBDevice *udev, USBPacket *p)
1539
{
1540
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1541
    USBHostRequest *r;
1542
    size_t size;
1543
    int ep, rc;
1544

1545
    if (usb_host_use_combining(p->ep) && p->state == USB_PACKET_SETUP) {
1546
        p->status = USB_RET_ADD_TO_QUEUE;
1547
        return;
1548
    }
1549

1550
    trace_usb_host_req_data(s->bus_num, s->addr, p,
1551
                            p->pid == USB_TOKEN_IN,
1552
                            p->ep->nr, p->iov.size);
1553

1554
    if (s->dh == NULL) {
1555
        p->status = USB_RET_NODEV;
1556
        trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1557
        return;
1558
    }
1559
    if (p->ep->halted) {
1560
        p->status = USB_RET_STALL;
1561
        trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1562
        return;
1563
    }
1564

1565
    switch (usb_ep_get_type(udev, p->pid, p->ep->nr)) {
1566
    case USB_ENDPOINT_XFER_BULK:
1567
        size = usb_packet_size(p);
1568
        r = usb_host_req_alloc(s, p, p->pid == USB_TOKEN_IN, size);
1569
        if (!r->in) {
1570
            usb_packet_copy(p, r->buffer, size);
1571
        }
1572
        ep = p->ep->nr | (r->in ? USB_DIR_IN : 0);
1573
        if (p->stream) {
1574
#ifdef HAVE_STREAMS
1575
            libusb_fill_bulk_stream_transfer(r->xfer, s->dh, ep, p->stream,
1576
                                             r->buffer, size,
1577
                                             usb_host_req_complete_data, r,
1578
                                             BULK_TIMEOUT);
1579
#else
1580
            usb_host_req_free(r);
1581
            p->status = USB_RET_STALL;
1582
            return;
1583
#endif
1584
        } else {
1585
            libusb_fill_bulk_transfer(r->xfer, s->dh, ep,
1586
                                      r->buffer, size,
1587
                                      usb_host_req_complete_data, r,
1588
                                      BULK_TIMEOUT);
1589
        }
1590
        break;
1591
    case USB_ENDPOINT_XFER_INT:
1592
        r = usb_host_req_alloc(s, p, p->pid == USB_TOKEN_IN, p->iov.size);
1593
        if (!r->in) {
1594
            usb_packet_copy(p, r->buffer, p->iov.size);
1595
        }
1596
        ep = p->ep->nr | (r->in ? USB_DIR_IN : 0);
1597
        libusb_fill_interrupt_transfer(r->xfer, s->dh, ep,
1598
                                       r->buffer, p->iov.size,
1599
                                       usb_host_req_complete_data, r,
1600
                                       INTR_TIMEOUT);
1601
        break;
1602
    case USB_ENDPOINT_XFER_ISOC:
1603
        if (p->pid == USB_TOKEN_IN) {
1604
            usb_host_iso_data_in(s, p);
1605
        } else {
1606
            usb_host_iso_data_out(s, p);
1607
        }
1608
        trace_usb_host_req_complete(s->bus_num, s->addr, p,
1609
                                    p->status, p->actual_length);
1610
        return;
1611
    default:
1612
        p->status = USB_RET_STALL;
1613
        trace_usb_host_req_complete(s->bus_num, s->addr, p,
1614
                                    p->status, p->actual_length);
1615
        return;
1616
    }
1617

1618
    rc = libusb_submit_transfer(r->xfer);
1619
    if (rc != 0) {
1620
        p->status = USB_RET_NODEV;
1621
        trace_usb_host_req_complete(s->bus_num, s->addr, p,
1622
                                    p->status, p->actual_length);
1623
        if (rc == LIBUSB_ERROR_NO_DEVICE) {
1624
            usb_host_nodev(s);
1625
        }
1626
        return;
1627
    }
1628

1629
    p->status = USB_RET_ASYNC;
1630
}
1631

1632
static void usb_host_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
1633
{
1634
    if (usb_host_use_combining(ep)) {
1635
        usb_ep_combine_input_packets(ep);
1636
    }
1637
}
1638

1639
static void usb_host_handle_reset(USBDevice *udev)
1640
{
1641
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1642
    int rc;
1643

1644
    if (!s->allow_one_guest_reset && !s->allow_all_guest_resets) {
1645
        return;
1646
    }
1647
    if (!s->allow_all_guest_resets && udev->addr == 0) {
1648
        return;
1649
    }
1650

1651
    trace_usb_host_reset(s->bus_num, s->addr);
1652

1653
    rc = libusb_reset_device(s->dh);
1654
    if (rc != 0) {
1655
        usb_host_nodev(s);
1656
    }
1657
}
1658

1659
static int usb_host_alloc_streams(USBDevice *udev, USBEndpoint **eps,
1660
                                  int nr_eps, int streams)
1661
{
1662
#ifdef HAVE_STREAMS
1663
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1664
    unsigned char endpoints[30];
1665
    int i, rc;
1666

1667
    for (i = 0; i < nr_eps; i++) {
1668
        endpoints[i] = eps[i]->nr;
1669
        if (eps[i]->pid == USB_TOKEN_IN) {
1670
            endpoints[i] |= 0x80;
1671
        }
1672
    }
1673
    rc = libusb_alloc_streams(s->dh, streams, endpoints, nr_eps);
1674
    if (rc < 0) {
1675
        usb_host_libusb_error("libusb_alloc_streams", rc);
1676
    } else if (rc != streams) {
1677
        error_report("libusb_alloc_streams: got less streams "
1678
                     "then requested %d < %d", rc, streams);
1679
    }
1680

1681
    return (rc == streams) ? 0 : -1;
1682
#else
1683
    error_report("libusb_alloc_streams: error not implemented");
1684
    return -1;
1685
#endif
1686
}
1687

1688
static void usb_host_free_streams(USBDevice *udev, USBEndpoint **eps,
1689
                                  int nr_eps)
1690
{
1691
#ifdef HAVE_STREAMS
1692
    USBHostDevice *s = USB_HOST_DEVICE(udev);
1693
    unsigned char endpoints[30];
1694
    int i;
1695

1696
    for (i = 0; i < nr_eps; i++) {
1697
        endpoints[i] = eps[i]->nr;
1698
        if (eps[i]->pid == USB_TOKEN_IN) {
1699
            endpoints[i] |= 0x80;
1700
        }
1701
    }
1702
    libusb_free_streams(s->dh, endpoints, nr_eps);
1703
#endif
1704
}
1705

1706
/*
1707
 * This is *NOT* about restoring state.  We have absolutely no idea
1708
 * what state the host device is in at the moment and whenever it is
1709
 * still present in the first place.  Attempting to continue where we
1710
 * left off is impossible.
1711
 *
1712
 * What we are going to do here is emulate a surprise removal of
1713
 * the usb device passed through, then kick host scan so the device
1714
 * will get re-attached (and re-initialized by the guest) in case it
1715
 * is still present.
1716
 *
1717
 * As the device removal will change the state of other devices (usb
1718
 * host controller, most likely interrupt controller too) we have to
1719
 * wait with it until *all* vmstate is loaded.  Thus post_load just
1720
 * kicks a bottom half which then does the actual work.
1721
 */
1722
static void usb_host_post_load_bh(void *opaque)
1723
{
1724
    USBHostDevice *dev = opaque;
1725
    USBDevice *udev = USB_DEVICE(dev);
1726

1727
    if (dev->dh != NULL) {
1728
        usb_host_close(dev);
1729
    }
1730
    if (udev->attached) {
1731
        usb_device_detach(udev);
1732
    }
1733
    dev->bh_postld_pending = false;
1734
    usb_host_auto_check(NULL);
1735
}
1736

1737
static int usb_host_post_load(void *opaque, int version_id)
1738
{
1739
    USBHostDevice *dev = opaque;
1740

1741
    if (!dev->bh_postld) {
1742
        dev->bh_postld = qemu_bh_new_guarded(usb_host_post_load_bh, dev,
1743
                                             &DEVICE(dev)->mem_reentrancy_guard);
1744
    }
1745
    qemu_bh_schedule(dev->bh_postld);
1746
    dev->bh_postld_pending = true;
1747
    return 0;
1748
}
1749

1750
static const VMStateDescription vmstate_usb_host = {
1751
    .name = "usb-host",
1752
    .version_id = 1,
1753
    .minimum_version_id = 1,
1754
    .post_load = usb_host_post_load,
1755
    .fields = (const VMStateField[]) {
1756
        VMSTATE_USB_DEVICE(parent_obj, USBHostDevice),
1757
        VMSTATE_END_OF_LIST()
1758
    }
1759
};
1760

1761
static Property usb_host_dev_properties[] = {
1762
    DEFINE_PROP_UINT32("hostbus",  USBHostDevice, match.bus_num,    0),
1763
    DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr,       0),
1764
    DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1765
    DEFINE_PROP_UINT32("vendorid",  USBHostDevice, match.vendor_id,  0),
1766
    DEFINE_PROP_UINT32("productid", USBHostDevice, match.product_id, 0),
1767
#if LIBUSB_API_VERSION >= 0x01000107
1768
    DEFINE_PROP_STRING("hostdevice", USBHostDevice, hostdevice),
1769
#endif
1770
    DEFINE_PROP_UINT32("isobufs",  USBHostDevice, iso_urb_count,    4),
1771
    DEFINE_PROP_UINT32("isobsize", USBHostDevice, iso_urb_frames,   32),
1772
    DEFINE_PROP_BOOL("guest-reset", USBHostDevice,
1773
                     allow_one_guest_reset, true),
1774
    DEFINE_PROP_BOOL("guest-resets-all", USBHostDevice,
1775
                     allow_all_guest_resets, false),
1776
    DEFINE_PROP_UINT32("loglevel",  USBHostDevice, loglevel,
1777
                       LIBUSB_LOG_LEVEL_WARNING),
1778
    DEFINE_PROP_BIT("pipeline",    USBHostDevice, options,
1779
                    USB_HOST_OPT_PIPELINE, true),
1780
    DEFINE_PROP_BOOL("suppress-remote-wake", USBHostDevice,
1781
                     suppress_remote_wake, true),
1782
    DEFINE_PROP_END_OF_LIST(),
1783
};
1784

1785
static void usb_host_class_initfn(ObjectClass *klass, void *data)
1786
{
1787
    DeviceClass *dc = DEVICE_CLASS(klass);
1788
    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
1789

1790
    uc->realize        = usb_host_realize;
1791
    uc->product_desc   = "USB Host Device";
1792
    uc->cancel_packet  = usb_host_cancel_packet;
1793
    uc->handle_data    = usb_host_handle_data;
1794
    uc->handle_control = usb_host_handle_control;
1795
    uc->handle_reset   = usb_host_handle_reset;
1796
    uc->unrealize      = usb_host_unrealize;
1797
    uc->flush_ep_queue = usb_host_flush_ep_queue;
1798
    uc->alloc_streams  = usb_host_alloc_streams;
1799
    uc->free_streams   = usb_host_free_streams;
1800
    dc->vmsd = &vmstate_usb_host;
1801
    device_class_set_props(dc, usb_host_dev_properties);
1802
    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
1803
}
1804

1805
static const TypeInfo usb_host_dev_info = {
1806
    .name          = TYPE_USB_HOST_DEVICE,
1807
    .parent        = TYPE_USB_DEVICE,
1808
    .instance_size = sizeof(USBHostDevice),
1809
    .class_init    = usb_host_class_initfn,
1810
    .instance_init = usb_host_instance_init,
1811
};
1812
module_obj(TYPE_USB_HOST_DEVICE);
1813
module_kconfig(USB);
1814

1815
static void usb_host_register_types(void)
1816
{
1817
    type_register_static(&usb_host_dev_info);
1818
    monitor_register_hmp("usbhost", true, hmp_info_usbhost);
1819
}
1820

1821
type_init(usb_host_register_types)
1822

1823
/* ------------------------------------------------------------------------ */
1824

1825
static QEMUTimer *usb_auto_timer;
1826
static VMChangeStateEntry *usb_vmstate;
1827

1828
static void usb_host_vm_state(void *unused, bool running, RunState state)
1829
{
1830
    if (running) {
1831
        usb_host_auto_check(unused);
1832
    }
1833
}
1834

1835
static void usb_host_auto_check(void *unused)
1836
{
1837
    struct USBHostDevice *s;
1838
    struct USBAutoFilter *f;
1839
    libusb_device **devs = NULL;
1840
    struct libusb_device_descriptor ddesc;
1841
    int i, n;
1842

1843
    if (usb_host_init() != 0) {
1844
        return;
1845
    }
1846

1847
    if (runstate_is_running()) {
1848
        n = libusb_get_device_list(ctx, &devs);
1849
        for (i = 0; i < n; i++) {
1850
            if (libusb_get_device_descriptor(devs[i], &ddesc) != 0) {
1851
                continue;
1852
            }
1853
            if (ddesc.bDeviceClass == LIBUSB_CLASS_HUB) {
1854
                continue;
1855
            }
1856
            QTAILQ_FOREACH(s, &hostdevs, next) {
1857
                f = &s->match;
1858
                if (f->bus_num > 0 &&
1859
                    f->bus_num != libusb_get_bus_number(devs[i])) {
1860
                    continue;
1861
                }
1862
                if (f->addr > 0 &&
1863
                    f->addr != libusb_get_device_address(devs[i])) {
1864
                    continue;
1865
                }
1866
                if (f->port != NULL) {
1867
                    char port[16] = "-";
1868
                    usb_host_get_port(devs[i], port, sizeof(port));
1869
                    if (strcmp(f->port, port) != 0) {
1870
                        continue;
1871
                    }
1872
                }
1873
                if (f->vendor_id > 0 &&
1874
                    f->vendor_id != ddesc.idVendor) {
1875
                    continue;
1876
                }
1877
                if (f->product_id > 0 &&
1878
                    f->product_id != ddesc.idProduct) {
1879
                    continue;
1880
                }
1881

1882
                /* We got a match */
1883
                s->seen++;
1884
                if (s->errcount >= 3) {
1885
                    continue;
1886
                }
1887
                if (s->dh != NULL) {
1888
                    continue;
1889
                }
1890
                if (usb_host_open(s, devs[i], 0) < 0) {
1891
                    s->errcount++;
1892
                    continue;
1893
                }
1894
                break;
1895
            }
1896
        }
1897
        libusb_free_device_list(devs, 1);
1898

1899
        QTAILQ_FOREACH(s, &hostdevs, next) {
1900
            if (s->seen == 0) {
1901
                if (s->dh) {
1902
                    usb_host_close(s);
1903
                }
1904
                s->errcount = 0;
1905
            }
1906
            s->seen = 0;
1907
        }
1908
    }
1909

1910
    if (!usb_vmstate) {
1911
        usb_vmstate = qemu_add_vm_change_state_handler(usb_host_vm_state, NULL);
1912
    }
1913
    if (!usb_auto_timer) {
1914
        usb_auto_timer = timer_new_ms(QEMU_CLOCK_REALTIME, usb_host_auto_check, NULL);
1915
        if (!usb_auto_timer) {
1916
            return;
1917
        }
1918
        trace_usb_host_auto_scan_enabled();
1919
    }
1920
    timer_mod(usb_auto_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 2000);
1921
}
1922

1923
void hmp_info_usbhost(Monitor *mon, const QDict *qdict)
1924
{
1925
    libusb_device **devs = NULL;
1926
    struct libusb_device_descriptor ddesc;
1927
    char port[16];
1928
    int i, n;
1929

1930
    if (usb_host_init() != 0) {
1931
        return;
1932
    }
1933

1934
    n = libusb_get_device_list(ctx, &devs);
1935
    for (i = 0; i < n; i++) {
1936
        if (libusb_get_device_descriptor(devs[i], &ddesc) != 0) {
1937
            continue;
1938
        }
1939
        if (ddesc.bDeviceClass == LIBUSB_CLASS_HUB) {
1940
            continue;
1941
        }
1942
        usb_host_get_port(devs[i], port, sizeof(port));
1943
        monitor_printf(mon, "  Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1944
                       libusb_get_bus_number(devs[i]),
1945
                       libusb_get_device_address(devs[i]),
1946
                       port,
1947
                       speed_name[libusb_get_device_speed(devs[i])]);
1948
        monitor_printf(mon, "    Class %02x:", ddesc.bDeviceClass);
1949
        monitor_printf(mon, " USB device %04x:%04x",
1950
                       ddesc.idVendor, ddesc.idProduct);
1951
        if (ddesc.iProduct) {
1952
            libusb_device_handle *handle;
1953
            if (libusb_open(devs[i], &handle) == 0) {
1954
                unsigned char name[64] = "";
1955
                libusb_get_string_descriptor_ascii(handle,
1956
                                                   ddesc.iProduct,
1957
                                                   name, sizeof(name));
1958
                libusb_close(handle);
1959
                monitor_printf(mon, ", %s", name);
1960
            }
1961
        }
1962
        monitor_printf(mon, "\n");
1963
    }
1964
    libusb_free_device_list(devs, 1);
1965
}
1966