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