Statistics
| Branch: | Revision:

root / usb-linux.c @ 130314f8

History | View | Annotate | Download (50.9 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

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

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

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

    
60
//#define DEBUG
61

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

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

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

    
77
static char *usb_host_device_path;
78

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

    
84
static int usb_fs_type;
85

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

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

    
94
typedef struct AsyncURB AsyncURB;
95

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
270
static void do_disconnect(USBHostDevice *s)
271
{
272
    printf("husb: device %d.%d disconnected\n",
273
           s->bus_num, s->addr);
274
    usb_host_close(s);
275
    usb_host_auto_check(NULL);
276
}
277

    
278
static void async_complete(void *opaque)
279
{
280
    USBHostDevice *s = opaque;
281
    AsyncURB *aurb;
282

    
283
    while (1) {
284
        USBPacket *p;
285

    
286
        int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
287
        if (r < 0) {
288
            if (errno == EAGAIN) {
289
                return;
290
            }
291
            if (errno == ENODEV && !s->closing) {
292
                do_disconnect(s);
293
                return;
294
            }
295

    
296
            DPRINTF("husb: async. reap urb failed errno %d\n", errno);
297
            return;
298
        }
299

    
300
        DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
301
                aurb, aurb->urb.status, aurb->urb.actual_length);
302

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

    
313
        p = aurb->packet;
314

    
315
        if (p) {
316
            switch (aurb->urb.status) {
317
            case 0:
318
                p->len += aurb->urb.actual_length;
319
                break;
320

    
321
            case -EPIPE:
322
                set_halt(s, p->devep);
323
                p->len = USB_RET_STALL;
324
                break;
325

    
326
            default:
327
                p->len = USB_RET_NAK;
328
                break;
329
            }
330

    
331
            if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
332
                usb_generic_async_ctrl_complete(&s->dev, p);
333
            } else if (!aurb->more) {
334
                usb_packet_complete(&s->dev, p);
335
            }
336
        }
337

    
338
        async_free(aurb);
339
    }
