2015-07-31 17:46:16 +03:00
/*
* 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
2016-07-19 20:52:57 +03:00
# include <linux/acpi.h>
2016-01-04 17:46:47 +03:00
# include <linux/arm-smccc.h>
2016-02-01 20:01:30 +03:00
# include <linux/cpuidle.h>
2015-07-31 17:46:16 +03:00
# 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>
2016-02-01 20:01:30 +03:00
# include <linux/slab.h>
2015-06-18 17:41:34 +03:00
# include <linux/suspend.h>
2015-07-31 17:46:16 +03:00
# include <uapi/linux/psci.h>
2016-02-01 20:01:30 +03:00
# include <asm/cpuidle.h>
2015-07-31 17:46:16 +03:00
# include <asm/cputype.h>
# include <asm/system_misc.h>
# include <asm/smp_plat.h>
2015-06-18 17:41:34 +03:00
# include <asm/suspend.h>
2015-07-31 17:46:16 +03:00
2015-07-31 17:46:17 +03:00
/*
* While a 64 - bit OS can make calls with SMC32 calling conventions , for some
2015-06-18 17:41:33 +03:00
* 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 .
2015-07-31 17:46:17 +03:00
*/
# ifdef CONFIG_64BIT
2015-06-18 17:41:33 +03:00
# define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN64_##name
2015-07-31 17:46:17 +03:00
# else
2015-06-18 17:41:33 +03:00
# define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN_##name
2015-07-31 17:46:17 +03:00
# endif
2015-07-31 17:46:16 +03:00
/*
* 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 ;
}
2018-02-06 20:56:16 +03:00
struct psci_operations psci_ops = {
. conduit = PSCI_CONDUIT_NONE ,
2018-02-06 20:56:17 +03:00
. smccc_version = SMCCC_VERSION_1_0 ,
2018-02-06 20:56:16 +03:00
} ;
2015-07-31 17:46:16 +03:00
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 ] ;
2015-05-26 18:49:01 +03:00
# 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 )
2015-05-26 19:10:32 +03:00
# 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 ;
}
2016-04-26 03:13:30 +03:00
static inline bool psci_power_state_loses_context ( u32 state )
2015-05-26 18:49:01 +03:00
{
2015-05-26 19:10:32 +03:00
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 ;
2015-05-26 18:49:01 +03:00
}
2016-04-26 03:13:30 +03:00
static inline bool psci_power_state_is_valid ( u32 state )
2015-05-26 18:49:01 +03:00
{
2015-05-26 19:10:32 +03:00
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 ) ;
2015-05-26 18:49:01 +03:00
}
2016-01-04 17:46:47 +03: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 ;
}
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 ;
}
2015-07-31 17:46:16 +03: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 :
2015-05-22 16:31:37 +03:00
case PSCI_RET_INVALID_ADDRESS :
2015-07-31 17:46:16 +03:00
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 )
{
2015-06-18 17:41:33 +03:00
return invoke_psci_fn ( PSCI_FN_NATIVE ( 0 _2 , AFFINITY_INFO ) ,
2015-07-31 17:46:17 +03:00
target_affinity , lowest_affinity_level , 0 ) ;
2015-07-31 17:46:16 +03:00
}
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 )
{
2015-06-18 17:41:33 +03:00
return invoke_psci_fn ( PSCI_FN_NATIVE ( 0 _2 , MIGRATE_INFO_UP_CPU ) ,
2015-07-31 17:46:17 +03:00
0 , 0 , 0 ) ;
2015-07-31 17:46:16 +03:00
}
2018-02-06 20:56:16 +03:00
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 ;
}
2015-07-31 17:46:16 +03: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 ) ) {
2018-02-06 20:56:16 +03:00
set_conduit ( PSCI_CONDUIT_HVC ) ;
2015-07-31 17:46:16 +03:00
} else if ( ! strcmp ( " smc " , method ) ) {
2018-02-06 20:56:16 +03:00
set_conduit ( PSCI_CONDUIT_SMC ) ;
2015-07-31 17:46:16 +03:00
} 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 ) ;
}
2015-05-26 19:06:21 +03: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 ) ;
}
2016-02-01 20:01:30 +03: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 ) {
2017-07-19 00:43:01 +03:00
pr_warn ( " * %pOF missing arm,psci-suspend-param property \n " ,
state_node ) ;
2016-02-01 20:01:30 +03:00
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 ;
}
2016-07-19 20:52:57 +03: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 ;
}
# else
static int __maybe_unused psci_acpi_cpu_init_idle ( unsigned int cpu )
{
return - EINVAL ;
}
# endif
2016-02-01 20:01:30 +03:00
int psci_cpu_init_idle ( unsigned int cpu )
{
struct device_node * cpu_node ;
int ret ;
2016-07-19 20:52:57 +03:00
/*
* 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 ) ;
2016-02-01 20:01:30 +03:00
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 ] ,
2017-01-11 00:35:46 +03:00
__pa_symbol ( cpu_resume ) ) ;
2016-02-01 20:01:30 +03: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 ;
}
/* ARM specific CPU idle operations */
# ifdef CONFIG_ARM
2016-03-22 17:42:43 +03:00
static const struct cpuidle_ops psci_cpuidle_ops __initconst = {
2016-02-01 20:01:30 +03:00
. suspend = psci_cpu_suspend_enter ,
. init = psci_dt_cpu_init_idle ,
} ;
2016-04-22 18:18:02 +03:00
CPUIDLE_METHOD_OF_DECLARE ( psci , " psci " , & psci_cpuidle_ops ) ;
2016-02-01 20:01:30 +03:00
# endif
# endif
2015-06-18 17:41:34 +03:00
static int psci_system_suspend ( unsigned long unused )
{
return invoke_psci_fn ( PSCI_FN_NATIVE ( 1 _0 , SYSTEM_SUSPEND ) ,
2017-01-24 18:30:19 +03:00
__pa_symbol ( cpu_resume ) , 0 , 0 ) ;
2015-06-18 17:41:34 +03:00
}
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 ) ;
}
2015-05-26 19:10:32 +03: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 ;
}
2015-07-31 17:46:16 +03: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 ) ;
}
2018-02-06 20:56:17 +03:00
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 ) ) ;
}
2015-07-31 17:46:16 +03:00
static void __init psci_0_2_set_functions ( void )
{
pr_info ( " Using standard PSCI v0.2 function IDs \n " ) ;
2018-01-03 00:45:41 +03:00
psci_ops . get_version = psci_get_version ;
2015-06-18 17:41:33 +03:00
psci_function_id [ PSCI_FN_CPU_SUSPEND ] =
PSCI_FN_NATIVE ( 0 _2 , CPU_SUSPEND ) ;
2015-07-31 17:46:16 +03:00
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 ;
2015-06-18 17:41:33 +03:00
psci_function_id [ PSCI_FN_CPU_ON ] = PSCI_FN_NATIVE ( 0 _2 , CPU_ON ) ;
2015-07-31 17:46:16 +03:00
psci_ops . cpu_on = psci_cpu_on ;
2015-06-18 17:41:33 +03:00
psci_function_id [ PSCI_FN_MIGRATE ] = PSCI_FN_NATIVE ( 0 _2 , MIGRATE ) ;
2015-07-31 17:46:16 +03:00
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 ( ) ;
2015-10-23 17:46:50 +03:00
if ( PSCI_VERSION_MAJOR ( ver ) > = 1 ) {
2018-02-06 20:56:17 +03:00
psci_init_smccc ( ) ;
2015-10-23 17:46:50 +03:00
psci_init_cpu_suspend ( ) ;
psci_init_system_suspend ( ) ;
}
2015-06-18 17:41:34 +03:00
2015-07-31 17:46:16 +03:00
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 ;
}
2016-04-20 13:20:27 +03:00
static const struct of_device_id psci_of_match [ ] __initconst = {
2015-07-31 17:46:16 +03:00
{ . compatible = " arm,psci " , . data = psci_0_1_init } ,
{ . compatible = " arm,psci-0.2 " , . data = psci_0_2_init } ,
2015-05-26 15:06:57 +03:00
{ . compatible = " arm,psci-1.0 " , . data = psci_0_2_init } ,
2015-07-31 17:46:16 +03:00
{ } ,
} ;
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 ) ;
2016-11-08 20:55:47 +03:00
if ( ! np | | ! of_device_is_available ( np ) )
2015-07-31 17:46:16 +03:00
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 ( ) )
2018-02-06 20:56:16 +03:00
set_conduit ( PSCI_CONDUIT_HVC ) ;
2015-07-31 17:46:16 +03:00
else
2018-02-06 20:56:16 +03:00
set_conduit ( PSCI_CONDUIT_SMC ) ;
2015-07-31 17:46:16 +03:00
return psci_probe ( ) ;
}
# endif