Statistics
| Branch: | Revision:

root / hw / usb.c @ 5fafdf24

History | View | Annotate | Download (6.5 kB)

1
/*
2
 * QEMU USB emulation
3
 *
4
 * Copyright (c) 2005 Fabrice Bellard
5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
7
 * of this software and associated documentation files (the "Software"), to deal
8
 * in the Software without restriction, including without limitation the rights
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
 * copies of the Software, and to permit persons to whom the Software is
11
 * furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
 * THE SOFTWARE.
23
 */
24
#include "vl.h"
25

    
26
void usb_attach(USBPort *port, USBDevice *dev)
27
{
28
    port->attach(port, dev);
29
}
30

    
31
/**********************/
32
/* generic USB device helpers (you are not forced to use them when
33
   writing your USB device driver, but they help handling the
34
   protocol)
35
*/
36

    
37
#define SETUP_STATE_IDLE 0
38
#define SETUP_STATE_DATA 1
39
#define SETUP_STATE_ACK  2
40

    
41
int usb_generic_handle_packet(USBDevice *s, USBPacket *p)
42
{
43
    int l, ret = 0;
44
    int len = p->len;
45
    uint8_t *data = p->data;
46

    
47
    switch(p->pid) {
48
    case USB_MSG_ATTACH:
49
        s->state = USB_STATE_ATTACHED;
50
        break;
51
    case USB_MSG_DETACH:
52
        s->state = USB_STATE_NOTATTACHED;
53
        break;
54
    case USB_MSG_RESET:
55
        s->remote_wakeup = 0;
56
        s->addr = 0;
57
        s->state = USB_STATE_DEFAULT;
58
        s->handle_reset(s);
59
        break;
60
    case USB_TOKEN_SETUP:
61
        if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
62
            return USB_RET_NODEV;
63
        if (len != 8)
64
            goto fail;
65
        memcpy(s->setup_buf, data, 8);
66
        s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6];
67
        s->setup_index = 0;
68
        if (s->setup_buf[0] & USB_DIR_IN) {
69
            ret = s->handle_control(s,
70
                                    (s->setup_buf[0] << 8) | s->setup_buf[1],
71
                                    (s->setup_buf[3] << 8) | s->setup_buf[2],
72
                                    (s->setup_buf[5] << 8) | s->setup_buf[4],
73
                                    s->setup_len,
74
                                    s->data_buf);
75
            if (ret < 0)
76
                return ret;
77
            if (ret < s->setup_len)
78
                s->setup_len = ret;
79
            s->setup_state = SETUP_STATE_DATA;
80
        } else {
81
            if (s->setup_len == 0)
82
                s->setup_state = SETUP_STATE_ACK;
83
            else
84
                s->setup_state = SETUP_STATE_DATA;
85
        }
86
        break;
87
    case USB_TOKEN_IN:
88
        if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
89
            return USB_RET_NODEV;
90
        switch(p->devep) {
91
        case 0:
92
            switch(s->setup_state) {
93
            case SETUP_STATE_ACK:
94
                if (!(s->setup_buf[0] & USB_DIR_IN)) {
95
                    s->setup_state = SETUP_STATE_IDLE;
96
                    ret = s->handle_control(s,
97
                                      (s->setup_buf[0] << 8) | s->setup_buf[1],
98
                                      (s->setup_buf[3] << 8) | s->setup_buf[2],
99
                                      (s->setup_buf[5] << 8) | s->setup_buf[4],
100
                                      s->setup_len,
101
                                      s->data_buf);
102
                    if (ret > 0)
103
                        ret = 0;
104
                } else {
105
                    /* return 0 byte */
106
                }
107
                break;
108
            case SETUP_STATE_DATA:
109
                if (s->setup_buf[0] & USB_DIR_IN) {
110
                    l = s->setup_len - s->setup_index;
111
                    if (l > len)
112
                        l = len;
113
                    memcpy(data, s->data_buf + s->setup_index, l);
114
                    s->setup_index += l;
115
                    if (s->setup_index >= s->setup_len)
116
                        s->setup_state = SETUP_STATE_ACK;
117
                    ret = l;
118
                } else {
119
                    s->setup_state = SETUP_STATE_IDLE;
120
                    goto fail;
121
                }
122
                break;
123
            default:
124
                goto fail;
125
            }
126
            break;
127
        default:
128
            ret = s->handle_data(s, p);
129
            break;
130
        }
131
        break;
132
    case USB_TOKEN_OUT:
133
        if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
134
            return USB_RET_NODEV;
135
        switch(p->devep) {
136
        case 0:
137
            switch(s->setup_state) {
138
            case SETUP_STATE_ACK:
139
                if (s->setup_buf[0] & USB_DIR_IN) {
140
                    s->setup_state = SETUP_STATE_IDLE;
141
                    /* transfer OK */
142
                } else {
143
                    /* ignore additional output */
144
                }
145
                break;
146
            case SETUP_STATE_DATA:
147
                if (!(s->setup_buf[0] & USB_DIR_IN)) {
148
                    l = s->setup_len - s->setup_index;
149
                    if (l > len)
150
                        l = len;
151
                    memcpy(s->data_buf + s->setup_index, data, l);
152
                    s->setup_index += l;
153
                    if (s->setup_index >= s->setup_len)
154
                        s->setup_state = SETUP_STATE_ACK;
155
                    ret = l;
156
                } else {
157
                    s->setup_state = SETUP_STATE_IDLE;
158
                    goto fail;
159
                }
160
                break;
161
            default:
162
                goto fail;
163
            }
164
            break;
165
        default:
166
            ret = s->handle_data(s, p);
167
            break;
168
        }
169
        break;
170
    default:
171
    fail:
172
        ret = USB_RET_STALL;
173
        break;
174
    }
175
    return ret;
176
}
177

    
178
/* XXX: fix overflow */
179
int set_usb_string(uint8_t *buf, const char *str)
180
{
181
    int len, i;
182
    uint8_t *q;
183

    
184
    q = buf;
185
    len = strlen(str);
186
    *q++ = 2 * len + 2;
187
    *q++ = 3;
188
    for(i = 0; i < len; i++) {
189
        *q++ = str[i];
190
        *q++ = 0;
191
    }
192
    return q - buf;
193
}
194

    
195
/* Send an internal message to a USB device.  */
196
void usb_send_msg(USBDevice *dev, int msg)
197
{
198
    USBPacket p;
199
    memset(&p, 0, sizeof(p));
200
    p.pid = msg;
201
    dev->handle_packet(dev, &p);
202
}
203