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