Statistics
| Branch: | Revision:

root / usb-linux.c @ eb5e680a

History | View | Annotate | Download (50.2 kB)

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
#include <signal.h>
41

    
42
#include <linux/usbdevice_fs.h>
43
#include <linux/version.h>
44
#include "hw/usb.h"
45

    
46
/* We redefine it to avoid version problems */
47
struct usb_ctrltransfer {
48
    uint8_t  bRequestType;
49
    uint8_t  bRequest;
50
    uint16_t wValue;
51
    uint16_t wIndex;
52
    uint16_t wLength;
53
    uint32_t timeout;
54
    void *data;
55
};
56

    
57
typedef int USBScanFunc(void *opaque, int bus_num, int addr, char *port,
58
                        int class_id, int vendor_id, int product_id,
59
                        const char *product_name, int speed);
60

    
61
//#define DEBUG
62

    
63
#ifdef DEBUG
64
#define DPRINTF printf
65
#else
66
#define DPRINTF(...)
67
#endif
68

    
69
#define USBDBG_DEVOPENED "husb: opened %s/devices\n"
70

    
71
#define USBPROCBUS_PATH "/proc/bus/usb"
72
#define PRODUCT_NAME_SZ 32
73
#define MAX_ENDPOINTS 15
74
#define MAX_PORTLEN 16
75
#define USBDEVBUS_PATH "/dev/bus/usb"
76
#define USBSYSBUS_PATH "/sys/bus/usb"
77

    
78
static char *usb_host_device_path;
79

    
80
#define USB_FS_NONE 0
81
#define USB_FS_PROC 1
82
#define USB_FS_DEV 2
83
#define USB_FS_SYS 3
84

    
85
static int usb_fs_type;
86

    
87
/* endpoint association data */
88
#define ISO_FRAME_DESC_PER_URB 32
89
#define ISO_URB_COUNT 3
90
#define INVALID_EP_TYPE 255
91

    
92
/* devio.c limits single requests to 16k */
93
#define MAX_USBFS_BUFFER_SIZE 16384
94

    
95
typedef struct AsyncURB AsyncURB;
96

    
97
struct endp_data {
98
    uint8_t type;
99
    uint8_t halted;
100
    uint8_t iso_started;
101
    AsyncURB *iso_urb;
102
    int iso_urb_idx;
103
    int iso_buffer_used;
104
    int max_packet_size;
105
};
106

    
107
struct USBAutoFilter {
108
    uint32_t bus_num;
109
    uint32_t addr;
110
    char     *port;
111
    uint32_t vendor_id;
112
    uint32_t product_id;
113
};
114

    
115
typedef struct USBHostDevice {
116
    USBDevice dev;
117
    int       fd;
118

    
119
    uint8_t   descr[1024];
120
    int       descr_len;
121
    int       configuration;
122
    int       ninterfaces;
123
    int       closing;
124
    Notifier  exit;
125

    
126
    struct endp_data endp_table[MAX_ENDPOINTS];
127
    QLIST_HEAD(, AsyncURB) aurbs;
128

    
129
    /* Host side address */
130
    int bus_num;
131
    int addr;
132
    char port[MAX_PORTLEN];
133
    struct USBAutoFilter match;
134

    
135
    QTAILQ_ENTRY(USBHostDevice) next;
136
} USBHostDevice;
137

    
138
static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
139

    
140
static int usb_host_close(USBHostDevice *dev);
141
static int parse_filter(const char *spec, struct USBAutoFilter *f);
142
static void usb_host_auto_check(void *unused);
143
static int usb_host_read_file(char *line, size_t line_size,
144
                            const char *device_file, const char *device_name);
145

    
146
static int is_isoc(USBHostDevice *s, int ep)
147
{
148
    return s->endp_table[ep - 1].type == USBDEVFS_URB_TYPE_ISO;
149
}
150

    
151
static int is_valid(USBHostDevice *s, int ep)
152
{
153
    return s->endp_table[ep - 1].type != INVALID_EP_TYPE;
154
}
155

    
156
static int is_halted(USBHostDevice *s, int ep)
157
{
158
    return s->endp_table[ep - 1].halted;
159
}
160

    
161
static void clear_halt(USBHostDevice *s, int ep)
162
{
163
    s->endp_table[ep - 1].halted = 0;
164
}
165

    
166
static void set_halt(USBHostDevice *s, int ep)
167
{
168
    s->endp_table[ep - 1].halted = 1;
169
}
170

    
171
static int is_iso_started(USBHostDevice *s, int ep)
172
{
173
    return s->endp_table[ep - 1].iso_started;
174
}
175

    
176
static void clear_iso_started(USBHostDevice *s, int ep)
177
{
178
    s->endp_table[ep - 1].iso_started = 0;
179
}
180

    
181
static void set_iso_started(USBHostDevice *s, int ep)
182
{
183
    s->endp_table[ep - 1].iso_started = 1;
184
}
185

    
186
static void set_iso_urb(USBHostDevice *s, int ep, AsyncURB *iso_urb)
187
{
188
    s->endp_table[ep - 1].iso_urb = iso_urb;
189
}
190

    
191
static AsyncURB *get_iso_urb(USBHostDevice *s, int ep)
192
{
193
    return s->endp_table[ep - 1].iso_urb;
194
}
195

    
196
static void set_iso_urb_idx(USBHostDevice *s, int ep, int i)
197
{
198
    s->endp_table[ep - 1].iso_urb_idx = i;
199
}
200

    
201
static int get_iso_urb_idx(USBHostDevice *s, int ep)
202
{
203
    return s->endp_table[ep - 1].iso_urb_idx;
204
}
205

    
206
static void set_iso_buffer_used(USBHostDevice *s, int ep, int i)
207
{
208
    s->endp_table[ep - 1].iso_buffer_used = i;
209
}
210

    
211
static int get_iso_buffer_used(USBHostDevice *s, int ep)
212
{
213
    return s->endp_table[ep - 1].iso_buffer_used;
214
}
215

    
216
static void set_max_packet_size(USBHostDevice *s, int ep, uint8_t *descriptor)
217
{
218
    int raw = descriptor[4] + (descriptor[5] << 8);
219
    int size, microframes;
220

    
221
    size = raw & 0x7ff;
222
    switch ((raw >> 11) & 3) {
223
    case 1:  microframes = 2; break;
224
    case 2:  microframes = 3; break;
225
    default: microframes = 1; break;
226
    }
227
    DPRINTF("husb: max packet size: 0x%x -> %d x %d\n",
228
            raw, microframes, size);
229
    s->endp_table[ep - 1].max_packet_size = size * microframes;
230
}
231

    
232
static int get_max_packet_size(USBHostDevice *s, int ep)
233
{
234
    return s->endp_table[ep - 1].max_packet_size;
235
}
236

    
237
/*
238
 * Async URB state.
239
 * We always allocate iso packet descriptors even for bulk transfers
240
 * to simplify allocation and casts.
241
 */
242
struct AsyncURB
243
{
244
    struct usbdevfs_urb urb;
245
    struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB];
246
    USBHostDevice *hdev;
247
    QLIST_ENTRY(AsyncURB) next;
248

    
249
    /* For regular async urbs */
250
    USBPacket     *packet;
251
    int more; /* large transfer, more urbs follow */
252

    
253
    /* For buffered iso handling */
