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