Merge tag 'pm-5.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull power management updates from Rafael Wysocki:
 "These fix the (Intel-specific) Performance and Energy Bias Hint (EPB)
  handling and expose it to user space via sysfs, fix and clean up
  several cpufreq drivers, add support for two new chips to the qoriq
  cpufreq driver, fix, simplify and clean up the cpufreq core and the
  schedutil governor, add support for "CPU" domains to the generic power
  domains (genpd) framework and provide low-level PSCI firmware support
  for that feature, fix the exynos cpuidle driver and fix a couple of
  issues in the devfreq subsystem and clean it up.

  Specifics:

   - Fix the handling of Performance and Energy Bias Hint (EPB) on Intel
     processors and expose it to user space via sysfs to avoid having to
     access it through the generic MSR I/F (Rafael Wysocki).

   - Improve the handling of global turbo changes made by the platform
     firmware in the intel_pstate driver (Rafael Wysocki).

   - Convert some slow-path static_cpu_has() callers to boot_cpu_has()
     in cpufreq (Borislav Petkov).

   - Fix the frequency calculation loop in the armada-37xx cpufreq
     driver (Gregory CLEMENT).

   - Fix possible object reference leaks in multuple cpufreq drivers
     (Wen Yang).

   - Fix kerneldoc comment in the centrino cpufreq driver (dongjian).

   - Clean up the ACPI and maple cpufreq drivers (Viresh Kumar, Mohan
     Kumar).

   - Add support for lx2160a and ls1028a to the qoriq cpufreq driver
     (Vabhav Sharma, Yuantian Tang).

   - Fix kobject memory leak in the cpufreq core (Viresh Kumar).

   - Simplify the IOwait boosting in the schedutil cpufreq governor and
     rework the TSC cpufreq notifier on x86 (Rafael Wysocki).

   - Clean up the cpufreq core and statistics code (Yue Hu, Kyle Lin).

   - Improve the cpufreq documentation, add SPDX license tags to some PM
     documentation files and unify copyright notices in them (Rafael
     Wysocki).

   - Add support for "CPU" domains to the generic power domains (genpd)
     framework and provide low-level PSCI firmware support for that
     feature (Ulf Hansson).

   - Rearrange the PSCI firmware support code and add support for
     SYSTEM_RESET2 to it (Ulf Hansson, Sudeep Holla).

   - Improve genpd support for devices in multiple power domains (Ulf
     Hansson).

   - Unify target residency for the AFTR and coupled AFTR states in the
     exynos cpuidle driver (Marek Szyprowski).

   - Introduce new helper routine in the operating performance points
     (OPP) framework (Andrew-sh.Cheng).

   - Add support for passing on-die termination (ODT) and auto power
     down parameters from the kernel to Trusted Firmware-A (TF-A) to the
     rk3399_dmc devfreq driver (Enric Balletbo i Serra).

   - Add tracing to devfreq (Lukasz Luba).

   - Make the exynos-bus devfreq driver suspend all devices on system
     shutdown (Marek Szyprowski).

   - Fix a few minor issues in the devfreq subsystem and clean it up
     somewhat (Enric Balletbo i Serra, MyungJoo Ham, Rob Herring,
     Saravana Kannan, Yangtao Li).

   - Improve system wakeup diagnostics (Stephen Boyd).

   - Rework filesystem sync messages emitted during system suspend and
     hibernation (Harry Pan)"

* tag 'pm-5.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (72 commits)
  cpufreq: Fix kobject memleak
  cpufreq: armada-37xx: fix frequency calculation for opp
  cpufreq: centrino: Fix centrino_setpolicy() kerneldoc comment
  cpufreq: qoriq: add support for lx2160a
  x86: tsc: Rework time_cpufreq_notifier()
  PM / Domains: Allow to attach a CPU via genpd_dev_pm_attach_by_id|name()
  PM / Domains: Search for the CPU device outside the genpd lock
  PM / Domains: Drop unused in-parameter to some genpd functions
  PM / Domains: Use the base device for driver_deferred_probe_check_state()
  cpufreq: qoriq: Add ls1028a chip support
  PM / Domains: Enable genpd_dev_pm_attach_by_id|name() for single PM domain
  PM / Domains: Allow OF lookup for multi PM domain case from ->attach_dev()
  PM / Domains: Don't kfree() the virtual device in the error path
  cpufreq: Move ->get callback check outside of __cpufreq_get()
  PM / Domains: remove unnecessary unlikely()
  cpufreq: Remove needless bios_limit check in show_bios_limit()
  drivers/cpufreq/acpi-cpufreq.c: This fixes the following checkpatch warning
  firmware/psci: add support for SYSTEM_RESET2
  PM / devfreq: add tracing for scheduling work
  trace: events: add devfreq trace event file
  ...

1 files changed, 750 insertions, 0 deletions