254
    int iso_frame_idx; /* -1 means in flight */
255
};
256

    
257
static AsyncURB *async_alloc(USBHostDevice *s)
258
{
259
    AsyncURB *aurb = qemu_mallocz(sizeof(AsyncURB));
260
    aurb->hdev = s;
261
    QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
262
    return aurb;
263
}
264

    
265
static void async_free(AsyncURB *aurb)
266
{
267
    QLIST_REMOVE(aurb, next);
268
    qemu_free(aurb);
269
}
270

    
271
static void async_complete(void *opaque)
272
{
273
    USBHostDevice *s = opaque;
274
    AsyncURB *aurb;
275

    
276
    while (1) {
277
        USBPacket *p;
278

    
279
        int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
280
        if (r < 0) {
281
            if (errno == EAGAIN) {
282
                return;
283
            }
284
            if (errno == ENODEV && !s->closing) {
285
                printf("husb: device %d.%d disconnected\n",
286
                       s->bus_num, s->addr);
287
                usb_host_close(s);
288
                usb_host_auto_check(NULL);
289
                return;
290
            }
291

    
292
            DPRINTF("husb: async. reap urb failed errno %d\n", errno);
293
            return;
294
        }
295

    
296
        DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
297
                aurb, aurb->urb.status, aurb->urb.actual_length);
298

    
299
        /* If this is a buffered iso urb mark it as complete and don't do
300
           anything else (it is handled further in usb_host_handle_iso_data) */
301
        if (aurb->iso_frame_idx == -1) {
302
            if (aurb->urb.status == -EPIPE) {
303
                set_halt(s, aurb->urb.endpoint & 0xf);
304
            }
305
            aurb->iso_frame_idx = 0;
306
            continue;
307
        }
308

    
309
        p = aurb->packet;
310

    
311
        if (p) {
312
            switch (aurb->urb.status) {
313
            case 0:
314
                p->len += aurb->urb.actual_length;
315
                break;
316

    
317
            case -EPIPE:
318
                set_halt(s, p->devep);
319
                p->len = USB_RET_STALL;
320
                break;
321

    
322
            default:
323
                p->len = USB_RET_NAK;
324
                break;
325
            }
326

    
327
            if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
328
                usb_generic_async_ctrl_complete(&s->dev, p);
329
            } else if (!aurb->more) {
330
                usb_packet_complete(&s->dev, p);
331
            }
332
        }
333

    
334
        async_free(aurb);
335
    }
336
}
337

    
338
static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
339
{
340
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
341
    AsyncURB *aurb;
342

    
343
    QLIST_FOREACH(aurb, &s->aurbs, next) {
344
        if (p != aurb->packet) {
345
            continue;
346
        }
347

    
348
        DPRINTF("husb: async cancel: packet %p, aurb %p\n", p, aurb);
349

    
350
        /* Mark it as dead (see async_complete above) */
351
        aurb->packet = NULL;
352

    
353
        int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
354
        if (r < 0) {
355
            DPRINTF("husb: async. discard urb failed errno %d\n", errno);
356
        }
357
    }
358
}
359

    
360
static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
361
{
362
    int dev_descr_len, config_descr_len;
363
    int interface, nb_interfaces;
364
    int ret, i;
365

    
366
    if (configuration == 0) /* address state - ignore */
367
        return 1;
368

    
369
    DPRINTF("husb: claiming interfaces. config %d\n", configuration);
370

    
371
    i = 0;
372
    dev_descr_len = dev->descr[0];
373
    if (dev_descr_len > dev->descr_len) {
374
        goto fail;
375
    }
376

    
377
    i += dev_descr_len;
378
    while (i < dev->descr_len) {
379
        DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
380
                i, dev->descr_len,
381
               dev->descr[i], dev->descr[i+1]);
382

    
383
        if (dev->descr[i+1] != USB_DT_CONFIG) {
384
            i += dev->descr[i];
385
            continue;
386
        }
387
        config_descr_len = dev->descr[i];
388

    
389
        printf("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
390

    
391
        if (configuration < 0 || configuration == dev->descr[i + 5]) {
392
            configuration = dev->descr[i + 5];
393
            break;
394
        }
395

    
396
        i += config_descr_len;
397
    }
398

    
399
    if (i >= dev->descr_len) {
400
        fprintf(stderr,
401
                "husb: update iface failed. no matching configuration\n");
402
        goto fail;
403
    }
404
    nb_interfaces = dev->descr[i + 4];
405

    
406
#ifdef USBDEVFS_DISCONNECT
407
    /* earlier Linux 2.4 do not support that */
408
    {
409
        struct usbdevfs_ioctl ctrl;
410
        for (interface = 0; interface < nb_interfaces; interface++) {
411
            ctrl.ioctl_code = USBDEVFS_DISCONNECT;
412
            ctrl.ifno = interface;
413
            ctrl.data = 0;
414
            ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
415
            if (ret < 0 && errno != ENODATA) {
416
                perror("USBDEVFS_DISCONNECT");
417
                goto fail;
418
            }
419
        }
420
    }
421
#endif
422

    
423
    /* XXX: only grab if all interfaces are free */
424
    for (interface = 0; interface < nb_interfaces; interface++) {
425
        ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
426
        if (ret < 0) {
427
            if (errno == EBUSY) {
428
                printf("husb: update iface. device already grabbed\n");
429
            } else {
430
                perror("husb: failed to claim interface");
431
            }
432
        fail:
433
            return 0;
434
        }
435
    }
436

    
437
    printf("husb: %d interfaces claimed for configuration %d\n",
438
           nb_interfaces, configuration);
439

    
440
    dev->ninterfaces   = nb_interfaces;
441
    dev->configuration = configuration;
442
    return 1;
443
}
444

    
445
static int usb_host_release_interfaces(USBHostDevice *s)
446
{
447
    int ret, i;
448

    
449
    DPRINTF("husb: releasing interfaces\n");
450

    
451
    for (i = 0; i < s->ninterfaces; i++) {
452
        ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
453
        if (ret < 0) {
454
            perror("husb: failed to release interface");
455
            return 0;
456
        }
457
    }
458

    
459
    return 1;
460
}
461

    
462
static void usb_host_handle_reset(USBDevice *dev)
463
{
464
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
465

    
466
    DPRINTF("husb: reset device %u.%u\n", s->bus_num, s->addr);
467

    
468
    ioctl(s->fd, USBDEVFS_RESET);
469

    
470
    usb_host_claim_interfaces(s, s->configuration);
471
}
472

    
473
static void usb_host_handle_destroy(USBDevice *dev)
474
{
475
    USBHostDevice *s = (USBHostDevice *)dev;
476

    
477
    usb_host_close(s);
478
    QTAILQ_REMOVE(&hostdevs, s, next);
479
    qemu_remove_exit_notifier(&s->exit);
480
}
481

    
482
static int usb_linux_update_endp_table(USBHostDevice *s);
483

    
484
/* iso data is special, we need to keep enough urbs in flight to make sure
485
   that the controller never runs out of them, otherwise the device will
486
   likely suffer a buffer underrun / overrun. */
