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/init.h>
20 #include <linux/smp.h>
21 #include <linux/reboot.h>
23 #include <linux/delay.h>
24 #include <uapi/linux/psci.h>
26 #include <asm/compiler.h>
27 #include <asm/cpu_ops.h>
28 #include <asm/errno.h>
30 #include <asm/smp_plat.h>
31 #include <asm/system_misc.h>
33 #if 0 /* move to asm/psci.h for public export */
34 #define PSCI_POWER_STATE_TYPE_STANDBY 0
35 #define PSCI_POWER_STATE_TYPE_POWER_DOWN 1
37 struct psci_power_state
{
44 struct psci_operations
{
45 int (*cpu_suspend
)(struct psci_power_state state
,
46 unsigned long entry_point
);
47 int (*cpu_off
)(struct psci_power_state state
);
48 int (*cpu_on
)(unsigned long cpuid
, unsigned long entry_point
);
49 int (*migrate
)(unsigned long cpuid
);
50 int (*affinity_info
)(unsigned long target_affinity
,
51 unsigned long lowest_affinity_level
);
52 int (*migrate_info_type
)(void);
54 #endif //#if 0 /* move to asm/psci.h for public export */
56 struct psci_operations psci_ops
;
58 static int (*invoke_psci_fn
)(u64
, u64
, u64
, u64
);
59 typedef int (*psci_initcall_t
)(const struct device_node
*);
66 PSCI_FN_AFFINITY_INFO
,
67 PSCI_FN_MIGRATE_INFO_TYPE
,
71 static u32 psci_function_id
[PSCI_FN_MAX
];
73 static int psci_to_linux_errno(int errno
)
76 case PSCI_RET_SUCCESS
:
78 case PSCI_RET_NOT_SUPPORTED
:
80 case PSCI_RET_INVALID_PARAMS
:
89 static u32
psci_power_state_pack(struct psci_power_state state
)
91 return ((state
.id
<< PSCI_0_2_POWER_STATE_ID_SHIFT
)
92 & PSCI_0_2_POWER_STATE_ID_MASK
) |
93 ((state
.type
<< PSCI_0_2_POWER_STATE_TYPE_SHIFT
)
94 & PSCI_0_2_POWER_STATE_TYPE_MASK
) |
95 ((state
.affinity_level
<< PSCI_0_2_POWER_STATE_AFFL_SHIFT
)
96 & PSCI_0_2_POWER_STATE_AFFL_MASK
);
100 * The following two functions are invoked via the invoke_psci_fn pointer
101 * and will not be inlined, allowing us to piggyback on the AAPCS.
103 static noinline
int __invoke_psci_fn_hvc(u64 function_id
, u64 arg0
, u64 arg1
,
113 : "r" (arg0
), "r" (arg1
), "r" (arg2
));
118 static noinline
int __invoke_psci_fn_smc(u64 function_id
, u64 arg0
, u64 arg1
,
128 : "r" (arg0
), "r" (arg1
), "r" (arg2
));
133 static int psci_get_version(void)
137 err
= invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION
, 0, 0, 0);
141 static int psci_cpu_suspend(struct psci_power_state state
,
142 unsigned long entry_point
)
147 fn
= psci_function_id
[PSCI_FN_CPU_SUSPEND
];
148 power_state
= psci_power_state_pack(state
);
149 err
= invoke_psci_fn(fn
, power_state
, entry_point
, 0);
150 return psci_to_linux_errno(err
);
153 static int psci_cpu_off(struct psci_power_state state
)
158 fn
= psci_function_id
[PSCI_FN_CPU_OFF
];
159 power_state
= psci_power_state_pack(state
);
160 err
= invoke_psci_fn(fn
, power_state
, 0, 0);
161 return psci_to_linux_errno(err
);
164 static int psci_cpu_on(unsigned long cpuid
, unsigned long entry_point
)
169 fn
= psci_function_id
[PSCI_FN_CPU_ON
];
170 err
= invoke_psci_fn(fn
, cpuid
, entry_point
, 0);
171 return psci_to_linux_errno(err
);
174 static int psci_migrate(unsigned long cpuid
)
179 fn
= psci_function_id
[PSCI_FN_MIGRATE
];
180 err
= invoke_psci_fn(fn
, cpuid
, 0, 0);
181 return psci_to_linux_errno(err
);
184 static int psci_affinity_info(unsigned long target_affinity
,
185 unsigned long lowest_affinity_level
)
190 fn
= psci_function_id
[PSCI_FN_AFFINITY_INFO
];
191 err
= invoke_psci_fn(fn
, target_affinity
, lowest_affinity_level
, 0);
195 static int psci_migrate_info_type(void)
200 fn
= psci_function_id
[PSCI_FN_MIGRATE_INFO_TYPE
];
201 err
= invoke_psci_fn(fn
, 0, 0, 0);
205 static int get_set_conduit_method(struct device_node
*np
)
209 pr_info("probing for conduit method from DT.\n");
211 if (of_property_read_string(np
, "method", &method
)) {
212 pr_warn("missing \"method\" property\n");
216 if (!strcmp("hvc", method
)) {
217 invoke_psci_fn
= __invoke_psci_fn_hvc
;
218 } else if (!strcmp("smc", method
)) {
219 invoke_psci_fn
= __invoke_psci_fn_smc
;
221 pr_warn("invalid \"method\" property: %s\n", method
);
227 static void psci_sys_reset(enum reboot_mode reboot_mode
, const char *cmd
)
229 invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET
, 0, 0, 0);
232 static void psci_sys_poweroff(void)
234 invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF
, 0, 0, 0);
238 * PSCI Function IDs for v0.2+ are well defined so use
241 static int psci_0_2_init(struct device_node
*np
)
245 err
= get_set_conduit_method(np
);
250 ver
= psci_get_version();
252 if (ver
== PSCI_RET_NOT_SUPPORTED
) {
253 /* PSCI v0.2 mandates implementation of PSCI_ID_VERSION. */
254 pr_err("PSCI firmware does not comply with the v0.2 spec.\n");
258 pr_info("PSCIv%d.%d detected in firmware.\n",
259 PSCI_VERSION_MAJOR(ver
),
260 PSCI_VERSION_MINOR(ver
));
262 if (PSCI_VERSION_MAJOR(ver
) == 0 &&
263 PSCI_VERSION_MINOR(ver
) < 2) {
265 pr_err("Conflicting PSCI version detected.\n");
270 pr_info("Using standard PSCI v0.2 function IDs\n");
271 psci_function_id
[PSCI_FN_CPU_SUSPEND
] = PSCI_0_2_FN64_CPU_SUSPEND
;
272 psci_ops
.cpu_suspend
= psci_cpu_suspend
;
274 psci_function_id
[PSCI_FN_CPU_OFF
] = PSCI_0_2_FN_CPU_OFF
;
275 psci_ops
.cpu_off
= psci_cpu_off
;
277 psci_function_id
[PSCI_FN_CPU_ON
] = PSCI_0_2_FN64_CPU_ON
;
278 psci_ops
.cpu_on
= psci_cpu_on
;
280 psci_function_id
[PSCI_FN_MIGRATE
] = PSCI_0_2_FN64_MIGRATE
;
281 psci_ops
.migrate
= psci_migrate
;
283 psci_function_id
[PSCI_FN_AFFINITY_INFO
] = PSCI_0_2_FN64_AFFINITY_INFO
;
284 psci_ops
.affinity_info
= psci_affinity_info
;
286 psci_function_id
[PSCI_FN_MIGRATE_INFO_TYPE
] =
287 PSCI_0_2_FN_MIGRATE_INFO_TYPE
;
288 psci_ops
.migrate_info_type
= psci_migrate_info_type
;
290 arm_pm_restart
= psci_sys_reset
;
292 pm_power_off
= psci_sys_poweroff
;
300 * PSCI < v0.2 get PSCI Function IDs via DT.
302 static int psci_0_1_init(struct device_node
*np
)
307 err
= get_set_conduit_method(np
);
312 pr_info("Using PSCI v0.1 Function IDs from DT\n");
314 if (!of_property_read_u32(np
, "cpu_suspend", &id
)) {
315 psci_function_id
[PSCI_FN_CPU_SUSPEND
] = id
;
316 psci_ops
.cpu_suspend
= psci_cpu_suspend
;
319 if (!of_property_read_u32(np
, "cpu_off", &id
)) {
320 psci_function_id
[PSCI_FN_CPU_OFF
] = id
;
321 psci_ops
.cpu_off
= psci_cpu_off
;
324 if (!of_property_read_u32(np
, "cpu_on", &id
)) {
325 psci_function_id
[PSCI_FN_CPU_ON
] = id
;
326 psci_ops
.cpu_on
= psci_cpu_on
;
329 if (!of_property_read_u32(np
, "migrate", &id
)) {
330 psci_function_id
[PSCI_FN_MIGRATE
] = id
;
331 psci_ops
.migrate
= psci_migrate
;
339 static const struct of_device_id psci_of_match
[] __initconst
= {
340 { .compatible
= "arm,psci", .data
= psci_0_1_init
},
341 { .compatible
= "arm,psci-0.2", .data
= psci_0_2_init
},
345 int __init
psci_init(void)
347 struct device_node
*np
;
348 const struct of_device_id
*matched_np
;
349 psci_initcall_t init_fn
;
351 np
= of_find_matching_node_and_match(NULL
, psci_of_match
, &matched_np
);
356 init_fn
= (psci_initcall_t
)matched_np
->data
;
362 static int __init
cpu_psci_cpu_init(struct device_node
*dn
, unsigned int cpu
)
367 static int __init
cpu_psci_cpu_prepare(unsigned int cpu
)
369 if (!psci_ops
.cpu_on
) {
370 pr_err("no cpu_on method, not booting CPU%d\n", cpu
);
377 static int cpu_psci_cpu_boot(unsigned int cpu
)
379 int err
= psci_ops
.cpu_on(cpu_logical_map(cpu
), __pa(secondary_entry
));
381 pr_err("failed to boot CPU%d (%d)\n", cpu
, err
);
386 #ifdef CONFIG_HOTPLUG_CPU
387 static int cpu_psci_cpu_disable(unsigned int cpu
)
389 /* Fail early if we don't have CPU_OFF support */
390 if (!psci_ops
.cpu_off
)
395 static void cpu_psci_cpu_die(unsigned int cpu
)
399 * There are no known implementations of PSCI actually using the
400 * power state field, pass a sensible default for now.
402 struct psci_power_state state
= {
403 .type
= PSCI_POWER_STATE_TYPE_POWER_DOWN
,
406 ret
= psci_ops
.cpu_off(state
);
408 pr_crit("unable to power off CPU%u (%d)\n", cpu
, ret
);
411 static int cpu_psci_cpu_kill(unsigned int cpu
)
415 if (!psci_ops
.affinity_info
)
418 * cpu_kill could race with cpu_die and we can
419 * potentially end up declaring this cpu undead
420 * while it is dying. So, try again a few times.
423 for (i
= 0; i
< 10; i
++) {
424 err
= psci_ops
.affinity_info(cpu_logical_map(cpu
), 0);
425 if (err
== PSCI_0_2_AFFINITY_LEVEL_OFF
) {
426 pr_info("CPU%d killed.\n", cpu
);
431 pr_info("Retrying again to check for CPU kill\n");
434 pr_warn("CPU%d may not have shut down cleanly (AFFINITY_INFO reports %d)\n",
436 /* Make op_cpu_kill() fail. */
441 const struct cpu_operations cpu_psci_ops
= {
443 .cpu_init
= cpu_psci_cpu_init
,
444 .cpu_prepare
= cpu_psci_cpu_prepare
,
445 .cpu_boot
= cpu_psci_cpu_boot
,
446 #ifdef CONFIG_HOTPLUG_CPU
447 .cpu_disable
= cpu_psci_cpu_disable
,
448 .cpu_die
= cpu_psci_cpu_die
,
449 .cpu_kill
= cpu_psci_cpu_kill
,