← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/1.6.1.patch/hw/usb/core.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/1.6.1.patch/hw/usb/core.c
 
1
/*
 
2
 * QEMU USB emulation
 
3
 *
 
4
 * Copyright (c) 2005 Fabrice Bellard
 
5
 *
 
6
 * 2008 Generic packet handler rewrite by Max Krasnyansky
 
7
 *
 
8
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
9
 * of this software and associated documentation files (the "Software"), to deal
 
10
 * in the Software without restriction, including without limitation the rights
 
11
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
12
 * copies of the Software, and to permit persons to whom the Software is
 
13
 * furnished to do so, subject to the following conditions:
 
14
 *
 
15
 * The above copyright notice and this permission notice shall be included in
 
16
 * all copies or substantial portions of the Software.
 
17
 *
 
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
19
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
20
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
21
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
22
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
23
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
24
 * THE SOFTWARE.
 
25
 */
 
26
#include "qemu-common.h"
 
27
#include "hw/usb.h"
 
28
#include "qemu/iov.h"
 
29
#include "trace.h"
 
30
 
 
31
void usb_attach(USBPort *port)
 
32
{
 
33
    USBDevice *dev = port->dev;
 
34
 
 
35
    assert(dev != NULL);
 
36
    assert(dev->attached);
 
37
    assert(dev->state == USB_STATE_NOTATTACHED);
 
38
    port->ops->attach(port);
 
39
    dev->state = USB_STATE_ATTACHED;
 
40
    usb_device_handle_attach(dev);
 
41
}
 
42
 
 
43
void usb_detach(USBPort *port)
 
44
{
 
45
    USBDevice *dev = port->dev;
 
46
 
 
47
    assert(dev != NULL);
 
48
    assert(dev->state != USB_STATE_NOTATTACHED);
 
49
    port->ops->detach(port);
 
50
    dev->state = USB_STATE_NOTATTACHED;
 
51
}
 
52
 
 
53
void usb_port_reset(USBPort *port)
 
54
{
 
55
    USBDevice *dev = port->dev;
 
56
 
 
57
    assert(dev != NULL);
 
58
    usb_detach(port);
 
59
    usb_attach(port);
 
60
    usb_device_reset(dev);
 
61
}
 
62
 
 
63
void usb_device_reset(USBDevice *dev)
 
64
{
 
65
    if (dev == NULL || !dev->attached) {
 
66
        return;
 
67
    }
 
68
    dev->remote_wakeup = 0;
 
69
    dev->addr = 0;
 
70
    dev->state = USB_STATE_DEFAULT;
 
71
    usb_device_handle_reset(dev);
 
72
}
 
73
 
 
74
void usb_wakeup(USBEndpoint *ep, unsigned int stream)
 
75
{
 
76
    USBDevice *dev = ep->dev;
 
77
    USBBus *bus = usb_bus_from_device(dev);
 
78
 
 
79
    if (dev->remote_wakeup && dev->port && dev->port->ops->wakeup) {
 
80
        dev->port->ops->wakeup(dev->port);
 
81
    }
 
82
    if (bus->ops->wakeup_endpoint) {
 
83
        bus->ops->wakeup_endpoint(bus, ep, stream);
 
84
    }
 
85
}
 
86
 
 
87
/**********************/
 
88
 
 
89
/* generic USB device helpers (you are not forced to use them when
 
90
   writing your USB device driver, but they help handling the
 
91
   protocol)
 
92
*/
 
93
 
 
94
#define SETUP_STATE_IDLE  0
 
95
#define SETUP_STATE_SETUP 1
 
96
#define SETUP_STATE_DATA  2
 
97
#define SETUP_STATE_ACK   3
 
98
#define SETUP_STATE_PARAM 4
 
99
 
 
100
static void do_token_setup(USBDevice *s, USBPacket *p)
 
