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