340
}
341

    
342
static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
343
{
344
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
345
    AsyncURB *aurb;
346

    
347
    QLIST_FOREACH(aurb, &s->aurbs, next) {
348
        if (p != aurb->packet) {
349
            continue;
350
        }
351

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

    
354
        /* Mark it as dead (see async_complete above) */
355
        aurb->packet = NULL;
356

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

    
364
static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
365
{
366
    const char *op = NULL;
367
    int dev_descr_len, config_descr_len;
368
    int interface, nb_interfaces;
369
    int ret, i;
370

    
371
    if (configuration == 0) /* address state - ignore */
372
        return 1;
373

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

    
376
    i = 0;
377
    dev_descr_len = dev->descr[0];
378
    if (dev_descr_len > dev->descr_len) {
379
        fprintf(stderr, "husb: update iface failed. descr too short\n");
380
        return 0;
381
    }
382

    
383
    i += dev_descr_len;
384
    while (i < dev->descr_len) {
385
        DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
386
                i, dev->descr_len,
387
               dev->descr[i], dev->descr[i+1]);
388

    
389
        if (dev->descr[i+1] != USB_DT_CONFIG) {
390
            i += dev->descr[i];
391
            continue;
392
        }
393
        config_descr_len = dev->descr[i];
394

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

    
397
        if (configuration < 0 || configuration == dev->descr[i + 5]) {
398
            configuration = dev->descr[i + 5];
399
            break;
400
        }
401

    
402
        i += config_descr_len;
403
    }
404

    
405
    if (i >= dev->descr_len) {
406
        fprintf(stderr,
407
                "husb: update iface failed. no matching configuration\n");
408
        return 0;
409
    }
410
    nb_interfaces = dev->descr[i + 4];
411

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

    
429
    /* XXX: only grab if all interfaces are free */
430
    for (interface = 0; interface < nb_interfaces; interface++) {
431
        op = "USBDEVFS_CLAIMINTERFACE";
432
        ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
433
        if (ret < 0) {
434
            if (errno == EBUSY) {
435
                printf("husb: update iface. device already grabbed\n");
436
            } else {
437
                perror("husb: failed to claim interface");
438
            }
439
            goto fail;
440
        }
441
    }
442

    
443
    printf("husb: %d interfaces claimed for configuration %d\n",
444
           nb_interfaces, configuration);
445

    
446
    dev->ninterfaces   = nb_interfaces;
447
    dev->configuration = configuration;
448
    return 1;
449

    
450
fail:
451
    if (errno == ENODEV) {
452
        do_disconnect(dev);
453
    }
454
    perror(op);
455
    return 0;
456
}
457

    
458
static int usb_host_release_interfaces(USBHostDevice *s)
459
{
460
    int ret, i;
461

    
462
    DPRINTF("husb: releasing interfaces\n");
463

    
464
    for (i = 0; i < s->ninterfaces; i++) {
465
        ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
466
        if (ret < 0) {
467
            perror("husb: failed to release interface");
468
            return 0;
469
        }
470
    }
471

    
472
    return 1;
473
}
474

    
475
static void usb_host_handle_reset(USBDevice *dev)
476
{
477
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
478

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

    
481
    ioctl(s->fd, USBDEVFS_RESET);
482

    
483
    usb_host_claim_interfaces(s, s->configuration);
484
}
485

    
486
static void usb_host_handle_destroy(USBDevice *dev)
487
{
488
    USBHostDevice *s = (USBHostDevice *)dev;
489

    
490
    usb_host_close(s);
491
    QTAILQ_REMOVE(&hostdevs, s, next);
492
    qemu_remove_exit_notifier(&s->exit);
493
}
494

    
495
static int usb_linux_update_endp_table(USBHostDevice *s);
496

    
497
/* iso data is special, we need to keep enough urbs in flight to make sure
498
   that the controller never runs out of them, otherwise the device will
499
   likely suffer a buffer underrun / overrun. */
500
static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, uint8_t ep, int in)
501
{
502
    AsyncURB *aurb;
503
    int i, j, len = get_max_packet_size(s, ep);
504

    
505
    aurb = qemu_mallocz(ISO_URB_COUNT * sizeof(*aurb));
506
    for (i = 0; i < ISO_URB_COUNT; i++) {
507
        aurb[i].urb.endpoint      = ep;
508
        aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
509
        aurb[i].urb.buffer        = qemu_malloc(aurb[i].urb.buffer_length);
510
        aurb[i].urb.type          = USBDEVFS_URB_TYPE_ISO;
511
        aurb[i].urb.flags         = USBDEVFS_URB_ISO_ASAP;
512
        aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
513
        for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
514
            aurb[i].urb.iso_frame_desc[j].length = len;
515
        if (in) {
516
            aurb[i].urb.endpoint |= 0x80;
517
            /* Mark as fully consumed (idle) */
518
            aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
519
        }
520
    }
521
    set_iso_urb(s, ep, aurb);
522

    
523
    return aurb;
524
}
525

    
526
static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep)
527
{
528
    AsyncURB *aurb;
529
    int i, ret, killed = 0, free = 1;
530

    
531
    aurb = get_iso_urb(s, ep);
532
    if (!aurb) {
533
        return;
534
    }
535

    
536
    for (i = 0; i < ISO_URB_COUNT; i++) {
537
        /* in flight? */
538
        if (aurb[i].iso_frame_idx == -1) {
539
            ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
540
            if (ret < 0) {
541
                printf("husb: discard isoc in urb failed errno %d\n", errno);
542
                free = 0;
543
                continue;
544
            }
545
            killed++;
546
        }
547
    }
548

    
549
    /* Make sure any urbs we've killed are reaped before we free them */
550
    if (killed) {
551
        async_complete(s);
552
    }
553

    
554
    for (i = 0; i < ISO_URB_COUNT; i++) {
555
        qemu_free(aurb[i].urb.buffer);
556
    }
557

    
558
    if (free)
559
        qemu_free(aurb);
560
    else
561
        printf("husb: leaking iso urbs because of discard failure\n");
562
    set_iso_urb(s, ep, NULL);
563
    set_iso_urb_idx(s, ep, 0);
564
    clear_iso_started(s, ep);
565
}
566

    
567
static int urb_status_to_usb_ret(int status)
568
{
569
    switch (status) {
570
    case -EPIPE:
571
        return USB_RET_STALL;
572
    default:
573
        return USB_RET_NAK;
574
    }
575
}
576

    
577
static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
578
{
579
    AsyncURB *aurb;
580
    int i, j, ret, max_packet_size, offset, len = 0;
581

    
582
    max_packet_size = get_max_packet_size(s, p->devep);
583
    if (max_packet_size == 0)
584
        return USB_RET_NAK;
585

    
586
    aurb = get_iso_urb(s, p->devep);
587
    if (!aurb) {
588
        aurb = usb_host_alloc_iso(s, p->devep, in);
589
    }
590

    
591
    i = get_iso_urb_idx(s, p->devep);
592
    j = aurb[i].iso_frame_idx;
593
    if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
594
        if (in) {
595
            /* Check urb status  */
596
            if (aurb[i].urb.status) {
597
                len = urb_status_to_usb_ret(aurb[i].urb.status);
598
                /* Move to the next urb */
599
                aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
600
            /* Check frame status */
601
            } else if (aurb[i].urb.iso_frame_desc[j].status) {
602
                len = urb_status_to_usb_ret(
603
                                        aurb[i].urb.iso_frame_desc[j].status);
604
            /* Check the frame fits */
605
            } else if (aurb[i].urb.iso_frame_desc[j].actual_length > p->len) {
606
                printf("husb: received iso data is larger then packet\n");
607
                len = USB_RET_NAK;
608
            /* All good copy data over */
609
            } else {
610
                len = aurb[i].urb.iso_frame_desc[j].actual_length;
611
                memcpy(p->data,
612
                       aurb[i].urb.buffer +
613
                           j * aurb[i].urb.iso_frame_desc[0].length,
614
                       len);
615
            }
616
        } else {
617
            len = p->len;
618
            offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->devep);
619

    
620
            /* Check the frame fits */
621
            if (len > max_packet_size) {
622
                printf("husb: send iso data is larger then max packet size\n");
623
                return USB_RET_NAK;
624
            }
625

    
626
            /* All good copy data over */
627
            memcpy(aurb[i].urb.buffer + offset, p->data, len);
628
            aurb[i].urb.iso_frame_desc[j].length = len;
629
            offset += len;
630
            set_iso_buffer_used(s, p->devep, offset);
631

    
632
            /* Start the stream once we have buffered enough data */
633
            if (!is_iso_started(s, p->devep) && i == 1 && j == 8) {
634
                set_iso_started(s, p->devep);
635
            }
636
        }
637
        aurb[i].iso_frame_idx++;
638
        if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
639
            i = (i + 1) % ISO_URB_COUNT;
640
            set_iso_urb_idx(s, p->devep, i);
641
        }
642
    } else {
643
        if (in) {
644
            set_iso_started(s, p->devep);
645
        } else {
646
            DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
647
        }
648
    }
649

    
650
    if (is_iso_started(s, p->devep)) {
651
        /* (Re)-submit all fully consumed / filled urbs */
652
        for (i = 0; i < ISO_URB_COUNT; i++) {
653
            if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
654
                ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
655
                if (ret < 0) {
656
                    printf("husb error submitting iso urb %d: %d\n", i, errno);
657
                    if (!in || len == 0) {
658
                        switch(errno) {
659
                        case ETIMEDOUT:
660
                            len = USB_RET_NAK;
661
                            break;
662
                        case EPIPE:
663
                        default:
664
                            len = USB_RET_STALL;
665
                        }
666
                    }
667
                    break;
668
                }
669
                aurb[i].iso_frame_idx = -1;
670
            }
671
        }
672
    }
673

    
674
    return len;
675
}
676

    
677
static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
678
{
679
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
680
    struct usbdevfs_urb *urb;
681
    AsyncURB *aurb;
682
    int ret, rem;
683
    uint8_t *pbuf;
684
    uint8_t ep;
685

    
686
    if (!is_valid(s, p->devep)) {
687
        return USB_RET_NAK;
688
    }
689

    
690
    if (p->pid == USB_TOKEN_IN) {
691
        ep = p->devep | 0x80;
692
    } else {
693
        ep = p->devep;
694
    }
695

    
696
    if (is_halted(s, p->devep)) {
697
        ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &ep);
698
        if (ret < 0) {
699
            DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n",
700
                   ep, errno);
701
            return USB_RET_NAK;
702
        }
703
        clear_halt(s, p->devep);
704
    }