101
{
 
102
    int request, value, index;
 
103
 
 
104
    if (p->iov.size != 8) {
 
105
        p->status = USB_RET_STALL;
 
106
        return;
 
107
    }
 
108
 
 
109
    usb_packet_copy(p, s->setup_buf, p->iov.size);
 
110
    p->actual_length = 0;
 
111
    s->setup_len   = (s->setup_buf[7] << 8) | s->setup_buf[6];
 
112
    s->setup_index = 0;
 
113
 
 
114
    request = (s->setup_buf[0] << 8) | s->setup_buf[1];
 
115
    value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
 
116
    index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 
117
 
 
118
    if (s->setup_buf[0] & USB_DIR_IN) {
 
119
        usb_device_handle_control(s, p, request, value, index,
 
120
                                  s->setup_len, s->data_buf);
 
121
        if (p->status == USB_RET_ASYNC) {
 
122
            s->setup_state = SETUP_STATE_SETUP;
 
123
        }
 
124
        if (p->status != USB_RET_SUCCESS) {
 
125
            return;
 
126
        }
 
127
 
 
128
        if (p->actual_length < s->setup_len) {
 
129
            s->setup_len = p->actual_length;
 
130
        }
 
131
        s->setup_state = SETUP_STATE_DATA;
 
132
    } else {
 
133
        if (s->setup_len > sizeof(s->data_buf)) {
 
134
            fprintf(stderr,
 
135
                "usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
 
136
                s->setup_len, sizeof(s->data_buf));
 
137
            p->status = USB_RET_STALL;
 
138
            return;
 
139
        }
 
140
        if (s->setup_len == 0)
 
141
            s->setup_state = SETUP_STATE_ACK;
 
142
        else
 
143
            s->setup_state = SETUP_STATE_DATA;
 
144
    }
 
145
 
 
146
    p->actual_length = 8;
 
147
}
 
148
 
 
149
static void do_token_in(USBDevice *s, USBPacket *p)
 
150
{
 
151
    int request, value, index;
 
152
 
 
153
    assert(p->ep->nr == 0);
 
154
 
 
155
    request = (s->setup_buf[0] << 8) | s->setup_buf[1];
 
156
    value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
 
157
    index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 
158
 
 
159
    switch(s->setup_state) {
 
160
    case SETUP_STATE_ACK:
 
161
        if (!(s->setup_buf[0] & USB_DIR_IN)) {
 
162
            usb_device_handle_control(s, p, request, value, index,
 
163
                                      s->setup_len, s->data_buf);
 
164
            if (p->status == USB_RET_ASYNC) {
 
165
                return;
 
166
            }
 
167
            s->setup_state = SETUP_STATE_IDLE;
 
168
            p->actual_length = 0;
 
169
        }
 
170
        break;
 
171
 
 
172
    case SETUP_STATE_DATA:
 
173
        if (s->setup_buf[0] & USB_DIR_IN) {
 
174
            int len = s->setup_len - s->setup_index;
 
175
            if (len > p->iov.size) {
 
176
                len = p->iov.size;
 
177
            }
 
178
            usb_packet_copy(p, s->data_buf + s->setup_index, len);
 
179
            s->setup_index += len;
 
180
            if (s->setup_index >= s->setup_len) {
 
181
                s->setup_state = SETUP_STATE_ACK;
 
182
            }
 
183
            return;
 
184
        }
 
185
        s->setup_state = SETUP_STATE_IDLE;
 
186
        p->status = USB_RET_STALL;
 
187
        break;
 
188
 
 
189
    default:
 
190
        p->status = USB_RET_STALL;
 
191
    }
 
192
}
 
193
 
 
194
static void do_token_out(USBDevice *s, USBPacket *p)
 
