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