usb-linux.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  * Permission is hereby granted, free of charge, to any person obtaining a copy
  15  * of this software and associated documentation files (the "Software"), to deal
  16  * in the Software without restriction, including without limitation the rights
  17  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  18  * copies of the Software, and to permit persons to whom the Software is
  19  * furnished to do so, subject to the following conditions:
  20  *
  21  * The above copyright notice and this permission notice shall be included in
  22  * all copies or substantial portions of the Software.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  27  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  28  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  29  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  30  * THE SOFTWARE.
  31  */
  32
  33 #include "qemu-common.h"
  34 #include "qemu-timer.h"
  35 #include "monitor.h"
  36 #include "sysemu.h"
  37 #include "trace.h"
  38
  39 #include <dirent.h>
  40 #include <sys/ioctl.h>
  41
  42 #include <linux/usbdevice_fs.h>
  43 #include <linux/version.h>
  44 #include "hw/usb.h"
  45
  46 /* We redefine it to avoid version problems */
  47 struct usb_ctrltransfer {
  48     uint8_t  bRequestType;
  49     uint8_t  bRequest;
  50     uint16_t wValue;
  51     uint16_t wIndex;
  52     uint16_t wLength;
  53     uint32_t timeout;
  54     void *data;
  55 };
  56
  57 typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port,
  58                         int class_id, int vendor_id, int product_id,
  59                         const char *product_name, int speed);
  60
  61 //#define DEBUG
  62
  63 #ifdef DEBUG
  64 #define DPRINTF printf
  65 #else
  66 #define DPRINTF(...)
  67 #endif
  68
  69 #define USBDBG_DEVOPENED "husb: opened %s/devices\n"
  70
  71 #define USBPROCBUS_PATH "/proc/bus/usb"
  72 #define PRODUCT_NAME_SZ 32
  73 #define MAX_ENDPOINTS 15
  74 #define MAX_PORTLEN 16
  75 #define USBDEVBUS_PATH "/dev/bus/usb"
  76 #define USBSYSBUS_PATH "/sys/bus/usb"
  77
  78 static char *usb_host_device_path;
  79
  80 #define USB_FS_NONE 0
  81 #define USB_FS_PROC 1
  82 #define USB_FS_DEV 2
  83 #define USB_FS_SYS 3
  84
  85 static int usb_fs_type;
  86
  87 /* endpoint association data */
  88 #define ISO_FRAME_DESC_PER_URB 32
  89 #define INVALID_EP_TYPE 255
  90
  91 /* devio.c limits single requests to 16k */
  92 #define MAX_USBFS_BUFFER_SIZE 16384
  93
  94 typedef struct AsyncURB AsyncURB;
  95
  96 struct endp_data {
  97     uint8_t type;
  98     uint8_t halted;
  99     uint8_t iso_started;
 100     AsyncURB *iso_urb;
 101     int iso_urb_idx;
 102     int iso_buffer_used;
 103     int max_packet_size;
 104     int inflight;
 105 };
 106
 107 struct USBAutoFilter {
 108     uint32_t bus_num;
 109     uint32_t addr;
 110     char     *port;
 111     uint32_t vendor_id;
 112     uint32_t product_id;
 113 };
 114
 115 typedef struct USBHostDevice {
 116     USBDevice dev;
 117     int       fd;
 118     int       hub_fd;
 119
 120     uint8_t   descr[8192];
 121     int       descr_len;
 122     int       configuration;
 123     int       ninterfaces;
 124     int       closing;
 125     uint32_t  iso_urb_count;
 126     Notifier  exit;
 127
 128     struct endp_data ep_in[MAX_ENDPOINTS];
 129     struct endp_data ep_out[MAX_ENDPOINTS];
 130     QLIST_HEAD(, AsyncURB) aurbs;
 131
 132     /* Host side address */
 133     int bus_num;
 134     int addr;
 135     char port[MAX_PORTLEN];
 136     struct USBAutoFilter match;
 137     int seen, errcount;
 138
 139     QTAILQ_ENTRY(USBHostDevice) next;
 140 } USBHostDevice;
 141
 142 static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
 143
 144 static int usb_host_close(USBHostDevice *dev);
 145 static int parse_filter(const char *spec, struct USBAutoFilter *f);
 146 static void usb_host_auto_check(void *unused);
 147 static int usb_host_read_file(char *line, size_t line_size,
 148                             const char *device_file, const char *device_name);
 149 static int usb_linux_update_endp_table(USBHostDevice *s);
 150
 151 static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep)
 152 {
 153     struct endp_data *eps = pid == USB_TOKEN_IN ? s->ep_in : s->ep_out;
 154     assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
 155     assert(ep > 0 && ep <= MAX_ENDPOINTS);
 156     return eps + ep - 1;
 157 }
 158
 159 static int is_isoc(USBHostDevice *s, int pid, int ep)
 160 {
 161     return get_endp(s, pid, ep)->type == USBDEVFS_URB_TYPE_ISO;
 162 }
 163
 164 static int is_valid(USBHostDevice *s, int pid, int ep)
 165 {
 166     return get_endp(s, pid, ep)->type != INVALID_EP_TYPE;
 167 }
 168
 169 static int is_halted(USBHostDevice *s, int pid, int ep)
 170 {
 171     return get_endp(s, pid, ep)->halted;
 172 }
 173
 174 static void clear_halt(USBHostDevice *s, int pid, int ep)
 175 {
 176     trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep);
 177     get_endp(s, pid, ep)->halted = 0;
 178 }
 179
 180 static void set_halt(USBHostDevice *s, int pid, int ep)
 181 {
 182     if (ep != 0) {
 183         trace_usb_host_ep_set_halt(s->bus_num, s->addr, ep);
 184         get_endp(s, pid, ep)->halted = 1;
 185     }
 186 }
 187
 188 static int is_iso_started(USBHostDevice *s, int pid, int ep)
 189 {
 190     return get_endp(s, pid, ep)->iso_started;
 191 }
 192
 193 static void clear_iso_started(USBHostDevice *s, int pid, int ep)
 194 {
 195     trace_usb_host_ep_stop_iso(s->bus_num, s->addr, ep);
 196     get_endp(s, pid, ep)->iso_started = 0;
 197 }
 198
 199 static void set_iso_started(USBHostDevice *s, int pid, int ep)
 200 {
 201     struct endp_data *e = get_endp(s, pid, ep);
 202
 203     trace_usb_host_ep_start_iso(s->bus_num, s->addr, ep);
 204     if (!e->iso_started) {
 205         e->iso_started = 1;
 206         e->inflight = 0;
 207     }
 208 }
 209
 210 static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value)
 211 {
 212     struct endp_data *e = get_endp(s, pid, ep);
 213
 214     e->inflight += value;
 215     return e->inflight;
 216 }
 217
 218 static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb)
 219 {
 220     get_endp(s, pid, ep)->iso_urb = iso_urb;
 221 }
 222
 223 static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep)
 224 {
 225     return get_endp(s, pid, ep)->iso_urb;
 226 }
 227
 228 static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i)
 229 {
 230     get_endp(s, pid, ep)->iso_urb_idx = i;
 231 }
 232
 233 static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep)
 234 {
 235     return get_endp(s, pid, ep)->iso_urb_idx;
 236 }
 237
 238 static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i)
 239 {
 240     get_endp(s, pid, ep)->iso_buffer_used = i;
 241 }
 242
 243 static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep)
 244 {
 245     return get_endp(s, pid, ep)->iso_buffer_used;
 246 }
 247
 248 static void set_max_packet_size(USBHostDevice *s, int pid, int ep,
 249                                 uint8_t *descriptor)
 250 {
 251     int raw = descriptor[4] + (descriptor[5] << 8);
 252     int size, microframes;
 253
 254     size = raw & 0x7ff;
 255     switch ((raw >> 11) & 3) {
 256     case 1:  microframes = 2; break;
 257     case 2:  microframes = 3; break;
 258     default: microframes = 1; break;
 259     }
 260     get_endp(s, pid, ep)->max_packet_size = size * microframes;
 261 }
 262
 263 static int get_max_packet_size(USBHostDevice *s, int pid, int ep)
 264 {
 265     return get_endp(s, pid, ep)->max_packet_size;
 266 }
 267
 268 /*
 269  * Async URB state.
 270  * We always allocate iso packet descriptors even for bulk transfers
 271  * to simplify allocation and casts.
 272  */
 273 struct AsyncURB
 274 {
 275     struct usbdevfs_urb urb;
 276     struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB];
 277     USBHostDevice *hdev;
 278     QLIST_ENTRY(AsyncURB) next;
 279
 280     /* For regular async urbs */
 281     USBPacket     *packet;
 282     int more; /* large transfer, more urbs follow */
 283
 284     /* For buffered iso handling */
 285     int iso_frame_idx; /* -1 means in flight */
 286 };
 287
 288 static AsyncURB *async_alloc(USBHostDevice *s)
 289 {
 290     AsyncURB *aurb = g_malloc0(sizeof(AsyncURB));
 291     aurb->hdev = s;
 292     QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
 293     return aurb;
 294 }
 295
 296 static void async_free(AsyncURB *aurb)
 297 {
 298     QLIST_REMOVE(aurb, next);
 299     g_free(aurb);
 300 }
 301
 302 static void do_disconnect(USBHostDevice *s)
 303 {
 304     usb_host_close(s);
 305     usb_host_auto_check(NULL);
 306 }
 307
 308 static void async_complete(void *opaque)
 309 {
 310     USBHostDevice *s = opaque;
 311     AsyncURB *aurb;
 312     int urbs = 0;
 313
 314     while (1) {
 315         USBPacket *p;
 316
 317         int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
 318         if (r < 0) {
 319             if (errno == EAGAIN) {
 320                 if (urbs > 2) {
 321                     fprintf(stderr, "husb: %d iso urbs finished at once\n", urbs);
 322                 }
 323                 return;
 324             }
 325             if (errno == ENODEV) {
 326                 if (!s->closing) {
 327                     trace_usb_host_disconnect(s->bus_num, s->addr);
 328                     do_disconnect(s);
 329                 }
 330                 return;
 331             }
 332
 333             perror("USBDEVFS_REAPURBNDELAY");
 334             return;
 335         }
 336
 337         DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
 338                 aurb, aurb->urb.status, aurb->urb.actual_length);
 339
 340         /* If this is a buffered iso urb mark it as complete and don't do
 341            anything else (it is handled further in usb_host_handle_iso_data) */
 342         if (aurb->iso_frame_idx == -1) {
 343             int inflight;
 344             int pid = (aurb->urb.endpoint & USB_DIR_IN) ?
 345                 USB_TOKEN_IN : USB_TOKEN_OUT;
 346             int ep = aurb->urb.endpoint & 0xf;
 347             if (aurb->urb.status == -EPIPE) {
 348                 set_halt(s, pid, ep);
 349             }
 350             aurb->iso_frame_idx = 0;
 351             urbs++;
 352             inflight = change_iso_inflight(s, pid, ep, -1);
 353             if (inflight == 0 && is_iso_started(s, pid, ep)) {
 354                 fprintf(stderr, "husb: out of buffers for iso stream\n");
 355             }
 356             continue;
 357         }
 358
 359         p = aurb->packet;
 360         trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status,
 361                                     aurb->urb.actual_length, aurb->more);
 362
 363         if (p) {
 364             switch (aurb->urb.status) {
 365             case 0:
 366                 p->result += aurb->urb.actual_length;
 367                 break;
 368
 369             case -EPIPE:
 370                 set_halt(s, p->pid, p->devep);
 371                 p->result = USB_RET_STALL;
 372                 break;
 373
 374             default:
 375                 p->result = USB_RET_NAK;
 376                 break;
 377             }
 378
 379             if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
 380                 trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
 381                 usb_generic_async_ctrl_complete(&s->dev, p);
 382             } else if (!aurb->more) {
 383                 trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
 384                 usb_packet_complete(&s->dev, p);
 385             }
 386         }
 387
 388         async_free(aurb);
 389     }
 390 }
 391
 392 static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
 393 {
 394     USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
 395     AsyncURB *aurb;
 396
 397     QLIST_FOREACH(aurb, &s->aurbs, next) {
 398         if (p != aurb->packet) {
 399             continue;
 400         }
 401
 402         DPRINTF("husb: async cancel: packet %p, aurb %p\n", p, aurb);
 403
 404         /* Mark it as dead (see async_complete above) */
 405         aurb->packet = NULL;
 406
 407         int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
 408         if (r < 0) {
 409             DPRINTF("husb: async. discard urb failed errno %d\n", errno);
 410         }
 411     }
 412 }
 413
 414 static int usb_host_claim_port(USBHostDevice *s)
 415 {
 416 #ifdef USBDEVFS_CLAIM_PORT
 417     char *h, hub_name[64], line[1024];
 418     int hub_addr, portnr, ret;
 419
 420     snprintf(hub_name, sizeof(hub_name), "%d-%s",
 421              s->match.bus_num, s->match.port);
 422
 423     /* try strip off last ".$portnr" to get hub */
 424     h = strrchr(hub_name, '.');
 425     if (h != NULL) {
 426         portnr = atoi(h+1);
 427         *h = '\0';
 428     } else {
 429         /* no dot in there -> it is the root hub */
 430         snprintf(hub_name, sizeof(hub_name), "usb%d",
 431                  s->match.bus_num);
 432         portnr = atoi(s->match.port);
 433     }
 434
 435     if (!usb_host_read_file(line, sizeof(line), "devnum",
 436                             hub_name)) {
 437         return -1;
 438     }
 439     if (sscanf(line, "%d", &hub_addr) != 1) {
 440         return -1;
 441     }
 442
 443     if (!usb_host_device_path) {
 444         return -1;
 445     }
 446     snprintf(line, sizeof(line), "%s/%03d/%03d",
 447              usb_host_device_path, s->match.bus_num, hub_addr);
 448     s->hub_fd = open(line, O_RDWR | O_NONBLOCK);
 449     if (s->hub_fd < 0) {
 450         return -1;
 451     }
 452
 453     ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &portnr);
 454     if (ret < 0) {
 455         close(s->hub_fd);
 456         s->hub_fd = -1;
 457         return -1;
 458     }
 459
 460     trace_usb_host_claim_port(s->match.bus_num, hub_addr, portnr);
 461     return 0;
 462 #else
 463     return -1;
 464 #endif
 465 }
 466
 467 static int usb_host_disconnect_ifaces(USBHostDevice *dev, int nb_interfaces)
 468 {
 469     /* earlier Linux 2.4 do not support that */
 470 #ifdef USBDEVFS_DISCONNECT
 471     struct usbdevfs_ioctl ctrl;
 472     int ret, interface;
 473
 474     for (interface = 0; interface < nb_interfaces; interface++) {
 475         ctrl.ioctl_code = USBDEVFS_DISCONNECT;
 476         ctrl.ifno = interface;
 477         ctrl.data = 0;
 478         ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
 479         if (ret < 0 && errno != ENODATA) {
 480             perror("USBDEVFS_DISCONNECT");
 481             return -1;
 482         }
 483     }
 484 #endif
 485     return 0;
 486 }
 487
 488 static int usb_linux_get_num_interfaces(USBHostDevice *s)
 489 {
 490     char device_name[64], line[1024];
 491     int num_interfaces = 0;
 492
 493     if (usb_fs_type != USB_FS_SYS) {
 494         return -1;
 495     }
 496
 497     sprintf(device_name, "%d-%s", s->bus_num, s->port);
 498     if (!usb_host_read_file(line, sizeof(line), "bNumInterfaces",
 499                             device_name)) {
 500         return -1;
 501     }
 502     if (sscanf(line, "%d", &num_interfaces) != 1) {
 503         return -1;
 504     }
 505     return num_interfaces;
 506 }
 507
 508 static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
 509 {
 510     const char *op = NULL;
 511     int dev_descr_len, config_descr_len;
 512     int interface, nb_interfaces;
 513     int ret, i;
 514
 515     if (configuration == 0) { /* address state - ignore */
 516         dev->ninterfaces   = 0;
 517         dev->configuration = 0;
 518         return 1;
 519     }
 520
 521     DPRINTF("husb: claiming interfaces. config %d\n", configuration);
 522
 523     i = 0;
 524     dev_descr_len = dev->descr[0];
 525     if (dev_descr_len > dev->descr_len) {
 526         fprintf(stderr, "husb: update iface failed. descr too short\n");
 527         return 0;
 528     }
 529
 530     i += dev_descr_len;
 531     while (i < dev->descr_len) {
 532         DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
 533                 i, dev->descr_len,
 534                dev->descr[i], dev->descr[i+1]);
 535
 536         if (dev->descr[i+1] != USB_DT_CONFIG) {
 537             i += dev->descr[i];
 538             continue;
 539         }
 540         config_descr_len = dev->descr[i];
 541
 542         DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
 543
 544         if (configuration == dev->descr[i + 5]) {
 545             configuration = dev->descr[i + 5];
 546             break;
 547         }
 548
 549         i += config_descr_len;
 550     }
 551
 552     if (i >= dev->descr_len) {
 553         fprintf(stderr,
 554                 "husb: update iface failed. no matching configuration\n");
 555         return 0;
 556     }
 557     nb_interfaces = dev->descr[i + 4];
 558
 559     if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) {
 560         goto fail;
 561     }
 562
 563     /* XXX: only grab if all interfaces are free */
 564     for (interface = 0; interface < nb_interfaces; interface++) {
 565         op = "USBDEVFS_CLAIMINTERFACE";
 566         ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
 567         if (ret < 0) {
 568             goto fail;
 569         }
 570     }
 571
 572     trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
 573                                     nb_interfaces, configuration);
 574
 575     dev->ninterfaces   = nb_interfaces;
 576     dev->configuration = configuration;
 577     return 1;
 578
 579 fail:
 580     if (errno == ENODEV) {
 581         do_disconnect(dev);
 582     }
 583     perror(op);
 584     return 0;
 585 }
 586
 587 static int usb_host_release_interfaces(USBHostDevice *s)
 588 {
 589     int ret, i;
 590
 591     trace_usb_host_release_interfaces(s->bus_num, s->addr);
 592
 593     for (i = 0; i < s->ninterfaces; i++) {
 594         ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
 595         if (ret < 0) {
 596             perror("USBDEVFS_RELEASEINTERFACE");
 597             return 0;
 598         }
 599     }
 600     return 1;
 601 }
 602
 603 static void usb_host_handle_reset(USBDevice *dev)
 604 {
 605     USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
 606
 607     trace_usb_host_reset(s->bus_num, s->addr);
 608
 609     ioctl(s->fd, USBDEVFS_RESET);
 610
 611     usb_host_claim_interfaces(s, 0);
 612     usb_linux_update_endp_table(s);
 613 }
 614
 615 static void usb_host_handle_destroy(USBDevice *dev)
 616 {
 617     USBHostDevice *s = (USBHostDevice *)dev;
 618
 619     usb_host_close(s);
 620     if (s->hub_fd != -1) {
 621         close(s->hub_fd);
 622     }
 623     QTAILQ_REMOVE(&hostdevs, s, next);
 624     qemu_remove_exit_notifier(&s->exit);
 625 }
 626
 627 /* iso data is special, we need to keep enough urbs in flight to make sure
 628    that the controller never runs out of them, otherwise the device will
 629    likely suffer a buffer underrun / overrun. */
 630 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
 631 {
 632     AsyncURB *aurb;
 633     int i, j, len = get_max_packet_size(s, pid, ep);
 634
 635     aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
 636     for (i = 0; i < s->iso_urb_count; i++) {
 637         aurb[i].urb.endpoint      = ep;
 638         aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
 639         aurb[i].urb.buffer        = g_malloc(aurb[i].urb.buffer_length);
 640         aurb[i].urb.type          = USBDEVFS_URB_TYPE_ISO;
 641         aurb[i].urb.flags         = USBDEVFS_URB_ISO_ASAP;
 642         aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
 643         for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
 644             aurb[i].urb.iso_frame_desc[j].length = len;
 645         if (pid == USB_TOKEN_IN) {
 646             aurb[i].urb.endpoint |= 0x80;
 647             /* Mark as fully consumed (idle) */
 648             aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
 649         }
 650     }
 651     set_iso_urb(s, pid, ep, aurb);
 652
 653     return aurb;
 654 }
 655
 656 static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
 657 {
 658     AsyncURB *aurb;
 659     int i, ret, killed = 0, free = 1;
 660
 661     aurb = get_iso_urb(s, pid, ep);
 662     if (!aurb) {
 663         return;
 664     }
 665
 666     for (i = 0; i < s->iso_urb_count; i++) {
 667         /* in flight? */
 668         if (aurb[i].iso_frame_idx == -1) {
 669             ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
 670             if (ret < 0) {
 671                 perror("USBDEVFS_DISCARDURB");
 672                 free = 0;
 673                 continue;
 674             }
 675             killed++;
 676         }
 677     }
 678
 679     /* Make sure any urbs we've killed are reaped before we free them */
 680     if (killed) {
 681         async_complete(s);
 682     }
 683
 684     for (i = 0; i < s->iso_urb_count; i++) {
 685         g_free(aurb[i].urb.buffer);
 686     }
 687
 688     if (free)
 689         g_free(aurb);
 690     else
 691         printf("husb: leaking iso urbs because of discard failure\n");
 692     set_iso_urb(s, pid, ep, NULL);
 693     set_iso_urb_idx(s, pid, ep, 0);
 694     clear_iso_started(s, pid, ep);
 695 }
 696
 697 static int urb_status_to_usb_ret(int status)
 698 {
 699     switch (status) {
 700     case -EPIPE:
 701         return USB_RET_STALL;
 702     default:
 703         return USB_RET_NAK;
 704     }
 705 }
 706
 707 static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
 708 {
 709     AsyncURB *aurb;
 710     int i, j, ret, max_packet_size, offset, len = 0;
 711     uint8_t *buf;
 712
 713     max_packet_size = get_max_packet_size(s, p->pid, p->devep);
 714     if (max_packet_size == 0)
 715         return USB_RET_NAK;
 716
 717     aurb = get_iso_urb(s, p->pid, p->devep);
 718     if (!aurb) {
 719         aurb = usb_host_alloc_iso(s, p->pid, p->devep);
 720     }
 721
 722     i = get_iso_urb_idx(s, p->pid, p->devep);
 723     j = aurb[i].iso_frame_idx;
 724     if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
 725         if (in) {
 726             /* Check urb status  */
 727             if (aurb[i].urb.status) {
 728                 len = urb_status_to_usb_ret(aurb[i].urb.status);
 729                 /* Move to the next urb */
 730                 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
 731             /* Check frame status */
 732             } else if (aurb[i].urb.iso_frame_desc[j].status) {
 733                 len = urb_status_to_usb_ret(
 734                                         aurb[i].urb.iso_frame_desc[j].status);
 735             /* Check the frame fits */
 736             } else if (aurb[i].urb.iso_frame_desc[j].actual_length
 737                        > p->iov.size) {
 738                 printf("husb: received iso data is larger then packet\n");
 739                 len = USB_RET_NAK;
 740             /* All good copy data over */
 741             } else {
 742                 len = aurb[i].urb.iso_frame_desc[j].actual_length;
 743                 buf  = aurb[i].urb.buffer +
 744                     j * aurb[i].urb.iso_frame_desc[0].length;
 745                 usb_packet_copy(p, buf, len);
 746             }
 747         } else {
 748             len = p->iov.size;
 749             offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
 750
 751             /* Check the frame fits */
 752             if (len > max_packet_size) {
 753                 printf("husb: send iso data is larger then max packet size\n");
 754                 return USB_RET_NAK;
 755             }
 756
 757             /* All good copy data over */
 758             usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
 759             aurb[i].urb.iso_frame_desc[j].length = len;
 760             offset += len;
 761             set_iso_buffer_used(s, p->pid, p->devep, offset);
 762
 763             /* Start the stream once we have buffered enough data */
 764             if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
 765                 set_iso_started(s, p->pid, p->devep);
 766             }
 767         }
 768         aurb[i].iso_frame_idx++;
 769         if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
 770             i = (i + 1) % s->iso_urb_count;
 771             set_iso_urb_idx(s, p->pid, p->devep, i);
 772         }
 773     } else {
 774         if (in) {
 775             set_iso_started(s, p->pid, p->devep);
 776         } else {
 777             DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
 778         }
 779     }
 780
 781     if (is_iso_started(s, p->pid, p->devep)) {
 782         /* (Re)-submit all fully consumed / filled urbs */
 783         for (i = 0; i < s->iso_urb_count; i++) {
 784             if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
 785                 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
 786                 if (ret < 0) {
 787                     perror("USBDEVFS_SUBMITURB");
 788                     if (!in || len == 0) {
 789                         switch(errno) {
 790                         case ETIMEDOUT:
 791                             len = USB_RET_NAK;
 792                             break;
 793                         case EPIPE:
 794                         default:
 795                             len = USB_RET_STALL;
 796                         }
 797                     }
 798                     break;
 799                 }
 800                 aurb[i].iso_frame_idx = -1;
 801                 change_iso_inflight(s, p->pid, p->devep, 1);
 802             }
 803         }
 804     }
 805
 806     return len;
 807 }
 808
 809 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
 810 {
 811     USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
 812     struct usbdevfs_urb *urb;
 813     AsyncURB *aurb;
 814     int ret, rem, prem, v;
 815     uint8_t *pbuf;
 816     uint8_t ep;
 817
 818     trace_usb_host_req_data(s->bus_num, s->addr,
 819                             p->pid == USB_TOKEN_IN,
 820                             p->devep, p->iov.size);
 821
 822     if (!is_valid(s, p->pid, p->devep)) {
 823         trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
 824         return USB_RET_NAK;
 825     }
 826
 827     if (p->pid == USB_TOKEN_IN) {
 828         ep = p->devep | 0x80;
 829     } else {
 830         ep = p->devep;
 831     }
 832
 833     if (is_halted(s, p->pid, p->devep)) {
 834         unsigned int arg = ep;
 835         ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
 836         if (ret < 0) {
 837             perror("USBDEVFS_CLEAR_HALT");
 838             trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
 839             return USB_RET_NAK;
 840         }
 841         clear_halt(s, p->pid, p->devep);
 842     }
 843
 844     if (is_isoc(s, p->pid, p->devep)) {
 845         return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
 846     }
 847
 848     v = 0;
 849     prem = p->iov.iov[v].iov_len;
 850     pbuf = p->iov.iov[v].iov_base;
 851     rem = p->iov.size;
 852     while (rem) {
 853         if (prem == 0) {
 854             v++;
 855             assert(v < p->iov.niov);
 856             prem = p->iov.iov[v].iov_len;
 857             pbuf = p->iov.iov[v].iov_base;
 858             assert(prem <= rem);
 859         }
 860         aurb = async_alloc(s);
 861         aurb->packet = p;
 862
 863         urb = &aurb->urb;
 864         urb->endpoint      = ep;
 865         urb->type          = USBDEVFS_URB_TYPE_BULK;
 866         urb->usercontext   = s;
 867         urb->buffer        = pbuf;
 868         urb->buffer_length = prem;
 869
 870         if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
 871             urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
 872         }
 873         pbuf += urb->buffer_length;
 874         prem -= urb->buffer_length;
 875         rem  -= urb->buffer_length;
 876         if (rem) {
 877             aurb->more         = 1;
 878         }
 879
 880         trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
 881                                   urb->buffer_length, aurb->more);
 882         ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
 883
 884         DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
 885                 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
 886
 887         if (ret < 0) {
 888             perror("USBDEVFS_SUBMITURB");
 889             async_free(aurb);
 890
 891             switch(errno) {
 892             case ETIMEDOUT:
 893                 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
 894                 return USB_RET_NAK;
 895             case EPIPE:
 896             default:
 897                 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL);
 898                 return USB_RET_STALL;
 899             }
 900         }
 901     }
 902
 903     return USB_RET_ASYNC;
 904 }
 905
 906 static int ctrl_error(void)
 907 {
 908     if (errno == ETIMEDOUT) {
 909         return USB_RET_NAK;
 910     } else {
 911         return USB_RET_STALL;
 912     }
 913 }
 914
 915 static int usb_host_set_address(USBHostDevice *s, int addr)
 916 {
 917     trace_usb_host_set_address(s->bus_num, s->addr, addr);
 918     s->dev.addr = addr;
 919     return 0;
 920 }
 921
 922 static int usb_host_set_config(USBHostDevice *s, int config)
 923 {
 924     int ret, first = 1;
 925
 926     trace_usb_host_set_config(s->bus_num, s->addr, config);
 927
 928     usb_host_release_interfaces(s);
 929
 930 again:
 931     ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
 932
 933     DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
 934
 935     if (ret < 0 && errno == EBUSY && first) {
 936         /* happens if usb device is in use by host drivers */
 937         int count = usb_linux_get_num_interfaces(s);
 938         if (count > 0) {
 939             DPRINTF("husb: busy -> disconnecting %d interfaces\n", count);
 940             usb_host_disconnect_ifaces(s, count);
 941             first = 0;
 942             goto again;
 943         }
 944     }
 945
 946     if (ret < 0) {
 947         return ctrl_error();
 948     }
 949     usb_host_claim_interfaces(s, config);
 950     usb_linux_update_endp_table(s);
 951     return 0;
 952 }
 953
 954 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
 955 {
 956     struct usbdevfs_setinterface si;
 957     int i, ret;
 958
 959     trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
 960
 961     for (i = 1; i <= MAX_ENDPOINTS; i++) {
 962         if (is_isoc(s, USB_TOKEN_IN, i)) {
 963             usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i);
 964         }
 965         if (is_isoc(s, USB_TOKEN_OUT, i)) {
 966             usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i);
 967         }
 968     }
 969
 970     si.interface  = iface;
 971     si.altsetting = alt;
 972     ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
 973
 974     DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
 975             iface, alt, ret, errno);
 976
 977     if (ret < 0) {
 978         return ctrl_error();
 979     }
 980     usb_linux_update_endp_table(s);
 981     return 0;
 982 }
 983
 984 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
 985                int request, int value, int index, int length, uint8_t *data)
 986 {
 987     USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
 988     struct usbdevfs_urb *urb;
 989     AsyncURB *aurb;
 990     int ret;
 991
 992     /*
 993      * Process certain standard device requests.
 994      * These are infrequent and are processed synchronously.
 995      */
 996
 997     /* Note request is (bRequestType << 8) | bRequest */
 998     trace_usb_host_req_control(s->bus_num, s->addr, request, value, index);
 999
1000     switch (request) {
1001     case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1002         return usb_host_set_address(s, value);
1003
1004     case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1005         return usb_host_set_config(s, value & 0xff);
1006
1007     case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1008         return usb_host_set_interface(s, index, value);
1009     }
1010
1011     /* The rest are asynchronous */
1012
1013     if (length > sizeof(dev->data_buf)) {
1014         fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
1015                 length, sizeof(dev->data_buf));
1016         return USB_RET_STALL;
1017     }
1018
1019     aurb = async_alloc(s);
1020     aurb->packet = p;
1021
1022     /*
1023      * Setup ctrl transfer.
1024      *
1025      * s->ctrl is laid out such that data buffer immediately follows
1026      * 'req' struct which is exactly what usbdevfs expects.
1027      */
1028     urb = &aurb->urb;
1029
1030     urb->type     = USBDEVFS_URB_TYPE_CONTROL;
1031     urb->endpoint = p->devep;
1032
1033     urb->buffer        = &dev->setup_buf;
1034     urb->buffer_length = length + 8;
1035
1036     urb->usercontext = s;
1037
1038     trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
1039                               urb->buffer_length, aurb->more);
1040     ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
1041
1042     DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
1043
1044     if (ret < 0) {
1045         DPRINTF("husb: submit failed. errno %d\n", errno);
1046         async_free(aurb);
1047
1048         switch(errno) {
1049         case ETIMEDOUT:
1050             return USB_RET_NAK;
1051         case EPIPE:
1052         default:
1053             return USB_RET_STALL;
1054         }
1055     }
1056
1057     return USB_RET_ASYNC;
1058 }
1059
1060 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
1061     uint8_t configuration, uint8_t interface)
1062 {
1063     uint8_t alt_setting;
1064     struct usb_ctrltransfer ct;
1065     int ret;
1066
1067     if (usb_fs_type == USB_FS_SYS) {
1068         char device_name[64], line[1024];
1069         int alt_setting;
1070
1071         sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
1072                 (int)configuration, (int)interface);
1073
1074         if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
1075                                 device_name)) {
1076             goto usbdevfs;
1077         }
1078         if (sscanf(line, "%d", &alt_setting) != 1) {
1079             goto usbdevfs;
1080         }
1081         return alt_setting;
1082     }
1083
1084 usbdevfs:
1085     ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
1086     ct.bRequest = USB_REQ_GET_INTERFACE;
1087     ct.wValue = 0;
1088     ct.wIndex = interface;
1089     ct.wLength = 1;
1090     ct.data = &alt_setting;
1091     ct.timeout = 50;
1092     ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
1093     if (ret < 0) {
1094         /* Assume alt 0 on error */
1095         return 0;
1096     }
1097
1098     return alt_setting;
1099 }
1100
1101 /* returns 1 on problem encountered or 0 for success */
1102 static int usb_linux_update_endp_table(USBHostDevice *s)
1103 {
1104     uint8_t *descriptors;
1105     uint8_t devep, type, alt_interface;
1106     int interface, length, i, ep, pid;
1107     struct endp_data *epd;
1108
1109     for (i = 0; i < MAX_ENDPOINTS; i++) {
1110         s->ep_in[i].type = INVALID_EP_TYPE;
1111         s->ep_out[i].type = INVALID_EP_TYPE;
1112     }
1113
1114     if (s->configuration == 0) {
1115         /* not configured yet -- leave all endpoints disabled */
1116         return 0;
1117     }
1118
1119     /* get the desired configuration, interface, and endpoint descriptors
1120      * from device description */
1121     descriptors = &s->descr[18];
1122     length = s->descr_len - 18;
1123     i = 0;
1124
1125     if (descriptors[i + 1] != USB_DT_CONFIG ||
1126         descriptors[i + 5] != s->configuration) {
1127         fprintf(stderr, "invalid descriptor data - configuration %d\n",
1128                 s->configuration);
1129         return 1;
1130     }
1131     i += descriptors[i];
1132
1133     while (i < length) {
1134         if (descriptors[i + 1] != USB_DT_INTERFACE ||
1135             (descriptors[i + 1] == USB_DT_INTERFACE &&
1136              descriptors[i + 4] == 0)) {
1137             i += descriptors[i];
1138             continue;
1139         }
1140
1141         interface = descriptors[i + 2];
1142         alt_interface = usb_linux_get_alt_setting(s, s->configuration,
1143                                                   interface);
1144
1145         /* the current interface descriptor is the active interface
1146          * and has endpoints */
1147         if (descriptors[i + 3] != alt_interface) {
1148             i += descriptors[i];
1149             continue;
1150         }
1151
1152         /* advance to the endpoints */
1153         while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1154             i += descriptors[i];
1155         }
1156
1157         if (i >= length)
1158             break;
1159
1160         while (i < length) {
1161             if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1162                 break;
1163             }
1164
1165             devep = descriptors[i + 2];
1166             pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1167             ep = devep & 0xf;
1168             if (ep == 0) {
1169                 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1170                 return 1;
1171             }
1172
1173             switch (descriptors[i + 3] & 0x3) {
1174             case 0x00:
1175                 type = USBDEVFS_URB_TYPE_CONTROL;
1176                 break;
1177             case 0x01:
1178                 type = USBDEVFS_URB_TYPE_ISO;
1179                 set_max_packet_size(s, pid, ep, descriptors + i);
1180                 break;
1181             case 0x02:
1182                 type = USBDEVFS_URB_TYPE_BULK;
1183                 break;
1184             case 0x03:
1185                 type = USBDEVFS_URB_TYPE_INTERRUPT;
1186                 break;
1187             default:
1188                 DPRINTF("usb_host: malformed endpoint type\n");
1189                 type = USBDEVFS_URB_TYPE_BULK;
1190             }
1191             epd = get_endp(s, pid, ep);
1192             assert(epd->type == INVALID_EP_TYPE);
1193             epd->type = type;
1194             epd->halted = 0;
1195
1196             i += descriptors[i];
1197         }
1198     }
1199     return 0;
1200 }
1201
1202 /*
1203  * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1204  * this function assumes this is safe, if:
1205  * 1) There are no isoc endpoints
1206  * 2) There are no interrupt endpoints with a max_packet_size > 64
1207  * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1208  * usb1 compatible, but in practice this seems to work fine.
1209  */
1210 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1211 {
1212     int i, packet_size;
1213
1214     /*
1215      * usb_linux_update_endp_table only registers info about ep in the current
1216      * interface altsettings, so we need to parse the descriptors again.
1217      */
1218     for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1219         if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1220             switch (dev->descr[i + 3] & 0x3) {
1221             case 0x00: /* CONTROL */
1222                 break;
1223             case 0x01: /* ISO */
1224                 return 0;
1225             case 0x02: /* BULK */
1226                 break;
1227             case 0x03: /* INTERRUPT */
1228                 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1229                 if (packet_size > 64)
1230                     return 0;
1231                 break;
1232             }
1233         }
1234     }
1235     return 1;
1236 }
1237
1238 static int usb_host_open(USBHostDevice *dev, int bus_num,
1239                          int addr, const char *port,
1240                          const char *prod_name, int speed)
1241 {
1242     int fd = -1, ret;
1243     char buf[1024];
1244
1245     trace_usb_host_open_started(bus_num, addr);
1246
1247     if (dev->fd != -1) {
1248         goto fail;
1249     }
1250
1251     if (!usb_host_device_path) {
1252         perror("husb: USB Host Device Path not set");
1253         goto fail;
1254     }
1255     snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1256              bus_num, addr);
1257     fd = open(buf, O_RDWR | O_NONBLOCK);
1258     if (fd < 0) {
1259         perror(buf);
1260         goto fail;
1261     }
1262     DPRINTF("husb: opened %s\n", buf);
1263
1264     dev->bus_num = bus_num;
1265     dev->addr = addr;
1266     strcpy(dev->port, port);
1267     dev->fd = fd;
1268
1269     /* read the device description */
1270     dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1271     if (dev->descr_len <= 0) {
1272         perror("husb: reading device data failed");
1273         goto fail;
1274     }
1275
1276 #ifdef DEBUG
1277     {
1278         int x;
1279         printf("=== begin dumping device descriptor data ===\n");
1280         for (x = 0; x < dev->descr_len; x++) {
1281             printf("%02x ", dev->descr[x]);
1282         }
1283         printf("\n=== end dumping device descriptor data ===\n");
1284     }
1285 #endif
1286
1287
1288     /* start unconfigured -- we'll wait for the guest to set a configuration */
1289     if (!usb_host_claim_interfaces(dev, 0)) {
1290         goto fail;
1291     }
1292
1293     ret = usb_linux_update_endp_table(dev);
1294     if (ret) {
1295         goto fail;
1296     }
1297
1298     if (speed == -1) {
1299         struct usbdevfs_connectinfo ci;
1300
1301         ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1302         if (ret < 0) {
1303             perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1304             goto fail;
1305         }
1306
1307         if (ci.slow) {
1308             speed = USB_SPEED_LOW;
1309         } else {
1310             speed = USB_SPEED_HIGH;
1311         }
1312     }
1313     dev->dev.speed = speed;
1314     dev->dev.speedmask = (1 << speed);
1315     if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1316         dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1317     }
1318
1319     trace_usb_host_open_success(bus_num, addr);
1320
1321     if (!prod_name || prod_name[0] == '\0') {
1322         snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1323                  "host:%d.%d", bus_num, addr);
1324     } else {
1325         pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1326                 prod_name);
1327     }
1328
1329     ret = usb_device_attach(&dev->dev);
1330     if (ret) {
1331         goto fail;
1332     }
1333
1334     /* USB devio uses 'write' flag to check for async completions */
1335     qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1336
1337     return 0;
1338
1339 fail:
1340     trace_usb_host_open_failure(bus_num, addr);
1341     if (dev->fd != -1) {
1342         close(dev->fd);
1343         dev->fd = -1;
1344     }
1345     return -1;
1346 }
1347
1348 static int usb_host_close(USBHostDevice *dev)
1349 {
1350     int i;
1351
1352     if (dev->fd == -1 || !dev->dev.attached) {
1353         return -1;
1354     }
1355
1356     trace_usb_host_close(dev->bus_num, dev->addr);
1357
1358     qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1359     dev->closing = 1;
1360     for (i = 1; i <= MAX_ENDPOINTS; i++) {
1361         if (is_isoc(dev, USB_TOKEN_IN, i)) {
1362             usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i);
1363         }
1364         if (is_isoc(dev, USB_TOKEN_OUT, i)) {
1365             usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i);
1366         }
1367     }
1368     async_complete(dev);
1369     dev->closing = 0;
1370     usb_device_detach(&dev->dev);
1371     ioctl(dev->fd, USBDEVFS_RESET);
1372     close(dev->fd);
1373     dev->fd = -1;
1374     return 0;
1375 }
1376
1377 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1378 {
1379     USBHostDevice *s = container_of(n, USBHostDevice, exit);
1380
1381     if (s->fd != -1) {
1382         ioctl(s->fd, USBDEVFS_RESET);
1383     }
1384 }
1385
1386 static int usb_host_initfn(USBDevice *dev)
1387 {
1388     USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1389
1390     dev->auto_attach = 0;
1391     s->fd = -1;
1392     s->hub_fd = -1;
1393
1394     QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1395     s->exit.notify = usb_host_exit_notifier;
1396     qemu_add_exit_notifier(&s->exit);
1397     usb_host_auto_check(NULL);
1398
1399     if (s->match.bus_num != 0 && s->match.port != NULL) {
1400         usb_host_claim_port(s);
1401     }
1402     return 0;
1403 }
1404
1405 static const VMStateDescription vmstate_usb_host = {
1406     .name = "usb-host",
1407     .unmigratable = 1,
1408 };
1409
1410 static struct USBDeviceInfo usb_host_dev_info = {
1411     .product_desc   = "USB Host Device",
1412     .qdev.name      = "usb-host",
1413     .qdev.size      = sizeof(USBHostDevice),
1414     .qdev.vmsd      = &vmstate_usb_host,
1415     .init           = usb_host_initfn,
1416     .handle_packet  = usb_generic_handle_packet,
1417     .cancel_packet  = usb_host_async_cancel,
1418     .handle_data    = usb_host_handle_data,
1419     .handle_control = usb_host_handle_control,
1420     .handle_reset   = usb_host_handle_reset,
1421     .handle_destroy = usb_host_handle_destroy,
1422     .usbdevice_name = "host",
1423     .usbdevice_init = usb_host_device_open,
1424     .qdev.props     = (Property[]) {
1425         DEFINE_PROP_UINT32("hostbus",  USBHostDevice, match.bus_num,    0),
1426         DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr,       0),
1427         DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1428         DEFINE_PROP_HEX32("vendorid",  USBHostDevice, match.vendor_id,  0),
1429         DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1430         DEFINE_PROP_UINT32("isobufs",  USBHostDevice, iso_urb_count,    4),
1431         DEFINE_PROP_END_OF_LIST(),
1432     },
1433 };
1434
1435 static void usb_host_register_devices(void)
1436 {
1437     usb_qdev_register(&usb_host_dev_info);
1438 }
1439 device_init(usb_host_register_devices)
1440
1441 USBDevice *usb_host_device_open(const char *devname)
1442 {
1443     struct USBAutoFilter filter;
1444     USBDevice *dev;
1445     char *p;
1446
1447     dev = usb_create(NULL /* FIXME */, "usb-host");
1448
1449     if (strstr(devname, "auto:")) {
1450         if (parse_filter(devname, &filter) < 0) {
1451             goto fail;
1452         }
1453     } else {
1454         if ((p = strchr(devname, '.'))) {
1455             filter.bus_num    = strtoul(devname, NULL, 0);
1456             filter.addr       = strtoul(p + 1, NULL, 0);
1457             filter.vendor_id  = 0;
1458             filter.product_id = 0;
1459         } else if ((p = strchr(devname, ':'))) {
1460             filter.bus_num    = 0;
1461             filter.addr       = 0;
1462             filter.vendor_id  = strtoul(devname, NULL, 16);
1463             filter.product_id = strtoul(p + 1, NULL, 16);
1464         } else {
1465             goto fail;
1466         }
1467     }
1468
1469     qdev_prop_set_uint32(&dev->qdev, "hostbus",   filter.bus_num);
1470     qdev_prop_set_uint32(&dev->qdev, "hostaddr",  filter.addr);
1471     qdev_prop_set_uint32(&dev->qdev, "vendorid",  filter.vendor_id);
1472     qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1473     qdev_init_nofail(&dev->qdev);
1474     return dev;
1475
1476 fail:
1477     qdev_free(&dev->qdev);
1478     return NULL;
1479 }
1480
1481 int usb_host_device_close(const char *devname)
1482 {
1483 #if 0
1484     char product_name[PRODUCT_NAME_SZ];
1485     int bus_num, addr;
1486     USBHostDevice *s;
1487
1488     if (strstr(devname, "auto:")) {
1489         return usb_host_auto_del(devname);
1490     }
1491     if (usb_host_find_device(&bus_num, &addr, product_name,
1492                                     sizeof(product_name), devname) < 0) {
1493         return -1;
1494     }
1495     s = hostdev_find(bus_num, addr);
1496     if (s) {
1497         usb_device_delete_addr(s->bus_num, s->dev.addr);
1498         return 0;
1499     }
1500 #endif
1501
1502     return -1;
1503 }
1504
1505 static int get_tag_value(char *buf, int buf_size,
1506                          const char *str, const char *tag,
1507                          const char *stopchars)
1508 {
1509     const char *p;
1510     char *q;
1511     p = strstr(str, tag);
1512     if (!p) {
1513         return -1;
1514     }
1515     p += strlen(tag);
1516     while (qemu_isspace(*p)) {
1517         p++;
1518     }
1519     q = buf;
1520     while (*p != '\0' && !strchr(stopchars, *p)) {
1521         if ((q - buf) < (buf_size - 1)) {
1522             *q++ = *p;
1523         }
1524         p++;
1525     }
1526     *q = '\0';
1527     return q - buf;
1528 }
1529
1530 /*
1531  * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1532  * host's USB devices. This is legacy support since many distributions
1533  * are moving to /sys/bus/usb
1534  */
1535 static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1536 {
1537     FILE *f = NULL;
1538     char line[1024];
1539     char buf[1024];
1540     int bus_num, addr, speed, device_count;
1541     int class_id, product_id, vendor_id, port;
1542     char product_name[512];
1543     int ret = 0;
1544
1545     if (!usb_host_device_path) {
1546         perror("husb: USB Host Device Path not set");
1547         goto the_end;
1548     }
1549     snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1550     f = fopen(line, "r");
1551     if (!f) {
1552         perror("husb: cannot open devices file");
1553         goto the_end;
1554     }
1555
1556     device_count = 0;
1557     bus_num = addr = class_id = product_id = vendor_id = port = 0;
1558     speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1559     for(;;) {
1560         if (fgets(line, sizeof(line), f) == NULL) {
1561             break;
1562         }
1563         if (strlen(line) > 0) {
1564             line[strlen(line) - 1] = '\0';
1565         }
1566         if (line[0] == 'T' && line[1] == ':') {
1567             if (device_count && (vendor_id || product_id)) {
1568                 /* New device.  Add the previously discovered device.  */
1569                 ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1570                            product_id, product_name, speed);
1571                 if (ret) {
1572                     goto the_end;
1573                 }
1574             }
1575             if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1576                 goto fail;
1577             }
1578             bus_num = atoi(buf);
1579             if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) {
1580                 goto fail;
1581             }
1582             port = atoi(buf);
1583             if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1584                 goto fail;
1585             }
1586             addr = atoi(buf);
1587             if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1588                 goto fail;
1589             }
1590             if (!strcmp(buf, "5000")) {
1591                 speed = USB_SPEED_SUPER;
1592             } else if (!strcmp(buf, "480")) {
1593                 speed = USB_SPEED_HIGH;
1594             } else if (!strcmp(buf, "1.5")) {
1595                 speed = USB_SPEED_LOW;
1596             } else {
1597                 speed = USB_SPEED_FULL;
1598             }
1599             product_name[0] = '\0';
1600             class_id = 0xff;
1601             device_count++;
1602             product_id = 0;
1603             vendor_id = 0;
1604         } else if (line[0] == 'P' && line[1] == ':') {
1605             if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1606                 goto fail;
1607             }
1608             vendor_id = strtoul(buf, NULL, 16);
1609             if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1610                 goto fail;
1611             }
1612             product_id = strtoul(buf, NULL, 16);
1613         } else if (line[0] == 'S' && line[1] == ':') {
1614             if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1615                 goto fail;
1616             }
1617             pstrcpy(product_name, sizeof(product_name), buf);
1618         } else if (line[0] == 'D' && line[1] == ':') {
1619             if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1620                 goto fail;
1621             }
1622             class_id = strtoul(buf, NULL, 16);
1623         }
1624     fail: ;
1625     }
1626     if (device_count && (vendor_id || product_id)) {
1627         /* Add the last device.  */
1628         if (port > 0) {
1629             snprintf(buf, sizeof(buf), "%d", port);
1630         } else {
1631             snprintf(buf, sizeof(buf), "?");
1632         }
1633         ret = func(opaque, bus_num, addr, buf, class_id, vendor_id,
1634                    product_id, product_name, speed);
1635     }
1636  the_end:
1637     if (f) {
1638         fclose(f);
1639     }
1640     return ret;
1641 }
1642
1643 /*
1644  * Read sys file-system device file
1645  *
1646  * @line address of buffer to put file contents in
1647  * @line_size size of line
1648  * @device_file path to device file (printf format string)
1649  * @device_name device being opened (inserted into device_file)
1650  *
1651  * @return 0 failed, 1 succeeded ('line' contains data)
1652  */
1653 static int usb_host_read_file(char *line, size_t line_size,
1654                               const char *device_file, const char *device_name)
1655 {
1656     FILE *f;
1657     int ret = 0;
1658     char filename[PATH_MAX];
1659
1660     snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1661              device_file);
1662     f = fopen(filename, "r");
1663     if (f) {
1664         ret = fgets(line, line_size, f) != NULL;
1665         fclose(f);
1666     }
1667
1668     return ret;
1669 }
1670
1671 /*
1672  * Use /sys/bus/usb/devices/ directory to determine host's USB
1673  * devices.
1674  *
1675  * This code is based on Robert Schiele's original patches posted to
1676  * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1677  */
1678 static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1679 {
1680     DIR *dir = NULL;
1681     char line[1024];
1682     int bus_num, addr, speed, class_id, product_id, vendor_id;
1683     int ret = 0;
1684     char port[MAX_PORTLEN];
1685     char product_name[512];
1686     struct dirent *de;
1687
1688     dir = opendir(USBSYSBUS_PATH "/devices");
1689     if (!dir) {
1690         perror("husb: cannot open devices directory");
1691         goto the_end;
1692     }
1693
1694     while ((de = readdir(dir))) {
1695         if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1696             if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1697                 continue;
1698             }
1699
1700             if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1701                 goto the_end;
1702             }
1703             if (sscanf(line, "%d", &addr) != 1) {
1704                 goto the_end;
1705             }
1706             if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1707                                     de->d_name)) {
1708                 goto the_end;
1709             }
1710             if (sscanf(line, "%x", &class_id) != 1) {
1711                 goto the_end;
1712             }
1713
1714             if (!usb_host_read_file(line, sizeof(line), "idVendor",
1715                                     de->d_name)) {
1716                 goto the_end;
1717             }
1718             if (sscanf(line, "%x", &vendor_id) != 1) {
1719                 goto the_end;
1720             }
1721             if (!usb_host_read_file(line, sizeof(line), "idProduct",
1722                                     de->d_name)) {
1723                 goto the_end;
1724             }
1725             if (sscanf(line, "%x", &product_id) != 1) {
1726                 goto the_end;
1727             }
1728             if (!usb_host_read_file(line, sizeof(line), "product",
1729                                     de->d_name)) {
1730                 *product_name = 0;
1731             } else {
1732                 if (strlen(line) > 0) {
1733                     line[strlen(line) - 1] = '\0';
1734                 }
1735                 pstrcpy(product_name, sizeof(product_name), line);
1736             }
1737
1738             if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1739                 goto the_end;
1740             }
1741             if (!strcmp(line, "5000\n")) {
1742                 speed = USB_SPEED_SUPER;
1743             } else if (!strcmp(line, "480\n")) {
1744                 speed = USB_SPEED_HIGH;
1745             } else if (!strcmp(line, "1.5\n")) {
1746                 speed = USB_SPEED_LOW;
1747             } else {
1748                 speed = USB_SPEED_FULL;
1749             }
1750
1751             ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1752                        product_id, product_name, speed);
1753             if (ret) {
1754                 goto the_end;
1755             }
1756         }
1757     }
1758  the_end:
1759     if (dir) {
1760         closedir(dir);
1761     }
1762     return ret;
1763 }
1764
1765 /*
1766  * Determine how to access the host's USB devices and call the
1767  * specific support function.
1768  */
1769 static int usb_host_scan(void *opaque, USBScanFunc *func)
1770 {
1771     Monitor *mon = cur_mon;
1772     FILE *f = NULL;
1773     DIR *dir = NULL;
1774     int ret = 0;
1775     const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1776     char devpath[PATH_MAX];
1777
1778     /* only check the host once */
1779     if (!usb_fs_type) {
1780         dir = opendir(USBSYSBUS_PATH "/devices");
1781         if (dir) {
1782             /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1783             strcpy(devpath, USBDEVBUS_PATH);
1784             usb_fs_type = USB_FS_SYS;
1785             closedir(dir);
1786             DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1787             goto found_devices;
1788         }
1789         f = fopen(USBPROCBUS_PATH "/devices", "r");
1790         if (f) {
1791             /* devices found in /proc/bus/usb/ */
1792             strcpy(devpath, USBPROCBUS_PATH);
1793             usb_fs_type = USB_FS_PROC;
1794             fclose(f);
1795             DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1796             goto found_devices;
1797         }
1798         /* try additional methods if an access method hasn't been found yet */
1799         f = fopen(USBDEVBUS_PATH "/devices", "r");
1800         if (f) {
1801             /* devices found in /dev/bus/usb/ */
1802             strcpy(devpath, USBDEVBUS_PATH);
1803             usb_fs_type = USB_FS_DEV;
1804             fclose(f);
1805             DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1806             goto found_devices;
1807         }
1808     found_devices:
1809         if (!usb_fs_type) {
1810             if (mon) {
1811                 monitor_printf(mon, "husb: unable to access USB devices\n");
1812             }
1813             return -ENOENT;
1814         }
1815
1816         /* the module setting (used later for opening devices) */
1817         usb_host_device_path = g_malloc0(strlen(devpath)+1);
1818         strcpy(usb_host_device_path, devpath);
1819         if (mon) {
1820             monitor_printf(mon, "husb: using %s file-system with %s\n",
1821                            fs_type[usb_fs_type], usb_host_device_path);
1822         }
1823     }
1824
1825     switch (usb_fs_type) {
1826     case USB_FS_PROC:
1827     case USB_FS_DEV:
1828         ret = usb_host_scan_dev(opaque, func);
1829         break;
1830     case USB_FS_SYS:
1831         ret = usb_host_scan_sys(opaque, func);
1832         break;
1833     default:
1834         ret = -EINVAL;
1835         break;
1836     }
1837     return ret;
1838 }
1839
1840 static QEMUTimer *usb_auto_timer;
1841
1842 static int usb_host_auto_scan(void *opaque, int bus_num,
1843                               int addr, const char *port,
1844                               int class_id, int vendor_id, int product_id,
1845                               const char *product_name, int speed)
1846 {
1847     struct USBAutoFilter *f;
1848     struct USBHostDevice *s;
1849
1850     /* Ignore hubs */
1851     if (class_id == 9)
1852         return 0;
1853
1854     QTAILQ_FOREACH(s, &hostdevs, next) {
1855         f = &s->match;
1856
1857         if (f->bus_num > 0 && f->bus_num != bus_num) {
1858             continue;
1859         }
1860         if (f->addr > 0 && f->addr != addr) {
1861             continue;
1862         }
1863         if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1864             continue;
1865         }
1866
1867         if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1868             continue;
1869         }
1870
1871         if (f->product_id > 0 && f->product_id != product_id) {
1872             continue;
1873         }
1874         /* We got a match */
1875         s->seen++;
1876         if (s->errcount >= 3) {
1877             return 0;
1878         }
1879
1880         /* Already attached ? */
1881         if (s->fd != -1) {
1882             return 0;
1883         }
1884         DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1885
1886         if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1887             s->errcount++;
1888         }
1889         break;
1890     }
1891
1892     return 0;
1893 }
1894
1895 static void usb_host_auto_check(void *unused)
1896 {
1897     struct USBHostDevice *s;
1898     int unconnected = 0;
1899
1900     usb_host_scan(NULL, usb_host_auto_scan);
1901
1902     QTAILQ_FOREACH(s, &hostdevs, next) {
1903         if (s->fd == -1) {
1904             unconnected++;
1905         }
1906         if (s->seen == 0) {
1907             s->errcount = 0;
1908         }
1909         s->seen = 0;
1910     }
1911
1912     if (unconnected == 0) {
1913         /* nothing to watch */
1914         if (usb_auto_timer) {
1915             qemu_del_timer(usb_auto_timer);
1916             trace_usb_host_auto_scan_disabled();
1917         }
1918         return;
1919     }
1920
1921     if (!usb_auto_timer) {
1922         usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1923         if (!usb_auto_timer) {
1924             return;
1925         }
1926         trace_usb_host_auto_scan_enabled();
1927     }
1928     qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1929 }
1930
1931 /*
1932  * Autoconnect filter
1933  * Format:
1934  *    auto:bus:dev[:vid:pid]
1935  *    auto:bus.dev[:vid:pid]
1936  *
1937  *    bus  - bus number    (dec, * means any)
1938  *    dev  - device number (dec, * means any)
1939  *    vid  - vendor id     (hex, * means any)
1940  *    pid  - product id    (hex, * means any)
1941  *
1942  *    See 'lsusb' output.
1943  */
1944 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1945 {
1946     enum { BUS, DEV, VID, PID, DONE };
1947     const char *p = spec;
1948     int i;
1949
1950     f->bus_num    = 0;
1951     f->addr       = 0;
1952     f->vendor_id  = 0;
1953     f->product_id = 0;
1954
1955     for (i = BUS; i < DONE; i++) {
1956         p = strpbrk(p, ":.");
1957         if (!p) {
1958             break;
1959         }
1960         p++;
1961
1962         if (*p == '*') {
1963             continue;
1964         }
1965         switch(i) {
1966         case BUS: f->bus_num = strtol(p, NULL, 10);    break;
1967         case DEV: f->addr    = strtol(p, NULL, 10);    break;
1968         case VID: f->vendor_id  = strtol(p, NULL, 16); break;
1969         case PID: f->product_id = strtol(p, NULL, 16); break;
1970         }
1971     }
1972
1973     if (i < DEV) {
1974         fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1975         return -1;
1976     }
1977
1978     return 0;
1979 }
1980
1981 /**********************/
1982 /* USB host device info */
1983
1984 struct usb_class_info {
1985     int class;
1986     const char *class_name;
1987 };
1988
1989 static const struct usb_class_info usb_class_info[] = {
1990     { USB_CLASS_AUDIO, "Audio"},
1991     { USB_CLASS_COMM, "Communication"},
1992     { USB_CLASS_HID, "HID"},
1993     { USB_CLASS_HUB, "Hub" },
1994     { USB_CLASS_PHYSICAL, "Physical" },
1995     { USB_CLASS_PRINTER, "Printer" },
1996     { USB_CLASS_MASS_STORAGE, "Storage" },
1997     { USB_CLASS_CDC_DATA, "Data" },
1998     { USB_CLASS_APP_SPEC, "Application Specific" },
1999     { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
2000     { USB_CLASS_STILL_IMAGE, "Still Image" },
2001     { USB_CLASS_CSCID, "Smart Card" },
2002     { USB_CLASS_CONTENT_SEC, "Content Security" },
2003     { -1, NULL }
2004 };
2005
2006 static const char *usb_class_str(uint8_t class)
2007 {
2008     const struct usb_class_info *p;
2009     for(p = usb_class_info; p->class != -1; p++) {
2010         if (p->class == class) {
2011             break;
2012         }
2013     }
2014     return p->class_name;
2015 }
2016
2017 static void usb_info_device(Monitor *mon, int bus_num,
2018                             int addr, const char *port,
2019                             int class_id, int vendor_id, int product_id,
2020                             const char *product_name,
2021                             int speed)
2022 {
2023     const char *class_str, *speed_str;
2024
2025     switch(speed) {
2026     case USB_SPEED_LOW:
2027         speed_str = "1.5";
2028         break;
2029     case USB_SPEED_FULL:
2030         speed_str = "12";
2031         break;
2032     case USB_SPEED_HIGH:
2033         speed_str = "480";
2034         break;
2035     case USB_SPEED_SUPER:
2036         speed_str = "5000";
2037         break;
2038     default:
2039         speed_str = "?";
2040         break;
2041     }
2042
2043     monitor_printf(mon, "  Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
2044                    bus_num, addr, port, speed_str);
2045     class_str = usb_class_str(class_id);
2046     if (class_str) {
2047         monitor_printf(mon, "    %s:", class_str);
2048     } else {
2049         monitor_printf(mon, "    Class %02x:", class_id);
2050     }
2051     monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
2052     if (product_name[0] != '\0') {
2053         monitor_printf(mon, ", %s", product_name);
2054     }
2055     monitor_printf(mon, "\n");
2056 }
2057
2058 static int usb_host_info_device(void *opaque, int bus_num, int addr,
2059                                 const char *path, int class_id,
2060                                 int vendor_id, int product_id,
2061                                 const char *product_name,
2062                                 int speed)
2063 {
2064     Monitor *mon = opaque;
2065
2066     usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
2067                     product_name, speed);
2068     return 0;
2069 }
2070
2071 static void dec2str(int val, char *str, size_t size)
2072 {
2073     if (val == 0) {
2074         snprintf(str, size, "*");
2075     } else {
2076         snprintf(str, size, "%d", val);
2077     }
2078 }
2079
2080 static void hex2str(int val, char *str, size_t size)
2081 {
2082     if (val == 0) {
2083         snprintf(str, size, "*");
2084     } else {
2085         snprintf(str, size, "%04x", val);
2086     }
2087 }
2088
2089 void usb_host_info(Monitor *mon)
2090 {
2091     struct USBAutoFilter *f;
2092     struct USBHostDevice *s;
2093
2094     usb_host_scan(mon, usb_host_info_device);
2095
2096     if (QTAILQ_EMPTY(&hostdevs)) {
2097         return;
2098     }
2099
2100     monitor_printf(mon, "  Auto filters:\n");
2101     QTAILQ_FOREACH(s, &hostdevs, next) {
2102         char bus[10], addr[10], vid[10], pid[10];
2103         f = &s->match;
2104         dec2str(f->bus_num, bus, sizeof(bus));
2105         dec2str(f->addr, addr, sizeof(addr));
2106         hex2str(f->vendor_id, vid, sizeof(vid));
2107         hex2str(f->product_id, pid, sizeof(pid));
2108         monitor_printf(mon, "    Bus %s, Addr %s, Port %s, ID %s:%s\n",
2109                        bus, addr, f->port ? f->port : "*", vid, pid);
2110     }
2111 }