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 "monitor.h"
  32
  33 static 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
  40 DeviceInfo *device_info_list;
  41
  42 static BusState *qbus_find_recursive(BusState *bus, const char *name,
  43                                      const BusInfo *info);
  44 static BusState *qbus_find(const char *path);
  45
  46 /* Register a new device type.  */
  47 void qdev_register(DeviceInfo *info)
  48 {
  49     assert(info->size >= sizeof(DeviceState));
  50     assert(!info->next);
  51
  52     info->next = device_info_list;
  53     device_info_list = info;
  54 }
  55
  56 static DeviceInfo *qdev_find_info(BusInfo *bus_info, const char *name)
  57 {
  58     DeviceInfo *info;
  59
  60     /* first check device names */
  61     for (info = device_info_list; info != NULL; info = info->next) {
  62         if (bus_info && info->bus_info != bus_info)
  63             continue;
  64         if (strcmp(info->name, name) != 0)
  65             continue;
  66         return info;
  67     }
  68
  69     /* failing that check the aliases */
  70     for (info = device_info_list; info != NULL; info = info->next) {
  71         if (bus_info && info->bus_info != bus_info)
  72             continue;
  73         if (!info->alias)
  74             continue;
  75         if (strcmp(info->alias, name) != 0)
  76             continue;
  77         return info;
  78     }
  79     return NULL;
  80 }
  81
  82 static DeviceState *qdev_create_from_info(BusState *bus, DeviceInfo *info)
  83 {
  84     DeviceState *dev;
  85
  86     assert(bus->info == info->bus_info);
  87     dev = qemu_mallocz(info->size);
  88     dev->info = info;
  89     dev->parent_bus = bus;
  90     qdev_prop_set_defaults(dev, dev->info->props);
  91     qdev_prop_set_defaults(dev, dev->parent_bus->info->props);
  92     qdev_prop_set_globals(dev);
  93     QLIST_INSERT_HEAD(&bus->children, dev, sibling);
  94     if (qdev_hotplug) {
  95         assert(bus->allow_hotplug);
  96         dev->hotplugged = 1;
  97         qdev_hot_added = true;
  98     }
  99     dev->instance_id_alias = -1;
 100     dev->state = DEV_STATE_CREATED;
 101     return dev;
 102 }
 103
 104 /* Create a new device.  This only initializes the device state structure
 105    and allows properties to be set.  qdev_init should be called to
 106    initialize the actual device emulation.  */
 107 DeviceState *qdev_create(BusState *bus, const char *name)
 108 {
 109     DeviceState *dev;
 110
 111     dev = qdev_try_create(bus, name);
 112     if (!dev) {
 113         hw_error("Unknown device '%s' for bus '%s'\n", name, bus->info->name);
 114     }
 115
 116     return dev;
 117 }
 118
 119 DeviceState *qdev_try_create(BusState *bus, const char *name)
 120 {
 121     DeviceInfo *info;
 122
 123     if (!bus) {
 124         bus = sysbus_get_default();
 125     }
 126
 127     info = qdev_find_info(bus->info, name);
 128     if (!info) {
 129         return NULL;
 130     }
 131
 132     return qdev_create_from_info(bus, info);
 133 }
 134
 135 static void qdev_print_devinfo(DeviceInfo *info)
 136 {
 137     error_printf("name \"%s\", bus %s",
 138                  info->name, info->bus_info->name);
 139     if (info->alias) {
 140         error_printf(", alias \"%s\"", info->alias);
 141     }
 142     if (info->desc) {
 143         error_printf(", desc \"%s\"", info->desc);
 144     }
 145     if (info->no_user) {
 146         error_printf(", no-user");
 147     }
 148     error_printf("\n");
 149 }
 150
 151 static int set_property(const char *name, const char *value, void *opaque)
 152 {
 153     DeviceState *dev = opaque;
 154
 155     if (strcmp(name, "driver") == 0)
 156         return 0;
 157     if (strcmp(name, "bus") == 0)
 158         return 0;
 159
 160     if (qdev_prop_parse(dev, name, value) == -1) {
 161         return -1;
 162     }
 163     return 0;
 164 }
 165
 166 int qdev_device_help(QemuOpts *opts)
 167 {
 168     const char *driver;
 169     DeviceInfo *info;
 170     Property *prop;
 171
 172     driver = qemu_opt_get(opts, "driver");
 173     if (driver && !strcmp(driver, "?")) {
 174         for (info = device_info_list; info != NULL; info = info->next) {
 175             if (info->no_user) {
 176                 continue;       /* not available, don't show */
 177             }
 178             qdev_print_devinfo(info);
 179         }
 180         return 1;
 181     }
 182
 183     if (!qemu_opt_get(opts, "?")) {
 184         return 0;
 185     }
 186
 187     info = qdev_find_info(NULL, driver);
 188     if (!info) {
 189         return 0;
 190     }
 191
 192     for (prop = info->props; prop && prop->name; prop++) {
 193         /*
 194          * TODO Properties without a parser are just for dirty hacks.
 195          * qdev_prop_ptr is the only such PropertyInfo.  It's marked
 196          * for removal.  This conditional should be removed along with
 197          * it.
 198          */
 199         if (!prop->info->parse) {
 200             continue;           /* no way to set it, don't show */
 201         }
 202         error_printf("%s.%s=%s\n", info->name, prop->name, prop->info->name);
 203     }
 204     return 1;
 205 }
 206
 207 DeviceState *qdev_device_add(QemuOpts *opts)
 208 {
 209     const char *driver, *path, *id;
 210     DeviceInfo *info;
 211     DeviceState *qdev;
 212     BusState *bus;
 213
 214     driver = qemu_opt_get(opts, "driver");
 215     if (!driver) {
 216         qerror_report(QERR_MISSING_PARAMETER, "driver");
 217         return NULL;
 218     }
 219
 220     /* find driver */
 221     info = qdev_find_info(NULL, driver);
 222     if (!info || info->no_user) {
 223         qerror_report(QERR_INVALID_PARAMETER_VALUE, "driver", "a driver name");
 224         error_printf_unless_qmp("Try with argument '?' for a list.\n");
 225         return NULL;
 226     }
 227
 228     /* find bus */
 229     path = qemu_opt_get(opts, "bus");
 230     if (path != NULL) {
 231         bus = qbus_find(path);
 232         if (!bus) {
 233             return NULL;
 234         }
 235         if (bus->info != info->bus_info) {
 236             qerror_report(QERR_BAD_BUS_FOR_DEVICE,
 237                            driver, bus->info->name);
 238             return NULL;
 239         }
 240     } else {
 241         bus = qbus_find_recursive(main_system_bus, NULL, info->bus_info);
 242         if (!bus) {
 243             qerror_report(QERR_NO_BUS_FOR_DEVICE,
 244                            info->name, info->bus_info->name);
 245             return NULL;
 246         }
 247     }
 248     if (qdev_hotplug && !bus->allow_hotplug) {
 249         qerror_report(QERR_BUS_NO_HOTPLUG, bus->name);
 250         return NULL;
 251     }
 252
 253     /* create device, set properties */
 254     qdev = qdev_create_from_info(bus, info);
 255     id = qemu_opts_id(opts);
 256     if (id) {
 257         qdev->id = id;
 258     }
 259     if (qemu_opt_foreach(opts, set_property, qdev, 1) != 0) {
 260         qdev_free(qdev);
 261         return NULL;
 262     }
 263     if (qdev_init(qdev) < 0) {
 264         qerror_report(QERR_DEVICE_INIT_FAILED, driver);
 265         return NULL;
 266     }
 267     qdev->opts = opts;
 268     return qdev;
 269 }
 270
 271 /* Initialize a device.  Device properties should be set before calling
 272    this function.  IRQs and MMIO regions should be connected/mapped after
 273    calling this function.
 274    On failure, destroy the device and return negative value.
 275    Return 0 on success.  */
 276 int qdev_init(DeviceState *dev)
 277 {
 278     int rc;
 279
 280     assert(dev->state == DEV_STATE_CREATED);
 281     rc = dev->info->init(dev, dev->info);
 282     if (rc < 0) {
 283         qdev_free(dev);
 284         return rc;
 285     }
 286     if (dev->info->vmsd) {
 287         vmstate_register_with_alias_id(dev, -1, dev->info->vmsd, dev,
 288                                        dev->instance_id_alias,
 289                                        dev->alias_required_for_version);
 290     }
 291     dev->state = DEV_STATE_INITIALIZED;
 292     return 0;
 293 }
 294
 295 void qdev_set_legacy_instance_id(DeviceState *dev, int alias_id,
 296                                  int required_for_version)
 297 {
 298     assert(dev->state == DEV_STATE_CREATED);
 299     dev->instance_id_alias = alias_id;
 300     dev->alias_required_for_version = required_for_version;
 301 }
 302
 303 int qdev_unplug(DeviceState *dev)
 304 {
 305     if (!dev->parent_bus->allow_hotplug) {
 306         qerror_report(QERR_BUS_NO_HOTPLUG, dev->parent_bus->name);
 307         return -1;
 308     }
 309     assert(dev->info->unplug != NULL);
 310
 311     qdev_hot_removed = true;
 312
 313     return dev->info->unplug(dev);
 314 }
 315
 316 static int qdev_reset_one(DeviceState *dev, void *opaque)
 317 {
 318     if (dev->info->reset) {
 319         dev->info->reset(dev);
 320     }
 321
 322     return 0;
 323 }
 324
 325 BusState *sysbus_get_default(void)
 326 {
 327     if (!main_system_bus) {
 328         main_system_bus = qbus_create(&system_bus_info, NULL,
 329                                       "main-system-bus");
 330     }
 331     return main_system_bus;
 332 }
 333
 334 static int qbus_reset_one(BusState *bus, void *opaque)
 335 {
 336     if (bus->info->reset) {
 337         return bus->info->reset(bus);
 338     }
 339     return 0;
 340 }
 341
 342 void qdev_reset_all(DeviceState *dev)
 343 {
 344     qdev_walk_children(dev, qdev_reset_one, qbus_reset_one, NULL);
 345 }
 346
 347 void qbus_reset_all_fn(void *opaque)
 348 {
 349     BusState *bus = opaque;
 350     qbus_walk_children(bus, qdev_reset_one, qbus_reset_one, NULL);
 351 }
 352
 353 /* can be used as ->unplug() callback for the simple cases */
 354 int qdev_simple_unplug_cb(DeviceState *dev)
 355 {
 356     /* just zap it */
 357     qdev_free(dev);
 358     return 0;
 359 }
 360
 361 /* Like qdev_init(), but terminate program via hw_error() instead of
 362    returning an error value.  This is okay during machine creation.
 363    Don't use for hotplug, because there callers need to recover from
 364    failure.  Exception: if you know the device's init() callback can't
 365    fail, then qdev_init_nofail() can't fail either, and is therefore
 366    usable even then.  But relying on the device implementation that
 367    way is somewhat unclean, and best avoided.  */
 368 void qdev_init_nofail(DeviceState *dev)
 369 {
 370     DeviceInfo *info = dev->info;
 371
 372     if (qdev_init(dev) < 0) {
 373         error_report("Initialization of device %s failed\n", info->name);
 374         exit(1);
 375     }
 376 }
 377
 378 /* Unlink device from bus and free the structure.  */
 379 void qdev_free(DeviceState *dev)
 380 {
 381     BusState *bus;
 382     Property *prop;
 383
 384     if (dev->state == DEV_STATE_INITIALIZED) {
 385         while (dev->num_child_bus) {
 386             bus = QLIST_FIRST(&dev->child_bus);
 387             qbus_free(bus);
 388         }
 389         if (dev->info->vmsd)
 390             vmstate_unregister(dev, dev->info->vmsd, dev);
 391         if (dev->info->exit)
 392             dev->info->exit(dev);
 393         if (dev->opts)
 394             qemu_opts_del(dev->opts);
 395     }
 396     QLIST_REMOVE(dev, sibling);
 397     for (prop = dev->info->props; prop && prop->name; prop++) {
 398         if (prop->info->free) {
 399             prop->info->free(dev, prop);
 400         }
 401     }
 402     qemu_free(dev);
 403 }
 404
 405 void qdev_machine_creation_done(void)
 406 {
 407     /*
 408      * ok, initial machine setup is done, starting from now we can
 409      * only create hotpluggable devices
 410      */
 411     qdev_hotplug = 1;
 412 }
 413
 414 bool qdev_machine_modified(void)
 415 {
 416     return qdev_hot_added || qdev_hot_removed;
 417 }
 418
 419 /* Get a character (serial) device interface.  */
 420 CharDriverState *qdev_init_chardev(DeviceState *dev)
 421 {
 422     static int next_serial;
 423
 424     /* FIXME: This function needs to go away: use chardev properties!  */
 425     return serial_hds[next_serial++];
 426 }
 427
 428 BusState *qdev_get_parent_bus(DeviceState *dev)
 429 {
 430     return dev->parent_bus;
 431 }
 432
 433 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
 434 {
 435     assert(dev->num_gpio_in == 0);
 436     dev->num_gpio_in = n;
 437     dev->gpio_in = qemu_allocate_irqs(handler, dev, n);
 438 }
 439
 440 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 441 {
 442     assert(dev->num_gpio_out == 0);
 443     dev->num_gpio_out = n;
 444     dev->gpio_out = pins;
 445 }
 446
 447 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 448 {
 449     assert(n >= 0 && n < dev->num_gpio_in);
 450     return dev->gpio_in[n];
 451 }
 452
 453 void qdev_connect_gpio_out(DeviceState * dev, int n, qemu_irq pin)
 454 {
 455     assert(n >= 0 && n < dev->num_gpio_out);
 456     dev->gpio_out[n] = pin;
 457 }
 458
 459 void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
 460 {
 461     qdev_prop_set_macaddr(dev, "mac", nd->macaddr);
 462     if (nd->vlan)
 463         qdev_prop_set_vlan(dev, "vlan", nd->vlan);
 464     if (nd->netdev)
 465         qdev_prop_set_netdev(dev, "netdev", nd->netdev);
 466     if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
 467         qdev_prop_exists(dev, "vectors")) {
 468         qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
 469     }
 470 }
 471
 472 BusState *qdev_get_child_bus(DeviceState *dev, const char *name)
 473 {
 474     BusState *bus;
 475
 476     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 477         if (strcmp(name, bus->name) == 0) {
 478             return bus;
 479         }
 480     }
 481     return NULL;
 482 }
 483
 484 int qbus_walk_children(BusState *bus, qdev_walkerfn *devfn,
 485                        qbus_walkerfn *busfn, void *opaque)
 486 {
 487     DeviceState *dev;
 488     int err;
 489
 490     if (busfn) {
 491         err = busfn(bus, opaque);
 492         if (err) {
 493             return err;
 494         }
 495     }
 496
 497     QLIST_FOREACH(dev, &bus->children, sibling) {
 498         err = qdev_walk_children(dev, devfn, busfn, opaque);
 499         if (err < 0) {
 500             return err;
 501         }
 502     }
 503
 504     return 0;
 505 }
 506
 507 int qdev_walk_children(DeviceState *dev, qdev_walkerfn *devfn,
 508                        qbus_walkerfn *busfn, void *opaque)
 509 {
 510     BusState *bus;
 511     int err;
 512
 513     if (devfn) {
 514         err = devfn(dev, opaque);
 515         if (err) {
 516             return err;
 517         }
 518     }
 519
 520     QLIST_FOREACH(bus, &dev->child_bus, sibling) {
 521         err = qbus_walk_children(bus, devfn, busfn, opaque);
 522         if (err < 0) {
 523             return err;
 524         }
 525     }
 526
 527     return 0;
 528 }
 529
 530 static BusState *qbus_find_recursive(BusState *bus, const char *name,
 531                                      const BusInfo *info)
 532 {
 533     DeviceState *dev;
 534     BusState *child, *ret;
 535     int match = 1;
 536
 537     if (name && (strcmp(bus->name, name) != 0)) {
 538         match = 0;
 539     }
 540     if (info && (bus->info != info)) {
 541         match = 0;
 542     }
 543     if (match) {
 544         return bus;
 545     }
 546
 547     QLIST_FOREACH(dev, &bus->children, sibling) {
 548         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 549             ret = qbus_find_recursive(child, name, info);
 550             if (ret) {
 551                 return ret;
 552             }
 553         }
 554     }
 555     return NULL;
 556 }
 557
 558 DeviceState *qdev_find_recursive(BusState *bus, const char *id)
 559 {
 560     DeviceState *dev, *ret;
 561     BusState *child;
 562
 563     QLIST_FOREACH(dev, &bus->children, sibling) {
 564         if (dev->id && strcmp(dev->id, id) == 0)
 565             return dev;
 566         QLIST_FOREACH(child, &dev->child_bus, sibling) {
 567             ret = qdev_find_recursive(child, id);
 568             if (ret) {
 569                 return ret;
 570             }
 571         }
 572     }
 573     return NULL;
 574 }
 575
 576 static void qbus_list_bus(DeviceState *dev)
 577 {
 578     BusState *child;
 579     const char *sep = " ";
 580
 581     error_printf("child busses at \"%s\":",
 582                  dev->id ? dev->id : dev->info->name);
 583     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 584         error_printf("%s\"%s\"", sep, child->name);
 585         sep = ", ";
 586     }
 587     error_printf("\n");
 588 }
 589
 590 static void qbus_list_dev(BusState *bus)
 591 {
 592     DeviceState *dev;
 593     const char *sep = " ";
 594
 595     error_printf("devices at \"%s\":", bus->name);
 596     QLIST_FOREACH(dev, &bus->children, sibling) {
 597         error_printf("%s\"%s\"", sep, dev->info->name);
 598         if (dev->id)
 599             error_printf("/\"%s\"", dev->id);
 600         sep = ", ";
 601     }
 602     error_printf("\n");
 603 }
 604
 605 static BusState *qbus_find_bus(DeviceState *dev, char *elem)
 606 {
 607     BusState *child;
 608
 609     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 610         if (strcmp(child->name, elem) == 0) {
 611             return child;
 612         }
 613     }
 614     return NULL;
 615 }
 616
 617 static DeviceState *qbus_find_dev(BusState *bus, char *elem)
 618 {
 619     DeviceState *dev;
 620
 621     /*
 622      * try to match in order:
 623      *   (1) instance id, if present
 624      *   (2) driver name
 625      *   (3) driver alias, if present
 626      */
 627     QLIST_FOREACH(dev, &bus->children, sibling) {
 628         if (dev->id  &&  strcmp(dev->id, elem) == 0) {
 629             return dev;
 630         }
 631     }
 632     QLIST_FOREACH(dev, &bus->children, sibling) {
 633         if (strcmp(dev->info->name, elem) == 0) {
 634             return dev;
 635         }
 636     }
 637     QLIST_FOREACH(dev, &bus->children, sibling) {
 638         if (dev->info->alias && strcmp(dev->info->alias, elem) == 0) {
 639             return dev;
 640         }
 641     }
 642     return NULL;
 643 }
 644
 645 static BusState *qbus_find(const char *path)
 646 {
 647     DeviceState *dev;
 648     BusState *bus;
 649     char elem[128];
 650     int pos, len;
 651
 652     /* find start element */
 653     if (path[0] == '/') {
 654         bus = main_system_bus;
 655         pos = 0;
 656     } else {
 657         if (sscanf(path, "%127[^/]%n", elem, &len) != 1) {
 658             assert(!path[0]);
 659             elem[0] = len = 0;
 660         }
 661         bus = qbus_find_recursive(main_system_bus, elem, NULL);
 662         if (!bus) {
 663             qerror_report(QERR_BUS_NOT_FOUND, elem);
 664             return NULL;
 665         }
 666         pos = len;
 667     }
 668
 669     for (;;) {
 670         assert(path[pos] == '/' || !path[pos]);
 671         while (path[pos] == '/') {
 672             pos++;
 673         }
 674         if (path[pos] == '\0') {
 675             return bus;
 676         }
 677
 678         /* find device */
 679         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
 680             assert(0);
 681             elem[0] = len = 0;
 682         }
 683         pos += len;
 684         dev = qbus_find_dev(bus, elem);
 685         if (!dev) {
 686             qerror_report(QERR_DEVICE_NOT_FOUND, elem);
 687             if (!monitor_cur_is_qmp()) {
 688                 qbus_list_dev(bus);
 689             }
 690             return NULL;
 691         }
 692
 693         assert(path[pos] == '/' || !path[pos]);
 694         while (path[pos] == '/') {
 695             pos++;
 696         }
 697         if (path[pos] == '\0') {
 698             /* last specified element is a device.  If it has exactly
 699              * one child bus accept it nevertheless */
 700             switch (dev->num_child_bus) {
 701             case 0:
 702                 qerror_report(QERR_DEVICE_NO_BUS, elem);
 703                 return NULL;
 704             case 1:
 705                 return QLIST_FIRST(&dev->child_bus);
 706             default:
 707                 qerror_report(QERR_DEVICE_MULTIPLE_BUSSES, elem);
 708                 if (!monitor_cur_is_qmp()) {
 709                     qbus_list_bus(dev);
 710                 }
 711                 return NULL;
 712             }
 713         }
 714
 715         /* find bus */
 716         if (sscanf(path+pos, "%127[^/]%n", elem, &len) != 1) {
 717             assert(0);
 718             elem[0] = len = 0;
 719         }
 720         pos += len;
 721         bus = qbus_find_bus(dev, elem);
 722         if (!bus) {
 723             qerror_report(QERR_BUS_NOT_FOUND, elem);
 724             if (!monitor_cur_is_qmp()) {
 725                 qbus_list_bus(dev);
 726             }
 727             return NULL;
 728         }
 729     }
 730 }
 731
 732 void qbus_create_inplace(BusState *bus, BusInfo *info,
 733                          DeviceState *parent, const char *name)
 734 {
 735     char *buf;
 736     int i,len;
 737
 738     bus->info = info;
 739     bus->parent = parent;
 740
 741     if (name) {
 742         /* use supplied name */
 743         bus->name = qemu_strdup(name);
 744     } else if (parent && parent->id) {
 745         /* parent device has id -> use it for bus name */
 746         len = strlen(parent->id) + 16;
 747         buf = qemu_malloc(len);
 748         snprintf(buf, len, "%s.%d", parent->id, parent->num_child_bus);
 749         bus->name = buf;
 750     } else {
 751         /* no id -> use lowercase bus type for bus name */
 752         len = strlen(info->name) + 16;
 753         buf = qemu_malloc(len);
 754         len = snprintf(buf, len, "%s.%d", info->name,
 755                        parent ? parent->num_child_bus : 0);
 756         for (i = 0; i < len; i++)
 757             buf[i] = qemu_tolower(buf[i]);
 758         bus->name = buf;
 759     }
 760
 761     QLIST_INIT(&bus->children);
 762     if (parent) {
 763         QLIST_INSERT_HEAD(&parent->child_bus, bus, sibling);
 764         parent->num_child_bus++;
 765     } else if (bus != main_system_bus) {
 766         /* TODO: once all bus devices are qdevified,
 767            only reset handler for main_system_bus should be registered here. */
 768         qemu_register_reset(qbus_reset_all_fn, bus);
 769     }
 770 }
 771
 772 BusState *qbus_create(BusInfo *info, DeviceState *parent, const char *name)
 773 {
 774     BusState *bus;
 775
 776     bus = qemu_mallocz(info->size);
 777     bus->qdev_allocated = 1;
 778     qbus_create_inplace(bus, info, parent, name);
 779     return bus;
 780 }
 781
 782 void qbus_free(BusState *bus)
 783 {
 784     DeviceState *dev;
 785
 786     while ((dev = QLIST_FIRST(&bus->children)) != NULL) {
 787         qdev_free(dev);
 788     }
 789     if (bus->parent) {
 790         QLIST_REMOVE(bus, sibling);
 791         bus->parent->num_child_bus--;
 792     } else {
 793         assert(bus != main_system_bus); /* main_system_bus is never freed */
 794         qemu_unregister_reset(qbus_reset_all_fn, bus);
 795     }
 796     qemu_free((void*)bus->name);
 797     if (bus->qdev_allocated) {
 798         qemu_free(bus);
 799     }
 800 }
 801
 802 #define qdev_printf(fmt, ...) monitor_printf(mon, "%*s" fmt, indent, "", ## __VA_ARGS__)
 803 static void qbus_print(Monitor *mon, BusState *bus, int indent);
 804
 805 static void qdev_print_props(Monitor *mon, DeviceState *dev, Property *props,
 806                              const char *prefix, int indent)
 807 {
 808     char buf[64];
 809
 810     if (!props)
 811         return;
 812     while (props->name) {
 813         /*
 814          * TODO Properties without a print method are just for dirty
 815          * hacks.  qdev_prop_ptr is the only such PropertyInfo.  It's
 816          * marked for removal.  The test props->info->print should be
 817          * removed along with it.
 818          */
 819         if (props->info->print) {
 820             props->info->print(dev, props, buf, sizeof(buf));
 821             qdev_printf("%s-prop: %s = %s\n", prefix, props->name, buf);
 822         }
 823         props++;
 824     }
 825 }
 826
 827 static void qdev_print(Monitor *mon, DeviceState *dev, int indent)
 828 {
 829     BusState *child;
 830     qdev_printf("dev: %s, id \"%s\"\n", dev->info->name,
 831                 dev->id ? dev->id : "");
 832     indent += 2;
 833     if (dev->num_gpio_in) {
 834         qdev_printf("gpio-in %d\n", dev->num_gpio_in);
 835     }
 836     if (dev->num_gpio_out) {
 837         qdev_printf("gpio-out %d\n", dev->num_gpio_out);
 838     }
 839     qdev_print_props(mon, dev, dev->info->props, "dev", indent);
 840     qdev_print_props(mon, dev, dev->parent_bus->info->props, "bus", indent);
 841     if (dev->parent_bus->info->print_dev)
 842         dev->parent_bus->info->print_dev(mon, dev, indent);
 843     QLIST_FOREACH(child, &dev->child_bus, sibling) {
 844         qbus_print(mon, child, indent);
 845     }
 846 }
 847
 848 static void qbus_print(Monitor *mon, BusState *bus, int indent)
 849 {
 850     struct DeviceState *dev;
 851
 852     qdev_printf("bus: %s\n", bus->name);
 853     indent += 2;
 854     qdev_printf("type %s\n", bus->info->name);
 855     QLIST_FOREACH(dev, &bus->children, sibling) {
 856         qdev_print(mon, dev, indent);
 857     }
 858 }
 859 #undef qdev_printf
 860
 861 void do_info_qtree(Monitor *mon)
 862 {
 863     if (main_system_bus)
 864         qbus_print(mon, main_system_bus, 0);
 865 }
 866
 867 void do_info_qdm(Monitor *mon)
 868 {
 869     DeviceInfo *info;
 870
 871     for (info = device_info_list; info != NULL; info = info->next) {
 872         qdev_print_devinfo(info);
 873     }
 874 }
 875
 876 int do_device_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
 877 {
 878     QemuOpts *opts;
 879
 880     opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict);
 881     if (!opts) {
 882         return -1;
 883     }
 884     if (!monitor_cur_is_qmp() && qdev_device_help(opts)) {
 885         qemu_opts_del(opts);
 886         return 0;
 887     }
 888     if (!qdev_device_add(opts)) {
 889         qemu_opts_del(opts);
 890         return -1;
 891     }
 892     return 0;
 893 }
 894
 895 int do_device_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
 896 {
 897     const char *id = qdict_get_str(qdict, "id");
 898     DeviceState *dev;
 899
 900     dev = qdev_find_recursive(main_system_bus, id);
 901     if (NULL == dev) {
 902         qerror_report(QERR_DEVICE_NOT_FOUND, id);
 903         return -1;
 904     }
 905     return qdev_unplug(dev);
 906 }
 907
 908 static int qdev_get_fw_dev_path_helper(DeviceState *dev, char *p, int size)
 909 {
 910     int l = 0;
 911
 912     if (dev && dev->parent_bus) {
 913         char *d;
 914         l = qdev_get_fw_dev_path_helper(dev->parent_bus->parent, p, size);
 915         if (dev->parent_bus->info->get_fw_dev_path) {
 916             d = dev->parent_bus->info->get_fw_dev_path(dev);
 917             l += snprintf(p + l, size - l, "%s", d);
 918             qemu_free(d);
 919         } else {
 920             l += snprintf(p + l, size - l, "%s", dev->info->name);
 921         }
 922     }
 923     l += snprintf(p + l , size - l, "/");
 924
 925     return l;
 926 }
 927
 928 char* qdev_get_fw_dev_path(DeviceState *dev)
 929 {
 930     char path[128];
 931     int l;
 932
 933     l = qdev_get_fw_dev_path_helper(dev, path, 128);
 934
 935     path[l-1] = '\0';
 936
 937     return strdup(path);
 938 }