1 /* 2 * Copyright (c) 2015-2018, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <arch_helpers.h> 8 #include <arm_def.h> 9 #include <arm_gic.h> 10 #include <assert.h> 11 #include <errno.h> 12 #include <plat_arm.h> 13 #include <platform.h> 14 #include <platform_def.h> 15 #include <psci.h> 16 17 /* Allow ARM Standard platforms to override these functions */ 18 #pragma weak plat_arm_psci_override_pm_ops 19 #pragma weak plat_arm_program_trusted_mailbox 20 21 /* Standard ARM platforms are expected to export plat_arm_psci_pm_ops */ 22 extern plat_psci_ops_t plat_arm_psci_pm_ops; 23 24 #if ARM_RECOM_STATE_ID_ENC 25 extern unsigned int arm_pm_idle_states[]; 26 #endif /* __ARM_RECOM_STATE_ID_ENC__ */ 27 28 #if !ARM_RECOM_STATE_ID_ENC 29 /******************************************************************************* 30 * ARM standard platform handler called to check the validity of the power state 31 * parameter. 32 ******************************************************************************/ 33 int arm_validate_power_state(unsigned int power_state, 34 psci_power_state_t *req_state) 35 { 36 int pstate = psci_get_pstate_type(power_state); 37 int pwr_lvl = psci_get_pstate_pwrlvl(power_state); 38 int i; 39 40 assert(req_state); 41 42 if (pwr_lvl > PLAT_MAX_PWR_LVL) 43 return PSCI_E_INVALID_PARAMS; 44 45 /* Sanity check the requested state */ 46 if (pstate == PSTATE_TYPE_STANDBY) { 47 /* 48 * It's possible to enter standby only on power level 0 49 * Ignore any other power level. 50 */ 51 if (pwr_lvl != ARM_PWR_LVL0) 52 return PSCI_E_INVALID_PARAMS; 53 54 req_state->pwr_domain_state[ARM_PWR_LVL0] = 55 ARM_LOCAL_STATE_RET; 56 } else { 57 for (i = ARM_PWR_LVL0; i <= pwr_lvl; i++) 58 req_state->pwr_domain_state[i] = 59 ARM_LOCAL_STATE_OFF; 60 } 61 62 /* 63 * We expect the 'state id' to be zero. 64 */ 65 if (psci_get_pstate_id(power_state)) 66 return PSCI_E_INVALID_PARAMS; 67 68 return PSCI_E_SUCCESS; 69 } 70 71 #else 72 /******************************************************************************* 73 * ARM standard platform handler called to check the validity of the power 74 * state parameter. The power state parameter has to be a composite power 75 * state. 76 ******************************************************************************/ 77 int arm_validate_power_state(unsigned int power_state, 78 psci_power_state_t *req_state) 79 { 80 unsigned int state_id; 81 int i; 82 83 assert(req_state); 84 85 /* 86 * Currently we are using a linear search for finding the matching 87 * entry in the idle power state array. This can be made a binary 88 * search if the number of entries justify the additional complexity. 89 */ 90 for (i = 0; !!arm_pm_idle_states[i]; i++) { 91 if (power_state == arm_pm_idle_states[i]) 92 break; 93 } 94 95 /* Return error if entry not found in the idle state array */ 96 if (!arm_pm_idle_states[i]) 97 return PSCI_E_INVALID_PARAMS; 98 99 i = 0; 100 state_id = psci_get_pstate_id(power_state); 101 102 /* Parse the State ID and populate the state info parameter */ 103 while (state_id) { 104 req_state->pwr_domain_state[i++] = state_id & 105 ARM_LOCAL_PSTATE_MASK; 106 state_id >>= ARM_LOCAL_PSTATE_WIDTH; 107 } 108 109 return PSCI_E_SUCCESS; 110 } 111 #endif /* __ARM_RECOM_STATE_ID_ENC__ */ 112 113 /******************************************************************************* 114 * ARM standard platform handler called to check the validity of the non secure 115 * entrypoint. Returns 0 if the entrypoint is valid, or -1 otherwise. 116 ******************************************************************************/ 117 int arm_validate_ns_entrypoint(uintptr_t entrypoint) 118 { 119 /* 120 * Check if the non secure entrypoint lies within the non 121 * secure DRAM. 122 */ 123 if ((entrypoint >= ARM_NS_DRAM1_BASE) && (entrypoint < 124 (ARM_NS_DRAM1_BASE + ARM_NS_DRAM1_SIZE))) { 125 return 0; 126 } 127 #ifndef AARCH32 128 if ((entrypoint >= ARM_DRAM2_BASE) && (entrypoint < 129 (ARM_DRAM2_BASE + ARM_DRAM2_SIZE))) { 130 return 0; 131 } 132 #endif 133 134 return -1; 135 } 136 137 int arm_validate_psci_entrypoint(uintptr_t entrypoint) 138 { 139 return arm_validate_ns_entrypoint(entrypoint) == 0 ? PSCI_E_SUCCESS : 140 PSCI_E_INVALID_ADDRESS; 141 } 142 143 /****************************************************************************** 144 * Default definition on ARM standard platforms to override the plat_psci_ops. 145 *****************************************************************************/ 146 const plat_psci_ops_t *plat_arm_psci_override_pm_ops(plat_psci_ops_t *ops) 147 { 148 return ops; 149 } 150 151 /****************************************************************************** 152 * Helper function to save the platform state before a system suspend. Save the 153 * state of the system components which are not in the Always ON power domain. 154 *****************************************************************************/ 155 void arm_system_pwr_domain_save(void) 156 { 157 /* Assert system power domain is available on the platform */ 158 assert(PLAT_MAX_PWR_LVL >= ARM_PWR_LVL2); 159 160 plat_arm_gic_save(); 161 162 /* 163 * Unregister console now so that it is not registered for a second 164 * time during resume. 165 */ 166 arm_console_runtime_end(); 167 168 /* 169 * All the other peripheral which are configured by ARM TF are 170 * re-initialized on resume from system suspend. Hence we 171 * don't save their state here. 172 */ 173 } 174 175 /****************************************************************************** 176 * Helper function to resume the platform from system suspend. Reinitialize 177 * the system components which are not in the Always ON power domain. 178 * TODO: Unify the platform setup when waking up from cold boot and system 179 * resume in arm_bl31_platform_setup(). 180 *****************************************************************************/ 181 void arm_system_pwr_domain_resume(void) 182 { 183 /* Initialize the console */ 184 arm_console_runtime_init(); 185 186 /* Assert system power domain is available on the platform */ 187 assert(PLAT_MAX_PWR_LVL >= ARM_PWR_LVL2); 188 189 plat_arm_gic_resume(); 190 191 plat_arm_security_setup(); 192 arm_configure_sys_timer(); 193 } 194 195 /******************************************************************************* 196 * ARM platform function to program the mailbox for a cpu before it is released 197 * from reset. This function assumes that the Trusted mail box base is within 198 * the ARM_SHARED_RAM region 199 ******************************************************************************/ 200 void plat_arm_program_trusted_mailbox(uintptr_t address) 201 { 202 uintptr_t *mailbox = (void *) PLAT_ARM_TRUSTED_MAILBOX_BASE; 203 204 *mailbox = address; 205 206 /* 207 * Ensure that the PLAT_ARM_TRUSTED_MAILBOX_BASE is within 208 * ARM_SHARED_RAM region. 209 */ 210 assert((PLAT_ARM_TRUSTED_MAILBOX_BASE >= ARM_SHARED_RAM_BASE) && 211 ((PLAT_ARM_TRUSTED_MAILBOX_BASE + sizeof(*mailbox)) <= \ 212 (ARM_SHARED_RAM_BASE + ARM_SHARED_RAM_SIZE))); 213 } 214 215 /******************************************************************************* 216 * The ARM Standard platform definition of platform porting API 217 * `plat_setup_psci_ops`. 218 ******************************************************************************/ 219 int plat_setup_psci_ops(uintptr_t sec_entrypoint, 220 const plat_psci_ops_t **psci_ops) 221 { 222 *psci_ops = plat_arm_psci_override_pm_ops(&plat_arm_psci_pm_ops); 223 224 /* Setup mailbox with entry point. */ 225 plat_arm_program_trusted_mailbox(sec_entrypoint); 226 return 0; 227 } 228