1 #include "hw/hw.h" 2 #include "hw/usb.h" 3 #include "hw/qdev.h" 4 #include "sysemu/sysemu.h" 5 #include "monitor/monitor.h" 6 #include "trace.h" 7 8 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent); 9 10 static char *usb_get_dev_path(DeviceState *dev); 11 static char *usb_get_fw_dev_path(DeviceState *qdev); 12 static int usb_qdev_exit(DeviceState *qdev); 13 14 static Property usb_props[] = { 15 DEFINE_PROP_STRING("port", USBDevice, port_path), 16 DEFINE_PROP_STRING("serial", USBDevice, serial), 17 DEFINE_PROP_BIT("full-path", USBDevice, flags, 18 USB_DEV_FLAG_FULL_PATH, true), 19 DEFINE_PROP_END_OF_LIST() 20 }; 21 22 static void usb_bus_class_init(ObjectClass *klass, void *data) 23 { 24 BusClass *k = BUS_CLASS(klass); 25 26 k->print_dev = usb_bus_dev_print; 27 k->get_dev_path = usb_get_dev_path; 28 k->get_fw_dev_path = usb_get_fw_dev_path; 29 } 30 31 static const TypeInfo usb_bus_info = { 32 .name = TYPE_USB_BUS, 33 .parent = TYPE_BUS, 34 .instance_size = sizeof(USBBus), 35 .class_init = usb_bus_class_init, 36 }; 37 38 static int next_usb_bus = 0; 39 static QTAILQ_HEAD(, USBBus) busses = QTAILQ_HEAD_INITIALIZER(busses); 40 41 static int usb_device_post_load(void *opaque, int version_id) 42 { 43 USBDevice *dev = opaque; 44 45 if (dev->state == USB_STATE_NOTATTACHED) { 46 dev->attached = 0; 47 } else { 48 dev->attached = 1; 49 } 50 return 0; 51 } 52 53 const VMStateDescription vmstate_usb_device = { 54 .name = "USBDevice", 55 .version_id = 1, 56 .minimum_version_id = 1, 57 .post_load = usb_device_post_load, 58 .fields = (VMStateField []) { 59 VMSTATE_UINT8(addr, USBDevice), 60 VMSTATE_INT32(state, USBDevice), 61 VMSTATE_INT32(remote_wakeup, USBDevice), 62 VMSTATE_INT32(setup_state, USBDevice), 63 VMSTATE_INT32(setup_len, USBDevice), 64 VMSTATE_INT32(setup_index, USBDevice), 65 VMSTATE_UINT8_ARRAY(setup_buf, USBDevice, 8), 66 VMSTATE_END_OF_LIST(), 67 } 68 }; 69 70 void usb_bus_new(USBBus *bus, size_t bus_size, 71 USBBusOps *ops, DeviceState *host) 72 { 73 qbus_create_inplace(bus, bus_size, TYPE_USB_BUS, host, NULL); 74 bus->ops = ops; 75 bus->busnr = next_usb_bus++; 76 bus->qbus.allow_hotplug = 1; /* Yes, we can */ 77 QTAILQ_INIT(&bus->free); 78 QTAILQ_INIT(&bus->used); 79 QTAILQ_INSERT_TAIL(&busses, bus, next); 80 } 81 82 USBBus *usb_bus_find(int busnr) 83 { 84 USBBus *bus; 85 86 if (-1 == busnr) 87 return QTAILQ_FIRST(&busses); 88 QTAILQ_FOREACH(bus, &busses, next) { 89 if (bus->busnr == busnr) 90 return bus; 91 } 92 return NULL; 93 } 94 95 static int usb_device_init(USBDevice *dev) 96 { 97 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 98 if (klass->init) { 99 return klass->init(dev); 100 } 101 return 0; 102 } 103 104 USBDevice *usb_device_find_device(USBDevice *dev, uint8_t addr) 105 { 106 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 107 if (klass->find_device) { 108 return klass->find_device(dev, addr); 109 } 110 return NULL; 111 } 112 113 static void usb_device_handle_destroy(USBDevice *dev) 114 { 115 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 116 if (klass->handle_destroy) { 117 klass->handle_destroy(dev); 118 } 119 } 120 121 void usb_device_cancel_packet(USBDevice *dev, USBPacket *p) 122 { 123 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 124 if (klass->cancel_packet) { 125 klass->cancel_packet(dev, p); 126 } 127 } 128 129 void usb_device_handle_attach(USBDevice *dev) 130 { 131 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 132 if (klass->handle_attach) { 133 klass->handle_attach(dev); 134 } 135 } 136 137 void usb_device_handle_reset(USBDevice *dev) 138 { 139 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 140 if (klass->handle_reset) { 141 klass->handle_reset(dev); 142 } 143 } 144 145 void usb_device_handle_control(USBDevice *dev, USBPacket *p, int request, 146 int value, int index, int length, uint8_t *data) 147 { 148 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 149 if (klass->handle_control) { 150 klass->handle_control(dev, p, request, value, index, length, data); 151 } 152 } 153 154 void usb_device_handle_data(USBDevice *dev, USBPacket *p) 155 { 156 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 157 if (klass->handle_data) { 158 klass->handle_data(dev, p); 159 } 160 } 161 162 const char *usb_device_get_product_desc(USBDevice *dev) 163 { 164 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 165 return klass->product_desc; 166 } 167 168 const USBDesc *usb_device_get_usb_desc(USBDevice *dev) 169 { 170 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 171 if (dev->usb_desc) { 172 return dev->usb_desc; 173 } 174 return klass->usb_desc; 175 } 176 177 void usb_device_set_interface(USBDevice *dev, int interface, 178 int alt_old, int alt_new) 179 { 180 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 181 if (klass->set_interface) { 182 klass->set_interface(dev, interface, alt_old, alt_new); 183 } 184 } 185 186 void usb_device_flush_ep_queue(USBDevice *dev, USBEndpoint *ep) 187 { 188 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 189 if (klass->flush_ep_queue) { 190 klass->flush_ep_queue(dev, ep); 191 } 192 } 193 194 void usb_device_ep_stopped(USBDevice *dev, USBEndpoint *ep) 195 { 196 USBDeviceClass *klass = USB_DEVICE_GET_CLASS(dev); 197 if (klass->ep_stopped) { 198 klass->ep_stopped(dev, ep); 199 } 200 } 201 202 static int usb_qdev_init(DeviceState *qdev) 203 { 204 USBDevice *dev = USB_DEVICE(qdev); 205 int rc; 206 207 pstrcpy(dev->product_desc, sizeof(dev->product_desc), 208 usb_device_get_product_desc(dev)); 209 dev->auto_attach = 1; 210 QLIST_INIT(&dev->strings); 211 usb_ep_init(dev); 212 rc = usb_claim_port(dev); 213 if (rc != 0) { 214 return rc; 215 } 216 rc = usb_device_init(dev); 217 if (rc != 0) { 218 usb_release_port(dev); 219 return rc; 220 } 221 if (dev->auto_attach) { 222 rc = usb_device_attach(dev); 223 if (rc != 0) { 224 usb_qdev_exit(qdev); 225 return rc; 226 } 227 } 228 return 0; 229 } 230 231 static int usb_qdev_exit(DeviceState *qdev) 232 { 233 USBDevice *dev = USB_DEVICE(qdev); 234 235 if (dev->attached) { 236 usb_device_detach(dev); 237 } 238 usb_device_handle_destroy(dev); 239 if (dev->port) { 240 usb_release_port(dev); 241 } 242 return 0; 243 } 244 245 typedef struct LegacyUSBFactory 246 { 247 const char *name; 248 const char *usbdevice_name; 249 USBDevice *(*usbdevice_init)(USBBus *bus, const char *params); 250 } LegacyUSBFactory; 251 252 static GSList *legacy_usb_factory; 253 254 void usb_legacy_register(const char *typename, const char *usbdevice_name, 255 USBDevice *(*usbdevice_init)(USBBus *bus, 256 const char *params)) 257 { 258 if (usbdevice_name) { 259 LegacyUSBFactory *f = g_malloc0(sizeof(*f)); 260 f->name = typename; 261 f->usbdevice_name = usbdevice_name; 262 f->usbdevice_init = usbdevice_init; 263 legacy_usb_factory = g_slist_append(legacy_usb_factory, f); 264 } 265 } 266 267 USBDevice *usb_create(USBBus *bus, const char *name) 268 { 269 DeviceState *dev; 270 271 dev = qdev_create(&bus->qbus, name); 272 return USB_DEVICE(dev); 273 } 274 275 USBDevice *usb_create_simple(USBBus *bus, const char *name) 276 { 277 USBDevice *dev = usb_create(bus, name); 278 int rc; 279 280 if (!dev) { 281 error_report("Failed to create USB device '%s'", name); 282 return NULL; 283 } 284 rc = qdev_init(&dev->qdev); 285 if (rc < 0) { 286 error_report("Failed to initialize USB device '%s'", name); 287 return NULL; 288 } 289 return dev; 290 } 291 292 static void usb_fill_port(USBPort *port, void *opaque, int index, 293 USBPortOps *ops, int speedmask) 294 { 295 port->opaque = opaque; 296 port->index = index; 297 port->ops = ops; 298 port->speedmask = speedmask; 299 usb_port_location(port, NULL, index + 1); 300 } 301 302 void usb_register_port(USBBus *bus, USBPort *port, void *opaque, int index, 303 USBPortOps *ops, int speedmask) 304 { 305 usb_fill_port(port, opaque, index, ops, speedmask); 306 QTAILQ_INSERT_TAIL(&bus->free, port, next); 307 bus->nfree++; 308 } 309 310 int usb_register_companion(const char *masterbus, USBPort *ports[], 311 uint32_t portcount, uint32_t firstport, 312 void *opaque, USBPortOps *ops, int speedmask) 313 { 314 USBBus *bus; 315 int i; 316 317 QTAILQ_FOREACH(bus, &busses, next) { 318 if (strcmp(bus->qbus.name, masterbus) == 0) { 319 break; 320 } 321 } 322 323 if (!bus || !bus->ops->register_companion) { 324 qerror_report(QERR_INVALID_PARAMETER_VALUE, "masterbus", 325 "an USB masterbus"); 326 if (bus) { 327 error_printf_unless_qmp( 328 "USB bus '%s' does not allow companion controllers\n", 329 masterbus); 330 } 331 return -1; 332 } 333 334 for (i = 0; i < portcount; i++) { 335 usb_fill_port(ports[i], opaque, i, ops, speedmask); 336 } 337 338 return bus->ops->register_companion(bus, ports, portcount, firstport); 339 } 340 341 void usb_port_location(USBPort *downstream, USBPort *upstream, int portnr) 342 { 343 if (upstream) { 344 snprintf(downstream->path, sizeof(downstream->path), "%s.%d", 345 upstream->path, portnr); 346 downstream->hubcount = upstream->hubcount + 1; 347 } else { 348 snprintf(downstream->path, sizeof(downstream->path), "%d", portnr); 349 downstream->hubcount = 0; 350 } 351 } 352 353 void usb_unregister_port(USBBus *bus, USBPort *port) 354 { 355 if (port->dev) 356 qdev_free(&port->dev->qdev); 357 QTAILQ_REMOVE(&bus->free, port, next); 358 bus->nfree--; 359 } 360 361 int usb_claim_port(USBDevice *dev) 362 { 363 USBBus *bus = usb_bus_from_device(dev); 364 USBPort *port; 365 366 assert(dev->port == NULL); 367 368 if (dev->port_path) { 369 QTAILQ_FOREACH(port, &bus->free, next) { 370 if (strcmp(port->path, dev->port_path) == 0) { 371 break; 372 } 373 } 374 if (port == NULL) { 375 error_report("Error: usb port %s (bus %s) not found (in use?)", 376 dev->port_path, bus->qbus.name); 377 return -1; 378 } 379 } else { 380 if (bus->nfree == 1 && strcmp(object_get_typename(OBJECT(dev)), "usb-hub") != 0) { 381 /* Create a new hub and chain it on */ 382 usb_create_simple(bus, "usb-hub"); 383 } 384 if (bus->nfree == 0) { 385 error_report("Error: tried to attach usb device %s to a bus " 386 "with no free ports", dev->product_desc); 387 return -1; 388 } 389 port = QTAILQ_FIRST(&bus->free); 390 } 391 trace_usb_port_claim(bus->busnr, port->path); 392 393 QTAILQ_REMOVE(&bus->free, port, next); 394 bus->nfree--; 395 396 dev->port = port; 397 port->dev = dev; 398 399 QTAILQ_INSERT_TAIL(&bus->used, port, next); 400 bus->nused++; 401 return 0; 402 } 403 404 void usb_release_port(USBDevice *dev) 405 { 406 USBBus *bus = usb_bus_from_device(dev); 407 USBPort *port = dev->port; 408 409 assert(port != NULL); 410 trace_usb_port_release(bus->busnr, port->path); 411 412 QTAILQ_REMOVE(&bus->used, port, next); 413 bus->nused--; 414 415 dev->port = NULL; 416 port->dev = NULL; 417 418 QTAILQ_INSERT_TAIL(&bus->free, port, next); 419 bus->nfree++; 420 } 421 422 static void usb_mask_to_str(char *dest, size_t size, 423 unsigned int speedmask) 424 { 425 static const struct { 426 unsigned int mask; 427 const char *name; 428 } speeds[] = { 429 { .mask = USB_SPEED_MASK_FULL, .name = "full" }, 430 { .mask = USB_SPEED_MASK_HIGH, .name = "high" }, 431 { .mask = USB_SPEED_MASK_SUPER, .name = "super" }, 432 }; 433 int i, pos = 0; 434 435 for (i = 0; i < ARRAY_SIZE(speeds); i++) { 436 if (speeds[i].mask & speedmask) { 437 pos += snprintf(dest + pos, size - pos, "%s%s", 438 pos ? "+" : "", 439 speeds[i].name); 440 } 441 } 442 } 443 444 int usb_device_attach(USBDevice *dev) 445 { 446 USBBus *bus = usb_bus_from_device(dev); 447 USBPort *port = dev->port; 448 char devspeed[32], portspeed[32]; 449 450 assert(port != NULL); 451 assert(!dev->attached); 452 usb_mask_to_str(devspeed, sizeof(devspeed), dev->speedmask); 453 usb_mask_to_str(portspeed, sizeof(portspeed), port->speedmask); 454 trace_usb_port_attach(bus->busnr, port->path, 455 devspeed, portspeed); 456 457 if (!(port->speedmask & dev->speedmask)) { 458 error_report("Warning: speed mismatch trying to attach" 459 " usb device \"%s\" (%s speed)" 460 " to bus \"%s\", port \"%s\" (%s speed)", 461 dev->product_desc, devspeed, 462 bus->qbus.name, port->path, portspeed); 463 return -1; 464 } 465 466 dev->attached++; 467 usb_attach(port); 468 469 return 0; 470 } 471 472 int usb_device_detach(USBDevice *dev) 473 { 474 USBBus *bus = usb_bus_from_device(dev); 475 USBPort *port = dev->port; 476 477 assert(port != NULL); 478 assert(dev->attached); 479 trace_usb_port_detach(bus->busnr, port->path); 480 481 usb_detach(port); 482 dev->attached--; 483 return 0; 484 } 485 486 int usb_device_delete_addr(int busnr, int addr) 487 { 488 USBBus *bus; 489 USBPort *port; 490 USBDevice *dev; 491 492 bus = usb_bus_find(busnr); 493 if (!bus) 494 return -1; 495 496 QTAILQ_FOREACH(port, &bus->used, next) { 497 if (port->dev->addr == addr) 498 break; 499 } 500 if (!port) 501 return -1; 502 dev = port->dev; 503 504 qdev_free(&dev->qdev); 505 return 0; 506 } 507 508 static const char *usb_speed(unsigned int speed) 509 { 510 static const char *txt[] = { 511 [ USB_SPEED_LOW ] = "1.5", 512 [ USB_SPEED_FULL ] = "12", 513 [ USB_SPEED_HIGH ] = "480", 514 [ USB_SPEED_SUPER ] = "5000", 515 }; 516 if (speed >= ARRAY_SIZE(txt)) 517 return "?"; 518 return txt[speed]; 519 } 520 521 static void usb_bus_dev_print(Monitor *mon, DeviceState *qdev, int indent) 522 { 523 USBDevice *dev = USB_DEVICE(qdev); 524 USBBus *bus = usb_bus_from_device(dev); 525 526 monitor_printf(mon, "%*saddr %d.%d, port %s, speed %s, name %s%s\n", 527 indent, "", bus->busnr, dev->addr, 528 dev->port ? dev->port->path : "-", 529 usb_speed(dev->speed), dev->product_desc, 530 dev->attached ? ", attached" : ""); 531 } 532 533 static char *usb_get_dev_path(DeviceState *qdev) 534 { 535 USBDevice *dev = USB_DEVICE(qdev); 536 DeviceState *hcd = qdev->parent_bus->parent; 537 char *id = NULL; 538 539 if (dev->flags & (1 << USB_DEV_FLAG_FULL_PATH)) { 540 id = qdev_get_dev_path(hcd); 541 } 542 if (id) { 543 char *ret = g_strdup_printf("%s/%s", id, dev->port->path); 544 g_free(id); 545 return ret; 546 } else { 547 return g_strdup(dev->port->path); 548 } 549 } 550 551 static char *usb_get_fw_dev_path(DeviceState *qdev) 552 { 553 USBDevice *dev = USB_DEVICE(qdev); 554 char *fw_path, *in; 555 ssize_t pos = 0, fw_len; 556 long nr; 557 558 fw_len = 32 + strlen(dev->port->path) * 6; 559 fw_path = g_malloc(fw_len); 560 in = dev->port->path; 561 while (fw_len - pos > 0) { 562 nr = strtol(in, &in, 10); 563 if (in[0] == '.') { 564 /* some hub between root port and device */ 565 pos += snprintf(fw_path + pos, fw_len - pos, "hub@%ld/", nr); 566 in++; 567 } else { 568 /* the device itself */ 569 pos += snprintf(fw_path + pos, fw_len - pos, "%s@%ld", 570 qdev_fw_name(qdev), nr); 571 break; 572 } 573 } 574 return fw_path; 575 } 576 577 void usb_info(Monitor *mon, const QDict *qdict) 578 { 579 USBBus *bus; 580 USBDevice *dev; 581 USBPort *port; 582 583 if (QTAILQ_EMPTY(&busses)) { 584 monitor_printf(mon, "USB support not enabled\n"); 585 return; 586 } 587 588 QTAILQ_FOREACH(bus, &busses, next) { 589 QTAILQ_FOREACH(port, &bus->used, next) { 590 dev = port->dev; 591 if (!dev) 592 continue; 593 monitor_printf(mon, " Device %d.%d, Port %s, Speed %s Mb/s, Product %s\n", 594 bus->busnr, dev->addr, port->path, usb_speed(dev->speed), 595 dev->product_desc); 596 } 597 } 598 } 599 600 /* handle legacy -usbdevice cmd line option */ 601 USBDevice *usbdevice_create(const char *cmdline) 602 { 603 USBBus *bus = usb_bus_find(-1 /* any */); 604 LegacyUSBFactory *f = NULL; 605 GSList *i; 606 char driver[32]; 607 const char *params; 608 int len; 609 610 params = strchr(cmdline,':'); 611 if (params) { 612 params++; 613 len = params - cmdline; 614 if (len > sizeof(driver)) 615 len = sizeof(driver); 616 pstrcpy(driver, len, cmdline); 617 } else { 618 params = ""; 619 pstrcpy(driver, sizeof(driver), cmdline); 620 } 621 622 for (i = legacy_usb_factory; i; i = i->next) { 623 f = i->data; 624 if (strcmp(f->usbdevice_name, driver) == 0) { 625 break; 626 } 627 } 628 if (i == NULL) { 629 #if 0 630 /* no error because some drivers are not converted (yet) */ 631 error_report("usbdevice %s not found", driver); 632 #endif 633 return NULL; 634 } 635 636 if (!bus) { 637 error_report("Error: no usb bus to attach usbdevice %s, " 638 "please try -machine usb=on and check that " 639 "the machine model supports USB", driver); 640 return NULL; 641 } 642 643 if (!f->usbdevice_init) { 644 if (*params) { 645 error_report("usbdevice %s accepts no params", driver); 646 return NULL; 647 } 648 return usb_create_simple(bus, f->name); 649 } 650 return f->usbdevice_init(bus, params); 651 } 652 653 static void usb_device_class_init(ObjectClass *klass, void *data) 654 { 655 DeviceClass *k = DEVICE_CLASS(klass); 656 k->bus_type = TYPE_USB_BUS; 657 k->init = usb_qdev_init; 658 k->unplug = qdev_simple_unplug_cb; 659 k->exit = usb_qdev_exit; 660 k->props = usb_props; 661 } 662 663 static const TypeInfo usb_device_type_info = { 664 .name = TYPE_USB_DEVICE, 665 .parent = TYPE_DEVICE, 666 .instance_size = sizeof(USBDevice), 667 .abstract = true, 668 .class_size = sizeof(USBDeviceClass), 669 .class_init = usb_device_class_init, 670 }; 671 672 static void usb_register_types(void) 673 { 674 type_register_static(&usb_bus_info); 675 type_register_static(&usb_device_type_info); 676 } 677 678 type_init(usb_register_types) 679