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/errno.h>
 13#include <linux/linkage.h>
 14#include <linux/of.h>
 15#include <linux/pm.h>
 16#include <linux/printk.h>
 17#include <linux/psci.h>
 18#include <linux/reboot.h>
 19#include <linux/slab.h>
 20#include <linux/suspend.h>
 21
 22#include <uapi/linux/psci.h>
 23
 24#include <asm/cpuidle.h>
 25#include <asm/cputype.h>
 26#include <asm/system_misc.h>
 27#include <asm/smp_plat.h>
 28#include <asm/suspend.h>
 29
 30/*
 31 * While a 64-bit OS can make calls with SMC32 calling conventions, for some
 32 * calls it is necessary to use SMC64 to pass or return 64-bit values.
 33 * For such calls PSCI_FN_NATIVE(version, name) will choose the appropriate
 34 * (native-width) function ID.
 35 */
 36#ifdef CONFIG_64BIT
 37#define PSCI_FN_NATIVE(version, name)	PSCI_##version##_FN64_##name
 38#else
 39#define PSCI_FN_NATIVE(version, name)	PSCI_##version##_FN_##name
 40#endif
 41
 42/*
 43 * The CPU any Trusted OS is resident on. The trusted OS may reject CPU_OFF
 44 * calls to its resident CPU, so we must avoid issuing those. We never migrate
 45 * a Trusted OS even if it claims to be capable of migration -- doing so will
 46 * require cooperation with a Trusted OS driver.
 47 */
 48static int resident_cpu = -1;
 49
 50bool psci_tos_resident_on(int cpu)
 51{
 52	return cpu == resident_cpu;
 53}
 54
 55struct psci_operations psci_ops = {
 56	.conduit = PSCI_CONDUIT_NONE,
 57	.smccc_version = SMCCC_VERSION_1_0,
 58};
 59
 60typedef unsigned long (psci_fn)(unsigned long, unsigned long,
 61				unsigned long, unsigned long);
 62static psci_fn *invoke_psci_fn;
 63
 64enum psci_function {
 65	PSCI_FN_CPU_SUSPEND,
 66	PSCI_FN_CPU_ON,
 67	PSCI_FN_CPU_OFF,
 68	PSCI_FN_MIGRATE,
 69	PSCI_FN_MAX,
 70};
 71
 72static u32 psci_function_id[PSCI_FN_MAX];
 73
 74#define PSCI_0_2_POWER_STATE_MASK		\
 75				(PSCI_0_2_POWER_STATE_ID_MASK | \
 76				PSCI_0_2_POWER_STATE_TYPE_MASK | \
 77				PSCI_0_2_POWER_STATE_AFFL_MASK)
 78
 79#define PSCI_1_0_EXT_POWER_STATE_MASK		\
 80				(PSCI_1_0_EXT_POWER_STATE_ID_MASK | \
 81				PSCI_1_0_EXT_POWER_STATE_TYPE_MASK)
 82
 83static u32 psci_cpu_suspend_feature;
 84static bool psci_system_reset2_supported;
 85
 86static inline bool psci_has_ext_power_state(void)
 87{
 88	return psci_cpu_suspend_feature &
 89				PSCI_1_0_FEATURES_CPU_SUSPEND_PF_MASK;
 90}
 91
 92static inline bool psci_has_osi_support(void)
 93{
 94	return psci_cpu_suspend_feature & PSCI_1_0_OS_INITIATED;
 95}
 96
 97static inline bool psci_power_state_loses_context(u32 state)
 98{
 99	const u32 mask = psci_has_ext_power_state() ?
100					PSCI_1_0_EXT_POWER_STATE_TYPE_MASK :
101					PSCI_0_2_POWER_STATE_TYPE_MASK;
102
103	return state & mask;
104}
105
106bool psci_power_state_is_valid(u32 state)
107{
108	const u32 valid_mask = psci_has_ext_power_state() ?
109			       PSCI_1_0_EXT_POWER_STATE_MASK :
110			       PSCI_0_2_POWER_STATE_MASK;
111
112	return !(state & ~valid_mask);
113}
114
115static unsigned long __invoke_psci_fn_hvc(unsigned long function_id,
116			unsigned long arg0, unsigned long arg1,
117			unsigned long arg2)
118{
119	struct arm_smccc_res res;
120
121	arm_smccc_hvc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
122	return res.a0;
123}
124
125static unsigned long __invoke_psci_fn_smc(unsigned long function_id,
126			unsigned long arg0, unsigned long arg1,
127			unsigned long arg2)
128{
129	struct arm_smccc_res res;
130
131	arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
132	return res.a0;
133}
134
135static int psci_to_linux_errno(int errno)
136{
137	switch (errno) {
138	case PSCI_RET_SUCCESS:
139		return 0;
140	case PSCI_RET_NOT_SUPPORTED:
141		return -EOPNOTSUPP;
142	case PSCI_RET_INVALID_PARAMS:
143	case PSCI_RET_INVALID_ADDRESS:
144		return -EINVAL;
145	case PSCI_RET_DENIED:
146		return -EPERM;
147	};
148
149	return -EINVAL;
150}
151
152static u32 psci_get_version(void)
153{
154	return invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0);
155}
156
157static int psci_cpu_suspend(u32 state, unsigned long entry_point)
158{
159	int err;
160	u32 fn;
161
162	fn = psci_function_id[PSCI_FN_CPU_SUSPEND];
163	err = invoke_psci_fn(fn, state, entry_point, 0);
164	return psci_to_linux_errno(err);
165}
166
167static int psci_cpu_off(u32 state)
168{
169	int err;
170	u32 fn;
171
172	fn = psci_function_id[PSCI_FN_CPU_OFF];
173	err = invoke_psci_fn(fn, state, 0, 0);
174	return psci_to_linux_errno(err);
175}
176
177static int psci_cpu_on(unsigned long cpuid, unsigned long entry_point)
178{
179	int err;
180	u32 fn;
181
182	fn = psci_function_id[PSCI_FN_CPU_ON];
183	err = invoke_psci_fn(fn, cpuid, entry_point, 0);
184	return psci_to_linux_errno(err);
185}
186
187static int psci_migrate(unsigned long cpuid)
188{
189	int err;
190	u32 fn;
191
192	fn = psci_function_id[PSCI_FN_MIGRATE];
193	err = invoke_psci_fn(fn, cpuid, 0, 0);
194	return psci_to_linux_errno(err);
195}
196
197static int psci_affinity_info(unsigned long target_affinity,
198		unsigned long lowest_affinity_level)
199{
200	return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO),
201			      target_affinity, lowest_affinity_level, 0);
202}
203
204static int psci_migrate_info_type(void)
205{
206	return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0);
207}
208
209static unsigned long psci_migrate_info_up_cpu(void)
210{
211	return invoke_psci_fn(PSCI_FN_NATIVE(0_2, MIGRATE_INFO_UP_CPU),
212			      0, 0, 0);
213}
214
215static void set_conduit(enum psci_conduit conduit)
216{
217	switch (conduit) {
218	case PSCI_CONDUIT_HVC:
219		invoke_psci_fn = __invoke_psci_fn_hvc;
220		break;
221	case PSCI_CONDUIT_SMC:
222		invoke_psci_fn = __invoke_psci_fn_smc;
223		break;
224	default:
225		WARN(1, "Unexpected PSCI conduit %d\n", conduit);
226	}
227
228	psci_ops.conduit = conduit;
229}
230
231static int get_set_conduit_method(struct device_node *np)
232{
233	const char *method;
234
235	pr_info("probing for conduit method from DT.\n");
236
237	if (of_property_read_string(np, "method", &method)) {
238		pr_warn("missing \"method\" property\n");
239		return -ENXIO;
240	}
241
242	if (!strcmp("hvc", method)) {
243		set_conduit(PSCI_CONDUIT_HVC);
244	} else if (!strcmp("smc", method)) {
245		set_conduit(PSCI_CONDUIT_SMC);
246	} else {
247		pr_warn("invalid \"method\" property: %s\n", method);
248		return -EINVAL;
249	}
250	return 0;
251}
252
253static void psci_sys_reset(enum reboot_mode reboot_mode, const char *cmd)
254{
255	if ((reboot_mode == REBOOT_WARM || reboot_mode == REBOOT_SOFT) &&
256	    psci_system_reset2_supported) {
257		/*
258		 * reset_type[31] = 0 (architectural)
259		 * reset_type[30:0] = 0 (SYSTEM_WARM_RESET)
260		 * cookie = 0 (ignored by the implementation)
261		 */
262		invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), 0, 0, 0);
263	} else {
264		invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
265	}
266}
267
268static void psci_sys_poweroff(void)
269{
270	invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
271}
272
273static int __init psci_features(u32 psci_func_id)
274{
275	return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES,
276			      psci_func_id, 0, 0);
277}
278
279#ifdef CONFIG_CPU_IDLE
280static int psci_suspend_finisher(unsigned long state)
281{
282	u32 power_state = state;
283
284	return psci_ops.cpu_suspend(power_state, __pa_symbol(cpu_resume));
285}
286
287int psci_cpu_suspend_enter(u32 state)
288{
289	int ret;
290
291	if (!psci_power_state_loses_context(state))
292		ret = psci_ops.cpu_suspend(state, 0);
293	else
294		ret = cpu_suspend(state, psci_suspend_finisher);
295
296	return ret;
297}
298#endif
299
300static int psci_system_suspend(unsigned long unused)
301{
302	return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
303			      __pa_symbol(cpu_resume), 0, 0);
304}
305
306static int psci_system_suspend_enter(suspend_state_t state)
307{
308	return cpu_suspend(0, psci_system_suspend);
309}
310
311static const struct platform_suspend_ops psci_suspend_ops = {
312	.valid          = suspend_valid_only_mem,
313	.enter          = psci_system_suspend_enter,
314};
315
316static void __init psci_init_system_reset2(void)
317{
318	int ret;
319
320	ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2));
321
322	if (ret != PSCI_RET_NOT_SUPPORTED)
323		psci_system_reset2_supported = true;
324}
325
326static void __init psci_init_system_suspend(void)
327{
328	int ret;
329
330	if (!IS_ENABLED(CONFIG_SUSPEND))
331		return;
332
333	ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND));
334
335	if (ret != PSCI_RET_NOT_SUPPORTED)
336		suspend_set_ops(&psci_suspend_ops);
337}
338
339static void __init psci_init_cpu_suspend(void)
340{
341	int feature = psci_features(psci_function_id[PSCI_FN_CPU_SUSPEND]);
342
343	if (feature != PSCI_RET_NOT_SUPPORTED)
344		psci_cpu_suspend_feature = feature;
345}
346
347/*
348 * Detect the presence of a resident Trusted OS which may cause CPU_OFF to
349 * return DENIED (which would be fatal).
350 */
351static void __init psci_init_migrate(void)
352{
353	unsigned long cpuid;
354	int type, cpu = -1;
355
356	type = psci_ops.migrate_info_type();
357
358	if (type == PSCI_0_2_TOS_MP) {
359		pr_info("Trusted OS migration not required\n");
360		return;
361	}
362
363	if (type == PSCI_RET_NOT_SUPPORTED) {
364		pr_info("MIGRATE_INFO_TYPE not supported.\n");
365		return;
366	}
367
368	if (type != PSCI_0_2_TOS_UP_MIGRATE &&
369	    type != PSCI_0_2_TOS_UP_NO_MIGRATE) {
370		pr_err("MIGRATE_INFO_TYPE returned unknown type (%d)\n", type);
371		return;
372	}
373
374	cpuid = psci_migrate_info_up_cpu();
375	if (cpuid & ~MPIDR_HWID_BITMASK) {
376		pr_warn("MIGRATE_INFO_UP_CPU reported invalid physical ID (0x%lx)\n",
377			cpuid);
378		return;
379	}
380
381	cpu = get_logical_index(cpuid);
382	resident_cpu = cpu >= 0 ? cpu : -1;
383
384	pr_info("Trusted OS resident on physical CPU 0x%lx\n", cpuid);
385}
386
387static void __init psci_init_smccc(void)
388{
389	u32 ver = ARM_SMCCC_VERSION_1_0;
390	int feature;
391
392	feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID);
393
394	if (feature != PSCI_RET_NOT_SUPPORTED) {
395		u32 ret;
396		ret = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0);
397		if (ret == ARM_SMCCC_VERSION_1_1) {
398			psci_ops.smccc_version = SMCCC_VERSION_1_1;
399			ver = ret;
400		}
401	}
402
403	/*
404	 * Conveniently, the SMCCC and PSCI versions are encoded the
405	 * same way. No, this isn't accidental.
406	 */
407	pr_info("SMC Calling Convention v%d.%d\n",
408		PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver));
409
410}
411
412static void __init psci_0_2_set_functions(void)
413{
414	pr_info("Using standard PSCI v0.2 function IDs\n");
415	psci_ops.get_version = psci_get_version;
416
417	psci_function_id[PSCI_FN_CPU_SUSPEND] =
418					PSCI_FN_NATIVE(0_2, CPU_SUSPEND);
419	psci_ops.cpu_suspend = psci_cpu_suspend;
420
421	psci_function_id[PSCI_FN_CPU_OFF] = PSCI_0_2_FN_CPU_OFF;
422	psci_ops.cpu_off = psci_cpu_off;
423
424	psci_function_id[PSCI_FN_CPU_ON] = PSCI_FN_NATIVE(0_2, CPU_ON);
425	psci_ops.cpu_on = psci_cpu_on;
426
427	psci_function_id[PSCI_FN_MIGRATE] = PSCI_FN_NATIVE(0_2, MIGRATE);
428	psci_ops.migrate = psci_migrate;
429
430	psci_ops.affinity_info = psci_affinity_info;
431
432	psci_ops.migrate_info_type = psci_migrate_info_type;
433
434	arm_pm_restart = psci_sys_reset;
435
436	pm_power_off = psci_sys_poweroff;
437}
438
439/*
440 * Probe function for PSCI firmware versions >= 0.2
441 */
442static int __init psci_probe(void)
443{
444	u32 ver = psci_get_version();
445
446	pr_info("PSCIv%d.%d detected in firmware.\n",
447			PSCI_VERSION_MAJOR(ver),
448			PSCI_VERSION_MINOR(ver));
449
450	if (PSCI_VERSION_MAJOR(ver) == 0 && PSCI_VERSION_MINOR(ver) < 2) {
451		pr_err("Conflicting PSCI version detected.\n");
452		return -EINVAL;
453	}
454
455	psci_0_2_set_functions();
456
457	psci_init_migrate();
458
459	if (PSCI_VERSION_MAJOR(ver) >= 1) {
460		psci_init_smccc();
461		psci_init_cpu_suspend();
462		psci_init_system_suspend();
463		psci_init_system_reset2();
464	}
465
466	return 0;
467}
468
469typedef int (*psci_initcall_t)(const struct device_node *);
470
471/*
472 * PSCI init function for PSCI versions >=0.2
473 *
474 * Probe based on PSCI PSCI_VERSION function
475 */
476static int __init psci_0_2_init(struct device_node *np)
477{
478	int err;
479
480	err = get_set_conduit_method(np);
481	if (err)
482		return err;
483
484	/*
485	 * Starting with v0.2, the PSCI specification introduced a call
486	 * (PSCI_VERSION) that allows probing the firmware version, so
487	 * that PSCI function IDs and version specific initialization
488	 * can be carried out according to the specific version reported
489	 * by firmware
490	 */
491	return psci_probe();
492}
493
494/*
495 * PSCI < v0.2 get PSCI Function IDs via DT.
496 */
497static int __init psci_0_1_init(struct device_node *np)
498{
499	u32 id;
500	int err;
501
502	err = get_set_conduit_method(np);
503	if (err)
504		return err;
505
506	pr_info("Using PSCI v0.1 Function IDs from DT\n");
507
508	if (!of_property_read_u32(np, "cpu_suspend", &id)) {
509		psci_function_id[PSCI_FN_CPU_SUSPEND] = id;
510		psci_ops.cpu_suspend = psci_cpu_suspend;
511	}
512
513	if (!of_property_read_u32(np, "cpu_off", &id)) {
514		psci_function_id[PSCI_FN_CPU_OFF] = id;
515		psci_ops.cpu_off = psci_cpu_off;
516	}
517
518	if (!of_property_read_u32(np, "cpu_on", &id)) {
519		psci_function_id[PSCI_FN_CPU_ON] = id;
520		psci_ops.cpu_on = psci_cpu_on;
521	}
522
523	if (!of_property_read_u32(np, "migrate", &id)) {
524		psci_function_id[PSCI_FN_MIGRATE] = id;
525		psci_ops.migrate = psci_migrate;
526	}
527
528	return 0;
529}
530
531static int __init psci_1_0_init(struct device_node *np)
532{
533	int err;
534
535	err = psci_0_2_init(np);
536	if (err)
537		return err;
538
539	if (psci_has_osi_support())
540		pr_info("OSI mode supported.\n");
541
542	return 0;
543}
544
545static const struct of_device_id psci_of_match[] __initconst = {
546	{ .compatible = "arm,psci",	.data = psci_0_1_init},
547	{ .compatible = "arm,psci-0.2",	.data = psci_0_2_init},
548	{ .compatible = "arm,psci-1.0",	.data = psci_1_0_init},
549	{},
550};
551
552int __init psci_dt_init(void)
553{
554	struct device_node *np;
555	const struct of_device_id *matched_np;
556	psci_initcall_t init_fn;
557	int ret;
558
559	np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);
560
561	if (!np || !of_device_is_available(np))
562		return -ENODEV;
563
564	init_fn = (psci_initcall_t)matched_np->data;
565	ret = init_fn(np);
566
567	of_node_put(np);
568	return ret;
569}
570
571#ifdef CONFIG_ACPI
572/*
573 * We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's
574 * explicitly clarified in SBBR
575 */
576int __init psci_acpi_init(void)
577{
578	if (!acpi_psci_present()) {
579		pr_info("is not implemented in ACPI.\n");
580		return -EOPNOTSUPP;
581	}
582
583	pr_info("probing for conduit method from ACPI.\n");
584
585	if (acpi_psci_use_hvc())
586		set_conduit(PSCI_CONDUIT_HVC);
587	else
588		set_conduit(PSCI_CONDUIT_SMC);
589
590	return psci_probe();
591}
592#endif