Release 4.11 drivers/firmware/psci.c

Directory: drivers/firmware
/*
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
Mark Rutland 13 100.00% 1 100.00%
Total 13 100.00% 1 100.00%


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;
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 24 92.31% 2 50.00%
JiSheng Zhang 1 3.85% 1 25.00%
Arnd Bergmann 1 3.85% 1 25.00%
Total 26 100.00% 4 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 28 93.33% 2 50.00%
Arnd Bergmann 1 3.33% 1 25.00%
JiSheng Zhang 1 3.33% 1 25.00%
Total 30 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Jens Wiklander 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Jens Wiklander 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 44 88.00% 1 33.33%
Ashwin Chaugule 3 6.00% 1 33.33%
Lorenzo Pieralisi 3 6.00% 1 33.33%
Total 50 100.00% 3 100.00%



static u32 psci_get_version(void)
{
	return invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 18 90.00% 1 50.00%
Mark Rutland 2 10.00% 1 50.00%
Total 20 100.00% 2 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 43 95.56% 1 50.00%
Mark Rutland 2 4.44% 1 50.00%
Total 45 100.00% 2 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 39 95.12% 1 50.00%
Mark Rutland 2 4.88% 1 50.00%
Total 41 100.00% 2 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 22 70.97% 1 20.00%
Mark Rutland 4 12.90% 2 40.00%
Sudeep Holla 3 9.68% 1 20.00%
Will Deacon 2 6.45% 1 20.00%
Total 31 100.00% 5 100.00%



static int psci_migrate_info_type(void)
{
	return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 9 45.00% 1 33.33%
Will Deacon 7 35.00% 1 33.33%
Mark Rutland 4 20.00% 1 33.33%
Total 20 100.00% 3 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Mark Rutland 20 76.92% 2 50.00%
Ashwin Chaugule 3 11.54% 1 25.00%
Sudeep Holla 3 11.54% 1 25.00%
Total 26 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 65 69.15% 1 50.00%
Ashwin Chaugule 29 30.85% 1 50.00%
Total 94 100.00% 2 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 25 96.15% 1 50.00%
Will Deacon 1 3.85% 1 50.00%
Total 26 100.00% 2 100.00%



static void psci_sys_poweroff(void)
{
	invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int __init psci_features(u32 psci_func_id)
{
	return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES,
			      psci_func_id, 0, 0);
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%

#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;
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 224 100.00% 1 100.00%
Total 224 100.00% 1 100.00%

#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;
}
Contributors
Person Tokens Prop Commits CommitProp
Sudeep Holla 185 100.00% 1 100.00%
Total 185 100.00% 1 100.00%

#else


static int __maybe_unused psci_acpi_cpu_init_idle(unsigned int cpu)
{
	return -EINVAL;
}
Contributors
Person Tokens Prop Commits CommitProp
Sudeep Holla 15 100.00% 1 100.00%
Total 15 100.00% 1 100.00%

#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;
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 52 69.33% 1 50.00%
Sudeep Holla 23 30.67% 1 50.00%
Total 75 100.00% 2 100.00%



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));
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 36 97.30% 1 50.00%
Laura Abbott 1 2.70% 1 50.00%
Total 37 100.00% 2 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 76 100.00% 1 100.00%
Total 76 100.00% 1 100.00%

/* 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);
}

Contributors
Person Tokens Prop Commits CommitProp
Sudeep Holla 29 96.67% 1 50.00%
Geert Uytterhoeven 1 3.33% 1 50.00%
Total 30 100.00% 2 100.00%



static int psci_system_suspend_enter(suspend_state_t state)
{
	return cpu_suspend(0, psci_system_suspend);
}

Contributors
Person Tokens Prop Commits CommitProp
Sudeep Holla 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%


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);
}

Contributors
Person Tokens Prop Commits CommitProp
Sudeep Holla 45 100.00% 1 100.00%
Total 45 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%

/*
 * 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);
}

Contributors
Person Tokens Prop Commits CommitProp
Mark Rutland 82 66.67% 1 50.00%
Ashwin Chaugule 41 33.33% 1 50.00%
Total 123 100.00% 2 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 74 73.27% 1 25.00%
Mark Rutland 18 17.82% 2 50.00%
Sudeep Holla 9 8.91% 1 25.00%
Total 101 100.00% 4 100.00%

/*
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
Mark Rutland 66 79.52% 1 25.00%
Lorenzo Pieralisi 14 16.87% 2 50.00%
Sudeep Holla 3 3.61% 1 25.00%
Total 83 100.00% 4 100.00%


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;
}

Contributors
Person Tokens Prop Commits CommitProp
Mark Rutland 34 75.56% 1 50.00%
Ashwin Chaugule 11 24.44% 1 50.00%
Total 45 100.00% 2 100.00%

/*
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
Will Deacon 113 71.07% 1 33.33%
Ashwin Chaugule 45 28.30% 1 33.33%
Mark Rutland 1 0.63% 1 33.33%
Total 159 100.00% 3 100.00%


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);
}

Contributors
Person Tokens Prop Commits CommitProp
Ashwin Chaugule 56 87.50% 1 25.00%
Thierry Reding 6 9.38% 1 25.00%
Will Deacon 1 1.56% 1 25.00%
Mark Rutland 1 1.56% 1 25.00%
Total 64 100.00% 4 100.00%

#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();
}
Contributors
Person Tokens Prop Commits CommitProp
Mark Rutland 48 100.00% 1 100.00%
Total 48 100.00% 1 100.00%

#endif
Overall Contributors
Person Tokens Prop Commits CommitProp
Lorenzo Pieralisi 604 25.83% 7 31.82%
Will Deacon 451 19.29% 1 4.55%
Ashwin Chaugule 404 17.28% 1 4.55%
Sudeep Holla 379 16.21% 4 18.18%
Mark Rutland 375 16.04% 2 9.09%
Jens Wiklander 111 4.75% 1 4.55%
Thierry Reding 6 0.26% 1 4.55%
JiSheng Zhang 4 0.17% 2 9.09%
Arnd Bergmann 2 0.09% 1 4.55%
Laura Abbott 1 0.04% 1 4.55%
Geert Uytterhoeven 1 0.04% 1 4.55%
Total 2338 100.00% 22 100.00%
Directory: drivers/firmware

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Mark Rutland	13	100.00%	1	100.00%
Total	13	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 drivers/firmware/psci.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