195
{
 
196
    assert(p->ep->nr == 0);
 
197
 
 
198
    switch(s->setup_state) {
 
199
    case SETUP_STATE_ACK:
 
200
        if (s->setup_buf[0] & USB_DIR_IN) {
 
201
            s->setup_state = SETUP_STATE_IDLE;
 
202
            /* transfer OK */
 
203
        } else {
 
204
            /* ignore additional output */
 
205
        }
 
206
        break;
 
207
 
 
208
    case SETUP_STATE_DATA:
 
209
        if (!(s->setup_buf[0] & USB_DIR_IN)) {
 
210
            int len = s->setup_len - s->setup_index;
 
211
            if (len > p->iov.size) {
 
212
                len = p->iov.size;
 
213
            }
 
214
            usb_packet_copy(p, s->data_buf + s->setup_index, len);
 
215
            s->setup_index += len;
 
216
            if (s->setup_index >= s->setup_len) {
 
217
                s->setup_state = SETUP_STATE_ACK;
 
218
            }
 
219
            return;
 
220
        }
 
221
        s->setup_state = SETUP_STATE_IDLE;
 
222
        p->status = USB_RET_STALL;
 
223
        break;
 
224
 
 
225
    default:
 
226
        p->status = USB_RET_STALL;
 
227
    }
 
228
}
 
229
 
 
230
static void do_parameter(USBDevice *s, USBPacket *p)
 
231
{
 
232
    int i, request, value, index;
 
233
 
 
234
    for (i = 0; i < 8; i++) {
 
235
        s->setup_buf[i] = p->parameter >> (i*8);
 
236
    }
 
237
 
 
238
    s->setup_state = SETUP_STATE_PARAM;
 
239
    s->setup_len   = (s->setup_buf[7] << 8) | s->setup_buf[6];
 
240
    s->setup_index = 0;
 
241
 
 
242
    request = (s->setup_buf[0] << 8) | s->setup_buf[1];
 
243
    value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
 
244
    index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 
245
 
 
246
    if (s->setup_len > sizeof(s->data_buf)) {
 
247
        fprintf(stderr,
 
248
                "usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
 
249
                s->setup_len, sizeof(s->data_buf));
 
250
        p->status = USB_RET_STALL;
 
251
        return;
 
252
    }
 
253
 
 
254
    if (p->pid == USB_TOKEN_OUT) {
 
255
        usb_packet_copy(p, s->data_buf, s->setup_len);
 
256
    }
 
257
 
 
258
    usb_device_handle_control(s, p, request, value, index,
 
259
                              s->setup_len, s->data_buf);
 
260
    if (p->status == USB_RET_ASYNC) {
 
261
        return;
 
262
    }
 
263
 
 
264
    if (p->actual_length < s->setup_len) {
 
265
        s->setup_len = p->actual_length;
 
266
    }
 
267
    if (p->pid == USB_TOKEN_IN) {
 
268
        p->actual_length = 0;
 
269
        usb_packet_copy(p, s->data_buf, s->setup_len);
 
270
    }
 
271
}
 
272
 
 
273
/* ctrl complete function for devices which use usb_generic_handle_packet and
 
274
   may return USB_RET_ASYNC from their handle_control callback. Device code
 
275
   which does this *must* call this function instead of the normal
 
276
   usb_packet_complete to complete their async control packets. */
 
277
void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p)
 
278
{
 
279
    if (p->status < 0) {
 
280
        s->setup_state = SETUP_STATE_IDLE;
 
281
    }
 
282
 
 
283
    switch (s->setup_state) {
 
284
    case SETUP_STATE_SETUP:
 
285
        if (p->actual_length < s->setup_len) {
 
286
            s->setup_len = p->actual_length;
 
287
        }
 
288
        s->setup_state = SETUP_STATE_DATA;
 
289
        p->actual_length = 8;
 
290
        break;
 
291
 
 
292
    case SETUP_STATE_ACK:
 
293
        s->setup_state = SETUP_STATE_IDLE;
 
294
        p->actual_length = 0;
 
295
        break;
 
296
 
 
297
    case SETUP_STATE_PARAM:
 
298
        if (p->actual_length < s->setup_len) {
 
299
            s->setup_len = p->actual_length;
 
300
        }
 
301
        if (p->pid == USB_TOKEN_IN) {
 
302
            p->actual_length = 0;
 
303
            usb_packet_copy(p, s->data_buf, s->setup_len);
 
304
        }
 
305
        break;
 
306
 
 
307
    default:
 
308
        break;
 
309
    }
 
310
    usb_packet_complete(s, p);
 
311
}
 
312
 
 
313
/* XXX: fix overflow */
 
