xref: /linux/drivers/firmware/psci/psci.c (revision 954ea91fb68b771dba6d87cfa61b68e09cc2497f) 
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_warn("failed to set %s mode: %d\n", enable ? "OSI" : "PC", err);
171  	return psci_to_linux_errno(err);
172  }
173  
174  static __always_inline int
175  __psci_cpu_suspend(u32 fn, u32 state, unsigned long entry_point)
176  {
177  	int err;
178  
179  	err = invoke_psci_fn(fn, state, entry_point, 0);
180  	return psci_to_linux_errno(err);
181  }
182  
183  static __always_inline int
184  psci_0_1_cpu_suspend(u32 state, unsigned long entry_point)
185  {
186  	return __psci_cpu_suspend(psci_0_1_function_ids.cpu_suspend,
187  				  state, entry_point);
188  }
189  
190  static __always_inline int
191  psci_0_2_cpu_suspend(u32 state, unsigned long entry_point)
192  {
193  	return __psci_cpu_suspend(PSCI_FN_NATIVE(0_2, CPU_SUSPEND),
194  				  state, entry_point);
195  }
196  
197  static int __psci_cpu_off(u32 fn, u32 state)
198  {
199  	int err;
200  
201  	err = invoke_psci_fn(fn, state, 0, 0);
202  	return psci_to_linux_errno(err);
203  }
204  
205  static int psci_0_1_cpu_off(u32 state)
206  {
207  	return __psci_cpu_off(psci_0_1_function_ids.cpu_off, state);
208  }
209  
210  static int psci_0_2_cpu_off(u32 state)
211  {
212  	return __psci_cpu_off(PSCI_0_2_FN_CPU_OFF, state);
213  }
214  
215  static int __psci_cpu_on(u32 fn, unsigned long cpuid, unsigned long entry_point)
216  {
217  	int err;
218  
219  	err = invoke_psci_fn(fn, cpuid, entry_point, 0);
220  	return psci_to_linux_errno(err);
221  }
222  
223  static int psci_0_1_cpu_on(unsigned long cpuid, unsigned long entry_point)
224  {
225  	return __psci_cpu_on(psci_0_1_function_ids.cpu_on, cpuid, entry_point);
226  }
227  
228  static int psci_0_2_cpu_on(unsigned long cpuid, unsigned long entry_point)
229  {
230  	return __psci_cpu_on(PSCI_FN_NATIVE(0_2, CPU_ON), cpuid, entry_point);
231  }
232  
233  static int __psci_migrate(u32 fn, unsigned long cpuid)
234  {
235  	int err;
236  
237  	err = invoke_psci_fn(fn, cpuid, 0, 0);
238  	return psci_to_linux_errno(err);
239  }
240  
241  static int psci_0_1_migrate(unsigned long cpuid)
242  {
243  	return __psci_migrate(psci_0_1_function_ids.migrate, cpuid);
244  }
245  
246  static int psci_0_2_migrate(unsigned long cpuid)
247  {
248  	return __psci_migrate(PSCI_FN_NATIVE(0_2, MIGRATE), cpuid);
249  }
250  
251  static int psci_affinity_info(unsigned long target_affinity,
252  		unsigned long lowest_affinity_level)
253  {
254  	return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO),
255  			      target_affinity, lowest_affinity_level, 0);
256  }
257  
258  static int psci_migrate_info_type(void)
259  {
260  	return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0);
261  }
262  
263  static unsigned long psci_migrate_info_up_cpu(void)
264  {
265  	return invoke_psci_fn(PSCI_FN_NATIVE(0_2, MIGRATE_INFO_UP_CPU),
266  			      0, 0, 0);
267  }
268  
269  static void set_conduit(enum arm_smccc_conduit conduit)
270  {
271  	switch (conduit) {
272  	case SMCCC_CONDUIT_HVC:
273  		invoke_psci_fn = __invoke_psci_fn_hvc;
274  		break;
275  	case SMCCC_CONDUIT_SMC:
276  		invoke_psci_fn = __invoke_psci_fn_smc;
277  		break;
278  	default:
279  		WARN(1, "Unexpected PSCI conduit %d\n", conduit);
280  	}
281  
282  	psci_conduit = conduit;
283  }
284  
285  static int get_set_conduit_method(const struct device_node *np)
286  {
287  	const char *method;
288  
289  	pr_info("probing for conduit method from DT.\n");
290  
291  	if (of_property_read_string(np, "method", &method)) {
292  		pr_warn("missing \"method\" property\n");
293  		return -ENXIO;
294  	}
295  
296  	if (!strcmp("hvc", method)) {
297  		set_conduit(SMCCC_CONDUIT_HVC);
298  	} else if (!strcmp("smc", method)) {
299  		set_conduit(SMCCC_CONDUIT_SMC);
300  	} else {
301  		pr_warn("invalid \"method\" property: %s\n", method);
302  		return -EINVAL;
303  	}
304  	return 0;
305  }
306  
307  static int psci_sys_reset(struct notifier_block *nb, unsigned long action,
308  			  void *data)
309  {
310  	if ((reboot_mode == REBOOT_WARM || reboot_mode == REBOOT_SOFT) &&
311  	    psci_system_reset2_supported) {
312  		/*
313  		 * reset_type[31] = 0 (architectural)
314  		 * reset_type[30:0] = 0 (SYSTEM_WARM_RESET)
315  		 * cookie = 0 (ignored by the implementation)
316  		 */
317  		invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), 0, 0, 0);
318  	} else {
319  		invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
320  	}
321  
322  	return NOTIFY_DONE;
323  }
324  
325  static struct notifier_block psci_sys_reset_nb = {
326  	.notifier_call = psci_sys_reset,
327  	.priority = 129,
328  };
329  
330  static void psci_sys_poweroff(void)
331  {
332  	invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
333  }
334  
335  static int psci_features(u32 psci_func_id)
336  {
337  	return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES,
338  			      psci_func_id, 0, 0);
339  }
340  
341  #ifdef CONFIG_DEBUG_FS
342  
343  #define PSCI_ID(ver, _name) \
344  	{ .fn = PSCI_##ver##_FN_##_name, .name = #_name, }
345  #define PSCI_ID_NATIVE(ver, _name) \
346  	{ .fn = PSCI_FN_NATIVE(ver, _name), .name = #_name, }
347  
348  /* A table of all optional functions */
349  static const struct {
350  	u32 fn;
351  	const char *name;
352  } psci_fn_ids[] = {
353  	PSCI_ID_NATIVE(0_2, MIGRATE),
354  	PSCI_ID(0_2, MIGRATE_INFO_TYPE),
355  	PSCI_ID_NATIVE(0_2, MIGRATE_INFO_UP_CPU),
356  	PSCI_ID(1_0, CPU_FREEZE),
357  	PSCI_ID_NATIVE(1_0, CPU_DEFAULT_SUSPEND),
358  	PSCI_ID_NATIVE(1_0, NODE_HW_STATE),
359  	PSCI_ID_NATIVE(1_0, SYSTEM_SUSPEND),
360  	PSCI_ID(1_0, SET_SUSPEND_MODE),
361  	PSCI_ID_NATIVE(1_0, STAT_RESIDENCY),
362  	PSCI_ID_NATIVE(1_0, STAT_COUNT),
363  	PSCI_ID_NATIVE(1_1, SYSTEM_RESET2),
364  	PSCI_ID(1_1, MEM_PROTECT),
365  	PSCI_ID_NATIVE(1_1, MEM_PROTECT_CHECK_RANGE),
366  };
367  
368  static int psci_debugfs_read(struct seq_file *s, void *data)
369  {
370  	int feature, type, i;
371  	u32 ver;
372  
373  	ver = psci_ops.get_version();
374  	seq_printf(s, "PSCIv%d.%d\n",
375  		   PSCI_VERSION_MAJOR(ver),
376  		   PSCI_VERSION_MINOR(ver));
377  
378  	/* PSCI_FEATURES is available only starting from 1.0 */
379  	if (PSCI_VERSION_MAJOR(ver) < 1)
380  		return 0;
381  
382  	feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID);
383  	if (feature != PSCI_RET_NOT_SUPPORTED) {
384  		ver = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0);
385  		seq_printf(s, "SMC Calling Convention v%d.%d\n",
386  			   PSCI_VERSION_MAJOR(ver),
387  			   PSCI_VERSION_MINOR(ver));
388  	} else {
389  		seq_puts(s, "SMC Calling Convention v1.0 is assumed\n");
390  	}
391  
392  	feature = psci_features(PSCI_FN_NATIVE(0_2, CPU_SUSPEND));
393  	if (feature < 0) {
394  		seq_printf(s, "PSCI_FEATURES(CPU_SUSPEND) error (%d)\n", feature);
395  	} else {
396  		seq_printf(s, "OSI is %ssupported\n",
397  			   (feature & BIT(0)) ? "" : "not ");
398  		seq_printf(s, "%s StateID format is used\n",
399  			   (feature & BIT(1)) ? "Extended" : "Original");
400  	}
401  
402  	type = psci_ops.migrate_info_type();
403  	if (type == PSCI_0_2_TOS_UP_MIGRATE ||
404  	    type == PSCI_0_2_TOS_UP_NO_MIGRATE) {
405  		unsigned long cpuid;
406  
407  		seq_printf(s, "Trusted OS %smigrate capable\n",
408  			   type == PSCI_0_2_TOS_UP_NO_MIGRATE ? "not " : "");
409  		cpuid = psci_migrate_info_up_cpu();
410  		seq_printf(s, "Trusted OS resident on physical CPU 0x%lx (#%d)\n",
411  			   cpuid, resident_cpu);
412  	} else if (type == PSCI_0_2_TOS_MP) {
413  		seq_puts(s, "Trusted OS migration not required\n");
414  	} else {
415  		if (type != PSCI_RET_NOT_SUPPORTED)
416  			seq_printf(s, "MIGRATE_INFO_TYPE returned unknown type (%d)\n", type);
417  	}
418  
419  	for (i = 0; i < ARRAY_SIZE(psci_fn_ids); i++) {
420  		feature = psci_features(psci_fn_ids[i].fn);
421  		if (feature == PSCI_RET_NOT_SUPPORTED)
422  			continue;
423  		if (feature < 0)
424  			seq_printf(s, "PSCI_FEATURES(%s) error (%d)\n",
425  				   psci_fn_ids[i].name, feature);
426  		else
427  			seq_printf(s, "%s is supported\n", psci_fn_ids[i].name);
428  	}
429  
430  	return 0;
431  }
432  
433  static int psci_debugfs_open(struct inode *inode, struct file *f)
434  {
435  	return single_open(f, psci_debugfs_read, NULL);
436  }
437  
438  static const struct file_operations psci_debugfs_ops = {
439  	.owner = THIS_MODULE,
440  	.open = psci_debugfs_open,
441  	.release = single_release,
442  	.read = seq_read,
443  	.llseek = seq_lseek
444  };
445  
446  static int __init psci_debugfs_init(void)
447  {
448  	if (!invoke_psci_fn || !psci_ops.get_version)
449  		return 0;
450  
451  	return PTR_ERR_OR_ZERO(debugfs_create_file("psci", 0444, NULL, NULL,
452  						   &psci_debugfs_ops));
453  }
454  late_initcall(psci_debugfs_init)
455  #endif
456  
457  #ifdef CONFIG_CPU_IDLE
458  static noinstr int psci_suspend_finisher(unsigned long state)
459  {
460  	u32 power_state = state;
461  	phys_addr_t pa_cpu_resume;
462  
463  	pa_cpu_resume = __pa_symbol_nodebug((unsigned long)cpu_resume);
464  
465  	return psci_ops.cpu_suspend(power_state, pa_cpu_resume);
466  }
467  
468  int psci_cpu_suspend_enter(u32 state)
469  {
470  	int ret;
471  
472  	if (!psci_power_state_loses_context(state)) {
473  		struct arm_cpuidle_irq_context context;
474  
475  		ct_cpuidle_enter();
476  		arm_cpuidle_save_irq_context(&context);
477  		ret = psci_ops.cpu_suspend(state, 0);
478  		arm_cpuidle_restore_irq_context(&context);
479  		ct_cpuidle_exit();
480  	} else {
481  		/*
482  		 * ARM64 cpu_suspend() wants to do ct_cpuidle_*() itself.
483  		 */
484  		if (!IS_ENABLED(CONFIG_ARM64))
485  			ct_cpuidle_enter();
486  
487  		ret = cpu_suspend(state, psci_suspend_finisher);
488  
489  		if (!IS_ENABLED(CONFIG_ARM64))
490  			ct_cpuidle_exit();
491  	}
492  
493  	return ret;
494  }
495  #endif
496  
497  static int psci_system_suspend(unsigned long unused)
498  {
499  	phys_addr_t pa_cpu_resume = __pa_symbol(cpu_resume);
500  
501  	return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
502  			      pa_cpu_resume, 0, 0);
503  }
504  
505  static int psci_system_suspend_enter(suspend_state_t state)
506  {
507  	return cpu_suspend(0, psci_system_suspend);
508  }
509  
510  static const struct platform_suspend_ops psci_suspend_ops = {
511  	.valid          = suspend_valid_only_mem,
512  	.enter          = psci_system_suspend_enter,
513  };
514  
515  static void __init psci_init_system_reset2(void)
516  {
517  	int ret;
518  
519  	ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2));
520  
521  	if (ret != PSCI_RET_NOT_SUPPORTED)
522  		psci_system_reset2_supported = true;
523  }
524  
525  static void __init psci_init_system_suspend(void)
526  {
527  	int ret;
528  
529  	if (!IS_ENABLED(CONFIG_SUSPEND))
530  		return;
531  
532  	ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND));
533  
534  	if (ret != PSCI_RET_NOT_SUPPORTED)
535  		suspend_set_ops(&psci_suspend_ops);
536  }
537  
538  static void __init psci_init_cpu_suspend(void)
539  {
540  	int feature = psci_features(PSCI_FN_NATIVE(0_2, CPU_SUSPEND));
541  
542  	if (feature != PSCI_RET_NOT_SUPPORTED)
543  		psci_cpu_suspend_feature = feature;
544  }
545  
546  /*
547   * Detect the presence of a resident Trusted OS which may cause CPU_OFF to
548   * return DENIED (which would be fatal).
549   */
550  static void __init psci_init_migrate(void)
551  {
552  	unsigned long cpuid;
553  	int type, cpu = -1;
554  
555  	type = psci_ops.migrate_info_type();
556  
557  	if (type == PSCI_0_2_TOS_MP) {
558  		pr_info("Trusted OS migration not required\n");
559  		return;
560  	}
561  
562  	if (type == PSCI_RET_NOT_SUPPORTED) {
563  		pr_info("MIGRATE_INFO_TYPE not supported.\n");
564  		return;
565  	}
566  
567  	if (type != PSCI_0_2_TOS_UP_MIGRATE &&
568  	    type != PSCI_0_2_TOS_UP_NO_MIGRATE) {
569  		pr_err("MIGRATE_INFO_TYPE returned unknown type (%d)\n", type);
570  		return;
571  	}
572  
573  	cpuid = psci_migrate_info_up_cpu();
574  	if (cpuid & ~MPIDR_HWID_BITMASK) {
575  		pr_warn("MIGRATE_INFO_UP_CPU reported invalid physical ID (0x%lx)\n",
576  			cpuid);
577  		return;
578  	}
579  
580  	cpu = get_logical_index(cpuid);
581  	resident_cpu = cpu >= 0 ? cpu : -1;
582  
583  	pr_info("Trusted OS resident on physical CPU 0x%lx\n", cpuid);
584  }
585  
586  static void __init psci_init_smccc(void)
587  {
588  	u32 ver = ARM_SMCCC_VERSION_1_0;
589  	int feature;
590  
591  	feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID);
592  
593  	if (feature != PSCI_RET_NOT_SUPPORTED) {
594  		u32 ret;
595  		ret = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0);
596  		if (ret >= ARM_SMCCC_VERSION_1_1) {
597  			arm_smccc_version_init(ret, psci_conduit);
598  			ver = ret;
599  		}
600  	}
601  
602  	/*
603  	 * Conveniently, the SMCCC and PSCI versions are encoded the
604  	 * same way. No, this isn't accidental.
605  	 */
606  	pr_info("SMC Calling Convention v%d.%d\n",
607  		PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver));
608  
609  }
610  
611  static void __init psci_0_2_set_functions(void)
612  {
613  	pr_info("Using standard PSCI v0.2 function IDs\n");
614  
615  	psci_ops = (struct psci_operations){
616  		.get_version = psci_0_2_get_version,
617  		.cpu_suspend = psci_0_2_cpu_suspend,
618  		.cpu_off = psci_0_2_cpu_off,
619  		.cpu_on = psci_0_2_cpu_on,
620  		.migrate = psci_0_2_migrate,
621  		.affinity_info = psci_affinity_info,
622  		.migrate_info_type = psci_migrate_info_type,
623  	};
624  
625  	register_restart_handler(&psci_sys_reset_nb);
626  
627  	pm_power_off = psci_sys_poweroff;
628  }
629  
630  /*
631   * Probe function for PSCI firmware versions >= 0.2
632   */
633  static int __init psci_probe(void)
634  {
635  	u32 ver = psci_0_2_get_version();
636  
637  	pr_info("PSCIv%d.%d detected in firmware.\n",
638  			PSCI_VERSION_MAJOR(ver),
639  			PSCI_VERSION_MINOR(ver));
640  
641  	if (PSCI_VERSION_MAJOR(ver) == 0 && PSCI_VERSION_MINOR(ver) < 2) {
642  		pr_err("Conflicting PSCI version detected.\n");
643  		return -EINVAL;
644  	}
645  
646  	psci_0_2_set_functions();
647  
648  	psci_init_migrate();
649  
650  	if (PSCI_VERSION_MAJOR(ver) >= 1) {
651  		psci_init_smccc();
652  		psci_init_cpu_suspend();
653  		psci_init_system_suspend();
654  		psci_init_system_reset2();
655  		kvm_init_hyp_services();
656  	}
657  
658  	return 0;
659  }
660  
661  typedef int (*psci_initcall_t)(const struct device_node *);
662  
663  /*
664   * PSCI init function for PSCI versions >=0.2
665   *
666   * Probe based on PSCI PSCI_VERSION function
667   */
668  static int __init psci_0_2_init(const struct device_node *np)
669  {
670  	int err;
671  
672  	err = get_set_conduit_method(np);
673  	if (err)
674  		return err;
675  
676  	/*
677  	 * Starting with v0.2, the PSCI specification introduced a call
678  	 * (PSCI_VERSION) that allows probing the firmware version, so
679  	 * that PSCI function IDs and version specific initialization
680  	 * can be carried out according to the specific version reported
681  	 * by firmware
682  	 */
683  	return psci_probe();
684  }
685  
686  /*
687   * PSCI < v0.2 get PSCI Function IDs via DT.
688   */
689  static int __init psci_0_1_init(const struct device_node *np)
690  {
691  	u32 id;
692  	int err;
693  
694  	err = get_set_conduit_method(np);
695  	if (err)
696  		return err;
697  
698  	pr_info("Using PSCI v0.1 Function IDs from DT\n");
699  
700  	psci_ops.get_version = psci_0_1_get_version;
701  
702  	if (!of_property_read_u32(np, "cpu_suspend", &id)) {
703  		psci_0_1_function_ids.cpu_suspend = id;
704  		psci_ops.cpu_suspend = psci_0_1_cpu_suspend;
705  	}
706  
707  	if (!of_property_read_u32(np, "cpu_off", &id)) {
708  		psci_0_1_function_ids.cpu_off = id;
709  		psci_ops.cpu_off = psci_0_1_cpu_off;
710  	}
711  
712  	if (!of_property_read_u32(np, "cpu_on", &id)) {
713  		psci_0_1_function_ids.cpu_on = id;
714  		psci_ops.cpu_on = psci_0_1_cpu_on;
715  	}
716  
717  	if (!of_property_read_u32(np, "migrate", &id)) {
718  		psci_0_1_function_ids.migrate = id;
719  		psci_ops.migrate = psci_0_1_migrate;
720  	}
721  
722  	return 0;
723  }
724  
725  static int __init psci_1_0_init(const struct device_node *np)
726  {
727  	int err;
728  
729  	err = psci_0_2_init(np);
730  	if (err)
731  		return err;
732  
733  	if (psci_has_osi_support()) {
734  		pr_info("OSI mode supported.\n");
735  
736  		/* Default to PC mode. */
737  		psci_set_osi_mode(false);
738  	}
739  
740  	return 0;
741  }
742  
743  static const struct of_device_id psci_of_match[] __initconst = {
744  	{ .compatible = "arm,psci",	.data = psci_0_1_init},
745  	{ .compatible = "arm,psci-0.2",	.data = psci_0_2_init},
746  	{ .compatible = "arm,psci-1.0",	.data = psci_1_0_init},
747  	{},
748  };
749  
750  int __init psci_dt_init(void)
751  {
752  	struct device_node *np;
753  	const struct of_device_id *matched_np;
754  	psci_initcall_t init_fn;
755  	int ret;
756  
757  	np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);
758  
759  	if (!np || !of_device_is_available(np))
760  		return -ENODEV;
761  
762  	init_fn = (psci_initcall_t)matched_np->data;
763  	ret = init_fn(np);
764  
765  	of_node_put(np);
766  	return ret;
767  }
768  
769  #ifdef CONFIG_ACPI
770  /*
771   * We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's
772   * explicitly clarified in SBBR
773   */
774  int __init psci_acpi_init(void)
775  {
776  	if (!acpi_psci_present()) {
777  		pr_info("is not implemented in ACPI.\n");
778  		return -EOPNOTSUPP;
779  	}
780  
781  	pr_info("probing for conduit method from ACPI.\n");
782  
783  	if (acpi_psci_use_hvc())
784  		set_conduit(SMCCC_CONDUIT_HVC);
785  	else
786  		set_conduit(SMCCC_CONDUIT_SMC);
787  
788  	return psci_probe();
789  }
790  #endif
791