Statistics
| Branch: | Revision:

root / hw / usb-hub.c @ 079d0b7f

History | View | Annotate | Download (15.4 kB)

1
/*
2
 * QEMU USB HUB emulation
3
 *
4
 * Copyright (c) 2005 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include "qemu-common.h"
25
#include "usb.h"
26
#include "usb-desc.h"
27

    
28
//#define DEBUG
29

    
30
#define NUM_PORTS 8
31

    
32
typedef struct USBHubPort {
33
    USBPort port;
34
    uint16_t wPortStatus;
35
    uint16_t wPortChange;
36
} USBHubPort;
37

    
38
typedef struct USBHubState {
39
    USBDevice dev;
40
    USBHubPort ports[NUM_PORTS];
41
} USBHubState;
42

    
43
#define ClearHubFeature                (0x2000 | USB_REQ_CLEAR_FEATURE)
44
#define ClearPortFeature        (0x2300 | USB_REQ_CLEAR_FEATURE)
45
#define GetHubDescriptor        (0xa000 | USB_REQ_GET_DESCRIPTOR)
46
#define GetHubStatus                (0xa000 | USB_REQ_GET_STATUS)
47
#define GetPortStatus                (0xa300 | USB_REQ_GET_STATUS)
48
#define SetHubFeature                (0x2000 | USB_REQ_SET_FEATURE)
49
#define SetPortFeature                (0x2300 | USB_REQ_SET_FEATURE)
50

    
51
#define PORT_STAT_CONNECTION        0x0001
52
#define PORT_STAT_ENABLE        0x0002
53
#define PORT_STAT_SUSPEND        0x0004
54
#define PORT_STAT_OVERCURRENT        0x0008
55
#define PORT_STAT_RESET                0x0010
56
#define PORT_STAT_POWER                0x0100
57
#define PORT_STAT_LOW_SPEED        0x0200
58
#define PORT_STAT_HIGH_SPEED    0x0400
59
#define PORT_STAT_TEST          0x0800
60
#define PORT_STAT_INDICATOR     0x1000
61

    
62
#define PORT_STAT_C_CONNECTION        0x0001
63
#define PORT_STAT_C_ENABLE        0x0002
64
#define PORT_STAT_C_SUSPEND        0x0004
65
#define PORT_STAT_C_OVERCURRENT        0x0008
66
#define PORT_STAT_C_RESET        0x0010
67

    
68
#define PORT_CONNECTION                0
69
#define PORT_ENABLE                1
70
#define PORT_SUSPEND                2
71
#define PORT_OVERCURRENT        3
72
#define PORT_RESET                4
73
#define PORT_POWER                8
74
#define PORT_LOWSPEED                9
75
#define PORT_HIGHSPEED                10
76
#define PORT_C_CONNECTION        16
77
#define PORT_C_ENABLE                17
78
#define PORT_C_SUSPEND                18
79
#define PORT_C_OVERCURRENT        19
80
#define PORT_C_RESET                20
81
#define PORT_TEST               21
82
#define PORT_INDICATOR          22
83

    
84
/* same as Linux kernel root hubs */
85

    
86
enum {
87
    STR_MANUFACTURER = 1,
88
    STR_PRODUCT,
89
    STR_SERIALNUMBER,
90
};
91

    
92
static const USBDescStrings desc_strings = {
93
    [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
94
    [STR_PRODUCT]      = "QEMU USB Hub",
95
    [STR_SERIALNUMBER] = "314159",
96
};
97

    
98
static const USBDescIface desc_iface_hub = {
99
    .bInterfaceNumber              = 0,
100
    .bNumEndpoints                 = 1,
101
    .bInterfaceClass               = USB_CLASS_HUB,
102
    .eps = (USBDescEndpoint[]) {
103
        {
104
            .bEndpointAddress      = USB_DIR_IN | 0x01,
105
            .bmAttributes          = USB_ENDPOINT_XFER_INT,
106
            .wMaxPacketSize        = 1 + (NUM_PORTS + 7) / 8,
107
            .bInterval             = 0xff,
108
        },
109
    }
110
};
111

    
112
static const USBDescDevice desc_device_hub = {
113
    .bcdUSB                        = 0x0110,
114
    .bDeviceClass                  = USB_CLASS_HUB,
115
    .bMaxPacketSize0               = 8,
116
    .bNumConfigurations            = 1,
117
    .confs = (USBDescConfig[]) {
118
        {
119
            .bNumInterfaces        = 1,
120
            .bConfigurationValue   = 1,
121
            .bmAttributes          = 0xe0,
122
            .nif = 1,
123
            .ifs = &desc_iface_hub,
124
        },
125
    },
126
};
127

    
128
static const USBDesc desc_hub = {
129
    .id = {
130
        .idVendor          = 0x0409,
131
        .idProduct         = 0x55aa,
132
        .bcdDevice         = 0x0101,
133
        .iManufacturer     = STR_MANUFACTURER,
134
        .iProduct          = STR_PRODUCT,
135
        .iSerialNumber     = STR_SERIALNUMBER,
136
    },
137
    .full = &desc_device_hub,
138
    .str  = desc_strings,
139
};
140

    
141
static const uint8_t qemu_hub_hub_descriptor[] =
142
{
143
        0x00,                        /*  u8  bLength; patched in later */
144
        0x29,                        /*  u8  bDescriptorType; Hub-descriptor */
145
        0x00,                        /*  u8  bNbrPorts; (patched later) */
146
        0x0a,                        /* u16  wHubCharacteristics; */
147
        0x00,                        /*   (per-port OC, no power switching) */
148
        0x01,                        /*  u8  bPwrOn2pwrGood; 2ms */
149
        0x00                        /*  u8  bHubContrCurrent; 0 mA */
150

    
151
        /* DeviceRemovable and PortPwrCtrlMask patched in later */
152
};
153

    
154
static void usb_hub_attach(USBPort *port1)
155
{
156
    USBHubState *s = port1->opaque;
157
    USBHubPort *port = &s->ports[port1->index];
158

    
159
    port->wPortStatus |= PORT_STAT_CONNECTION;
160
    port->wPortChange |= PORT_STAT_C_CONNECTION;
161
    if (port->port.dev->speed == USB_SPEED_LOW) {
162
        port->wPortStatus |= PORT_STAT_LOW_SPEED;
163
    } else {
164
        port->wPortStatus &= ~PORT_STAT_LOW_SPEED;
165
    }
166
    usb_wakeup(&s->dev);
167
}
168

    
169
static void usb_hub_detach(USBPort *port1)
170
{
171
    USBHubState *s = port1->opaque;
172
    USBHubPort *port = &s->ports[port1->index];
173

    
174
    usb_wakeup(&s->dev);
175

    
176
    /* Let upstream know the device on this port is gone */
177
    s->dev.port->ops->child_detach(s->dev.port, port1->dev);
178

    
179
    port->wPortStatus &= ~PORT_STAT_CONNECTION;
180
    port->wPortChange |= PORT_STAT_C_CONNECTION;
181
    if (port->wPortStatus & PORT_STAT_ENABLE) {
182
        port->wPortStatus &= ~PORT_STAT_ENABLE;
183
        port->wPortChange |= PORT_STAT_C_ENABLE;
184
    }
185
}
186

    
187
static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
188
{
189
    USBHubState *s = port1->opaque;
190

    
191
    /* Pass along upstream */
192
    s->dev.port->ops->child_detach(s->dev.port, child);
193
}
194

    
195
static void usb_hub_wakeup(USBPort *port1)
196
{
197
    USBHubState *s = port1->opaque;
198
    USBHubPort *port = &s->ports[port1->index];
199

    
200
    if (port->wPortStatus & PORT_STAT_SUSPEND) {
201
        port->wPortChange |= PORT_STAT_C_SUSPEND;
202
        usb_wakeup(&s->dev);
203
    }
204
}
205

    
206
static void usb_hub_complete(USBPort *port, USBPacket *packet)
207
{
208
    USBHubState *s = port->opaque;
209

    
210
    /*
211
     * Just pass it along upstream for now.
212
     *
213
     * If we ever implement usb 2.0 split transactions this will
214
     * become a little more complicated ...
215
     *
216
     * Can't use usb_packet_complete() here because packet->owner is
217
     * cleared already, go call the ->complete() callback directly
218
     * instead.
219
     */
220
    s->dev.port->ops->complete(s->dev.port, packet);
221
}
222

    
223
static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
224
{
225
    USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
226
    USBHubPort *port;
227
    USBDevice *downstream;
228
    int i;
229

    
230
    for (i = 0; i < NUM_PORTS; i++) {
231
        port = &s->ports[i];
232
        if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
233
            continue;
234
        }
235
        downstream = usb_find_device(&port->port, addr);
236
        if (downstream != NULL) {
237
            return downstream;
238
        }
239
    }
240
    return NULL;
241
}
242

    
243
static void usb_hub_handle_reset(USBDevice *dev)
244
{
245
    USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
246
    USBHubPort *port;
247
    int i;
248

    
249
    for (i = 0; i < NUM_PORTS; i++) {
250
        port = s->ports + i;
251
        port->wPortStatus = PORT_STAT_POWER;
252
        port->wPortChange = 0;
253
        if (port->port.dev && port->port.dev->attached) {
254
            port->wPortStatus |= PORT_STAT_CONNECTION;
255
            port->wPortChange |= PORT_STAT_C_CONNECTION;
256
            if (port->port.dev->speed == USB_SPEED_LOW) {
257
                port->wPortStatus |= PORT_STAT_LOW_SPEED;
258
            }
259
        }
260
    }
261
}
262

    
263
static int usb_hub_handle_control(USBDevice *dev, USBPacket *p,
264
               int request, int value, int index, int length, uint8_t *data)
