usb-linux.c

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