usb-linux.c

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