487
static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, uint8_t ep, int in)
488
{
489
    AsyncURB *aurb;
490
    int i, j, len = get_max_packet_size(s, ep);
491

    
492
    aurb = qemu_mallocz(ISO_URB_COUNT * sizeof(*aurb));
493
    for (i = 0; i < ISO_URB_COUNT; i++) {
494
        aurb[i].urb.endpoint      = ep;
495
        aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
496
        aurb[i].urb.buffer        = qemu_malloc(aurb[i].urb.buffer_length);
497
        aurb[i].urb.type          = USBDEVFS_URB_TYPE_ISO;
498
        aurb[i].urb.flags         = USBDEVFS_URB_ISO_ASAP;
499
        aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
500
        for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
501
            aurb[i].urb.iso_frame_desc[j].length = len;
502
        if (in) {
503
            aurb[i].urb.endpoint |= 0x80;
504
            /* Mark as fully consumed (idle) */
505
            aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
506
        }
507
    }
508
    set_iso_urb(s, ep, aurb);
509

    
510
    return aurb;
511
}
512

    
513
static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep)
514
{
515
    AsyncURB *aurb;
516
    int i, ret, killed = 0, free = 1;
517

    
518
    aurb = get_iso_urb(s, ep);
519
    if (!aurb) {
520
        return;
521
    }
522

    
523
    for (i = 0; i < ISO_URB_COUNT; i++) {
524
        /* in flight? */
525
        if (aurb[i].iso_frame_idx == -1) {
526
            ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
527
            if (ret < 0) {
528
                printf("husb: discard isoc in urb failed errno %d\n", errno);
529
                free = 0;
530
                continue;
531
            }
532
            killed++;
533
        }
534
    }
535

    
536
    /* Make sure any urbs we've killed are reaped before we free them */
537
    if (killed) {
538
        async_complete(s);
539
    }
540

    
541
    for (i = 0; i < ISO_URB_COUNT; i++) {
542
        qemu_free(aurb[i].urb.buffer);
543
    }
544

    
545
    if (free)
546
        qemu_free(aurb);
547
    else
548
        printf("husb: leaking iso urbs because of discard failure\n");
549
    set_iso_urb(s, ep, NULL);
550
    set_iso_urb_idx(s, ep, 0);
551
    clear_iso_started(s, ep);
552
}
553

    
554
static int urb_status_to_usb_ret(int status)
555
{
556
    switch (status) {
557
    case -EPIPE:
558
        return USB_RET_STALL;
559
    default:
560
        return USB_RET_NAK;
561
    }
562
}
563

    
564
static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
565
{
566
    AsyncURB *aurb;
567
    int i, j, ret, max_packet_size, offset, len = 0;
568

    
569
    max_packet_size = get_max_packet_size(s, p->devep);
570
    if (max_packet_size == 0)
571
        return USB_RET_NAK;
572

    
573
    aurb = get_iso_urb(s, p->devep);
574
    if (!aurb) {
575
        aurb = usb_host_alloc_iso(s, p->devep, in);
576
    }
577

    
578
    i = get_iso_urb_idx(s, p->devep);
579
    j = aurb[i].iso_frame_idx;
580
    if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
581
        if (in) {
582
            /* Check urb status  */
583
            if (aurb[i].urb.status) {
584
                len = urb_status_to_usb_ret(aurb[i].urb.status);
585
                /* Move to the next urb */
586
                aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
587
            /* Check frame status */
588
            } else if (aurb[i].urb.iso_frame_desc[j].status) {
589
                len = urb_status_to_usb_ret(
590
                                        aurb[i].urb.iso_frame_desc[j].status);
591
            /* Check the frame fits */
592
            } else if (aurb[i].urb.iso_frame_desc[j].actual_length > p->len) {
593
                printf("husb: received iso data is larger then packet\n");
594
                len = USB_RET_NAK;
595
            /* All good copy data over */
596
            } else {
597
                len = aurb[i].urb.iso_frame_desc[j].actual_length;
598
                memcpy(p->data,
599
                       aurb[i].urb.buffer +
600
                           j * aurb[i].urb.iso_frame_desc[0].length,
601
                       len);
602
            }
603
        } else {
604
            len = p->len;
605
            offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->devep);
606

    
607
            /* Check the frame fits */
608
            if (len > max_packet_size) {
609
                printf("husb: send iso data is larger then max packet size\n");
610
                return USB_RET_NAK;
611
            }
612

    
613
            /* All good copy data over */
614
            memcpy(aurb[i].urb.buffer + offset, p->data, len);
615
            aurb[i].urb.iso_frame_desc[j].length = len;
616
            offset += len;
617
            set_iso_buffer_used(s, p->devep, offset);
618

    
619
            /* Start the stream once we have buffered enough data */
620
            if (!is_iso_started(s, p->devep) && i == 1 && j == 8) {
621
                set_iso_started(s, p->devep);
622
            }
623
        }
624
        aurb[i].iso_frame_idx++;
625
        if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
626
            i = (i + 1) % ISO_URB_COUNT;
627
            set_iso_urb_idx(s, p->devep, i);
628
        }
629
    } else {
630
        if (in) {
631
            set_iso_started(s, p->devep);
632
        } else {
633
            DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
634
        }
635
    }
636

    
637
    if (is_iso_started(s, p->devep)) {
638
        /* (Re)-submit all fully consumed / filled urbs */
639
        for (i = 0; i < ISO_URB_COUNT; i++) {
640
            if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
641
                ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
642
                if (ret < 0) {
643
                    printf("husb error submitting iso urb %d: %d\n", i, errno);
644
                    if (!in || len == 0) {
645
                        switch(errno) {
646
                        case ETIMEDOUT:
647
                            len = USB_RET_NAK;
648
                            break;
649
                        case EPIPE:
650
                        default:
651
                            len = USB_RET_STALL;
652
                        }
653
                    }
654
                    break;
655
                }
656
                aurb[i].iso_frame_idx = -1;
657
            }
658
        }
659
    }
660

    
661
    return len;
662
}
663

    
664
static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
665
{
666
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
667
    struct usbdevfs_urb *urb;
668
    AsyncURB *aurb;
669
    int ret, rem;
670
    uint8_t *pbuf;
671
    uint8_t ep;
672

    
673
    if (!is_valid(s, p->devep)) {
674
        return USB_RET_NAK;
675
    }
676

    
677
    if (p->pid == USB_TOKEN_IN) {
678
        ep = p->devep | 0x80;
679
    } else {
680
        ep = p->devep;
681
    }
682

    
683
    if (is_halted(s, p->devep)) {
684
        ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &ep);
685
        if (ret < 0) {
686
            DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",
687
                   ep, errno);
688
            return USB_RET_NAK;
689
        }
690
        clear_halt(s, p->devep);
691
    }
692

    
693
    if (is_isoc(s, p->devep)) {
694
        return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
695
    }
696

    
697
    rem = p->len;
698
    pbuf = p->data;
699
    p->len = 0;
700
    while (rem) {
701
        aurb = async_alloc(s);
702
        aurb->packet = p;
703

    
704
        urb = &aurb->urb;
705
        urb->endpoint      = ep;
706
        urb->type          = USBDEVFS_URB_TYPE_BULK;
707
        urb->usercontext   = s;
708
        urb->buffer        = pbuf;
709

    
710
        if (rem > MAX_USBFS_BUFFER_SIZE) {
711
            urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
712
            aurb->more         = 1;
713
        } else {
714
            urb->buffer_length = rem;
715
            aurb->more         = 0;
716
        }
717
        pbuf += urb->buffer_length;
718
        rem  -= urb->buffer_length;
719

    
720
        ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
721

    
722
        DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
723
                urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
724

    
725
        if (ret < 0) {
726
            DPRINTF("husb: submit failed. errno %d\n", errno);
727
            async_free(aurb);
728

    
729
            switch(errno) {
730
            case ETIMEDOUT:
731
                return USB_RET_NAK;
732
            case EPIPE:
733
            default:
734
                return USB_RET_STALL;
735
            }
736
        }
737
    }