314
int set_usb_string(uint8_t *buf, const char *str)
 
315
{
 
316
    int len, i;
 
317
    uint8_t *q;
 
318
 
 
319
    q = buf;
 
320
    len = strlen(str);
 
321
    *q++ = 2 * len + 2;
 
322
    *q++ = 3;
 
323
    for(i = 0; i < len; i++) {
 
324
        *q++ = str[i];
 
325
        *q++ = 0;
 
326
    }
 
327
    return q - buf;
 
328
}
 
329
 
 
330
USBDevice *usb_find_device(USBPort *port, uint8_t addr)
 
331
{
 
332
    USBDevice *dev = port->dev;
 
333
 
 
334
    if (dev == NULL || !dev->attached || dev->state != USB_STATE_DEFAULT) {
 
335
        return NULL;
 
336
    }
 
337
    if (dev->addr == addr) {
 
338
        return dev;
 
339
    }
 
340
    return usb_device_find_device(dev, addr);
 
341
}
 
342
 
 
343
static void usb_process_one(USBPacket *p)
 
344
{
 
345
    USBDevice *dev = p->ep->dev;
 
346
 
 
347
    /*
 
348
     * Handlers expect status to be initialized to USB_RET_SUCCESS, but it
 
349
     * can be USB_RET_NAK here from a previous usb_process_one() call,
 
350
     * or USB_RET_ASYNC from going through usb_queue_one().
 
351
     */
 
352
    p->status = USB_RET_SUCCESS;
 
353
 
 
354
    if (p->ep->nr == 0) {
 
355
        /* control pipe */
 
356
        if (p->parameter) {
 
357
            do_parameter(dev, p);
 
358
            return;
 
359
        }
 
360
        switch (p->pid) {
 
361
        case USB_TOKEN_SETUP:
 
362
            do_token_setup(dev, p);
 
363
            break;
 
364
        case USB_TOKEN_IN:
 
365
            do_token_in(dev, p);
 
366
            break;
 
367
        case USB_TOKEN_OUT:
 
368
            do_token_out(dev, p);
 
369
            break;
 
370
        default:
 
371
            p->status = USB_RET_STALL;
 
372
        }
 
373
    } else {
 
374
        /* data pipe */
 
375
        usb_device_handle_data(dev, p);
 
376
    }
 
377
}
 
378
 
 
379
static void usb_queue_one(USBPacket *p)
 
380
{
 
381
    usb_packet_set_state(p, USB_PACKET_QUEUED);
 
382
    QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue);
 
383
    p->status = USB_RET_ASYNC;
 
384
}
 
385
 
 
386
/* Hand over a packet to a device for processing.  p->status ==
 
387
   USB_RET_ASYNC indicates the processing isn't finished yet, the
 
388
   driver will call usb_packet_complete() when done processing it. */
 
389
void usb_handle_packet(USBDevice *dev, USBPacket *p)
 
390
{
 
391
    if (dev == NULL) {
 
392
        p->status = USB_RET_NODEV;
 
393
        return;
 
394
    }
 
395
    assert(dev == p->ep->dev);
 
396
    assert(dev->state == USB_STATE_DEFAULT);
 
397
    usb_packet_check_state(p, USB_PACKET_SETUP);
 
398
    assert(p->ep != NULL);
 
399
 
 
400
    /* Submitting a new packet clears halt */
 
401
    if (p->ep->halted) {
 
402
        assert(QTAILQ_EMPTY(&p->ep->queue));
 
403
        p->ep->halted = false;
 
404
    }
 
405
 
 
406
    if (QTAILQ_EMPTY(&p->ep->queue) || p->ep->pipeline) {
 
407
        usb_process_one(p);
 
408
        if (p->status == USB_RET_ASYNC) {
 
409
            /* hcd drivers cannot handle async for isoc */
 
410
            assert(p->ep->type != USB_ENDPOINT_XFER_ISOC);
 
411
            /* using async for interrupt packets breaks migration */
 
412
            assert(p->ep->type != USB_ENDPOINT_XFER_INT ||
 
413
                   (dev->flags & (1 << USB_DEV_FLAG_IS_HOST)));
 
414
            usb_packet_set_state(p, USB_PACKET_ASYNC);
 
415
            QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue);
 
416
        } else if (p->status == USB_RET_ADD_TO_QUEUE) {
 
417
            usb_queue_one(p);
 
418
        } else {
 
419
            /*
 
420
             * When pipelining is enabled usb-devices must always return async,
 
421
             * otherwise packets can complete out of order!
 
422
             */
 
423
            assert(!p->ep->pipeline || QTAILQ_EMPTY(&p->ep->queue));
 
424
            if (p->status != USB_RET_NAK) {
 
425
                usb_packet_set_state(p, USB_PACKET_COMPLETE);
 
426
            }
 
427
        }
 
428
    } else {
 
429
        usb_queue_one(p);
 
430
    }
 
