hw/qdev.c

   1 /*
   2  *  Dynamic device configuration and creation.
   3  *
   4  *  Copyright (c) 2009 CodeSourcery
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /* The theory here is that it should be possible to create a machine without
  21    knowledge of specific devices.  Historically board init routines have
  22    passed a bunch of arguments to each device, requiring the board know
  23    exactly which device it is dealing with.  This file provides an abstract
  24    API for device configuration and initialization.  Devices will generally
  25    inherit from a particular bus (e.g. PCI or I2C) rather than
  26    this API directly.  */
  27
  28 #include "net.h"
  29 #include "qdev.h"
  30 #include "sysemu.h"
  31 #include "error.h"
  32
  33 int qdev_hotplug = 0;
  34 static bool qdev_hot_added = false;
  35 static bool qdev_hot_removed = false;
  36
  37 /* Register a new device type.  */
  38 const VMStateDescription *qdev_get_vmsd(DeviceState *dev)
  39 {
  40     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  41     return dc->vmsd;
  42 }
  43
  44 const char *qdev_fw_name(DeviceState *dev)
  45 {
  46     DeviceClass *dc = DEVICE_GET_CLASS(dev);
  47
  48     if (dc->fw_name) {
  49         return dc->fw_name;
  50     }
  51
  52     return object_get_typename(OBJECT(dev));
  53 }
  54
  55 bool qdev_exists(const char *name)
  56 {
  57     return !!object_class_by_name(name);
  58 }
  59
  60 static void qdev_property_add_legacy(DeviceState *dev, Property *prop,
  61                                      Error **errp);
  62
  63 void qdev_set_parent_bus(DeviceState *dev, BusState *bus)
  64 {
  65     if (qdev_hotplug) {
  66         assert(bus->allow_hotplug);
  67     }
  68
  69     dev->parent_bus = bus;
  70     QTAILQ_INSERT_HEAD(&bus->children, dev, sibling);
  71 }
  72
  73 /* Create a new device.  This only initializes the device state structure
  74    and allows properties to be set.  qdev_init should be called to
  75    initialize the actual device emulation.  */
  76 DeviceState *qdev_create(BusState *bus, const char *name)
  77 {
  78     DeviceState *dev;
  79
  80     dev = qdev_try_create(bus, name);
  81     if (!dev) {
  82         if (bus) {
  83             hw_error("Unknown device '%s' for bus '%s'\n", name,
  84                      object_get_typename(OBJECT(bus)));
  85         } else {
  86             hw_error("Unknown device '%s' for default sysbus\n", name);
  87         }
  88     }
  89
  90     return dev;
  91 }
  92
  93 DeviceState *qdev_try_create(BusState *bus, const char *type)
  94 {
  95     DeviceState *dev;
  96
  97     if (object_class_by_name(type) == NULL) {
  98         return NULL;
  99     }
 100     dev = DEVICE(object_new(type));
 101     if (!dev) {
 102         return NULL;
 103     }
 104
 105     if (!bus) {
 106         bus = sysbus_get_default();
 107     }
 108
 109     qdev_set_parent_bus(dev, bus);
 110
 111     return dev;
 112 }
 113
 114 /* Initialize a device.  Device properties should be set before calling
 115    this function.  IRQs and MMIO regions should be connected/mapped after
 116    calling this function.
 117    On failure, destroy the device and return negative value.
 118    Return 0 on success.  */
 119 int qdev_init(DeviceState *dev)
 120 {
 121     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 122     int rc;
 123
 124     assert(dev->state == DEV_STATE_CREATED);
 125
 126     rc = dc->init(dev);
 127     if (rc < 0) {
 128         qdev_free(dev);
 129         return rc;
 130     }
 131
 132     if (!OBJECT(dev)->parent) {
 133         static int unattached_count = 0;
 134         gchar *name = g_strdup_printf("device[%d]", unattached_count++);
 135
 136         object_property_add_child(container_get(qdev_get_machine(),
 137                                                 "/unattached"),
 138                                   name, OBJECT(dev), NULL);
 139         g_free(name);
 140     }
 141
 142     if (qdev_get_vmsd(dev)) {
 143         vmstate_register_with_alias_id(dev, -1, qdev_get_vmsd(dev), dev,
 144                                        dev->instance_id_alias,
 145                                        dev->alias_required_for_version);
 146     }
 147     dev->state = DEV_STATE_INITIALIZED;
 148     if (dev->hotplugged) {
 149         device_reset(dev);
 150     }
 151     return 0;
 152 }
 153
 154 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 155                                  int required_for_version)
 156 {
 157     assert(dev->state == DEV_STATE_CREATED);
 158     dev->instance_id_alias = alias_id;
 159     dev->alias_required_for_version = required_for_version;
 160 }
 161
 162 void qdev_unplug(DeviceState *dev, Error **errp)
 163 {
 164     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 165
 166     if (!dev->parent_bus->allow_hotplug) {
 167         error_set(errp, QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
 168         return;
 169     }
 170     assert(dc->unplug != NULL);
 171
 172     qdev_hot_removed = true;
 173
 174     if (dc->unplug(dev) < 0) {
 175         error_set(errp, QERR_UNDEFINED_ERROR);
 176         return;
 177     }
 178 }
 179
 180 static int qdev_reset_one(DeviceState *dev, void *opaque)
 181 {
 182     device_reset(dev);
 183
 184     return 0;
 185 }
 186
 187 static int qbus_reset_one(BusState *bus, void *opaque)
 188 {
 189     BusClass *bc = BUS_GET_CLASS(bus);
 190     if (bc->reset) {
 191         return bc->reset(bus);
 192     }
 193     return 0;
 194 }
 195
 196 void qdev_reset_all(DeviceState *dev)
 197 {
 198     qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL);
 199 }
 200
 201 void qbus_reset_all_fn(void *opaque)
 202 {
 203     BusState *bus = opaque;
 204     qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL);
 205 }
 206
 207 /* can be used as ->unplug() callback for the simple cases */
 208 int qdev_simple_unplug_cb(DeviceState *dev)
 209 {
 210     /* just zap it */
 211     object_unparent(OBJECT(dev));
 212     qdev_free(dev);
 213     return 0;
 214 }
 215
 216
 217 /* Like qdev_init(), but terminate program via error_report() instead of
 218    returning an error value.  This is okay during machine creation.
 219    Don't use for hotplug, because there callers need to recover from
 220    failure.  Exception: if you know the device's init() callback can't
 221    fail, then qdev_init_nofail() can't fail either, and is therefore
 222    usable even then.  But relying on the device implementation that
 223    way is somewhat unclean, and best avoided.  */
 224 void qdev_init_nofail(DeviceState *dev)
 225 {
 226     if (qdev_init(dev) < 0) {
 227         error_report("Initialization of device %s failed",
 228                      object_get_typename(OBJECT(dev)));
 229         exit(1);
 230     }
 231 }
 232
 233 /* Unlink device from bus and free the structure.  */
 234 void qdev_free(DeviceState *dev)
 235 {
 236     object_delete(OBJECT(dev));
 237 }
 238
 239 void qdev_machine_creation_done(void)
 240 {
 241     /*
 242      * ok, initial machine setup is done, starting from now we can
 243      * only create hotpluggable devices
 244      */
 245     qdev_hotplug = 1;
 246 }
 247
 248 bool qdev_machine_modified(void)
 249 {
 250     return qdev_hot_added || qdev_hot_removed;
 251 }
 252
 253 BusState *qdev_get_parent_bus(DeviceState *dev)
 254 {
 255     return dev->parent_bus;
 256 }
 257
 258 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 259 {
 260     assert(dev->num_gpio_in == 0);
 261     dev->num_gpio_in = n;
 262     dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
 263 }
 264
 265 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 266 {
 267     assert(dev->num_gpio_out == 0);
 268     dev->num_gpio_out = n;
 269     dev->gpio_out = pins;
 270 }
 271
 272 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 273 {
 274     assert(n >= 0 && n < dev->num_gpio_in);
 275     return dev->gpio_in[n];
 276 }
 277
 278 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 279 {
 280     assert(n >= 0 && n < dev->num_gpio_out);
 281     dev->gpio_out[n] = pin;
 282 }
 283
 284 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
 285 {
 286     qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
 287     if (nd->vlan)
 288         qdev_prop_set_vlan(dev, "vlan", nd->vlan);
 289     if (nd->netdev)
 290         qdev_prop_set_netdev(dev, "netdev", nd->netdev);
 291     if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
 292         qdev_prop_exists(dev, "vectors")) {
 293         qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
 294     }
 295     nd->instantiated = 1;
 296 }
 297
 298 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 299 {
 300     BusState *bus;
 301
 302     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 303         if (strcmp(name, bus->name) == 0) {
 304             return bus;
 305         }
 306     }
 307     return NULL;
 308 }
 309
 310 int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
 311                        qbus_walkerfn *busfn, void *opaque)
 312 {
 313     DeviceState *dev;
 314     int err;
 315
 316     if (busfn) {
 317         err = busfn(bus, opaque);
 318         if (err) {
 319             return err;
 320         }
 321     }
 322
 323     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 324         err = qdev_walk_children(dev, devfn, busfn, opaque);
 325         if (err < 0) {
 326             return err;
 327         }
 328     }
 329
 330     return 0;
 331 }
 332
 333 int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn,
 334                        qbus_walkerfn *busfn, void *opaque)
 335 {
 336     BusState *bus;
 337     int err;
 338
 339     if (devfn) {
 340         err = devfn(dev, opaque);
 341         if (err) {
 342             return err;
 343         }
 344     }
 345
 346     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 347         err = qbus_walk_children(bus, devfn, busfn, opaque);
 348         if (err < 0) {
 349             return err;
 350         }
 351     }
 352
 353     return 0;
 354 }
 355
 356 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 357 {
 358     DeviceState *dev, *ret;
 359     BusState *child;
 360
 361     QTAILQ_FOREACH(dev, &bus->children, sibling) {
 362         if (dev->id && strcmp(dev->id, id) == 0)
 363             return dev;
 364         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 365             ret = qdev_find_recursive(child, id);
 366             if (ret) {
 367                 return ret;
 368             }
 369         }
 370     }
 371     return NULL;
 372 }
 373
 374 /* FIXME move this logic into instance_init */
 375 static void do_qbus_create_inplace(BusState *bus, const char *typename,
 376                                    DeviceState *parent, const char *name)
 377 {
 378     char *buf;
 379     int i,len;
 380
 381     bus->parent = parent;
 382
 383     if (name) {
 384         /* use supplied name */
 385         bus->name = g_strdup(name);
 386     } else if (parent && parent->id) {
 387         /* parent device has id -> use it for bus name */
 388         len = strlen(parent->id) + 16;
 389         buf = g_malloc(len);
 390         snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus);
 391         bus->name = buf;
 392     } else {
 393         /* no id -> use lowercase bus type for bus name */
 394         len = strlen(typename) + 16;
 395         buf = g_malloc(len);
 396         len = snprintf(buf, len, "%s.%d", typename,
 397                        parent ? parent->num_child_bus : 0);
 398         for (i = 0; i < len; i++)
 399             buf[i] = qemu_tolower(buf[i]);
 400         bus->name = buf;
 401     }
 402
 403     QTAILQ_INIT(&bus->children);
 404     if (parent) {
 405         QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
 406         parent->num_child_bus++;
 407         object_property_add_child(OBJECT(parent), bus->name, OBJECT(bus), NULL);
 408     } else if (bus != sysbus_get_default()) {
 409         /* TODO: once all bus devices are qdevified,
 410            only reset handler for main_system_bus should be registered here. */
 411         qemu_register_reset(qbus_reset_all_fn, bus);
 412     }
 413 }
 414
 415 void qbus_create_inplace(BusState *bus, const char *typename,
 416                          DeviceState *parent, const char *name)
 417 {
 418     object_initialize(bus, typename);
 419     do_qbus_create_inplace(bus, typename, parent, name);
 420 }
 421
 422 BusState *qbus_create(const char *typename, DeviceState *parent, const char *name)
 423 {
 424     BusState *bus;
 425
 426     bus = BUS(object_new(typename));
 427     bus->qom_allocated = true;
 428     do_qbus_create_inplace(bus, typename, parent, name);
 429     return bus;
 430 }
 431
 432 void qbus_free(BusState *bus)
 433 {
 434     DeviceState *dev;
 435
 436     while ((dev = QTAILQ_FIRST(&bus->children)) != NULL) {
 437         qdev_free(dev);
 438     }
 439     if (bus->parent) {
 440         QLIST_REMOVE(bus, sibling);
 441         bus->parent->num_child_bus--;
 442     } else {
 443         assert(bus != sysbus_get_default()); /* main_system_bus is never freed */
 444         qemu_unregister_reset(qbus_reset_all_fn, bus);
 445     }
 446     g_free((void*)bus->name);
 447     if (bus->qom_allocated) {
 448         object_delete(OBJECT(bus));
 449     } else {
 450         object_finalize(OBJECT(bus));
 451         if (bus->glib_allocated) {
 452             g_free(bus);
 453         }
 454     }
 455 }
 456
 457 static char *bus_get_fw_dev_path(BusState *bus, DeviceState *dev)
 458 {
 459     BusClass *bc = BUS_GET_CLASS(bus);
 460
 461     if (bc->get_fw_dev_path) {
 462         return bc->get_fw_dev_path(dev);
 463     }
 464
 465     return NULL;
 466 }
 467
 468 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
 469 {
 470     int l = 0;
 471
 472     if (dev && dev->parent_bus) {
 473         char *d;
 474         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
 475         d = bus_get_fw_dev_path(dev->parent_bus, dev);
 476         if (d) {
 477             l += snprintf(p + l, size - l, "%s", d);
 478             g_free(d);
 479         } else {
 480             l += snprintf(p + l, size - l, "%s", object_get_typename(OBJECT(dev)));
 481         }
 482     }
 483     l += snprintf(p + l , size - l, "/");
 484
 485     return l;
 486 }
 487
 488 char* qdev_get_fw_dev_path(DeviceState *dev)
 489 {
 490     char path[128];
 491     int l;
 492
 493     l = qdev_get_fw_dev_path_helper(dev, path, 128);
 494
 495     path[l-1] = '\0';
 496
 497     return strdup(path);
 498 }
 499
 500 char *qdev_get_dev_path(DeviceState *dev)
 501 {
 502     BusClass *bc;
 503
 504     if (!dev || !dev->parent_bus) {
 505         return NULL;
 506     }
 507
 508     bc = BUS_GET_CLASS(dev->parent_bus);
 509     if (bc->get_dev_path) {
 510         return bc->get_dev_path(dev);
 511     }
 512
 513     return NULL;
 514 }
 515
 516 /**
 517  * Legacy property handling
 518  */
 519
 520 static void qdev_get_legacy_property(Object *obj, Visitor *v, void *opaque,
 521                                      const char *name, Error **errp)
 522 {
 523     DeviceState *dev = DEVICE(obj);
 524     Property *prop = opaque;
 525
 526     char buffer[1024];
 527     char *ptr = buffer;
 528
 529     prop->info->print(dev, prop, buffer, sizeof(buffer));
 530     visit_type_str(v, &ptr, name, errp);
 531 }
 532
 533 static void qdev_set_legacy_property(Object *obj, Visitor *v, void *opaque,
 534                                      const char *name, Error **errp)
 535 {
 536     DeviceState *dev = DEVICE(obj);
 537     Property *prop = opaque;
 538     Error *local_err = NULL;
 539     char *ptr = NULL;
 540     int ret;
 541
 542     if (dev->state != DEV_STATE_CREATED) {
 543         error_set(errp, QERR_PERMISSION_DENIED);
 544         return;
 545     }
 546
 547     visit_type_str(v, &ptr, name, &local_err);
 548     if (local_err) {
 549         error_propagate(errp, local_err);
 550         return;
 551     }
 552
 553     ret = prop->info->parse(dev, prop, ptr);
 554     error_set_from_qdev_prop_error(errp, ret, dev, prop, ptr);
 555     g_free(ptr);
 556 }
 557
 558 /**
 559  * @qdev_add_legacy_property - adds a legacy property
 560  *
 561  * Do not use this is new code!  Properties added through this interface will
 562  * be given names and types in the "legacy" namespace.
 563  *
 564  * Legacy properties are string versions of other OOM properties.  The format
 565  * of the string depends on the property type.
 566  */
 567 void qdev_property_add_legacy(DeviceState *dev, Property *prop,
 568                               Error **errp)
 569 {
 570     gchar *name, *type;
 571
 572     /* Register pointer properties as legacy properties */
 573     if (!prop->info->print && !prop->info->parse &&
 574         (prop->info->set || prop->info->get)) {
 575         return;
 576     }
 577
 578     name = g_strdup_printf("legacy-%s", prop->name);
 579     type = g_strdup_printf("legacy<%s>",
 580                            prop->info->legacy_name ?: prop->info->name);
 581
 582     object_property_add(OBJECT(dev), name, type,
 583                         prop->info->print ? qdev_get_legacy_property : prop->info->get,
 584                         prop->info->parse ? qdev_set_legacy_property : prop->info->set,
 585                         NULL,
 586                         prop, errp);
 587
 588     g_free(type);
 589     g_free(name);
 590 }
 591
 592 /**
 593  * @qdev_property_add_static - add a @Property to a device.
 594  *
 595  * Static properties access data in a struct.  The actual type of the
 596  * property and the field depends on the property type.
 597  */
 598 void qdev_property_add_static(DeviceState *dev, Property *prop,
 599                               Error **errp)
 600 {
 601     Error *local_err = NULL;
 602     Object *obj = OBJECT(dev);
 603
 604     /*
 605      * TODO qdev_prop_ptr does not have getters or setters.  It must
 606      * go now that it can be replaced with links.  The test should be
 607      * removed along with it: all static properties are read/write.
 608      */
 609     if (!prop->info->get && !prop->info->set) {
 610         return;
 611     }
 612
 613     object_property_add(obj, prop->name, prop->info->name,
 614                         prop->info->get, prop->info->set,
 615                         prop->info->release,
 616                         prop, &local_err);
 617
 618     if (local_err) {
 619         error_propagate(errp, local_err);
 620         return;
 621     }
 622     if (prop->qtype == QTYPE_NONE) {
 623         return;
 624     }
 625
 626     if (prop->qtype == QTYPE_QBOOL) {
 627         object_property_set_bool(obj, prop->defval, prop->name, &local_err);
 628     } else if (prop->info->enum_table) {
 629         object_property_set_str(obj, prop->info->enum_table[prop->defval],
 630                                 prop->name, &local_err);
 631     } else if (prop->qtype == QTYPE_QINT) {
 632         object_property_set_int(obj, prop->defval, prop->name, &local_err);
 633     }
 634     assert_no_error(local_err);
 635 }
 636
 637 static void device_initfn(Object *obj)
 638 {
 639     DeviceState *dev = DEVICE(obj);
 640     ObjectClass *class;
 641     Property *prop;
 642
 643     if (qdev_hotplug) {
 644         dev->hotplugged = 1;
 645         qdev_hot_added = true;
 646     }
 647
 648     dev->instance_id_alias = -1;
 649     dev->state = DEV_STATE_CREATED;
 650
 651     class = object_get_class(OBJECT(dev));
 652     do {
 653         for (prop = DEVICE_CLASS(class)->props; prop && prop->name; prop++) {
 654             qdev_property_add_legacy(dev, prop, NULL);
 655             qdev_property_add_static(dev, prop, NULL);
 656         }
 657         class = object_class_get_parent(class);
 658     } while (class != object_class_by_name(TYPE_DEVICE));
 659     qdev_prop_set_globals(dev);
 660
 661     object_property_add_link(OBJECT(dev), "parent_bus", TYPE_BUS,
 662                              (Object **)&dev->parent_bus, NULL);
 663 }
 664
 665 /* Unlink device from bus and free the structure.  */
 666 static void device_finalize(Object *obj)
 667 {
 668     DeviceState *dev = DEVICE(obj);
 669     BusState *bus;
 670     DeviceClass *dc = DEVICE_GET_CLASS(dev);
 671
 672     if (dev->state == DEV_STATE_INITIALIZED) {
 673         while (dev->num_child_bus) {
 674             bus = QLIST_FIRST(&dev->child_bus);
 675             qbus_free(bus);
 676         }
 677         if (qdev_get_vmsd(dev)) {
 678             vmstate_unregister(dev, qdev_get_vmsd(dev), dev);
 679         }
 680         if (dc->exit) {
 681             dc->exit(dev);
 682         }
 683         if (dev->opts) {
 684             qemu_opts_del(dev->opts);
 685         }
 686     }
 687     QTAILQ_REMOVE(&dev->parent_bus->children, dev, sibling);
 688 }
 689
 690 static void device_class_base_init(ObjectClass *class, void *data)
 691 {
 692     DeviceClass *klass = DEVICE_CLASS(class);
 693
 694     /* We explicitly look up properties in the superclasses,
 695      * so do not propagate them to the subclasses.
 696      */
 697     klass->props = NULL;
 698 }
 699
 700 void device_reset(DeviceState *dev)
 701 {
 702     DeviceClass *klass = DEVICE_GET_CLASS(dev);
 703
 704     if (klass->reset) {
 705         klass->reset(dev);
 706     }
 707 }
 708
 709 Object *qdev_get_machine(void)
 710 {
 711     static Object *dev;
 712
 713     if (dev == NULL) {
 714         dev = container_get(object_get_root(), "/machine");
 715     }
 716
 717     return dev;
 718 }
 719
 720 static TypeInfo device_type_info = {
 721     .name = TYPE_DEVICE,
 722     .parent = TYPE_OBJECT,
 723     .instance_size = sizeof(DeviceState),
 724     .instance_init = device_initfn,
 725     .instance_finalize = device_finalize,
 726     .class_base_init = device_class_base_init,
 727     .abstract = true,
 728     .class_size = sizeof(DeviceClass),
 729 };
 730
 731 static const TypeInfo bus_info = {
 732     .name = TYPE_BUS,
 733     .parent = TYPE_OBJECT,
 734     .instance_size = sizeof(BusState),
 735     .abstract = true,
 736     .class_size = sizeof(BusClass),
 737 };
 738
 739 static void qdev_register_types(void)
 740 {
 741     type_register_static(&bus_info);
 742     type_register_static(&device_type_info);
 743 }
 744
 745 type_init(qdev_register_types)