738

    
739
    return USB_RET_ASYNC;
740
}
741

    
742
static int ctrl_error(void)
743
{
744
    if (errno == ETIMEDOUT) {
745
        return USB_RET_NAK;
746
    } else {
747
        return USB_RET_STALL;
748
    }
749
}
750

    
751
static int usb_host_set_address(USBHostDevice *s, int addr)
752
{
753
    DPRINTF("husb: ctrl set addr %u\n", addr);
754
    s->dev.addr = addr;
755
    return 0;
756
}
757

    
758
static int usb_host_set_config(USBHostDevice *s, int config)
759
{
760
    usb_host_release_interfaces(s);
761

    
762
    int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
763

    
764
    DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
765

    
766
    if (ret < 0) {
767
        return ctrl_error();
768
    }
769
    usb_host_claim_interfaces(s, config);
770
    return 0;
771
}
772

    
773
static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
774
{
775
    struct usbdevfs_setinterface si;
776
    int i, ret;
777

    
778
    for (i = 1; i <= MAX_ENDPOINTS; i++) {
779
        if (is_isoc(s, i)) {
780
            usb_host_stop_n_free_iso(s, i);
781
        }
782
    }
783

    
784
    si.interface  = iface;
785
    si.altsetting = alt;
786
    ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
787

    
788
    DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
789
            iface, alt, ret, errno);
790

    
791
    if (ret < 0) {
792
        return ctrl_error();
793
    }
794
    usb_linux_update_endp_table(s);
795
    return 0;
796
}
797

    
798
static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
799
               int request, int value, int index, int length, uint8_t *data)
800
{
801
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
802
    struct usbdevfs_urb *urb;
803
    AsyncURB *aurb;
804
    int ret;
805

    
806
    /*
807
     * Process certain standard device requests.
808
     * These are infrequent and are processed synchronously.
809
     */
810

    
811
    /* Note request is (bRequestType << 8) | bRequest */
812
    DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",
813
            request >> 8, request & 0xff, value, index, length);
814

    
815
    switch (request) {
816
    case DeviceOutRequest | USB_REQ_SET_ADDRESS:
817
        return usb_host_set_address(s, value);
818

    
819
    case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
820
        return usb_host_set_config(s, value & 0xff);
821

    
822
    case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
823
        return usb_host_set_interface(s, index, value);
824
    }
825

    
826
    /* The rest are asynchronous */
827

    
828
    if (length > sizeof(dev->data_buf)) {
829
        fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
830
                length, sizeof(dev->data_buf));
831
        return USB_RET_STALL;
832
    }
833

    
834
    aurb = async_alloc(s);
835
    aurb->packet = p;
836

    
837
    /*
838
     * Setup ctrl transfer.
839
     *
840
     * s->ctrl is laid out such that data buffer immediately follows
841
     * 'req' struct which is exactly what usbdevfs expects.
842
     */
843
    urb = &aurb->urb;
844

    
845
    urb->type     = USBDEVFS_URB_TYPE_CONTROL;
846
    urb->endpoint = p->devep;
847

    
848
    urb->buffer        = &dev->setup_buf;
849
    urb->buffer_length = length + 8;
850

    
851
    urb->usercontext = s;
852

    
853
    ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
854

    
855
    DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
856

    
857
    if (ret < 0) {
858
        DPRINTF("husb: submit failed. errno %d\n", errno);
859
        async_free(aurb);
860

    
861
        switch(errno) {
862
        case ETIMEDOUT:
863
            return USB_RET_NAK;
864
        case EPIPE:
865
        default:
866
            return USB_RET_STALL;
867
        }
868
    }
869

    
870
    return USB_RET_ASYNC;
871
}
872

    
873
static int usb_linux_get_configuration(USBHostDevice *s)
874
{
875
    uint8_t configuration;
876
    struct usb_ctrltransfer ct;
877
    int ret;
878

    
879
    if (usb_fs_type == USB_FS_SYS) {
880
        char device_name[32], line[1024];
881
        int configuration;
882

    
883
        sprintf(device_name, "%d-%s", s->bus_num, s->port);
884

    
885
        if (!usb_host_read_file(line, sizeof(line), "bConfigurationValue",
886
                                device_name)) {
887
            goto usbdevfs;
888
        }
889
        if (sscanf(line, "%d", &configuration) != 1) {
890
            goto usbdevfs;
891
        }
892
        return configuration;
893
    }
894

    
895
usbdevfs:
896
    ct.bRequestType = USB_DIR_IN;
897
    ct.bRequest = USB_REQ_GET_CONFIGURATION;
898
    ct.wValue = 0;
899
    ct.wIndex = 0;
900
    ct.wLength = 1;
901
    ct.data = &configuration;
902
    ct.timeout = 50;
903

    
904
    ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
905
    if (ret < 0) {
906
        perror("usb_linux_get_configuration");
907
        return -1;
908
    }
909

    
910
    /* in address state */
911
    if (configuration == 0) {
912
        return -1;
913
    }
914

    
915
    return configuration;
916
}
917

    
918
static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
919
    uint8_t configuration, uint8_t interface)
920
{
921
    uint8_t alt_setting;
922
    struct usb_ctrltransfer ct;
923
    int ret;
924

    
925
    if (usb_fs_type == USB_FS_SYS) {
926
        char device_name[64], line[1024];
927
        int alt_setting;
928

    
929
        sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
930
                (int)configuration, (int)interface);
931

    
932
        if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
933
                                device_name)) {
934
            goto usbdevfs;
935
        }
936
        if (sscanf(line, "%d", &alt_setting) != 1) {
937
            goto usbdevfs;
938
        }
939
        return alt_setting;
940
    }
941

    
942
usbdevfs:
943
    ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
944
    ct.bRequest = USB_REQ_GET_INTERFACE;
945
    ct.wValue = 0;
946
    ct.wIndex = interface;
947
    ct.wLength = 1;
948
    ct.data = &alt_setting;
949
    ct.timeout = 50;
950
    ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
951
    if (ret < 0) {
952
        /* Assume alt 0 on error */
953
        return 0;
954
    }
955

    
956
    return alt_setting;