431
}
 
432
 
 
433
void usb_packet_complete_one(USBDevice *dev, USBPacket *p)
 
434
{
 
435
    USBEndpoint *ep = p->ep;
 
436
 
 
437
    assert(QTAILQ_FIRST(&ep->queue) == p);
 
438
    assert(p->status != USB_RET_ASYNC && p->status != USB_RET_NAK);
 
439
 
 
440
    if (p->status != USB_RET_SUCCESS ||
 
441
            (p->short_not_ok && (p->actual_length < p->iov.size))) {
 
442
        ep->halted = true;
 
443
    }
 
444
    usb_packet_set_state(p, USB_PACKET_COMPLETE);
 
445
    QTAILQ_REMOVE(&ep->queue, p, queue);
 
446
    dev->port->ops->complete(dev->port, p);
 
447
}
 
448
 
 
449
/* Notify the controller that an async packet is complete.  This should only
 
450
   be called for packets previously deferred by returning USB_RET_ASYNC from
 
451
   handle_packet. */
 
452
void usb_packet_complete(USBDevice *dev, USBPacket *p)
 
453
{
 
454
    USBEndpoint *ep = p->ep;
 
455
 
 
456
    usb_packet_check_state(p, USB_PACKET_ASYNC);
 
457
    usb_packet_complete_one(dev, p);
 
458
 
 
459
    while (!QTAILQ_EMPTY(&ep->queue)) {
 
460
        p = QTAILQ_FIRST(&ep->queue);
 
461
        if (ep->halted) {
 
462
            /* Empty the queue on a halt */
 
463
            p->status = USB_RET_REMOVE_FROM_QUEUE;
 
464
            dev->port->ops->complete(dev->port, p);
 
465
            continue;
 
466
        }
 
467
        if (p->state == USB_PACKET_ASYNC) {
 
468
            break;
 
469
        }
 
470
        usb_packet_check_state(p, USB_PACKET_QUEUED);
 
471
        usb_process_one(p);
 
472
        if (p->status == USB_RET_ASYNC) {
 
473
            usb_packet_set_state(p, USB_PACKET_ASYNC);
 
474
            break;
 
475
        }
 
476
        usb_packet_complete_one(ep->dev, p);
 
477
    }
 
478
}
 
479
 
 
480
/* Cancel an active packet.  The packed must have been deferred by
 
481
   returning USB_RET_ASYNC from handle_packet, and not yet
 
482
   completed.  */
 
483
void usb_cancel_packet(USBPacket * p)
 
484
{
 
485
    bool callback = (p->state == USB_PACKET_ASYNC);
 
486
    assert(usb_packet_is_inflight(p));
 
487
    usb_packet_set_state(p, USB_PACKET_CANCELED);
 
488
    QTAILQ_REMOVE(&p->ep->queue, p, queue);
 
489
    if (callback) {
 
490
        usb_device_cancel_packet(p->ep->dev, p);
 
491
    }
 
492
}
 
493
 
 
494
 
 
495
void usb_packet_init(USBPacket *p)
 
496
{
 
497
    qemu_iovec_init(&p->iov, 1);
 
498
}
 
499
 
 
500
static const char *usb_packet_state_name(USBPacketState state)
 
