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
26 #include "qemu-common.h"
30 void usb_attach(USBPort
*port
)
32 USBDevice
*dev
= port
->dev
;
35 assert(dev
->attached
);
36 port
->ops
->attach(port
);
37 usb_send_msg(dev
, USB_MSG_ATTACH
);
40 void usb_detach(USBPort
*port
)
42 USBDevice
*dev
= port
->dev
;
45 port
->ops
->detach(port
);
46 usb_send_msg(dev
, USB_MSG_DETACH
);
49 void usb_wakeup(USBDevice
*dev
)
51 if (dev
->remote_wakeup
&& dev
->port
&& dev
->port
->ops
->wakeup
) {
52 dev
->port
->ops
->wakeup(dev
->port
);
56 /**********************/
58 /* generic USB device helpers (you are not forced to use them when
59 writing your USB device driver, but they help handling the
63 #define SETUP_STATE_IDLE 0
64 #define SETUP_STATE_SETUP 1
65 #define SETUP_STATE_DATA 2
66 #define SETUP_STATE_ACK 3
68 static int do_token_setup(USBDevice
*s
, USBPacket
*p
)
70 int request
, value
, index
;
73 if (p
->iov
.size
!= 8) {
77 usb_packet_copy(p
, s
->setup_buf
, p
->iov
.size
);
78 s
->setup_len
= (s
->setup_buf
[7] << 8) | s
->setup_buf
[6];
81 request
= (s
->setup_buf
[0] << 8) | s
->setup_buf
[1];
82 value
= (s
->setup_buf
[3] << 8) | s
->setup_buf
[2];
83 index
= (s
->setup_buf
[5] << 8) | s
->setup_buf
[4];
85 if (s
->setup_buf
[0] & USB_DIR_IN
) {
86 ret
= s
->info
->handle_control(s
, p
, request
, value
, index
,
87 s
->setup_len
, s
->data_buf
);
88 if (ret
== USB_RET_ASYNC
) {
89 s
->setup_state
= SETUP_STATE_SETUP
;
95 if (ret
< s
->setup_len
)
97 s
->setup_state
= SETUP_STATE_DATA
;
99 if (s
->setup_len
> sizeof(s
->data_buf
)) {
101 "usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
102 s
->setup_len
, sizeof(s
->data_buf
));
103 return USB_RET_STALL
;
105 if (s
->setup_len
== 0)
106 s
->setup_state
= SETUP_STATE_ACK
;
108 s
->setup_state
= SETUP_STATE_DATA
;
114 static int do_token_in(USBDevice
*s
, USBPacket
*p
)
116 int request
, value
, index
;
120 return s
->info
->handle_data(s
, p
);
122 request
= (s
->setup_buf
[0] << 8) | s
->setup_buf
[1];
123 value
= (s
->setup_buf
[3] << 8) | s
->setup_buf
[2];
124 index
= (s
->setup_buf
[5] << 8) | s
->setup_buf
[4];
126 switch(s
->setup_state
) {
127 case SETUP_STATE_ACK
:
128 if (!(s
->setup_buf
[0] & USB_DIR_IN
)) {
129 ret
= s
->info
->handle_control(s
, p
, request
, value
, index
,
130 s
->setup_len
, s
->data_buf
);
131 if (ret
== USB_RET_ASYNC
) {
132 return USB_RET_ASYNC
;
134 s
->setup_state
= SETUP_STATE_IDLE
;
143 case SETUP_STATE_DATA
:
144 if (s
->setup_buf
[0] & USB_DIR_IN
) {
145 int len
= s
->setup_len
- s
->setup_index
;
146 if (len
> p
->iov
.size
) {
149 usb_packet_copy(p
, s
->data_buf
+ s
->setup_index
, len
);
150 s
->setup_index
+= len
;
151 if (s
->setup_index
>= s
->setup_len
)
152 s
->setup_state
= SETUP_STATE_ACK
;
156 s
->setup_state
= SETUP_STATE_IDLE
;
157 return USB_RET_STALL
;
160 return USB_RET_STALL
;
164 static int do_token_out(USBDevice
*s
, USBPacket
*p
)
167 return s
->info
->handle_data(s
, p
);
169 switch(s
->setup_state
) {
170 case SETUP_STATE_ACK
:
171 if (s
->setup_buf
[0] & USB_DIR_IN
) {
172 s
->setup_state
= SETUP_STATE_IDLE
;
175 /* ignore additional output */
179 case SETUP_STATE_DATA
:
180 if (!(s
->setup_buf
[0] & USB_DIR_IN
)) {
181 int len
= s
->setup_len
- s
->setup_index
;
182 if (len
> p
->iov
.size
) {
185 usb_packet_copy(p
, s
->data_buf
+ s
->setup_index
, len
);
186 s
->setup_index
+= len
;
187 if (s
->setup_index
>= s
->setup_len
)
188 s
->setup_state
= SETUP_STATE_ACK
;
192 s
->setup_state
= SETUP_STATE_IDLE
;
193 return USB_RET_STALL
;
196 return USB_RET_STALL
;
201 * Generic packet handler.
202 * Called by the HC (host controller).
204 * Returns length of the transaction or one of the USB_RET_XXX codes.
206 int usb_generic_handle_packet(USBDevice
*s
, USBPacket
*p
)
210 s
->state
= USB_STATE_ATTACHED
;
211 if (s
->info
->handle_attach
) {
212 s
->info
->handle_attach(s
);
217 s
->state
= USB_STATE_NOTATTACHED
;
221 s
->remote_wakeup
= 0;
223 s
->state
= USB_STATE_DEFAULT
;
224 if (s
->info
->handle_reset
) {
225 s
->info
->handle_reset(s
);
230 /* Rest of the PIDs must match our address */
231 if (s
->state
< USB_STATE_DEFAULT
|| p
->devaddr
!= s
->addr
)
232 return USB_RET_NODEV
;
235 case USB_TOKEN_SETUP
:
236 return do_token_setup(s
, p
);
239 return do_token_in(s
, p
);
242 return do_token_out(s
, p
);
245 return USB_RET_STALL
;
249 /* ctrl complete function for devices which use usb_generic_handle_packet and
250 may return USB_RET_ASYNC from their handle_control callback. Device code
251 which does this *must* call this function instead of the normal
252 usb_packet_complete to complete their async control packets. */
253 void usb_generic_async_ctrl_complete(USBDevice
*s
, USBPacket
*p
)
256 s
->setup_state
= SETUP_STATE_IDLE
;
259 switch (s
->setup_state
) {
260 case SETUP_STATE_SETUP
:
261 if (p
->result
< s
->setup_len
) {
262 s
->setup_len
= p
->result
;
264 s
->setup_state
= SETUP_STATE_DATA
;
268 case SETUP_STATE_ACK
:
269 s
->setup_state
= SETUP_STATE_IDLE
;
276 usb_packet_complete(s
, p
);
279 /* XXX: fix overflow */
280 int set_usb_string(uint8_t *buf
, const char *str
)
289 for(i
= 0; i
< len
; i
++) {
296 /* Send an internal message to a USB device. */
297 void usb_send_msg(USBDevice
*dev
, int msg
)
302 memset(&p
, 0, sizeof(p
));
304 ret
= usb_handle_packet(dev
, &p
);
305 /* This _must_ be synchronous */
306 assert(ret
!= USB_RET_ASYNC
);
309 /* Hand over a packet to a device for processing. Return value
310 USB_RET_ASYNC indicates the processing isn't finished yet, the
311 driver will call usb_packet_complete() when done processing it. */
312 int usb_handle_packet(USBDevice
*dev
, USBPacket
*p
)
316 assert(p
->owner
== NULL
);
317 ret
= dev
->info
->handle_packet(dev
, p
);
318 if (ret
== USB_RET_ASYNC
) {
319 if (p
->owner
== NULL
) {
322 /* We'll end up here when usb_handle_packet is called
323 * recursively due to a hub being in the chain. Nothing
324 * to do. Leave p->owner pointing to the device, not the
331 /* Notify the controller that an async packet is complete. This should only
332 be called for packets previously deferred by returning USB_RET_ASYNC from
334 void usb_packet_complete(USBDevice
*dev
, USBPacket
*p
)
336 /* Note: p->owner != dev is possible in case dev is a hub */
337 assert(p
->owner
!= NULL
);
339 dev
->port
->ops
->complete(dev
->port
, p
);
342 /* Cancel an active packet. The packed must have been deferred by
343 returning USB_RET_ASYNC from handle_packet, and not yet
345 void usb_cancel_packet(USBPacket
* p
)
347 assert(p
->owner
!= NULL
);
348 p
->owner
->info
->cancel_packet(p
->owner
, p
);
353 void usb_packet_init(USBPacket
*p
)
355 qemu_iovec_init(&p
->iov
, 1);
358 void usb_packet_setup(USBPacket
*p
, int pid
, uint8_t addr
, uint8_t ep
)
364 qemu_iovec_reset(&p
->iov
);
367 void usb_packet_addbuf(USBPacket
*p
, void *ptr
, size_t len
)
369 qemu_iovec_add(&p
->iov
, ptr
, len
);
372 void usb_packet_copy(USBPacket
*p
, void *ptr
, size_t bytes
)
374 assert(p
->result
>= 0);
375 assert(p
->result
+ bytes
<= p
->iov
.size
);
377 case USB_TOKEN_SETUP
:
379 iov_to_buf(p
->iov
.iov
, p
->iov
.niov
, ptr
, p
->result
, bytes
);
382 iov_from_buf(p
->iov
.iov
, p
->iov
.niov
, ptr
, p
->result
, bytes
);
385 fprintf(stderr
, "%s: invalid pid: %x\n", __func__
, p
->pid
);
391 void usb_packet_skip(USBPacket
*p
, size_t bytes
)
393 assert(p
->result
>= 0);
394 assert(p
->result
+ bytes
<= p
->iov
.size
);
395 if (p
->pid
== USB_TOKEN_IN
) {
396 iov_clear(p
->iov
.iov
, p
->iov
.niov
, p
->result
, bytes
);
401 void usb_packet_cleanup(USBPacket
*p
)
403 qemu_iovec_destroy(&p
->iov
);