957
}
958

    
959
/* returns 1 on problem encountered or 0 for success */
960
static int usb_linux_update_endp_table(USBHostDevice *s)
961
{
962
    uint8_t *descriptors;
963
    uint8_t devep, type, configuration, alt_interface;
964
    int interface, length, i;
965

    
966
    for (i = 0; i < MAX_ENDPOINTS; i++)
967
        s->endp_table[i].type = INVALID_EP_TYPE;
968

    
969
    i = usb_linux_get_configuration(s);
970
    if (i < 0)
971
        return 1;
972
    configuration = i;
973

    
974
    /* get the desired configuration, interface, and endpoint descriptors
975
     * from device description */
976
    descriptors = &s->descr[18];
977
    length = s->descr_len - 18;
978
    i = 0;
979

    
980
    if (descriptors[i + 1] != USB_DT_CONFIG ||
981
        descriptors[i + 5] != configuration) {
982
        DPRINTF("invalid descriptor data - configuration\n");
983
        return 1;
984
    }
985
    i += descriptors[i];
986

    
987
    while (i < length) {
988
        if (descriptors[i + 1] != USB_DT_INTERFACE ||
989
            (descriptors[i + 1] == USB_DT_INTERFACE &&
990
             descriptors[i + 4] == 0)) {
991
            i += descriptors[i];
992
            continue;
993
        }
994

    
995
        interface = descriptors[i + 2];
996
        alt_interface = usb_linux_get_alt_setting(s, configuration, interface);
997

    
998
        /* the current interface descriptor is the active interface
999
         * and has endpoints */
1000
        if (descriptors[i + 3] != alt_interface) {
1001
            i += descriptors[i];
1002
            continue;
1003
        }
1004

    
1005
        /* advance to the endpoints */
1006
        while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1007
            i += descriptors[i];
1008
        }
1009

    
1010
        if (i >= length)
1011
            break;
1012

    
1013
        while (i < length) {
1014
            if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1015
                break;
1016
            }
1017

    
1018
            devep = descriptors[i + 2];
1019
            switch (descriptors[i + 3] & 0x3) {
1020
            case 0x00:
1021
                type = USBDEVFS_URB_TYPE_CONTROL;
1022
                break;
1023
            case 0x01:
1024
                type = USBDEVFS_URB_TYPE_ISO;
1025
                set_max_packet_size(s, (devep & 0xf), descriptors + i);
1026
                break;
1027
            case 0x02:
1028
                type = USBDEVFS_URB_TYPE_BULK;
1029
                break;
1030
            case 0x03:
1031
                type = USBDEVFS_URB_TYPE_INTERRUPT;
1032
                break;
1033
            default:
1034
                DPRINTF("usb_host: malformed endpoint type\n");
1035
                type = USBDEVFS_URB_TYPE_BULK;
1036
            }
1037
            s->endp_table[(devep & 0xf) - 1].type = type;
1038
            s->endp_table[(devep & 0xf) - 1].halted = 0;
1039

    
1040
            i += descriptors[i];
1041
        }
1042
    }
1043
    return 0;
1044
}
1045

    
1046
static int usb_host_open(USBHostDevice *dev, int bus_num,
1047
                         int addr, char *port, const char *prod_name)
1048
{
1049
    int fd = -1, ret;
1050
    struct usbdevfs_connectinfo ci;
1051
    char buf[1024];
1052

    
1053
    if (dev->fd != -1) {
1054
        goto fail;
1055
    }
1056
    printf("husb: open device %d.%d\n", bus_num, addr);
1057

    
1058
    if (!usb_host_device_path) {
1059
        perror("husb: USB Host Device Path not set");
1060
        goto fail;
1061
    }
1062
    snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1063
             bus_num, addr);
1064
    fd = open(buf, O_RDWR | O_NONBLOCK);
1065
    if (fd < 0) {
1066
        perror(buf);
1067
        goto fail;
1068
    }
1069
    DPRINTF("husb: opened %s\n", buf);
1070

    
1071
    dev->bus_num = bus_num;
1072
    dev->addr = addr;
1073
    strcpy(dev->port, port);
1074
    dev->fd = fd;
1075

    
1076
    /* read the device description */
1077
    dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1078
    if (dev->descr_len <= 0) {
1079
        perror("husb: reading device data failed");
1080
        goto fail;
1081
    }
1082

    
1083
#ifdef DEBUG
1084
    {
1085
        int x;
1086
        printf("=== begin dumping device descriptor data ===\n");
1087
        for (x = 0; x < dev->descr_len; x++) {
1088
            printf("%02x ", dev->descr[x]);
1089
        }
1090
        printf("\n=== end dumping device descriptor data ===\n");
1091
    }
1092
#endif
1093

    
1094

    
1095
    /*
1096
     * Initial configuration is -1 which makes us claim first
1097
     * available config. We used to start with 1, which does not
1098
     * always work. I've seen devices where first config starts
1099
     * with 2.
1100
     */
1101
    if (!usb_host_claim_interfaces(dev, -1)) {
1102
        goto fail;
1103
    }
1104

    
1105
    ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1106
    if (ret < 0) {
1107
        perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1108
        goto fail;
1109
    }
1110

    
1111
    printf("husb: grabbed usb device %d.%d\n", bus_num, addr);
1112

    
1113
    ret = usb_linux_update_endp_table(dev);
1114
    if (ret) {
1115
        goto fail;
1116
    }
1117

    
1118
    if (ci.slow) {
1119
        dev->dev.speed = USB_SPEED_LOW;
1120
    } else {
1121
        dev->dev.speed = USB_SPEED_HIGH;
1122
    }
1123

    
1124
    if (!prod_name || prod_name[0] == '\0') {
1125
        snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1126
                 "host:%d.%d", bus_num, addr);
1127
    } else {
1128
        pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1129
                prod_name);
1130
    }
1131

    
1132
    /* USB devio uses 'write' flag to check for async completions */
1133
    qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1134

    
1135
    usb_device_attach(&dev->dev);
1136
    return 0;
1137

    
1138
fail:
1139
    dev->fd = -1;
1140
    if (fd != -1) {
1141
        close(fd);
1142
    }
1143
    return -1;
1144
}
1145

    
1146
static int usb_host_close(USBHostDevice *dev)
1147
{
1148
    int i;
1149

    
1150
    if (dev->fd == -1) {
1151
        return -1;
1152
    }
1153

    
1154
    qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1155
    dev->closing = 1;
1156
    for (i = 1; i <= MAX_ENDPOINTS; i++) {
1157
        if (is_isoc(dev, i)) {
1158
            usb_host_stop_n_free_iso(dev, i);
1159
        }
1160
    }
1161
    async_complete(dev);
1162
    dev->closing = 0;
1163
    usb_device_detach(&dev->dev);
1164
    ioctl(dev->fd, USBDEVFS_RESET);
1165
    close(dev->fd);
1166
    dev->fd = -1;
1167
    return 0;
1168
}
1169

    
1170
static void usb_host_exit_notifier(struct Notifier* n)
1171
{
1172
    USBHostDevice *s = container_of(n, USBHostDevice, exit);
1173

    
1174
    if (s->fd != -1) {
1175
        ioctl(s->fd, USBDEVFS_RESET);
1176
    }
1177
}
1178

    
1179
static int usb_host_initfn(USBDevice *dev)
1180
{
1181
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1182

    
1183
    dev->auto_attach = 0;
1184
    s->fd = -1;
1185
    QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1186
    s->exit.notify = usb_host_exit_notifier;
1187
    qemu_add_exit_notifier(&s->exit);
1188
    usb_host_auto_check(NULL);
1189
    return 0;
1190
}
1191

    
1192
static struct USBDeviceInfo usb_host_dev_info = {
1193
    .product_desc   = "USB Host Device",
1194
    .qdev.name      = "usb-host",
1195
    .qdev.size      = sizeof(USBHostDevice),
1196
    .init           = usb_host_initfn,
1197
    .handle_packet  = usb_generic_handle_packet,
1198
    .cancel_packet  = usb_host_async_cancel,
1199
    .handle_data    = usb_host_handle_data,
1200
    .handle_control = usb_host_handle_control,
1201
    .handle_reset   = usb_host_handle_reset,
1202
    .handle_destroy = usb_host_handle_destroy,
1203
    .usbdevice_name = "host",
1204
    .usbdevice_init = usb_host_device_open,
1205
    .qdev.props     = (Property[]) {
1206
        DEFINE_PROP_UINT32("hostbus",  USBHostDevice, match.bus_num,    0),
1207
        DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr,       0),
1208
        DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1209
        DEFINE_PROP_HEX32("vendorid",  USBHostDevice, match.vendor_id,  0),
1210
        DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1211
        DEFINE_PROP_END_OF_LIST(),
1212
    },