705

    
706
    if (is_isoc(s, p->devep)) {
707
        return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
708
    }
709

    
710
    rem = p->len;
711
    pbuf = p->data;
712
    p->len = 0;
713
    while (rem) {
714
        aurb = async_alloc(s);
715
        aurb->packet = p;
716

    
717
        urb = &aurb->urb;
718
        urb->endpoint      = ep;
719
        urb->type          = USBDEVFS_URB_TYPE_BULK;
720
        urb->usercontext   = s;
721
        urb->buffer        = pbuf;
722

    
723
        if (rem > MAX_USBFS_BUFFER_SIZE) {
724
            urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
725
            aurb->more         = 1;
726
        } else {
727
            urb->buffer_length = rem;
728
            aurb->more         = 0;
729
        }
730
        pbuf += urb->buffer_length;
731
        rem  -= urb->buffer_length;
732

    
733
        ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
734

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

    
738
        if (ret < 0) {
739
            DPRINTF("husb: submit failed. errno %d\n", errno);
740
            async_free(aurb);
741

    
742
            switch(errno) {
743
            case ETIMEDOUT:
744
                return USB_RET_NAK;
745
            case EPIPE:
746
            default:
747
                return USB_RET_STALL;
748
            }
749
        }
750
    }
751

    
752
    return USB_RET_ASYNC;
753
}
754

    
755
static int ctrl_error(void)
756
{
757
    if (errno == ETIMEDOUT) {
758
        return USB_RET_NAK;
759
    } else {
760
        return USB_RET_STALL;
761
    }
762
}
763

    
764
static int usb_host_set_address(USBHostDevice *s, int addr)
765
{
766
    DPRINTF("husb: ctrl set addr %u\n", addr);
767
    s->dev.addr = addr;
768
    return 0;
769
}
770

    
771
static int usb_host_set_config(USBHostDevice *s, int config)
772
{
773
    usb_host_release_interfaces(s);
774

    
775
    int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
776

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

    
779
    if (ret < 0) {
780
        return ctrl_error();
781
    }
782
    usb_host_claim_interfaces(s, config);
783
    return 0;
784
}
785

    
786
static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
787
{
788
    struct usbdevfs_setinterface si;
789
    int i, ret;
790

    
791
    for (i = 1; i <= MAX_ENDPOINTS; i++) {
792
        if (is_isoc(s, i)) {
793
            usb_host_stop_n_free_iso(s, i);
794
        }
795
    }
796

    
797
    si.interface  = iface;
798
    si.altsetting = alt;
799
    ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
800

    
801
    DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
802
            iface, alt, ret, errno);
803

    
804
    if (ret < 0) {
805
        return ctrl_error();
806
    }
807
    usb_linux_update_endp_table(s);
808
    return 0;
809
}
810

    
811
static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
812
               int request, int value, int index, int length, uint8_t *data)
813
{
814
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
815
    struct usbdevfs_urb *urb;
816
    AsyncURB *aurb;
817
    int ret;
818

    
819
    /*
820
     * Process certain standard device requests.
821
     * These are infrequent and are processed synchronously.
822
     */
823

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

    
828
    switch (request) {
829
    case DeviceOutRequest | USB_REQ_SET_ADDRESS:
830
        return usb_host_set_address(s, value);
831

    
832
    case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
833
        return usb_host_set_config(s, value & 0xff);
834

    
835
    case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
836
        return usb_host_set_interface(s, index, value);
837
    }
838

    
839
    /* The rest are asynchronous */
840

    
841
    if (length > sizeof(dev->data_buf)) {
842
        fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
843
                length, sizeof(dev->data_buf));
844
        return USB_RET_STALL;
845
    }
846

    
847
    aurb = async_alloc(s);
848
    aurb->packet = p;
849

    
850
    /*
851
     * Setup ctrl transfer.
852
     *
853
     * s->ctrl is laid out such that data buffer immediately follows
854
     * 'req' struct which is exactly what usbdevfs expects.
855
     */
856
    urb = &aurb->urb;
857

    
858
    urb->type     = USBDEVFS_URB_TYPE_CONTROL;
859
    urb->endpoint = p->devep;
860

    
861
    urb->buffer        = &dev->setup_buf;
862
    urb->buffer_length = length + 8;
863

    
864
    urb->usercontext = s;
865

    
866
    ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
867

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

    
870
    if (ret < 0) {
871
        DPRINTF("husb: submit failed. errno %d\n", errno);
872
        async_free(aurb);
873

    
874
        switch(errno) {
875
        case ETIMEDOUT:
876
            return USB_RET_NAK;
877
        case EPIPE:
878
        default:
879
            return USB_RET_STALL;
880
        }
881
    }
882

    
883
    return USB_RET_ASYNC;
884
}
885

    
886
static int usb_linux_get_configuration(USBHostDevice *s)
887
{
888
    uint8_t configuration;
889
    struct usb_ctrltransfer ct;
890
    int ret;
891

    
892
    if (usb_fs_type == USB_FS_SYS) {
893
        char device_name[32], line[1024];
894
        int configuration;
895

    
896
        sprintf(device_name, "%d-%s", s->bus_num, s->port);
897

    
898
        if (!usb_host_read_file(line, sizeof(line), "bConfigurationValue",
899
                                device_name)) {
900
            goto usbdevfs;
901
        }
902
        if (sscanf(line, "%d", &configuration) != 1) {
903
            goto usbdevfs;
904
        }
905
        return configuration;
906
    }
907

    
908
usbdevfs:
909
    ct.bRequestType = USB_DIR_IN;
910
    ct.bRequest = USB_REQ_GET_CONFIGURATION;
911
    ct.wValue = 0;
912
    ct.wIndex = 0;
913
    ct.wLength = 1;
914
    ct.data = &configuration;
915
    ct.timeout = 50;
916

    
917
    ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
918
    if (ret < 0) {
919
        perror("usb_linux_get_configuration");
920
        return -1;
921
    }
922

    
923
    /* in address state */
924
    if (configuration == 0) {
925
        return -1;
926
    }
927

    
928
    return configuration;
929
}
930

    
931
static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
932
    uint8_t configuration, uint8_t interface)
933
{
934
    uint8_t alt_setting;
935
    struct usb_ctrltransfer ct;
936
    int ret;
937

    
938
    if (usb_fs_type == USB_FS_SYS) {
939
        char device_name[64], line[1024];
940
        int alt_setting;
941

    
942
        sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
943
                (int)configuration, (int)interface);
944

    
945
        if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
946
                                device_name)) {
947
            goto usbdevfs;
948
        }
