← Back to branch summary

~fboudra/qemu-linaro/new-upstream-release-1.2.0-2012.09-0ubuntu1

« back to all changes in this revision

Viewing changes to hw/usb-hub.c

  • Committer: Fathi Boudra
  • Author(s): Fathi Boudra
  • Date: 2012-08-21 06:47:11 UTC
  • mfrom: (0.1.16)
  • Revision ID: fathi.boudra@linaro.org-20120821064711-7yxmubp2v8a44xce
Tags: 1.1.50-2012.08-0ubuntu1
https://launchpad.net/bugs/1030588
https://launchpad.net/bugs/1030594
* New upstream release.
  - support emulated systems with more than 2G of memory. (LP: #1030588)
* Drop powerpc-missing-include.patch - merged upstream.
* Update debian/control: 
  - drop perl build dependency.
  - add libfdt-dev build dependency.
* Update debian/qemu-keymaps.install file.
* Update debian/rules:
  - update QEMU_CPU for ARM architecture: armv4l -> armv7l.
  - update conf_audio_drv: default to PulseAudio since PA is the default on
    Ubuntu.
  - enable KVM on ARM architecture.
  - enable flat device tree support (--enable-fdt). (LP: #1030594)

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/usb-hub.c
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
 
    USBEndpoint *intr;
41
 
    USBHubPort ports[NUM_PORTS];
42
 
} USBHubState;
43
 
 
44
 
#define ClearHubFeature         (0x2000 | USB_REQ_CLEAR_FEATURE)
45
 
#define ClearPortFeature        (0x2300 | USB_REQ_CLEAR_FEATURE)
46
 
#define GetHubDescriptor        (0xa000 | USB_REQ_GET_DESCRIPTOR)
47
 
#define GetHubStatus            (0xa000 | USB_REQ_GET_STATUS)
48
 
#define GetPortStatus           (0xa300 | USB_REQ_GET_STATUS)
49
 
#define SetHubFeature           (0x2000 | USB_REQ_SET_FEATURE)
50
 
#define SetPortFeature          (0x2300 | USB_REQ_SET_FEATURE)
51
 
 
52
 
#define PORT_STAT_CONNECTION    0x0001
53
 
#define PORT_STAT_ENABLE        0x0002
54
 
#define PORT_STAT_SUSPEND       0x0004
55
 
#define PORT_STAT_OVERCURRENT   0x0008
56
 
#define PORT_STAT_RESET         0x0010
57
 
#define PORT_STAT_POWER         0x0100
58
 
#define PORT_STAT_LOW_SPEED     0x0200
59
 
#define PORT_STAT_HIGH_SPEED    0x0400
60
 
#define PORT_STAT_TEST          0x0800
61
 
#define PORT_STAT_INDICATOR     0x1000
62
 
 
63
 
#define PORT_STAT_C_CONNECTION  0x0001
64
 
#define PORT_STAT_C_ENABLE      0x0002
65
 
#define PORT_STAT_C_SUSPEND     0x0004
66
 
#define PORT_STAT_C_OVERCURRENT 0x0008
67
 
#define PORT_STAT_C_RESET       0x0010
68
 
 
69
 
#define PORT_CONNECTION         0
70
 
#define PORT_ENABLE             1
71
 
#define PORT_SUSPEND            2
72
 
#define PORT_OVERCURRENT        3
73
 
#define PORT_RESET              4
74
 
#define PORT_POWER              8
75
 
#define PORT_LOWSPEED           9
76
 
#define PORT_HIGHSPEED          10
77
 
#define PORT_C_CONNECTION       16
78
 
#define PORT_C_ENABLE           17
79
 
#define PORT_C_SUSPEND          18
80
 
#define PORT_C_OVERCURRENT      19
81
 
#define PORT_C_RESET            20
82
 
#define PORT_TEST               21
83
 
#define PORT_INDICATOR          22
84
 
 
85
 
/* same as Linux kernel root hubs */
86
 
 
87
 
enum {
88
 
    STR_MANUFACTURER = 1,
89
 
    STR_PRODUCT,
90
 
    STR_SERIALNUMBER,
91
 
};
92
 
 
93
 
static const USBDescStrings desc_strings = {
94
 
    [STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
95
 
    [STR_PRODUCT]      = "QEMU USB Hub",
96
 
    [STR_SERIALNUMBER] = "314159",
97
 
};
98
 
 
99
 
static const USBDescIface desc_iface_hub = {
100
 
    .bInterfaceNumber              = 0,
101
 
    .bNumEndpoints                 = 1,
102
 
    .bInterfaceClass               = USB_CLASS_HUB,
103
 
    .eps = (USBDescEndpoint[]) {
104
 
        {
105
 
            .bEndpointAddress      = USB_DIR_IN | 0x01,
106
 
            .bmAttributes          = USB_ENDPOINT_XFER_INT,
107
 
            .wMaxPacketSize        = 1 + (NUM_PORTS + 7) / 8,
108
 
            .bInterval             = 0xff,
109
 
        },
110
 
    }
111
 
};
112
 
 
113
 
static const USBDescDevice desc_device_hub = {
114
 
    .bcdUSB                        = 0x0110,
115
 
    .bDeviceClass                  = USB_CLASS_HUB,
116
 
    .bMaxPacketSize0               = 8,
117
 
    .bNumConfigurations            = 1,
118
 
    .confs = (USBDescConfig[]) {
119
 
        {
120
 
            .bNumInterfaces        = 1,
121
 
            .bConfigurationValue   = 1,
122
 
            .bmAttributes          = 0xe0,
123
 
            .nif = 1,
124
 
            .ifs = &desc_iface_hub,
125
 
        },
126
 
    },
127
 
};
128
 
 
129
 
static const USBDesc desc_hub = {
130
 
    .id = {
131
 
        .idVendor          = 0x0409,
132
 
        .idProduct         = 0x55aa,
133
 
        .bcdDevice         = 0x0101,
134
 
        .iManufacturer     = STR_MANUFACTURER,
135
 
        .iProduct          = STR_PRODUCT,
136
 
        .iSerialNumber     = STR_SERIALNUMBER,
137
 
    },
138
 
    .full = &desc_device_hub,
139
 
    .str  = desc_strings,
140
 
};
141
 
 
142
 
static const uint8_t qemu_hub_hub_descriptor[] =
143
 
{
144
 
        0x00,                   /*  u8  bLength; patched in later */
145
 
        0x29,                   /*  u8  bDescriptorType; Hub-descriptor */
146
 
        0x00,                   /*  u8  bNbrPorts; (patched later) */
147
 
        0x0a,                   /* u16  wHubCharacteristics; */
148
 
        0x00,                   /*   (per-port OC, no power switching) */
149
 
        0x01,                   /*  u8  bPwrOn2pwrGood; 2ms */
150
 
        0x00                    /*  u8  bHubContrCurrent; 0 mA */
151
 
 
152
 
        /* DeviceRemovable and PortPwrCtrlMask patched in later */
153
 
};
154
 
 
155
 
static void usb_hub_attach(USBPort *port1)
156
 
{
157
 
    USBHubState *s = port1->opaque;
158
 
    USBHubPort *port = &s->ports[port1->index];
159
 
 
160
 
    port->wPortStatus |= PORT_STAT_CONNECTION;
161
 
    port->wPortChange |= PORT_STAT_C_CONNECTION;
162
 
    if (port->port.dev->speed == USB_SPEED_LOW) {
163
 
        port->wPortStatus |= PORT_STAT_LOW_SPEED;
164
 
    } else {
165
 
        port->wPortStatus &= ~PORT_STAT_LOW_SPEED;
166
 
    }
167
 
    usb_wakeup(s->intr);
168
 
}
169
 
 
170
 
static void usb_hub_detach(USBPort *port1)
171
 
{
172
 
    USBHubState *s = port1->opaque;
173
 
    USBHubPort *port = &s->ports[port1->index];
174
 
 
175
 
    usb_wakeup(s->intr);
176
 
 
177
 
    /* Let upstream know the device on this port is gone */
178
 
    s->dev.port->ops->child_detach(s->dev.port, port1->dev);
179
 
 
180
 
    port->wPortStatus &= ~PORT_STAT_CONNECTION;
181
 
    port->wPortChange |= PORT_STAT_C_CONNECTION;
182
 
    if (port->wPortStatus & PORT_STAT_ENABLE) {
183
 
        port->wPortStatus &= ~PORT_STAT_ENABLE;
184
 
        port->wPortChange |= PORT_STAT_C_ENABLE;
185
 
    }
186
 
}
187
 
 
188
 
static void usb_hub_child_detach(USBPort *port1, USBDevice *child)
189
 
{
190
 
    USBHubState *s = port1->opaque;
191
 
 
192
 
    /* Pass along upstream */
193
 
    s->dev.port->ops->child_detach(s->dev.port, child);
194
 
}
195
 
 
196
 
static void usb_hub_wakeup(USBPort *port1)
197
 
{
198
 
    USBHubState *s = port1->opaque;
199
 
    USBHubPort *port = &s->ports[port1->index];
200
 
 
201
 
    if (port->wPortStatus & PORT_STAT_SUSPEND) {
202
 
        port->wPortChange |= PORT_STAT_C_SUSPEND;
203
 
        usb_wakeup(s->intr);
204
 
    }
205
 
}
206
 
 
207
 
static void usb_hub_complete(USBPort *port, USBPacket *packet)
208
 
{
209
 
    USBHubState *s = port->opaque;
210
 
 
211
 
    /*
212
 
     * Just pass it along upstream for now.
213
 
     *
214
 
     * If we ever implement usb 2.0 split transactions this will
215
 
     * become a little more complicated ...
216
 
     *
217
 
     * Can't use usb_packet_complete() here because packet->owner is
218
 
     * cleared already, go call the ->complete() callback directly
219
 
     * instead.
220
 
     */
221
 
    s->dev.port->ops->complete(s->dev.port, packet);
222
 
}
223
 
 
224
 
static USBDevice *usb_hub_find_device(USBDevice *dev, uint8_t addr)
225
 
{
226
 
    USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
227
 
    USBHubPort *port;
228
 
    USBDevice *downstream;
229
 
    int i;
230
 
 
231
 
    for (i = 0; i < NUM_PORTS; i++) {
232
 
        port = &s->ports[i];
233
 
        if (!(port->wPortStatus & PORT_STAT_ENABLE)) {
234
 
            continue;
235
 
        }
236
 
        downstream = usb_find_device(&port->port, addr);
237
 
        if (downstream != NULL) {
238
 
            return downstream;
239
 
        }
240
 
    }
241
 
    return NULL;
242
 
}
243
 
 
244
 
static void usb_hub_handle_reset(USBDevice *dev)
245
 
{
246
 
    USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
247
 
    USBHubPort *port;
248
 
    int i;
249
 
 
250
 
    for (i = 0; i < NUM_PORTS; i++) {
251
 
        port = s->ports + i;
252
 
        port->wPortStatus = PORT_STAT_POWER;
253
 
        port->wPortChange = 0;
254
 
        if (port->port.dev && port->port.dev->attached) {
255
 
            port->wPortStatus |= PORT_STAT_CONNECTION;
256
 
            port->wPortChange |= PORT_STAT_C_CONNECTION;
257
 
            if (port->port.dev->speed == USB_SPEED_LOW) {
258
 
                port->wPortStatus |= PORT_STAT_LOW_SPEED;
259
 
            }
260
 
        }
261
 
    }
262
 
}
263
 
 
264
 
static int usb_hub_handle_control(USBDevice *dev, USBPacket *p,
265
 
               int request, int value, int index, int length, uint8_t *data)
266
 
{
267
 
    USBHubState *s = (USBHubState *)dev;
268
 
    int ret;
269
 
 
270
 
    ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
271
 
    if (ret >= 0) {
272
 
        return ret;
273
 
    }
274
 
 
275
 
    switch(request) {
276
 
    case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
277
 
        if (value == 0 && index != 0x81) { /* clear ep halt */
278
 
            goto fail;
279
 
        }
280
 
        ret = 0;
281
 
        break;
282
 
        /* usb specific requests */
283
 
    case GetHubStatus:
284
 
        data[0] = 0;
285
 
        data[1] = 0;
286
 
        data[2] = 0;
287
 
        data[3] = 0;
288
 
        ret = 4;
289
 
        break;
290
 
    case GetPortStatus:
291
 
        {
292
 
            unsigned int n = index - 1;
293
 
            USBHubPort *port;
294
 
            if (n >= NUM_PORTS) {
295
 
                goto fail;
296
 
            }
297
 
            port = &s->ports[n];
298
 
            data[0] = port->wPortStatus;
299
 
            data[1] = port->wPortStatus >> 8;
300
 
            data[2] = port->wPortChange;
301
 
            data[3] = port->wPortChange >> 8;
302
 
            ret = 4;
303
 
        }
304
 
        break;
305
 
    case SetHubFeature:
306
 
    case ClearHubFeature:
307
 
        if (value == 0 || value == 1) {
308
 
        } else {
309
 
            goto fail;
310
 
        }
311
 
        ret = 0;
312
 
        break;
313
 
    case SetPortFeature:
314
 
        {
315
 
            unsigned int n = index - 1;
316
 
            USBHubPort *port;
317
 
            USBDevice *dev;
318
 
            if (n >= NUM_PORTS) {
319
 
                goto fail;
320
 
            }
321
 
            port = &s->ports[n];
322
 
            dev = port->port.dev;
323
 
            switch(value) {
324
 
            case PORT_SUSPEND:
325
 
                port->wPortStatus |= PORT_STAT_SUSPEND;
326
 
                break;
327
 
            case PORT_RESET:
328
 
                if (dev && dev->attached) {
329
 
                    usb_device_reset(dev);
330
 
                    port->wPortChange |= PORT_STAT_C_RESET;
331
 
                    /* set enable bit */
332
 
                    port->wPortStatus |= PORT_STAT_ENABLE;
333
 
                }
334
 
                break;
335
 
            case PORT_POWER:
336
 
                break;
337
 
            default:
338
 
                goto fail;
339
 
            }
340
 
            ret = 0;
341
 
        }
342
 
        break;
343
 
    case ClearPortFeature:
344
 
        {
345
 
            unsigned int n = index - 1;
346
 
            USBHubPort *port;
347
 
 
348
 
            if (n >= NUM_PORTS) {
349
 
                goto fail;
350
 
            }
351
 
            port = &s->ports[n];
352
 
            switch(value) {
353
 
            case PORT_ENABLE:
354
 
                port->wPortStatus &= ~PORT_STAT_ENABLE;
355
 
                break;
356
 
            case PORT_C_ENABLE:
357
 
                port->wPortChange &= ~PORT_STAT_C_ENABLE;
358
 
                break;
359
 
            case PORT_SUSPEND:
360
 
                port->wPortStatus &= ~PORT_STAT_SUSPEND;
361
 
                break;
362
 
            case PORT_C_SUSPEND:
363
 
                port->wPortChange &= ~PORT_STAT_C_SUSPEND;
364
 
                break;
365
 
            case PORT_C_CONNECTION:
366
 
                port->wPortChange &= ~PORT_STAT_C_CONNECTION;
367
 
                break;
368
 
            case PORT_C_OVERCURRENT:
369
 
                port->wPortChange &= ~PORT_STAT_C_OVERCURRENT;
370
 
                break;
371
 
            case PORT_C_RESET:
372
 
                port->wPortChange &= ~PORT_STAT_C_RESET;
373
 
                break;
374
 
            default:
375
 
                goto fail;
376
 
            }
377
 
            ret = 0;
378
 
        }
379
 
        break;
380
 
    case GetHubDescriptor:
381
 
        {
382
 
            unsigned int n, limit, var_hub_size = 0;
383
 
            memcpy(data, qemu_hub_hub_descriptor,
384
 
                   sizeof(qemu_hub_hub_descriptor));
385
 
            data[2] = NUM_PORTS;
386
 
 
387
 
            /* fill DeviceRemovable bits */
388
 
            limit = ((NUM_PORTS + 1 + 7) / 8) + 7;
389
 
            for (n = 7; n < limit; n++) {
390
 
                data[n] = 0x00;
391
 
                var_hub_size++;
392
 
            }
393
 
 
394
 
            /* fill PortPwrCtrlMask bits */
395
 
            limit = limit + ((NUM_PORTS + 7) / 8);
396
 
            for (;n < limit; n++) {
397
 
                data[n] = 0xff;
398
 
                var_hub_size++;
399
 
            }
400
 
 
401
 
            ret = sizeof(qemu_hub_hub_descriptor) + var_hub_size;
402
 
            data[0] = ret;
403
 
            break;
404
 
        }
405
 
    default:
406
 
    fail:
407
 
        ret = USB_RET_STALL;
408
 
        break;
409
 
    }
410
 
    return ret;
411
 
}
412
 
 
413
 
static int usb_hub_handle_data(USBDevice *dev, USBPacket *p)
414
 
{
415
 
    USBHubState *s = (USBHubState *)dev;
416
 
    int ret;
417
 
 
418
 
    switch(p->pid) {
419
 
    case USB_TOKEN_IN:
420
 
        if (p->ep->nr == 1) {
421
 
            USBHubPort *port;
422
 
            unsigned int status;
423
 
            uint8_t buf[4];
424
 
            int i, n;
425
 
            n = (NUM_PORTS + 1 + 7) / 8;
426
 
            if (p->iov.size == 1) { /* FreeBSD workaround */
427
 
                n = 1;
428
 
            } else if (n > p->iov.size) {
429
 
                return USB_RET_BABBLE;
430
 
            }
431
 
            status = 0;
432
 
            for(i = 0; i < NUM_PORTS; i++) {
433
 
                port = &s->ports[i];
434
 
                if (port->wPortChange)
435
 
                    status |= (1 << (i + 1));
436
 
            }
437
 
            if (status != 0) {
438
 
                for(i = 0; i < n; i++) {
439
 
                    buf[i] = status >> (8 * i);
440
 
                }
441
 
                usb_packet_copy(p, buf, n);
442
 
                ret = n;
443
 
            } else {
444
 
                ret = USB_RET_NAK; /* usb11 11.13.1 */
445
 
            }
446
 
        } else {
447
 
            goto fail;
448
 
        }
449
 
        break;
450
 
    case USB_TOKEN_OUT:
451
 
    default:
452
 
    fail:
453
 
        ret = USB_RET_STALL;
454
 
        break;
455
 
    }
456
 
    return ret;
457
 
}
458
 
 
459
 
static void usb_hub_handle_destroy(USBDevice *dev)
460
 
{
461
 
    USBHubState *s = (USBHubState *)dev;
462
 
    int i;
463
 
 
464
 
    for (i = 0; i < NUM_PORTS; i++) {
465
 
        usb_unregister_port(usb_bus_from_device(dev),
466
 
                            &s->ports[i].port);
467
 
    }
468
 
}
469
 
 
470
 
static USBPortOps usb_hub_port_ops = {
471
 
    .attach = usb_hub_attach,
472
 
    .detach = usb_hub_detach,
473
 
    .child_detach = usb_hub_child_detach,
474
 
    .wakeup = usb_hub_wakeup,
475
 
    .complete = usb_hub_complete,
476
 
};
477
 
 
478
 
static int usb_hub_initfn(USBDevice *dev)
479
 
{
480
 
    USBHubState *s = DO_UPCAST(USBHubState, dev, dev);
481
 
    USBHubPort *port;
482
 
    int i;
483
 
 
484
 
    usb_desc_init(dev);
485
 
    s->intr = usb_ep_get(dev, USB_TOKEN_IN, 1);
486
 
    for (i = 0; i < NUM_PORTS; i++) {
487
 
        port = &s->ports[i];
488
 
        usb_register_port(usb_bus_from_device(dev),
489
 
                          &port->port, s, i, &usb_hub_port_ops,
490
 
                          USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL);
491
 
        usb_port_location(&port->port, dev->port, i+1);
492
 
    }
493
 
    usb_hub_handle_reset(dev);
494
 
    return 0;
495
 
}
496
 
 
497
 
static const VMStateDescription vmstate_usb_hub_port = {
498
 
    .name = "usb-hub-port",
499
 
    .version_id = 1,
500
 
    .minimum_version_id = 1,
501
 
    .fields = (VMStateField []) {
502
 
        VMSTATE_UINT16(wPortStatus, USBHubPort),
503
 
        VMSTATE_UINT16(wPortChange, USBHubPort),
504
 
        VMSTATE_END_OF_LIST()
505
 
    }
506
 
};
507
 
 
508
 
static const VMStateDescription vmstate_usb_hub = {
509
 
    .name = "usb-hub",
510
 
    .version_id = 1,
511
 
    .minimum_version_id = 1,
512
 
    .fields = (VMStateField []) {
513
 
        VMSTATE_USB_DEVICE(dev, USBHubState),
514
 
        VMSTATE_STRUCT_ARRAY(ports, USBHubState, NUM_PORTS, 0,
515
 
                             vmstate_usb_hub_port, USBHubPort),
516
 
        VMSTATE_END_OF_LIST()
517
 
    }
518
 
};
519
 
 
520
 
static void usb_hub_class_initfn(ObjectClass *klass, void *data)
521
 
{
522
 
    DeviceClass *dc = DEVICE_CLASS(klass);
523
 
    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
524
 
 
525
 
    uc->init           = usb_hub_initfn;
526
 
    uc->product_desc   = "QEMU USB Hub";
527
 
    uc->usb_desc       = &desc_hub;
528
 
    uc->find_device    = usb_hub_find_device;
529
 
    uc->handle_reset   = usb_hub_handle_reset;
530
 
    uc->handle_control = usb_hub_handle_control;
531
 
    uc->handle_data    = usb_hub_handle_data;
532
 
    uc->handle_destroy = usb_hub_handle_destroy;
533
 
    dc->fw_name = "hub";
534
 
    dc->vmsd = &vmstate_usb_hub;
535
 
}
536
 
 
537
 
static TypeInfo hub_info = {
538
 
    .name          = "usb-hub",
539
 
    .parent        = TYPE_USB_DEVICE,
540
 
    .instance_size = sizeof(USBHubState),
541
 
    .class_init    = usb_hub_class_initfn,
542
 
};
543
 
 
544
 
static void usb_hub_register_types(void)
545
 
{
546
 
    type_register_static(&hub_info);
547
 
}
548
 
 
549
 
type_init(usb_hub_register_types)