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