← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to usb-linux.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

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