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