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