501
{
 
502
    static const char *name[] = {
 
503
        [USB_PACKET_UNDEFINED] = "undef",
 
504
        [USB_PACKET_SETUP]     = "setup",
 
505
        [USB_PACKET_QUEUED]    = "queued",
 
506
        [USB_PACKET_ASYNC]     = "async",
 
507
        [USB_PACKET_COMPLETE]  = "complete",
 
508
        [USB_PACKET_CANCELED]  = "canceled",
 
509
    };
 
510
    if (state < ARRAY_SIZE(name)) {
 
511
        return name[state];
 
512
    }
 
513
    return "INVALID";
 
514
}
 
515
 
 
516
void usb_packet_check_state(USBPacket *p, USBPacketState expected)
 
517
{
 
518
    USBDevice *dev;
 
519
    USBBus *bus;
 
520
 
 
521
    if (p->state == expected) {
 
522
        return;
 
523
    }
 
524
    dev = p->ep->dev;
 
525
    bus = usb_bus_from_device(dev);
 
526
    trace_usb_packet_state_fault(bus->busnr, dev->port->path, p->ep->nr, p,
 
527
                                 usb_packet_state_name(p->state),
 
528
                                 usb_packet_state_name(expected));
 
529
    assert(!"usb packet state check failed");
 
530
}
 
531
 
 
532
void usb_packet_set_state(USBPacket *p, USBPacketState state)
 
533
{
 
534
    if (p->ep) {
 
535
        USBDevice *dev = p->ep->dev;
 
536
        USBBus *bus = usb_bus_from_device(dev);
 
537
        trace_usb_packet_state_change(bus->busnr, dev->port->path, p->ep->nr, p,
 
538
                                      usb_packet_state_name(p->state),
 
539
                                      usb_packet_state_name(state));
 
540
    } else {
 
541
        trace_usb_packet_state_change(-1, "", -1, p,
 
542
                                      usb_packet_state_name(p->state),
 
543
                                      usb_packet_state_name(state));
 
544
    }
 
545
    p->state = state;
 
546
}
 
547
 
 
548
void usb_packet_setup(USBPacket *p, int pid,
 
549
                      USBEndpoint *ep, unsigned int stream,
 
550
                      uint64_t id, bool short_not_ok, bool int_req)
 
551
{
 
552
    assert(!usb_packet_is_inflight(p));
 
553
    assert(p->iov.iov != NULL);
 
554
    p->id = id;
 
555
    p->pid = pid;
 
556
    p->ep = ep;
 
557
    p->stream = stream;
 
558
    p->status = USB_RET_SUCCESS;
 
559
    p->actual_length = 0;
 
560
    p->parameter = 0;
 
561
    p->short_not_ok = short_not_ok;
 
562
    p->int_req = int_req;
 
563
    p->combined = NULL;
 
564
    qemu_iovec_reset(&p->iov);
 
565
    usb_packet_set_state(p, USB_PACKET_SETUP);
 
566
}
 
567
 
 
568
void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len)
 
569
{
 
570
    qemu_iovec_add(&p->iov, ptr, len);
 
571
}
 
572
 
 
573
void usb_packet_copy(USBPacket *p, void *ptr, size_t bytes)
 
574
{
 
575
    QEMUIOVector *iov = p->combined ? &p->combined->iov : &p->iov;
 
576
 
 
577
    assert(p->actual_length >= 0);
 
578
    assert(p->actual_length + bytes <= iov->size);
 
579
    switch (p->pid) {
 
580
    case USB_TOKEN_SETUP:
 
581
    case USB_TOKEN_OUT:
 
582
        iov_to_buf(iov->iov, iov->niov, p->actual_length, ptr, bytes);
 
583
        break;
 
584
    case USB_TOKEN_IN:
 
585
        iov_from_buf(iov->iov, iov->niov, p->actual_length, ptr, bytes);
 
586
        break;
 
587
    default:
 
588
        fprintf(stderr, "%s: invalid pid: %x\n", __func__, p->pid);
 
589
        abort();
 
590
    }
 
591
    p->actual_length += bytes;
 
592
}
 
