hw/ppc/spapr_vio.c

   1 /*
   2  * QEMU sPAPR VIO code
   3  *
   4  * Copyright (c) 2010 David Gibson, IBM Corporation <dwg@au1.ibm.com>
   5  * Based on the s390 virtio bus code:
   6  * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "qemu/osdep.h"
  23 #include "qemu/error-report.h"
  24 #include "qapi/error.h"
  25 #include "qapi/visitor.h"
  26 #include "hw/hw.h"
  27 #include "qemu/log.h"
  28 #include "sysemu/sysemu.h"
  29 #include "hw/boards.h"
  30 #include "hw/loader.h"
  31 #include "elf.h"
  32 #include "hw/sysbus.h"
  33 #include "sysemu/kvm.h"
  34 #include "sysemu/device_tree.h"
  35 #include "kvm_ppc.h"
  36 #include "sysemu/qtest.h"
  37
  38 #include "hw/ppc/spapr.h"
  39 #include "hw/ppc/spapr_vio.h"
  40 #include "hw/ppc/xics.h"
  41 #include "hw/ppc/fdt.h"
  42 #include "trace.h"
  43
  44 #include <libfdt.h>
  45
  46 static void spapr_vio_getset_irq(Object *obj, Visitor *v, const char *name,
  47                               void *opaque, Error **errp)
  48 {
  49     Property *prop = opaque;
  50     uint32_t *ptr = qdev_get_prop_ptr(DEVICE(obj), prop);
  51
  52     if (!qtest_enabled()) {
  53         warn_report(TYPE_VIO_SPAPR_DEVICE " '%s' property is deprecated", name);
  54     }
  55     visit_type_uint32(v, name, ptr, errp);
  56 }
  57
  58 static const PropertyInfo spapr_vio_irq_propinfo = {
  59     .name = "irq",
  60     .get = spapr_vio_getset_irq,
  61     .set = spapr_vio_getset_irq,
  62 };
  63
  64 static Property spapr_vio_props[] = {
  65     DEFINE_PROP("irq", VIOsPAPRDevice, irq, spapr_vio_irq_propinfo, uint32_t),
  66     DEFINE_PROP_END_OF_LIST(),
  67 };
  68
  69 static char *spapr_vio_get_dev_name(DeviceState *qdev)
  70 {
  71     VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev);
  72     VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
  73
  74     /* Device tree style name device@reg */
  75     return g_strdup_printf("%s@%x", pc->dt_name, dev->reg);
  76 }
  77
  78 static void spapr_vio_bus_class_init(ObjectClass *klass, void *data)
  79 {
  80     BusClass *k = BUS_CLASS(klass);
  81
  82     k->get_dev_path = spapr_vio_get_dev_name;
  83     k->get_fw_dev_path = spapr_vio_get_dev_name;
  84 }
  85
  86 static const TypeInfo spapr_vio_bus_info = {
  87     .name = TYPE_SPAPR_VIO_BUS,
  88     .parent = TYPE_BUS,
  89     .class_init = spapr_vio_bus_class_init,
  90     .instance_size = sizeof(VIOsPAPRBus),
  91 };
  92
  93 VIOsPAPRDevice *spapr_vio_find_by_reg(VIOsPAPRBus *bus, uint32_t reg)
  94 {
  95     BusChild *kid;
  96     VIOsPAPRDevice *dev = NULL;
  97
  98     QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
  99         dev = (VIOsPAPRDevice *)kid->child;
 100         if (dev->reg == reg) {
 101             return dev;
 102         }
 103     }
 104
 105     return NULL;
 106 }
 107
 108 static int vio_make_devnode(VIOsPAPRDevice *dev,
 109                             void *fdt)
 110 {
 111     VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
 112     int vdevice_off, node_off, ret;
 113     char *dt_name;
 114
 115     vdevice_off = fdt_path_offset(fdt, "/vdevice");
 116     if (vdevice_off < 0) {
 117         return vdevice_off;
 118     }
 119
 120     dt_name = spapr_vio_get_dev_name(DEVICE(dev));
 121     node_off = fdt_add_subnode(fdt, vdevice_off, dt_name);
 122     g_free(dt_name);
 123     if (node_off < 0) {
 124         return node_off;
 125     }
 126
 127     ret = fdt_setprop_cell(fdt, node_off, "reg", dev->reg);
 128     if (ret < 0) {
 129         return ret;
 130     }
 131
 132     if (pc->dt_type) {
 133         ret = fdt_setprop_string(fdt, node_off, "device_type",
 134                                  pc->dt_type);
 135         if (ret < 0) {
 136             return ret;
 137         }
 138     }
 139
 140     if (pc->dt_compatible) {
 141         ret = fdt_setprop_string(fdt, node_off, "compatible",
 142                                  pc->dt_compatible);
 143         if (ret < 0) {
 144             return ret;
 145         }
 146     }
 147
 148     if (dev->irq) {
 149         uint32_t ints_prop[2];
 150
 151         spapr_dt_xics_irq(ints_prop, dev->irq, false);
 152         ret = fdt_setprop(fdt, node_off, "interrupts", ints_prop,
 153                           sizeof(ints_prop));
 154         if (ret < 0) {
 155             return ret;
 156         }
 157     }
 158
 159     ret = spapr_tcet_dma_dt(fdt, node_off, "ibm,my-dma-window", dev->tcet);
 160     if (ret < 0) {
 161         return ret;
 162     }
 163
 164     if (pc->devnode) {
 165         ret = (pc->devnode)(dev, fdt, node_off);
 166         if (ret < 0) {
 167             return ret;
 168         }
 169     }
 170
 171     return node_off;
 172 }
 173
 174 /*
 175  * CRQ handling
 176  */
 177 static target_ulong h_reg_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 178                               target_ulong opcode, target_ulong *args)
 179 {
 180     target_ulong reg = args[0];
 181     target_ulong queue_addr = args[1];
 182     target_ulong queue_len = args[2];
 183     VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
 184
 185     if (!dev) {
 186         hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg);
 187         return H_PARAMETER;
 188     }
 189
 190     /* We can't grok a queue size bigger than 256M for now */
 191     if (queue_len < 0x1000 || queue_len > 0x10000000) {
 192         hcall_dprintf("Queue size too small or too big (0x" TARGET_FMT_lx
 193                       ")\n", queue_len);
 194         return H_PARAMETER;
 195     }
 196
 197     /* Check queue alignment */
 198     if (queue_addr & 0xfff) {
 199         hcall_dprintf("Queue not aligned (0x" TARGET_FMT_lx ")\n", queue_addr);
 200         return H_PARAMETER;
 201     }
 202
 203     /* Check if device supports CRQs */
 204     if (!dev->crq.SendFunc) {
 205         hcall_dprintf("Device does not support CRQ\n");
 206         return H_NOT_FOUND;
 207     }
 208
 209     /* Already a queue ? */
 210     if (dev->crq.qsize) {
 211         hcall_dprintf("CRQ already registered\n");
 212         return H_RESOURCE;
 213     }
 214     dev->crq.qladdr = queue_addr;
 215     dev->crq.qsize = queue_len;
 216     dev->crq.qnext = 0;
 217
 218     trace_spapr_vio_h_reg_crq(reg, queue_addr, queue_len);
 219     return H_SUCCESS;
 220 }
 221
 222 static target_ulong free_crq(VIOsPAPRDevice *dev)
 223 {
 224     dev->crq.qladdr = 0;
 225     dev->crq.qsize = 0;
 226     dev->crq.qnext = 0;
 227
 228     trace_spapr_vio_free_crq(dev->reg);
 229
 230     return H_SUCCESS;
 231 }
 232
 233 static target_ulong h_free_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 234                                target_ulong opcode, target_ulong *args)
 235 {
 236     target_ulong reg = args[0];
 237     VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
 238
 239     if (!dev) {
 240         hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg);
 241         return H_PARAMETER;
 242     }
 243
 244     return free_crq(dev);
 245 }
 246
 247 static target_ulong h_send_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 248                                target_ulong opcode, target_ulong *args)
 249 {
 250     target_ulong reg = args[0];
 251     target_ulong msg_hi = args[1];
 252     target_ulong msg_lo = args[2];
 253     VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
 254     uint64_t crq_mangle[2];
 255
 256     if (!dev) {
 257         hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg);
 258         return H_PARAMETER;
 259     }
 260     crq_mangle[0] = cpu_to_be64(msg_hi);
 261     crq_mangle[1] = cpu_to_be64(msg_lo);
 262
 263     if (dev->crq.SendFunc) {
 264         return dev->crq.SendFunc(dev, (uint8_t *)crq_mangle);
 265     }
 266
 267     return H_HARDWARE;
 268 }
 269
 270 static target_ulong h_enable_crq(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 271                                  target_ulong opcode, target_ulong *args)
 272 {
 273     target_ulong reg = args[0];
 274     VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
 275
 276     if (!dev) {
 277         hcall_dprintf("Unit 0x" TARGET_FMT_lx " does not exist\n", reg);
 278         return H_PARAMETER;
 279     }
 280
 281     return 0;
 282 }
 283
 284 /* Returns negative error, 0 success, or positive: queue full */
 285 int spapr_vio_send_crq(VIOsPAPRDevice *dev, uint8_t *crq)
 286 {
 287     int rc;
 288     uint8_t byte;
 289
 290     if (!dev->crq.qsize) {
 291         error_report("spapr_vio_send_creq on uninitialized queue");
 292         return -1;
 293     }
 294
 295     /* Maybe do a fast path for KVM just writing to the pages */
 296     rc = spapr_vio_dma_read(dev, dev->crq.qladdr + dev->crq.qnext, &byte, 1);
 297     if (rc) {
 298         return rc;
 299     }
 300     if (byte != 0) {
 301         return 1;
 302     }
 303
 304     rc = spapr_vio_dma_write(dev, dev->crq.qladdr + dev->crq.qnext + 8,
 305                              &crq[8], 8);
 306     if (rc) {
 307         return rc;
 308     }
 309
 310     kvmppc_eieio();
 311
 312     rc = spapr_vio_dma_write(dev, dev->crq.qladdr + dev->crq.qnext, crq, 8);
 313     if (rc) {
 314         return rc;
 315     }
 316
 317     dev->crq.qnext = (dev->crq.qnext + 16) % dev->crq.qsize;
 318
 319     if (dev->signal_state & 1) {
 320         qemu_irq_pulse(spapr_vio_qirq(dev));
 321     }
 322
 323     return 0;
 324 }
 325
 326 /* "quiesce" handling */
 327
 328 static void spapr_vio_quiesce_one(VIOsPAPRDevice *dev)
 329 {
 330     if (dev->tcet) {
 331         device_reset(DEVICE(dev->tcet));
 332     }
 333     free_crq(dev);
 334 }
 335
 336 void spapr_vio_set_bypass(VIOsPAPRDevice *dev, bool bypass)
 337 {
 338     if (!dev->tcet) {
 339         return;
 340     }
 341
 342     memory_region_set_enabled(&dev->mrbypass, bypass);
 343     memory_region_set_enabled(spapr_tce_get_iommu(dev->tcet), !bypass);
 344
 345     dev->tcet->bypass = bypass;
 346 }
 347
 348 static void rtas_set_tce_bypass(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 349                                 uint32_t token,
 350                                 uint32_t nargs, target_ulong args,
 351                                 uint32_t nret, target_ulong rets)
 352 {
 353     VIOsPAPRBus *bus = spapr->vio_bus;
 354     VIOsPAPRDevice *dev;
 355     uint32_t unit, enable;
 356
 357     if (nargs != 2) {
 358         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 359         return;
 360     }
 361     unit = rtas_ld(args, 0);
 362     enable = rtas_ld(args, 1);
 363     dev = spapr_vio_find_by_reg(bus, unit);
 364     if (!dev) {
 365         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 366         return;
 367     }
 368
 369     if (!dev->tcet) {
 370         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 371         return;
 372     }
 373
 374     spapr_vio_set_bypass(dev, !!enable);
 375
 376     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 377 }
 378
 379 static void rtas_quiesce(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 380                          uint32_t token,
 381                          uint32_t nargs, target_ulong args,
 382                          uint32_t nret, target_ulong rets)
 383 {
 384     VIOsPAPRBus *bus = spapr->vio_bus;
 385     BusChild *kid;
 386     VIOsPAPRDevice *dev = NULL;
 387
 388     if (nargs != 0) {
 389         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 390         return;
 391     }
 392
 393     QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
 394         dev = (VIOsPAPRDevice *)kid->child;
 395         spapr_vio_quiesce_one(dev);
 396     }
 397
 398     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 399 }
 400
 401 static VIOsPAPRDevice *reg_conflict(VIOsPAPRDevice *dev)
 402 {
 403     VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->qdev.parent_bus);
 404     BusChild *kid;
 405     VIOsPAPRDevice *other;
 406
 407     /*
 408      * Check for a device other than the given one which is already
 409      * using the requested address. We have to open code this because
 410      * the given dev might already be in the list.
 411      */
 412     QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
 413         other = VIO_SPAPR_DEVICE(kid->child);
 414
 415         if (other != dev && other->reg == dev->reg) {
 416             return other;
 417         }
 418     }
 419
 420     return 0;
 421 }
 422
 423 static void spapr_vio_busdev_reset(DeviceState *qdev)
 424 {
 425     VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev);
 426     VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
 427
 428     /* Shut down the request queue and TCEs if necessary */
 429     spapr_vio_quiesce_one(dev);
 430
 431     dev->signal_state = 0;
 432
 433     spapr_vio_set_bypass(dev, false);
 434     if (pc->reset) {
 435         pc->reset(dev);
 436     }
 437 }
 438
 439 static void spapr_vio_busdev_realize(DeviceState *qdev, Error **errp)
 440 {
 441     sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
 442     VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev;
 443     VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
 444     char *id;
 445     Error *local_err = NULL;
 446
 447     if (dev->reg != -1) {
 448         /*
 449          * Explicitly assigned address, just verify that no-one else
 450          * is using it.  other mechanism). We have to open code this
 451          * rather than using spapr_vio_find_by_reg() because sdev
 452          * itself is already in the list.
 453          */
 454         VIOsPAPRDevice *other = reg_conflict(dev);
 455
 456         if (other) {
 457             error_setg(errp, "%s and %s devices conflict at address %#x",
 458                        object_get_typename(OBJECT(qdev)),
 459                        object_get_typename(OBJECT(&other->qdev)),
 460                        dev->reg);
 461             return;
 462         }
 463     } else {
 464         /* Need to assign an address */
 465         VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->qdev.parent_bus);
 466
 467         do {
 468             dev->reg = bus->next_reg++;
 469         } while (reg_conflict(dev));
 470     }
 471
 472     /* Don't overwrite ids assigned on the command line */
 473     if (!dev->qdev.id) {
 474         id = spapr_vio_get_dev_name(DEVICE(dev));
 475         dev->qdev.id = id;
 476     }
 477
 478     dev->irq = spapr_irq_alloc(spapr, dev->irq, false, &local_err);
 479     if (local_err) {
 480         error_propagate(errp, local_err);
 481         return;
 482     }
 483
 484     if (pc->rtce_window_size) {
 485         uint32_t liobn = SPAPR_VIO_LIOBN(dev->reg);
 486
 487         memory_region_init(&dev->mrroot, OBJECT(dev), "iommu-spapr-root",
 488                            ram_size);
 489         memory_region_init_alias(&dev->mrbypass, OBJECT(dev),
 490                                  "iommu-spapr-bypass", get_system_memory(),
 491                                  0, ram_size);
 492         memory_region_add_subregion_overlap(&dev->mrroot, 0, &dev->mrbypass, 1);
 493         address_space_init(&dev->as, &dev->mrroot, qdev->id);
 494
 495         dev->tcet = spapr_tce_new_table(qdev, liobn);
 496         spapr_tce_table_enable(dev->tcet, SPAPR_TCE_PAGE_SHIFT, 0,
 497                                pc->rtce_window_size >> SPAPR_TCE_PAGE_SHIFT);
 498         dev->tcet->vdev = dev;
 499         memory_region_add_subregion_overlap(&dev->mrroot, 0,
 500                                             spapr_tce_get_iommu(dev->tcet), 2);
 501     }
 502
 503     pc->realize(dev, errp);
 504 }
 505
 506 static target_ulong h_vio_signal(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 507                                  target_ulong opcode,
 508                                  target_ulong *args)
 509 {
 510     target_ulong reg = args[0];
 511     target_ulong mode = args[1];
 512     VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
 513     VIOsPAPRDeviceClass *pc;
 514
 515     if (!dev) {
 516         return H_PARAMETER;
 517     }
 518
 519     pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
 520
 521     if (mode & ~pc->signal_mask) {
 522         return H_PARAMETER;
 523     }
 524
 525     dev->signal_state = mode;
 526
 527     return H_SUCCESS;
 528 }
 529
 530 VIOsPAPRBus *spapr_vio_bus_init(void)
 531 {
 532     VIOsPAPRBus *bus;
 533     BusState *qbus;
 534     DeviceState *dev;
 535
 536     /* Create bridge device */
 537     dev = qdev_create(NULL, TYPE_SPAPR_VIO_BRIDGE);
 538     qdev_init_nofail(dev);
 539
 540     /* Create bus on bridge device */
 541     qbus = qbus_create(TYPE_SPAPR_VIO_BUS, dev, "spapr-vio");
 542     bus = SPAPR_VIO_BUS(qbus);
 543     bus->next_reg = 0x71000000;
 544
 545     /* hcall-vio */
 546     spapr_register_hypercall(H_VIO_SIGNAL, h_vio_signal);
 547
 548     /* hcall-crq */
 549     spapr_register_hypercall(H_REG_CRQ, h_reg_crq);
 550     spapr_register_hypercall(H_FREE_CRQ, h_free_crq);
 551     spapr_register_hypercall(H_SEND_CRQ, h_send_crq);
 552     spapr_register_hypercall(H_ENABLE_CRQ, h_enable_crq);
 553
 554     /* RTAS calls */
 555     spapr_rtas_register(RTAS_IBM_SET_TCE_BYPASS, "ibm,set-tce-bypass",
 556                         rtas_set_tce_bypass);
 557     spapr_rtas_register(RTAS_QUIESCE, "quiesce", rtas_quiesce);
 558
 559     return bus;
 560 }
 561
 562 static void spapr_vio_bridge_class_init(ObjectClass *klass, void *data)
 563 {
 564     DeviceClass *dc = DEVICE_CLASS(klass);
 565
 566     dc->fw_name = "vdevice";
 567 }
 568
 569 static const TypeInfo spapr_vio_bridge_info = {
 570     .name          = TYPE_SPAPR_VIO_BRIDGE,
 571     .parent        = TYPE_SYS_BUS_DEVICE,
 572     .class_init    = spapr_vio_bridge_class_init,
 573 };
 574
 575 const VMStateDescription vmstate_spapr_vio = {
 576     .name = "spapr_vio",
 577     .version_id = 1,
 578     .minimum_version_id = 1,
 579     .fields = (VMStateField[]) {
 580         /* Sanity check */
 581         VMSTATE_UINT32_EQUAL(reg, VIOsPAPRDevice, NULL),
 582         VMSTATE_UINT32_EQUAL(irq, VIOsPAPRDevice, NULL),
 583
 584         /* General VIO device state */
 585         VMSTATE_UINT64(signal_state, VIOsPAPRDevice),
 586         VMSTATE_UINT64(crq.qladdr, VIOsPAPRDevice),
 587         VMSTATE_UINT32(crq.qsize, VIOsPAPRDevice),
 588         VMSTATE_UINT32(crq.qnext, VIOsPAPRDevice),
 589
 590         VMSTATE_END_OF_LIST()
 591     },
 592 };
 593
 594 static void vio_spapr_device_class_init(ObjectClass *klass, void *data)
 595 {
 596     DeviceClass *k = DEVICE_CLASS(klass);
 597     k->realize = spapr_vio_busdev_realize;
 598     k->reset = spapr_vio_busdev_reset;
 599     k->bus_type = TYPE_SPAPR_VIO_BUS;
 600     k->props = spapr_vio_props;
 601 }
 602
 603 static const TypeInfo spapr_vio_type_info = {
 604     .name = TYPE_VIO_SPAPR_DEVICE,
 605     .parent = TYPE_DEVICE,
 606     .instance_size = sizeof(VIOsPAPRDevice),
 607     .abstract = true,
 608     .class_size = sizeof(VIOsPAPRDeviceClass),
 609     .class_init = vio_spapr_device_class_init,
 610 };
 611
 612 static void spapr_vio_register_types(void)
 613 {
 614     type_register_static(&spapr_vio_bus_info);
 615     type_register_static(&spapr_vio_bridge_info);
 616     type_register_static(&spapr_vio_type_info);
 617 }
 618
 619 type_init(spapr_vio_register_types)
 620
 621 static int compare_reg(const void *p1, const void *p2)
 622 {
 623     VIOsPAPRDevice const *dev1, *dev2;
 624
 625     dev1 = (VIOsPAPRDevice *)*(DeviceState **)p1;
 626     dev2 = (VIOsPAPRDevice *)*(DeviceState **)p2;
 627
 628     if (dev1->reg < dev2->reg) {
 629         return -1;
 630     }
 631     if (dev1->reg == dev2->reg) {
 632         return 0;
 633     }
 634
 635     /* dev1->reg > dev2->reg */
 636     return 1;
 637 }
 638
 639 void spapr_dt_vdevice(VIOsPAPRBus *bus, void *fdt)
 640 {
 641     DeviceState *qdev, **qdevs;
 642     BusChild *kid;
 643     int i, num, ret = 0;
 644     int node;
 645
 646     _FDT(node = fdt_add_subnode(fdt, 0, "vdevice"));
 647
 648     _FDT(fdt_setprop_string(fdt, node, "device_type", "vdevice"));
 649     _FDT(fdt_setprop_string(fdt, node, "compatible", "IBM,vdevice"));
 650     _FDT(fdt_setprop_cell(fdt, node, "#address-cells", 1));
 651     _FDT(fdt_setprop_cell(fdt, node, "#size-cells", 0));
 652     _FDT(fdt_setprop_cell(fdt, node, "#interrupt-cells", 2));
 653     _FDT(fdt_setprop(fdt, node, "interrupt-controller", NULL, 0));
 654
 655     /* Count qdevs on the bus list */
 656     num = 0;
 657     QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
 658         num++;
 659     }
 660
 661     /* Copy out into an array of pointers */
 662     qdevs = g_malloc(sizeof(qdev) * num);
 663     num = 0;
 664     QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
 665         qdevs[num++] = kid->child;
 666     }
 667
 668     /* Sort the array */
 669     qsort(qdevs, num, sizeof(qdev), compare_reg);
 670
 671     /* Hack alert. Give the devices to libfdt in reverse order, we happen
 672      * to know that will mean they are in forward order in the tree. */
 673     for (i = num - 1; i >= 0; i--) {
 674         VIOsPAPRDevice *dev = (VIOsPAPRDevice *)(qdevs[i]);
 675         VIOsPAPRDeviceClass *vdc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
 676
 677         ret = vio_make_devnode(dev, fdt);
 678         if (ret < 0) {
 679             error_report("Couldn't create device node /vdevice/%s@%"PRIx32,
 680                          vdc->dt_name, dev->reg);
 681             exit(1);
 682         }
 683     }
 684
 685     g_free(qdevs);
 686 }
 687
 688 gchar *spapr_vio_stdout_path(VIOsPAPRBus *bus)
 689 {
 690     VIOsPAPRDevice *dev;
 691     char *name, *path;
 692
 693     dev = spapr_vty_get_default(bus);
 694     if (!dev) {
 695         return NULL;
 696     }
 697
 698     name = spapr_vio_get_dev_name(DEVICE(dev));
 699     path = g_strdup_printf("/vdevice/%s", name);
 700
 701     g_free(name);
 702     return path;
 703 }