diff --git a/drivers/firmware/psci/psci.c b/drivers/firmware/psci/psci.c
new file mode 100644
index 000000000000..fe090ef43d28
--- /dev/null
+++ b/drivers/firmware/psci/psci.c
@@ -0,0 +1,750 @@
+/*
+ * 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 = {
+        .conduit = PSCI_CONDUIT_NONE,
+        .smccc_version = SMCCC_VERSION_1_0,
+};
+
+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 bool psci_system_reset2_supported;
+
+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_has_osi_support(void)
+{
+        return psci_cpu_suspend_feature & PSCI_1_0_OS_INITIATED;
+}
+
+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 void set_conduit(enum psci_conduit conduit)
+{
+        switch (conduit) {
+        case PSCI_CONDUIT_HVC:
+                invoke_psci_fn = __invoke_psci_fn_hvc;
+                break;
+        case PSCI_CONDUIT_SMC:
+                invoke_psci_fn = __invoke_psci_fn_smc;
+                break;
+        default:
+                WARN(1, "Unexpected PSCI conduit %d\n", conduit);
+        }
+
+        psci_ops.conduit = conduit;
+}
+
+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)) {
+                set_conduit(PSCI_CONDUIT_HVC);
+        } else if (!strcmp("smc", method)) {
+                set_conduit(PSCI_CONDUIT_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)
+{
+        if ((reboot_mode == REBOOT_WARM || reboot_mode == REBOOT_SOFT) &&
+            psci_system_reset2_supported) {
+                /*
+                 * reset_type[31] = 0 (architectural)
+                 * reset_type[30:0] = 0 (SYSTEM_WARM_RESET)
+                 * cookie = 0 (ignored by the implementation)
+                 */
+                invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), 0, 0, 0);
+        } else {
+                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_parse_state_node(struct device_node *np, u32 *state)
+{
+        int err = of_property_read_u32(np, "arm,psci-suspend-param", state);
+
+        if (err) {
+                pr_warn("%pOF missing arm,psci-suspend-param property\n", np);
+                return err;
+        }
+
+        if (!psci_power_state_is_valid(*state)) {
+                pr_warn("Invalid PSCI power state %#x\n", *state);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int psci_dt_cpu_init_idle(struct device_node *cpu_node, int cpu)
+{
+        int i, ret = 0, 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++) {
+                state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
+                ret = psci_dt_parse_state_node(state_node, &psci_states[i]);
+                of_node_put(state_node);
+
+                if (ret)
+                        goto free_mem;
+
+                pr_debug("psci-power-state %#x index %d\n", psci_states[i], i);
+        }
+
+        /* 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],
+                                    __pa_symbol(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),
+                              __pa_symbol(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_reset2(void)
+{
+        int ret;
+
+        ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2));
+
+        if (ret != PSCI_RET_NOT_SUPPORTED)
+                psci_system_reset2_supported = true;
+}
+
+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_init_smccc(void)
+{
+        u32 ver = ARM_SMCCC_VERSION_1_0;
+        int feature;
+
+        feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID);
+
+        if (feature != PSCI_RET_NOT_SUPPORTED) {
+                u32 ret;
+                ret = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0);
+                if (ret == ARM_SMCCC_VERSION_1_1) {
+                        psci_ops.smccc_version = SMCCC_VERSION_1_1;
+                        ver = ret;
+                }
+        }
+
+        /*
+         * Conveniently, the SMCCC and PSCI versions are encoded the
+         * same way. No, this isn't accidental.
+         */
+        pr_info("SMC Calling Convention v%d.%d\n",
+                PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver));
+
+}
+
+static void __init psci_0_2_set_functions(void)
+{
+        pr_info("Using standard PSCI v0.2 function IDs\n");
+        psci_ops.get_version = psci_get_version;
+
+        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_smccc();
+                psci_init_cpu_suspend();
+                psci_init_system_suspend();
+                psci_init_system_reset2();
+        }
+
+        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)
+                return err;
+
+        /*
+         * 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
+         */
+        return psci_probe();
+}
+
+/*
+ * 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)
+                return err;
+
+        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;
+        }
+
+        return 0;
+}
+
+static int __init psci_1_0_init(struct device_node *np)
+{
+        int err;
+
+        err = psci_0_2_init(np);
+        if (err)
+                return err;
+
+        if (psci_has_osi_support())
+                pr_info("OSI mode supported.\n");
+
+        return 0;
+}
+
+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_1_0_init},
+        {},
+};
+
+int __init psci_dt_init(void)
+{
+        struct device_node *np;
+        const struct of_device_id *matched_np;
+        psci_initcall_t init_fn;
+        int ret;
+
+        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;
+        ret = init_fn(np);
+
+        of_node_put(np);
+        return ret;
+}
+
+#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())
+                set_conduit(PSCI_CONDUIT_HVC);
+        else
+                set_conduit(PSCI_CONDUIT_SMC);
+
+        return psci_probe();
+}
+#endif