593
 
 
594
void usb_packet_skip(USBPacket *p, size_t bytes)
 
595
{
 
596
    QEMUIOVector *iov = p->combined ? &p->combined->iov : &p->iov;
 
597
 
 
598
    assert(p->actual_length >= 0);
 
599
    assert(p->actual_length + bytes <= iov->size);
 
600
    if (p->pid == USB_TOKEN_IN) {
 
601
        iov_memset(iov->iov, iov->niov, p->actual_length, 0, bytes);
 
602
    }
 
603
    p->actual_length += bytes;
 
604
}
 
605
 
 
606
size_t usb_packet_size(USBPacket *p)
 
607
{
 
608
    return p->combined ? p->combined->iov.size : p->iov.size;
 
609
}
 
610
 
 
611
void usb_packet_cleanup(USBPacket *p)
 
612
{
 
613
    assert(!usb_packet_is_inflight(p));
 
614
    qemu_iovec_destroy(&p->iov);
 
615
}
 
616
 
 
617
void usb_ep_reset(USBDevice *dev)
 
618
{
 
619
    int ep;
 
620
 
 
621
    dev->ep_ctl.nr = 0;
 
622
    dev->ep_ctl.type = USB_ENDPOINT_XFER_CONTROL;
 
623
    dev->ep_ctl.ifnum = 0;
 
624
    dev->ep_ctl.dev = dev;
 
625
    dev->ep_ctl.pipeline = false;
 
626
    for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
 
627
        dev->ep_in[ep].nr = ep + 1;
 
628
        dev->ep_out[ep].nr = ep + 1;
 
629
        dev->ep_in[ep].pid = USB_TOKEN_IN;
 
630
        dev->ep_out[ep].pid = USB_TOKEN_OUT;
 
631
        dev->ep_in[ep].type = USB_ENDPOINT_XFER_INVALID;
 
632
        dev->ep_out[ep].type = USB_ENDPOINT_XFER_INVALID;
 
633
        dev->ep_in[ep].ifnum = USB_INTERFACE_INVALID;
 
634
        dev->ep_out[ep].ifnum = USB_INTERFACE_INVALID;
 
635
        dev->ep_in[ep].dev = dev;
 
636
        dev->ep_out[ep].dev = dev;
 
637
        dev->ep_in[ep].pipeline = false;
 
638
        dev->ep_out[ep].pipeline = false;
 
639
    }
 
640
}
 
641
 
 
642
void usb_ep_init(USBDevice *dev)
 
643
{
 
644
    int ep;
 
645
 
 
646
    usb_ep_reset(dev);
 
647
    QTAILQ_INIT(&dev->ep_ctl.queue);
 
648
    for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
 
649
        QTAILQ_INIT(&dev->ep_in[ep].queue);
 
650
        QTAILQ_INIT(&dev->ep_out[ep].queue);
 
651
    }
 
652
}
 
653
 
 
654
void usb_ep_dump(USBDevice *dev)
 
655
{
 
656
    static const char *tname[] = {
 
657
        [USB_ENDPOINT_XFER_CONTROL] = "control",
 
658
        [USB_ENDPOINT_XFER_ISOC]    = "isoc",
 
659
        [USB_ENDPOINT_XFER_BULK]    = "bulk",
 
660
        [USB_ENDPOINT_XFER_INT]     = "int",
 
661
    };
 
662
    int ifnum, ep, first;
 
663
 
 
664
    fprintf(stderr, "Device \"%s\", config %d\n",
 
665
            dev->product_desc, dev->configuration);
 
666
    for (ifnum = 0; ifnum < 16; ifnum++) {
 
667
        first = 1;
 
668
        for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
 
669
            if (dev->ep_in[ep].type != USB_ENDPOINT_XFER_INVALID &&
 
670
                dev->ep_in[ep].ifnum == ifnum) {
 
671
                if (first) {
 
672
                    first = 0;
 
673
                    fprintf(stderr, "  Interface %d, alternative %d\n",
 
674
                            ifnum, dev->altsetting[ifnum]);
 
675
                }
 
676
                fprintf(stderr, "    Endpoint %d, IN, %s, %d max\n", ep,
 
677
                        tname[dev->ep_in[ep].type],
 
678
                        dev->ep_in[ep].max_packet_size);
 
679
            }
 
680
            if (dev->ep_out[ep].type != USB_ENDPOINT_XFER_INVALID &&
 
681
                dev->ep_out[ep].ifnum == ifnum) {
 
682
                if (first) {
 
683
                    first = 0;
 
684
                    fprintf(stderr, "  Interface %d, alternative %d\n",
 
685
                            ifnum, dev->altsetting[ifnum]);
 
686
                }
 
687
                fprintf(stderr, "    Endpoint %d, OUT, %s, %d max\n", ep,
 
688
                        tname[dev->ep_out[ep].type],
 
689
                        dev->ep_out[ep].max_packet_size);
 
690
            }
 
691
        }
 
692
    }
 
