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