mmu-hash*: Don't keep looking for PTEs after we find a match
[qemu/agraf.git] / hw / usb / core.c
blob15a150aea03806fded1adbb193bb0b41505aef6d
1 /*
2 * QEMU USB emulation
4 * Copyright (c) 2005 Fabrice Bellard
6 * 2008 Generic packet handler rewrite by Max Krasnyansky
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:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
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.
26 #include "qemu-common.h"
27 #include "hw/usb.h"
28 #include "qemu/iov.h"
29 #include "trace.h"
31 void usb_attach(USBPort *port)
33 USBDevice *dev = port->dev;
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);
43 void usb_detach(USBPort *port)
45 USBDevice *dev = port->dev;
47 assert(dev != NULL);
48 assert(dev->state != USB_STATE_NOTATTACHED);
49 port->ops->detach(port);
50 dev->state = USB_STATE_NOTATTACHED;
53 void usb_port_reset(USBPort *port)
55 USBDevice *dev = port->dev;
57 assert(dev != NULL);
58 usb_detach(port);
59 usb_attach(port);
60 usb_device_reset(dev);
63 void usb_device_reset(USBDevice *dev)
65 if (dev == NULL || !dev->attached) {
66 return;
68 dev->remote_wakeup = 0;
69 dev->addr = 0;
70 dev->state = USB_STATE_DEFAULT;
71 usb_device_handle_reset(dev);
74 void usb_wakeup(USBEndpoint *ep, unsigned int stream)
76 USBDevice *dev = ep->dev;
77 USBBus *bus = usb_bus_from_device(dev);
79 if (dev->remote_wakeup && dev->port && dev->port->ops->wakeup) {
80 dev->port->ops->wakeup(dev->port);
82 if (bus->ops->wakeup_endpoint) {
83 bus->ops->wakeup_endpoint(bus, ep, stream);
87 /**********************/
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)
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
100 static void do_token_setup(USBDevice *s, USBPacket *p)
102 int request, value, index;
104 if (p->iov.size != 8) {
105 p->status = USB_RET_STALL;
106 return;
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;
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];
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;
124 if (p->status != USB_RET_SUCCESS) {
125 return;
128 if (p->actual_length < s->setup_len) {
129 s->setup_len = p->actual_length;
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;
140 if (s->setup_len == 0)
141 s->setup_state = SETUP_STATE_ACK;
142 else
143 s->setup_state = SETUP_STATE_DATA;
146 p->actual_length = 8;
149 static void do_token_in(USBDevice *s, USBPacket *p)
151 int request, value, index;
153 assert(p->ep->nr == 0);
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];
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;
167 s->setup_state = SETUP_STATE_IDLE;
168 p->actual_length = 0;
170 break;
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;
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;
183 return;
185 s->setup_state = SETUP_STATE_IDLE;
186 p->status = USB_RET_STALL;
187 break;
189 default:
190 p->status = USB_RET_STALL;
194 static void do_token_out(USBDevice *s, USBPacket *p)
196 assert(p->ep->nr == 0);
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 */
206 break;
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;
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;
219 return;
221 s->setup_state = SETUP_STATE_IDLE;
222 p->status = USB_RET_STALL;
223 break;
225 default:
226 p->status = USB_RET_STALL;
230 static void do_parameter(USBDevice *s, USBPacket *p)
232 int i, request, value, index;
234 for (i = 0; i < 8; i++) {
235 s->setup_buf[i] = p->parameter >> (i*8);
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;
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];
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;
254 if (p->pid == USB_TOKEN_OUT) {
255 usb_packet_copy(p, s->data_buf, s->setup_len);
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;
264 if (p->actual_length < s->setup_len) {
265 s->setup_len = p->actual_length;
267 if (p->pid == USB_TOKEN_IN) {
268 p->actual_length = 0;
269 usb_packet_copy(p, s->data_buf, s->setup_len);
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)
279 if (p->status < 0) {
280 s->setup_state = SETUP_STATE_IDLE;
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;
288 s->setup_state = SETUP_STATE_DATA;
289 p->actual_length = 8;
290 break;
292 case SETUP_STATE_ACK:
293 s->setup_state = SETUP_STATE_IDLE;
294 p->actual_length = 0;
295 break;
297 case SETUP_STATE_PARAM:
298 if (p->actual_length < s->setup_len) {
299 s->setup_len = p->actual_length;
301 if (p->pid == USB_TOKEN_IN) {
302 p->actual_length = 0;
303 usb_packet_copy(p, s->data_buf, s->setup_len);
305 break;
307 default:
308 break;
310 usb_packet_complete(s, p);
313 /* XXX: fix overflow */
314 int set_usb_string(uint8_t *buf, const char *str)
316 int len, i;
317 uint8_t *q;
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;
327 return q - buf;
330 USBDevice *usb_find_device(USBPort *port, uint8_t addr)
332 USBDevice *dev = port->dev;
334 if (dev == NULL || !dev->attached || dev->state != USB_STATE_DEFAULT) {
335 return NULL;
337 if (dev->addr == addr) {
338 return dev;
340 return usb_device_find_device(dev, addr);
343 static void usb_process_one(USBPacket *p)
345 USBDevice *dev = p->ep->dev;
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().
352 p->status = USB_RET_SUCCESS;
354 if (p->ep->nr == 0) {
355 /* control pipe */
356 if (p->parameter) {
357 do_parameter(dev, p);
358 return;
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;
373 } else {
374 /* data pipe */
375 usb_device_handle_data(dev, p);
379 static void usb_queue_one(USBPacket *p)
381 usb_packet_set_state(p, USB_PACKET_QUEUED);
382 QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue);
383 p->status = USB_RET_ASYNC;
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)
391 if (dev == NULL) {
392 p->status = USB_RET_NODEV;
393 return;
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);
400 /* Submitting a new packet clears halt */
401 if (p->ep->halted) {
402 assert(QTAILQ_EMPTY(&p->ep->queue));
403 p->ep->halted = false;
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 & 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 {
420 * When pipelining is enabled usb-devices must always return async,
421 * otherwise packets can complete out of order!
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);
428 } else {
429 usb_queue_one(p);
433 void usb_packet_complete_one(USBDevice *dev, USBPacket *p)
435 USBEndpoint *ep = p->ep;
437 assert(QTAILQ_FIRST(&ep->queue) == p);
438 assert(p->status != USB_RET_ASYNC && p->status != USB_RET_NAK);
440 if (p->status != USB_RET_SUCCESS ||
441 (p->short_not_ok && (p->actual_length < p->iov.size))) {
442 ep->halted = true;
444 usb_packet_set_state(p, USB_PACKET_COMPLETE);
445 QTAILQ_REMOVE(&ep->queue, p, queue);
446 dev->port->ops->complete(dev->port, p);
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)
454 USBEndpoint *ep = p->ep;
456 usb_packet_check_state(p, USB_PACKET_ASYNC);
457 usb_packet_complete_one(dev, p);
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;
467 if (p->state == USB_PACKET_ASYNC) {
468 break;
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;
476 usb_packet_complete_one(ep->dev, p);
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)
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);
495 void usb_packet_init(USBPacket *p)
497 qemu_iovec_init(&p->iov, 1);
500 static const char *usb_packet_state_name(USBPacketState state)
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",
510 if (state < ARRAY_SIZE(name)) {
511 return name[state];
513 return "INVALID";
516 void usb_packet_check_state(USBPacket *p, USBPacketState expected)
518 USBDevice *dev;
519 USBBus *bus;
521 if (p->state == expected) {
522 return;
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");
532 void usb_packet_set_state(USBPacket *p, USBPacketState state)
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));
545 p->state = state;
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)
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);
568 void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len)
570 qemu_iovec_add(&p->iov, ptr, len);
573 void usb_packet_copy(USBPacket *p, void *ptr, size_t bytes)
575 QEMUIOVector *iov = p->combined ? &p->combined->iov : &p->iov;
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();
591 p->actual_length += bytes;
594 void usb_packet_skip(USBPacket *p, size_t bytes)
596 QEMUIOVector *iov = p->combined ? &p->combined->iov : &p->iov;
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);
603 p->actual_length += bytes;
606 size_t usb_packet_size(USBPacket *p)
608 return p->combined ? p->combined->iov.size : p->iov.size;
611 void usb_packet_cleanup(USBPacket *p)
613 assert(!usb_packet_is_inflight(p));
614 qemu_iovec_destroy(&p->iov);
617 void usb_ep_reset(USBDevice *dev)
619 int ep;
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;
642 void usb_ep_init(USBDevice *dev)
644 int ep;
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);
654 void usb_ep_dump(USBDevice *dev)
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",
662 int ifnum, ep, first;
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]);
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);
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]);
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);
693 fprintf(stderr, "--\n");
696 struct USBEndpoint *usb_ep_get(USBDevice *dev, int pid, int ep)
698 struct USBEndpoint *eps;
700 if (dev == NULL) {
701 return NULL;
703 eps = (pid == USB_TOKEN_IN) ? dev->ep_in : dev->ep_out;
704 if (ep == 0) {
705 return &dev->ep_ctl;
707 assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
708 assert(ep > 0 && ep <= USB_MAX_ENDPOINTS);
709 return eps + ep - 1;
712 uint8_t usb_ep_get_type(USBDevice *dev, int pid, int ep)
714 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
715 return uep->type;
718 void usb_ep_set_type(USBDevice *dev, int pid, int ep, uint8_t type)
720 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
721 uep->type = type;
724 uint8_t usb_ep_get_ifnum(USBDevice *dev, int pid, int ep)
726 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
727 return uep->ifnum;
730 void usb_ep_set_ifnum(USBDevice *dev, int pid, int ep, uint8_t ifnum)
732 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
733 uep->ifnum = ifnum;
736 void usb_ep_set_max_packet_size(USBDevice *dev, int pid, int ep,
737 uint16_t raw)
739 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
740 int size, microframes;
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;
754 uep->max_packet_size = size * microframes;
757 int usb_ep_get_max_packet_size(USBDevice *dev, int pid, int ep)
759 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
760 return uep->max_packet_size;
763 void usb_ep_set_pipeline(USBDevice *dev, int pid, int ep, bool enabled)
765 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
766 uep->pipeline = enabled;
769 void usb_ep_set_halted(USBDevice *dev, int pid, int ep, bool halted)
771 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
772 uep->halted = halted;
775 USBPacket *usb_ep_find_packet_by_id(USBDevice *dev, int pid, int ep,
776 uint64_t id)
778 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
779 USBPacket *p;
781 QTAILQ_FOREACH(p, &uep->queue, queue) {
782 if (p->id == id) {
783 return p;
787 return NULL;