949
        if (sscanf(line, "%d", &alt_setting) != 1) {
950
            goto usbdevfs;
951
        }
952
        return alt_setting;
953
    }
954

    
955
usbdevfs:
956
    ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
957
    ct.bRequest = USB_REQ_GET_INTERFACE;
958
    ct.wValue = 0;
959
    ct.wIndex = interface;
960
    ct.wLength = 1;
961
    ct.data = &alt_setting;
962
    ct.timeout = 50;
963
    ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
964
    if (ret < 0) {
965
        /* Assume alt 0 on error */
966
        return 0;
967
    }
968

    
969
    return alt_setting;
970
}
971

    
972
/* returns 1 on problem encountered or 0 for success */
973
static int usb_linux_update_endp_table(USBHostDevice *s)
974
{
975
    uint8_t *descriptors;
976
    uint8_t devep, type, configuration, alt_interface;
977
    int interface, length, i;
978

    
979
    for (i = 0; i < MAX_ENDPOINTS; i++)
980
        s->endp_table[i].type = INVALID_EP_TYPE;
981

    
982
    i = usb_linux_get_configuration(s);
983
    if (i < 0)
984
        return 1;
985
    configuration = i;
986

    
987
    /* get the desired configuration, interface, and endpoint descriptors
988
     * from device description */
989
    descriptors = &s->descr[18];
990
    length = s->descr_len - 18;
991
    i = 0;
992

    
993
    if (descriptors[i + 1] != USB_DT_CONFIG ||
994
        descriptors[i + 5] != configuration) {
995
        DPRINTF("invalid descriptor data - configuration\n");
996
        return 1;
997
    }
998
    i += descriptors[i];
999

    
1000
    while (i < length) {
1001
        if (descriptors[i + 1] != USB_DT_INTERFACE ||
1002
            (descriptors[i + 1] == USB_DT_INTERFACE &&
1003
             descriptors[i + 4] == 0)) {
1004
            i += descriptors[i];
1005
            continue;
1006
        }
1007

    
1008
        interface = descriptors[i + 2];
1009
        alt_interface = usb_linux_get_alt_setting(s, configuration, interface);
1010

    
1011
        /* the current interface descriptor is the active interface
1012
         * and has endpoints */
1013
        if (descriptors[i + 3] != alt_interface) {
1014
            i += descriptors[i];
1015
            continue;
1016
        }
1017

    
1018
        /* advance to the endpoints */
1019
        while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1020
            i += descriptors[i];
1021
        }
1022

    
1023
        if (i >= length)
1024
            break;
1025

    
1026
        while (i < length) {
1027
            if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1028
                break;
1029
            }
1030

    
1031
            devep = descriptors[i + 2];
1032
            if ((devep & 0x0f) == 0) {
1033
                fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1034
                return 1;
1035
            }
1036

    
1037
            switch (descriptors[i + 3] & 0x3) {
1038
            case 0x00:
1039
                type = USBDEVFS_URB_TYPE_CONTROL;
1040
                break;
1041
            case 0x01:
1042
                type = USBDEVFS_URB_TYPE_ISO;
1043
                set_max_packet_size(s, (devep & 0xf), descriptors + i);
1044
                break;
1045
            case 0x02:
1046
                type = USBDEVFS_URB_TYPE_BULK;
1047
                break;
1048
            case 0x03:
1049
                type = USBDEVFS_URB_TYPE_INTERRUPT;
1050
                break;
1051
            default:
1052
                DPRINTF("usb_host: malformed endpoint type\n");
1053
                type = USBDEVFS_URB_TYPE_BULK;
1054
            }
1055
            s->endp_table[(devep & 0xf) - 1].type = type;
1056
            s->endp_table[(devep & 0xf) - 1].halted = 0;
1057

    
1058
            i += descriptors[i];
1059
        }
1060
    }
1061
    return 0;
1062
}
1063

    
1064
static int usb_host_open(USBHostDevice *dev, int bus_num,
1065
                        int addr, char *port, const char *prod_name, int speed)
1066
{
1067
    int fd = -1, ret;
1068
    char buf[1024];
1069

    
1070
    if (dev->fd != -1) {
1071
        goto fail;
1072
    }
1073
    printf("husb: open device %d.%d\n", bus_num, addr);
1074

    
1075
    if (!usb_host_device_path) {
1076
        perror("husb: USB Host Device Path not set");
1077
        goto fail;
1078
    }
1079
    snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
1080
             bus_num, addr);
1081
    fd = open(buf, O_RDWR | O_NONBLOCK);
1082
    if (fd < 0) {
1083
        perror(buf);
1084
        goto fail;
1085
    }
1086
    DPRINTF("husb: opened %s\n", buf);
1087

    
1088
    dev->bus_num = bus_num;
1089
    dev->addr = addr;
1090
    strcpy(dev->port, port);
1091
    dev->fd = fd;
1092

    
1093
    /* read the device description */
1094
    dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1095
    if (dev->descr_len <= 0) {
1096
        perror("husb: reading device data failed");
1097
        goto fail;
1098
    }
1099

    
1100
#ifdef DEBUG
1101
    {
1102
        int x;
1103
        printf("=== begin dumping device descriptor data ===\n");
1104
        for (x = 0; x < dev->descr_len; x++) {
1105
            printf("%02x ", dev->descr[x]);
1106
        }
1107
        printf("\n=== end dumping device descriptor data ===\n");
1108
    }
1109
#endif
1110

    
1111

    
1112
    /*
1113
     * Initial configuration is -1 which makes us claim first
1114
     * available config. We used to start with 1, which does not
1115
     * always work. I've seen devices where first config starts
1116
     * with 2.
1117
     */
1118
    if (!usb_host_claim_interfaces(dev, -1)) {
1119
        goto fail;
1120
    }
1121

    
1122
    ret = usb_linux_update_endp_table(dev);
1123
    if (ret) {
1124
        goto fail;
1125
    }
1126

    
1127
    if (speed == -1) {
1128
        struct usbdevfs_connectinfo ci;
1129

    
1130
        ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1131
        if (ret < 0) {
1132
            perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1133
            goto fail;
1134
        }
1135

    
1136
        if (ci.slow) {
1137
            speed = USB_SPEED_LOW;
1138
        } else {
1139
            speed = USB_SPEED_HIGH;
1140
        }
1141
    }
