mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 21:36:44 +07:00
d09a0011ec
Allow disabling PSCI support (mostly for testing purposes) by setting the status property to "disabled". This makes the node behave in much the same way as proper device nodes. Signed-off-by: Thierry Reding <treding@nvidia.com> Signed-off-by: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com> Acked-by: Mark Rutland <mark.rutland@arm.com> Signed-off-by: Arnd Bergmann <arnd@arndb.de>
662 lines
15 KiB
C
662 lines
15 KiB
C
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* Copyright (C) 2015 ARM Limited
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "psci: " fmt
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/arm-smccc.h>
|
|
#include <linux/cpuidle.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/linkage.h>
|
|
#include <linux/of.h>
|
|
#include <linux/pm.h>
|
|
#include <linux/printk.h>
|
|
#include <linux/psci.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/suspend.h>
|
|
|
|
#include <uapi/linux/psci.h>
|
|
|
|
#include <asm/cpuidle.h>
|
|
#include <asm/cputype.h>
|
|
#include <asm/system_misc.h>
|
|
#include <asm/smp_plat.h>
|
|
#include <asm/suspend.h>
|
|
|
|
/*
|
|
* While a 64-bit OS can make calls with SMC32 calling conventions, for some
|
|
* calls it is necessary to use SMC64 to pass or return 64-bit values.
|
|
* For such calls PSCI_FN_NATIVE(version, name) will choose the appropriate
|
|
* (native-width) function ID.
|
|
*/
|
|
#ifdef CONFIG_64BIT
|
|
#define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN64_##name
|
|
#else
|
|
#define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN_##name
|
|
#endif
|
|
|
|
/*
|
|
* The CPU any Trusted OS is resident on. The trusted OS may reject CPU_OFF
|
|
* calls to its resident CPU, so we must avoid issuing those. We never migrate
|
|
* a Trusted OS even if it claims to be capable of migration -- doing so will
|
|
* require cooperation with a Trusted OS driver.
|
|
*/
|
|
static int resident_cpu = -1;
|
|
|
|
bool psci_tos_resident_on(int cpu)
|
|
{
|
|
return cpu == resident_cpu;
|
|
}
|
|
|
|
struct psci_operations psci_ops;
|
|
|
|
typedef unsigned long (psci_fn)(unsigned long, unsigned long,
|
|
unsigned long, unsigned long);
|
|
static psci_fn *invoke_psci_fn;
|
|
|
|
enum psci_function {
|
|
PSCI_FN_CPU_SUSPEND,
|
|
PSCI_FN_CPU_ON,
|
|
PSCI_FN_CPU_OFF,
|
|
PSCI_FN_MIGRATE,
|
|
PSCI_FN_MAX,
|
|
};
|
|
|
|
static u32 psci_function_id[PSCI_FN_MAX];
|
|
|
|
#define PSCI_0_2_POWER_STATE_MASK \
|
|
(PSCI_0_2_POWER_STATE_ID_MASK | \
|
|
PSCI_0_2_POWER_STATE_TYPE_MASK | \
|
|
PSCI_0_2_POWER_STATE_AFFL_MASK)
|
|
|
|
#define PSCI_1_0_EXT_POWER_STATE_MASK \
|
|
(PSCI_1_0_EXT_POWER_STATE_ID_MASK | \
|
|
PSCI_1_0_EXT_POWER_STATE_TYPE_MASK)
|
|
|
|
static u32 psci_cpu_suspend_feature;
|
|
|
|
static inline bool psci_has_ext_power_state(void)
|
|
{
|
|
return psci_cpu_suspend_feature &
|
|
PSCI_1_0_FEATURES_CPU_SUSPEND_PF_MASK;
|
|
}
|
|
|
|
static inline bool psci_power_state_loses_context(u32 state)
|
|
{
|
|
const u32 mask = psci_has_ext_power_state() ?
|
|
PSCI_1_0_EXT_POWER_STATE_TYPE_MASK :
|
|
PSCI_0_2_POWER_STATE_TYPE_MASK;
|
|
|
|
return state & mask;
|
|
}
|
|
|
|
static inline bool psci_power_state_is_valid(u32 state)
|
|
{
|
|
const u32 valid_mask = psci_has_ext_power_state() ?
|
|
PSCI_1_0_EXT_POWER_STATE_MASK :
|
|
PSCI_0_2_POWER_STATE_MASK;
|
|
|
|
return !(state & ~valid_mask);
|
|
}
|
|
|
|
static unsigned long __invoke_psci_fn_hvc(unsigned long function_id,
|
|
unsigned long arg0, unsigned long arg1,
|
|
unsigned long arg2)
|
|
{
|
|
struct arm_smccc_res res;
|
|
|
|
arm_smccc_hvc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
|
|
return res.a0;
|
|
}
|
|
|
|
static unsigned long __invoke_psci_fn_smc(unsigned long function_id,
|
|
unsigned long arg0, unsigned long arg1,
|
|
unsigned long arg2)
|
|
{
|
|
struct arm_smccc_res res;
|
|
|
|
arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res);
|
|
return res.a0;
|
|
}
|
|
|
|
static int psci_to_linux_errno(int errno)
|
|
{
|
|
switch (errno) {
|
|
case PSCI_RET_SUCCESS:
|
|
return 0;
|
|
case PSCI_RET_NOT_SUPPORTED:
|
|
return -EOPNOTSUPP;
|
|
case PSCI_RET_INVALID_PARAMS:
|
|
case PSCI_RET_INVALID_ADDRESS:
|
|
return -EINVAL;
|
|
case PSCI_RET_DENIED:
|
|
return -EPERM;
|
|
};
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static u32 psci_get_version(void)
|
|
{
|
|
return invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0);
|
|
}
|
|
|
|
static int psci_cpu_suspend(u32 state, unsigned long entry_point)
|
|
{
|
|
int err;
|
|
u32 fn;
|
|
|
|
fn = psci_function_id[PSCI_FN_CPU_SUSPEND];
|
|
err = invoke_psci_fn(fn, state, entry_point, 0);
|
|
return psci_to_linux_errno(err);
|
|
}
|
|
|
|
static int psci_cpu_off(u32 state)
|
|
{
|
|
int err;
|
|
u32 fn;
|
|
|
|
fn = psci_function_id[PSCI_FN_CPU_OFF];
|
|
err = invoke_psci_fn(fn, state, 0, 0);
|
|
return psci_to_linux_errno(err);
|
|
}
|
|
|
|
static int psci_cpu_on(unsigned long cpuid, unsigned long entry_point)
|
|
{
|
|
int err;
|
|
u32 fn;
|
|
|
|
fn = psci_function_id[PSCI_FN_CPU_ON];
|
|
err = invoke_psci_fn(fn, cpuid, entry_point, 0);
|
|
return psci_to_linux_errno(err);
|
|
}
|
|
|
|
static int psci_migrate(unsigned long cpuid)
|
|
{
|
|
int err;
|
|
u32 fn;
|
|
|
|
fn = psci_function_id[PSCI_FN_MIGRATE];
|
|
err = invoke_psci_fn(fn, cpuid, 0, 0);
|
|
return psci_to_linux_errno(err);
|
|
}
|
|
|
|
static int psci_affinity_info(unsigned long target_affinity,
|
|
unsigned long lowest_affinity_level)
|
|
{
|
|
return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO),
|
|
target_affinity, lowest_affinity_level, 0);
|
|
}
|
|
|
|
static int psci_migrate_info_type(void)
|
|
{
|
|
return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0);
|
|
}
|
|
|
|
static unsigned long psci_migrate_info_up_cpu(void)
|
|
{
|
|
return invoke_psci_fn(PSCI_FN_NATIVE(0_2, MIGRATE_INFO_UP_CPU),
|
|
0, 0, 0);
|
|
}
|
|
|
|
static int get_set_conduit_method(struct device_node *np)
|
|
{
|
|
const char *method;
|
|
|
|
pr_info("probing for conduit method from DT.\n");
|
|
|
|
if (of_property_read_string(np, "method", &method)) {
|
|
pr_warn("missing \"method\" property\n");
|
|
return -ENXIO;
|
|
}
|
|
|
|
if (!strcmp("hvc", method)) {
|
|
invoke_psci_fn = __invoke_psci_fn_hvc;
|
|
} else if (!strcmp("smc", method)) {
|
|
invoke_psci_fn = __invoke_psci_fn_smc;
|
|
} else {
|
|
pr_warn("invalid \"method\" property: %s\n", method);
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void psci_sys_reset(enum reboot_mode reboot_mode, const char *cmd)
|
|
{
|
|
invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
|
|
}
|
|
|
|
static void psci_sys_poweroff(void)
|
|
{
|
|
invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
|
|
}
|
|
|
|
static int __init psci_features(u32 psci_func_id)
|
|
{
|
|
return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES,
|
|
psci_func_id, 0, 0);
|
|
}
|
|
|
|
#ifdef CONFIG_CPU_IDLE
|
|
static DEFINE_PER_CPU_READ_MOSTLY(u32 *, psci_power_state);
|
|
|
|
static int psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu)
|
|
{
|
|
int i, ret, count = 0;
|
|
u32 *psci_states;
|
|
struct device_node *state_node;
|
|
|
|
/* Count idle states */
|
|
while ((state_node = of_parse_phandle(cpu_node, "cpu-idle-states",
|
|
count))) {
|
|
count++;
|
|
of_node_put(state_node);
|
|
}
|
|
|
|
if (!count)
|
|
return -ENODEV;
|
|
|
|
psci_states = kcalloc(count, sizeof(*psci_states), GFP_KERNEL);
|
|
if (!psci_states)
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
u32 state;
|
|
|
|
state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
|
|
|
|
ret = of_property_read_u32(state_node,
|
|
"arm,psci-suspend-param",
|
|
&state);
|
|
if (ret) {
|
|
pr_warn(" * %s missing arm,psci-suspend-param property\n",
|
|
state_node->full_name);
|
|
of_node_put(state_node);
|
|
goto free_mem;
|
|
}
|
|
|
|
of_node_put(state_node);
|
|
pr_debug("psci-power-state %#x index %d\n", state, i);
|
|
if (!psci_power_state_is_valid(state)) {
|
|
pr_warn("Invalid PSCI power state %#x\n", state);
|
|
ret = -EINVAL;
|
|
goto free_mem;
|
|
}
|
|
psci_states[i] = state;
|
|
}
|
|
/* Idle states parsed correctly, initialize per-cpu pointer */
|
|
per_cpu(psci_power_state, cpu) = psci_states;
|
|
return 0;
|
|
|
|
free_mem:
|
|
kfree(psci_states);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_ACPI
|
|
#include <acpi/processor.h>
|
|
|
|
static int __maybe_unused psci_acpi_cpu_init_idle(unsigned int cpu)
|
|
{
|
|
int i, count;
|
|
u32 *psci_states;
|
|
struct acpi_lpi_state *lpi;
|
|
struct acpi_processor *pr = per_cpu(processors, cpu);
|
|
|
|
if (unlikely(!pr || !pr->flags.has_lpi))
|
|
return -EINVAL;
|
|
|
|
count = pr->power.count - 1;
|
|
if (count <= 0)
|
|
return -ENODEV;
|
|
|
|
psci_states = kcalloc(count, sizeof(*psci_states), GFP_KERNEL);
|
|
if (!psci_states)
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
u32 state;
|
|
|
|
lpi = &pr->power.lpi_states[i + 1];
|
|
/*
|
|
* Only bits[31:0] represent a PSCI power_state while
|
|
* bits[63:32] must be 0x0 as per ARM ACPI FFH Specification
|
|
*/
|
|
state = lpi->address;
|
|
if (!psci_power_state_is_valid(state)) {
|
|
pr_warn("Invalid PSCI power state %#x\n", state);
|
|
kfree(psci_states);
|
|
return -EINVAL;
|
|
}
|
|
psci_states[i] = state;
|
|
}
|
|
/* Idle states parsed correctly, initialize per-cpu pointer */
|
|
per_cpu(psci_power_state, cpu) = psci_states;
|
|
return 0;
|
|
}
|
|
#else
|
|
static int __maybe_unused psci_acpi_cpu_init_idle(unsigned int cpu)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
#endif
|
|
|
|
int psci_cpu_init_idle(unsigned int cpu)
|
|
{
|
|
struct device_node *cpu_node;
|
|
int ret;
|
|
|
|
/*
|
|
* If the PSCI cpu_suspend function hook has not been initialized
|
|
* idle states must not be enabled, so bail out
|
|
*/
|
|
if (!psci_ops.cpu_suspend)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (!acpi_disabled)
|
|
return psci_acpi_cpu_init_idle(cpu);
|
|
|
|
cpu_node = of_get_cpu_node(cpu, NULL);
|
|
if (!cpu_node)
|
|
return -ENODEV;
|
|
|
|
ret = psci_dt_cpu_init_idle(cpu_node, cpu);
|
|
|
|
of_node_put(cpu_node);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int psci_suspend_finisher(unsigned long index)
|
|
{
|
|
u32 *state = __this_cpu_read(psci_power_state);
|
|
|
|
return psci_ops.cpu_suspend(state[index - 1],
|
|
virt_to_phys(cpu_resume));
|
|
}
|
|
|
|
int psci_cpu_suspend_enter(unsigned long index)
|
|
{
|
|
int ret;
|
|
u32 *state = __this_cpu_read(psci_power_state);
|
|
/*
|
|
* idle state index 0 corresponds to wfi, should never be called
|
|
* from the cpu_suspend operations
|
|
*/
|
|
if (WARN_ON_ONCE(!index))
|
|
return -EINVAL;
|
|
|
|
if (!psci_power_state_loses_context(state[index - 1]))
|
|
ret = psci_ops.cpu_suspend(state[index - 1], 0);
|
|
else
|
|
ret = cpu_suspend(index, psci_suspend_finisher);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* ARM specific CPU idle operations */
|
|
#ifdef CONFIG_ARM
|
|
static const struct cpuidle_ops psci_cpuidle_ops __initconst = {
|
|
.suspend = psci_cpu_suspend_enter,
|
|
.init = psci_dt_cpu_init_idle,
|
|
};
|
|
|
|
CPUIDLE_METHOD_OF_DECLARE(psci, "psci", &psci_cpuidle_ops);
|
|
#endif
|
|
#endif
|
|
|
|
static int psci_system_suspend(unsigned long unused)
|
|
{
|
|
return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND),
|
|
virt_to_phys(cpu_resume), 0, 0);
|
|
}
|
|
|
|
static int psci_system_suspend_enter(suspend_state_t state)
|
|
{
|
|
return cpu_suspend(0, psci_system_suspend);
|
|
}
|
|
|
|
static const struct platform_suspend_ops psci_suspend_ops = {
|
|
.valid = suspend_valid_only_mem,
|
|
.enter = psci_system_suspend_enter,
|
|
};
|
|
|
|
static void __init psci_init_system_suspend(void)
|
|
{
|
|
int ret;
|
|
|
|
if (!IS_ENABLED(CONFIG_SUSPEND))
|
|
return;
|
|
|
|
ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND));
|
|
|
|
if (ret != PSCI_RET_NOT_SUPPORTED)
|
|
suspend_set_ops(&psci_suspend_ops);
|
|
}
|
|
|
|
static void __init psci_init_cpu_suspend(void)
|
|
{
|
|
int feature = psci_features(psci_function_id[PSCI_FN_CPU_SUSPEND]);
|
|
|
|
if (feature != PSCI_RET_NOT_SUPPORTED)
|
|
psci_cpu_suspend_feature = feature;
|
|
}
|
|
|
|
/*
|
|
* Detect the presence of a resident Trusted OS which may cause CPU_OFF to
|
|
* return DENIED (which would be fatal).
|
|
*/
|
|
static void __init psci_init_migrate(void)
|
|
{
|
|
unsigned long cpuid;
|
|
int type, cpu = -1;
|
|
|
|
type = psci_ops.migrate_info_type();
|
|
|
|
if (type == PSCI_0_2_TOS_MP) {
|
|
pr_info("Trusted OS migration not required\n");
|
|
return;
|
|
}
|
|
|
|
if (type == PSCI_RET_NOT_SUPPORTED) {
|
|
pr_info("MIGRATE_INFO_TYPE not supported.\n");
|
|
return;
|
|
}
|
|
|
|
if (type != PSCI_0_2_TOS_UP_MIGRATE &&
|
|
type != PSCI_0_2_TOS_UP_NO_MIGRATE) {
|
|
pr_err("MIGRATE_INFO_TYPE returned unknown type (%d)\n", type);
|
|
return;
|
|
}
|
|
|
|
cpuid = psci_migrate_info_up_cpu();
|
|
if (cpuid & ~MPIDR_HWID_BITMASK) {
|
|
pr_warn("MIGRATE_INFO_UP_CPU reported invalid physical ID (0x%lx)\n",
|
|
cpuid);
|
|
return;
|
|
}
|
|
|
|
cpu = get_logical_index(cpuid);
|
|
resident_cpu = cpu >= 0 ? cpu : -1;
|
|
|
|
pr_info("Trusted OS resident on physical CPU 0x%lx\n", cpuid);
|
|
}
|
|
|
|
static void __init psci_0_2_set_functions(void)
|
|
{
|
|
pr_info("Using standard PSCI v0.2 function IDs\n");
|
|
psci_function_id[PSCI_FN_CPU_SUSPEND] =
|
|
PSCI_FN_NATIVE(0_2, CPU_SUSPEND);
|
|
psci_ops.cpu_suspend = psci_cpu_suspend;
|
|
|
|
psci_function_id[PSCI_FN_CPU_OFF] = PSCI_0_2_FN_CPU_OFF;
|
|
psci_ops.cpu_off = psci_cpu_off;
|
|
|
|
psci_function_id[PSCI_FN_CPU_ON] = PSCI_FN_NATIVE(0_2, CPU_ON);
|
|
psci_ops.cpu_on = psci_cpu_on;
|
|
|
|
psci_function_id[PSCI_FN_MIGRATE] = PSCI_FN_NATIVE(0_2, MIGRATE);
|
|
psci_ops.migrate = psci_migrate;
|
|
|
|
psci_ops.affinity_info = psci_affinity_info;
|
|
|
|
psci_ops.migrate_info_type = psci_migrate_info_type;
|
|
|
|
arm_pm_restart = psci_sys_reset;
|
|
|
|
pm_power_off = psci_sys_poweroff;
|
|
}
|
|
|
|
/*
|
|
* Probe function for PSCI firmware versions >= 0.2
|
|
*/
|
|
static int __init psci_probe(void)
|
|
{
|
|
u32 ver = psci_get_version();
|
|
|
|
pr_info("PSCIv%d.%d detected in firmware.\n",
|
|
PSCI_VERSION_MAJOR(ver),
|
|
PSCI_VERSION_MINOR(ver));
|
|
|
|
if (PSCI_VERSION_MAJOR(ver) == 0 && PSCI_VERSION_MINOR(ver) < 2) {
|
|
pr_err("Conflicting PSCI version detected.\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
psci_0_2_set_functions();
|
|
|
|
psci_init_migrate();
|
|
|
|
if (PSCI_VERSION_MAJOR(ver) >= 1) {
|
|
psci_init_cpu_suspend();
|
|
psci_init_system_suspend();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
typedef int (*psci_initcall_t)(const struct device_node *);
|
|
|
|
/*
|
|
* PSCI init function for PSCI versions >=0.2
|
|
*
|
|
* Probe based on PSCI PSCI_VERSION function
|
|
*/
|
|
static int __init psci_0_2_init(struct device_node *np)
|
|
{
|
|
int err;
|
|
|
|
err = get_set_conduit_method(np);
|
|
|
|
if (err)
|
|
goto out_put_node;
|
|
/*
|
|
* Starting with v0.2, the PSCI specification introduced a call
|
|
* (PSCI_VERSION) that allows probing the firmware version, so
|
|
* that PSCI function IDs and version specific initialization
|
|
* can be carried out according to the specific version reported
|
|
* by firmware
|
|
*/
|
|
err = psci_probe();
|
|
|
|
out_put_node:
|
|
of_node_put(np);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* PSCI < v0.2 get PSCI Function IDs via DT.
|
|
*/
|
|
static int __init psci_0_1_init(struct device_node *np)
|
|
{
|
|
u32 id;
|
|
int err;
|
|
|
|
err = get_set_conduit_method(np);
|
|
|
|
if (err)
|
|
goto out_put_node;
|
|
|
|
pr_info("Using PSCI v0.1 Function IDs from DT\n");
|
|
|
|
if (!of_property_read_u32(np, "cpu_suspend", &id)) {
|
|
psci_function_id[PSCI_FN_CPU_SUSPEND] = id;
|
|
psci_ops.cpu_suspend = psci_cpu_suspend;
|
|
}
|
|
|
|
if (!of_property_read_u32(np, "cpu_off", &id)) {
|
|
psci_function_id[PSCI_FN_CPU_OFF] = id;
|
|
psci_ops.cpu_off = psci_cpu_off;
|
|
}
|
|
|
|
if (!of_property_read_u32(np, "cpu_on", &id)) {
|
|
psci_function_id[PSCI_FN_CPU_ON] = id;
|
|
psci_ops.cpu_on = psci_cpu_on;
|
|
}
|
|
|
|
if (!of_property_read_u32(np, "migrate", &id)) {
|
|
psci_function_id[PSCI_FN_MIGRATE] = id;
|
|
psci_ops.migrate = psci_migrate;
|
|
}
|
|
|
|
out_put_node:
|
|
of_node_put(np);
|
|
return err;
|
|
}
|
|
|
|
static const struct of_device_id psci_of_match[] __initconst = {
|
|
{ .compatible = "arm,psci", .data = psci_0_1_init},
|
|
{ .compatible = "arm,psci-0.2", .data = psci_0_2_init},
|
|
{ .compatible = "arm,psci-1.0", .data = psci_0_2_init},
|
|
{},
|
|
};
|
|
|
|
int __init psci_dt_init(void)
|
|
{
|
|
struct device_node *np;
|
|
const struct of_device_id *matched_np;
|
|
psci_initcall_t init_fn;
|
|
|
|
np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);
|
|
|
|
if (!np || !of_device_is_available(np))
|
|
return -ENODEV;
|
|
|
|
init_fn = (psci_initcall_t)matched_np->data;
|
|
return init_fn(np);
|
|
}
|
|
|
|
#ifdef CONFIG_ACPI
|
|
/*
|
|
* We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's
|
|
* explicitly clarified in SBBR
|
|
*/
|
|
int __init psci_acpi_init(void)
|
|
{
|
|
if (!acpi_psci_present()) {
|
|
pr_info("is not implemented in ACPI.\n");
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
pr_info("probing for conduit method from ACPI.\n");
|
|
|
|
if (acpi_psci_use_hvc())
|
|
invoke_psci_fn = __invoke_psci_fn_hvc;
|
|
else
|
|
invoke_psci_fn = __invoke_psci_fn_smc;
|
|
|
|
return psci_probe();
|
|
}
|
|
#endif
|