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 #include "iov.h" 29 30 void usb_attach(USBPort *port) 31 { 32 USBDevice *dev = port->dev; 33 34 assert(dev != NULL); 35 assert(dev->attached); 36 assert(dev->state == USB_STATE_NOTATTACHED); 37 port->ops->attach(port); 38 dev->state = USB_STATE_ATTACHED; 39 usb_device_handle_attach(dev); 40 } 41 42 void usb_detach(USBPort *port) 43 { 44 USBDevice *dev = port->dev; 45 46 assert(dev != NULL); 47 assert(dev->state != USB_STATE_NOTATTACHED); 48 port->ops->detach(port); 49 dev->state = USB_STATE_NOTATTACHED; 50 } 51 52 void usb_port_reset(USBPort *port) 53 { 54 USBDevice *dev = port->dev; 55 56 assert(dev != NULL); 57 usb_detach(port); 58 usb_attach(port); 59 usb_device_reset(dev); 60 } 61 62 void usb_device_reset(USBDevice *dev) 63 { 64 if (dev == NULL || !dev->attached) { 65 return; 66 } 67 dev->remote_wakeup = 0; 68 dev->addr = 0; 69 dev->state = USB_STATE_DEFAULT; 70 usb_device_handle_reset(dev); 71 } 72 73 void usb_wakeup(USBDevice *dev) 74 { 75 if (dev->remote_wakeup && dev->port && dev->port->ops->wakeup) { 76 dev->port->ops->wakeup(dev->port); 77 } 78 } 79 80 /**********************/ 81 82 /* generic USB device helpers (you are not forced to use them when 83 writing your USB device driver, but they help handling the 84 protocol) 85 */ 86 87 #define SETUP_STATE_IDLE 0 88 #define SETUP_STATE_SETUP 1 89 #define SETUP_STATE_DATA 2 90 #define SETUP_STATE_ACK 3 91 92 static int do_token_setup(USBDevice *s, USBPacket *p) 93 { 94 int request, value, index; 95 int ret = 0; 96 97 if (p->iov.size != 8) { 98 return USB_RET_STALL; 99 } 100 101 usb_packet_copy(p, s->setup_buf, p->iov.size); 102 s->setup_len = (s->setup_buf[7] << 8) | s->setup_buf[6]; 103 s->setup_index = 0; 104 105 request = (s->setup_buf[0] << 8) | s->setup_buf[1]; 106 value = (s->setup_buf[3] << 8) | s->setup_buf[2]; 107 index = (s->setup_buf[5] << 8) | s->setup_buf[4]; 108 109 if (s->setup_buf[0] & USB_DIR_IN) { 110 ret = usb_device_handle_control(s, p, request, value, index, 111 s->setup_len, s->data_buf); 112 if (ret == USB_RET_ASYNC) { 113 s->setup_state = SETUP_STATE_SETUP; 114 return USB_RET_ASYNC; 115 } 116 if (ret < 0) 117 return ret; 118 119 if (ret < s->setup_len) 120 s->setup_len = ret; 121 s->setup_state = SETUP_STATE_DATA; 122 } else { 123 if (s->setup_len > sizeof(s->data_buf)) { 124 fprintf(stderr, 125 "usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n", 126 s->setup_len, sizeof(s->data_buf)); 127 return USB_RET_STALL; 128 } 129 if (s->setup_len == 0) 130 s->setup_state = SETUP_STATE_ACK; 131 else 132 s->setup_state = SETUP_STATE_DATA; 133 } 134 135 return ret; 136 } 137 138 static int do_token_in(USBDevice *s, USBPacket *p) 139 { 140 int request, value, index; 141 int ret = 0; 142 143 if (p->devep != 0) 144 return usb_device_handle_data(s, p); 145 146 request = (s->setup_buf[0] << 8) | s->setup_buf[1]; 147 value = (s->setup_buf[3] << 8) | s->setup_buf[2]; 148 index = (s->setup_buf[5] << 8) | s->setup_buf[4]; 149 150 switch(s->setup_state) { 151 case SETUP_STATE_ACK: 152 if (!(s->setup_buf[0] & USB_DIR_IN)) { 153 ret = usb_device_handle_control(s, p, request, value, index, 154 s->setup_len, s->data_buf); 155 if (ret == USB_RET_ASYNC) { 156 return USB_RET_ASYNC; 157 } 158 s->setup_state = SETUP_STATE_IDLE; 159 if (ret > 0) 160 return 0; 161 return ret; 162 } 163 164 /* return 0 byte */ 165 return 0; 166 167 case SETUP_STATE_DATA: 168 if (s->setup_buf[0] & USB_DIR_IN) { 169 int len = s->setup_len - s->setup_index; 170 if (len > p->iov.size) { 171 len = p->iov.size; 172 } 173 usb_packet_copy(p, s->data_buf + s->setup_index, len); 174 s->setup_index += len; 175 if (s->setup_index >= s->setup_len) 176 s->setup_state = SETUP_STATE_ACK; 177 return len; 178 } 179 180 s->setup_state = SETUP_STATE_IDLE; 181 return USB_RET_STALL; 182 183 default: 184 return USB_RET_STALL; 185 } 186 } 187 188 static int do_token_out(USBDevice *s, USBPacket *p) 189 { 190 if (p->devep != 0) 191 return usb_device_handle_data(s, p); 192 193 switch(s->setup_state) { 194 case SETUP_STATE_ACK: 195 if (s->setup_buf[0] & USB_DIR_IN) { 196 s->setup_state = SETUP_STATE_IDLE; 197 /* transfer OK */ 198 } else { 199 /* ignore additional output */ 200 } 201 return 0; 202 203 case SETUP_STATE_DATA: 204 if (!(s->setup_buf[0] & USB_DIR_IN)) { 205 int len = s->setup_len - s->setup_index; 206 if (len > p->iov.size) { 207 len = p->iov.size; 208 } 209 usb_packet_copy(p, s->data_buf + s->setup_index, len); 210 s->setup_index += len; 211 if (s->setup_index >= s->setup_len) 212 s->setup_state = SETUP_STATE_ACK; 213 return len; 214 } 215 216 s->setup_state = SETUP_STATE_IDLE; 217 return USB_RET_STALL; 218 219 default: 220 return USB_RET_STALL; 221 } 222 } 223 224 /* 225 * Generic packet handler. 226 * Called by the HC (host controller). 227 * 228 * Returns length of the transaction or one of the USB_RET_XXX codes. 229 */ 230 int usb_generic_handle_packet(USBDevice *s, USBPacket *p) 231 { 232 /* Rest of the PIDs must match our address */ 233 if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr) 234 return USB_RET_NODEV; 235 236 switch (p->pid) { 237 case USB_TOKEN_SETUP: 238 return do_token_setup(s, p); 239 240 case USB_TOKEN_IN: 241 return do_token_in(s, p); 242 243 case USB_TOKEN_OUT: 244 return do_token_out(s, p); 245 246 default: 247 return USB_RET_STALL; 248 } 249 } 250 251 /* ctrl complete function for devices which use usb_generic_handle_packet and 252 may return USB_RET_ASYNC from their handle_control callback. Device code 253 which does this *must* call this function instead of the normal 254 usb_packet_complete to complete their async control packets. */ 255 void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p) 256 { 257 if (p->result < 0) { 258 s->setup_state = SETUP_STATE_IDLE; 259 } 260 261 switch (s->setup_state) { 262 case SETUP_STATE_SETUP: 263 if (p->result < s->setup_len) { 264 s->setup_len = p->result; 265 } 266 s->setup_state = SETUP_STATE_DATA; 267 p->result = 8; 268 break; 269 270 case SETUP_STATE_ACK: 271 s->setup_state = SETUP_STATE_IDLE; 272 p->result = 0; 273 break; 274 275 default: 276 break; 277 } 278 usb_packet_complete(s, p); 279 } 280 281 /* XXX: fix overflow */ 282 int set_usb_string(uint8_t *buf, const char *str) 283 { 284 int len, i; 285 uint8_t *q; 286 287 q = buf; 288 len = strlen(str); 289 *q++ = 2 * len + 2; 290 *q++ = 3; 291 for(i = 0; i < len; i++) { 292 *q++ = str[i]; 293 *q++ = 0; 294 } 295 return q - buf; 296 } 297 298 USBDevice *usb_find_device(USBPort *port, uint8_t addr) 299 { 300 USBDevice *dev = port->dev; 301 302 if (dev == NULL || !dev->attached || dev->state != USB_STATE_DEFAULT) { 303 return NULL; 304 } 305 if (dev->addr == addr) { 306 return dev; 307 } 308 return usb_device_find_device(dev, addr); 309 } 310 311 /* Hand over a packet to a device for processing. Return value 312 USB_RET_ASYNC indicates the processing isn't finished yet, the 313 driver will call usb_packet_complete() when done processing it. */ 314 int usb_handle_packet(USBDevice *dev, USBPacket *p) 315 { 316 int ret; 317 318 assert(p->owner == NULL); 319 ret = usb_device_handle_packet(dev, p); 320 if (ret == USB_RET_ASYNC) { 321 if (p->owner == NULL) { 322 p->owner = usb_ep_get(dev, p->pid, p->devep); 323 } else { 324 /* We'll end up here when usb_handle_packet is called 325 * recursively due to a hub being in the chain. Nothing 326 * to do. Leave p->owner pointing to the device, not the 327 * hub. */; 328 } 329 } 330 return ret; 331 } 332 333 /* Notify the controller that an async packet is complete. This should only 334 be called for packets previously deferred by returning USB_RET_ASYNC from 335 handle_packet. */ 336 void usb_packet_complete(USBDevice *dev, USBPacket *p) 337 { 338 /* Note: p->owner != dev is possible in case dev is a hub */ 339 assert(p->owner != NULL); 340 p->owner = NULL; 341 dev->port->ops->complete(dev->port, p); 342 } 343 344 /* Cancel an active packet. The packed must have been deferred by 345 returning USB_RET_ASYNC from handle_packet, and not yet 346 completed. */ 347 void usb_cancel_packet(USBPacket * p) 348 { 349 assert(p->owner != NULL); 350 usb_device_cancel_packet(p->owner->dev, p); 351 p->owner = NULL; 352 } 353 354 355 void usb_packet_init(USBPacket *p) 356 { 357 qemu_iovec_init(&p->iov, 1); 358 } 359 360 void usb_packet_setup(USBPacket *p, int pid, uint8_t addr, uint8_t ep) 361 { 362 p->pid = pid; 363 p->devaddr = addr; 364 p->devep = ep; 365 p->result = 0; 366 qemu_iovec_reset(&p->iov); 367 } 368 369 void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len) 370 { 371 qemu_iovec_add(&p->iov, ptr, len); 372 } 373 374 void usb_packet_copy(USBPacket *p, void *ptr, size_t bytes) 375 { 376 assert(p->result >= 0); 377 assert(p->result + bytes <= p->iov.size); 378 switch (p->pid) { 379 case USB_TOKEN_SETUP: 380 case USB_TOKEN_OUT: 381 iov_to_buf(p->iov.iov, p->iov.niov, ptr, p->result, bytes); 382 break; 383 case USB_TOKEN_IN: 384 iov_from_buf(p->iov.iov, p->iov.niov, ptr, p->result, bytes); 385 break; 386 default: 387 fprintf(stderr, "%s: invalid pid: %x\n", __func__, p->pid); 388 abort(); 389 } 390 p->result += bytes; 391 } 392 393 void usb_packet_skip(USBPacket *p, size_t bytes) 394 { 395 assert(p->result >= 0); 396 assert(p->result + bytes <= p->iov.size); 397 if (p->pid == USB_TOKEN_IN) { 398 iov_clear(p->iov.iov, p->iov.niov, p->result, bytes); 399 } 400 p->result += bytes; 401 } 402 403 void usb_packet_cleanup(USBPacket *p) 404 { 405 qemu_iovec_destroy(&p->iov); 406 } 407 408 void usb_ep_init(USBDevice *dev) 409 { 410 int ep; 411 412 dev->ep_ctl.type = USB_ENDPOINT_XFER_CONTROL; 413 dev->ep_ctl.ifnum = 0; 414 dev->ep_ctl.dev = dev; 415 for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) { 416 dev->ep_in[ep].type = USB_ENDPOINT_XFER_INVALID; 417 dev->ep_out[ep].type = USB_ENDPOINT_XFER_INVALID; 418 dev->ep_in[ep].ifnum = 0; 419 dev->ep_out[ep].ifnum = 0; 420 dev->ep_in[ep].dev = dev; 421 dev->ep_out[ep].dev = dev; 422 } 423 } 424 425 void usb_ep_dump(USBDevice *dev) 426 { 427 static const char *tname[] = { 428 [USB_ENDPOINT_XFER_CONTROL] = "control", 429 [USB_ENDPOINT_XFER_ISOC] = "isoc", 430 [USB_ENDPOINT_XFER_BULK] = "bulk", 431 [USB_ENDPOINT_XFER_INT] = "int", 432 }; 433 int ifnum, ep, first; 434 435 fprintf(stderr, "Device \"%s\", config %d\n", 436 dev->product_desc, dev->configuration); 437 for (ifnum = 0; ifnum < 16; ifnum++) { 438 first = 1; 439 for (ep = 0; ep < USB_MAX_ENDPOINTS; ep++) { 440 if (dev->ep_in[ep].type != USB_ENDPOINT_XFER_INVALID && 441 dev->ep_in[ep].ifnum == ifnum) { 442 if (first) { 443 first = 0; 444 fprintf(stderr, " Interface %d, alternative %d\n", 445 ifnum, dev->altsetting[ifnum]); 446 } 447 fprintf(stderr, " Endpoint %d, IN, %s, %d max\n", ep, 448 tname[dev->ep_in[ep].type], 449 dev->ep_in[ep].max_packet_size); 450 } 451 if (dev->ep_out[ep].type != USB_ENDPOINT_XFER_INVALID && 452 dev->ep_out[ep].ifnum == ifnum) { 453 if (first) { 454 first = 0; 455 fprintf(stderr, " Interface %d, alternative %d\n", 456 ifnum, dev->altsetting[ifnum]); 457 } 458 fprintf(stderr, " Endpoint %d, OUT, %s, %d max\n", ep, 459 tname[dev->ep_out[ep].type], 460 dev->ep_out[ep].max_packet_size); 461 } 462 } 463 } 464 fprintf(stderr, "--\n"); 465 } 466 467 struct USBEndpoint *usb_ep_get(USBDevice *dev, int pid, int ep) 468 { 469 struct USBEndpoint *eps = pid == USB_TOKEN_IN ? dev->ep_in : dev->ep_out; 470 if (ep == 0) { 471 return &dev->ep_ctl; 472 } 473 assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT); 474 assert(ep > 0 && ep <= USB_MAX_ENDPOINTS); 475 return eps + ep - 1; 476 } 477 478 uint8_t usb_ep_get_type(USBDevice *dev, int pid, int ep) 479 { 480 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep); 481 return uep->type; 482 } 483 484 void usb_ep_set_type(USBDevice *dev, int pid, int ep, uint8_t type) 485 { 486 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep); 487 uep->type = type; 488 } 489 490 uint8_t usb_ep_get_ifnum(USBDevice *dev, int pid, int ep) 491 { 492 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep); 493 return uep->ifnum; 494 } 495 496 void usb_ep_set_ifnum(USBDevice *dev, int pid, int ep, uint8_t ifnum) 497 { 498 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep); 499 uep->ifnum = ifnum; 500 } 501 502 void usb_ep_set_max_packet_size(USBDevice *dev, int pid, int ep, 503 uint16_t raw) 504 { 505 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep); 506 int size, microframes; 507 508 size = raw & 0x7ff; 509 switch ((raw >> 11) & 3) { 510 case 1: 511 microframes = 2; 512 break; 513 case 2: 514 microframes = 3; 515 break; 516 default: 517 microframes = 1; 518 break; 519 } 520 uep->max_packet_size = size * microframes; 521 } 522 523 int usb_ep_get_max_packet_size(USBDevice *dev, int pid, int ep) 524 { 525 struct USBEndpoint *uep = usb_ep_get(dev, pid, ep); 526 return uep->max_packet_size; 527 } 528