1142
    dev->dev.speed = speed;
1143

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

    
1146
    if (!prod_name || prod_name[0] == '\0') {
1147
        snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1148
                 "host:%d.%d", bus_num, addr);
1149
    } else {
1150
        pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1151
                prod_name);
1152
    }
1153

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

    
1157
    usb_device_attach(&dev->dev);
1158
    return 0;
1159

    
1160
fail:
1161
    dev->fd = -1;
1162
    if (fd != -1) {
1163
        close(fd);
1164
    }
1165
    return -1;
1166
}
1167

    
1168
static int usb_host_close(USBHostDevice *dev)
1169
{
1170
    int i;
1171

    
1172
    if (dev->fd == -1) {
1173
        return -1;
1174
    }
1175

    
1176
    qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1177
    dev->closing = 1;
1178
    for (i = 1; i <= MAX_ENDPOINTS; i++) {
1179
        if (is_isoc(dev, i)) {
1180
            usb_host_stop_n_free_iso(dev, i);
1181
        }
1182
    }
1183
    async_complete(dev);
1184
    dev->closing = 0;
1185
    usb_device_detach(&dev->dev);
1186
    ioctl(dev->fd, USBDEVFS_RESET);
1187
    close(dev->fd);
1188
    dev->fd = -1;
1189
    return 0;
1190
}
1191

    
1192
static void usb_host_exit_notifier(struct Notifier* n)
1193
{
1194
    USBHostDevice *s = container_of(n, USBHostDevice, exit);
1195

    
1196
    if (s->fd != -1) {
1197
        ioctl(s->fd, USBDEVFS_RESET);
1198
    }
1199
}
1200

    
1201
static int usb_host_initfn(USBDevice *dev)
1202
{
1203
    USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1204

    
1205
    dev->auto_attach = 0;
1206
    s->fd = -1;
1207
    QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1208
    s->exit.notify = usb_host_exit_notifier;
1209
    qemu_add_exit_notifier(&s->exit);
1210
    usb_host_auto_check(NULL);
1211
    return 0;
1212
}
1213

    
1214
static struct USBDeviceInfo usb_host_dev_info = {
1215
    .product_desc   = "USB Host Device",
1216
    .qdev.name      = "usb-host",
1217
    .qdev.size      = sizeof(USBHostDevice),
1218
    .init           = usb_host_initfn,
1219
    .handle_packet  = usb_generic_handle_packet,
1220
    .cancel_packet  = usb_host_async_cancel,
1221
    .handle_data    = usb_host_handle_data,
1222
    .handle_control = usb_host_handle_control,
1223
    .handle_reset   = usb_host_handle_reset,
1224
    .handle_destroy = usb_host_handle_destroy,
1225
    .usbdevice_name = "host",
1226
    .usbdevice_init = usb_host_device_open,
1227
    .qdev.props     = (Property[]) {
1228
        DEFINE_PROP_UINT32("hostbus",  USBHostDevice, match.bus_num,    0),
1229
        DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr,       0),
1230
        DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1231
        DEFINE_PROP_HEX32("vendorid",  USBHostDevice, match.vendor_id,  0),
1232
        DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1233
        DEFINE_PROP_END_OF_LIST(),
1234
    },
1235
};
1236

    
1237
static void usb_host_register_devices(void)
1238
{
1239
    usb_qdev_register(&usb_host_dev_info);
1240
}
1241
device_init(usb_host_register_devices)
1242

    
1243
USBDevice *usb_host_device_open(const char *devname)
1244
{
1245
    struct USBAutoFilter filter;
1246
    USBDevice *dev;
1247
    char *p;
1248

    
1249
    dev = usb_create(NULL /* FIXME */, "usb-host");
1250

    
1251
    if (strstr(devname, "auto:")) {
1252
        if (parse_filter(devname, &filter) < 0) {
1253
            goto fail;
1254
        }
1255
    } else {
1256
        if ((p = strchr(devname, '.'))) {
1257
            filter.bus_num    = strtoul(devname, NULL, 0);
1258
            filter.addr       = strtoul(p + 1, NULL, 0);
1259
            filter.vendor_id  = 0;
1260
            filter.product_id = 0;
1261
        } else if ((p = strchr(devname, ':'))) {
1262
            filter.bus_num    = 0;
1263
            filter.addr       = 0;
1264
            filter.vendor_id  = strtoul(devname, NULL, 16);
1265
            filter.product_id = strtoul(p + 1, NULL, 16);
1266
        } else {
1267
            goto fail;
1268
        }
1269
    }
1270

    
1271
    qdev_prop_set_uint32(&dev->qdev, "hostbus",   filter.bus_num);
1272
    qdev_prop_set_uint32(&dev->qdev, "hostaddr",  filter.addr);
1273
    qdev_prop_set_uint32(&dev->qdev, "vendorid",  filter.vendor_id);
1274
    qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1275
    qdev_init_nofail(&dev->qdev);
1276
    return dev;
1277

    
1278
fail:
1279
    qdev_free(&dev->qdev);
1280
    return NULL;
1281
}
1282

    
1283
int usb_host_device_close(const char *devname)
1284
{
1285
#if 0
1286
    char product_name[PRODUCT_NAME_SZ];
1287
    int bus_num, addr;
1288
    USBHostDevice *s;
1289

1290
    if (strstr(devname, "auto:")) {
1291
        return usb_host_auto_del(devname);
1292
    }
1293
    if (usb_host_find_device(&bus_num, &addr, product_name,
1294
                                    sizeof(product_name), devname) < 0) {
1295
        return -1;
1296
    }
1297
    s = hostdev_find(bus_num, addr);
1298
    if (s) {
1299
        usb_device_delete_addr(s->bus_num, s->dev.addr);
1300
        return 0;
1301
    }
1302
#endif
1303

    
1304
    return -1;
1305
}
1306

    
1307
static int get_tag_value(char *buf, int buf_size,
1308
                         const char *str, const char *tag,
1309
                         const char *stopchars)
