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 "usb.h" 28 29 void usb_attach(USBPort *port, USBDevice *dev) 30 { 31 if (dev != NULL) { 32 /* attach */ 33 if (port->dev) { 34 usb_attach(port, NULL); 35 } 36 dev->port = port; 37 port->dev = dev; 38 port->ops->attach(port); 39 usb_send_msg(dev, USB_MSG_ATTACH); 40 } else { 41 /* detach */ 42 dev = port->dev; 43 port->ops->detach(port); 44 if (dev) { 45 usb_send_msg(dev, USB_MSG_DETACH); 46 dev->port = NULL; 47 port->dev = NULL; 48 } 49 } 50 } 51 52 /**********************/ 53 54 /* generic USB device helpers (you are not forced to use them when 55 writing your USB device driver, but they help handling the 56 protocol) 57 */ 58 59 #define SETUP_STATE_IDLE 0 60 #define SETUP_STATE_DATA 1 61 #define SETUP_STATE_ACK 2 62 63 static int do_token_setup(USBDevice *s, USBPacket *p) 64 { 65 int request, value, index; 66 int ret = 0; 67 68 if (p->len != 8) 69 return USB_RET_STALL; 70 71 memcpy(s->setup_buf, p->data, 8); 72 s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6]; 73 s->setup_index = 0; 74 75 request = (s->setup_buf[0] << 8) | s->setup_buf[1]; 76 value = (s->setup_buf[3] << 8) | s->setup_buf[2]; 77 index = (s->setup_buf[5] << 8) | s->setup_buf[4]; 78 79 if (s->setup_buf[0] & USB_DIR_IN) { 80 ret = s->info->handle_control(s, request, value, index, 81 s->setup_len, s->data_buf); 82 if (ret < 0) 83 return ret; 84 85 if (ret < s->setup_len) 86 s->setup_len = ret; 87 s->setup_state = SETUP_STATE_DATA; 88 } else { 89 if (s->setup_len == 0) 90 s->setup_state = SETUP_STATE_ACK; 91 else 92 s->setup_state = SETUP_STATE_DATA; 93 } 94 95 return ret; 96 } 97 98 static int do_token_in(USBDevice *s, USBPacket *p) 99 { 100 int request, value, index; 101 int ret = 0; 102 103 if (p->devep != 0) 104 return s->info->handle_data(s, p); 105 106 request = (s->setup_buf[0] << 8) | s->setup_buf[1]; 107 value = (s->setup_buf[3] << 8) | s->setup_buf[2]; 108 index = (s->setup_buf[5] << 8) | s->setup_buf[4]; 109 110 switch(s->setup_state) { 111 case SETUP_STATE_ACK: 112 if (!(s->setup_buf[0] & USB_DIR_IN)) { 113 s->setup_state = SETUP_STATE_IDLE; 114 ret = s->info->handle_control(s, request, value, index, 115 s->setup_len, s->data_buf); 116 if (ret > 0) 117 return 0; 118 return ret; 119 } 120 121 /* return 0 byte */ 122 return 0; 123 124 case SETUP_STATE_DATA: 125 if (s->setup_buf[0] & USB_DIR_IN) { 126 int len = s->setup_len - s->setup_index; 127 if (len > p->len) 128 len = p->len; 129 memcpy(p->data, s->data_buf + s->setup_index, len); 130 s->setup_index += len; 131 if (s->setup_index >= s->setup_len) 132 s->setup_state = SETUP_STATE_ACK; 133 return len; 134 } 135 136 s->setup_state = SETUP_STATE_IDLE; 137 return USB_RET_STALL; 138 139 default: 140 return USB_RET_STALL; 141 } 142 } 143 144 static int do_token_out(USBDevice *s, USBPacket *p) 145 { 146 if (p->devep != 0) 147 return s->info->handle_data(s, p); 148 149 switch(s->setup_state) { 150 case SETUP_STATE_ACK: 151 if (s->setup_buf[0] & USB_DIR_IN) { 152 s->setup_state = SETUP_STATE_IDLE; 153 /* transfer OK */ 154 } else { 155 /* ignore additional output */ 156 } 157 return 0; 158 159 case SETUP_STATE_DATA: 160 if (!(s->setup_buf[0] & USB_DIR_IN)) { 161 int len = s->setup_len - s->setup_index; 162 if (len > p->len) 163 len = p->len; 164 memcpy(s->data_buf + s->setup_index, p->data, len); 165 s->setup_index += len; 166 if (s->setup_index >= s->setup_len) 167 s->setup_state = SETUP_STATE_ACK; 168 return len; 169 } 170 171 s->setup_state = SETUP_STATE_IDLE; 172 return USB_RET_STALL; 173 174 default: 175 return USB_RET_STALL; 176 } 177 } 178 179 /* 180 * Generic packet handler. 181 * Called by the HC (host controller). 182 * 183 * Returns length of the transaction or one of the USB_RET_XXX codes. 184 */ 185 int usb_generic_handle_packet(USBDevice *s, USBPacket *p) 186 { 187 switch(p->pid) { 188 case USB_MSG_ATTACH: 189 s->state = USB_STATE_ATTACHED; 190 return 0; 191 192 case USB_MSG_DETACH: 193 s->state = USB_STATE_NOTATTACHED; 194 return 0; 195 196 case USB_MSG_RESET: 197 s->remote_wakeup = 0; 198 s->addr = 0; 199 s->state = USB_STATE_DEFAULT; 200 s->info->handle_reset(s); 201 return 0; 202 } 203 204 /* Rest of the PIDs must match our address */ 205 if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr) 206 return USB_RET_NODEV; 207 208 switch (p->pid) { 209 case USB_TOKEN_SETUP: 210 return do_token_setup(s, p); 211 212 case USB_TOKEN_IN: 213 return do_token_in(s, p); 214 215 case USB_TOKEN_OUT: 216 return do_token_out(s, p); 217 218 default: 219 return USB_RET_STALL; 220 } 221 } 222 223 /* XXX: fix overflow */ 224 int set_usb_string(uint8_t *buf, const char *str) 225 { 226 int len, i; 227 uint8_t *q; 228 229 q = buf; 230 len = strlen(str); 231 *q++ = 2 * len + 2; 232 *q++ = 3; 233 for(i = 0; i < len; i++) { 234 *q++ = str[i]; 235 *q++ = 0; 236 } 237 return q - buf; 238 } 239 240 /* Send an internal message to a USB device. */ 241 void usb_send_msg(USBDevice *dev, int msg) 242 { 243 USBPacket p; 244 memset(&p, 0, sizeof(p)); 245 p.pid = msg; 246 dev->info->handle_packet(dev, &p); 247 248 /* This _must_ be synchronous */ 249 } 250