1f1ae32a1SGerd Hoffmann /*
2f1ae32a1SGerd Hoffmann * QEMU USB emulation
3f1ae32a1SGerd Hoffmann *
4f1ae32a1SGerd Hoffmann * Copyright (c) 2005 Fabrice Bellard
5f1ae32a1SGerd Hoffmann *
6f1ae32a1SGerd Hoffmann * 2008 Generic packet handler rewrite by Max Krasnyansky
7f1ae32a1SGerd Hoffmann *
8f1ae32a1SGerd Hoffmann * Permission is hereby granted, free of charge, to any person obtaining a copy
9f1ae32a1SGerd Hoffmann * of this software and associated documentation files (the "Software"), to deal
10f1ae32a1SGerd Hoffmann * in the Software without restriction, including without limitation the rights
11f1ae32a1SGerd Hoffmann * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12f1ae32a1SGerd Hoffmann * copies of the Software, and to permit persons to whom the Software is
13f1ae32a1SGerd Hoffmann * furnished to do so, subject to the following conditions:
14f1ae32a1SGerd Hoffmann *
15f1ae32a1SGerd Hoffmann * The above copyright notice and this permission notice shall be included in
16f1ae32a1SGerd Hoffmann * all copies or substantial portions of the Software.
17f1ae32a1SGerd Hoffmann *
18f1ae32a1SGerd Hoffmann * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19f1ae32a1SGerd Hoffmann * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20f1ae32a1SGerd Hoffmann * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21f1ae32a1SGerd Hoffmann * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22f1ae32a1SGerd Hoffmann * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23f1ae32a1SGerd Hoffmann * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24f1ae32a1SGerd Hoffmann * THE SOFTWARE.
25f1ae32a1SGerd Hoffmann */
26e532b2e0SPeter Maydell #include "qemu/osdep.h"
27f1ae32a1SGerd Hoffmann #include "hw/usb.h"
281de7afc9SPaolo Bonzini #include "qemu/iov.h"
29f1ae32a1SGerd Hoffmann #include "trace.h"
30f1ae32a1SGerd Hoffmann
usb_pick_speed(USBPort * port)31b791c3b3SGerd Hoffmann void usb_pick_speed(USBPort *port)
32b791c3b3SGerd Hoffmann {
33b791c3b3SGerd Hoffmann static const int speeds[] = {
34b791c3b3SGerd Hoffmann USB_SPEED_SUPER,
35b791c3b3SGerd Hoffmann USB_SPEED_HIGH,
36b791c3b3SGerd Hoffmann USB_SPEED_FULL,
37b791c3b3SGerd Hoffmann USB_SPEED_LOW,
38b791c3b3SGerd Hoffmann };
39b791c3b3SGerd Hoffmann USBDevice *udev = port->dev;
40b791c3b3SGerd Hoffmann int i;
41b791c3b3SGerd Hoffmann
42b791c3b3SGerd Hoffmann for (i = 0; i < ARRAY_SIZE(speeds); i++) {
43b791c3b3SGerd Hoffmann if ((udev->speedmask & (1 << speeds[i])) &&
44b791c3b3SGerd Hoffmann (port->speedmask & (1 << speeds[i]))) {
45b791c3b3SGerd Hoffmann udev->speed = speeds[i];
46b791c3b3SGerd Hoffmann return;
47b791c3b3SGerd Hoffmann }
48b791c3b3SGerd Hoffmann }
49b791c3b3SGerd Hoffmann }
50b791c3b3SGerd Hoffmann
usb_attach(USBPort * port)51f1ae32a1SGerd Hoffmann void usb_attach(USBPort *port)
52f1ae32a1SGerd Hoffmann {
53f1ae32a1SGerd Hoffmann USBDevice *dev = port->dev;
54f1ae32a1SGerd Hoffmann
55f1ae32a1SGerd Hoffmann assert(dev != NULL);
56f1ae32a1SGerd Hoffmann assert(dev->attached);
57f1ae32a1SGerd Hoffmann assert(dev->state == USB_STATE_NOTATTACHED);
58b791c3b3SGerd Hoffmann usb_pick_speed(port);
59f1ae32a1SGerd Hoffmann port->ops->attach(port);
60f1ae32a1SGerd Hoffmann dev->state = USB_STATE_ATTACHED;
61f1ae32a1SGerd Hoffmann usb_device_handle_attach(dev);
62f1ae32a1SGerd Hoffmann }
63f1ae32a1SGerd Hoffmann
usb_detach(USBPort * port)64f1ae32a1SGerd Hoffmann void usb_detach(USBPort *port)
65f1ae32a1SGerd Hoffmann {
66f1ae32a1SGerd Hoffmann USBDevice *dev = port->dev;
67f1ae32a1SGerd Hoffmann
68f1ae32a1SGerd Hoffmann assert(dev != NULL);
69f1ae32a1SGerd Hoffmann assert(dev->state != USB_STATE_NOTATTACHED);
70f1ae32a1SGerd Hoffmann port->ops->detach(port);
71f1ae32a1SGerd Hoffmann dev->state = USB_STATE_NOTATTACHED;
72f1ae32a1SGerd Hoffmann }
73f1ae32a1SGerd Hoffmann
usb_port_reset(USBPort * port)74f1ae32a1SGerd Hoffmann void usb_port_reset(USBPort *port)
75f1ae32a1SGerd Hoffmann {
76f1ae32a1SGerd Hoffmann USBDevice *dev = port->dev;
77f1ae32a1SGerd Hoffmann
78f1ae32a1SGerd Hoffmann assert(dev != NULL);
79f1ae32a1SGerd Hoffmann usb_detach(port);
80f1ae32a1SGerd Hoffmann usb_attach(port);
81f1ae32a1SGerd Hoffmann usb_device_reset(dev);
82f1ae32a1SGerd Hoffmann }
83f1ae32a1SGerd Hoffmann
usb_device_reset(USBDevice * dev)84f1ae32a1SGerd Hoffmann void usb_device_reset(USBDevice *dev)
85f1ae32a1SGerd Hoffmann {
86f1ae32a1SGerd Hoffmann if (dev == NULL || !dev->attached) {
87f1ae32a1SGerd Hoffmann return;
88f1ae32a1SGerd Hoffmann }
897ed46573SGerd Hoffmann usb_device_handle_reset(dev);
90f1ae32a1SGerd Hoffmann dev->remote_wakeup = 0;
91f1ae32a1SGerd Hoffmann dev->addr = 0;
92f1ae32a1SGerd Hoffmann dev->state = USB_STATE_DEFAULT;
93f1ae32a1SGerd Hoffmann }
94f1ae32a1SGerd Hoffmann
usb_wakeup(USBEndpoint * ep,unsigned int stream)958550a02dSGerd Hoffmann void usb_wakeup(USBEndpoint *ep, unsigned int stream)
96f1ae32a1SGerd Hoffmann {
97f1ae32a1SGerd Hoffmann USBDevice *dev = ep->dev;
98f1ae32a1SGerd Hoffmann USBBus *bus = usb_bus_from_device(dev);
99f1ae32a1SGerd Hoffmann
1002f181fbdSPaolo Bonzini if (!phase_check(PHASE_MACHINE_READY)) {
10126022652SGerd Hoffmann /*
10226022652SGerd Hoffmann * This is machine init cold plug. No need to wakeup anyone,
10326022652SGerd Hoffmann * all devices will be reset anyway. And trying to wakeup can
10426022652SGerd Hoffmann * cause problems due to hitting uninitialized devices.
10526022652SGerd Hoffmann */
10626022652SGerd Hoffmann return;
10726022652SGerd Hoffmann }
108f1ae32a1SGerd Hoffmann if (dev->remote_wakeup && dev->port && dev->port->ops->wakeup) {
109f1ae32a1SGerd Hoffmann dev->port->ops->wakeup(dev->port);
110f1ae32a1SGerd Hoffmann }
111f1ae32a1SGerd Hoffmann if (bus->ops->wakeup_endpoint) {
1128550a02dSGerd Hoffmann bus->ops->wakeup_endpoint(bus, ep, stream);
113f1ae32a1SGerd Hoffmann }
114f1ae32a1SGerd Hoffmann }
115f1ae32a1SGerd Hoffmann
116f1ae32a1SGerd Hoffmann /**********************/
117f1ae32a1SGerd Hoffmann
118f1ae32a1SGerd Hoffmann /* generic USB device helpers (you are not forced to use them when
119f1ae32a1SGerd Hoffmann writing your USB device driver, but they help handling the
120f1ae32a1SGerd Hoffmann protocol)
121f1ae32a1SGerd Hoffmann */
122f1ae32a1SGerd Hoffmann
123f1ae32a1SGerd Hoffmann #define SETUP_STATE_IDLE 0
124f1ae32a1SGerd Hoffmann #define SETUP_STATE_SETUP 1
125f1ae32a1SGerd Hoffmann #define SETUP_STATE_DATA 2
126f1ae32a1SGerd Hoffmann #define SETUP_STATE_ACK 3
127f1ae32a1SGerd Hoffmann #define SETUP_STATE_PARAM 4
128f1ae32a1SGerd Hoffmann
do_token_setup(USBDevice * s,USBPacket * p)1299a77a0f5SHans de Goede static void do_token_setup(USBDevice *s, USBPacket *p)
130f1ae32a1SGerd Hoffmann {
131f1ae32a1SGerd Hoffmann int request, value, index;
132b946434fSGerd Hoffmann unsigned int setup_len;
133f1ae32a1SGerd Hoffmann
134f1ae32a1SGerd Hoffmann if (p->iov.size != 8) {
1359a77a0f5SHans de Goede p->status = USB_RET_STALL;
1369a77a0f5SHans de Goede return;
137f1ae32a1SGerd Hoffmann }
138f1ae32a1SGerd Hoffmann
139f1ae32a1SGerd Hoffmann usb_packet_copy(p, s->setup_buf, p->iov.size);
14064c9bc18SPrasad J Pandit s->setup_index = 0;
1419a77a0f5SHans de Goede p->actual_length = 0;
142b946434fSGerd Hoffmann setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
143b946434fSGerd Hoffmann if (setup_len > sizeof(s->data_buf)) {
14464c9bc18SPrasad J Pandit fprintf(stderr,
145268c0242SAlex Chen "usb_generic_handle_packet: ctrl buffer too small (%u > %zu)\n",
146b946434fSGerd Hoffmann setup_len, sizeof(s->data_buf));
14764c9bc18SPrasad J Pandit p->status = USB_RET_STALL;
14864c9bc18SPrasad J Pandit return;
14964c9bc18SPrasad J Pandit }
150b946434fSGerd Hoffmann s->setup_len = setup_len;
151f1ae32a1SGerd Hoffmann
152f1ae32a1SGerd Hoffmann request = (s->setup_buf[0] << 8) | s->setup_buf[1];
153f1ae32a1SGerd Hoffmann value = (s->setup_buf[3] << 8) | s->setup_buf[2];
154f1ae32a1SGerd Hoffmann index = (s->setup_buf[5] << 8) | s->setup_buf[4];
155f1ae32a1SGerd Hoffmann
156f1ae32a1SGerd Hoffmann if (s->setup_buf[0] & USB_DIR_IN) {
157*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, true);
1589a77a0f5SHans de Goede usb_device_handle_control(s, p, request, value, index,
159f1ae32a1SGerd Hoffmann s->setup_len, s->data_buf);
1609a77a0f5SHans de Goede if (p->status == USB_RET_ASYNC) {
161f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_SETUP;
162f1ae32a1SGerd Hoffmann }
1639a77a0f5SHans de Goede if (p->status != USB_RET_SUCCESS) {
1649a77a0f5SHans de Goede return;
1659a77a0f5SHans de Goede }
166f1ae32a1SGerd Hoffmann
1679a77a0f5SHans de Goede if (p->actual_length < s->setup_len) {
1689a77a0f5SHans de Goede s->setup_len = p->actual_length;
1699a77a0f5SHans de Goede }
170f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_DATA;
171f1ae32a1SGerd Hoffmann } else {
172f1ae32a1SGerd Hoffmann if (s->setup_len == 0)
173f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_ACK;
174f1ae32a1SGerd Hoffmann else
175f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_DATA;
176f1ae32a1SGerd Hoffmann }
177f1ae32a1SGerd Hoffmann
1789a77a0f5SHans de Goede p->actual_length = 8;
179f1ae32a1SGerd Hoffmann }
180f1ae32a1SGerd Hoffmann
do_token_in(USBDevice * s,USBPacket * p)1819a77a0f5SHans de Goede static void do_token_in(USBDevice *s, USBPacket *p)
182f1ae32a1SGerd Hoffmann {
183f1ae32a1SGerd Hoffmann int request, value, index;
184f1ae32a1SGerd Hoffmann
185f1ae32a1SGerd Hoffmann assert(p->ep->nr == 0);
186f1ae32a1SGerd Hoffmann
187f1ae32a1SGerd Hoffmann request = (s->setup_buf[0] << 8) | s->setup_buf[1];
188f1ae32a1SGerd Hoffmann value = (s->setup_buf[3] << 8) | s->setup_buf[2];
189f1ae32a1SGerd Hoffmann index = (s->setup_buf[5] << 8) | s->setup_buf[4];
190f1ae32a1SGerd Hoffmann
191f1ae32a1SGerd Hoffmann switch(s->setup_state) {
192f1ae32a1SGerd Hoffmann case SETUP_STATE_ACK:
193f1ae32a1SGerd Hoffmann if (!(s->setup_buf[0] & USB_DIR_IN)) {
194*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, true);
1959a77a0f5SHans de Goede usb_device_handle_control(s, p, request, value, index,
196f1ae32a1SGerd Hoffmann s->setup_len, s->data_buf);
1979a77a0f5SHans de Goede if (p->status == USB_RET_ASYNC) {
1989a77a0f5SHans de Goede return;
199f1ae32a1SGerd Hoffmann }
200f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_IDLE;
2019a77a0f5SHans de Goede p->actual_length = 0;
202*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
203f1ae32a1SGerd Hoffmann }
2049a77a0f5SHans de Goede break;
205f1ae32a1SGerd Hoffmann
206f1ae32a1SGerd Hoffmann case SETUP_STATE_DATA:
207f1ae32a1SGerd Hoffmann if (s->setup_buf[0] & USB_DIR_IN) {
208f1ae32a1SGerd Hoffmann int len = s->setup_len - s->setup_index;
209f1ae32a1SGerd Hoffmann if (len > p->iov.size) {
210f1ae32a1SGerd Hoffmann len = p->iov.size;
211f1ae32a1SGerd Hoffmann }
212f1ae32a1SGerd Hoffmann usb_packet_copy(p, s->data_buf + s->setup_index, len);
213f1ae32a1SGerd Hoffmann s->setup_index += len;
2149a77a0f5SHans de Goede if (s->setup_index >= s->setup_len) {
215f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_ACK;
216f1ae32a1SGerd Hoffmann }
2179a77a0f5SHans de Goede return;
2189a77a0f5SHans de Goede }
219f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_IDLE;
2209a77a0f5SHans de Goede p->status = USB_RET_STALL;
221*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
2229a77a0f5SHans de Goede break;
223f1ae32a1SGerd Hoffmann
224f1ae32a1SGerd Hoffmann default:
2259a77a0f5SHans de Goede p->status = USB_RET_STALL;
226f1ae32a1SGerd Hoffmann }
227f1ae32a1SGerd Hoffmann }
228f1ae32a1SGerd Hoffmann
do_token_out(USBDevice * s,USBPacket * p)2299a77a0f5SHans de Goede static void do_token_out(USBDevice *s, USBPacket *p)
230f1ae32a1SGerd Hoffmann {
231f1ae32a1SGerd Hoffmann assert(p->ep->nr == 0);
232f1ae32a1SGerd Hoffmann
233f1ae32a1SGerd Hoffmann switch(s->setup_state) {
234f1ae32a1SGerd Hoffmann case SETUP_STATE_ACK:
235f1ae32a1SGerd Hoffmann if (s->setup_buf[0] & USB_DIR_IN) {
236f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_IDLE;
237*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
238f1ae32a1SGerd Hoffmann /* transfer OK */
239f1ae32a1SGerd Hoffmann } else {
240f1ae32a1SGerd Hoffmann /* ignore additional output */
241f1ae32a1SGerd Hoffmann }
2429a77a0f5SHans de Goede break;
243f1ae32a1SGerd Hoffmann
244f1ae32a1SGerd Hoffmann case SETUP_STATE_DATA:
245f1ae32a1SGerd Hoffmann if (!(s->setup_buf[0] & USB_DIR_IN)) {
246f1ae32a1SGerd Hoffmann int len = s->setup_len - s->setup_index;
247f1ae32a1SGerd Hoffmann if (len > p->iov.size) {
248f1ae32a1SGerd Hoffmann len = p->iov.size;
249f1ae32a1SGerd Hoffmann }
250f1ae32a1SGerd Hoffmann usb_packet_copy(p, s->data_buf + s->setup_index, len);
251f1ae32a1SGerd Hoffmann s->setup_index += len;
2529a77a0f5SHans de Goede if (s->setup_index >= s->setup_len) {
253f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_ACK;
254f1ae32a1SGerd Hoffmann }
2559a77a0f5SHans de Goede return;
2569a77a0f5SHans de Goede }
257f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_IDLE;
2589a77a0f5SHans de Goede p->status = USB_RET_STALL;
259*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
2609a77a0f5SHans de Goede break;
261f1ae32a1SGerd Hoffmann
262f1ae32a1SGerd Hoffmann default:
2639a77a0f5SHans de Goede p->status = USB_RET_STALL;
264f1ae32a1SGerd Hoffmann }
265f1ae32a1SGerd Hoffmann }
266f1ae32a1SGerd Hoffmann
do_parameter(USBDevice * s,USBPacket * p)2679a77a0f5SHans de Goede static void do_parameter(USBDevice *s, USBPacket *p)
268f1ae32a1SGerd Hoffmann {
2699a77a0f5SHans de Goede int i, request, value, index;
270b946434fSGerd Hoffmann unsigned int setup_len;
271f1ae32a1SGerd Hoffmann
272f1ae32a1SGerd Hoffmann for (i = 0; i < 8; i++) {
273f1ae32a1SGerd Hoffmann s->setup_buf[i] = p->parameter >> (i*8);
274f1ae32a1SGerd Hoffmann }
275f1ae32a1SGerd Hoffmann
276f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_PARAM;
277f1ae32a1SGerd Hoffmann s->setup_index = 0;
278f1ae32a1SGerd Hoffmann
279f1ae32a1SGerd Hoffmann request = (s->setup_buf[0] << 8) | s->setup_buf[1];
280f1ae32a1SGerd Hoffmann value = (s->setup_buf[3] << 8) | s->setup_buf[2];
281f1ae32a1SGerd Hoffmann index = (s->setup_buf[5] << 8) | s->setup_buf[4];
282f1ae32a1SGerd Hoffmann
283b946434fSGerd Hoffmann setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
284b946434fSGerd Hoffmann if (setup_len > sizeof(s->data_buf)) {
285f1ae32a1SGerd Hoffmann fprintf(stderr,
286268c0242SAlex Chen "usb_generic_handle_packet: ctrl buffer too small (%u > %zu)\n",
287b946434fSGerd Hoffmann setup_len, sizeof(s->data_buf));
2889a77a0f5SHans de Goede p->status = USB_RET_STALL;
2899a77a0f5SHans de Goede return;
290f1ae32a1SGerd Hoffmann }
291b946434fSGerd Hoffmann s->setup_len = setup_len;
292f1ae32a1SGerd Hoffmann
293f1ae32a1SGerd Hoffmann if (p->pid == USB_TOKEN_OUT) {
294f1ae32a1SGerd Hoffmann usb_packet_copy(p, s->data_buf, s->setup_len);
295f1ae32a1SGerd Hoffmann }
296f1ae32a1SGerd Hoffmann
297*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, true);
2989a77a0f5SHans de Goede usb_device_handle_control(s, p, request, value, index,
299f1ae32a1SGerd Hoffmann s->setup_len, s->data_buf);
3009a77a0f5SHans de Goede if (p->status == USB_RET_ASYNC) {
3019a77a0f5SHans de Goede return;
302f1ae32a1SGerd Hoffmann }
303f1ae32a1SGerd Hoffmann
3049a77a0f5SHans de Goede if (p->actual_length < s->setup_len) {
3059a77a0f5SHans de Goede s->setup_len = p->actual_length;
306f1ae32a1SGerd Hoffmann }
307f1ae32a1SGerd Hoffmann if (p->pid == USB_TOKEN_IN) {
3089a77a0f5SHans de Goede p->actual_length = 0;
309f1ae32a1SGerd Hoffmann usb_packet_copy(p, s->data_buf, s->setup_len);
310f1ae32a1SGerd Hoffmann }
311*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
312f1ae32a1SGerd Hoffmann }
313f1ae32a1SGerd Hoffmann
314f1ae32a1SGerd Hoffmann /* ctrl complete function for devices which use usb_generic_handle_packet and
315f1ae32a1SGerd Hoffmann may return USB_RET_ASYNC from their handle_control callback. Device code
316f1ae32a1SGerd Hoffmann which does this *must* call this function instead of the normal
317f1ae32a1SGerd Hoffmann usb_packet_complete to complete their async control packets. */
usb_generic_async_ctrl_complete(USBDevice * s,USBPacket * p)318f1ae32a1SGerd Hoffmann void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p)
319f1ae32a1SGerd Hoffmann {
3209a77a0f5SHans de Goede if (p->status < 0) {
321f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_IDLE;
322*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
323f1ae32a1SGerd Hoffmann }
324f1ae32a1SGerd Hoffmann
325f1ae32a1SGerd Hoffmann switch (s->setup_state) {
326f1ae32a1SGerd Hoffmann case SETUP_STATE_SETUP:
3279a77a0f5SHans de Goede if (p->actual_length < s->setup_len) {
3289a77a0f5SHans de Goede s->setup_len = p->actual_length;
329f1ae32a1SGerd Hoffmann }
330f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_DATA;
3319a77a0f5SHans de Goede p->actual_length = 8;
332f1ae32a1SGerd Hoffmann break;
333f1ae32a1SGerd Hoffmann
334f1ae32a1SGerd Hoffmann case SETUP_STATE_ACK:
335f1ae32a1SGerd Hoffmann s->setup_state = SETUP_STATE_IDLE;
3369a77a0f5SHans de Goede p->actual_length = 0;
337*0f6dba14SGerd Hoffmann usb_pcap_ctrl(p, false);
338f1ae32a1SGerd Hoffmann break;
339f1ae32a1SGerd Hoffmann
340f1ae32a1SGerd Hoffmann case SETUP_STATE_PARAM:
3419a77a0f5SHans de Goede if (p->actual_length < s->setup_len) {
3429a77a0f5SHans de Goede s->setup_len = p->actual_length;
343f1ae32a1SGerd Hoffmann }
344f1ae32a1SGerd Hoffmann if (p->pid == USB_TOKEN_IN) {
3459a77a0f5SHans de Goede p->actual_length = 0;
346f1ae32a1SGerd Hoffmann usb_packet_copy(p, s->data_buf, s->setup_len);
347f1ae32a1SGerd Hoffmann }
348f1ae32a1SGerd Hoffmann break;
349f1ae32a1SGerd Hoffmann
350f1ae32a1SGerd Hoffmann default:
351f1ae32a1SGerd Hoffmann break;
352f1ae32a1SGerd Hoffmann }
353f1ae32a1SGerd Hoffmann usb_packet_complete(s, p);
354f1ae32a1SGerd Hoffmann }
355f1ae32a1SGerd Hoffmann
usb_find_device(USBPort * port,uint8_t addr)356f1ae32a1SGerd Hoffmann USBDevice *usb_find_device(USBPort *port, uint8_t addr)
357f1ae32a1SGerd Hoffmann {
358f1ae32a1SGerd Hoffmann USBDevice *dev = port->dev;
359f1ae32a1SGerd Hoffmann
360f1ae32a1SGerd Hoffmann if (dev == NULL || !dev->attached || dev->state != USB_STATE_DEFAULT) {
361f1ae32a1SGerd Hoffmann return NULL;
362f1ae32a1SGerd Hoffmann }
363f1ae32a1SGerd Hoffmann if (dev->addr == addr) {
364f1ae32a1SGerd Hoffmann return dev;
365f1ae32a1SGerd Hoffmann }
366f1ae32a1SGerd Hoffmann return usb_device_find_device(dev, addr);
367f1ae32a1SGerd Hoffmann }
368f1ae32a1SGerd Hoffmann
usb_process_one(USBPacket * p)3699a77a0f5SHans de Goede static void usb_process_one(USBPacket *p)
370f1ae32a1SGerd Hoffmann {
371f1ae32a1SGerd Hoffmann USBDevice *dev = p->ep->dev;
372*0f6dba14SGerd Hoffmann bool nak;
373f1ae32a1SGerd Hoffmann
3749a77a0f5SHans de Goede /*
3759a77a0f5SHans de Goede * Handlers expect status to be initialized to USB_RET_SUCCESS, but it
3769a77a0f5SHans de Goede * can be USB_RET_NAK here from a previous usb_process_one() call,
3779a77a0f5SHans de Goede * or USB_RET_ASYNC from going through usb_queue_one().
3789a77a0f5SHans de Goede */
379*0f6dba14SGerd Hoffmann nak = (p->status == USB_RET_NAK);
3809a77a0f5SHans de Goede p->status = USB_RET_SUCCESS;
3819a77a0f5SHans de Goede
382f1ae32a1SGerd Hoffmann if (p->ep->nr == 0) {
383f1ae32a1SGerd Hoffmann /* control pipe */
384f1ae32a1SGerd Hoffmann if (p->parameter) {
3859a77a0f5SHans de Goede do_parameter(dev, p);
3869a77a0f5SHans de Goede return;
387f1ae32a1SGerd Hoffmann }
388f1ae32a1SGerd Hoffmann switch (p->pid) {
389f1ae32a1SGerd Hoffmann case USB_TOKEN_SETUP:
3909a77a0f5SHans de Goede do_token_setup(dev, p);
3919a77a0f5SHans de Goede break;
392f1ae32a1SGerd Hoffmann case USB_TOKEN_IN:
3939a77a0f5SHans de Goede do_token_in(dev, p);
3949a77a0f5SHans de Goede break;
395f1ae32a1SGerd Hoffmann case USB_TOKEN_OUT:
3969a77a0f5SHans de Goede do_token_out(dev, p);
3979a77a0f5SHans de Goede break;
398f1ae32a1SGerd Hoffmann default:
3999a77a0f5SHans de Goede p->status = USB_RET_STALL;
400f1ae32a1SGerd Hoffmann }
401f1ae32a1SGerd Hoffmann } else {
402f1ae32a1SGerd Hoffmann /* data pipe */
403*0f6dba14SGerd Hoffmann if (!nak) {
404*0f6dba14SGerd Hoffmann usb_pcap_data(p, true);
405*0f6dba14SGerd Hoffmann }
4069a77a0f5SHans de Goede usb_device_handle_data(dev, p);
407f1ae32a1SGerd Hoffmann }
408f1ae32a1SGerd Hoffmann }
409f1ae32a1SGerd Hoffmann
usb_queue_one(USBPacket * p)4109a77a0f5SHans de Goede static void usb_queue_one(USBPacket *p)
4119a77a0f5SHans de Goede {
4129a77a0f5SHans de Goede usb_packet_set_state(p, USB_PACKET_QUEUED);
4139a77a0f5SHans de Goede QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue);
4149a77a0f5SHans de Goede p->status = USB_RET_ASYNC;
4159a77a0f5SHans de Goede }
4169a77a0f5SHans de Goede
4179a77a0f5SHans de Goede /* Hand over a packet to a device for processing. p->status ==
418f1ae32a1SGerd Hoffmann USB_RET_ASYNC indicates the processing isn't finished yet, the
419f1ae32a1SGerd Hoffmann driver will call usb_packet_complete() when done processing it. */
usb_handle_packet(USBDevice * dev,USBPacket * p)4209a77a0f5SHans de Goede void usb_handle_packet(USBDevice *dev, USBPacket *p)
421f1ae32a1SGerd Hoffmann {
422f1ae32a1SGerd Hoffmann if (dev == NULL) {
4239a77a0f5SHans de Goede p->status = USB_RET_NODEV;
4249a77a0f5SHans de Goede return;
425f1ae32a1SGerd Hoffmann }
426f1ae32a1SGerd Hoffmann assert(dev == p->ep->dev);
427f1ae32a1SGerd Hoffmann assert(dev->state == USB_STATE_DEFAULT);
4285ac2731cSGerd Hoffmann usb_packet_check_state(p, USB_PACKET_SETUP);
429f1ae32a1SGerd Hoffmann assert(p->ep != NULL);
430f1ae32a1SGerd Hoffmann
4310132b4b6SHans de Goede /* Submitting a new packet clears halt */
4320132b4b6SHans de Goede if (p->ep->halted) {
4330132b4b6SHans de Goede assert(QTAILQ_EMPTY(&p->ep->queue));
4340132b4b6SHans de Goede p->ep->halted = false;
4350132b4b6SHans de Goede }
4360132b4b6SHans de Goede
437c96c41edSGerd Hoffmann if (QTAILQ_EMPTY(&p->ep->queue) || p->ep->pipeline || p->stream) {
4389a77a0f5SHans de Goede usb_process_one(p);
4399a77a0f5SHans de Goede if (p->status == USB_RET_ASYNC) {
440be41efdeSHans de Goede /* hcd drivers cannot handle async for isoc */
441aaac7434SHans de Goede assert(p->ep->type != USB_ENDPOINT_XFER_ISOC);
442be41efdeSHans de Goede /* using async for interrupt packets breaks migration */
443be41efdeSHans de Goede assert(p->ep->type != USB_ENDPOINT_XFER_INT ||
44475633529SMichael Marineau (dev->flags & (1 << USB_DEV_FLAG_IS_HOST)));
445f1ae32a1SGerd Hoffmann usb_packet_set_state(p, USB_PACKET_ASYNC);
446f1ae32a1SGerd Hoffmann QTAILQ_INSERT_TAIL(&p->ep->queue, p, queue);
4479a77a0f5SHans de Goede } else if (p->status == USB_RET_ADD_TO_QUEUE) {
4489a77a0f5SHans de Goede usb_queue_one(p);
449f1ae32a1SGerd Hoffmann } else {
4500132b4b6SHans de Goede /*
4510132b4b6SHans de Goede * When pipelining is enabled usb-devices must always return async,
4520132b4b6SHans de Goede * otherwise packets can complete out of order!
4530132b4b6SHans de Goede */
454c96c41edSGerd Hoffmann assert(p->stream || !p->ep->pipeline ||
455c96c41edSGerd Hoffmann QTAILQ_EMPTY(&p->ep->queue));
4569a77a0f5SHans de Goede if (p->status != USB_RET_NAK) {
457*0f6dba14SGerd Hoffmann usb_pcap_data(p, false);
458f1ae32a1SGerd Hoffmann usb_packet_set_state(p, USB_PACKET_COMPLETE);
459f1ae32a1SGerd Hoffmann }
460cc409974SHans de Goede }
461f1ae32a1SGerd Hoffmann } else {
4629a77a0f5SHans de Goede usb_queue_one(p);
463f1ae32a1SGerd Hoffmann }
464f1ae32a1SGerd Hoffmann }
465f1ae32a1SGerd Hoffmann
usb_packet_complete_one(USBDevice * dev,USBPacket * p)466d0ff81b8SHans de Goede void usb_packet_complete_one(USBDevice *dev, USBPacket *p)
4670132b4b6SHans de Goede {
4680132b4b6SHans de Goede USBEndpoint *ep = p->ep;
4690132b4b6SHans de Goede
470c96c41edSGerd Hoffmann assert(p->stream || QTAILQ_FIRST(&ep->queue) == p);
4719a77a0f5SHans de Goede assert(p->status != USB_RET_ASYNC && p->status != USB_RET_NAK);
4720132b4b6SHans de Goede
4739a77a0f5SHans de Goede if (p->status != USB_RET_SUCCESS ||
4749a77a0f5SHans de Goede (p->short_not_ok && (p->actual_length < p->iov.size))) {
4750132b4b6SHans de Goede ep->halted = true;
4760132b4b6SHans de Goede }
477*0f6dba14SGerd Hoffmann usb_pcap_data(p, false);
4780132b4b6SHans de Goede usb_packet_set_state(p, USB_PACKET_COMPLETE);
4790132b4b6SHans de Goede QTAILQ_REMOVE(&ep->queue, p, queue);
4800132b4b6SHans de Goede dev->port->ops->complete(dev->port, p);
4810132b4b6SHans de Goede }
4820132b4b6SHans de Goede
483f1ae32a1SGerd Hoffmann /* Notify the controller that an async packet is complete. This should only
484f1ae32a1SGerd Hoffmann be called for packets previously deferred by returning USB_RET_ASYNC from
485f1ae32a1SGerd Hoffmann handle_packet. */
usb_packet_complete(USBDevice * dev,USBPacket * p)486f1ae32a1SGerd Hoffmann void usb_packet_complete(USBDevice *dev, USBPacket *p)
487f1ae32a1SGerd Hoffmann {
488f1ae32a1SGerd Hoffmann USBEndpoint *ep = p->ep;
489f1ae32a1SGerd Hoffmann
4905ac2731cSGerd Hoffmann usb_packet_check_state(p, USB_PACKET_ASYNC);
491d0ff81b8SHans de Goede usb_packet_complete_one(dev, p);
492f1ae32a1SGerd Hoffmann
4930cae7b1aSHans de Goede while (!QTAILQ_EMPTY(&ep->queue)) {
494f1ae32a1SGerd Hoffmann p = QTAILQ_FIRST(&ep->queue);
4950cae7b1aSHans de Goede if (ep->halted) {
4960cae7b1aSHans de Goede /* Empty the queue on a halt */
4979a77a0f5SHans de Goede p->status = USB_RET_REMOVE_FROM_QUEUE;
4980cae7b1aSHans de Goede dev->port->ops->complete(dev->port, p);
4990cae7b1aSHans de Goede continue;
5000cae7b1aSHans de Goede }
501f1ae32a1SGerd Hoffmann if (p->state == USB_PACKET_ASYNC) {
502f1ae32a1SGerd Hoffmann break;
503f1ae32a1SGerd Hoffmann }
5045ac2731cSGerd Hoffmann usb_packet_check_state(p, USB_PACKET_QUEUED);
5059a77a0f5SHans de Goede usb_process_one(p);
5069a77a0f5SHans de Goede if (p->status == USB_RET_ASYNC) {
507f1ae32a1SGerd Hoffmann usb_packet_set_state(p, USB_PACKET_ASYNC);
508f1ae32a1SGerd Hoffmann break;
509f1ae32a1SGerd Hoffmann }
510d0ff81b8SHans de Goede usb_packet_complete_one(ep->dev, p);
511f1ae32a1SGerd Hoffmann }
512f1ae32a1SGerd Hoffmann }
513f1ae32a1SGerd Hoffmann
514f1ae32a1SGerd Hoffmann /* Cancel an active packet. The packed must have been deferred by
515f1ae32a1SGerd Hoffmann returning USB_RET_ASYNC from handle_packet, and not yet
516f1ae32a1SGerd Hoffmann completed. */
usb_cancel_packet(USBPacket * p)517f1ae32a1SGerd Hoffmann void usb_cancel_packet(USBPacket * p)
518f1ae32a1SGerd Hoffmann {
519f1ae32a1SGerd Hoffmann bool callback = (p->state == USB_PACKET_ASYNC);
520f1ae32a1SGerd Hoffmann assert(usb_packet_is_inflight(p));
521f1ae32a1SGerd Hoffmann usb_packet_set_state(p, USB_PACKET_CANCELED);
522f1ae32a1SGerd Hoffmann QTAILQ_REMOVE(&p->ep->queue, p, queue);
523f1ae32a1SGerd Hoffmann if (callback) {
524f1ae32a1SGerd Hoffmann usb_device_cancel_packet(p->ep->dev, p);
525f1ae32a1SGerd Hoffmann }
526f1ae32a1SGerd Hoffmann }
527f1ae32a1SGerd Hoffmann
528f1ae32a1SGerd Hoffmann
usb_packet_init(USBPacket * p)529f1ae32a1SGerd Hoffmann void usb_packet_init(USBPacket *p)
530f1ae32a1SGerd Hoffmann {
531f1ae32a1SGerd Hoffmann qemu_iovec_init(&p->iov, 1);
532f1ae32a1SGerd Hoffmann }
533f1ae32a1SGerd Hoffmann
usb_packet_state_name(USBPacketState state)5345ac2731cSGerd Hoffmann static const char *usb_packet_state_name(USBPacketState state)
535f1ae32a1SGerd Hoffmann {
536f1ae32a1SGerd Hoffmann static const char *name[] = {
537f1ae32a1SGerd Hoffmann [USB_PACKET_UNDEFINED] = "undef",
538f1ae32a1SGerd Hoffmann [USB_PACKET_SETUP] = "setup",
539f1ae32a1SGerd Hoffmann [USB_PACKET_QUEUED] = "queued",
540f1ae32a1SGerd Hoffmann [USB_PACKET_ASYNC] = "async",
541f1ae32a1SGerd Hoffmann [USB_PACKET_COMPLETE] = "complete",
542f1ae32a1SGerd Hoffmann [USB_PACKET_CANCELED] = "canceled",
543f1ae32a1SGerd Hoffmann };
5445ac2731cSGerd Hoffmann if (state < ARRAY_SIZE(name)) {
5455ac2731cSGerd Hoffmann return name[state];
5465ac2731cSGerd Hoffmann }
5475ac2731cSGerd Hoffmann return "INVALID";
5485ac2731cSGerd Hoffmann }
5495ac2731cSGerd Hoffmann
usb_packet_check_state(USBPacket * p,USBPacketState expected)5505ac2731cSGerd Hoffmann void usb_packet_check_state(USBPacket *p, USBPacketState expected)
5515ac2731cSGerd Hoffmann {
5525ac2731cSGerd Hoffmann USBDevice *dev;
5535ac2731cSGerd Hoffmann USBBus *bus;
5545ac2731cSGerd Hoffmann
5555ac2731cSGerd Hoffmann if (p->state == expected) {
5565ac2731cSGerd Hoffmann return;
5575ac2731cSGerd Hoffmann }
5585ac2731cSGerd Hoffmann dev = p->ep->dev;
5595ac2731cSGerd Hoffmann bus = usb_bus_from_device(dev);
5605ac2731cSGerd Hoffmann trace_usb_packet_state_fault(bus->busnr, dev->port->path, p->ep->nr, p,
5615ac2731cSGerd Hoffmann usb_packet_state_name(p->state),
5625ac2731cSGerd Hoffmann usb_packet_state_name(expected));
5635ac2731cSGerd Hoffmann assert(!"usb packet state check failed");
5645ac2731cSGerd Hoffmann }
5655ac2731cSGerd Hoffmann
usb_packet_set_state(USBPacket * p,USBPacketState state)5665ac2731cSGerd Hoffmann void usb_packet_set_state(USBPacket *p, USBPacketState state)
5675ac2731cSGerd Hoffmann {
568f5bf14bfSGerd Hoffmann if (p->ep) {
569f1ae32a1SGerd Hoffmann USBDevice *dev = p->ep->dev;
570f1ae32a1SGerd Hoffmann USBBus *bus = usb_bus_from_device(dev);
5715ac2731cSGerd Hoffmann trace_usb_packet_state_change(bus->busnr, dev->port->path, p->ep->nr, p,
5725ac2731cSGerd Hoffmann usb_packet_state_name(p->state),
5735ac2731cSGerd Hoffmann usb_packet_state_name(state));
574f5bf14bfSGerd Hoffmann } else {
575f5bf14bfSGerd Hoffmann trace_usb_packet_state_change(-1, "", -1, p,
576f5bf14bfSGerd Hoffmann usb_packet_state_name(p->state),
577f5bf14bfSGerd Hoffmann usb_packet_state_name(state));
578f5bf14bfSGerd Hoffmann }
579f1ae32a1SGerd Hoffmann p->state = state;
580f1ae32a1SGerd Hoffmann }
581f1ae32a1SGerd Hoffmann
usb_packet_setup(USBPacket * p,int pid,USBEndpoint * ep,unsigned int stream,uint64_t id,bool short_not_ok,bool int_req)5828550a02dSGerd Hoffmann void usb_packet_setup(USBPacket *p, int pid,
5838550a02dSGerd Hoffmann USBEndpoint *ep, unsigned int stream,
5848550a02dSGerd Hoffmann uint64_t id, bool short_not_ok, bool int_req)
585f1ae32a1SGerd Hoffmann {
586f1ae32a1SGerd Hoffmann assert(!usb_packet_is_inflight(p));
5870cc6a0f1SGerd Hoffmann assert(p->iov.iov != NULL);
588e983395dSGerd Hoffmann p->id = id;
589f1ae32a1SGerd Hoffmann p->pid = pid;
590f1ae32a1SGerd Hoffmann p->ep = ep;
5918550a02dSGerd Hoffmann p->stream = stream;
5929a77a0f5SHans de Goede p->status = USB_RET_SUCCESS;
5939a77a0f5SHans de Goede p->actual_length = 0;
594f1ae32a1SGerd Hoffmann p->parameter = 0;
5956ba43f1fSHans de Goede p->short_not_ok = short_not_ok;
596a6fb2ddbSHans de Goede p->int_req = int_req;
597a552a966SHans de Goede p->combined = NULL;
598f1ae32a1SGerd Hoffmann qemu_iovec_reset(&p->iov);
599f1ae32a1SGerd Hoffmann usb_packet_set_state(p, USB_PACKET_SETUP);
600f1ae32a1SGerd Hoffmann }
601f1ae32a1SGerd Hoffmann
usb_packet_addbuf(USBPacket * p,void * ptr,size_t len)602f1ae32a1SGerd Hoffmann void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len)
603f1ae32a1SGerd Hoffmann {
604f1ae32a1SGerd Hoffmann qemu_iovec_add(&p->iov, ptr, len);
605f1ae32a1SGerd Hoffmann }
606f1ae32a1SGerd Hoffmann
usb_packet_copy(USBPacket * p,void * ptr,size_t bytes)607f1ae32a1SGerd Hoffmann void usb_packet_copy(USBPacket *p, void *ptr, size_t bytes)
608f1ae32a1SGerd Hoffmann {
6096a98d1c0SGerd Hoffmann QEMUIOVector *iov = p->combined ? &p->combined->iov : &p->iov;
6106a98d1c0SGerd Hoffmann
6119a77a0f5SHans de Goede assert(p->actual_length >= 0);
6126a98d1c0SGerd Hoffmann assert(p->actual_length + bytes <= iov->size);
613f1ae32a1SGerd Hoffmann switch (p->pid) {
614f1ae32a1SGerd Hoffmann case USB_TOKEN_SETUP:
615f1ae32a1SGerd Hoffmann case USB_TOKEN_OUT:
6166a98d1c0SGerd Hoffmann iov_to_buf(iov->iov, iov->niov, p->actual_length, ptr, bytes);
617f1ae32a1SGerd Hoffmann break;
618f1ae32a1SGerd Hoffmann case USB_TOKEN_IN:
6196a98d1c0SGerd Hoffmann iov_from_buf(iov->iov, iov->niov, p->actual_length, ptr, bytes);
620f1ae32a1SGerd Hoffmann break;
621f1ae32a1SGerd Hoffmann default:
622f1ae32a1SGerd Hoffmann fprintf(stderr, "%s: invalid pid: %x\n", __func__, p->pid);
623f1ae32a1SGerd Hoffmann abort();
624f1ae32a1SGerd Hoffmann }
6259a77a0f5SHans de Goede p->actual_length += bytes;
626f1ae32a1SGerd Hoffmann }
627f1ae32a1SGerd Hoffmann
usb_packet_skip(USBPacket * p,size_t bytes)628f1ae32a1SGerd Hoffmann void usb_packet_skip(USBPacket *p, size_t bytes)
629f1ae32a1SGerd Hoffmann {
6306a98d1c0SGerd Hoffmann QEMUIOVector *iov = p->combined ? &p->combined->iov : &p->iov;
6316a98d1c0SGerd Hoffmann
6329a77a0f5SHans de Goede assert(p->actual_length >= 0);
6336a98d1c0SGerd Hoffmann assert(p->actual_length + bytes <= iov->size);
634f1ae32a1SGerd Hoffmann if (p->pid == USB_TOKEN_IN) {
6356a98d1c0SGerd Hoffmann iov_memset(iov->iov, iov->niov, p->actual_length, 0, bytes);
636f1ae32a1SGerd Hoffmann }
6379a77a0f5SHans de Goede p->actual_length += bytes;
638f1ae32a1SGerd Hoffmann }
639f1ae32a1SGerd Hoffmann
usb_packet_size(USBPacket * p)6406a98d1c0SGerd Hoffmann size_t usb_packet_size(USBPacket *p)
6416a98d1c0SGerd Hoffmann {
6426a98d1c0SGerd Hoffmann return p->combined ? p->combined->iov.size : p->iov.size;
6436a98d1c0SGerd Hoffmann }
6446a98d1c0SGerd Hoffmann
usb_packet_cleanup(USBPacket * p)645f1ae32a1SGerd Hoffmann void usb_packet_cleanup(USBPacket *p)
646f1ae32a1SGerd Hoffmann {
647f1ae32a1SGerd Hoffmann assert(!usb_packet_is_inflight(p));
648f1ae32a1SGerd Hoffmann qemu_iovec_destroy(&p->iov);
649f1ae32a1SGerd Hoffmann }
650f1ae32a1SGerd Hoffmann
usb_ep_reset(USBDevice * dev)65119deaa08SGerd Hoffmann void usb_ep_reset(USBDevice *dev)
652f1ae32a1SGerd Hoffmann {
653f1ae32a1SGerd Hoffmann int ep;
654f1ae32a1SGerd Hoffmann
655f1ae32a1SGerd Hoffmann dev->ep_ctl.nr = 0;
656f1ae32a1SGerd Hoffmann dev->ep_ctl.type = USB_ENDPOINT_XFER_CONTROL;
657f1ae32a1SGerd Hoffmann dev->ep_ctl.ifnum = 0;
6589adbaad3SHans de Goede dev->ep_ctl.max_packet_size = 64;
65904b300f8SHans de Goede dev->ep_ctl.max_streams = 0;
660f1ae32a1SGerd Hoffmann dev->ep_ctl.dev = dev;
661f1ae32a1SGerd Hoffmann dev->ep_ctl.pipeline = false;
662f1ae32a1SGerd Hoffmann for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
663f1ae32a1SGerd Hoffmann dev->ep_in[ep].nr = ep + 1;
664f1ae32a1SGerd Hoffmann dev->ep_out[ep].nr = ep + 1;
665f1ae32a1SGerd Hoffmann dev->ep_in[ep].pid = USB_TOKEN_IN;
666f1ae32a1SGerd Hoffmann dev->ep_out[ep].pid = USB_TOKEN_OUT;
667f1ae32a1SGerd Hoffmann dev->ep_in[ep].type = USB_ENDPOINT_XFER_INVALID;
668f1ae32a1SGerd Hoffmann dev->ep_out[ep].type = USB_ENDPOINT_XFER_INVALID;
6697c37e6a4SGerd Hoffmann dev->ep_in[ep].ifnum = USB_INTERFACE_INVALID;
6707c37e6a4SGerd Hoffmann dev->ep_out[ep].ifnum = USB_INTERFACE_INVALID;
6719adbaad3SHans de Goede dev->ep_in[ep].max_packet_size = 0;
6729adbaad3SHans de Goede dev->ep_out[ep].max_packet_size = 0;
67304b300f8SHans de Goede dev->ep_in[ep].max_streams = 0;
67404b300f8SHans de Goede dev->ep_out[ep].max_streams = 0;
675f1ae32a1SGerd Hoffmann dev->ep_in[ep].dev = dev;
676f1ae32a1SGerd Hoffmann dev->ep_out[ep].dev = dev;
677f1ae32a1SGerd Hoffmann dev->ep_in[ep].pipeline = false;
678f1ae32a1SGerd Hoffmann dev->ep_out[ep].pipeline = false;
67919deaa08SGerd Hoffmann }
68019deaa08SGerd Hoffmann }
68119deaa08SGerd Hoffmann
usb_ep_init(USBDevice * dev)68219deaa08SGerd Hoffmann void usb_ep_init(USBDevice *dev)
68319deaa08SGerd Hoffmann {
68419deaa08SGerd Hoffmann int ep;
68519deaa08SGerd Hoffmann
68619deaa08SGerd Hoffmann usb_ep_reset(dev);
68719deaa08SGerd Hoffmann QTAILQ_INIT(&dev->ep_ctl.queue);
68819deaa08SGerd Hoffmann for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
689f1ae32a1SGerd Hoffmann QTAILQ_INIT(&dev->ep_in[ep].queue);
690f1ae32a1SGerd Hoffmann QTAILQ_INIT(&dev->ep_out[ep].queue);
691f1ae32a1SGerd Hoffmann }
692f1ae32a1SGerd Hoffmann }
693f1ae32a1SGerd Hoffmann
usb_ep_dump(USBDevice * dev)694f1ae32a1SGerd Hoffmann void usb_ep_dump(USBDevice *dev)
695f1ae32a1SGerd Hoffmann {
696f1ae32a1SGerd Hoffmann static const char *tname[] = {
697f1ae32a1SGerd Hoffmann [USB_ENDPOINT_XFER_CONTROL] = "control",
698f1ae32a1SGerd Hoffmann [USB_ENDPOINT_XFER_ISOC] = "isoc",
699f1ae32a1SGerd Hoffmann [USB_ENDPOINT_XFER_BULK] = "bulk",
700f1ae32a1SGerd Hoffmann [USB_ENDPOINT_XFER_INT] = "int",
701f1ae32a1SGerd Hoffmann };
702f1ae32a1SGerd Hoffmann int ifnum, ep, first;
703f1ae32a1SGerd Hoffmann
704f1ae32a1SGerd Hoffmann fprintf(stderr, "Device \"%s\", config %d\n",
705f1ae32a1SGerd Hoffmann dev->product_desc, dev->configuration);
706f1ae32a1SGerd Hoffmann for (ifnum = 0; ifnum < 16; ifnum++) {
707f1ae32a1SGerd Hoffmann first = 1;
708f1ae32a1SGerd Hoffmann for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) {
709f1ae32a1SGerd Hoffmann if (dev->ep_in[ep].type != USB_ENDPOINT_XFER_INVALID &&
710f1ae32a1SGerd Hoffmann dev->ep_in[ep].ifnum == ifnum) {
711f1ae32a1SGerd Hoffmann if (first) {
712f1ae32a1SGerd Hoffmann first = 0;
713f1ae32a1SGerd Hoffmann fprintf(stderr, " Interface %d, alternative %d\n",
714f1ae32a1SGerd Hoffmann ifnum, dev->altsetting[ifnum]);
715f1ae32a1SGerd Hoffmann }
716f1ae32a1SGerd Hoffmann fprintf(stderr, " Endpoint %d, IN, %s, %d max\n", ep,
717f1ae32a1SGerd Hoffmann tname[dev->ep_in[ep].type],
718f1ae32a1SGerd Hoffmann dev->ep_in[ep].max_packet_size);
719f1ae32a1SGerd Hoffmann }
720f1ae32a1SGerd Hoffmann if (dev->ep_out[ep].type != USB_ENDPOINT_XFER_INVALID &&
721f1ae32a1SGerd Hoffmann dev->ep_out[ep].ifnum == ifnum) {
722f1ae32a1SGerd Hoffmann if (first) {
723f1ae32a1SGerd Hoffmann first = 0;
724f1ae32a1SGerd Hoffmann fprintf(stderr, " Interface %d, alternative %d\n",
725f1ae32a1SGerd Hoffmann ifnum, dev->altsetting[ifnum]);
726f1ae32a1SGerd Hoffmann }
727f1ae32a1SGerd Hoffmann fprintf(stderr, " Endpoint %d, OUT, %s, %d max\n", ep,
728f1ae32a1SGerd Hoffmann tname[dev->ep_out[ep].type],
729f1ae32a1SGerd Hoffmann dev->ep_out[ep].max_packet_size);
730f1ae32a1SGerd Hoffmann }
731f1ae32a1SGerd Hoffmann }
732f1ae32a1SGerd Hoffmann }
733f1ae32a1SGerd Hoffmann fprintf(stderr, "--\n");
734f1ae32a1SGerd Hoffmann }
735f1ae32a1SGerd Hoffmann
usb_ep_get(USBDevice * dev,int pid,int ep)736f1ae32a1SGerd Hoffmann struct USBEndpoint *usb_ep_get(USBDevice *dev, int pid, int ep)
737f1ae32a1SGerd Hoffmann {
738f1ae32a1SGerd Hoffmann struct USBEndpoint *eps;
739f1ae32a1SGerd Hoffmann
7407011baecSLiam Merwick assert(dev != NULL);
741f1ae32a1SGerd Hoffmann if (ep == 0) {
742f1ae32a1SGerd Hoffmann return &dev->ep_ctl;
743f1ae32a1SGerd Hoffmann }
744f1ae32a1SGerd Hoffmann assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
745f1ae32a1SGerd Hoffmann assert(ep > 0 && ep <= USB_MAX_ENDPOINTS);
74656090d78SLiam Merwick eps = (pid == USB_TOKEN_IN) ? dev->ep_in : dev->ep_out;
747f1ae32a1SGerd Hoffmann return eps + ep - 1;
748f1ae32a1SGerd Hoffmann }
749f1ae32a1SGerd Hoffmann
usb_ep_get_type(USBDevice * dev,int pid,int ep)750f1ae32a1SGerd Hoffmann uint8_t usb_ep_get_type(USBDevice *dev, int pid, int ep)
751f1ae32a1SGerd Hoffmann {
752f1ae32a1SGerd Hoffmann struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
753f1ae32a1SGerd Hoffmann return uep->type;
754f1ae32a1SGerd Hoffmann }
755f1ae32a1SGerd Hoffmann
usb_ep_set_type(USBDevice * dev,int pid,int ep,uint8_t type)756f1ae32a1SGerd Hoffmann void usb_ep_set_type(USBDevice *dev, int pid, int ep, uint8_t type)
757f1ae32a1SGerd Hoffmann {
758f1ae32a1SGerd Hoffmann struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
759f1ae32a1SGerd Hoffmann uep->type = type;
760f1ae32a1SGerd Hoffmann }
761f1ae32a1SGerd Hoffmann
usb_ep_set_ifnum(USBDevice * dev,int pid,int ep,uint8_t ifnum)762f1ae32a1SGerd Hoffmann void usb_ep_set_ifnum(USBDevice *dev, int pid, int ep, uint8_t ifnum)
763f1ae32a1SGerd Hoffmann {
764f1ae32a1SGerd Hoffmann struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
765f1ae32a1SGerd Hoffmann uep->ifnum = ifnum;
766f1ae32a1SGerd Hoffmann }
767f1ae32a1SGerd Hoffmann
usb_ep_set_max_packet_size(USBDevice * dev,int pid,int ep,uint16_t raw)768f1ae32a1SGerd Hoffmann void usb_ep_set_max_packet_size(USBDevice *dev, int pid, int ep,
769f1ae32a1SGerd Hoffmann uint16_t raw)
770f1ae32a1SGerd Hoffmann {
771f1ae32a1SGerd Hoffmann struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
772f1ae32a1SGerd Hoffmann int size, microframes;
773f1ae32a1SGerd Hoffmann
774f1ae32a1SGerd Hoffmann size = raw & 0x7ff;
775f1ae32a1SGerd Hoffmann switch ((raw >> 11) & 3) {
776f1ae32a1SGerd Hoffmann case 1:
777f1ae32a1SGerd Hoffmann microframes = 2;
778f1ae32a1SGerd Hoffmann break;
779f1ae32a1SGerd Hoffmann case 2:
780f1ae32a1SGerd Hoffmann microframes = 3;
781f1ae32a1SGerd Hoffmann break;
782f1ae32a1SGerd Hoffmann default:
783f1ae32a1SGerd Hoffmann microframes = 1;
784f1ae32a1SGerd Hoffmann break;
785f1ae32a1SGerd Hoffmann }
786f1ae32a1SGerd Hoffmann uep->max_packet_size = size * microframes;
787f1ae32a1SGerd Hoffmann }
788f1ae32a1SGerd Hoffmann
usb_ep_set_max_streams(USBDevice * dev,int pid,int ep,uint8_t raw)78904b300f8SHans de Goede void usb_ep_set_max_streams(USBDevice *dev, int pid, int ep, uint8_t raw)
79004b300f8SHans de Goede {
79104b300f8SHans de Goede struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
79204b300f8SHans de Goede int MaxStreams;
79304b300f8SHans de Goede
79404b300f8SHans de Goede MaxStreams = raw & 0x1f;
79504b300f8SHans de Goede if (MaxStreams) {
79604b300f8SHans de Goede uep->max_streams = 1 << MaxStreams;
79704b300f8SHans de Goede } else {
79804b300f8SHans de Goede uep->max_streams = 0;
79904b300f8SHans de Goede }
80004b300f8SHans de Goede }
80104b300f8SHans de Goede
usb_ep_set_halted(USBDevice * dev,int pid,int ep,bool halted)802e382d966SGerd Hoffmann void usb_ep_set_halted(USBDevice *dev, int pid, int ep, bool halted)
803e382d966SGerd Hoffmann {
804e382d966SGerd Hoffmann struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
805e382d966SGerd Hoffmann uep->halted = halted;
806e382d966SGerd Hoffmann }
807e382d966SGerd Hoffmann
usb_ep_find_packet_by_id(USBDevice * dev,int pid,int ep,uint64_t id)808c13a9e61SHans de Goede USBPacket *usb_ep_find_packet_by_id(USBDevice *dev, int pid, int ep,
809c13a9e61SHans de Goede uint64_t id)
810c13a9e61SHans de Goede {
811c13a9e61SHans de Goede struct USBEndpoint *uep = usb_ep_get(dev, pid, ep);
812c13a9e61SHans de Goede USBPacket *p;
813c13a9e61SHans de Goede
8146735d433SHans de Goede QTAILQ_FOREACH(p, &uep->queue, queue) {
815c13a9e61SHans de Goede if (p->id == id) {
816c13a9e61SHans de Goede return p;
817c13a9e61SHans de Goede }
818c13a9e61SHans de Goede }
819c13a9e61SHans de Goede
820c13a9e61SHans de Goede return NULL;
821c13a9e61SHans de Goede }
822