hw/usb/bus.c

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