hw/usb/host-libusb.c

   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
 183 static const char *speed_name[] = {
 184     [LIBUSB_SPEED_UNKNOWN] = "?",
 185     [LIBUSB_SPEED_LOW]     = "1.5",
 186     [LIBUSB_SPEED_FULL]    = "12",
 187     [LIBUSB_SPEED_HIGH]    = "480",
 188     [LIBUSB_SPEED_SUPER]   = "5000",
 189 };
 190
 191 static const unsigned int speed_map[] = {
 192     [LIBUSB_SPEED_LOW]     = USB_SPEED_LOW,
 193     [LIBUSB_SPEED_FULL]    = USB_SPEED_FULL,
 194     [LIBUSB_SPEED_HIGH]    = USB_SPEED_HIGH,
 195     [LIBUSB_SPEED_SUPER]   = USB_SPEED_SUPER,
 196 };
 197
 198 static const unsigned int status_map[] = {
 199     [LIBUSB_TRANSFER_COMPLETED] = USB_RET_SUCCESS,
 200     [LIBUSB_TRANSFER_ERROR]     = USB_RET_IOERROR,
 201     [LIBUSB_TRANSFER_TIMED_OUT] = USB_RET_IOERROR,
 202     [LIBUSB_TRANSFER_CANCELLED] = USB_RET_IOERROR,
 203     [LIBUSB_TRANSFER_STALL]     = USB_RET_STALL,
 204     [LIBUSB_TRANSFER_NO_DEVICE] = USB_RET_NODEV,
 205     [LIBUSB_TRANSFER_OVERFLOW]  = USB_RET_BABBLE,
 206 };
 207
 208 static const char *err_names[] = {
 209     [-LIBUSB_ERROR_IO]               = "IO",
 210     [-LIBUSB_ERROR_INVALID_PARAM]    = "INVALID_PARAM",
 211     [-LIBUSB_ERROR_ACCESS]           = "ACCESS",
 212     [-LIBUSB_ERROR_NO_DEVICE]        = "NO_DEVICE",
 213     [-LIBUSB_ERROR_NOT_FOUND]        = "NOT_FOUND",
 214     [-LIBUSB_ERROR_BUSY]             = "BUSY",
 215     [-LIBUSB_ERROR_TIMEOUT]          = "TIMEOUT",
 216     [-LIBUSB_ERROR_OVERFLOW]         = "OVERFLOW",
 217     [-LIBUSB_ERROR_PIPE]             = "PIPE",
 218     [-LIBUSB_ERROR_INTERRUPTED]      = "INTERRUPTED",
 219     [-LIBUSB_ERROR_NO_MEM]           = "NO_MEM",
 220     [-LIBUSB_ERROR_NOT_SUPPORTED]    = "NOT_SUPPORTED",
 221     [-LIBUSB_ERROR_OTHER]            = "OTHER",
 222 };
 223
 224 static libusb_context *ctx;
 225 static uint32_t loglevel;
 226
 227 #ifndef CONFIG_WIN32
 228
 229 static void usb_host_handle_fd(void *opaque)
 230 {
 231     struct timeval tv = { 0, 0 };
 232     libusb_handle_events_timeout(ctx, &tv);
 233 }
 234
 235 static void usb_host_add_fd(int fd, short events, void *user_data)
 236 {
 237     qemu_set_fd_handler(fd,
 238                         (events & POLLIN)  ? usb_host_handle_fd : NULL,
 239                         (events & POLLOUT) ? usb_host_handle_fd : NULL,
 240                         ctx);
 241 }
 242
 243 static void usb_host_del_fd(int fd, void *user_data)
 244 {
 245     qemu_set_fd_handler(fd, NULL, NULL, NULL);
 246 }
 247
 248 #endif /* !CONFIG_WIN32 */
 249
 250 static int usb_host_init(void)
 251 {
 252 #ifndef CONFIG_WIN32
 253     const struct libusb_pollfd **poll;
 254 #endif
 255     int rc;
 256
 257     if (ctx) {
 258         return 0;
 259     }
 260     rc = libusb_init(&ctx);
 261     if (rc != 0) {
 262         return -1;
 263     }
 264 #if LIBUSB_API_VERSION >= 0x01000106
 265     libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, loglevel);
 266 #else
 267     libusb_set_debug(ctx, loglevel);
 268 #endif
 269 #ifdef CONFIG_WIN32
 270     /* FIXME: add support for Windows. */
 271 #else
 272     libusb_set_pollfd_notifiers(ctx, usb_host_add_fd,
 273                                 usb_host_del_fd,
 274                                 ctx);
 275     poll = libusb_get_pollfds(ctx);
 276     if (poll) {
 277         int i;
 278         for (i = 0; poll[i] != NULL; i++) {
 279             usb_host_add_fd(poll[i]->fd, poll[i]->events, ctx);
 280         }
 281     }
 282     free(poll);
 283 #endif
 284     return 0;
 285 }
 286
 287 static int usb_host_get_port(libusb_device *dev, char *port, size_t len)
 288 {
 289     uint8_t path[7];
 290     size_t off;
 291     int rc, i;
 292
 293 #if LIBUSB_API_VERSION >= 0x01000102
 294     rc = libusb_get_port_numbers(dev, path, 7);
 295 #else
 296     rc = libusb_get_port_path(ctx, dev, path, 7);
 297 #endif
 298     if (rc < 0) {
 299         return 0;
 300     }
 301     off = snprintf(port, len, "%d", path[0]);
 302     for (i = 1; i < rc; i++) {
 303         off += snprintf(port+off, len-off, ".%d", path[i]);
 304     }
 305     return off;
 306 }
 307
 308 static void usb_host_libusb_error(const char *func, int rc)
 309 {
 310     const char *errname;
 311
 312     if (rc >= 0) {
 313         return;
 314     }
 315
 316     if (-rc < ARRAY_SIZE(err_names) && err_names[-rc]) {
 317         errname = err_names[-rc];
 318     } else {
 319         errname = "?";
 320     }
 321     error_report("%s: %d [%s]", func, rc, errname);
 322 }
 323
 324 /* ------------------------------------------------------------------------ */
 325
 326 static bool usb_host_use_combining(USBEndpoint *ep)
 327 {
 328     int type;
 329
 330     if (!ep->pipeline) {
 331         return false;
 332     }
 333     if (ep->pid != USB_TOKEN_IN) {
 334         return false;
 335     }
 336     type = usb_ep_get_type(ep->dev, ep->pid, ep->nr);
 337     if (type != USB_ENDPOINT_XFER_BULK) {
 338         return false;
 339     }
 340     return true;
 341 }
 342
 343 /* ------------------------------------------------------------------------ */
 344
 345 static USBHostRequest *usb_host_req_alloc(USBHostDevice *s, USBPacket *p,
 346                                           bool in, size_t bufsize)
 347 {
 348     USBHostRequest *r = g_new0(USBHostRequest, 1);
 349
 350     r->host = s;
 351     r->p = p;
 352     r->in = in;
 353     r->xfer = libusb_alloc_transfer(0);
 354     if (bufsize) {
 355         r->buffer = g_malloc(bufsize);
 356     }
 357     QTAILQ_INSERT_TAIL(&s->requests, r, next);
 358     return r;
 359 }
 360
 361 static void usb_host_req_free(USBHostRequest *r)
 362 {
 363     QTAILQ_REMOVE(&r->host->requests, r, next);
 364     libusb_free_transfer(r->xfer);
 365     g_free(r->buffer);
 366     g_free(r);
 367 }
 368
 369 static USBHostRequest *usb_host_req_find(USBHostDevice *s, USBPacket *p)
 370 {
 371     USBHostRequest *r;
 372
 373     QTAILQ_FOREACH(r, &s->requests, next) {
 374         if (r->p == p) {
 375             return r;
 376         }
 377     }
 378     return NULL;
 379 }
 380
 381 static void LIBUSB_CALL usb_host_req_complete_ctrl(struct libusb_transfer *xfer)
 382 {
 383     USBHostRequest *r = xfer->user_data;
 384     USBHostDevice  *s = r->host;
 385     bool disconnect = (xfer->status == LIBUSB_TRANSFER_NO_DEVICE);
 386
 387     if (r->p == NULL) {
 388         goto out; /* request was canceled */
 389     }
 390
 391     r->p->status = status_map[xfer->status];
 392     r->p->actual_length = xfer->actual_length;
 393     if (r->in && xfer->actual_length) {
 394         USBDevice *udev = USB_DEVICE(s);
 395         struct libusb_config_descriptor *conf = (void *)r->cbuf;
 396         memcpy(r->cbuf, r->buffer + 8, xfer->actual_length);
 397
 398         /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices
 399          * to work redirected to a not superspeed capable hcd */
 400         if (r->usb3ep0quirk && xfer->actual_length >= 18 &&
 401             r->cbuf[7] == 9) {
 402             r->cbuf[7] = 64;
 403         }
 404         /*
 405          *If this is GET_DESCRIPTOR request for configuration descriptor,
 406          * remove 'remote wakeup' flag from it to prevent idle power down
 407          * in Windows guest
 408          */
 409         if (s->suppress_remote_wake &&
 410             udev->setup_buf[0] == USB_DIR_IN &&
 411             udev->setup_buf[1] == USB_REQ_GET_DESCRIPTOR &&
 412             udev->setup_buf[3] == USB_DT_CONFIG && udev->setup_buf[2] == 0 &&
 413             xfer->actual_length >
 414                 offsetof(struct libusb_config_descriptor, bmAttributes) &&
 415             (conf->bmAttributes & USB_CFG_ATT_WAKEUP)) {
 416                 trace_usb_host_remote_wakeup_removed(s->bus_num, s->addr);
 417                 conf->bmAttributes &= ~USB_CFG_ATT_WAKEUP;
 418         }
 419     }
 420     trace_usb_host_req_complete(s->bus_num, s->addr, r->p,
 421                                 r->p->status, r->p->actual_length);
 422     usb_generic_async_ctrl_complete(USB_DEVICE(s), r->p);
 423
 424 out:
 425     usb_host_req_free(r);
 426     if (disconnect) {
 427         usb_host_nodev(s);
 428     }
 429 }
 430
 431 static void LIBUSB_CALL usb_host_req_complete_data(struct libusb_transfer *xfer)
 432 {
 433     USBHostRequest *r = xfer->user_data;
 434     USBHostDevice  *s = r->host;
 435     bool disconnect = (xfer->status == LIBUSB_TRANSFER_NO_DEVICE);
 436
 437     if (r->p == NULL) {
 438         goto out; /* request was canceled */
 439     }
 440
 441     r->p->status = status_map[xfer->status];
 442     if (r->in && xfer->actual_length) {
 443         usb_packet_copy(r->p, r->buffer, xfer->actual_length);
 444     }
 445     trace_usb_host_req_complete(s->bus_num, s->addr, r->p,
 446                                 r->p->status, r->p->actual_length);
 447     if (usb_host_use_combining(r->p->ep)) {
 448         usb_combined_input_packet_complete(USB_DEVICE(s), r->p);
 449     } else {
 450         usb_packet_complete(USB_DEVICE(s), r->p);
 451     }
 452
 453 out:
 454     usb_host_req_free(r);
 455     if (disconnect) {
 456         usb_host_nodev(s);
 457     }
 458 }
 459
 460 static void usb_host_req_abort(USBHostRequest *r)
 461 {
 462     USBHostDevice  *s = r->host;
 463     bool inflight = (r->p && r->p->state == USB_PACKET_ASYNC);
 464
 465     if (inflight) {
 466         r->p->status = USB_RET_NODEV;
 467         trace_usb_host_req_complete(s->bus_num, s->addr, r->p,
 468                                     r->p->status, r->p->actual_length);
 469         if (r->p->ep->nr == 0) {
 470             usb_generic_async_ctrl_complete(USB_DEVICE(s), r->p);
 471         } else {
 472             usb_packet_complete(USB_DEVICE(s), r->p);
 473         }
 474         r->p = NULL;
 475
 476         libusb_cancel_transfer(r->xfer);
 477     }
 478 }
 479
 480 /* ------------------------------------------------------------------------ */
 481
 482 static void LIBUSB_CALL
 483 usb_host_req_complete_iso(struct libusb_transfer *transfer)
 484 {
 485     USBHostIsoXfer *xfer = transfer->user_data;
 486
 487     if (!xfer) {
 488         /* USBHostIsoXfer released while inflight */
 489         g_free(transfer->buffer);
 490         libusb_free_transfer(transfer);
 491         return;
 492     }
 493
 494     QTAILQ_REMOVE(&xfer->ring->inflight, xfer, next);
 495     if (QTAILQ_EMPTY(&xfer->ring->inflight)) {
 496         USBHostDevice *s = xfer->ring->host;
 497         trace_usb_host_iso_stop(s->bus_num, s->addr, xfer->ring->ep->nr);
 498     }
 499     if (xfer->ring->ep->pid == USB_TOKEN_IN) {
 500         QTAILQ_INSERT_TAIL(&xfer->ring->copy, xfer, next);
 501         usb_wakeup(xfer->ring->ep, 0);
 502     } else {
 503         QTAILQ_INSERT_TAIL(&xfer->ring->unused, xfer, next);
 504     }
 505 }
 506
 507 static USBHostIsoRing *usb_host_iso_alloc(USBHostDevice *s, USBEndpoint *ep)
 508 {
 509     USBHostIsoRing *ring = g_new0(USBHostIsoRing, 1);
 510     USBHostIsoXfer *xfer;
 511     /* FIXME: check interval (for now assume one xfer per frame) */
 512     int packets = s->iso_urb_frames;
 513     int i;
 514
 515     ring->host = s;
 516     ring->ep = ep;
 517     QTAILQ_INIT(&ring->unused);
 518     QTAILQ_INIT(&ring->inflight);
 519     QTAILQ_INIT(&ring->copy);
 520     QTAILQ_INSERT_TAIL(&s->isorings, ring, next);
 521
 522     for (i = 0; i < s->iso_urb_count; i++) {
 523         xfer = g_new0(USBHostIsoXfer, 1);
 524         xfer->ring = ring;
 525         xfer->xfer = libusb_alloc_transfer(packets);
 526         xfer->xfer->dev_handle = s->dh;
 527         xfer->xfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
 528
 529         xfer->xfer->endpoint = ring->ep->nr;
 530         if (ring->ep->pid == USB_TOKEN_IN) {
 531             xfer->xfer->endpoint |= USB_DIR_IN;
 532         }
 533         xfer->xfer->callback = usb_host_req_complete_iso;
 534         xfer->xfer->user_data = xfer;
 535
 536         xfer->xfer->num_iso_packets = packets;
 537         xfer->xfer->length = ring->ep->max_packet_size * packets;
 538         xfer->xfer->buffer = g_malloc0(xfer->xfer->length);
 539
 540         QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
 541     }
 542
 543     return ring;
 544 }
 545
 546 static USBHostIsoRing *usb_host_iso_find(USBHostDevice *s, USBEndpoint *ep)
 547 {
 548     USBHostIsoRing *ring;
 549
 550     QTAILQ_FOREACH(ring, &s->isorings, next) {
 551         if (ring->ep == ep) {
 552             return ring;
 553         }
 554     }
 555     return NULL;
 556 }
 557
 558 static void usb_host_iso_reset_xfer(USBHostIsoXfer *xfer)
 559 {
 560     libusb_set_iso_packet_lengths(xfer->xfer,
 561                                   xfer->ring->ep->max_packet_size);
 562     xfer->packet = 0;
 563     xfer->copy_complete = false;
 564 }
 565
 566 static void usb_host_iso_free_xfer(USBHostIsoXfer *xfer, bool inflight)
 567 {
 568     if (inflight) {
 569         xfer->xfer->user_data = NULL;
 570     } else {
 571         g_free(xfer->xfer->buffer);
 572         libusb_free_transfer(xfer->xfer);
 573     }
 574     g_free(xfer);
 575 }
 576
 577 static void usb_host_iso_free(USBHostIsoRing *ring)
 578 {
 579     USBHostIsoXfer *xfer;
 580
 581     while ((xfer = QTAILQ_FIRST(&ring->inflight)) != NULL) {
 582         QTAILQ_REMOVE(&ring->inflight, xfer, next);
 583         usb_host_iso_free_xfer(xfer, true);
 584     }
 585     while ((xfer = QTAILQ_FIRST(&ring->unused)) != NULL) {
 586         QTAILQ_REMOVE(&ring->unused, xfer, next);
 587         usb_host_iso_free_xfer(xfer, false);
 588     }
 589     while ((xfer = QTAILQ_FIRST(&ring->copy)) != NULL) {
 590         QTAILQ_REMOVE(&ring->copy, xfer, next);
 591         usb_host_iso_free_xfer(xfer, false);
 592     }
 593
 594     QTAILQ_REMOVE(&ring->host->isorings, ring, next);
 595     g_free(ring);
 596 }
 597
 598 static void usb_host_iso_free_all(USBHostDevice *s)
 599 {
 600     USBHostIsoRing *ring;
 601
 602     while ((ring = QTAILQ_FIRST(&s->isorings)) != NULL) {
 603         usb_host_iso_free(ring);
 604     }
 605 }
 606
 607 static bool usb_host_iso_data_copy(USBHostIsoXfer *xfer, USBPacket *p)
 608 {
 609     unsigned int psize;
 610     unsigned char *buf;
 611
 612     buf = libusb_get_iso_packet_buffer_simple(xfer->xfer, xfer->packet);
 613     if (p->pid == USB_TOKEN_OUT) {
 614         psize = p->iov.size;
 615         if (psize > xfer->ring->ep->max_packet_size) {
 616             /* should not happen (guest bug) */
 617             psize = xfer->ring->ep->max_packet_size;
 618         }
 619         xfer->xfer->iso_packet_desc[xfer->packet].length = psize;
 620     } else {
 621         psize = xfer->xfer->iso_packet_desc[xfer->packet].actual_length;
 622         if (psize > p->iov.size) {
 623             /* should not happen (guest bug) */
 624             psize = p->iov.size;
 625         }
 626     }
 627     usb_packet_copy(p, buf, psize);
 628     xfer->packet++;
 629     xfer->copy_complete = (xfer->packet == xfer->xfer->num_iso_packets);
 630     return xfer->copy_complete;
 631 }
 632
 633 static void usb_host_iso_data_in(USBHostDevice *s, USBPacket *p)
 634 {
 635     USBHostIsoRing *ring;
 636     USBHostIsoXfer *xfer;
 637     bool disconnect = false;
 638     int rc;
 639
 640     ring = usb_host_iso_find(s, p->ep);
 641     if (ring == NULL) {
 642         ring = usb_host_iso_alloc(s, p->ep);
 643     }
 644
 645     /* copy data to guest */
 646     xfer = QTAILQ_FIRST(&ring->copy);
 647     if (xfer != NULL) {
 648         if (usb_host_iso_data_copy(xfer, p)) {
 649             QTAILQ_REMOVE(&ring->copy, xfer, next);
 650             QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
 651         }
 652     }
 653
 654     /* submit empty bufs to host */
 655     while ((xfer = QTAILQ_FIRST(&ring->unused)) != NULL) {
 656         QTAILQ_REMOVE(&ring->unused, xfer, next);
 657         usb_host_iso_reset_xfer(xfer);
 658         rc = libusb_submit_transfer(xfer->xfer);
 659         if (rc != 0) {
 660             usb_host_libusb_error("libusb_submit_transfer [iso]", rc);
 661             QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
 662             if (rc == LIBUSB_ERROR_NO_DEVICE) {
 663                 disconnect = true;
 664             }
 665             break;
 666         }
 667         if (QTAILQ_EMPTY(&ring->inflight)) {
 668             trace_usb_host_iso_start(s->bus_num, s->addr, p->ep->nr);
 669         }
 670         QTAILQ_INSERT_TAIL(&ring->inflight, xfer, next);
 671     }
 672
 673     if (disconnect) {
 674         usb_host_nodev(s);
 675     }
 676 }
 677
 678 static void usb_host_iso_data_out(USBHostDevice *s, USBPacket *p)
 679 {
 680     USBHostIsoRing *ring;
 681     USBHostIsoXfer *xfer;
 682     bool disconnect = false;
 683     int rc, filled = 0;
 684
 685     ring = usb_host_iso_find(s, p->ep);
 686     if (ring == NULL) {
 687         ring = usb_host_iso_alloc(s, p->ep);
 688     }
 689
 690     /* copy data from guest */
 691     xfer = QTAILQ_FIRST(&ring->copy);
 692     while (xfer != NULL && xfer->copy_complete) {
 693         filled++;
 694         xfer = QTAILQ_NEXT(xfer, next);
 695     }
 696     if (xfer == NULL) {
 697         xfer = QTAILQ_FIRST(&ring->unused);
 698         if (xfer == NULL) {
 699             trace_usb_host_iso_out_of_bufs(s->bus_num, s->addr, p->ep->nr);
 700             return;
 701         }
 702         QTAILQ_REMOVE(&ring->unused, xfer, next);
 703         usb_host_iso_reset_xfer(xfer);
 704         QTAILQ_INSERT_TAIL(&ring->copy, xfer, next);
 705     }
 706     usb_host_iso_data_copy(xfer, p);
 707
 708     if (QTAILQ_EMPTY(&ring->inflight)) {
 709         /* wait until half of our buffers are filled
 710            before kicking the iso out stream */
 711         if (filled*2 < s->iso_urb_count) {
 712             return;
 713         }
 714     }
 715
 716     /* submit filled bufs to host */
 717     while ((xfer = QTAILQ_FIRST(&ring->copy)) != NULL &&
 718            xfer->copy_complete) {
 719         QTAILQ_REMOVE(&ring->copy, xfer, next);
 720         rc = libusb_submit_transfer(xfer->xfer);
 721         if (rc != 0) {
 722             usb_host_libusb_error("libusb_submit_transfer [iso]", rc);
 723             QTAILQ_INSERT_TAIL(&ring->unused, xfer, next);
 724             if (rc == LIBUSB_ERROR_NO_DEVICE) {
 725                 disconnect = true;
 726             }
 727             break;
 728         }
 729         if (QTAILQ_EMPTY(&ring->inflight)) {
 730             trace_usb_host_iso_start(s->bus_num, s->addr, p->ep->nr);
 731         }
 732         QTAILQ_INSERT_TAIL(&ring->inflight, xfer, next);
 733     }
 734
 735     if (disconnect) {
 736         usb_host_nodev(s);
 737     }
 738 }
 739
 740 /* ------------------------------------------------------------------------ */
 741
 742 static void usb_host_speed_compat(USBHostDevice *s)
 743 {
 744     USBDevice *udev = USB_DEVICE(s);
 745     struct libusb_config_descriptor *conf;
 746     const struct libusb_interface_descriptor *intf;
 747     const struct libusb_endpoint_descriptor *endp;
 748 #ifdef HAVE_STREAMS
 749     struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
 750 #endif
 751     bool compat_high = true;
 752     bool compat_full = true;
 753     uint8_t type;
 754     int rc, c, i, a, e;
 755
 756     for (c = 0;; c++) {
 757         rc = libusb_get_config_descriptor(s->dev, c, &conf);
 758         if (rc != 0) {
 759             break;
 760         }
 761         for (i = 0; i < conf->bNumInterfaces; i++) {
 762             for (a = 0; a < conf->interface[i].num_altsetting; a++) {
 763                 intf = &conf->interface[i].altsetting[a];
 764                 for (e = 0; e < intf->bNumEndpoints; e++) {
 765                     endp = &intf->endpoint[e];
 766                     type = endp->bmAttributes & 0x3;
 767                     switch (type) {
 768                     case 0x01: /* ISO */
 769                         compat_full = false;
 770                         compat_high = false;
 771                         break;
 772                     case 0x02: /* BULK */
 773 #ifdef HAVE_STREAMS
 774                         rc = libusb_get_ss_endpoint_companion_descriptor
 775                             (ctx, endp, &endp_ss_comp);
 776                         if (rc == LIBUSB_SUCCESS) {
 777                             int streams = endp_ss_comp->bmAttributes & 0x1f;
 778                             if (streams) {
 779                                 compat_full = false;
 780                                 compat_high = false;
 781                             }
 782                             libusb_free_ss_endpoint_companion_descriptor
 783                                 (endp_ss_comp);
 784                         }
 785 #endif
 786                         break;
 787                     case 0x03: /* INTERRUPT */
 788                         if (endp->wMaxPacketSize > 64) {
 789                             compat_full = false;
 790                         }
 791                         if (endp->wMaxPacketSize > 1024) {
 792                             compat_high = false;
 793                         }
 794                         break;
 795                     }
 796                 }
 797             }
 798         }
 799         libusb_free_config_descriptor(conf);
 800     }
 801
 802     udev->speedmask = (1 << udev->speed);
 803     if (udev->speed == USB_SPEED_SUPER && compat_high) {
 804         udev->speedmask |= USB_SPEED_MASK_HIGH;
 805     }
 806     if (udev->speed == USB_SPEED_SUPER && compat_full) {
 807         udev->speedmask |= USB_SPEED_MASK_FULL;
 808     }
 809     if (udev->speed == USB_SPEED_HIGH && compat_full) {
 810         udev->speedmask |= USB_SPEED_MASK_FULL;
 811     }
 812 }
 813
 814 static void usb_host_ep_update(USBHostDevice *s)
 815 {
 816     static const char *tname[] = {
 817         [USB_ENDPOINT_XFER_CONTROL] = "control",
 818         [USB_ENDPOINT_XFER_ISOC]    = "isoc",
 819         [USB_ENDPOINT_XFER_BULK]    = "bulk",
 820         [USB_ENDPOINT_XFER_INT]     = "int",
 821     };
 822     USBDevice *udev = USB_DEVICE(s);
 823     struct libusb_config_descriptor *conf;
 824     const struct libusb_interface_descriptor *intf;
 825     const struct libusb_endpoint_descriptor *endp;
 826 #ifdef HAVE_STREAMS
 827     struct libusb_ss_endpoint_companion_descriptor *endp_ss_comp;
 828 #endif
 829     uint8_t devep, type;
 830     int pid, ep;
 831     int rc, i, e;
 832
 833     usb_ep_reset(udev);
 834     rc = libusb_get_active_config_descriptor(s->dev, &conf);
 835     if (rc != 0) {
 836         return;
 837     }
 838     trace_usb_host_parse_config(s->bus_num, s->addr,
 839                                 conf->bConfigurationValue, true);
 840
 841     for (i = 0; i < conf->bNumInterfaces; i++) {
 842         assert(udev->altsetting[i] < conf->interface[i].num_altsetting);
 843         intf = &conf->interface[i].altsetting[udev->altsetting[i]];
 844         trace_usb_host_parse_interface(s->bus_num, s->addr,
 845                                        intf->bInterfaceNumber,
 846                                        intf->bAlternateSetting, true);
 847         for (e = 0; e < intf->bNumEndpoints; e++) {
 848             endp = &intf->endpoint[e];
 849
 850             devep = endp->bEndpointAddress;
 851             pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
 852             ep = devep & 0xf;
 853             type = endp->bmAttributes & 0x3;
 854
 855             if (ep == 0) {
 856                 trace_usb_host_parse_error(s->bus_num, s->addr,
 857                                            "invalid endpoint address");
 858                 return;
 859             }
 860             if (usb_ep_get_type(udev, pid, ep) != USB_ENDPOINT_XFER_INVALID) {
 861                 trace_usb_host_parse_error(s->bus_num, s->addr,
 862                                            "duplicate endpoint address");
 863                 return;
 864             }
 865
 866             trace_usb_host_parse_endpoint(s->bus_num, s->addr, ep,
 867                                           (devep & USB_DIR_IN) ? "in" : "out",
 868                                           tname[type], true);
 869             usb_ep_set_max_packet_size(udev, pid, ep,
 870                                        endp->wMaxPacketSize);
 871             usb_ep_set_type(udev, pid, ep, type);
 872             usb_ep_set_ifnum(udev, pid, ep, i);
 873             usb_ep_set_halted(udev, pid, ep, 0);
 874 #ifdef HAVE_STREAMS
 875             if (type == LIBUSB_TRANSFER_TYPE_BULK &&
 876                     libusb_get_ss_endpoint_companion_descriptor(ctx, endp,
 877                         &endp_ss_comp) == LIBUSB_SUCCESS) {
 878                 usb_ep_set_max_streams(udev, pid, ep,
 879                                        endp_ss_comp->bmAttributes);
 880                 libusb_free_ss_endpoint_companion_descriptor(endp_ss_comp);
 881             }
 882 #endif
 883         }
 884     }
 885
 886     libusb_free_config_descriptor(conf);
 887 }
 888
 889 static int usb_host_open(USBHostDevice *s, libusb_device *dev, int hostfd)
 890 {
 891     USBDevice *udev = USB_DEVICE(s);
 892     int libusb_speed;
 893     int bus_num = 0;
 894     int addr = 0;
 895     int rc;
 896     Error *local_err = NULL;
 897
 898     if (s->bh_postld_pending) {
 899         return -1;
 900     }
 901     if (s->dh != NULL) {
 902         goto fail;
 903     }
 904
 905     if (dev) {
 906         bus_num = libusb_get_bus_number(dev);
 907         addr = libusb_get_device_address(dev);
 908         trace_usb_host_open_started(bus_num, addr);
 909
 910         rc = libusb_open(dev, &s->dh);
 911         if (rc != 0) {
 912             goto fail;
 913         }
 914     } else {
 915 #if LIBUSB_API_VERSION >= 0x01000107 && !defined(CONFIG_WIN32)
 916         trace_usb_host_open_hostfd(hostfd);
 917
 918         rc = libusb_wrap_sys_device(ctx, hostfd, &s->dh);
 919         if (rc != 0) {
 920             goto fail;
 921         }
 922         s->hostfd  = hostfd;
 923         dev = libusb_get_device(s->dh);
 924         bus_num = libusb_get_bus_number(dev);
 925         addr = libusb_get_device_address(dev);
 926 #else
 927         g_assert_not_reached();
 928 #endif
 929     }
 930
 931     s->dev     = dev;
 932     s->bus_num = bus_num;
 933     s->addr    = addr;
 934
 935     usb_host_detach_kernel(s);
 936
 937     libusb_get_device_descriptor(dev, &s->ddesc);
 938     usb_host_get_port(s->dev, s->port, sizeof(s->port));
 939
 940     usb_ep_init(udev);
 941     usb_host_ep_update(s);
 942
 943     libusb_speed = libusb_get_device_speed(dev);
 944 #if LIBUSB_API_VERSION >= 0x01000107 && defined(CONFIG_LINUX)
 945     if (hostfd && libusb_speed == 0) {
 946         /*
 947          * Workaround libusb bug: libusb_get_device_speed() does not
 948          * work for libusb_wrap_sys_device() devices in v1.0.23.
 949          *
 950          * Speeds are defined in linux/usb/ch9.h, file not included
 951          * due to name conflicts.
 952          */
 953         int rc = ioctl(hostfd, USBDEVFS_GET_SPEED, NULL);
 954         switch (rc) {
 955         case 1: /* low */
 956             libusb_speed = LIBUSB_SPEED_LOW;
 957             break;
 958         case 2: /* full */
 959             libusb_speed = LIBUSB_SPEED_FULL;
 960             break;
 961         case 3: /* high */
 962         case 4: /* wireless */
 963             libusb_speed = LIBUSB_SPEED_HIGH;
 964             break;
 965         case 5: /* super */
 966         case 6: /* super plus */
 967             libusb_speed = LIBUSB_SPEED_SUPER;
 968             break;
 969         }
 970     }
 971 #endif
 972     udev->speed = speed_map[libusb_speed];
 973     usb_host_speed_compat(s);
 974
 975     if (s->ddesc.iProduct) {
 976         libusb_get_string_descriptor_ascii(s->dh, s->ddesc.iProduct,
 977                                            (unsigned char *)udev->product_desc,
 978                                            sizeof(udev->product_desc));
 979     } else {
 980         snprintf(udev->product_desc, sizeof(udev->product_desc),
 981                  "host:%d.%d", bus_num, addr);
 982     }
 983
 984     usb_device_attach(udev, &local_err);
 985     if (local_err) {
 986         error_report_err(local_err);
 987         goto fail;
 988     }
 989
 990     trace_usb_host_open_success(bus_num, addr);
 991     return 0;
 992
 993 fail:
 994     trace_usb_host_open_failure(bus_num, addr);
 995     if (s->dh != NULL) {
 996         usb_host_release_interfaces(s);
 997         libusb_reset_device(s->dh);
 998         usb_host_attach_kernel(s);
 999         libusb_close(s->dh);
1000         s->dh = NULL;
1001         s->dev = NULL;
1002     }
1003     return -1;
1004 }
1005
1006 static void usb_host_abort_xfers(USBHostDevice *s)
1007 {
1008     USBHostRequest *r, *rtmp;
1009     int limit = 100;
1010
1011     QTAILQ_FOREACH_SAFE(r, &s->requests, next, rtmp) {
1012         usb_host_req_abort(r);
1013     }
1014
1015     while (QTAILQ_FIRST(&s->requests) != NULL) {
1016         struct timeval tv;
1017         memset(&tv, 0, sizeof(tv));
1018         tv.tv_usec = 2500;
1019         libusb_handle_events_timeout(ctx, &tv);
1020         if (--limit == 0) {
1021             /*
1022              * Don't wait forever for libusb calling the complete
1023              * callback (which will unlink and free the request).
1024              *
1025              * Leaking memory here, to make sure libusb will not
1026              * access memory which we have released already.
1027              */
1028             QTAILQ_FOREACH_SAFE(r, &s->requests, next, rtmp) {
1029                 QTAILQ_REMOVE(&s->requests, r, next);
1030             }
1031             return;
1032         }
1033     }
1034 }
1035
1036 static int usb_host_close(USBHostDevice *s)
1037 {
1038     USBDevice *udev = USB_DEVICE(s);
1039
1040     if (s->dh == NULL) {
1041         return -1;
1042     }
1043
1044     trace_usb_host_close(s->bus_num, s->addr);
1045
1046     usb_host_abort_xfers(s);
1047     usb_host_iso_free_all(s);
1048
1049     if (udev->attached) {
1050         usb_device_detach(udev);
1051     }
1052
1053     usb_host_release_interfaces(s);
1054     libusb_reset_device(s->dh);
1055     usb_host_attach_kernel(s);
1056     libusb_close(s->dh);
1057     s->dh = NULL;
1058     s->dev = NULL;
1059
1060     if (s->hostfd != -1) {
1061         close(s->hostfd);
1062         s->hostfd = -1;
1063     }
1064
1065     usb_host_auto_check(NULL);
1066     return 0;
1067 }
1068
1069 static void usb_host_nodev_bh(void *opaque)
1070 {
1071     USBHostDevice *s = opaque;
1072     usb_host_close(s);
1073 }
1074
1075 static void usb_host_nodev(USBHostDevice *s)
1076 {
1077     if (!s->bh_nodev) {
1078         s->bh_nodev = qemu_bh_new(usb_host_nodev_bh, s);
1079     }
1080     qemu_bh_schedule(s->bh_nodev);
1081 }
1082
1083 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1084 {
1085     USBHostDevice *s = container_of(n, USBHostDevice, exit);
1086
1087     if (s->dh) {
1088         usb_host_abort_xfers(s);
1089         usb_host_release_interfaces(s);
1090         libusb_reset_device(s->dh);
1091         usb_host_attach_kernel(s);
1092         libusb_close(s->dh);
1093     }
1094 }
1095
1096 static libusb_device *usb_host_find_ref(int bus, int addr)
1097 {
1098     libusb_device **devs = NULL;
1099     libusb_device *ret = NULL;
1100     int i, n;
1101
1102     n = libusb_get_device_list(ctx, &devs);
1103     for (i = 0; i < n; i++) {
1104         if (libusb_get_bus_number(devs[i]) == bus &&
1105             libusb_get_device_address(devs[i]) == addr) {
1106             ret = libusb_ref_device(devs[i]);
1107             break;
1108         }
1109     }
1110     libusb_free_device_list(devs, 1);
1111     return ret;
1112 }
1113
1114 static void usb_host_realize(USBDevice *udev, Error **errp)
1115 {
1116     USBHostDevice *s = USB_HOST_DEVICE(udev);
1117     libusb_device *ldev;
1118     int rc;
1119
1120     if (usb_host_init() != 0) {
1121         error_setg(errp, "failed to init libusb");
1122         return;
1123     }
1124     if (s->match.vendor_id > 0xffff) {
1125         error_setg(errp, "vendorid out of range");
1126         return;
1127     }
1128     if (s->match.product_id > 0xffff) {
1129         error_setg(errp, "productid out of range");
1130         return;
1131     }
1132     if (s->match.addr > 127) {
1133         error_setg(errp, "hostaddr out of range");
1134         return;
1135     }
1136
1137     loglevel = s->loglevel;
1138     udev->flags |= (1 << USB_DEV_FLAG_IS_HOST);
1139     udev->auto_attach = 0;
1140     QTAILQ_INIT(&s->requests);
1141     QTAILQ_INIT(&s->isorings);
1142     s->hostfd = -1;
1143
1144 #if LIBUSB_API_VERSION >= 0x01000107 && !defined(CONFIG_WIN32)
1145     if (s->hostdevice) {
1146         int fd;
1147         s->needs_autoscan = false;
1148         fd = qemu_open_old(s->hostdevice, O_RDWR);
1149         if (fd < 0) {
1150             error_setg_errno(errp, errno, "failed to open %s", s->hostdevice);
1151             return;
1152         }
1153         rc = usb_host_open(s, NULL, fd);
1154         if (rc < 0) {
1155             error_setg(errp, "failed to open host usb device %s", s->hostdevice);
1156             return;
1157         }
1158     } else
1159 #endif
1160     if (s->match.addr && s->match.bus_num &&
1161         !s->match.vendor_id &&
1162         !s->match.product_id &&
1163         !s->match.port) {
1164         s->needs_autoscan = false;
1165         ldev = usb_host_find_ref(s->match.bus_num,
1166                                  s->match.addr);
1167         if (!ldev) {
1168             error_setg(errp, "failed to find host usb device %d:%d",
1169                        s->match.bus_num, s->match.addr);
1170             return;
1171         }
1172         rc = usb_host_open(s, ldev, 0);
1173         libusb_unref_device(ldev);
1174         if (rc < 0) {
1175             error_setg(errp, "failed to open host usb device %d:%d",
1176                        s->match.bus_num, s->match.addr);
1177             return;
1178         }
1179     } else {
1180         s->needs_autoscan = true;
1181         QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1182         usb_host_auto_check(NULL);
1183     }
1184
1185     s->exit.notify = usb_host_exit_notifier;
1186     qemu_add_exit_notifier(&s->exit);
1187 }
1188
1189 static void usb_host_instance_init(Object *obj)
1190 {
1191     USBDevice *udev = USB_DEVICE(obj);
1192     USBHostDevice *s = USB_HOST_DEVICE(udev);
1193
1194     device_add_bootindex_property(obj, &s->bootindex,
1195                                   "bootindex", NULL,
1196                                   &udev->qdev);
1197 }
1198
1199 static void usb_host_unrealize(USBDevice *udev)
1200 {
1201     USBHostDevice *s = USB_HOST_DEVICE(udev);
1202
1203     qemu_remove_exit_notifier(&s->exit);
1204     if (s->needs_autoscan) {
1205         QTAILQ_REMOVE(&hostdevs, s, next);
1206     }
1207     usb_host_close(s);
1208 }
1209
1210 static void usb_host_cancel_packet(USBDevice *udev, USBPacket *p)
1211 {
1212     USBHostDevice *s = USB_HOST_DEVICE(udev);
1213     USBHostRequest *r;
1214
1215     if (p->combined) {
1216         usb_combined_packet_cancel(udev, p);
1217         return;
1218     }
1219
1220     trace_usb_host_req_canceled(s->bus_num, s->addr, p);
1221
1222     r = usb_host_req_find(s, p);
1223     if (r && r->p) {
1224         r->p = NULL; /* mark as dead */
1225         libusb_cancel_transfer(r->xfer);
1226     }
1227 }
1228
1229 static void usb_host_detach_kernel(USBHostDevice *s)
1230 {
1231     struct libusb_config_descriptor *conf;
1232     int rc, i;
1233
1234     rc = libusb_get_active_config_descriptor(s->dev, &conf);
1235     if (rc != 0) {
1236         return;
1237     }
1238     for (i = 0; i < USB_MAX_INTERFACES; i++) {
1239         rc = libusb_kernel_driver_active(s->dh, i);
1240         usb_host_libusb_error("libusb_kernel_driver_active", rc);
1241         if (rc != 1) {
1242             if (rc == 0) {
1243                 s->ifs[i].detached = true;
1244             }
1245             continue;
1246         }
1247         trace_usb_host_detach_kernel(s->bus_num, s->addr, i);
1248         rc = libusb_detach_kernel_driver(s->dh, i);
1249         usb_host_libusb_error("libusb_detach_kernel_driver", rc);
1250         s->ifs[i].detached = true;
1251     }
1252     libusb_free_config_descriptor(conf);
1253 }
1254
1255 static void usb_host_attach_kernel(USBHostDevice *s)
1256 {
1257     struct libusb_config_descriptor *conf;
1258     int rc, i;
1259
1260     rc = libusb_get_active_config_descriptor(s->dev, &conf);
1261     if (rc != 0) {
1262         return;
1263     }
1264     for (i = 0; i < USB_MAX_INTERFACES; i++) {
1265         if (!s->ifs[i].detached) {
1266             continue;
1267         }
1268         trace_usb_host_attach_kernel(s->bus_num, s->addr, i);
1269         libusb_attach_kernel_driver(s->dh, i);
1270         s->ifs[i].detached = false;
1271     }
1272     libusb_free_config_descriptor(conf);
1273 }
1274
1275 static int usb_host_claim_interfaces(USBHostDevice *s, int configuration)
1276 {
1277     USBDevice *udev = USB_DEVICE(s);
1278     struct libusb_config_descriptor *conf;
1279     int rc, i, claimed;
1280
1281     for (i = 0; i < USB_MAX_INTERFACES; i++) {
1282         udev->altsetting[i] = 0;
1283     }
1284     udev->ninterfaces   = 0;
1285     udev->configuration = 0;
1286
1287     usb_host_detach_kernel(s);
1288
1289     rc = libusb_get_active_config_descriptor(s->dev, &conf);
1290     if (rc != 0) {
1291         if (rc == LIBUSB_ERROR_NOT_FOUND) {
1292             /* address state - ignore */
1293             return USB_RET_SUCCESS;
1294         }
1295         return USB_RET_STALL;
1296     }
1297
1298     claimed = 0;
1299     for (i = 0; i < USB_MAX_INTERFACES; i++) {
1300         trace_usb_host_claim_interface(s->bus_num, s->addr, configuration, i);
1301         rc = libusb_claim_interface(s->dh, i);
1302         if (rc == 0) {
1303             s->ifs[i].claimed = true;
1304             if (++claimed == conf->bNumInterfaces) {
1305                 break;
1306             }
1307         }
1308     }
1309     if (claimed != conf->bNumInterfaces) {
1310         return USB_RET_STALL;
1311     }
1312
1313     udev->ninterfaces   = conf->bNumInterfaces;
1314     udev->configuration = configuration;
1315
1316     libusb_free_config_descriptor(conf);
1317     return USB_RET_SUCCESS;
1318 }
1319
1320 static void usb_host_release_interfaces(USBHostDevice *s)
1321 {
1322     int i, rc;
1323
1324     for (i = 0; i < USB_MAX_INTERFACES; i++) {
1325         if (!s->ifs[i].claimed) {
1326             continue;
1327         }
1328         trace_usb_host_release_interface(s->bus_num, s->addr, i);
1329         rc = libusb_release_interface(s->dh, i);
1330         usb_host_libusb_error("libusb_release_interface", rc);
1331         s->ifs[i].claimed = false;
1332     }
1333 }
1334
1335 static void usb_host_set_address(USBHostDevice *s, int addr)
1336 {
1337     USBDevice *udev = USB_DEVICE(s);
1338
1339     trace_usb_host_set_address(s->bus_num, s->addr, addr);
1340     udev->addr = addr;
1341 }
1342
1343 static void usb_host_set_config(USBHostDevice *s, int config, USBPacket *p)
1344 {
1345     int rc = 0;
1346
1347     trace_usb_host_set_config(s->bus_num, s->addr, config);
1348
1349     usb_host_release_interfaces(s);
1350     if (s->ddesc.bNumConfigurations != 1) {
1351         rc = libusb_set_configuration(s->dh, config);
1352         if (rc != 0) {
1353             usb_host_libusb_error("libusb_set_configuration", rc);
1354             p->status = USB_RET_STALL;
1355             if (rc == LIBUSB_ERROR_NO_DEVICE) {
1356                 usb_host_nodev(s);
1357             }
1358             return;
1359         }
1360     }
1361     p->status = usb_host_claim_interfaces(s, config);
1362     if (p->status != USB_RET_SUCCESS) {
1363         return;
1364     }
1365     usb_host_ep_update(s);
1366 }
1367
1368 static void usb_host_set_interface(USBHostDevice *s, int iface, int alt,
1369                                    USBPacket *p)
1370 {
1371     USBDevice *udev = USB_DEVICE(s);
1372     int rc;
1373
1374     trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
1375
1376     usb_host_iso_free_all(s);
1377
1378     if (iface >= USB_MAX_INTERFACES) {
1379         p->status = USB_RET_STALL;
1380         return;
1381     }
1382
1383     rc = libusb_set_interface_alt_setting(s->dh, iface, alt);
1384     if (rc != 0) {
1385         usb_host_libusb_error("libusb_set_interface_alt_setting", rc);
1386         p->status = USB_RET_STALL;
1387         if (rc == LIBUSB_ERROR_NO_DEVICE) {
1388             usb_host_nodev(s);
1389         }
1390         return;
1391     }
1392
1393     udev->altsetting[iface] = alt;
1394     usb_host_ep_update(s);
1395 }
1396
1397 static void usb_host_handle_control(USBDevice *udev, USBPacket *p,
1398                                     int request, int value, int index,
1399                                     int length, uint8_t *data)
1400 {
1401     USBHostDevice *s = USB_HOST_DEVICE(udev);
1402     USBHostRequest *r;
1403     int rc;
1404
1405     trace_usb_host_req_control(s->bus_num, s->addr, p, request, value, index);
1406
1407     if (s->dh == NULL) {
1408         p->status = USB_RET_NODEV;
1409         trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1410         return;
1411     }
1412
1413     switch (request) {
1414     case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1415         usb_host_set_address(s, value);
1416         trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1417         return;
1418
1419     case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1420         usb_host_set_config(s, value & 0xff, p);
1421         trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1422         return;
1423
1424     case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1425         usb_host_set_interface(s, index, value, p);
1426         trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1427         return;
1428
1429     case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
1430         if (value == 0) { /* clear halt */
1431             int pid = (index & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1432             libusb_clear_halt(s->dh, index);
1433             usb_ep_set_halted(udev, pid, index & 0x0f, 0);
1434             trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1435             return;
1436         }
1437     }
1438
1439     r = usb_host_req_alloc(s, p, (request >> 8) & USB_DIR_IN, length + 8);
1440     r->cbuf = data;
1441     r->clen = length;
1442     memcpy(r->buffer, udev->setup_buf, 8);
1443     if (!r->in) {
1444         memcpy(r->buffer + 8, r->cbuf, r->clen);
1445     }
1446
1447     /* Fix up USB-3 ep0 maxpacket size to allow superspeed connected devices
1448      * to work redirected to a not superspeed capable hcd */
1449     if ((udev->speedmask & USB_SPEED_MASK_SUPER) &&
1450         !(udev->port->speedmask & USB_SPEED_MASK_SUPER) &&
1451         request == 0x8006 && value == 0x100 && index == 0) {
1452         r->usb3ep0quirk = true;
1453     }
1454
1455     libusb_fill_control_transfer(r->xfer, s->dh, r->buffer,
1456                                  usb_host_req_complete_ctrl, r,
1457                                  CONTROL_TIMEOUT);
1458     rc = libusb_submit_transfer(r->xfer);
1459     if (rc != 0) {
1460         p->status = USB_RET_NODEV;
1461         trace_usb_host_req_complete(s->bus_num, s->addr, p,
1462                                     p->status, p->actual_length);
1463         if (rc == LIBUSB_ERROR_NO_DEVICE) {
1464             usb_host_nodev(s);
1465         }
1466         return;
1467     }
1468
1469     p->status = USB_RET_ASYNC;
1470 }
1471
1472 static void usb_host_handle_data(USBDevice *udev, USBPacket *p)
1473 {
1474     USBHostDevice *s = USB_HOST_DEVICE(udev);
1475     USBHostRequest *r;
1476     size_t size;
1477     int ep, rc;
1478
1479     if (usb_host_use_combining(p->ep) && p->state == USB_PACKET_SETUP) {
1480         p->status = USB_RET_ADD_TO_QUEUE;
1481         return;
1482     }
1483
1484     trace_usb_host_req_data(s->bus_num, s->addr, p,
1485                             p->pid == USB_TOKEN_IN,
1486                             p->ep->nr, p->iov.size);
1487
1488     if (s->dh == NULL) {
1489         p->status = USB_RET_NODEV;
1490         trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1491         return;
1492     }
1493     if (p->ep->halted) {
1494         p->status = USB_RET_STALL;
1495         trace_usb_host_req_emulated(s->bus_num, s->addr, p, p->status);
1496         return;
1497     }
1498
1499     switch (usb_ep_get_type(udev, p->pid, p->ep->nr)) {
1500     case USB_ENDPOINT_XFER_BULK:
1501         size = usb_packet_size(p);
1502         r = usb_host_req_alloc(s, p, p->pid == USB_TOKEN_IN, size);
1503         if (!r->in) {
1504             usb_packet_copy(p, r->buffer, size);
1505         }
1506         ep = p->ep->nr | (r->in ? USB_DIR_IN : 0);
1507         if (p->stream) {
1508 #ifdef HAVE_STREAMS
1509             libusb_fill_bulk_stream_transfer(r->xfer, s->dh, ep, p->stream,
1510                                              r->buffer, size,
1511                                              usb_host_req_complete_data, r,
1512                                              BULK_TIMEOUT);
1513 #else
1514             usb_host_req_free(r);
1515             p->status = USB_RET_STALL;
1516             return;
1517 #endif
1518         } else {
1519             libusb_fill_bulk_transfer(r->xfer, s->dh, ep,
1520                                       r->buffer, size,
1521                                       usb_host_req_complete_data, r,
1522                                       BULK_TIMEOUT);
1523         }
1524         break;
1525     case USB_ENDPOINT_XFER_INT:
1526         r = usb_host_req_alloc(s, p, p->pid == USB_TOKEN_IN, p->iov.size);
1527         if (!r->in) {
1528             usb_packet_copy(p, r->buffer, p->iov.size);
1529         }
1530         ep = p->ep->nr | (r->in ? USB_DIR_IN : 0);
1531         libusb_fill_interrupt_transfer(r->xfer, s->dh, ep,
1532                                        r->buffer, p->iov.size,
1533                                        usb_host_req_complete_data, r,
1534                                        INTR_TIMEOUT);
1535         break;
1536     case USB_ENDPOINT_XFER_ISOC:
1537         if (p->pid == USB_TOKEN_IN) {
1538             usb_host_iso_data_in(s, p);
1539         } else {
1540             usb_host_iso_data_out(s, p);
1541         }
1542         trace_usb_host_req_complete(s->bus_num, s->addr, p,
1543                                     p->status, p->actual_length);
1544         return;
1545     default:
1546         p->status = USB_RET_STALL;
1547         trace_usb_host_req_complete(s->bus_num, s->addr, p,
1548                                     p->status, p->actual_length);
1549         return;
1550     }
1551
1552     rc = libusb_submit_transfer(r->xfer);
1553     if (rc != 0) {
1554         p->status = USB_RET_NODEV;
1555         trace_usb_host_req_complete(s->bus_num, s->addr, p,
1556                                     p->status, p->actual_length);
1557         if (rc == LIBUSB_ERROR_NO_DEVICE) {
1558             usb_host_nodev(s);
1559         }
1560         return;
1561     }
1562
1563     p->status = USB_RET_ASYNC;
1564 }
1565
1566 static void usb_host_flush_ep_queue(USBDevice *dev, USBEndpoint *ep)
1567 {
1568     if (usb_host_use_combining(ep)) {
1569         usb_ep_combine_input_packets(ep);
1570     }
1571 }
1572
1573 static void usb_host_handle_reset(USBDevice *udev)
1574 {
1575     USBHostDevice *s = USB_HOST_DEVICE(udev);
1576     int rc;
1577
1578     if (!s->allow_one_guest_reset && !s->allow_all_guest_resets) {
1579         return;
1580     }
1581     if (!s->allow_all_guest_resets && udev->addr == 0) {
1582         return;
1583     }
1584
1585     trace_usb_host_reset(s->bus_num, s->addr);
1586
1587     rc = libusb_reset_device(s->dh);
1588     if (rc != 0) {
1589         usb_host_nodev(s);
1590     }
1591 }
1592
1593 static int usb_host_alloc_streams(USBDevice *udev, USBEndpoint **eps,
1594                                   int nr_eps, int streams)
1595 {
1596 #ifdef HAVE_STREAMS
1597     USBHostDevice *s = USB_HOST_DEVICE(udev);
1598     unsigned char endpoints[30];
1599     int i, rc;
1600
1601     for (i = 0; i < nr_eps; i++) {
1602         endpoints[i] = eps[i]->nr;
1603         if (eps[i]->pid == USB_TOKEN_IN) {
1604             endpoints[i] |= 0x80;
1605         }
1606     }
1607     rc = libusb_alloc_streams(s->dh, streams, endpoints, nr_eps);
1608     if (rc < 0) {
1609         usb_host_libusb_error("libusb_alloc_streams", rc);
1610     } else if (rc != streams) {
1611         error_report("libusb_alloc_streams: got less streams "
1612                      "then requested %d < %d", rc, streams);
1613     }
1614
1615     return (rc == streams) ? 0 : -1;
1616 #else
1617     error_report("libusb_alloc_streams: error not implemented");
1618     return -1;
1619 #endif
1620 }
1621
1622 static void usb_host_free_streams(USBDevice *udev, USBEndpoint **eps,
1623                                   int nr_eps)
1624 {
1625 #ifdef HAVE_STREAMS
1626     USBHostDevice *s = USB_HOST_DEVICE(udev);
1627     unsigned char endpoints[30];
1628     int i;
1629
1630     for (i = 0; i < nr_eps; i++) {
1631         endpoints[i] = eps[i]->nr;
1632         if (eps[i]->pid == USB_TOKEN_IN) {
1633             endpoints[i] |= 0x80;
1634         }
1635     }
1636     libusb_free_streams(s->dh, endpoints, nr_eps);
1637 #endif
1638 }
1639
1640 /*
1641  * This is *NOT* about restoring state.  We have absolutely no idea
1642  * what state the host device is in at the moment and whenever it is
1643  * still present in the first place.  Attemping to contine where we
1644  * left off is impossible.
1645  *
1646  * What we are going to do here is emulate a surprise removal of
1647  * the usb device passed through, then kick host scan so the device
1648  * will get re-attached (and re-initialized by the guest) in case it
1649  * is still present.
1650  *
1651  * As the device removal will change the state of other devices (usb
1652  * host controller, most likely interrupt controller too) we have to
1653  * wait with it until *all* vmstate is loaded.  Thus post_load just
1654  * kicks a bottom half which then does the actual work.
1655  */
1656 static void usb_host_post_load_bh(void *opaque)
1657 {
1658     USBHostDevice *dev = opaque;
1659     USBDevice *udev = USB_DEVICE(dev);
1660
1661     if (dev->dh != NULL) {
1662         usb_host_close(dev);
1663     }
1664     if (udev->attached) {
1665         usb_device_detach(udev);
1666     }
1667     dev->bh_postld_pending = false;
1668     usb_host_auto_check(NULL);
1669 }
1670
1671 static int usb_host_post_load(void *opaque, int version_id)
1672 {
1673     USBHostDevice *dev = opaque;
1674
1675     if (!dev->bh_postld) {
1676         dev->bh_postld = qemu_bh_new(usb_host_post_load_bh, dev);
1677     }
1678     qemu_bh_schedule(dev->bh_postld);
1679     dev->bh_postld_pending = true;
1680     return 0;
1681 }
1682
1683 static const VMStateDescription vmstate_usb_host = {
1684     .name = "usb-host",
1685     .version_id = 1,
1686     .minimum_version_id = 1,
1687     .post_load = usb_host_post_load,
1688     .fields = (VMStateField[]) {
1689         VMSTATE_USB_DEVICE(parent_obj, USBHostDevice),
1690         VMSTATE_END_OF_LIST()
1691     }
1692 };
1693
1694 static Property usb_host_dev_properties[] = {
1695     DEFINE_PROP_UINT32("hostbus",  USBHostDevice, match.bus_num,    0),
1696     DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr,       0),
1697     DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1698     DEFINE_PROP_UINT32("vendorid",  USBHostDevice, match.vendor_id,  0),
1699     DEFINE_PROP_UINT32("productid", USBHostDevice, match.product_id, 0),
1700 #if LIBUSB_API_VERSION >= 0x01000107
1701     DEFINE_PROP_STRING("hostdevice", USBHostDevice, hostdevice),
1702 #endif
1703     DEFINE_PROP_UINT32("isobufs",  USBHostDevice, iso_urb_count,    4),
1704     DEFINE_PROP_UINT32("isobsize", USBHostDevice, iso_urb_frames,   32),
1705     DEFINE_PROP_BOOL("guest-reset", USBHostDevice,
1706                      allow_one_guest_reset, true),
1707     DEFINE_PROP_BOOL("guest-resets-all", USBHostDevice,
1708                      allow_all_guest_resets, false),
1709     DEFINE_PROP_UINT32("loglevel",  USBHostDevice, loglevel,
1710                        LIBUSB_LOG_LEVEL_WARNING),
1711     DEFINE_PROP_BIT("pipeline",    USBHostDevice, options,
1712                     USB_HOST_OPT_PIPELINE, true),
1713     DEFINE_PROP_BOOL("suppress-remote-wake", USBHostDevice,
1714                      suppress_remote_wake, true),
1715     DEFINE_PROP_END_OF_LIST(),
1716 };
1717
1718 static void usb_host_class_initfn(ObjectClass *klass, void *data)
1719 {
1720     DeviceClass *dc = DEVICE_CLASS(klass);
1721     USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
1722
1723     uc->realize        = usb_host_realize;
1724     uc->product_desc   = "USB Host Device";
1725     uc->cancel_packet  = usb_host_cancel_packet;
1726     uc->handle_data    = usb_host_handle_data;
1727     uc->handle_control = usb_host_handle_control;
1728     uc->handle_reset   = usb_host_handle_reset;
1729     uc->unrealize      = usb_host_unrealize;
1730     uc->flush_ep_queue = usb_host_flush_ep_queue;
1731     uc->alloc_streams  = usb_host_alloc_streams;
1732     uc->free_streams   = usb_host_free_streams;
1733     dc->vmsd = &vmstate_usb_host;
1734     device_class_set_props(dc, usb_host_dev_properties);
1735     set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
1736 }
1737
1738 static TypeInfo usb_host_dev_info = {
1739     .name          = TYPE_USB_HOST_DEVICE,
1740     .parent        = TYPE_USB_DEVICE,
1741     .instance_size = sizeof(USBHostDevice),
1742     .class_init    = usb_host_class_initfn,
1743     .instance_init = usb_host_instance_init,
1744 };
1745
1746 static void usb_host_register_types(void)
1747 {
1748     type_register_static(&usb_host_dev_info);
1749 }
1750
1751 type_init(usb_host_register_types)
1752
1753 /* ------------------------------------------------------------------------ */
1754
1755 static QEMUTimer *usb_auto_timer;
1756 static VMChangeStateEntry *usb_vmstate;
1757
1758 static void usb_host_vm_state(void *unused, int running, RunState state)
1759 {
1760     if (running) {
1761         usb_host_auto_check(unused);
1762     }
1763 }
1764
1765 static void usb_host_auto_check(void *unused)
1766 {
1767     struct USBHostDevice *s;
1768     struct USBAutoFilter *f;
1769     libusb_device **devs = NULL;
1770     struct libusb_device_descriptor ddesc;
1771     int unconnected = 0;
1772     int i, n;
1773
1774     if (usb_host_init() != 0) {
1775         return;
1776     }
1777
1778     if (runstate_is_running()) {
1779         n = libusb_get_device_list(ctx, &devs);
1780         for (i = 0; i < n; i++) {
1781             if (libusb_get_device_descriptor(devs[i], &ddesc) != 0) {
1782                 continue;
1783             }
1784             if (ddesc.bDeviceClass == LIBUSB_CLASS_HUB) {
1785                 continue;
1786             }
1787             QTAILQ_FOREACH(s, &hostdevs, next) {
1788                 f = &s->match;
1789                 if (f->bus_num > 0 &&
1790                     f->bus_num != libusb_get_bus_number(devs[i])) {
1791                     continue;
1792                 }
1793                 if (f->addr > 0 &&
1794                     f->addr != libusb_get_device_address(devs[i])) {
1795                     continue;
1796                 }
1797                 if (f->port != NULL) {
1798                     char port[16] = "-";
1799                     usb_host_get_port(devs[i], port, sizeof(port));
1800                     if (strcmp(f->port, port) != 0) {
1801                         continue;
1802                     }
1803                 }
1804                 if (f->vendor_id > 0 &&
1805                     f->vendor_id != ddesc.idVendor) {
1806                     continue;
1807                 }
1808                 if (f->product_id > 0 &&
1809                     f->product_id != ddesc.idProduct) {
1810                     continue;
1811                 }
1812
1813                 /* We got a match */
1814                 s->seen++;
1815                 if (s->errcount >= 3) {
1816                     continue;
1817                 }
1818                 if (s->dh != NULL) {
1819                     continue;
1820                 }
1821                 if (usb_host_open(s, devs[i], 0) < 0) {
1822                     s->errcount++;
1823                     continue;
1824                 }
1825                 break;
1826             }
1827         }
1828         libusb_free_device_list(devs, 1);
1829
1830         QTAILQ_FOREACH(s, &hostdevs, next) {
1831             if (s->dh == NULL) {
1832                 unconnected++;
1833             }
1834             if (s->seen == 0) {
1835                 if (s->dh) {
1836                     usb_host_close(s);
1837                 }
1838                 s->errcount = 0;
1839             }
1840             s->seen = 0;
1841         }
1842
1843 #if 0
1844         if (unconnected == 0) {
1845             /* nothing to watch */
1846             if (usb_auto_timer) {
1847                 timer_del(usb_auto_timer);
1848                 trace_usb_host_auto_scan_disabled();
1849             }
1850             return;
1851         }
1852 #endif
1853     }
1854
1855     if (!usb_vmstate) {
1856         usb_vmstate = qemu_add_vm_change_state_handler(usb_host_vm_state, NULL);
1857     }
1858     if (!usb_auto_timer) {
1859         usb_auto_timer = timer_new_ms(QEMU_CLOCK_REALTIME, usb_host_auto_check, NULL);
1860         if (!usb_auto_timer) {
1861             return;
1862         }
1863         trace_usb_host_auto_scan_enabled();
1864     }
1865     timer_mod(usb_auto_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 2000);
1866 }
1867
1868 /**
1869  * Check whether USB host device has a USB mass storage SCSI interface
1870  */
1871 bool usb_host_dev_is_scsi_storage(USBDevice *ud)
1872 {
1873     USBHostDevice *uhd = USB_HOST_DEVICE(ud);
1874     struct libusb_config_descriptor *conf;
1875     const struct libusb_interface_descriptor *intf;
1876     bool is_scsi_storage = false;
1877     int i;
1878
1879     if (!uhd || libusb_get_active_config_descriptor(uhd->dev, &conf) != 0) {
1880         return false;
1881     }
1882
1883     for (i = 0; i < conf->bNumInterfaces; i++) {
1884         intf = &conf->interface[i].altsetting[ud->altsetting[i]];
1885         if (intf->bInterfaceClass == LIBUSB_CLASS_MASS_STORAGE &&
1886             intf->bInterfaceSubClass == 6) {                 /* 6 means SCSI */
1887             is_scsi_storage = true;
1888             break;
1889         }
1890     }
1891
1892     libusb_free_config_descriptor(conf);
1893
1894     return is_scsi_storage;
1895 }
1896
1897 void hmp_info_usbhost(Monitor *mon, const QDict *qdict)
1898 {
1899     libusb_device **devs = NULL;
1900     struct libusb_device_descriptor ddesc;
1901     char port[16];
1902     int i, n;
1903
1904     if (usb_host_init() != 0) {
1905         return;
1906     }
1907
1908     n = libusb_get_device_list(ctx, &devs);
1909     for (i = 0; i < n; i++) {
1910         if (libusb_get_device_descriptor(devs[i], &ddesc) != 0) {
1911             continue;
1912         }
1913         if (ddesc.bDeviceClass == LIBUSB_CLASS_HUB) {
1914             continue;
1915         }
1916         usb_host_get_port(devs[i], port, sizeof(port));
1917         monitor_printf(mon, "  Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1918                        libusb_get_bus_number(devs[i]),
1919                        libusb_get_device_address(devs[i]),
1920                        port,
1921                        speed_name[libusb_get_device_speed(devs[i])]);
1922         monitor_printf(mon, "    Class %02x:", ddesc.bDeviceClass);
1923         monitor_printf(mon, " USB device %04x:%04x",
1924                        ddesc.idVendor, ddesc.idProduct);
1925         if (ddesc.iProduct) {
1926             libusb_device_handle *handle;
1927             if (libusb_open(devs[i], &handle) == 0) {
1928                 unsigned char name[64] = "";
1929                 libusb_get_string_descriptor_ascii(handle,
1930                                                    ddesc.iProduct,
1931                                                    name, sizeof(name));
1932                 libusb_close(handle);
1933                 monitor_printf(mon, ", %s", name);
1934             }
1935         }
1936         monitor_printf(mon, "\n");
1937     }
1938     libusb_free_device_list(devs, 1);
1939 }