2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License version 2 as
4 * published by the Free Software Foundation.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
11 * Copyright (C) 2013 ARM Limited
13 * Author: Will Deacon <will.deacon@arm.com>
16 #define pr_fmt(fmt) "psci: " fmt
18 #include <linux/acpi.h>
19 #include <linux/init.h>
21 #include <linux/smp.h>
22 #include <linux/reboot.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <uapi/linux/psci.h>
29 #include <asm/compiler.h>
30 #include <asm/cpu_ops.h>
31 #include <asm/errno.h>
33 #include <asm/smp_plat.h>
34 #include <asm/suspend.h>
35 #include <asm/system_misc.h>
37 #define PSCI_POWER_STATE_TYPE_STANDBY 0
38 #define PSCI_POWER_STATE_TYPE_POWER_DOWN 1
40 struct psci_power_state
{
46 struct psci_operations
{
47 int (*cpu_suspend
)(struct psci_power_state state
,
48 unsigned long entry_point
);
49 int (*cpu_off
)(struct psci_power_state state
);
50 int (*cpu_on
)(unsigned long cpuid
, unsigned long entry_point
);
51 int (*migrate
)(unsigned long cpuid
);
52 int (*affinity_info
)(unsigned long target_affinity
,
53 unsigned long lowest_affinity_level
);
54 int (*migrate_info_type
)(void);
57 static struct psci_operations psci_ops
;
59 static int (*invoke_psci_fn
)(u64
, u64
, u64
, u64
);
60 typedef int (*psci_initcall_t
)(const struct device_node
*);
62 asmlinkage
int __invoke_psci_fn_hvc(u64
, u64
, u64
, u64
);
63 asmlinkage
int __invoke_psci_fn_smc(u64
, u64
, u64
, u64
);
70 PSCI_FN_AFFINITY_INFO
,
71 PSCI_FN_MIGRATE_INFO_TYPE
,
75 static DEFINE_PER_CPU_READ_MOSTLY(struct psci_power_state
*, psci_power_state
);
77 static u32 psci_function_id
[PSCI_FN_MAX
];
79 static int psci_to_linux_errno(int errno
)
82 case PSCI_RET_SUCCESS
:
84 case PSCI_RET_NOT_SUPPORTED
:
86 case PSCI_RET_INVALID_PARAMS
:
95 static u32
psci_power_state_pack(struct psci_power_state state
)
97 return ((state
.id
<< PSCI_0_2_POWER_STATE_ID_SHIFT
)
98 & PSCI_0_2_POWER_STATE_ID_MASK
) |
99 ((state
.type
<< PSCI_0_2_POWER_STATE_TYPE_SHIFT
)
100 & PSCI_0_2_POWER_STATE_TYPE_MASK
) |
101 ((state
.affinity_level
<< PSCI_0_2_POWER_STATE_AFFL_SHIFT
)
102 & PSCI_0_2_POWER_STATE_AFFL_MASK
);
105 static void psci_power_state_unpack(u32 power_state
,
106 struct psci_power_state
*state
)
108 state
->id
= (power_state
& PSCI_0_2_POWER_STATE_ID_MASK
) >>
109 PSCI_0_2_POWER_STATE_ID_SHIFT
;
110 state
->type
= (power_state
& PSCI_0_2_POWER_STATE_TYPE_MASK
) >>
111 PSCI_0_2_POWER_STATE_TYPE_SHIFT
;
112 state
->affinity_level
=
113 (power_state
& PSCI_0_2_POWER_STATE_AFFL_MASK
) >>
114 PSCI_0_2_POWER_STATE_AFFL_SHIFT
;
117 static int psci_get_version(void)
121 err
= invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION
, 0, 0, 0);
125 static int psci_cpu_suspend(struct psci_power_state state
,
126 unsigned long entry_point
)
131 fn
= psci_function_id
[PSCI_FN_CPU_SUSPEND
];
132 power_state
= psci_power_state_pack(state
);
133 err
= invoke_psci_fn(fn
, power_state
, entry_point
, 0);
134 return psci_to_linux_errno(err
);
137 static int psci_cpu_off(struct psci_power_state state
)
142 fn
= psci_function_id
[PSCI_FN_CPU_OFF
];
143 power_state
= psci_power_state_pack(state
);
144 err
= invoke_psci_fn(fn
, power_state
, 0, 0);
145 return psci_to_linux_errno(err
);
148 static int psci_cpu_on(unsigned long cpuid
, unsigned long entry_point
)
153 fn
= psci_function_id
[PSCI_FN_CPU_ON
];
154 err
= invoke_psci_fn(fn
, cpuid
, entry_point
, 0);
155 return psci_to_linux_errno(err
);
158 static int psci_migrate(unsigned long cpuid
)
163 fn
= psci_function_id
[PSCI_FN_MIGRATE
];
164 err
= invoke_psci_fn(fn
, cpuid
, 0, 0);
165 return psci_to_linux_errno(err
);
168 static int psci_affinity_info(unsigned long target_affinity
,
169 unsigned long lowest_affinity_level
)
174 fn
= psci_function_id
[PSCI_FN_AFFINITY_INFO
];
175 err
= invoke_psci_fn(fn
, target_affinity
, lowest_affinity_level
, 0);
179 static int psci_migrate_info_type(void)
184 fn
= psci_function_id
[PSCI_FN_MIGRATE_INFO_TYPE
];
185 err
= invoke_psci_fn(fn
, 0, 0, 0);
189 static int __maybe_unused
cpu_psci_cpu_init_idle(struct device_node
*cpu_node
,
192 int i
, ret
, count
= 0;
193 struct psci_power_state
*psci_states
;
194 struct device_node
*state_node
;
197 * If the PSCI cpu_suspend function hook has not been initialized
198 * idle states must not be enabled, so bail out
200 if (!psci_ops
.cpu_suspend
)
203 /* Count idle states */
204 while ((state_node
= of_parse_phandle(cpu_node
, "cpu-idle-states",
207 of_node_put(state_node
);
213 psci_states
= kcalloc(count
, sizeof(*psci_states
), GFP_KERNEL
);
217 for (i
= 0; i
< count
; i
++) {
218 u32 psci_power_state
;
220 state_node
= of_parse_phandle(cpu_node
, "cpu-idle-states", i
);
222 ret
= of_property_read_u32(state_node
,
223 "arm,psci-suspend-param",
226 pr_warn(" * %s missing arm,psci-suspend-param property\n",
227 state_node
->full_name
);
228 of_node_put(state_node
);
232 of_node_put(state_node
);
233 pr_debug("psci-power-state %#x index %d\n", psci_power_state
,
235 psci_power_state_unpack(psci_power_state
, &psci_states
[i
]);
237 /* Idle states parsed correctly, initialize per-cpu pointer */
238 per_cpu(psci_power_state
, cpu
) = psci_states
;
246 static int get_set_conduit_method(struct device_node
*np
)
250 pr_info("probing for conduit method from DT.\n");
252 if (of_property_read_string(np
, "method", &method
)) {
253 pr_warn("missing \"method\" property\n");
257 if (!strcmp("hvc", method
)) {
258 invoke_psci_fn
= __invoke_psci_fn_hvc
;
259 } else if (!strcmp("smc", method
)) {
260 invoke_psci_fn
= __invoke_psci_fn_smc
;
262 pr_warn("invalid \"method\" property: %s\n", method
);
268 static void psci_sys_reset(enum reboot_mode reboot_mode
, const char *cmd
)
270 invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET
, 0, 0, 0);
273 static void psci_sys_poweroff(void)
275 invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF
, 0, 0, 0);
278 static void __init
psci_0_2_set_functions(void)
280 pr_info("Using standard PSCI v0.2 function IDs\n");
281 psci_function_id
[PSCI_FN_CPU_SUSPEND
] = PSCI_0_2_FN64_CPU_SUSPEND
;
282 psci_ops
.cpu_suspend
= psci_cpu_suspend
;
284 psci_function_id
[PSCI_FN_CPU_OFF
] = PSCI_0_2_FN_CPU_OFF
;
285 psci_ops
.cpu_off
= psci_cpu_off
;
287 psci_function_id
[PSCI_FN_CPU_ON
] = PSCI_0_2_FN64_CPU_ON
;
288 psci_ops
.cpu_on
= psci_cpu_on
;
290 psci_function_id
[PSCI_FN_MIGRATE
] = PSCI_0_2_FN64_MIGRATE
;
291 psci_ops
.migrate
= psci_migrate
;
293 psci_function_id
[PSCI_FN_AFFINITY_INFO
] = PSCI_0_2_FN64_AFFINITY_INFO
;
294 psci_ops
.affinity_info
= psci_affinity_info
;
296 psci_function_id
[PSCI_FN_MIGRATE_INFO_TYPE
] =
297 PSCI_0_2_FN_MIGRATE_INFO_TYPE
;
298 psci_ops
.migrate_info_type
= psci_migrate_info_type
;
300 arm_pm_restart
= psci_sys_reset
;
302 pm_power_off
= psci_sys_poweroff
;
306 * Probe function for PSCI firmware versions >= 0.2
308 static int __init
psci_probe(void)
310 int ver
= psci_get_version();
312 if (ver
== PSCI_RET_NOT_SUPPORTED
) {
314 * PSCI versions >=0.2 mandates implementation of
317 pr_err("PSCI firmware does not comply with the v0.2 spec.\n");
320 pr_info("PSCIv%d.%d detected in firmware.\n",
321 PSCI_VERSION_MAJOR(ver
),
322 PSCI_VERSION_MINOR(ver
));
324 if (PSCI_VERSION_MAJOR(ver
) == 0 &&
325 PSCI_VERSION_MINOR(ver
) < 2) {
326 pr_err("Conflicting PSCI version detected.\n");
331 psci_0_2_set_functions();
337 * PSCI init function for PSCI versions >=0.2
339 * Probe based on PSCI PSCI_VERSION function
341 static int __init
psci_0_2_init(struct device_node
*np
)
345 err
= get_set_conduit_method(np
);
350 * Starting with v0.2, the PSCI specification introduced a call
351 * (PSCI_VERSION) that allows probing the firmware version, so
352 * that PSCI function IDs and version specific initialization
353 * can be carried out according to the specific version reported
364 * PSCI < v0.2 get PSCI Function IDs via DT.
366 static int __init
psci_0_1_init(struct device_node
*np
)
371 err
= get_set_conduit_method(np
);
376 pr_info("Using PSCI v0.1 Function IDs from DT\n");
378 if (!of_property_read_u32(np
, "cpu_suspend", &id
)) {
379 psci_function_id
[PSCI_FN_CPU_SUSPEND
] = id
;
380 psci_ops
.cpu_suspend
= psci_cpu_suspend
;
383 if (!of_property_read_u32(np
, "cpu_off", &id
)) {
384 psci_function_id
[PSCI_FN_CPU_OFF
] = id
;
385 psci_ops
.cpu_off
= psci_cpu_off
;
388 if (!of_property_read_u32(np
, "cpu_on", &id
)) {
389 psci_function_id
[PSCI_FN_CPU_ON
] = id
;
390 psci_ops
.cpu_on
= psci_cpu_on
;
393 if (!of_property_read_u32(np
, "migrate", &id
)) {
394 psci_function_id
[PSCI_FN_MIGRATE
] = id
;
395 psci_ops
.migrate
= psci_migrate
;
403 static const struct of_device_id psci_of_match
[] __initconst
= {
404 { .compatible
= "arm,psci", .data
= psci_0_1_init
},
405 { .compatible
= "arm,psci-0.2", .data
= psci_0_2_init
},
409 int __init
psci_dt_init(void)
411 struct device_node
*np
;
412 const struct of_device_id
*matched_np
;
413 psci_initcall_t init_fn
;
415 np
= of_find_matching_node_and_match(NULL
, psci_of_match
, &matched_np
);
420 init_fn
= (psci_initcall_t
)matched_np
->data
;
425 * We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's
426 * explicitly clarified in SBBR
428 int __init
psci_acpi_init(void)
430 if (!acpi_psci_present()) {
431 pr_info("is not implemented in ACPI.\n");
435 pr_info("probing for conduit method from ACPI.\n");
437 if (acpi_psci_use_hvc())
438 invoke_psci_fn
= __invoke_psci_fn_hvc
;
440 invoke_psci_fn
= __invoke_psci_fn_smc
;
442 psci_0_2_set_functions();
449 static int __init
cpu_psci_cpu_init(struct device_node
*dn
, unsigned int cpu
)
454 static int __init
cpu_psci_cpu_prepare(unsigned int cpu
)
456 if (!psci_ops
.cpu_on
) {
457 pr_err("no cpu_on method, not booting CPU%d\n", cpu
);
464 static int cpu_psci_cpu_boot(unsigned int cpu
)
466 int err
= psci_ops
.cpu_on(cpu_logical_map(cpu
), __pa(secondary_entry
));
468 pr_err("failed to boot CPU%d (%d)\n", cpu
, err
);
473 #ifdef CONFIG_HOTPLUG_CPU
474 static int cpu_psci_cpu_disable(unsigned int cpu
)
476 /* Fail early if we don't have CPU_OFF support */
477 if (!psci_ops
.cpu_off
)
482 static void cpu_psci_cpu_die(unsigned int cpu
)
486 * There are no known implementations of PSCI actually using the
487 * power state field, pass a sensible default for now.
489 struct psci_power_state state
= {
490 .type
= PSCI_POWER_STATE_TYPE_POWER_DOWN
,
493 ret
= psci_ops
.cpu_off(state
);
495 pr_crit("unable to power off CPU%u (%d)\n", cpu
, ret
);
498 static int cpu_psci_cpu_kill(unsigned int cpu
)
502 if (!psci_ops
.affinity_info
)
505 * cpu_kill could race with cpu_die and we can
506 * potentially end up declaring this cpu undead
507 * while it is dying. So, try again a few times.
510 for (i
= 0; i
< 10; i
++) {
511 err
= psci_ops
.affinity_info(cpu_logical_map(cpu
), 0);
512 if (err
== PSCI_0_2_AFFINITY_LEVEL_OFF
) {
513 pr_info("CPU%d killed.\n", cpu
);
518 pr_info("Retrying again to check for CPU kill\n");
521 pr_warn("CPU%d may not have shut down cleanly (AFFINITY_INFO reports %d)\n",
523 /* Make op_cpu_kill() fail. */
529 static int psci_suspend_finisher(unsigned long index
)
531 struct psci_power_state
*state
= __this_cpu_read(psci_power_state
);
533 return psci_ops
.cpu_suspend(state
[index
- 1],
534 virt_to_phys(cpu_resume
));
537 static int __maybe_unused
cpu_psci_cpu_suspend(unsigned long index
)
540 struct psci_power_state
*state
= __this_cpu_read(psci_power_state
);
542 * idle state index 0 corresponds to wfi, should never be called
543 * from the cpu_suspend operations
545 if (WARN_ON_ONCE(!index
))
548 if (state
[index
- 1].type
== PSCI_POWER_STATE_TYPE_STANDBY
)
549 ret
= psci_ops
.cpu_suspend(state
[index
- 1], 0);
551 ret
= __cpu_suspend(index
, psci_suspend_finisher
);
556 const struct cpu_operations cpu_psci_ops
= {
558 #ifdef CONFIG_CPU_IDLE
559 .cpu_init_idle
= cpu_psci_cpu_init_idle
,
560 .cpu_suspend
= cpu_psci_cpu_suspend
,
563 .cpu_init
= cpu_psci_cpu_init
,
564 .cpu_prepare
= cpu_psci_cpu_prepare
,
565 .cpu_boot
= cpu_psci_cpu_boot
,
566 #ifdef CONFIG_HOTPLUG_CPU
567 .cpu_disable
= cpu_psci_cpu_disable
,
568 .cpu_die
= cpu_psci_cpu_die
,
569 .cpu_kill
= cpu_psci_cpu_kill
,