1310
{
1311
    const char *p;
1312
    char *q;
1313
    p = strstr(str, tag);
1314
    if (!p) {
1315
        return -1;
1316
    }
1317
    p += strlen(tag);
1318
    while (qemu_isspace(*p)) {
1319
        p++;
1320
    }
1321
    q = buf;
1322
    while (*p != '\0' && !strchr(stopchars, *p)) {
1323
        if ((q - buf) < (buf_size - 1)) {
1324
            *q++ = *p;
1325
        }
1326
        p++;
1327
    }
1328
    *q = '\0';
1329
    return q - buf;
1330
}
1331

    
1332
/*
1333
 * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
1334
 * host's USB devices. This is legacy support since many distributions
1335
 * are moving to /sys/bus/usb
1336
 */
1337
static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
1338
{
1339
    FILE *f = NULL;
1340
    char line[1024];
1341
    char buf[1024];
1342
    int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
1343
    char product_name[512];
1344
    int ret = 0;
1345

    
1346
    if (!usb_host_device_path) {
1347
        perror("husb: USB Host Device Path not set");
1348
        goto the_end;
1349
    }
1350
    snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
1351
    f = fopen(line, "r");
1352
    if (!f) {
1353
        perror("husb: cannot open devices file");
1354
        goto the_end;
1355
    }
1356

    
1357
    device_count = 0;
1358
    bus_num = addr = class_id = product_id = vendor_id = 0;
1359
    speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */
1360
    for(;;) {
1361
        if (fgets(line, sizeof(line), f) == NULL) {
1362
            break;
1363
        }
1364
        if (strlen(line) > 0) {
1365
            line[strlen(line) - 1] = '\0';
1366
        }
1367
        if (line[0] == 'T' && line[1] == ':') {
1368
            if (device_count && (vendor_id || product_id)) {
1369
                /* New device.  Add the previously discovered device.  */
1370
                ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1371
                           product_id, product_name, speed);
1372
                if (ret) {
1373
                    goto the_end;
1374
                }
1375
            }
1376
            if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0) {
1377
                goto fail;
1378
            }
1379
            bus_num = atoi(buf);
1380
            if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) {
1381
                goto fail;
1382
            }
1383
            addr = atoi(buf);
1384
            if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0) {
1385
                goto fail;
1386
            }
1387
            if (!strcmp(buf, "5000")) {
1388
                speed = USB_SPEED_SUPER;
1389
            } else if (!strcmp(buf, "480")) {
1390
                speed = USB_SPEED_HIGH;
1391
            } else if (!strcmp(buf, "1.5")) {
1392
                speed = USB_SPEED_LOW;
1393
            } else {
1394
                speed = USB_SPEED_FULL;
1395
            }
1396
            product_name[0] = '\0';
1397
            class_id = 0xff;
1398
            device_count++;
1399
            product_id = 0;
1400
            vendor_id = 0;
1401
        } else if (line[0] == 'P' && line[1] == ':') {
1402
            if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0) {
1403
                goto fail;
1404
            }
1405
            vendor_id = strtoul(buf, NULL, 16);
1406
            if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0) {
1407
                goto fail;
1408
            }
1409
            product_id = strtoul(buf, NULL, 16);
1410
        } else if (line[0] == 'S' && line[1] == ':') {
1411
            if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0) {
1412
                goto fail;
1413
            }
1414
            pstrcpy(product_name, sizeof(product_name), buf);
1415
        } else if (line[0] == 'D' && line[1] == ':') {
1416
            if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0) {
1417
                goto fail;
1418
            }
1419
            class_id = strtoul(buf, NULL, 16);
1420
        }
1421
    fail: ;
1422
    }
1423
    if (device_count && (vendor_id || product_id)) {
1424
        /* Add the last device.  */
1425
        ret = func(opaque, bus_num, addr, 0, class_id, vendor_id,
1426
                   product_id, product_name, speed);
1427
    }
1428
 the_end:
1429
    if (f) {
1430
        fclose(f);
1431
    }
1432
    return ret;
1433
}
1434

    
1435
/*
1436
 * Read sys file-system device file
1437
 *
1438
 * @line address of buffer to put file contents in
1439
 * @line_size size of line
1440
 * @device_file path to device file (printf format string)
1441
 * @device_name device being opened (inserted into device_file)
1442
 *
1443
 * @return 0 failed, 1 succeeded ('line' contains data)
1444
 */
1445
static int usb_host_read_file(char *line, size_t line_size,
1446
                              const char *device_file, const char *device_name)
1447
{
1448
    FILE *f;
1449
    int ret = 0;
1450
    char filename[PATH_MAX];
1451

    
1452
    snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
1453
             device_file);
1454
    f = fopen(filename, "r");
1455
    if (f) {
1456
        ret = fgets(line, line_size, f) != NULL;
1457
        fclose(f);
1458
    }
1459

    
1460
    return ret;
1461
}
1462

    
1463
/*
1464
 * Use /sys/bus/usb/devices/ directory to determine host's USB
1465
 * devices.
1466
 *
1467
 * This code is based on Robert Schiele's original patches posted to
1468
 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1469
 */
1470
static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
1471
{
1472
    DIR *dir = NULL;
1473
    char line[1024];
1474
    int bus_num, addr, speed, class_id, product_id, vendor_id;
1475
    int ret = 0;
1476
    char port[MAX_PORTLEN];
1477
    char product_name[512];
1478
    struct dirent *de;
1479

    
1480
    dir = opendir(USBSYSBUS_PATH "/devices");
1481
    if (!dir) {
1482
        perror("husb: cannot open devices directory");
1483
        goto the_end;
1484
    }
1485

    
1486
    while ((de = readdir(dir))) {
1487
        if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1488
            if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1489
                continue;
1490
            }
1491

    
1492
            if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1493
                goto the_end;
1494
            }
1495
            if (sscanf(line, "%d", &addr) != 1) {
1496
                goto the_end;
1497
            }
1498
            if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1499
                                    de->d_name)) {
1500
                goto the_end;
1501
            }
1502
            if (sscanf(line, "%x", &class_id) != 1) {
1503
                goto the_end;
1504
            }
1505

    
1506
            if (!usb_host_read_file(line, sizeof(line), "idVendor",
1507
                                    de->d_name)) {
1508
                goto the_end;
1509
            }
1510
            if (sscanf(line, "%x", &vendor_id) != 1) {
1511
                goto the_end;
1512
            }
1513
            if (!usb_host_read_file(line, sizeof(line), "idProduct",
1514
                                    de->d_name)) {
1515
                goto the_end;
1516
            }
