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