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