hw/ppc/spapr_rtas.c

   1 /*
   2  * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
   3  *
   4  * Hypercall based emulated RTAS
   5  *
   6  * Copyright (c) 2010-2011 David Gibson, IBM Corporation.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  *
  26  */
  27 #include "qemu/osdep.h"
  28 #include "cpu.h"
  29 #include "qemu/log.h"
  30 #include "qemu/error-report.h"
  31 #include "sysemu/sysemu.h"
  32 #include "sysemu/char.h"
  33 #include "hw/qdev.h"
  34 #include "sysemu/device_tree.h"
  35 #include "sysemu/cpus.h"
  36 #include "sysemu/kvm.h"
  37
  38 #include "hw/ppc/spapr.h"
  39 #include "hw/ppc/spapr_vio.h"
  40 #include "hw/ppc/ppc.h"
  41 #include "qapi-event.h"
  42 #include "hw/boards.h"
  43
  44 #include <libfdt.h>
  45 #include "hw/ppc/spapr_drc.h"
  46 #include "qemu/cutils.h"
  47
  48 /* #define DEBUG_SPAPR */
  49
  50 #ifdef DEBUG_SPAPR
  51 #define DPRINTF(fmt, ...) \
  52     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  53 #else
  54 #define DPRINTF(fmt, ...) \
  55     do { } while (0)
  56 #endif
  57
  58 static sPAPRConfigureConnectorState *spapr_ccs_find(sPAPRMachineState *spapr,
  59                                                     uint32_t drc_index)
  60 {
  61     sPAPRConfigureConnectorState *ccs = NULL;
  62
  63     QTAILQ_FOREACH(ccs, &spapr->ccs_list, next) {
  64         if (ccs->drc_index == drc_index) {
  65             break;
  66         }
  67     }
  68
  69     return ccs;
  70 }
  71
  72 static void spapr_ccs_add(sPAPRMachineState *spapr,
  73                           sPAPRConfigureConnectorState *ccs)
  74 {
  75     g_assert(!spapr_ccs_find(spapr, ccs->drc_index));
  76     QTAILQ_INSERT_HEAD(&spapr->ccs_list, ccs, next);
  77 }
  78
  79 static void spapr_ccs_remove(sPAPRMachineState *spapr,
  80                              sPAPRConfigureConnectorState *ccs)
  81 {
  82     QTAILQ_REMOVE(&spapr->ccs_list, ccs, next);
  83     g_free(ccs);
  84 }
  85
  86 void spapr_ccs_reset_hook(void *opaque)
  87 {
  88     sPAPRMachineState *spapr = opaque;
  89     sPAPRConfigureConnectorState *ccs, *ccs_tmp;
  90
  91     QTAILQ_FOREACH_SAFE(ccs, &spapr->ccs_list, next, ccs_tmp) {
  92         spapr_ccs_remove(spapr, ccs);
  93     }
  94 }
  95
  96 static void rtas_display_character(PowerPCCPU *cpu, sPAPRMachineState *spapr,
  97                                    uint32_t token, uint32_t nargs,
  98                                    target_ulong args,
  99                                    uint32_t nret, target_ulong rets)
 100 {
 101     uint8_t c = rtas_ld(args, 0);
 102     VIOsPAPRDevice *sdev = vty_lookup(spapr, 0);
 103
 104     if (!sdev) {
 105         rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 106     } else {
 107         vty_putchars(sdev, &c, sizeof(c));
 108         rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 109     }
 110 }
 111
 112 static void rtas_power_off(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 113                            uint32_t token, uint32_t nargs, target_ulong args,
 114                            uint32_t nret, target_ulong rets)
 115 {
 116     if (nargs != 2 || nret != 1) {
 117         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 118         return;
 119     }
 120     qemu_system_shutdown_request();
 121     cpu_stop_current();
 122     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 123 }
 124
 125 static void rtas_system_reboot(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 126                                uint32_t token, uint32_t nargs,
 127                                target_ulong args,
 128                                uint32_t nret, target_ulong rets)
 129 {
 130     if (nargs != 0 || nret != 1) {
 131         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 132         return;
 133     }
 134     qemu_system_reset_request();
 135     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 136 }
 137
 138 static void rtas_query_cpu_stopped_state(PowerPCCPU *cpu_,
 139                                          sPAPRMachineState *spapr,
 140                                          uint32_t token, uint32_t nargs,
 141                                          target_ulong args,
 142                                          uint32_t nret, target_ulong rets)
 143 {
 144     target_ulong id;
 145     PowerPCCPU *cpu;
 146
 147     if (nargs != 1 || nret != 2) {
 148         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 149         return;
 150     }
 151
 152     id = rtas_ld(args, 0);
 153     cpu = ppc_get_vcpu_by_dt_id(id);
 154     if (cpu != NULL) {
 155         if (CPU(cpu)->halted) {
 156             rtas_st(rets, 1, 0);
 157         } else {
 158             rtas_st(rets, 1, 2);
 159         }
 160
 161         rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 162         return;
 163     }
 164
 165     /* Didn't find a matching cpu */
 166     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 167 }
 168
 169 /*
 170  * Set the timebase offset of the CPU to that of first CPU.
 171  * This helps hotplugged CPU to have the correct timebase offset.
 172  */
 173 static void spapr_cpu_update_tb_offset(PowerPCCPU *cpu)
 174 {
 175     PowerPCCPU *fcpu = POWERPC_CPU(first_cpu);
 176
 177     cpu->env.tb_env->tb_offset = fcpu->env.tb_env->tb_offset;
 178 }
 179
 180 static void spapr_cpu_set_endianness(PowerPCCPU *cpu)
 181 {
 182     PowerPCCPU *fcpu = POWERPC_CPU(first_cpu);
 183     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(fcpu);
 184
 185     if (!pcc->interrupts_big_endian(fcpu)) {
 186         cpu->env.spr[SPR_LPCR] |= LPCR_ILE;
 187     }
 188 }
 189
 190 static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr,
 191                            uint32_t token, uint32_t nargs,
 192                            target_ulong args,
 193                            uint32_t nret, target_ulong rets)
 194 {
 195     target_ulong id, start, r3;
 196     PowerPCCPU *cpu;
 197
 198     if (nargs != 3 || nret != 1) {
 199         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 200         return;
 201     }
 202
 203     id = rtas_ld(args, 0);
 204     start = rtas_ld(args, 1);
 205     r3 = rtas_ld(args, 2);
 206
 207     cpu = ppc_get_vcpu_by_dt_id(id);
 208     if (cpu != NULL) {
 209         CPUState *cs = CPU(cpu);
 210         CPUPPCState *env = &cpu->env;
 211
 212         if (!cs->halted) {
 213             rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
 214             return;
 215         }
 216
 217         /* This will make sure qemu state is up to date with kvm, and
 218          * mark it dirty so our changes get flushed back before the
 219          * new cpu enters */
 220         kvm_cpu_synchronize_state(cs);
 221
 222         env->msr = (1ULL << MSR_SF) | (1ULL << MSR_ME);
 223         env->nip = start;
 224         env->gpr[3] = r3;
 225         cs->halted = 0;
 226         spapr_cpu_set_endianness(cpu);
 227         spapr_cpu_update_tb_offset(cpu);
 228
 229         qemu_cpu_kick(cs);
 230
 231         rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 232         return;
 233     }
 234
 235     /* Didn't find a matching cpu */
 236     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 237 }
 238
 239 static void rtas_stop_self(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 240                            uint32_t token, uint32_t nargs,
 241                            target_ulong args,
 242                            uint32_t nret, target_ulong rets)
 243 {
 244     CPUState *cs = CPU(cpu);
 245     CPUPPCState *env = &cpu->env;
 246
 247     cs->halted = 1;
 248     qemu_cpu_kick(cs);
 249     /*
 250      * While stopping a CPU, the guest calls H_CPPR which
 251      * effectively disables interrupts on XICS level.
 252      * However decrementer interrupts in TCG can still
 253      * wake the CPU up so here we disable interrupts in MSR
 254      * as well.
 255      * As rtas_start_cpu() resets the whole MSR anyway, there is
 256      * no need to bother with specific bits, we just clear it.
 257      */
 258     env->msr = 0;
 259 }
 260
 261 static inline int sysparm_st(target_ulong addr, target_ulong len,
 262                              const void *val, uint16_t vallen)
 263 {
 264     hwaddr phys = ppc64_phys_to_real(addr);
 265
 266     if (len < 2) {
 267         return RTAS_OUT_SYSPARM_PARAM_ERROR;
 268     }
 269     stw_be_phys(&address_space_memory, phys, vallen);
 270     cpu_physical_memory_write(phys + 2, val, MIN(len - 2, vallen));
 271     return RTAS_OUT_SUCCESS;
 272 }
 273
 274 static void rtas_ibm_get_system_parameter(PowerPCCPU *cpu,
 275                                           sPAPRMachineState *spapr,
 276                                           uint32_t token, uint32_t nargs,
 277                                           target_ulong args,
 278                                           uint32_t nret, target_ulong rets)
 279 {
 280     target_ulong parameter = rtas_ld(args, 0);
 281     target_ulong buffer = rtas_ld(args, 1);
 282     target_ulong length = rtas_ld(args, 2);
 283     target_ulong ret;
 284
 285     switch (parameter) {
 286     case RTAS_SYSPARM_SPLPAR_CHARACTERISTICS: {
 287         char *param_val = g_strdup_printf("MaxEntCap=%d,"
 288                                           "DesMem=%llu,"
 289                                           "DesProcs=%d,"
 290                                           "MaxPlatProcs=%d",
 291                                           max_cpus,
 292                                           current_machine->ram_size / M_BYTE,
 293                                           smp_cpus,
 294                                           max_cpus);
 295         ret = sysparm_st(buffer, length, param_val, strlen(param_val) + 1);
 296         g_free(param_val);
 297         break;
 298     }
 299     case RTAS_SYSPARM_DIAGNOSTICS_RUN_MODE: {
 300         uint8_t param_val = DIAGNOSTICS_RUN_MODE_DISABLED;
 301
 302         ret = sysparm_st(buffer, length, &param_val, sizeof(param_val));
 303         break;
 304     }
 305     case RTAS_SYSPARM_UUID:
 306         ret = sysparm_st(buffer, length, qemu_uuid, (qemu_uuid_set ? 16 : 0));
 307         break;
 308     default:
 309         ret = RTAS_OUT_NOT_SUPPORTED;
 310     }
 311
 312     rtas_st(rets, 0, ret);
 313 }
 314
 315 static void rtas_ibm_set_system_parameter(PowerPCCPU *cpu,
 316                                           sPAPRMachineState *spapr,
 317                                           uint32_t token, uint32_t nargs,
 318                                           target_ulong args,
 319                                           uint32_t nret, target_ulong rets)
 320 {
 321     target_ulong parameter = rtas_ld(args, 0);
 322     target_ulong ret = RTAS_OUT_NOT_SUPPORTED;
 323
 324     switch (parameter) {
 325     case RTAS_SYSPARM_SPLPAR_CHARACTERISTICS:
 326     case RTAS_SYSPARM_DIAGNOSTICS_RUN_MODE:
 327     case RTAS_SYSPARM_UUID:
 328         ret = RTAS_OUT_NOT_AUTHORIZED;
 329         break;
 330     }
 331
 332     rtas_st(rets, 0, ret);
 333 }
 334
 335 static void rtas_ibm_os_term(PowerPCCPU *cpu,
 336                             sPAPRMachineState *spapr,
 337                             uint32_t token, uint32_t nargs,
 338                             target_ulong args,
 339                             uint32_t nret, target_ulong rets)
 340 {
 341     target_ulong ret = 0;
 342
 343     qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, &error_abort);
 344
 345     rtas_st(rets, 0, ret);
 346 }
 347
 348 static void rtas_set_power_level(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 349                                  uint32_t token, uint32_t nargs,
 350                                  target_ulong args, uint32_t nret,
 351                                  target_ulong rets)
 352 {
 353     int32_t power_domain;
 354
 355     if (nargs != 2 || nret != 2) {
 356         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 357         return;
 358     }
 359
 360     /* we currently only use a single, "live insert" powerdomain for
 361      * hotplugged/dlpar'd resources, so the power is always live/full (100)
 362      */
 363     power_domain = rtas_ld(args, 0);
 364     if (power_domain != -1) {
 365         rtas_st(rets, 0, RTAS_OUT_NOT_SUPPORTED);
 366         return;
 367     }
 368
 369     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 370     rtas_st(rets, 1, 100);
 371 }
 372
 373 static void rtas_get_power_level(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 374                                   uint32_t token, uint32_t nargs,
 375                                   target_ulong args, uint32_t nret,
 376                                   target_ulong rets)
 377 {
 378     int32_t power_domain;
 379
 380     if (nargs != 1 || nret != 2) {
 381         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 382         return;
 383     }
 384
 385     /* we currently only use a single, "live insert" powerdomain for
 386      * hotplugged/dlpar'd resources, so the power is always live/full (100)
 387      */
 388     power_domain = rtas_ld(args, 0);
 389     if (power_domain != -1) {
 390         rtas_st(rets, 0, RTAS_OUT_NOT_SUPPORTED);
 391         return;
 392     }
 393
 394     rtas_st(rets, 0, RTAS_OUT_SUCCESS);
 395     rtas_st(rets, 1, 100);
 396 }
 397
 398 static bool sensor_type_is_dr(uint32_t sensor_type)
 399 {
 400     switch (sensor_type) {
 401     case RTAS_SENSOR_TYPE_ISOLATION_STATE:
 402     case RTAS_SENSOR_TYPE_DR:
 403     case RTAS_SENSOR_TYPE_ALLOCATION_STATE:
 404         return true;
 405     }
 406
 407     return false;
 408 }
 409
 410 static void rtas_set_indicator(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 411                                uint32_t token, uint32_t nargs,
 412                                target_ulong args, uint32_t nret,
 413                                target_ulong rets)
 414 {
 415     uint32_t sensor_type;
 416     uint32_t sensor_index;
 417     uint32_t sensor_state;
 418     uint32_t ret = RTAS_OUT_SUCCESS;
 419     sPAPRDRConnector *drc;
 420     sPAPRDRConnectorClass *drck;
 421
 422     if (nargs != 3 || nret != 1) {
 423         ret = RTAS_OUT_PARAM_ERROR;
 424         goto out;
 425     }
 426
 427     sensor_type = rtas_ld(args, 0);
 428     sensor_index = rtas_ld(args, 1);
 429     sensor_state = rtas_ld(args, 2);
 430
 431     if (!sensor_type_is_dr(sensor_type)) {
 432         goto out_unimplemented;
 433     }
 434
 435     /* if this is a DR sensor we can assume sensor_index == drc_index */
 436     drc = spapr_dr_connector_by_index(sensor_index);
 437     if (!drc) {
 438         DPRINTF("rtas_set_indicator: invalid sensor/DRC index: %xh\n",
 439                 sensor_index);
 440         ret = RTAS_OUT_PARAM_ERROR;
 441         goto out;
 442     }
 443     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 444
 445     switch (sensor_type) {
 446     case RTAS_SENSOR_TYPE_ISOLATION_STATE:
 447         /* if the guest is configuring a device attached to this
 448          * DRC, we should reset the configuration state at this
 449          * point since it may no longer be reliable (guest released
 450          * device and needs to start over, or unplug occurred so
 451          * the FDT is no longer valid)
 452          */
 453         if (sensor_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) {
 454             sPAPRConfigureConnectorState *ccs = spapr_ccs_find(spapr,
 455                                                                sensor_index);
 456             if (ccs) {
 457                 spapr_ccs_remove(spapr, ccs);
 458             }
 459         }
 460         ret = drck->set_isolation_state(drc, sensor_state);
 461         break;
 462     case RTAS_SENSOR_TYPE_DR:
 463         ret = drck->set_indicator_state(drc, sensor_state);
 464         break;
 465     case RTAS_SENSOR_TYPE_ALLOCATION_STATE:
 466         ret = drck->set_allocation_state(drc, sensor_state);
 467         break;
 468     default:
 469         goto out_unimplemented;
 470     }
 471
 472 out:
 473     rtas_st(rets, 0, ret);
 474     return;
 475
 476 out_unimplemented:
 477     /* currently only DR-related sensors are implemented */
 478     DPRINTF("rtas_set_indicator: sensor/indicator not implemented: %d\n",
 479             sensor_type);
 480     rtas_st(rets, 0, RTAS_OUT_NOT_SUPPORTED);
 481 }
 482
 483 static void rtas_get_sensor_state(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 484                                   uint32_t token, uint32_t nargs,
 485                                   target_ulong args, uint32_t nret,
 486                                   target_ulong rets)
 487 {
 488     uint32_t sensor_type;
 489     uint32_t sensor_index;
 490     uint32_t sensor_state = 0;
 491     sPAPRDRConnector *drc;
 492     sPAPRDRConnectorClass *drck;
 493     uint32_t ret = RTAS_OUT_SUCCESS;
 494
 495     if (nargs != 2 || nret != 2) {
 496         ret = RTAS_OUT_PARAM_ERROR;
 497         goto out;
 498     }
 499
 500     sensor_type = rtas_ld(args, 0);
 501     sensor_index = rtas_ld(args, 1);
 502
 503     if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) {
 504         /* currently only DR-related sensors are implemented */
 505         DPRINTF("rtas_get_sensor_state: sensor/indicator not implemented: %d\n",
 506                 sensor_type);
 507         ret = RTAS_OUT_NOT_SUPPORTED;
 508         goto out;
 509     }
 510
 511     drc = spapr_dr_connector_by_index(sensor_index);
 512     if (!drc) {
 513         DPRINTF("rtas_get_sensor_state: invalid sensor/DRC index: %xh\n",
 514                 sensor_index);
 515         ret = RTAS_OUT_PARAM_ERROR;
 516         goto out;
 517     }
 518     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 519     ret = drck->entity_sense(drc, &sensor_state);
 520
 521 out:
 522     rtas_st(rets, 0, ret);
 523     rtas_st(rets, 1, sensor_state);
 524 }
 525
 526 /* configure-connector work area offsets, int32_t units for field
 527  * indexes, bytes for field offset/len values.
 528  *
 529  * as documented by PAPR+ v2.7, 13.5.3.5
 530  */
 531 #define CC_IDX_NODE_NAME_OFFSET 2
 532 #define CC_IDX_PROP_NAME_OFFSET 2
 533 #define CC_IDX_PROP_LEN 3
 534 #define CC_IDX_PROP_DATA_OFFSET 4
 535 #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4)
 536 #define CC_WA_LEN 4096
 537
 538 static void configure_connector_st(target_ulong addr, target_ulong offset,
 539                                    const void *buf, size_t len)
 540 {
 541     cpu_physical_memory_write(ppc64_phys_to_real(addr + offset),
 542                               buf, MIN(len, CC_WA_LEN - offset));
 543 }
 544
 545 static void rtas_ibm_configure_connector(PowerPCCPU *cpu,
 546                                          sPAPRMachineState *spapr,
 547                                          uint32_t token, uint32_t nargs,
 548                                          target_ulong args, uint32_t nret,
 549                                          target_ulong rets)
 550 {
 551     uint64_t wa_addr;
 552     uint64_t wa_offset;
 553     uint32_t drc_index;
 554     sPAPRDRConnector *drc;
 555     sPAPRDRConnectorClass *drck;
 556     sPAPRConfigureConnectorState *ccs;
 557     sPAPRDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE;
 558     int rc;
 559     const void *fdt;
 560
 561     if (nargs != 2 || nret != 1) {
 562         rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 563         return;
 564     }
 565
 566     wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0);
 567
 568     drc_index = rtas_ld(wa_addr, 0);
 569     drc = spapr_dr_connector_by_index(drc_index);
 570     if (!drc) {
 571         DPRINTF("rtas_ibm_configure_connector: invalid DRC index: %xh\n",
 572                 drc_index);
 573         rc = RTAS_OUT_PARAM_ERROR;
 574         goto out;
 575     }
 576
 577     drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 578     fdt = drck->get_fdt(drc, NULL);
 579     if (!fdt) {
 580         DPRINTF("rtas_ibm_configure_connector: Missing FDT for DRC index: %xh\n",
 581                 drc_index);
 582         rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE;
 583         goto out;
 584     }
 585
 586     ccs = spapr_ccs_find(spapr, drc_index);
 587     if (!ccs) {
 588         ccs = g_new0(sPAPRConfigureConnectorState, 1);
 589         (void)drck->get_fdt(drc, &ccs->fdt_offset);
 590         ccs->drc_index = drc_index;
 591         spapr_ccs_add(spapr, ccs);
 592     }
 593
 594     do {
 595         uint32_t tag;
 596         const char *name;
 597         const struct fdt_property *prop;
 598         int fdt_offset_next, prop_len;
 599
 600         tag = fdt_next_tag(fdt, ccs->fdt_offset, &fdt_offset_next);
 601
 602         switch (tag) {
 603         case FDT_BEGIN_NODE:
 604             ccs->fdt_depth++;
 605             name = fdt_get_name(fdt, ccs->fdt_offset, NULL);
 606
 607             /* provide the name of the next OF node */
 608             wa_offset = CC_VAL_DATA_OFFSET;
 609             rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset);
 610             configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
 611             resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD;
 612             break;
 613         case FDT_END_NODE:
 614             ccs->fdt_depth--;
 615             if (ccs->fdt_depth == 0) {
 616                 /* done sending the device tree, don't need to track
 617                  * the state anymore
 618                  */
 619                 drck->set_configured(drc);
 620                 spapr_ccs_remove(spapr, ccs);
 621                 ccs = NULL;
 622                 resp = SPAPR_DR_CC_RESPONSE_SUCCESS;
 623             } else {
 624                 resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT;
 625             }
 626             break;
 627         case FDT_PROP:
 628             prop = fdt_get_property_by_offset(fdt, ccs->fdt_offset,
 629                                               &prop_len);
 630             name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
 631
 632             /* provide the name of the next OF property */
 633             wa_offset = CC_VAL_DATA_OFFSET;
 634             rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset);
 635             configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
 636
 637             /* provide the length and value of the OF property. data gets
 638              * placed immediately after NULL terminator of the OF property's
 639              * name string
 640              */
 641             wa_offset += strlen(name) + 1,
 642             rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len);
 643             rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset);
 644             configure_connector_st(wa_addr, wa_offset, prop->data, prop_len);
 645             resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY;
 646             break;
 647         case FDT_END:
 648             resp = SPAPR_DR_CC_RESPONSE_ERROR;
 649         default:
 650             /* keep seeking for an actionable tag */
 651             break;
 652         }
 653         if (ccs) {
 654             ccs->fdt_offset = fdt_offset_next;
 655         }
 656     } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE);
 657
 658     rc = resp;
 659 out:
 660     rtas_st(rets, 0, rc);
 661 }
 662
 663 static struct rtas_call {
 664     const char *name;
 665     spapr_rtas_fn fn;
 666 } rtas_table[RTAS_TOKEN_MAX - RTAS_TOKEN_BASE];
 667
 668 target_ulong spapr_rtas_call(PowerPCCPU *cpu, sPAPRMachineState *spapr,
 669                              uint32_t token, uint32_t nargs, target_ulong args,
 670                              uint32_t nret, target_ulong rets)
 671 {
 672     if ((token >= RTAS_TOKEN_BASE) && (token < RTAS_TOKEN_MAX)) {
 673         struct rtas_call *call = rtas_table + (token - RTAS_TOKEN_BASE);
 674
 675         if (call->fn) {
 676             call->fn(cpu, spapr, token, nargs, args, nret, rets);
 677             return H_SUCCESS;
 678         }
 679     }
 680
 681     /* HACK: Some Linux early debug code uses RTAS display-character,
 682      * but assumes the token value is 0xa (which it is on some real
 683      * machines) without looking it up in the device tree.  This
 684      * special case makes this work */
 685     if (token == 0xa) {
 686         rtas_display_character(cpu, spapr, 0xa, nargs, args, nret, rets);
 687         return H_SUCCESS;
 688     }
 689
 690     hcall_dprintf("Unknown RTAS token 0x%x\n", token);
 691     rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
 692     return H_PARAMETER;
 693 }
 694
 695 void spapr_rtas_register(int token, const char *name, spapr_rtas_fn fn)
 696 {
 697     assert((token >= RTAS_TOKEN_BASE) && (token < RTAS_TOKEN_MAX));
 698
 699     token -= RTAS_TOKEN_BASE;
 700
 701     assert(!rtas_table[token].name);
 702
 703     rtas_table[token].name = name;
 704     rtas_table[token].fn = fn;
 705 }
 706
 707 int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
 708                                  hwaddr rtas_size)
 709 {
 710     int ret;
 711     int i;
 712     uint32_t lrdr_capacity[5];
 713     MachineState *machine = MACHINE(qdev_get_machine());
 714     sPAPRMachineState *spapr = SPAPR_MACHINE(machine);
 715     uint64_t max_hotplug_addr = spapr->hotplug_memory.base +
 716                                 memory_region_size(&spapr->hotplug_memory.mr);
 717
 718     ret = fdt_add_mem_rsv(fdt, rtas_addr, rtas_size);
 719     if (ret < 0) {
 720         error_report("Couldn't add RTAS reserve entry: %s",
 721                 fdt_strerror(ret));
 722         return ret;
 723     }
 724
 725     ret = qemu_fdt_setprop_cell(fdt, "/rtas", "linux,rtas-base",
 726                                 rtas_addr);
 727     if (ret < 0) {
 728         error_report("Couldn't add linux,rtas-base property: %s",
 729                 fdt_strerror(ret));
 730         return ret;
 731     }
 732
 733     ret = qemu_fdt_setprop_cell(fdt, "/rtas", "linux,rtas-entry",
 734                                 rtas_addr);
 735     if (ret < 0) {
 736         error_report("Couldn't add linux,rtas-entry property: %s",
 737                 fdt_strerror(ret));
 738         return ret;
 739     }
 740
 741     ret = qemu_fdt_setprop_cell(fdt, "/rtas", "rtas-size",
 742                                 rtas_size);
 743     if (ret < 0) {
 744         error_report("Couldn't add rtas-size property: %s",
 745                 fdt_strerror(ret));
 746         return ret;
 747     }
 748
 749     for (i = 0; i < RTAS_TOKEN_MAX - RTAS_TOKEN_BASE; i++) {
 750         struct rtas_call *call = &rtas_table[i];
 751
 752         if (!call->name) {
 753             continue;
 754         }
 755
 756         ret = qemu_fdt_setprop_cell(fdt, "/rtas", call->name,
 757                                     i + RTAS_TOKEN_BASE);
 758         if (ret < 0) {
 759             error_report("Couldn't add rtas token for %s: %s",
 760                     call->name, fdt_strerror(ret));
 761             return ret;
 762         }
 763
 764     }
 765
 766     lrdr_capacity[0] = cpu_to_be32(max_hotplug_addr >> 32);
 767     lrdr_capacity[1] = cpu_to_be32(max_hotplug_addr & 0xffffffff);
 768     lrdr_capacity[2] = 0;
 769     lrdr_capacity[3] = cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE);
 770     lrdr_capacity[4] = cpu_to_be32(max_cpus/smp_threads);
 771     ret = qemu_fdt_setprop(fdt, "/rtas", "ibm,lrdr-capacity", lrdr_capacity,
 772                      sizeof(lrdr_capacity));
 773     if (ret < 0) {
 774         error_report("Couldn't add ibm,lrdr-capacity rtas property");
 775         return ret;
 776     }
 777
 778     return 0;
 779 }
 780
 781 static void core_rtas_register_types(void)
 782 {
 783     spapr_rtas_register(RTAS_DISPLAY_CHARACTER, "display-character",
 784                         rtas_display_character);
 785     spapr_rtas_register(RTAS_POWER_OFF, "power-off", rtas_power_off);
 786     spapr_rtas_register(RTAS_SYSTEM_REBOOT, "system-reboot",
 787                         rtas_system_reboot);
 788     spapr_rtas_register(RTAS_QUERY_CPU_STOPPED_STATE, "query-cpu-stopped-state",
 789                         rtas_query_cpu_stopped_state);
 790     spapr_rtas_register(RTAS_START_CPU, "start-cpu", rtas_start_cpu);
 791     spapr_rtas_register(RTAS_STOP_SELF, "stop-self", rtas_stop_self);
 792     spapr_rtas_register(RTAS_IBM_GET_SYSTEM_PARAMETER,
 793                         "ibm,get-system-parameter",
 794                         rtas_ibm_get_system_parameter);
 795     spapr_rtas_register(RTAS_IBM_SET_SYSTEM_PARAMETER,
 796                         "ibm,set-system-parameter",
 797                         rtas_ibm_set_system_parameter);
 798     spapr_rtas_register(RTAS_IBM_OS_TERM, "ibm,os-term",
 799                         rtas_ibm_os_term);
 800     spapr_rtas_register(RTAS_SET_POWER_LEVEL, "set-power-level",
 801                         rtas_set_power_level);
 802     spapr_rtas_register(RTAS_GET_POWER_LEVEL, "get-power-level",
 803                         rtas_get_power_level);
 804     spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator",
 805                         rtas_set_indicator);
 806     spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state",
 807                         rtas_get_sensor_state);
 808     spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector",
 809                         rtas_ibm_configure_connector);
 810 }
 811
 812 type_init(core_rtas_register_types)