1213
};
1214

    
1215
static void usb_host_register_devices(void)
1216
{
1217
    usb_qdev_register(&usb_host_dev_info);
1218
}
1219
device_init(usb_host_register_devices)
1220

    
1221
USBDevice *usb_host_device_open(const char *devname)
1222
{
1223
    struct USBAutoFilter filter;
1224
    USBDevice *dev;
1225
    char *p;
1226

    
1227
    dev = usb_create(NULL /* FIXME */, "usb-host");
1228

    
1229
    if (strstr(devname, "auto:")) {
1230
        if (parse_filter(devname, &filter) < 0) {
1231
            goto fail;
1232
        }
1233
    } else {
1234
        if ((p = strchr(devname, '.'))) {
1235
            filter.bus_num    = strtoul(devname, NULL, 0);
1236
            filter.addr       = strtoul(p + 1, NULL, 0);
1237
            filter.vendor_id  = 0;
1238
            filter.product_id = 0;
1239
        } else if ((p = strchr(devname, ':'))) {
1240
            filter.bus_num    = 0;
1241
            filter.addr       = 0;
1242
            filter.vendor_id  = strtoul(devname, NULL, 16);
1243
            filter.product_id = strtoul(p + 1, NULL, 16);
1244
        } else {
1245
            goto fail;
1246
        }
1247
    }
1248

    
1249
    qdev_prop_set_uint32(&dev->qdev, "hostbus",   filter.bus_num);
1250
    qdev_prop_set_uint32(&dev->qdev, "hostaddr",  filter.addr);
1251
    qdev_prop_set_uint32(&dev->qdev, "vendorid",  filter.vendor_id);
1252
    qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1253
    qdev_init_nofail(&dev->qdev);
1254
    return dev;
1255

    
1256
fail:
1257
    qdev_free(&dev->qdev);
1258
    return NULL;
1259
}
1260

    
1261
int usb_host_device_close(const char *devname)
1262
{
1263
#if 0
1264
    char product_name[PRODUCT_NAME_SZ];
1265
    int bus_num, addr;
1266
    USBHostDevice *s;
1267

1268
    if (strstr(devname, "auto:")) {
1269
        return usb_host_auto_del(devname);
1270
    }
1271
    if (usb_host_find_device(&bus_num, &addr, product_name,
1272
                                    sizeof(product_name), devname) < 0) {
1273
        return -1;
1274
    }
1275
    s = hostdev_find(bus_num, addr);
1276
    if (s) {
1277
        usb_device_delete_addr(s->bus_num, s->dev.addr);
1278
        return 0;
1279
    }
1280
#endif
1281

    
1282
    return -1;
1283
}
1284

    
1285
static int get_tag_value(char *buf, int buf_size,
1286
                         const char *str, const char *tag,
1287
                         const char *stopchars)
1288
{
1289
    const char *p;
1290
    char *q;
1291
    p = strstr(str, tag);
1292
    if (!p) {
1293
        return -1;
1294
    }
1295
    p += strlen(tag);
1296
    while (qemu_isspace(*p)) {
1297
        p++;
1298
    }
1299
    q = buf;
1300
    while (*p != '\0' && !strchr(stopchars, *p)) {
1301
        if ((q - buf) < (buf_size - 1)) {
1302
            *q++ = *p;
1303
        }
1304
        p++;
1305
    }
1306
    *q = '\0';
1307
    return q - buf;
1308
}
1309

    
1310
/*
1311
 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1312
 * host's USB devices. This is legacy support since many distributions
1313
 * are moving to /sys/bus/usb
1314
 */
1315
static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1316
{
1317
    FILE *f = NULL;
1318
    char line[1024];
1319
    char buf[1024];
1320
    int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
1321
    char product_name[512];
1322
    int ret = 0;
1323

    
1324
    if (!usb_host_device_path) {
1325
        perror("husb: USB Host Device Path not set");
1326
        goto the_end;
1327
    }
1328
    snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1329
    f = fopen(line, "r");
1330
    if (!f) {
1331
        perror("husb: cannot open devices file");
1332
        goto the_end;
1333
    }
1334

    
1335
    device_count = 0;
1336
    bus_num = addr = speed = class_id = product_id = vendor_id = 0;
1337
    for(;;) {
1338
        if (fgets(line, sizeof(line), f) == NULL) {
1339
            break;
1340
        }
1341
        if (strlen(line) > 0) {
1342
            line[strlen(line) - 1] = '\0';
1343
        }
1344
        if (line[0] == 'T' && line[1] == ':') {
1345
            if (device_count && (vendor_id || product_id)) {
1346
                /* New device.  Add the previously discovered device.  */
1347
                ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1348
                           product_id, product_name, speed);
1349
                if (ret) {
1350
                    goto the_end;
1351
                }
1352
            }
1353
            if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1354
                goto fail;
1355
            }
1356
            bus_num = atoi(buf);
1357
            if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1358
                goto fail;
1359
            }
1360
            addr = atoi(buf);
1361
            if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1362
                goto fail;
1363
            }
1364
            if (!strcmp(buf, "480")) {
1365
                speed = USB_SPEED_HIGH;
1366
            } else if (!strcmp(buf, "1.5")) {
1367
                speed = USB_SPEED_LOW;
1368
            } else {
1369
                speed = USB_SPEED_FULL;
1370
            }
1371
            product_name[0] = '\0';
1372
            class_id = 0xff;
1373
            device_count++;
1374
            product_id = 0;
1375
            vendor_id = 0;
1376
        } else if (line[0] == 'P' && line[1] == ':') {
1377
            if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1378
                goto fail;
1379
            }
1380
            vendor_id = strtoul(buf, NULL, 16);
1381
            if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1382
                goto fail;
1383
            }
1384
            product_id = strtoul(buf, NULL, 16);
1385
        } else if (line[0] == 'S' && line[1] == ':') {
1386
            if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1387
                goto fail;
1388
            }
1389
            pstrcpy(product_name, sizeof(product_name), buf);
1390
        } else if (line[0] == 'D' && line[1] == ':') {
1391
            if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1392
                goto fail;
1393
            }
1394
            class_id = strtoul(buf, NULL, 16);
1395
        }
1396
    fail: ;
1397
    }
1398
    if (device_count && (vendor_id || product_id)) {
1399
        /* Add the last device.  */
1400
        ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1401
                   product_id, product_name, speed);
1402
    }
1403
 the_end:
1404
    if (f) {
1405
        fclose(f);
1406
    }
1407
    return ret;
