1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * |
4 | * Copyright (C) 2015 ARM Limited |
5 | */ |
6 | |
7 | #define pr_fmt(fmt) "psci: " fmt |
8 | |
9 | #include <linux/acpi.h> |
10 | #include <linux/arm-smccc.h> |
11 | #include <linux/cpuidle.h> |
12 | #include <linux/debugfs.h> |
13 | #include <linux/errno.h> |
14 | #include <linux/linkage.h> |
15 | #include <linux/of.h> |
16 | #include <linux/pm.h> |
17 | #include <linux/printk.h> |
18 | #include <linux/psci.h> |
19 | #include <linux/reboot.h> |
20 | #include <linux/slab.h> |
21 | #include <linux/suspend.h> |
22 | |
23 | #include <uapi/linux/psci.h> |
24 | |
25 | #include <asm/cpuidle.h> |
26 | #include <asm/cputype.h> |
27 | #include <asm/hypervisor.h> |
28 | #include <asm/system_misc.h> |
29 | #include <asm/smp_plat.h> |
30 | #include <asm/suspend.h> |
31 | |
32 | /* |
33 | * While a 64-bit OS can make calls with SMC32 calling conventions, for some |
34 | * calls it is necessary to use SMC64 to pass or return 64-bit values. |
35 | * For such calls PSCI_FN_NATIVE(version, name) will choose the appropriate |
36 | * (native-width) function ID. |
37 | */ |
38 | #ifdef CONFIG_64BIT |
39 | #define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN64_##name |
40 | #else |
41 | #define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN_##name |
42 | #endif |
43 | |
44 | /* |
45 | * The CPU any Trusted OS is resident on. The trusted OS may reject CPU_OFF |
46 | * calls to its resident CPU, so we must avoid issuing those. We never migrate |
47 | * a Trusted OS even if it claims to be capable of migration -- doing so will |
48 | * require cooperation with a Trusted OS driver. |
49 | */ |
50 | static int resident_cpu = -1; |
51 | struct psci_operations psci_ops; |
52 | static enum arm_smccc_conduit psci_conduit = SMCCC_CONDUIT_NONE; |
53 | |
54 | bool psci_tos_resident_on(int cpu) |
55 | { |
56 | return cpu == resident_cpu; |
57 | } |
58 | |
59 | typedef unsigned long (psci_fn)(unsigned long, unsigned long, |
60 | unsigned long, unsigned long); |
61 | static psci_fn *invoke_psci_fn; |
62 | |
63 | static struct psci_0_1_function_ids psci_0_1_function_ids; |
64 | |
65 | struct psci_0_1_function_ids get_psci_0_1_function_ids(void) |
66 | { |
67 | return psci_0_1_function_ids; |
68 | } |
69 | |
70 | #define PSCI_0_2_POWER_STATE_MASK \ |
71 | (PSCI_0_2_POWER_STATE_ID_MASK | \ |
72 | PSCI_0_2_POWER_STATE_TYPE_MASK | \ |
73 | PSCI_0_2_POWER_STATE_AFFL_MASK) |
74 | |
75 | #define PSCI_1_0_EXT_POWER_STATE_MASK \ |
76 | (PSCI_1_0_EXT_POWER_STATE_ID_MASK | \ |
77 | PSCI_1_0_EXT_POWER_STATE_TYPE_MASK) |
78 | |
79 | static u32 psci_cpu_suspend_feature; |
80 | static bool psci_system_reset2_supported; |
81 | |
82 | static inline bool psci_has_ext_power_state(void) |
83 | { |
84 | return psci_cpu_suspend_feature & |
85 | PSCI_1_0_FEATURES_CPU_SUSPEND_PF_MASK; |
86 | } |
87 | |
88 | bool psci_has_osi_support(void) |
89 | { |
90 | return psci_cpu_suspend_feature & PSCI_1_0_OS_INITIATED; |
91 | } |
92 | |
93 | static inline bool psci_power_state_loses_context(u32 state) |
94 | { |
95 | const u32 mask = psci_has_ext_power_state() ? |
96 | PSCI_1_0_EXT_POWER_STATE_TYPE_MASK : |
97 | PSCI_0_2_POWER_STATE_TYPE_MASK; |
98 | |
99 | return state & mask; |
100 | } |
101 | |
102 | bool psci_power_state_is_valid(u32 state) |
103 | { |
104 | const u32 valid_mask = psci_has_ext_power_state() ? |
105 | PSCI_1_0_EXT_POWER_STATE_MASK : |
106 | PSCI_0_2_POWER_STATE_MASK; |
107 | |
108 | return !(state & ~valid_mask); |
109 | } |
110 | |
111 | static __always_inline unsigned long |
112 | __invoke_psci_fn_hvc(unsigned long function_id, |
113 | unsigned long arg0, unsigned long arg1, |
114 | unsigned long arg2) |
115 | { |
116 | struct arm_smccc_res res; |
117 | |
118 | arm_smccc_hvc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res); |
119 | return res.a0; |
120 | } |
121 | |
122 | static __always_inline unsigned long |
123 | __invoke_psci_fn_smc(unsigned long function_id, |
124 | unsigned long arg0, unsigned long arg1, |
125 | unsigned long arg2) |
126 | { |
127 | struct arm_smccc_res res; |
128 | |
129 | arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res); |
130 | return res.a0; |
131 | } |
132 | |
133 | static __always_inline int psci_to_linux_errno(int errno) |
134 | { |
135 | switch (errno) { |
136 | case PSCI_RET_SUCCESS: |
137 | return 0; |
138 | case PSCI_RET_NOT_SUPPORTED: |
139 | return -EOPNOTSUPP; |
140 | case PSCI_RET_INVALID_PARAMS: |
141 | case PSCI_RET_INVALID_ADDRESS: |
142 | return -EINVAL; |
143 | case PSCI_RET_DENIED: |
144 | return -EPERM; |
145 | } |
146 | |
147 | return -EINVAL; |
148 | } |
149 | |
150 | static u32 psci_0_1_get_version(void) |
151 | { |
152 | return PSCI_VERSION(0, 1); |
153 | } |
154 | |
155 | static u32 psci_0_2_get_version(void) |
156 | { |
157 | return invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0); |
158 | } |
159 | |
160 | int psci_set_osi_mode(bool enable) |
161 | { |
162 | unsigned long suspend_mode; |
163 | int err; |
164 | |
165 | suspend_mode = enable ? PSCI_1_0_SUSPEND_MODE_OSI : |
166 | PSCI_1_0_SUSPEND_MODE_PC; |
167 | |
168 | err = invoke_psci_fn(PSCI_1_0_FN_SET_SUSPEND_MODE, suspend_mode, 0, 0); |
169 | if (err < 0) |
170 | pr_info(FW_BUG "failed to set %s mode: %d\n" , |
171 | enable ? "OSI" : "PC" , err); |
172 | return psci_to_linux_errno(errno: err); |
173 | } |
174 | |
175 | static __always_inline int |
176 | __psci_cpu_suspend(u32 fn, u32 state, unsigned long entry_point) |
177 | { |
178 | int err; |
179 | |
180 | err = invoke_psci_fn(fn, state, entry_point, 0); |
181 | return psci_to_linux_errno(errno: err); |
182 | } |
183 | |
184 | static __always_inline int |
185 | psci_0_1_cpu_suspend(u32 state, unsigned long entry_point) |
186 | { |
187 | return __psci_cpu_suspend(fn: psci_0_1_function_ids.cpu_suspend, |
188 | state, entry_point); |
189 | } |
190 | |
191 | static __always_inline int |
192 | psci_0_2_cpu_suspend(u32 state, unsigned long entry_point) |
193 | { |
194 | return __psci_cpu_suspend(PSCI_FN_NATIVE(0_2, CPU_SUSPEND), |
195 | state, entry_point); |
196 | } |
197 | |
198 | static int __psci_cpu_off(u32 fn, u32 state) |
199 | { |
200 | int err; |
201 | |
202 | err = invoke_psci_fn(fn, state, 0, 0); |
203 | return psci_to_linux_errno(errno: err); |
204 | } |
205 | |
206 | static int psci_0_1_cpu_off(u32 state) |
207 | { |
208 | return __psci_cpu_off(fn: psci_0_1_function_ids.cpu_off, state); |
209 | } |
210 | |
211 | static int psci_0_2_cpu_off(u32 state) |
212 | { |
213 | return __psci_cpu_off(PSCI_0_2_FN_CPU_OFF, state); |
214 | } |
215 | |
216 | static int __psci_cpu_on(u32 fn, unsigned long cpuid, unsigned long entry_point) |
217 | { |
218 | int err; |
219 | |
220 | err = invoke_psci_fn(fn, cpuid, entry_point, 0); |
221 | return psci_to_linux_errno(errno: err); |
222 | } |
223 | |
224 | static int psci_0_1_cpu_on(unsigned long cpuid, unsigned long entry_point) |
225 | { |
226 | return __psci_cpu_on(fn: psci_0_1_function_ids.cpu_on, cpuid, entry_point); |
227 | } |
228 | |
229 | static int psci_0_2_cpu_on(unsigned long cpuid, unsigned long entry_point) |
230 | { |
231 | return __psci_cpu_on(PSCI_FN_NATIVE(0_2, CPU_ON), cpuid, entry_point); |
232 | } |
233 | |
234 | static int __psci_migrate(u32 fn, unsigned long cpuid) |
235 | { |
236 | int err; |
237 | |
238 | err = invoke_psci_fn(fn, cpuid, 0, 0); |
239 | return psci_to_linux_errno(errno: err); |
240 | } |
241 | |
242 | static int psci_0_1_migrate(unsigned long cpuid) |
243 | { |
244 | return __psci_migrate(fn: psci_0_1_function_ids.migrate, cpuid); |
245 | } |
246 | |
247 | static int psci_0_2_migrate(unsigned long cpuid) |
248 | { |
249 | return __psci_migrate(PSCI_FN_NATIVE(0_2, MIGRATE), cpuid); |
250 | } |
251 | |
252 | static int psci_affinity_info(unsigned long target_affinity, |
253 | unsigned long lowest_affinity_level) |
254 | { |
255 | return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO), |
256 | target_affinity, lowest_affinity_level, 0); |
257 | } |
258 | |
259 | static int psci_migrate_info_type(void) |
260 | { |
261 | return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0); |
262 | } |
263 | |
264 | static unsigned long psci_migrate_info_up_cpu(void) |
265 | { |
266 | return invoke_psci_fn(PSCI_FN_NATIVE(0_2, MIGRATE_INFO_UP_CPU), |
267 | 0, 0, 0); |
268 | } |
269 | |
270 | static void set_conduit(enum arm_smccc_conduit conduit) |
271 | { |
272 | switch (conduit) { |
273 | case SMCCC_CONDUIT_HVC: |
274 | invoke_psci_fn = __invoke_psci_fn_hvc; |
275 | break; |
276 | case SMCCC_CONDUIT_SMC: |
277 | invoke_psci_fn = __invoke_psci_fn_smc; |
278 | break; |
279 | default: |
280 | WARN(1, "Unexpected PSCI conduit %d\n" , conduit); |
281 | } |
282 | |
283 | psci_conduit = conduit; |
284 | } |
285 | |
286 | static int get_set_conduit_method(const struct device_node *np) |
287 | { |
288 | const char *method; |
289 | |
290 | pr_info("probing for conduit method from DT.\n" ); |
291 | |
292 | if (of_property_read_string(np, propname: "method" , out_string: &method)) { |
293 | pr_warn("missing \"method\" property\n" ); |
294 | return -ENXIO; |
295 | } |
296 | |
297 | if (!strcmp("hvc" , method)) { |
298 | set_conduit(SMCCC_CONDUIT_HVC); |
299 | } else if (!strcmp("smc" , method)) { |
300 | set_conduit(SMCCC_CONDUIT_SMC); |
301 | } else { |
302 | pr_warn("invalid \"method\" property: %s\n" , method); |
303 | return -EINVAL; |
304 | } |
305 | return 0; |
306 | } |
307 | |
308 | static int psci_sys_reset(struct notifier_block *nb, unsigned long action, |
309 | void *data) |
310 | { |
311 | if ((reboot_mode == REBOOT_WARM || reboot_mode == REBOOT_SOFT) && |
312 | psci_system_reset2_supported) { |
313 | /* |
314 | * reset_type[31] = 0 (architectural) |
315 | * reset_type[30:0] = 0 (SYSTEM_WARM_RESET) |
316 | * cookie = 0 (ignored by the implementation) |
317 | */ |
318 | invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), 0, 0, 0); |
319 | } else { |
320 | invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0); |
321 | } |
322 | |
323 | return NOTIFY_DONE; |
324 | } |
325 | |
326 | static struct notifier_block psci_sys_reset_nb = { |
327 | .notifier_call = psci_sys_reset, |
328 | .priority = 129, |
329 | }; |
330 | |
331 | static void psci_sys_poweroff(void) |
332 | { |
333 | invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0); |
334 | } |
335 | |
336 | static int psci_features(u32 psci_func_id) |
337 | { |
338 | return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES, |
339 | psci_func_id, 0, 0); |
340 | } |
341 | |
342 | #ifdef CONFIG_DEBUG_FS |
343 | |
344 | #define PSCI_ID(ver, _name) \ |
345 | { .fn = PSCI_##ver##_FN_##_name, .name = #_name, } |
346 | #define PSCI_ID_NATIVE(ver, _name) \ |
347 | { .fn = PSCI_FN_NATIVE(ver, _name), .name = #_name, } |
348 | |
349 | /* A table of all optional functions */ |
350 | static const struct { |
351 | u32 fn; |
352 | const char *name; |
353 | } psci_fn_ids[] = { |
354 | PSCI_ID_NATIVE(0_2, MIGRATE), |
355 | PSCI_ID(0_2, MIGRATE_INFO_TYPE), |
356 | PSCI_ID_NATIVE(0_2, MIGRATE_INFO_UP_CPU), |
357 | PSCI_ID(1_0, CPU_FREEZE), |
358 | PSCI_ID_NATIVE(1_0, CPU_DEFAULT_SUSPEND), |
359 | PSCI_ID_NATIVE(1_0, NODE_HW_STATE), |
360 | PSCI_ID_NATIVE(1_0, SYSTEM_SUSPEND), |
361 | PSCI_ID(1_0, SET_SUSPEND_MODE), |
362 | PSCI_ID_NATIVE(1_0, STAT_RESIDENCY), |
363 | PSCI_ID_NATIVE(1_0, STAT_COUNT), |
364 | PSCI_ID_NATIVE(1_1, SYSTEM_RESET2), |
365 | PSCI_ID(1_1, MEM_PROTECT), |
366 | PSCI_ID_NATIVE(1_1, MEM_PROTECT_CHECK_RANGE), |
367 | }; |
368 | |
369 | static int psci_debugfs_read(struct seq_file *s, void *data) |
370 | { |
371 | int feature, type, i; |
372 | u32 ver; |
373 | |
374 | ver = psci_ops.get_version(); |
375 | seq_printf(m: s, fmt: "PSCIv%d.%d\n" , |
376 | PSCI_VERSION_MAJOR(ver), |
377 | PSCI_VERSION_MINOR(ver)); |
378 | |
379 | /* PSCI_FEATURES is available only starting from 1.0 */ |
380 | if (PSCI_VERSION_MAJOR(ver) < 1) |
381 | return 0; |
382 | |
383 | feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID); |
384 | if (feature != PSCI_RET_NOT_SUPPORTED) { |
385 | ver = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0); |
386 | seq_printf(m: s, fmt: "SMC Calling Convention v%d.%d\n" , |
387 | PSCI_VERSION_MAJOR(ver), |
388 | PSCI_VERSION_MINOR(ver)); |
389 | } else { |
390 | seq_puts(m: s, s: "SMC Calling Convention v1.0 is assumed\n" ); |
391 | } |
392 | |
393 | feature = psci_features(PSCI_FN_NATIVE(0_2, CPU_SUSPEND)); |
394 | if (feature < 0) { |
395 | seq_printf(m: s, fmt: "PSCI_FEATURES(CPU_SUSPEND) error (%d)\n" , feature); |
396 | } else { |
397 | seq_printf(m: s, fmt: "OSI is %ssupported\n" , |
398 | (feature & BIT(0)) ? "" : "not " ); |
399 | seq_printf(m: s, fmt: "%s StateID format is used\n" , |
400 | (feature & BIT(1)) ? "Extended" : "Original" ); |
401 | } |
402 | |
403 | type = psci_ops.migrate_info_type(); |
404 | if (type == PSCI_0_2_TOS_UP_MIGRATE || |
405 | type == PSCI_0_2_TOS_UP_NO_MIGRATE) { |
406 | unsigned long cpuid; |
407 | |
408 | seq_printf(m: s, fmt: "Trusted OS %smigrate capable\n" , |
409 | type == PSCI_0_2_TOS_UP_NO_MIGRATE ? "not " : "" ); |
410 | cpuid = psci_migrate_info_up_cpu(); |
411 | seq_printf(m: s, fmt: "Trusted OS resident on physical CPU 0x%lx (#%d)\n" , |
412 | cpuid, resident_cpu); |
413 | } else if (type == PSCI_0_2_TOS_MP) { |
414 | seq_puts(m: s, s: "Trusted OS migration not required\n" ); |
415 | } else { |
416 | if (type != PSCI_RET_NOT_SUPPORTED) |
417 | seq_printf(m: s, fmt: "MIGRATE_INFO_TYPE returned unknown type (%d)\n" , type); |
418 | } |
419 | |
420 | for (i = 0; i < ARRAY_SIZE(psci_fn_ids); i++) { |
421 | feature = psci_features(psci_func_id: psci_fn_ids[i].fn); |
422 | if (feature == PSCI_RET_NOT_SUPPORTED) |
423 | continue; |
424 | if (feature < 0) |
425 | seq_printf(m: s, fmt: "PSCI_FEATURES(%s) error (%d)\n" , |
426 | psci_fn_ids[i].name, feature); |
427 | else |
428 | seq_printf(m: s, fmt: "%s is supported\n" , psci_fn_ids[i].name); |
429 | } |
430 | |
431 | return 0; |
432 | } |
433 | |
434 | static int psci_debugfs_open(struct inode *inode, struct file *f) |
435 | { |
436 | return single_open(f, psci_debugfs_read, NULL); |
437 | } |
438 | |
439 | static const struct file_operations psci_debugfs_ops = { |
440 | .owner = THIS_MODULE, |
441 | .open = psci_debugfs_open, |
442 | .release = single_release, |
443 | .read = seq_read, |
444 | .llseek = seq_lseek |
445 | }; |
446 | |
447 | static int __init psci_debugfs_init(void) |
448 | { |
449 | if (!invoke_psci_fn || !psci_ops.get_version) |
450 | return 0; |
451 | |
452 | return PTR_ERR_OR_ZERO(ptr: debugfs_create_file(name: "psci" , mode: 0444, NULL, NULL, |
453 | fops: &psci_debugfs_ops)); |
454 | } |
455 | late_initcall(psci_debugfs_init) |
456 | #endif |
457 | |
458 | #ifdef CONFIG_CPU_IDLE |
459 | static noinstr int psci_suspend_finisher(unsigned long state) |
460 | { |
461 | u32 power_state = state; |
462 | phys_addr_t pa_cpu_resume; |
463 | |
464 | pa_cpu_resume = __pa_symbol_nodebug((unsigned long)cpu_resume); |
465 | |
466 | return psci_ops.cpu_suspend(power_state, pa_cpu_resume); |
467 | } |
468 | |
469 | int psci_cpu_suspend_enter(u32 state) |
470 | { |
471 | int ret; |
472 | |
473 | if (!psci_power_state_loses_context(state)) { |
474 | struct arm_cpuidle_irq_context context; |
475 | |
476 | ct_cpuidle_enter(); |
477 | arm_cpuidle_save_irq_context(&context); |
478 | ret = psci_ops.cpu_suspend(state, 0); |
479 | arm_cpuidle_restore_irq_context(&context); |
480 | ct_cpuidle_exit(); |
481 | } else { |
482 | /* |
483 | * ARM64 cpu_suspend() wants to do ct_cpuidle_*() itself. |
484 | */ |
485 | if (!IS_ENABLED(CONFIG_ARM64)) |
486 | ct_cpuidle_enter(); |
487 | |
488 | ret = cpu_suspend(state, psci_suspend_finisher); |
489 | |
490 | if (!IS_ENABLED(CONFIG_ARM64)) |
491 | ct_cpuidle_exit(); |
492 | } |
493 | |
494 | return ret; |
495 | } |
496 | #endif |
497 | |
498 | static int psci_system_suspend(unsigned long unused) |
499 | { |
500 | phys_addr_t pa_cpu_resume = __pa_symbol(cpu_resume); |
501 | |
502 | return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND), |
503 | pa_cpu_resume, 0, 0); |
504 | } |
505 | |
506 | static int psci_system_suspend_enter(suspend_state_t state) |
507 | { |
508 | return cpu_suspend(0, psci_system_suspend); |
509 | } |
510 | |
511 | static const struct platform_suspend_ops psci_suspend_ops = { |
512 | .valid = suspend_valid_only_mem, |
513 | .enter = psci_system_suspend_enter, |
514 | }; |
515 | |
516 | static void __init psci_init_system_reset2(void) |
517 | { |
518 | int ret; |
519 | |
520 | ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2)); |
521 | |
522 | if (ret != PSCI_RET_NOT_SUPPORTED) |
523 | psci_system_reset2_supported = true; |
524 | } |
525 | |
526 | static void __init psci_init_system_suspend(void) |
527 | { |
528 | int ret; |
529 | |
530 | if (!IS_ENABLED(CONFIG_SUSPEND)) |
531 | return; |
532 | |
533 | ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND)); |
534 | |
535 | if (ret != PSCI_RET_NOT_SUPPORTED) |
536 | suspend_set_ops(ops: &psci_suspend_ops); |
537 | } |
538 | |
539 | static void __init psci_init_cpu_suspend(void) |
540 | { |
541 | int feature = psci_features(PSCI_FN_NATIVE(0_2, CPU_SUSPEND)); |
542 | |
543 | if (feature != PSCI_RET_NOT_SUPPORTED) |
544 | psci_cpu_suspend_feature = feature; |
545 | } |
546 | |
547 | /* |
548 | * Detect the presence of a resident Trusted OS which may cause CPU_OFF to |
549 | * return DENIED (which would be fatal). |
550 | */ |
551 | static void __init psci_init_migrate(void) |
552 | { |
553 | unsigned long cpuid; |
554 | int type, cpu = -1; |
555 | |
556 | type = psci_ops.migrate_info_type(); |
557 | |
558 | if (type == PSCI_0_2_TOS_MP) { |
559 | pr_info("Trusted OS migration not required\n" ); |
560 | return; |
561 | } |
562 | |
563 | if (type == PSCI_RET_NOT_SUPPORTED) { |
564 | pr_info("MIGRATE_INFO_TYPE not supported.\n" ); |
565 | return; |
566 | } |
567 | |
568 | if (type != PSCI_0_2_TOS_UP_MIGRATE && |
569 | type != PSCI_0_2_TOS_UP_NO_MIGRATE) { |
570 | pr_err("MIGRATE_INFO_TYPE returned unknown type (%d)\n" , type); |
571 | return; |
572 | } |
573 | |
574 | cpuid = psci_migrate_info_up_cpu(); |
575 | if (cpuid & ~MPIDR_HWID_BITMASK) { |
576 | pr_warn("MIGRATE_INFO_UP_CPU reported invalid physical ID (0x%lx)\n" , |
577 | cpuid); |
578 | return; |
579 | } |
580 | |
581 | cpu = get_logical_index(cpuid); |
582 | resident_cpu = cpu >= 0 ? cpu : -1; |
583 | |
584 | pr_info("Trusted OS resident on physical CPU 0x%lx\n" , cpuid); |
585 | } |
586 | |
587 | static void __init psci_init_smccc(void) |
588 | { |
589 | u32 ver = ARM_SMCCC_VERSION_1_0; |
590 | int feature; |
591 | |
592 | feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID); |
593 | |
594 | if (feature != PSCI_RET_NOT_SUPPORTED) { |
595 | u32 ret; |
596 | ret = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0); |
597 | if (ret >= ARM_SMCCC_VERSION_1_1) { |
598 | arm_smccc_version_init(version: ret, conduit: psci_conduit); |
599 | ver = ret; |
600 | } |
601 | } |
602 | |
603 | /* |
604 | * Conveniently, the SMCCC and PSCI versions are encoded the |
605 | * same way. No, this isn't accidental. |
606 | */ |
607 | pr_info("SMC Calling Convention v%d.%d\n" , |
608 | PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver)); |
609 | |
610 | } |
611 | |
612 | static void __init psci_0_2_set_functions(void) |
613 | { |
614 | pr_info("Using standard PSCI v0.2 function IDs\n" ); |
615 | |
616 | psci_ops = (struct psci_operations){ |
617 | .get_version = psci_0_2_get_version, |
618 | .cpu_suspend = psci_0_2_cpu_suspend, |
619 | .cpu_off = psci_0_2_cpu_off, |
620 | .cpu_on = psci_0_2_cpu_on, |
621 | .migrate = psci_0_2_migrate, |
622 | .affinity_info = psci_affinity_info, |
623 | .migrate_info_type = psci_migrate_info_type, |
624 | }; |
625 | |
626 | register_restart_handler(&psci_sys_reset_nb); |
627 | |
628 | pm_power_off = psci_sys_poweroff; |
629 | } |
630 | |
631 | /* |
632 | * Probe function for PSCI firmware versions >= 0.2 |
633 | */ |
634 | static int __init psci_probe(void) |
635 | { |
636 | u32 ver = psci_0_2_get_version(); |
637 | |
638 | pr_info("PSCIv%d.%d detected in firmware.\n" , |
639 | PSCI_VERSION_MAJOR(ver), |
640 | PSCI_VERSION_MINOR(ver)); |
641 | |
642 | if (PSCI_VERSION_MAJOR(ver) == 0 && PSCI_VERSION_MINOR(ver) < 2) { |
643 | pr_err("Conflicting PSCI version detected.\n" ); |
644 | return -EINVAL; |
645 | } |
646 | |
647 | psci_0_2_set_functions(); |
648 | |
649 | psci_init_migrate(); |
650 | |
651 | if (PSCI_VERSION_MAJOR(ver) >= 1) { |
652 | psci_init_smccc(); |
653 | psci_init_cpu_suspend(); |
654 | psci_init_system_suspend(); |
655 | psci_init_system_reset2(); |
656 | kvm_init_hyp_services(); |
657 | } |
658 | |
659 | return 0; |
660 | } |
661 | |
662 | typedef int (*psci_initcall_t)(const struct device_node *); |
663 | |
664 | /* |
665 | * PSCI init function for PSCI versions >=0.2 |
666 | * |
667 | * Probe based on PSCI PSCI_VERSION function |
668 | */ |
669 | static int __init psci_0_2_init(const struct device_node *np) |
670 | { |
671 | int err; |
672 | |
673 | err = get_set_conduit_method(np); |
674 | if (err) |
675 | return err; |
676 | |
677 | /* |
678 | * Starting with v0.2, the PSCI specification introduced a call |
679 | * (PSCI_VERSION) that allows probing the firmware version, so |
680 | * that PSCI function IDs and version specific initialization |
681 | * can be carried out according to the specific version reported |
682 | * by firmware |
683 | */ |
684 | return psci_probe(); |
685 | } |
686 | |
687 | /* |
688 | * PSCI < v0.2 get PSCI Function IDs via DT. |
689 | */ |
690 | static int __init psci_0_1_init(const struct device_node *np) |
691 | { |
692 | u32 id; |
693 | int err; |
694 | |
695 | err = get_set_conduit_method(np); |
696 | if (err) |
697 | return err; |
698 | |
699 | pr_info("Using PSCI v0.1 Function IDs from DT\n" ); |
700 | |
701 | psci_ops.get_version = psci_0_1_get_version; |
702 | |
703 | if (!of_property_read_u32(np, propname: "cpu_suspend" , out_value: &id)) { |
704 | psci_0_1_function_ids.cpu_suspend = id; |
705 | psci_ops.cpu_suspend = psci_0_1_cpu_suspend; |
706 | } |
707 | |
708 | if (!of_property_read_u32(np, propname: "cpu_off" , out_value: &id)) { |
709 | psci_0_1_function_ids.cpu_off = id; |
710 | psci_ops.cpu_off = psci_0_1_cpu_off; |
711 | } |
712 | |
713 | if (!of_property_read_u32(np, propname: "cpu_on" , out_value: &id)) { |
714 | psci_0_1_function_ids.cpu_on = id; |
715 | psci_ops.cpu_on = psci_0_1_cpu_on; |
716 | } |
717 | |
718 | if (!of_property_read_u32(np, propname: "migrate" , out_value: &id)) { |
719 | psci_0_1_function_ids.migrate = id; |
720 | psci_ops.migrate = psci_0_1_migrate; |
721 | } |
722 | |
723 | return 0; |
724 | } |
725 | |
726 | static int __init psci_1_0_init(const struct device_node *np) |
727 | { |
728 | int err; |
729 | |
730 | err = psci_0_2_init(np); |
731 | if (err) |
732 | return err; |
733 | |
734 | if (psci_has_osi_support()) { |
735 | pr_info("OSI mode supported.\n" ); |
736 | |
737 | /* Default to PC mode. */ |
738 | psci_set_osi_mode(enable: false); |
739 | } |
740 | |
741 | return 0; |
742 | } |
743 | |
744 | static const struct of_device_id psci_of_match[] __initconst = { |
745 | { .compatible = "arm,psci" , .data = psci_0_1_init}, |
746 | { .compatible = "arm,psci-0.2" , .data = psci_0_2_init}, |
747 | { .compatible = "arm,psci-1.0" , .data = psci_1_0_init}, |
748 | {}, |
749 | }; |
750 | |
751 | int __init psci_dt_init(void) |
752 | { |
753 | struct device_node *np; |
754 | const struct of_device_id *matched_np; |
755 | psci_initcall_t init_fn; |
756 | int ret; |
757 | |
758 | np = of_find_matching_node_and_match(NULL, matches: psci_of_match, match: &matched_np); |
759 | |
760 | if (!np || !of_device_is_available(device: np)) |
761 | return -ENODEV; |
762 | |
763 | init_fn = (psci_initcall_t)matched_np->data; |
764 | ret = init_fn(np); |
765 | |
766 | of_node_put(node: np); |
767 | return ret; |
768 | } |
769 | |
770 | #ifdef CONFIG_ACPI |
771 | /* |
772 | * We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's |
773 | * explicitly clarified in SBBR |
774 | */ |
775 | int __init psci_acpi_init(void) |
776 | { |
777 | if (!acpi_psci_present()) { |
778 | pr_info("is not implemented in ACPI.\n" ); |
779 | return -EOPNOTSUPP; |
780 | } |
781 | |
782 | pr_info("probing for conduit method from ACPI.\n" ); |
783 | |
784 | if (acpi_psci_use_hvc()) |
785 | set_conduit(SMCCC_CONDUIT_HVC); |
786 | else |
787 | set_conduit(SMCCC_CONDUIT_SMC); |
788 | |
789 | return psci_probe(); |
790 | } |
791 | #endif |
792 | |