1517
            if (sscanf(line, "%x", &product_id) != 1) {
1518
                goto the_end;
1519
            }
1520
            if (!usb_host_read_file(line, sizeof(line), "product",
1521
                                    de->d_name)) {
1522
                *product_name = 0;
1523
            } else {
1524
                if (strlen(line) > 0) {
1525
                    line[strlen(line) - 1] = '\0';
1526
                }
1527
                pstrcpy(product_name, sizeof(product_name), line);
1528
            }
1529

    
1530
            if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1531
                goto the_end;
1532
            }
1533
            if (!strcmp(line, "5000\n")) {
1534
                speed = USB_SPEED_SUPER;
1535
            } else if (!strcmp(line, "480\n")) {
1536
                speed = USB_SPEED_HIGH;
1537
            } else if (!strcmp(line, "1.5\n")) {
1538
                speed = USB_SPEED_LOW;
1539
            } else {
1540
                speed = USB_SPEED_FULL;
1541
            }
1542

    
1543
            ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1544
                       product_id, product_name, speed);
1545
            if (ret) {
1546
                goto the_end;
1547
            }
1548
        }
1549
    }
1550
 the_end:
1551
    if (dir) {
1552
        closedir(dir);
1553
    }
1554
    return ret;
1555
}
1556

    
1557
/*
1558
 * Determine how to access the host's USB devices and call the
1559
 * specific support function.
1560
 */
1561
static int usb_host_scan(void *opaque, USBScanFunc *func)
1562
{
1563
    Monitor *mon = cur_mon;
1564
    FILE *f = NULL;
1565
    DIR *dir = NULL;
1566
    int ret = 0;
1567
    const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
1568
    char devpath[PATH_MAX];
1569

    
1570
    /* only check the host once */
1571
    if (!usb_fs_type) {
1572
        dir = opendir(USBSYSBUS_PATH "/devices");
1573
        if (dir) {
1574
            /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
1575
            strcpy(devpath, USBDEVBUS_PATH);
1576
            usb_fs_type = USB_FS_SYS;
1577
            closedir(dir);
1578
            DPRINTF(USBDBG_DEVOPENED, USBSYSBUS_PATH);
1579
            goto found_devices;
1580
        }
1581
        f = fopen(USBPROCBUS_PATH "/devices", "r");
1582
        if (f) {
1583
            /* devices found in /proc/bus/usb/ */
1584
            strcpy(devpath, USBPROCBUS_PATH);
1585
            usb_fs_type = USB_FS_PROC;
1586
            fclose(f);
1587
            DPRINTF(USBDBG_DEVOPENED, USBPROCBUS_PATH);
1588
            goto found_devices;
1589
        }
1590
        /* try additional methods if an access method hasn't been found yet */
1591
        f = fopen(USBDEVBUS_PATH "/devices", "r");
1592
        if (f) {
1593
            /* devices found in /dev/bus/usb/ */
1594
            strcpy(devpath, USBDEVBUS_PATH);
1595
            usb_fs_type = USB_FS_DEV;
1596
            fclose(f);
1597
            DPRINTF(USBDBG_DEVOPENED, USBDEVBUS_PATH);
1598
            goto found_devices;
1599
        }
1600
    found_devices:
1601
        if (!usb_fs_type) {
1602
            if (mon) {
1603
                monitor_printf(mon, "husb: unable to access USB devices\n");
1604
            }
1605
            return -ENOENT;
1606
        }
1607

    
1608
        /* the module setting (used later for opening devices) */
1609
        usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
1610
        strcpy(usb_host_device_path, devpath);
1611
        if (mon) {
1612
            monitor_printf(mon, "husb: using %s file-system with %s\n",
1613
                           fs_type[usb_fs_type], usb_host_device_path);
1614
        }
1615
    }
1616

    
1617
    switch (usb_fs_type) {
1618
    case USB_FS_PROC:
1619
    case USB_FS_DEV:
1620
        ret = usb_host_scan_dev(opaque, func);
1621
        break;
1622
    case USB_FS_SYS:
1623
        ret = usb_host_scan_sys(opaque, func);
1624
        break;
1625
    default:
1626
        ret = -EINVAL;
1627
        break;
1628
    }
1629
    return ret;
1630
}
1631

    
1632
static QEMUTimer *usb_auto_timer;
1633

    
1634
static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port,
1635
                              int class_id, int vendor_id, int product_id,
1636
                              const char *product_name, int speed)
1637
{
1638
    struct USBAutoFilter *f;
1639
    struct USBHostDevice *s;
1640

    
1641
    /* Ignore hubs */
1642
    if (class_id == 9)
1643
        return 0;
1644

    
1645
    QTAILQ_FOREACH(s, &hostdevs, next) {
1646
        f = &s->match;
1647

    
1648
        if (f->bus_num > 0 && f->bus_num != bus_num) {
1649
            continue;
1650
        }
1651
        if (f->addr > 0 && f->addr != addr) {
1652
            continue;
1653
        }
1654
        if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1655
            continue;
1656
        }
1657

    
1658
        if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1659
            continue;
1660
        }
1661

    
1662
        if (f->product_id > 0 && f->product_id != product_id) {
1663
            continue;
1664
        }
1665
        /* We got a match */
1666

    
1667
        /* Already attached ? */
1668
        if (s->fd != -1) {
1669
            return 0;
1670
        }
1671
        DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1672

    
1673
        usb_host_open(s, bus_num, addr, port, product_name, speed);
1674
    }
1675

    
1676
    return 0;
1677
}
1678

    
1679
static void usb_host_auto_check(void *unused)
1680
{
1681
    struct USBHostDevice *s;
1682
    int unconnected = 0;
1683

    
1684
    usb_host_scan(NULL, usb_host_auto_scan);
1685

    
1686
    QTAILQ_FOREACH(s, &hostdevs, next) {
1687
        if (s->fd == -1) {
1688
            unconnected++;
1689
        }
1690
    }
1691

    
1692
    if (unconnected == 0) {
1693
        /* nothing to watch */
1694
        if (usb_auto_timer) {
1695
            qemu_del_timer(usb_auto_timer);
1696
        }
1697
        return;
1698
    }
1699

    
1700
    if (!usb_auto_timer) {
1701
        usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1702
        if (!usb_auto_timer) {
1703
            return;
1704
        }
1705
    }
1706
    qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1707
}
1708

    
1709
/*
1710
 * Autoconnect filter
1711
 * Format:
1712
 *    auto:bus:dev[:vid:pid]
1713
 *    auto:bus.dev[:vid:pid]
1714
 *
1715
 *    bus  - bus number    (dec, * means any)
1716
 *    dev  - device number (dec, * means any)
1717
 *    vid  - vendor id     (hex, * means any)
1718
 *    pid  - product id    (hex, * means any)
1719
 *
1720
 *    See 'lsusb' output.
1721
 */