693
    fprintf(stderr, "--\n");
 
694
}
 
695
 
 
696
struct USBEndpoint *usb_ep_get(USBDevice *dev, int pid, int ep)
 
697
{
 
698
    struct USBEndpoint *eps;
 
699
 
 
700
    if (dev == NULL) {
 
701
        return NULL;
 
702
    }
 
703
    eps = (pid == USB_TOKEN_IN) ? dev->ep_in : dev->ep_out;
 
704
    if (ep == 0) {
 
705
        return &dev->ep_ctl;
 
706
    }
 
707
    assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
 
708
    assert(ep > 0 && ep <= USB_MAX_ENDPOINTS);
 
709
    return eps + ep - 1;
 
710
}
 
711
 
 
712
uint8_t usb_ep_get_type(USBDevice *dev, int pid, int ep)
 
713
{
 
714
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
715
    return uep->type;
 
716
}
 
717
 
 
718
void usb_ep_set_type(USBDevice *dev, int pid, int ep, uint8_t type)
 
719
{
 
720
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
721
    uep->type = type;
 
722
}
 
723
 
 
724
uint8_t usb_ep_get_ifnum(USBDevice *dev, int pid, int ep)
 
725
{
 
726
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
727
    return uep->ifnum;
 
728
}
 
729
 
 
730
void usb_ep_set_ifnum(USBDevice *dev, int pid, int ep, uint8_t ifnum)
 
731
{
 
732
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
733
    uep->ifnum = ifnum;
 
734
}
 
735
 
 
736
void usb_ep_set_max_packet_size(USBDevice *dev, int pid, int ep,
 
737
                                uint16_t raw)
 
738
{
 
739
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
740
    int size, microframes;
 
741
 
 
742
    size = raw & 0x7ff;
 
743
    switch ((raw >> 11) & 3) {
 
744
    case 1:
 
745
        microframes = 2;
 
746
        break;
 
747
    case 2:
 
748
        microframes = 3;
 
749
        break;
 
750
    default:
 
751
        microframes = 1;
 
752
        break;
 
753
    }
 
754
    uep->max_packet_size = size * microframes;
 
755
}
 
756
 
 
757
int usb_ep_get_max_packet_size(USBDevice *dev, int pid, int ep)
 
758
{
 
759
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
760
    return uep->max_packet_size;
 
761
}
 
762
 
 
763
void usb_ep_set_pipeline(USBDevice *dev, int pid, int ep, bool enabled)
 
764
{
 
765
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
766
    uep->pipeline = enabled;
 
767
}
 
768
 
 
769
void usb_ep_set_halted(USBDevice *dev, int pid, int ep, bool halted)
 
770
{
 
771
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
772
    uep->halted = halted;
 
773
}
 
774
 
 
775
USBPacket *usb_ep_find_packet_by_id(USBDevice *dev, int pid, int ep,
 
776
                                    uint64_t id)
 
777
{
 
778
    struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
 
779
    USBPacket *p;
 
780
 
 
781
    QTAILQ_FOREACH(p, &uep->queue, queue) {
 
782
        if (p->id == id) {
 
783
            return p;
 
784
        }
 
785
    }
 
786
 
 
787
    return NULL;
 
788
}