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