1408
}
1409

    
1410
/*
1411
 * Read sys file-system device file
1412
 *
1413
 * @line address of buffer to put file contents in
1414
 * @line_size size of line
1415
 * @device_file path to device file (printf format string)
1416
 * @device_name device being opened (inserted into device_file)
1417
 *
1418
 * @return 0 failed, 1 succeeded ('line' contains data)
1419
 */
1420
static int usb_host_read_file(char *line, size_t line_size,
1421
                              const char *device_file, const char *device_name)
1422
{
1423
    FILE *f;
1424
    int ret = 0;
1425
    char filename[PATH_MAX];
1426

    
1427
    snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1428
             device_file);
1429
    f = fopen(filename, "r");
1430
    if (f) {
1431
        ret = fgets(line, line_size, f) != NULL;
1432
        fclose(f);
1433
    }
1434

    
1435
    return ret;
1436
}
1437

    
1438
/*
1439
 * Use /sys/bus/usb/devices/ directory to determine host's USB
1440
 * devices.
1441
 *
1442
 * This code is based on Robert Schiele's original patches posted to
1443
 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1444
 */
1445
static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1446
{
1447
    DIR *dir = NULL;
1448
    char line[1024];
1449
    int bus_num, addr, speed, class_id, product_id, vendor_id;
1450
    int ret = 0;
1451
    char port[MAX_PORTLEN];
1452
    char product_name[512];
1453
    struct dirent *de;
1454

    
1455
    dir = opendir(USBSYSBUS_PATH "/devices");
1456
    if (!dir) {
1457
        perror("husb: cannot open devices directory");
1458
        goto the_end;
1459
    }
1460

    
1461
    while ((de = readdir(dir))) {
1462
        if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1463
            if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1464
                continue;
1465
            }
1466

    
1467
            if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1468
                goto the_end;
1469
            }
1470
            if (sscanf(line, "%d", &addr) != 1) {
1471
                goto the_end;
1472
            }
1473
            if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1474
                                    de->d_name)) {
1475
                goto the_end;
1476
            }
1477
            if (sscanf(line, "%x", &class_id) != 1) {
1478
                goto the_end;
1479
            }
1480

    
1481
            if (!usb_host_read_file(line, sizeof(line), "idVendor",
1482
                                    de->d_name)) {
1483
                goto the_end;
1484
            }
1485
            if (sscanf(line, "%x", &vendor_id) != 1) {
1486
                goto the_end;
1487
            }
1488
            if (!usb_host_read_file(line, sizeof(line), "idProduct",
1489
                                    de->d_name)) {
1490
                goto the_end;
1491
            }
1492
            if (sscanf(line, "%x", &product_id) != 1) {
1493
                goto the_end;
1494
            }
1495
            if (!usb_host_read_file(line, sizeof(line), "product",
1496
                                    de->d_name)) {
1497
                *product_name = 0;
1498
            } else {
1499
                if (strlen(line) > 0) {
1500
                    line[strlen(line) - 1] = '\0';
1501
                }
1502
                pstrcpy(product_name, sizeof(product_name), line);
1503
            }
1504

    
1505
            if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1506
                goto the_end;
1507
            }
1508
            if (!strcmp(line, "480\n")) {
1509
                speed = USB_SPEED_HIGH;
1510
            } else if (!strcmp(line, "1.5\n")) {
1511
                speed = USB_SPEED_LOW;
1512
            } else {
1513
                speed = USB_SPEED_FULL;
1514
            }
1515

    
1516
            ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1517
                       product_id, product_name, speed);
1518
            if (ret) {
1519
                goto the_end;
1520
            }
1521
        }
1522
    }
1523
 the_end:
1524
    if (dir) {
1525
        closedir(dir);
1526
    }
1527
    return ret;
1528
}
1529

    
1530
/*
1531
 * Determine how to access the host's USB devices and call the
1532
 * specific support function.
1533
 */
1534
static int usb_host_scan(void *opaque, USBScanFunc *func)
1535
{
1536
    Monitor *mon = cur_mon;
1537
    FILE *f = NULL;
1538
    DIR *dir = NULL;
1539
    int ret = 0;
1540
    const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1541
    char devpath[PATH_MAX];
1542

    
1543
    /* only check the host once */
1544
    if (!usb_fs_type) {
1545
        dir = opendir(USBSYSBUS_PATH "/devices");
1546
        if (dir) {
1547
            /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1548
            strcpy(devpath, USBDEVBUS_PATH);
1549
            usb_fs_type = USB_FS_SYS;
1550
            closedir(dir);
1551
            DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1552
            goto found_devices;
1553
        }
1554
        f = fopen(USBPROCBUS_PATH "/devices", "r");
1555
        if (f) {
1556
            /* devices found in /proc/bus/usb/ */
1557
            strcpy(devpath, USBPROCBUS_PATH);
1558
            usb_fs_type = USB_FS_PROC;
1559
            fclose(f);
1560
            DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1561
            goto found_devices;
1562
        }
1563
        /* try additional methods if an access method hasn't been found yet */
1564
        f = fopen(USBDEVBUS_PATH "/devices", "r");
1565
        if (f) {
1566
            /* devices found in /dev/bus/usb/ */
1567
            strcpy(devpath, USBDEVBUS_PATH);
1568
            usb_fs_type = USB_FS_DEV;
1569
            fclose(f);
1570
            DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1571
            goto found_devices;
1572
        }
1573
    found_devices:
1574
        if (!usb_fs_type) {
1575
            if (mon) {
1576
                monitor_printf(mon, "husb: unable to access USB devices\n");
1577
            }
1578
            return -ENOENT;
1579
        }
1580

    
1581
        /* the module setting (used later for opening devices) */
1582
        usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
1583
        strcpy(usb_host_device_path, devpath);
1584
        if (mon) {
1585
            monitor_printf(mon, "husb: using %s file-system with %s\n",
1586
                           fs_type[usb_fs_type], usb_host_device_path);
1587
        }
1588
    }
1589

    
1590
    switch (usb_fs_type) {
1591
    case USB_FS_PROC:
1592
    case USB_FS_DEV:
1593
        ret = usb_host_scan_dev(opaque, func);
1594
        break;
1595
    case USB_FS_SYS:
1596
        ret = usb_host_scan_sys(opaque, func);
1597
        break;
1598
    default:
1599
        ret = -EINVAL;
1600
        break;
1601
    }
1602
    return ret;
1603
}
1604

    
1605
static QEMUTimer *usb_auto_timer;
1606

    
1607
static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
1608
                              int class_id, int vendor_id, int product_id,
1609
                              const char *product_name, int speed)
1610
{
1611
    struct USBAutoFilter *f;
1612
    struct USBHostDevice *s;
1613

    
1614
    /* Ignore hubs */
1615
    if (class_id == 9)
1616
        return 0;
1617

    
1618
    QTAILQ_FOREACH(s, &hostdevs, next) {
1619
        f = &s->match;
1620

    
1621
        if (f->bus_num > 0 && f->bus_num != bus_num) {
1622
            continue;
1623
        }
1624
        if (f->addr > 0 && f->addr != addr) {
1625
            continue;
1626
        }
1627
        if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1628
            continue;
1629
        }
1630

    
1631
        if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1632
            continue;
1633
        }
1634

    
1635
        if (f->product_id > 0 && f->product_id != product_id) {
1636
            continue;
1637
        }
1638
        /* We got a match */
1639

    
1640
        /* Already attached ? */
