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