1722
static int parse_filter(const char *spec, struct USBAutoFilter *f)
1723
{
1724
    enum { BUS, DEV, VID, PID, DONE };
1725
    const char *p = spec;
1726
    int i;
1727

    
1728
    f->bus_num    = 0;
1729
    f->addr       = 0;
1730
    f->vendor_id  = 0;
1731
    f->product_id = 0;
1732

    
1733
    for (i = BUS; i < DONE; i++) {
1734
        p = strpbrk(p, ":.");
1735
        if (!p) {
1736
            break;
1737
        }
1738
        p++;
1739

    
1740
        if (*p == '*') {
1741
            continue;
1742
        }
1743
        switch(i) {
1744
        case BUS: f->bus_num = strtol(p, NULL, 10);    break;
1745
        case DEV: f->addr    = strtol(p, NULL, 10);    break;
1746
        case VID: f->vendor_id  = strtol(p, NULL, 16); break;
1747
        case PID: f->product_id = strtol(p, NULL, 16); break;
1748
        }
1749
    }
1750

    
1751
    if (i < DEV) {
1752
        fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1753
        return -1;
1754
    }
1755

    
1756
    return 0;
1757
}
1758

    
1759
/**********************/
1760
/* USB host device info */
1761

    
1762
struct usb_class_info {
1763
    int class;
1764
    const char *class_name;
1765
};
1766

    
1767
static const struct usb_class_info usb_class_info[] = {
1768
    { USB_CLASS_AUDIO, "Audio"},
1769
    { USB_CLASS_COMM, "Communication"},
1770
    { USB_CLASS_HID, "HID"},
1771
    { USB_CLASS_HUB, "Hub" },
1772
    { USB_CLASS_PHYSICAL, "Physical" },
1773
    { USB_CLASS_PRINTER, "Printer" },
1774
    { USB_CLASS_MASS_STORAGE, "Storage" },
1775
    { USB_CLASS_CDC_DATA, "Data" },
1776
    { USB_CLASS_APP_SPEC, "Application Specific" },
1777
    { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1778
    { USB_CLASS_STILL_IMAGE, "Still Image" },
1779
    { USB_CLASS_CSCID, "Smart Card" },
1780
    { USB_CLASS_CONTENT_SEC, "Content Security" },
1781
    { -1, NULL }
1782
};
1783

    
1784
static const char *usb_class_str(uint8_t class)
1785
{
1786
    const struct usb_class_info *p;
1787
    for(p = usb_class_info; p->class != -1; p++) {
1788
        if (p->class == class) {
1789
            break;
1790
        }
1791
    }
1792
    return p->class_name;
1793
}
1794

    
1795
static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port,
1796
                            int class_id, int vendor_id, int product_id,
1797
                            const char *product_name,
1798
                            int speed)
1799
{
1800
    const char *class_str, *speed_str;
1801

    
1802
    switch(speed) {
1803
    case USB_SPEED_LOW:
1804
        speed_str = "1.5";
1805
        break;
1806
    case USB_SPEED_FULL:
1807
        speed_str = "12";
1808
        break;
1809
    case USB_SPEED_HIGH:
1810
        speed_str = "480";
1811
        break;
1812
    case USB_SPEED_SUPER:
1813
        speed_str = "5000";
1814
        break;
1815
    default:
1816
        speed_str = "?";
1817
        break;
1818
    }
1819

    
1820
    monitor_printf(mon, "  Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1821
                   bus_num, addr, port, speed_str);
1822
    class_str = usb_class_str(class_id);
1823
    if (class_str) {
1824
        monitor_printf(mon, "    %s:", class_str);
1825
    } else {
1826
        monitor_printf(mon, "    Class %02x:", class_id);
1827
    }
1828
    monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1829
    if (product_name[0] != '\0') {
1830
        monitor_printf(mon, ", %s", product_name);
1831
    }
1832
    monitor_printf(mon, "\n");
1833
}
1834

    
1835
static int usb_host_info_device(void *opaque, int bus_num, int addr,
1836
                                char *path, int class_id,
1837
                                int vendor_id, int product_id,
1838
                                const char *product_name,
1839
                                int speed)
1840
{
1841
    Monitor *mon = opaque;
1842

    
1843
    usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1844
                    product_name, speed);
1845
    return 0;
1846
}
1847

    
1848
static void dec2str(int val, char *str, size_t size)
1849
{
1850
    if (val == 0) {
1851
        snprintf(str, size, "*");
1852
    } else {
1853
        snprintf(str, size, "%d", val);
1854
    }
1855
}
1856

    
1857
static void hex2str(int val, char *str, size_t size)
1858
{
1859
    if (val == 0) {
1860
        snprintf(str, size, "*");
1861
    } else {
1862
        snprintf(str, size, "%04x", val);
1863
    }
1864
}
1865

    
1866
void usb_host_info(Monitor *mon)
1867
{
1868
    struct USBAutoFilter *f;
1869
    struct USBHostDevice *s;
1870

    
1871
    usb_host_scan(mon, usb_host_info_device);
1872

    
1873
    if (QTAILQ_EMPTY(&hostdevs)) {
1874
        return;
1875
    }
1876

    
1877
    monitor_printf(mon, "  Auto filters:\n");
1878
    QTAILQ_FOREACH(s, &hostdevs, next) {
1879
        char bus[10], addr[10], vid[10], pid[10];
1880
        f = &s->match;
1881
        dec2str(f->bus_num, bus, sizeof(bus));
1882
        dec2str(f->addr, addr, sizeof(addr));
1883
        hex2str(f->vendor_id, vid, sizeof(vid));
1884
        hex2str(f->product_id, pid, sizeof(pid));
1885
        monitor_printf(mon, "    Bus %s, Addr %s, Port %s, ID %s:%s\n",
1886
                       bus, addr, f->port ? f->port : "*", vid, pid);
1887
    }
1888
}