1641
        if (s->fd != -1) {
1642
            return 0;
1643
        }
1644
        DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1645

    
1646
        usb_host_open(s, bus_num, addr, port, product_name);
1647
    }
1648

    
1649
    return 0;
1650
}
1651

    
1652
static void usb_host_auto_check(void *unused)
1653
{
1654
    struct USBHostDevice *s;
1655
    int unconnected = 0;
1656

    
1657
    usb_host_scan(NULL, usb_host_auto_scan);
1658

    
1659
    QTAILQ_FOREACH(s, &hostdevs, next) {
1660
        if (s->fd == -1) {
1661
            unconnected++;
1662
        }
1663
    }
1664

    
1665
    if (unconnected == 0) {
1666
        /* nothing to watch */
1667
        if (usb_auto_timer) {
1668
            qemu_del_timer(usb_auto_timer);
1669
        }
1670
        return;
1671
    }
1672

    
1673
    if (!usb_auto_timer) {
1674
        usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1675
        if (!usb_auto_timer) {
1676
            return;
1677
        }
1678
    }
1679
    qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1680
}
1681

    
1682
/*
1683
 * Autoconnect filter
1684
 * Format:
1685
 *    auto:bus:dev[:vid:pid]
1686
 *    auto:bus.dev[:vid:pid]
1687
 *
1688
 *    bus  - bus number    (dec, * means any)
1689
 *    dev  - device number (dec, * means any)
1690
 *    vid  - vendor id     (hex, * means any)
1691
 *    pid  - product id    (hex, * means any)
1692
 *
1693
 *    See 'lsusb' output.
1694
 */
1695
static int parse_filter(const char *spec, struct USBAutoFilter *f)
1696
{
1697
    enum { BUS, DEV, VID, PID, DONE };
1698
    const char *p = spec;
1699
    int i;
1700

    
1701
    f->bus_num    = 0;
1702
    f->addr       = 0;
1703
    f->vendor_id  = 0;
1704
    f->product_id = 0;
1705

    
1706
    for (i = BUS; i < DONE; i++) {
1707
        p = strpbrk(p, ":.");
1708
        if (!p) {
1709
            break;
1710
        }
1711
        p++;
1712

    
1713
        if (*p == '*') {
1714
            continue;
1715
        }
1716
        switch(i) {
1717
        case BUS: f->bus_num = strtol(p, NULL, 10);    break;
1718
        case DEV: f->addr    = strtol(p, NULL, 10);    break;
1719
        case VID: f->vendor_id  = strtol(p, NULL, 16); break;
1720
        case PID: f->product_id = strtol(p, NULL, 16); break;
1721
        }
1722
    }
1723

    
1724
    if (i < DEV) {
1725
        fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1726
        return -1;
1727
    }
1728

    
1729
    return 0;
1730
}
1731

    
1732
/**********************/
1733
/* USB host device info */
1734

    
1735
struct usb_class_info {
1736
    int class;
1737
    const char *class_name;
1738
};
1739

    
1740
static const struct usb_class_info usb_class_info[] = {
1741
    { USB_CLASS_AUDIO, "Audio"},
1742
    { USB_CLASS_COMM, "Communication"},
1743
    { USB_CLASS_HID, "HID"},
1744
    { USB_CLASS_HUB, "Hub" },
1745
    { USB_CLASS_PHYSICAL, "Physical" },
1746
    { USB_CLASS_PRINTER, "Printer" },
1747
    { USB_CLASS_MASS_STORAGE, "Storage" },
1748
    { USB_CLASS_CDC_DATA, "Data" },
1749
    { USB_CLASS_APP_SPEC, "Application Specific" },
1750
    { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1751
    { USB_CLASS_STILL_IMAGE, "Still Image" },
1752
    { USB_CLASS_CSCID, "Smart Card" },
1753
    { USB_CLASS_CONTENT_SEC, "Content Security" },
1754
    { -1, NULL }
1755
};
1756

    
1757
static const char *usb_class_str(uint8_t class)
1758
{
1759
    const struct usb_class_info *p;
1760
    for(p = usb_class_info; p->class != -1; p++) {
1761
        if (p->class == class) {
1762
            break;
1763
        }
1764
    }
1765
    return p->class_name;
1766
}
1767

    
1768
static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
1769
                            int class_id, int vendor_id, int product_id,
1770
                            const char *product_name,
1771
                            int speed)
1772
{
1773
    const char *class_str, *speed_str;
1774

    
1775
    switch(speed) {
1776
    case USB_SPEED_LOW:
1777
        speed_str = "1.5";
1778
        break;
1779
    case USB_SPEED_FULL:
1780
        speed_str = "12";
1781
        break;
1782
    case USB_SPEED_HIGH:
1783
        speed_str = "480";
1784
        break;
1785
    default:
1786
        speed_str = "?";
1787
        break;
1788
    }
1789

    
1790
    monitor_printf(mon, "  Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1791
                   bus_num, addr, port, speed_str);
1792
    class_str = usb_class_str(class_id);
1793
    if (class_str) {
1794
        monitor_printf(mon, "    %s:", class_str);
1795
    } else {
1796
        monitor_printf(mon, "    Class %02x:", class_id);
1797
    }
1798
    monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1799
    if (product_name[0] != '\0') {
1800
        monitor_printf(mon, ", %s", product_name);
1801
    }
1802
    monitor_printf(mon, "\n");
1803
}
1804

    
1805
static int usb_host_info_device(void *opaque, int bus_num, int addr,
1806
                                char *path, int class_id,
1807
                                int vendor_id, int product_id,
1808
                                const char *product_name,
1809
                                int speed)
1810
{
1811
    Monitor *mon = opaque;
1812

    
1813
    usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1814
                    product_name, speed);
1815
    return 0;
1816
}
1817

    
1818
static void dec2str(int val, char *str, size_t size)
1819
{
1820
    if (val == 0) {
1821
        snprintf(str, size, "*");
1822
    } else {
1823
        snprintf(str, size, "%d", val);
1824
    }
1825
}
1826

    
1827
static void hex2str(int val, char *str, size_t size)
1828
{
1829
    if (val == 0) {
1830
        snprintf(str, size, "*");
1831
    } else {
1832
        snprintf(str, size, "%04x", val);
1833
    }
1834
}
1835

    
1836
void usb_host_info(Monitor *mon)
1837
{
1838
    struct USBAutoFilter *f;
1839
    struct USBHostDevice *s;
1840

    
1841
    usb_host_scan(mon, usb_host_info_device);
1842

    
1843
    if (QTAILQ_EMPTY(&hostdevs)) {
1844
        return;
1845
    }
1846

    
1847
    monitor_printf(mon, "  Auto filters:\n");
1848
    QTAILQ_FOREACH(s, &hostdevs, next) {
1849
        char bus[10], addr[10], vid[10], pid[10];
1850
        f = &s->match;
1851
        dec2str(f->bus_num, bus, sizeof(bus));
1852
        dec2str(f->addr, addr, sizeof(addr));
1853
        hex2str(f->vendor_id, vid, sizeof(vid));
1854
        hex2str(f->product_id, pid, sizeof(pid));
1855
        monitor_printf(mon, "    Bus %s, Addr %s, Port %s, ID %s:%s\n",
1856
                       bus, addr, f->port ? f->port : "*", vid, pid);
1857
    }
1858
}