2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
4 * Hypercall based emulated RTAS
6 * Copyright (c) 2010-2011 David Gibson, IBM Corporation.
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:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
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
27 #include "qemu/osdep.h"
30 #include "qemu/error-report.h"
31 #include "sysemu/sysemu.h"
32 #include "sysemu/char.h"
34 #include "sysemu/device_tree.h"
35 #include "sysemu/cpus.h"
36 #include "sysemu/kvm.h"
38 #include "hw/ppc/spapr.h"
39 #include "hw/ppc/spapr_vio.h"
40 #include "hw/ppc/spapr_rtas.h"
41 #include "hw/ppc/ppc.h"
42 #include "qapi-event.h"
43 #include "hw/boards.h"
46 #include "hw/ppc/spapr_drc.h"
47 #include "qemu/cutils.h"
50 static sPAPRConfigureConnectorState
*spapr_ccs_find(sPAPRMachineState
*spapr
,
53 sPAPRConfigureConnectorState
*ccs
= NULL
;
55 QTAILQ_FOREACH(ccs
, &spapr
->ccs_list
, next
) {
56 if (ccs
->drc_index
== drc_index
) {
64 static void spapr_ccs_add(sPAPRMachineState
*spapr
,
65 sPAPRConfigureConnectorState
*ccs
)
67 g_assert(!spapr_ccs_find(spapr
, ccs
->drc_index
));
68 QTAILQ_INSERT_HEAD(&spapr
->ccs_list
, ccs
, next
);
71 static void spapr_ccs_remove(sPAPRMachineState
*spapr
,
72 sPAPRConfigureConnectorState
*ccs
)
74 QTAILQ_REMOVE(&spapr
->ccs_list
, ccs
, next
);
78 void spapr_ccs_reset_hook(void *opaque
)
80 sPAPRMachineState
*spapr
= opaque
;
81 sPAPRConfigureConnectorState
*ccs
, *ccs_tmp
;
83 QTAILQ_FOREACH_SAFE(ccs
, &spapr
->ccs_list
, next
, ccs_tmp
) {
84 spapr_ccs_remove(spapr
, ccs
);
88 static void rtas_display_character(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
89 uint32_t token
, uint32_t nargs
,
91 uint32_t nret
, target_ulong rets
)
93 uint8_t c
= rtas_ld(args
, 0);
94 VIOsPAPRDevice
*sdev
= vty_lookup(spapr
, 0);
97 rtas_st(rets
, 0, RTAS_OUT_HW_ERROR
);
99 vty_putchars(sdev
, &c
, sizeof(c
));
100 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
104 static void rtas_power_off(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
105 uint32_t token
, uint32_t nargs
, target_ulong args
,
106 uint32_t nret
, target_ulong rets
)
108 if (nargs
!= 2 || nret
!= 1) {
109 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
112 qemu_system_shutdown_request();
114 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
117 static void rtas_system_reboot(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
118 uint32_t token
, uint32_t nargs
,
120 uint32_t nret
, target_ulong rets
)
122 if (nargs
!= 0 || nret
!= 1) {
123 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
126 qemu_system_reset_request();
127 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
130 static void rtas_query_cpu_stopped_state(PowerPCCPU
*cpu_
,
131 sPAPRMachineState
*spapr
,
132 uint32_t token
, uint32_t nargs
,
134 uint32_t nret
, target_ulong rets
)
139 if (nargs
!= 1 || nret
!= 2) {
140 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
144 id
= rtas_ld(args
, 0);
145 cpu
= ppc_get_vcpu_by_dt_id(id
);
147 if (CPU(cpu
)->halted
) {
153 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
157 /* Didn't find a matching cpu */
158 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
162 * Set the timebase offset of the CPU to that of first CPU.
163 * This helps hotplugged CPU to have the correct timebase offset.
165 static void spapr_cpu_update_tb_offset(PowerPCCPU
*cpu
)
167 PowerPCCPU
*fcpu
= POWERPC_CPU(first_cpu
);
169 cpu
->env
.tb_env
->tb_offset
= fcpu
->env
.tb_env
->tb_offset
;
172 static void spapr_cpu_set_endianness(PowerPCCPU
*cpu
)
174 PowerPCCPU
*fcpu
= POWERPC_CPU(first_cpu
);
175 PowerPCCPUClass
*pcc
= POWERPC_CPU_GET_CLASS(fcpu
);
177 if (!pcc
->interrupts_big_endian(fcpu
)) {
178 cpu
->env
.spr
[SPR_LPCR
] |= LPCR_ILE
;
182 static void rtas_start_cpu(PowerPCCPU
*cpu_
, sPAPRMachineState
*spapr
,
183 uint32_t token
, uint32_t nargs
,
185 uint32_t nret
, target_ulong rets
)
187 target_ulong id
, start
, r3
;
190 if (nargs
!= 3 || nret
!= 1) {
191 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
195 id
= rtas_ld(args
, 0);
196 start
= rtas_ld(args
, 1);
197 r3
= rtas_ld(args
, 2);
199 cpu
= ppc_get_vcpu_by_dt_id(id
);
201 CPUState
*cs
= CPU(cpu
);
202 CPUPPCState
*env
= &cpu
->env
;
205 rtas_st(rets
, 0, RTAS_OUT_HW_ERROR
);
209 /* This will make sure qemu state is up to date with kvm, and
210 * mark it dirty so our changes get flushed back before the
212 kvm_cpu_synchronize_state(cs
);
214 env
->msr
= (1ULL << MSR_SF
) | (1ULL << MSR_ME
);
218 spapr_cpu_set_endianness(cpu
);
219 spapr_cpu_update_tb_offset(cpu
);
223 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
227 /* Didn't find a matching cpu */
228 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
231 static void rtas_stop_self(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
232 uint32_t token
, uint32_t nargs
,
234 uint32_t nret
, target_ulong rets
)
236 CPUState
*cs
= CPU(cpu
);
237 CPUPPCState
*env
= &cpu
->env
;
242 * While stopping a CPU, the guest calls H_CPPR which
243 * effectively disables interrupts on XICS level.
244 * However decrementer interrupts in TCG can still
245 * wake the CPU up so here we disable interrupts in MSR
247 * As rtas_start_cpu() resets the whole MSR anyway, there is
248 * no need to bother with specific bits, we just clear it.
253 static inline int sysparm_st(target_ulong addr
, target_ulong len
,
254 const void *val
, uint16_t vallen
)
256 hwaddr phys
= ppc64_phys_to_real(addr
);
259 return RTAS_OUT_SYSPARM_PARAM_ERROR
;
261 stw_be_phys(&address_space_memory
, phys
, vallen
);
262 cpu_physical_memory_write(phys
+ 2, val
, MIN(len
- 2, vallen
));
263 return RTAS_OUT_SUCCESS
;
266 static void rtas_ibm_get_system_parameter(PowerPCCPU
*cpu
,
267 sPAPRMachineState
*spapr
,
268 uint32_t token
, uint32_t nargs
,
270 uint32_t nret
, target_ulong rets
)
272 target_ulong parameter
= rtas_ld(args
, 0);
273 target_ulong buffer
= rtas_ld(args
, 1);
274 target_ulong length
= rtas_ld(args
, 2);
278 case RTAS_SYSPARM_SPLPAR_CHARACTERISTICS
: {
279 char *param_val
= g_strdup_printf("MaxEntCap=%d,"
284 current_machine
->ram_size
/ M_BYTE
,
287 ret
= sysparm_st(buffer
, length
, param_val
, strlen(param_val
) + 1);
291 case RTAS_SYSPARM_DIAGNOSTICS_RUN_MODE
: {
292 uint8_t param_val
= DIAGNOSTICS_RUN_MODE_DISABLED
;
294 ret
= sysparm_st(buffer
, length
, ¶m_val
, sizeof(param_val
));
297 case RTAS_SYSPARM_UUID
:
298 ret
= sysparm_st(buffer
, length
, (unsigned char *)&qemu_uuid
,
299 (qemu_uuid_set
? 16 : 0));
302 ret
= RTAS_OUT_NOT_SUPPORTED
;
305 rtas_st(rets
, 0, ret
);
308 static void rtas_ibm_set_system_parameter(PowerPCCPU
*cpu
,
309 sPAPRMachineState
*spapr
,
310 uint32_t token
, uint32_t nargs
,
312 uint32_t nret
, target_ulong rets
)
314 target_ulong parameter
= rtas_ld(args
, 0);
315 target_ulong ret
= RTAS_OUT_NOT_SUPPORTED
;
318 case RTAS_SYSPARM_SPLPAR_CHARACTERISTICS
:
319 case RTAS_SYSPARM_DIAGNOSTICS_RUN_MODE
:
320 case RTAS_SYSPARM_UUID
:
321 ret
= RTAS_OUT_NOT_AUTHORIZED
;
325 rtas_st(rets
, 0, ret
);
328 static void rtas_ibm_os_term(PowerPCCPU
*cpu
,
329 sPAPRMachineState
*spapr
,
330 uint32_t token
, uint32_t nargs
,
332 uint32_t nret
, target_ulong rets
)
334 target_ulong ret
= 0;
336 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE
, &error_abort
);
338 rtas_st(rets
, 0, ret
);
341 static void rtas_set_power_level(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
342 uint32_t token
, uint32_t nargs
,
343 target_ulong args
, uint32_t nret
,
346 int32_t power_domain
;
348 if (nargs
!= 2 || nret
!= 2) {
349 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
353 /* we currently only use a single, "live insert" powerdomain for
354 * hotplugged/dlpar'd resources, so the power is always live/full (100)
356 power_domain
= rtas_ld(args
, 0);
357 if (power_domain
!= -1) {
358 rtas_st(rets
, 0, RTAS_OUT_NOT_SUPPORTED
);
362 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
363 rtas_st(rets
, 1, 100);
366 static void rtas_get_power_level(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
367 uint32_t token
, uint32_t nargs
,
368 target_ulong args
, uint32_t nret
,
371 int32_t power_domain
;
373 if (nargs
!= 1 || nret
!= 2) {
374 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
378 /* we currently only use a single, "live insert" powerdomain for
379 * hotplugged/dlpar'd resources, so the power is always live/full (100)
381 power_domain
= rtas_ld(args
, 0);
382 if (power_domain
!= -1) {
383 rtas_st(rets
, 0, RTAS_OUT_NOT_SUPPORTED
);
387 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
388 rtas_st(rets
, 1, 100);
391 static bool sensor_type_is_dr(uint32_t sensor_type
)
393 switch (sensor_type
) {
394 case RTAS_SENSOR_TYPE_ISOLATION_STATE
:
395 case RTAS_SENSOR_TYPE_DR
:
396 case RTAS_SENSOR_TYPE_ALLOCATION_STATE
:
403 static void rtas_set_indicator(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
404 uint32_t token
, uint32_t nargs
,
405 target_ulong args
, uint32_t nret
,
408 uint32_t sensor_type
;
409 uint32_t sensor_index
;
410 uint32_t sensor_state
;
411 uint32_t ret
= RTAS_OUT_SUCCESS
;
412 sPAPRDRConnector
*drc
;
413 sPAPRDRConnectorClass
*drck
;
415 if (nargs
!= 3 || nret
!= 1) {
416 ret
= RTAS_OUT_PARAM_ERROR
;
420 sensor_type
= rtas_ld(args
, 0);
421 sensor_index
= rtas_ld(args
, 1);
422 sensor_state
= rtas_ld(args
, 2);
424 if (!sensor_type_is_dr(sensor_type
)) {
425 goto out_unimplemented
;
428 /* if this is a DR sensor we can assume sensor_index == drc_index */
429 drc
= spapr_dr_connector_by_index(sensor_index
);
431 trace_spapr_rtas_set_indicator_invalid(sensor_index
);
432 ret
= RTAS_OUT_PARAM_ERROR
;
435 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
437 switch (sensor_type
) {
438 case RTAS_SENSOR_TYPE_ISOLATION_STATE
:
439 /* if the guest is configuring a device attached to this
440 * DRC, we should reset the configuration state at this
441 * point since it may no longer be reliable (guest released
442 * device and needs to start over, or unplug occurred so
443 * the FDT is no longer valid)
445 if (sensor_state
== SPAPR_DR_ISOLATION_STATE_ISOLATED
) {
446 sPAPRConfigureConnectorState
*ccs
= spapr_ccs_find(spapr
,
449 spapr_ccs_remove(spapr
, ccs
);
452 ret
= drck
->set_isolation_state(drc
, sensor_state
);
454 case RTAS_SENSOR_TYPE_DR
:
455 ret
= drck
->set_indicator_state(drc
, sensor_state
);
457 case RTAS_SENSOR_TYPE_ALLOCATION_STATE
:
458 ret
= drck
->set_allocation_state(drc
, sensor_state
);
461 goto out_unimplemented
;
465 rtas_st(rets
, 0, ret
);
469 /* currently only DR-related sensors are implemented */
470 trace_spapr_rtas_set_indicator_not_supported(sensor_index
, sensor_type
);
471 rtas_st(rets
, 0, RTAS_OUT_NOT_SUPPORTED
);
474 static void rtas_get_sensor_state(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
475 uint32_t token
, uint32_t nargs
,
476 target_ulong args
, uint32_t nret
,
479 uint32_t sensor_type
;
480 uint32_t sensor_index
;
481 uint32_t sensor_state
= 0;
482 sPAPRDRConnector
*drc
;
483 sPAPRDRConnectorClass
*drck
;
484 uint32_t ret
= RTAS_OUT_SUCCESS
;
486 if (nargs
!= 2 || nret
!= 2) {
487 ret
= RTAS_OUT_PARAM_ERROR
;
491 sensor_type
= rtas_ld(args
, 0);
492 sensor_index
= rtas_ld(args
, 1);
494 if (sensor_type
!= RTAS_SENSOR_TYPE_ENTITY_SENSE
) {
495 /* currently only DR-related sensors are implemented */
496 trace_spapr_rtas_get_sensor_state_not_supported(sensor_index
,
498 ret
= RTAS_OUT_NOT_SUPPORTED
;
502 drc
= spapr_dr_connector_by_index(sensor_index
);
504 trace_spapr_rtas_get_sensor_state_invalid(sensor_index
);
505 ret
= RTAS_OUT_PARAM_ERROR
;
508 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
509 ret
= drck
->entity_sense(drc
, &sensor_state
);
512 rtas_st(rets
, 0, ret
);
513 rtas_st(rets
, 1, sensor_state
);
516 /* configure-connector work area offsets, int32_t units for field
517 * indexes, bytes for field offset/len values.
519 * as documented by PAPR+ v2.7, 13.5.3.5
521 #define CC_IDX_NODE_NAME_OFFSET 2
522 #define CC_IDX_PROP_NAME_OFFSET 2
523 #define CC_IDX_PROP_LEN 3
524 #define CC_IDX_PROP_DATA_OFFSET 4
525 #define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4)
526 #define CC_WA_LEN 4096
528 static void configure_connector_st(target_ulong addr
, target_ulong offset
,
529 const void *buf
, size_t len
)
531 cpu_physical_memory_write(ppc64_phys_to_real(addr
+ offset
),
532 buf
, MIN(len
, CC_WA_LEN
- offset
));
535 static void rtas_ibm_configure_connector(PowerPCCPU
*cpu
,
536 sPAPRMachineState
*spapr
,
537 uint32_t token
, uint32_t nargs
,
538 target_ulong args
, uint32_t nret
,
544 sPAPRDRConnector
*drc
;
545 sPAPRDRConnectorClass
*drck
;
546 sPAPRConfigureConnectorState
*ccs
;
547 sPAPRDRCCResponse resp
= SPAPR_DR_CC_RESPONSE_CONTINUE
;
551 if (nargs
!= 2 || nret
!= 1) {
552 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
556 wa_addr
= ((uint64_t)rtas_ld(args
, 1) << 32) | rtas_ld(args
, 0);
558 drc_index
= rtas_ld(wa_addr
, 0);
559 drc
= spapr_dr_connector_by_index(drc_index
);
561 trace_spapr_rtas_ibm_configure_connector_invalid(drc_index
);
562 rc
= RTAS_OUT_PARAM_ERROR
;
566 drck
= SPAPR_DR_CONNECTOR_GET_CLASS(drc
);
567 fdt
= drck
->get_fdt(drc
, NULL
);
569 trace_spapr_rtas_ibm_configure_connector_missing_fdt(drc_index
);
570 rc
= SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE
;
574 ccs
= spapr_ccs_find(spapr
, drc_index
);
576 ccs
= g_new0(sPAPRConfigureConnectorState
, 1);
577 (void)drck
->get_fdt(drc
, &ccs
->fdt_offset
);
578 ccs
->drc_index
= drc_index
;
579 spapr_ccs_add(spapr
, ccs
);
585 const struct fdt_property
*prop
;
586 int fdt_offset_next
, prop_len
;
588 tag
= fdt_next_tag(fdt
, ccs
->fdt_offset
, &fdt_offset_next
);
593 name
= fdt_get_name(fdt
, ccs
->fdt_offset
, NULL
);
595 /* provide the name of the next OF node */
596 wa_offset
= CC_VAL_DATA_OFFSET
;
597 rtas_st(wa_addr
, CC_IDX_NODE_NAME_OFFSET
, wa_offset
);
598 configure_connector_st(wa_addr
, wa_offset
, name
, strlen(name
) + 1);
599 resp
= SPAPR_DR_CC_RESPONSE_NEXT_CHILD
;
603 if (ccs
->fdt_depth
== 0) {
604 /* done sending the device tree, don't need to track
607 drck
->set_configured(drc
);
608 spapr_ccs_remove(spapr
, ccs
);
610 resp
= SPAPR_DR_CC_RESPONSE_SUCCESS
;
612 resp
= SPAPR_DR_CC_RESPONSE_PREV_PARENT
;
616 prop
= fdt_get_property_by_offset(fdt
, ccs
->fdt_offset
,
618 name
= fdt_string(fdt
, fdt32_to_cpu(prop
->nameoff
));
620 /* provide the name of the next OF property */
621 wa_offset
= CC_VAL_DATA_OFFSET
;
622 rtas_st(wa_addr
, CC_IDX_PROP_NAME_OFFSET
, wa_offset
);
623 configure_connector_st(wa_addr
, wa_offset
, name
, strlen(name
) + 1);
625 /* provide the length and value of the OF property. data gets
626 * placed immediately after NULL terminator of the OF property's
629 wa_offset
+= strlen(name
) + 1,
630 rtas_st(wa_addr
, CC_IDX_PROP_LEN
, prop_len
);
631 rtas_st(wa_addr
, CC_IDX_PROP_DATA_OFFSET
, wa_offset
);
632 configure_connector_st(wa_addr
, wa_offset
, prop
->data
, prop_len
);
633 resp
= SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY
;
636 resp
= SPAPR_DR_CC_RESPONSE_ERROR
;
638 /* keep seeking for an actionable tag */
642 ccs
->fdt_offset
= fdt_offset_next
;
644 } while (resp
== SPAPR_DR_CC_RESPONSE_CONTINUE
);
648 rtas_st(rets
, 0, rc
);
651 static struct rtas_call
{
654 } rtas_table
[RTAS_TOKEN_MAX
- RTAS_TOKEN_BASE
];
656 target_ulong
spapr_rtas_call(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
657 uint32_t token
, uint32_t nargs
, target_ulong args
,
658 uint32_t nret
, target_ulong rets
)
660 if ((token
>= RTAS_TOKEN_BASE
) && (token
< RTAS_TOKEN_MAX
)) {
661 struct rtas_call
*call
= rtas_table
+ (token
- RTAS_TOKEN_BASE
);
664 call
->fn(cpu
, spapr
, token
, nargs
, args
, nret
, rets
);
669 /* HACK: Some Linux early debug code uses RTAS display-character,
670 * but assumes the token value is 0xa (which it is on some real
671 * machines) without looking it up in the device tree. This
672 * special case makes this work */
674 rtas_display_character(cpu
, spapr
, 0xa, nargs
, args
, nret
, rets
);
678 hcall_dprintf("Unknown RTAS token 0x%x\n", token
);
679 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
683 uint64_t qtest_rtas_call(char *cmd
, uint32_t nargs
, uint64_t args
,
684 uint32_t nret
, uint64_t rets
)
688 for (token
= 0; token
< RTAS_TOKEN_MAX
- RTAS_TOKEN_BASE
; token
++) {
689 if (strcmp(cmd
, rtas_table
[token
].name
) == 0) {
690 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
691 PowerPCCPU
*cpu
= POWERPC_CPU(first_cpu
);
693 rtas_table
[token
].fn(cpu
, spapr
, token
+ RTAS_TOKEN_BASE
,
694 nargs
, args
, nret
, rets
);
701 void spapr_rtas_register(int token
, const char *name
, spapr_rtas_fn fn
)
703 assert((token
>= RTAS_TOKEN_BASE
) && (token
< RTAS_TOKEN_MAX
));
705 token
-= RTAS_TOKEN_BASE
;
707 assert(!rtas_table
[token
].name
);
709 rtas_table
[token
].name
= name
;
710 rtas_table
[token
].fn
= fn
;
713 int spapr_rtas_device_tree_setup(void *fdt
, hwaddr rtas_addr
,
718 uint32_t lrdr_capacity
[5];
719 MachineState
*machine
= MACHINE(qdev_get_machine());
720 sPAPRMachineState
*spapr
= SPAPR_MACHINE(machine
);
721 uint64_t max_hotplug_addr
= spapr
->hotplug_memory
.base
+
722 memory_region_size(&spapr
->hotplug_memory
.mr
);
724 ret
= fdt_add_mem_rsv(fdt
, rtas_addr
, rtas_size
);
726 error_report("Couldn't add RTAS reserve entry: %s",
731 ret
= qemu_fdt_setprop_cell(fdt
, "/rtas", "linux,rtas-base",
734 error_report("Couldn't add linux,rtas-base property: %s",
739 ret
= qemu_fdt_setprop_cell(fdt
, "/rtas", "linux,rtas-entry",
742 error_report("Couldn't add linux,rtas-entry property: %s",
747 ret
= qemu_fdt_setprop_cell(fdt
, "/rtas", "rtas-size",
750 error_report("Couldn't add rtas-size property: %s",
755 for (i
= 0; i
< RTAS_TOKEN_MAX
- RTAS_TOKEN_BASE
; i
++) {
756 struct rtas_call
*call
= &rtas_table
[i
];
762 ret
= qemu_fdt_setprop_cell(fdt
, "/rtas", call
->name
,
763 i
+ RTAS_TOKEN_BASE
);
765 error_report("Couldn't add rtas token for %s: %s",
766 call
->name
, fdt_strerror(ret
));
772 lrdr_capacity
[0] = cpu_to_be32(max_hotplug_addr
>> 32);
773 lrdr_capacity
[1] = cpu_to_be32(max_hotplug_addr
& 0xffffffff);
774 lrdr_capacity
[2] = 0;
775 lrdr_capacity
[3] = cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE
);
776 lrdr_capacity
[4] = cpu_to_be32(max_cpus
/smp_threads
);
777 ret
= qemu_fdt_setprop(fdt
, "/rtas", "ibm,lrdr-capacity", lrdr_capacity
,
778 sizeof(lrdr_capacity
));
780 error_report("Couldn't add ibm,lrdr-capacity rtas property");
787 static void core_rtas_register_types(void)
789 spapr_rtas_register(RTAS_DISPLAY_CHARACTER
, "display-character",
790 rtas_display_character
);
791 spapr_rtas_register(RTAS_POWER_OFF
, "power-off", rtas_power_off
);
792 spapr_rtas_register(RTAS_SYSTEM_REBOOT
, "system-reboot",
794 spapr_rtas_register(RTAS_QUERY_CPU_STOPPED_STATE
, "query-cpu-stopped-state",
795 rtas_query_cpu_stopped_state
);
796 spapr_rtas_register(RTAS_START_CPU
, "start-cpu", rtas_start_cpu
);
797 spapr_rtas_register(RTAS_STOP_SELF
, "stop-self", rtas_stop_self
);
798 spapr_rtas_register(RTAS_IBM_GET_SYSTEM_PARAMETER
,
799 "ibm,get-system-parameter",
800 rtas_ibm_get_system_parameter
);
801 spapr_rtas_register(RTAS_IBM_SET_SYSTEM_PARAMETER
,
802 "ibm,set-system-parameter",
803 rtas_ibm_set_system_parameter
);
804 spapr_rtas_register(RTAS_IBM_OS_TERM
, "ibm,os-term",
806 spapr_rtas_register(RTAS_SET_POWER_LEVEL
, "set-power-level",
807 rtas_set_power_level
);
808 spapr_rtas_register(RTAS_GET_POWER_LEVEL
, "get-power-level",
809 rtas_get_power_level
);
810 spapr_rtas_register(RTAS_SET_INDICATOR
, "set-indicator",
812 spapr_rtas_register(RTAS_GET_SENSOR_STATE
, "get-sensor-state",
813 rtas_get_sensor_state
);
814 spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR
, "ibm,configure-connector",
815 rtas_ibm_configure_connector
);
818 type_init(core_rtas_register_types
)