1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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/spapr_rtas.h"
41#include "hw/ppc/ppc.h"
42#include "qapi-event.h"
43#include "hw/boards.h"
44
45#include <libfdt.h>
46#include "hw/ppc/spapr_drc.h"
47#include "qemu/cutils.h"
48#include "trace.h"
49#include "hw/ppc/fdt.h"
50
51static sPAPRConfigureConnectorState *spapr_ccs_find(sPAPRMachineState *spapr,
52 uint32_t drc_index)
53{
54 sPAPRConfigureConnectorState *ccs = NULL;
55
56 QTAILQ_FOREACH(ccs, &spapr->ccs_list, next) {
57 if (ccs->drc_index == drc_index) {
58 break;
59 }
60 }
61
62 return ccs;
63}
64
65static void spapr_ccs_add(sPAPRMachineState *spapr,
66 sPAPRConfigureConnectorState *ccs)
67{
68 g_assert(!spapr_ccs_find(spapr, ccs->drc_index));
69 QTAILQ_INSERT_HEAD(&spapr->ccs_list, ccs, next);
70}
71
72static void spapr_ccs_remove(sPAPRMachineState *spapr,
73 sPAPRConfigureConnectorState *ccs)
74{
75 QTAILQ_REMOVE(&spapr->ccs_list, ccs, next);
76 g_free(ccs);
77}
78
79void spapr_ccs_reset_hook(void *opaque)
80{
81 sPAPRMachineState *spapr = opaque;
82 sPAPRConfigureConnectorState *ccs, *ccs_tmp;
83
84 QTAILQ_FOREACH_SAFE(ccs, &spapr->ccs_list, next, ccs_tmp) {
85 spapr_ccs_remove(spapr, ccs);
86 }
87}
88
89static void rtas_display_character(PowerPCCPU *cpu, sPAPRMachineState *spapr,
90 uint32_t token, uint32_t nargs,
91 target_ulong args,
92 uint32_t nret, target_ulong rets)
93{
94 uint8_t c = rtas_ld(args, 0);
95 VIOsPAPRDevice *sdev = vty_lookup(spapr, 0);
96
97 if (!sdev) {
98 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
99 } else {
100 vty_putchars(sdev, &c, sizeof(c));
101 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
102 }
103}
104
105static void rtas_power_off(PowerPCCPU *cpu, sPAPRMachineState *spapr,
106 uint32_t token, uint32_t nargs, target_ulong args,
107 uint32_t nret, target_ulong rets)
108{
109 if (nargs != 2 || nret != 1) {
110 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
111 return;
112 }
113 qemu_system_shutdown_request();
114 cpu_stop_current();
115 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
116}
117
118static void rtas_system_reboot(PowerPCCPU *cpu, sPAPRMachineState *spapr,
119 uint32_t token, uint32_t nargs,
120 target_ulong args,
121 uint32_t nret, target_ulong rets)
122{
123 if (nargs != 0 || nret != 1) {
124 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
125 return;
126 }
127 qemu_system_reset_request();
128 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
129}
130
131static void rtas_query_cpu_stopped_state(PowerPCCPU *cpu_,
132 sPAPRMachineState *spapr,
133 uint32_t token, uint32_t nargs,
134 target_ulong args,
135 uint32_t nret, target_ulong rets)
136{
137 target_ulong id;
138 PowerPCCPU *cpu;
139
140 if (nargs != 1 || nret != 2) {
141 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
142 return;
143 }
144
145 id = rtas_ld(args, 0);
146 cpu = ppc_get_vcpu_by_dt_id(id);
147 if (cpu != NULL) {
148 if (CPU(cpu)->halted) {
149 rtas_st(rets, 1, 0);
150 } else {
151 rtas_st(rets, 1, 2);
152 }
153
154 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
155 return;
156 }
157
158
159 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
160}
161
162
163
164
165
166static void spapr_cpu_update_tb_offset(PowerPCCPU *cpu)
167{
168 PowerPCCPU *fcpu = POWERPC_CPU(first_cpu);
169
170 cpu->env.tb_env->tb_offset = fcpu->env.tb_env->tb_offset;
171}
172
173static void spapr_cpu_set_endianness(PowerPCCPU *cpu)
174{
175 PowerPCCPU *fcpu = POWERPC_CPU(first_cpu);
176 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(fcpu);
177
178 if (!pcc->interrupts_big_endian(fcpu)) {
179 cpu->env.spr[SPR_LPCR] |= LPCR_ILE;
180 }
181}
182
183static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr,
184 uint32_t token, uint32_t nargs,
185 target_ulong args,
186 uint32_t nret, target_ulong rets)
187{
188 target_ulong id, start, r3;
189 PowerPCCPU *cpu;
190
191 if (nargs != 3 || nret != 1) {
192 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
193 return;
194 }
195
196 id = rtas_ld(args, 0);
197 start = rtas_ld(args, 1);
198 r3 = rtas_ld(args, 2);
199
200 cpu = ppc_get_vcpu_by_dt_id(id);
201 if (cpu != NULL) {
202 CPUState *cs = CPU(cpu);
203 CPUPPCState *env = &cpu->env;
204
205 if (!cs->halted) {
206 rtas_st(rets, 0, RTAS_OUT_HW_ERROR);
207 return;
208 }
209
210
211
212
213 kvm_cpu_synchronize_state(cs);
214
215 env->msr = (1ULL << MSR_SF) | (1ULL << MSR_ME);
216 env->nip = start;
217 env->gpr[3] = r3;
218 cs->halted = 0;
219 spapr_cpu_set_endianness(cpu);
220 spapr_cpu_update_tb_offset(cpu);
221
222 qemu_cpu_kick(cs);
223
224 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
225 return;
226 }
227
228
229 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
230}
231
232static void rtas_stop_self(PowerPCCPU *cpu, sPAPRMachineState *spapr,
233 uint32_t token, uint32_t nargs,
234 target_ulong args,
235 uint32_t nret, target_ulong rets)
236{
237 CPUState *cs = CPU(cpu);
238 CPUPPCState *env = &cpu->env;
239
240 cs->halted = 1;
241 qemu_cpu_kick(cs);
242
243
244
245
246
247
248
249
250
251 env->msr = 0;
252}
253
254static inline int sysparm_st(target_ulong addr, target_ulong len,
255 const void *val, uint16_t vallen)
256{
257 hwaddr phys = ppc64_phys_to_real(addr);
258
259 if (len < 2) {
260 return RTAS_OUT_SYSPARM_PARAM_ERROR;
261 }
262 stw_be_phys(&address_space_memory, phys, vallen);
263 cpu_physical_memory_write(phys + 2, val, MIN(len - 2, vallen));
264 return RTAS_OUT_SUCCESS;
265}
266
267static void rtas_ibm_get_system_parameter(PowerPCCPU *cpu,
268 sPAPRMachineState *spapr,
269 uint32_t token, uint32_t nargs,
270 target_ulong args,
271 uint32_t nret, target_ulong rets)
272{
273 target_ulong parameter = rtas_ld(args, 0);
274 target_ulong buffer = rtas_ld(args, 1);
275 target_ulong length = rtas_ld(args, 2);
276 target_ulong ret;
277
278 switch (parameter) {
279 case RTAS_SYSPARM_SPLPAR_CHARACTERISTICS: {
280 char *param_val = g_strdup_printf("MaxEntCap=%d,"
281 "DesMem=%llu,"
282 "DesProcs=%d,"
283 "MaxPlatProcs=%d",
284 max_cpus,
285 current_machine->ram_size / M_BYTE,
286 smp_cpus,
287 max_cpus);
288 ret = sysparm_st(buffer, length, param_val, strlen(param_val) + 1);
289 g_free(param_val);
290 break;
291 }
292 case RTAS_SYSPARM_DIAGNOSTICS_RUN_MODE: {
293 uint8_t param_val = DIAGNOSTICS_RUN_MODE_DISABLED;
294
295 ret = sysparm_st(buffer, length, ¶m_val, sizeof(param_val));
296 break;
297 }
298 case RTAS_SYSPARM_UUID:
299 ret = sysparm_st(buffer, length, (unsigned char *)&qemu_uuid,
300 (qemu_uuid_set ? 16 : 0));
301 break;
302 default:
303 ret = RTAS_OUT_NOT_SUPPORTED;
304 }
305
306 rtas_st(rets, 0, ret);
307}
308
309static void rtas_ibm_set_system_parameter(PowerPCCPU *cpu,
310 sPAPRMachineState *spapr,
311 uint32_t token, uint32_t nargs,
312 target_ulong args,
313 uint32_t nret, target_ulong rets)
314{
315 target_ulong parameter = rtas_ld(args, 0);
316 target_ulong ret = RTAS_OUT_NOT_SUPPORTED;
317
318 switch (parameter) {
319 case RTAS_SYSPARM_SPLPAR_CHARACTERISTICS:
320 case RTAS_SYSPARM_DIAGNOSTICS_RUN_MODE:
321 case RTAS_SYSPARM_UUID:
322 ret = RTAS_OUT_NOT_AUTHORIZED;
323 break;
324 }
325
326 rtas_st(rets, 0, ret);
327}
328
329static void rtas_ibm_os_term(PowerPCCPU *cpu,
330 sPAPRMachineState *spapr,
331 uint32_t token, uint32_t nargs,
332 target_ulong args,
333 uint32_t nret, target_ulong rets)
334{
335 target_ulong ret = 0;
336
337 qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, &error_abort);
338
339 rtas_st(rets, 0, ret);
340}
341
342static void rtas_set_power_level(PowerPCCPU *cpu, sPAPRMachineState *spapr,
343 uint32_t token, uint32_t nargs,
344 target_ulong args, uint32_t nret,
345 target_ulong rets)
346{
347 int32_t power_domain;
348
349 if (nargs != 2 || nret != 2) {
350 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
351 return;
352 }
353
354
355
356
357 power_domain = rtas_ld(args, 0);
358 if (power_domain != -1) {
359 rtas_st(rets, 0, RTAS_OUT_NOT_SUPPORTED);
360 return;
361 }
362
363 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
364 rtas_st(rets, 1, 100);
365}
366
367static void rtas_get_power_level(PowerPCCPU *cpu, sPAPRMachineState *spapr,
368 uint32_t token, uint32_t nargs,
369 target_ulong args, uint32_t nret,
370 target_ulong rets)
371{
372 int32_t power_domain;
373
374 if (nargs != 1 || nret != 2) {
375 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
376 return;
377 }
378
379
380
381
382 power_domain = rtas_ld(args, 0);
383 if (power_domain != -1) {
384 rtas_st(rets, 0, RTAS_OUT_NOT_SUPPORTED);
385 return;
386 }
387
388 rtas_st(rets, 0, RTAS_OUT_SUCCESS);
389 rtas_st(rets, 1, 100);
390}
391
392static bool sensor_type_is_dr(uint32_t sensor_type)
393{
394 switch (sensor_type) {
395 case RTAS_SENSOR_TYPE_ISOLATION_STATE:
396 case RTAS_SENSOR_TYPE_DR:
397 case RTAS_SENSOR_TYPE_ALLOCATION_STATE:
398 return true;
399 }
400
401 return false;
402}
403
404static void rtas_set_indicator(PowerPCCPU *cpu, sPAPRMachineState *spapr,
405 uint32_t token, uint32_t nargs,
406 target_ulong args, uint32_t nret,
407 target_ulong rets)
408{
409 uint32_t sensor_type;
410 uint32_t sensor_index;
411 uint32_t sensor_state;
412 uint32_t ret = RTAS_OUT_SUCCESS;
413 sPAPRDRConnector *drc;
414 sPAPRDRConnectorClass *drck;
415
416 if (nargs != 3 || nret != 1) {
417 ret = RTAS_OUT_PARAM_ERROR;
418 goto out;
419 }
420
421 sensor_type = rtas_ld(args, 0);
422 sensor_index = rtas_ld(args, 1);
423 sensor_state = rtas_ld(args, 2);
424
425 if (!sensor_type_is_dr(sensor_type)) {
426 goto out_unimplemented;
427 }
428
429
430 drc = spapr_dr_connector_by_index(sensor_index);
431 if (!drc) {
432 trace_spapr_rtas_set_indicator_invalid(sensor_index);
433 ret = RTAS_OUT_PARAM_ERROR;
434 goto out;
435 }
436 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
437
438 switch (sensor_type) {
439 case RTAS_SENSOR_TYPE_ISOLATION_STATE:
440
441
442
443
444
445
446 if (sensor_state == SPAPR_DR_ISOLATION_STATE_ISOLATED) {
447 sPAPRConfigureConnectorState *ccs = spapr_ccs_find(spapr,
448 sensor_index);
449 if (ccs) {
450 spapr_ccs_remove(spapr, ccs);
451 }
452 }
453 ret = drck->set_isolation_state(drc, sensor_state);
454 break;
455 case RTAS_SENSOR_TYPE_DR:
456 ret = drck->set_indicator_state(drc, sensor_state);
457 break;
458 case RTAS_SENSOR_TYPE_ALLOCATION_STATE:
459 ret = drck->set_allocation_state(drc, sensor_state);
460 break;
461 default:
462 goto out_unimplemented;
463 }
464
465out:
466 rtas_st(rets, 0, ret);
467 return;
468
469out_unimplemented:
470
471 trace_spapr_rtas_set_indicator_not_supported(sensor_index, sensor_type);
472 rtas_st(rets, 0, RTAS_OUT_NOT_SUPPORTED);
473}
474
475static void rtas_get_sensor_state(PowerPCCPU *cpu, sPAPRMachineState *spapr,
476 uint32_t token, uint32_t nargs,
477 target_ulong args, uint32_t nret,
478 target_ulong rets)
479{
480 uint32_t sensor_type;
481 uint32_t sensor_index;
482 uint32_t sensor_state = 0;
483 sPAPRDRConnector *drc;
484 sPAPRDRConnectorClass *drck;
485 uint32_t ret = RTAS_OUT_SUCCESS;
486
487 if (nargs != 2 || nret != 2) {
488 ret = RTAS_OUT_PARAM_ERROR;
489 goto out;
490 }
491
492 sensor_type = rtas_ld(args, 0);
493 sensor_index = rtas_ld(args, 1);
494
495 if (sensor_type != RTAS_SENSOR_TYPE_ENTITY_SENSE) {
496
497 trace_spapr_rtas_get_sensor_state_not_supported(sensor_index,
498 sensor_type);
499 ret = RTAS_OUT_NOT_SUPPORTED;
500 goto out;
501 }
502
503 drc = spapr_dr_connector_by_index(sensor_index);
504 if (!drc) {
505 trace_spapr_rtas_get_sensor_state_invalid(sensor_index);
506 ret = RTAS_OUT_PARAM_ERROR;
507 goto out;
508 }
509 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
510 ret = drck->entity_sense(drc, &sensor_state);
511
512out:
513 rtas_st(rets, 0, ret);
514 rtas_st(rets, 1, sensor_state);
515}
516
517
518
519
520
521
522#define CC_IDX_NODE_NAME_OFFSET 2
523#define CC_IDX_PROP_NAME_OFFSET 2
524#define CC_IDX_PROP_LEN 3
525#define CC_IDX_PROP_DATA_OFFSET 4
526#define CC_VAL_DATA_OFFSET ((CC_IDX_PROP_DATA_OFFSET + 1) * 4)
527#define CC_WA_LEN 4096
528
529static void configure_connector_st(target_ulong addr, target_ulong offset,
530 const void *buf, size_t len)
531{
532 cpu_physical_memory_write(ppc64_phys_to_real(addr + offset),
533 buf, MIN(len, CC_WA_LEN - offset));
534}
535
536static void rtas_ibm_configure_connector(PowerPCCPU *cpu,
537 sPAPRMachineState *spapr,
538 uint32_t token, uint32_t nargs,
539 target_ulong args, uint32_t nret,
540 target_ulong rets)
541{
542 uint64_t wa_addr;
543 uint64_t wa_offset;
544 uint32_t drc_index;
545 sPAPRDRConnector *drc;
546 sPAPRDRConnectorClass *drck;
547 sPAPRConfigureConnectorState *ccs;
548 sPAPRDRCCResponse resp = SPAPR_DR_CC_RESPONSE_CONTINUE;
549 int rc;
550 const void *fdt;
551
552 if (nargs != 2 || nret != 1) {
553 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
554 return;
555 }
556
557 wa_addr = ((uint64_t)rtas_ld(args, 1) << 32) | rtas_ld(args, 0);
558
559 drc_index = rtas_ld(wa_addr, 0);
560 drc = spapr_dr_connector_by_index(drc_index);
561 if (!drc) {
562 trace_spapr_rtas_ibm_configure_connector_invalid(drc_index);
563 rc = RTAS_OUT_PARAM_ERROR;
564 goto out;
565 }
566
567 drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
568 fdt = drck->get_fdt(drc, NULL);
569 if (!fdt) {
570 trace_spapr_rtas_ibm_configure_connector_missing_fdt(drc_index);
571 rc = SPAPR_DR_CC_RESPONSE_NOT_CONFIGURABLE;
572 goto out;
573 }
574
575 ccs = spapr_ccs_find(spapr, drc_index);
576 if (!ccs) {
577 ccs = g_new0(sPAPRConfigureConnectorState, 1);
578 (void)drck->get_fdt(drc, &ccs->fdt_offset);
579 ccs->drc_index = drc_index;
580 spapr_ccs_add(spapr, ccs);
581 }
582
583 do {
584 uint32_t tag;
585 const char *name;
586 const struct fdt_property *prop;
587 int fdt_offset_next, prop_len;
588
589 tag = fdt_next_tag(fdt, ccs->fdt_offset, &fdt_offset_next);
590
591 switch (tag) {
592 case FDT_BEGIN_NODE:
593 ccs->fdt_depth++;
594 name = fdt_get_name(fdt, ccs->fdt_offset, NULL);
595
596
597 wa_offset = CC_VAL_DATA_OFFSET;
598 rtas_st(wa_addr, CC_IDX_NODE_NAME_OFFSET, wa_offset);
599 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
600 resp = SPAPR_DR_CC_RESPONSE_NEXT_CHILD;
601 break;
602 case FDT_END_NODE:
603 ccs->fdt_depth--;
604 if (ccs->fdt_depth == 0) {
605
606
607
608 drck->set_configured(drc);
609 spapr_ccs_remove(spapr, ccs);
610 ccs = NULL;
611 resp = SPAPR_DR_CC_RESPONSE_SUCCESS;
612 } else {
613 resp = SPAPR_DR_CC_RESPONSE_PREV_PARENT;
614 }
615 break;
616 case FDT_PROP:
617 prop = fdt_get_property_by_offset(fdt, ccs->fdt_offset,
618 &prop_len);
619 name = fdt_string(fdt, fdt32_to_cpu(prop->nameoff));
620
621
622 wa_offset = CC_VAL_DATA_OFFSET;
623 rtas_st(wa_addr, CC_IDX_PROP_NAME_OFFSET, wa_offset);
624 configure_connector_st(wa_addr, wa_offset, name, strlen(name) + 1);
625
626
627
628
629
630 wa_offset += strlen(name) + 1,
631 rtas_st(wa_addr, CC_IDX_PROP_LEN, prop_len);
632 rtas_st(wa_addr, CC_IDX_PROP_DATA_OFFSET, wa_offset);
633 configure_connector_st(wa_addr, wa_offset, prop->data, prop_len);
634 resp = SPAPR_DR_CC_RESPONSE_NEXT_PROPERTY;
635 break;
636 case FDT_END:
637 resp = SPAPR_DR_CC_RESPONSE_ERROR;
638 default:
639
640 break;
641 }
642 if (ccs) {
643 ccs->fdt_offset = fdt_offset_next;
644 }
645 } while (resp == SPAPR_DR_CC_RESPONSE_CONTINUE);
646
647 rc = resp;
648out:
649 rtas_st(rets, 0, rc);
650}
651
652static struct rtas_call {
653 const char *name;
654 spapr_rtas_fn fn;
655} rtas_table[RTAS_TOKEN_MAX - RTAS_TOKEN_BASE];
656
657target_ulong spapr_rtas_call(PowerPCCPU *cpu, sPAPRMachineState *spapr,
658 uint32_t token, uint32_t nargs, target_ulong args,
659 uint32_t nret, target_ulong rets)
660{
661 if ((token >= RTAS_TOKEN_BASE) && (token < RTAS_TOKEN_MAX)) {
662 struct rtas_call *call = rtas_table + (token - RTAS_TOKEN_BASE);
663
664 if (call->fn) {
665 call->fn(cpu, spapr, token, nargs, args, nret, rets);
666 return H_SUCCESS;
667 }
668 }
669
670
671
672
673
674 if (token == 0xa) {
675 rtas_display_character(cpu, spapr, 0xa, nargs, args, nret, rets);
676 return H_SUCCESS;
677 }
678
679 hcall_dprintf("Unknown RTAS token 0x%x\n", token);
680 rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR);
681 return H_PARAMETER;
682}
683
684uint64_t qtest_rtas_call(char *cmd, uint32_t nargs, uint64_t args,
685 uint32_t nret, uint64_t rets)
686{
687 int token;
688
689 for (token = 0; token < RTAS_TOKEN_MAX - RTAS_TOKEN_BASE; token++) {
690 if (strcmp(cmd, rtas_table[token].name) == 0) {
691 sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
692 PowerPCCPU *cpu = POWERPC_CPU(first_cpu);
693
694 rtas_table[token].fn(cpu, spapr, token + RTAS_TOKEN_BASE,
695 nargs, args, nret, rets);
696 return H_SUCCESS;
697 }
698 }
699 return H_PARAMETER;
700}
701
702void spapr_rtas_register(int token, const char *name, spapr_rtas_fn fn)
703{
704 assert((token >= RTAS_TOKEN_BASE) && (token < RTAS_TOKEN_MAX));
705
706 token -= RTAS_TOKEN_BASE;
707
708 assert(!rtas_table[token].name);
709
710 rtas_table[token].name = name;
711 rtas_table[token].fn = fn;
712}
713
714void spapr_dt_rtas_tokens(void *fdt, int rtas)
715{
716 int i;
717
718 for (i = 0; i < RTAS_TOKEN_MAX - RTAS_TOKEN_BASE; i++) {
719 struct rtas_call *call = &rtas_table[i];
720
721 if (!call->name) {
722 continue;
723 }
724
725 _FDT(fdt_setprop_cell(fdt, rtas, call->name, i + RTAS_TOKEN_BASE));
726 }
727}
728
729void spapr_load_rtas(sPAPRMachineState *spapr, void *fdt, hwaddr addr)
730{
731 int rtas_node;
732 int ret;
733
734
735 cpu_physical_memory_write(addr, spapr->rtas_blob, spapr->rtas_size);
736
737 ret = fdt_add_mem_rsv(fdt, addr, spapr->rtas_size);
738 if (ret < 0) {
739 error_report("Couldn't add RTAS reserve entry: %s",
740 fdt_strerror(ret));
741 exit(1);
742 }
743
744
745 rtas_node = fdt_path_offset(fdt, "/rtas");
746 assert(rtas_node >= 0);
747
748 ret = fdt_setprop_cell(fdt, rtas_node, "linux,rtas-base", addr);
749 if (ret < 0) {
750 error_report("Couldn't add linux,rtas-base property: %s",
751 fdt_strerror(ret));
752 exit(1);
753 }
754
755 ret = fdt_setprop_cell(fdt, rtas_node, "linux,rtas-entry", addr);
756 if (ret < 0) {
757 error_report("Couldn't add linux,rtas-entry property: %s",
758 fdt_strerror(ret));
759 exit(1);
760 }
761
762 ret = fdt_setprop_cell(fdt, rtas_node, "rtas-size", spapr->rtas_size);
763 if (ret < 0) {
764 error_report("Couldn't add rtas-size property: %s",
765 fdt_strerror(ret));
766 exit(1);
767 }
768}
769
770static void core_rtas_register_types(void)
771{
772 spapr_rtas_register(RTAS_DISPLAY_CHARACTER, "display-character",
773 rtas_display_character);
774 spapr_rtas_register(RTAS_POWER_OFF, "power-off", rtas_power_off);
775 spapr_rtas_register(RTAS_SYSTEM_REBOOT, "system-reboot",
776 rtas_system_reboot);
777 spapr_rtas_register(RTAS_QUERY_CPU_STOPPED_STATE, "query-cpu-stopped-state",
778 rtas_query_cpu_stopped_state);
779 spapr_rtas_register(RTAS_START_CPU, "start-cpu", rtas_start_cpu);
780 spapr_rtas_register(RTAS_STOP_SELF, "stop-self", rtas_stop_self);
781 spapr_rtas_register(RTAS_IBM_GET_SYSTEM_PARAMETER,
782 "ibm,get-system-parameter",
783 rtas_ibm_get_system_parameter);
784 spapr_rtas_register(RTAS_IBM_SET_SYSTEM_PARAMETER,
785 "ibm,set-system-parameter",
786 rtas_ibm_set_system_parameter);
787 spapr_rtas_register(RTAS_IBM_OS_TERM, "ibm,os-term",
788 rtas_ibm_os_term);
789 spapr_rtas_register(RTAS_SET_POWER_LEVEL, "set-power-level",
790 rtas_set_power_level);
791 spapr_rtas_register(RTAS_GET_POWER_LEVEL, "get-power-level",
792 rtas_get_power_level);
793 spapr_rtas_register(RTAS_SET_INDICATOR, "set-indicator",
794 rtas_set_indicator);
795 spapr_rtas_register(RTAS_GET_SENSOR_STATE, "get-sensor-state",
796 rtas_get_sensor_state);
797 spapr_rtas_register(RTAS_IBM_CONFIGURE_CONNECTOR, "ibm,configure-connector",
798 rtas_ibm_configure_connector);
799}
800
801type_init(core_rtas_register_types)
802