265
{
266
    USBHubState *s = (USBHubState *)dev;
267
    int ret;
268

    
269
    ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
270
    if (ret >= 0) {
271
        return ret;
272
    }
273

    
274
    switch(request) {
275
    case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
276
        if (value == 0 && index != 0x81) { /* clear ep halt */
277
            goto fail;
278
        }
279
        ret = 0;
280
        break;
281
        /* usb specific requests */
282
    case GetHubStatus:
283
        data[0] = 0;
284
        data[1] = 0;
285
        data[2] = 0;
286
        data[3] = 0;
287
        ret = 4;
288
        break;
289
    case GetPortStatus:
290
        {
291
            unsigned int n = index - 1;
292
            USBHubPort *port;
293
            if (n >= NUM_PORTS) {
294
                goto fail;
295
            }
296
            port = &s->ports[n];
297
            data[0] = port->wPortStatus;
298
            data[1] = port->wPortStatus >> 8;
299
            data[2] = port->wPortChange;
300
            data[3] = port->wPortChange >> 8;
301
            ret = 4;
302
        }
303
        break;
304
    case SetHubFeature:
305
    case ClearHubFeature:
306
        if (value == 0 || value == 1) {
307
        } else {
308
            goto fail;
309
        }
310
        ret = 0;
311
        break;
312
    case SetPortFeature:
313
        {
314
            unsigned int n = index - 1;
315
            USBHubPort *port;
316
            USBDevice *dev;
317
            if (n >= NUM_PORTS) {
318
                goto fail;
319
            }
320
            port = &s->ports[n];
321
            dev = port->port.dev;
322
            switch(value) {
323
            case PORT_SUSPEND:
324
                port->wPortStatus |= PORT_STAT_SUSPEND;
325
                break;
326
            case PORT_RESET:
327
                if (dev && dev->attached) {
328
                    usb_device_reset(dev);
329
                    port->wPortChange |= PORT_STAT_C_RESET;
330
                    /* set enable bit */
331
                    port->wPortStatus |= PORT_STAT_ENABLE;
332
                }
333
                break;
334
            case PORT_POWER:
335
                break;
336
            default:
337
                goto fail;
338
            }
339
            ret = 0;
340
        }
341
        break;
342
    case ClearPortFeature:
343
        {
344
            unsigned int n = index - 1;
345
            USBHubPort *port;
346

    
347
            if (n >= NUM_PORTS) {
348
                goto fail;
349
            }
350
            port = &s->ports[n];
351
            switch(value) {
352
            case PORT_ENABLE:
353
                port->wPortStatus &= ~PORT_STAT_ENABLE;
354
                break;
355
            case PORT_C_ENABLE:
356
                port->wPortChange &= ~PORT_STAT_C_ENABLE;
357
                break;
358
            case PORT_SUSPEND:
359
                port->wPortStatus &= ~PORT_STAT_SUSPEND;
360
                break;
361
            case PORT_C_SUSPEND:
362
                port->wPortChange &= ~PORT_STAT_C_SUSPEND;
363
                break;
364
            case PORT_C_CONNECTION:
365
                port->wPortChange &= ~PORT_STAT_C_CONNECTION;
366
                break;
367
            case PORT_C_OVERCURRENT:
368
                port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
369
                break;
370
            case PORT_C_RESET:
371
                port->wPortChange &= ~PORT_STAT_C_RESET;
372
                break;
373
            default:
374
                goto fail;
375
            }
376
            ret = 0;
377
        }
378
        break;
379
    case GetHubDescriptor:
380
        {
381
            unsigned int n, limit, var_hub_size = 0;
382
            memcpy(data, qemu_hub_hub_descriptor,
383
                   sizeof(qemu_hub_hub_descriptor));
384
            data[2] = NUM_PORTS;
385

    
386
            /* fill DeviceRemovable bits */
387
            limit = ((NUM_PORTS + 1 + 7) / 8) + 7;
388
            for (n = 7; n < limit; n++) {
389
                data[n] = 0x00;
390
                var_hub_size++;
391
            }
392

    
393
            /* fill PortPwrCtrlMask bits */
394
            limit = limit + ((NUM_PORTS + 7) / 8);
395
            for (;n < limit; n++) {
396
                data[n] = 0xff;
397
                var_hub_size++;
398
            }
399

    
400
            ret = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
401
            data[0] = ret;
402
            break;
403
        }
404
    default:
405
    fail:
406
        ret = USB_RET_STALL;
407
        break;
408
    }
409
    return ret;
410
}
411

    
412
static int usb_hub_handle_data(USBDevice *dev, USBPacket *p)
413
{
414
    USBHubState *s = (USBHubState *)dev;
415
    int ret;
416

    
417
    switch(p->pid) {
418
    case USB_TOKEN_IN:
419
        if (p->ep->nr == 1) {
420
            USBHubPort *port;
421
            unsigned int status;
422
            uint8_t buf[4];
423
            int i, n;
424
            n = (NUM_PORTS + 1 + 7) / 8;
425
            if (p->iov.size == 1) { /* FreeBSD workaround */
426
                n = 1;
427
            } else if (n > p->iov.size) {
428
                return USB_RET_BABBLE;
429
            }
430
            status = 0;
431
            for(i = 0; i < NUM_PORTS; i++) {
432
                port = &s->ports[i];
433
                if (port->wPortChange)
434
                    status |= (1 << (i + 1));
435
            }
436
            if (status != 0) {
437
                for(i = 0; i < n; i++) {
438
                    buf[i] = status >> (8 * i);
439
                }
440
                usb_packet_copy(p, buf, n);
441
                ret = n;
442
            } else {
443
                ret = USB_RET_NAK; /* usb11 11.13.1 */
444
            }
445
        } else {
446
            goto fail;
447
        }
448
        break;
449
    case USB_TOKEN_OUT:
450
    default:
451
    fail:
452
        ret = USB_RET_STALL;
453
        break;
454
    }
455
    return ret;
456
}
457

    
458
static void usb_hub_handle_destroy(USBDevice *dev)
459
{
460
    USBHubState *s = (USBHubState *)dev;
461
    int i;
462

    
463
    for (i = 0; i < NUM_PORTS; i++) {
464
        usb_unregister_port(usb_bus_from_device(dev),
465
                            &s->ports[i].port);
466
    }
467
}
468

    
469
static USBPortOps usb_hub_port_ops = {
470
    .attach = usb_hub_attach,
471
    .detach = usb_hub_detach,
472
    .child_detach = usb_hub_child_detach,
473
    .wakeup = usb_hub_wakeup,
474
    .complete = usb_hub_complete,
475
};
476

    
477
static int usb_hub_initfn(USBDevice *dev)
478
{
479
    USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
480
    USBHubPort *port;
481
    int i;
482

    
483
    usb_desc_init(dev);
484
    for (i = 0; i < NUM_PORTS; i++) {
485
        port = &s->ports[i];
486
        usb_register_port(usb_bus_from_device(dev),
487
                          &port->port, s, i, &usb_hub_port_ops,
488
                          USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
489
        usb_port_location(&port->port, dev->port, i+1);
490
    }
491
    usb_hub_handle_reset(dev);
492
    return 0;
493
}
494

    
495
static const VMStateDescription vmstate_usb_hub_port = {
496
    .name = "usb-hub-port",
497
    .version_id = 1,
498
    .minimum_version_id = 1,
499
    .fields = (VMStateField []) {
500
        VMSTATE_UINT16(wPortStatus, USBHubPort),
501
        VMSTATE_UINT16(wPortChange, USBHubPort),
502
        VMSTATE_END_OF_LIST()
503
    }
504
};
505

    
506
static const VMStateDescription vmstate_usb_hub = {
507
    .name = "usb-hub",
508
    .version_id = 1,
509
    .minimum_version_id = 1,
510
    .fields = (VMStateField []) {
511
        VMSTATE_USB_DEVICE(dev, USBHubState),
512
        VMSTATE_STRUCT_ARRAY(ports, USBHubState, NUM_PORTS, 0,
513
                             vmstate_usb_hub_port, USBHubPort),
514
        VMSTATE_END_OF_LIST()
515
    }
516
};
517

    
518
static void usb_hub_class_initfn(ObjectClass *klass, void *data)
519
{
520
    DeviceClass *dc = DEVICE_CLASS(klass);
521
    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
522

    
523
    uc->init           = usb_hub_initfn;
524
    uc->product_desc   = "QEMU USB Hub";
525
    uc->usb_desc       = &desc_hub;
526
    uc->find_device    = usb_hub_find_device;
527
    uc->handle_reset   = usb_hub_handle_reset;
528
    uc->handle_control = usb_hub_handle_control;
529
    uc->handle_data    = usb_hub_handle_data;
530
    uc->handle_destroy = usb_hub_handle_destroy;
531
    dc->fw_name = "hub";
532
    dc->vmsd = &vmstate_usb_hub;
533
}
534

    
535
static TypeInfo hub_info = {
536
    .name          = "usb-hub",
537
    .parent        = TYPE_USB_DEVICE,
538
    .instance_size = sizeof(USBHubState),
539
    .class_init    = usb_hub_class_initfn,
540
};
541

    
542
static void usb_hub_register_devices(void)
543
{
544
    type_register_static(&hub_info);
545
}
546
device_init(usb_hub_register_devices)