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 <assert.h> 8 #include <string.h> 9 10 #include <arch.h> 11 #include <arch_helpers.h> 12 #include <common/bl_common.h> 13 #include <common/debug.h> 14 #include <context.h> 15 #include <cortex_a57.h> 16 #include <denver.h> 17 #include <lib/el3_runtime/context_mgmt.h> 18 #include <lib/psci/psci.h> 19 #include <plat/common/platform.h> 20 21 #include <mce.h> 22 #include <smmu.h> 23 #include <stdbool.h> 24 #include <t18x_ari.h> 25 #include <tegra186_private.h> 26 #include <tegra_private.h> 27 28 extern void memcpy16(void *dest, const void *src, unsigned int length); 29 30 /* state id mask */ 31 #define TEGRA186_STATE_ID_MASK 0xFU 32 /* constants to get power state's wake time */ 33 #define TEGRA186_WAKE_TIME_MASK 0x0FFFFFF0U 34 #define TEGRA186_WAKE_TIME_SHIFT 4U 35 /* default core wake mask for CPU_SUSPEND */ 36 #define TEGRA186_CORE_WAKE_MASK 0x180cU 37 /* context size to save during system suspend */ 38 #define TEGRA186_SE_CONTEXT_SIZE 3U 39 40 static uint32_t se_regs[TEGRA186_SE_CONTEXT_SIZE]; 41 static struct tegra_psci_percpu_data { 42 uint32_t wake_time; 43 } __aligned(CACHE_WRITEBACK_GRANULE) tegra_percpu_data[PLATFORM_CORE_COUNT]; 44 45 int32_t tegra_soc_validate_power_state(uint32_t power_state, 46 psci_power_state_t *req_state) 47 { 48 uint8_t state_id = (uint8_t)psci_get_pstate_id(power_state) & TEGRA186_STATE_ID_MASK; 49 uint32_t cpu = plat_my_core_pos(); 50 int32_t ret = PSCI_E_SUCCESS; 51 52 /* save the core wake time (in TSC ticks)*/ 53 tegra_percpu_data[cpu].wake_time = (power_state & TEGRA186_WAKE_TIME_MASK) 54 << TEGRA186_WAKE_TIME_SHIFT; 55 56 /* 57 * Clean percpu_data[cpu] to DRAM. This needs to be done to ensure that 58 * the correct value is read in tegra_soc_pwr_domain_suspend(), which 59 * is called with caches disabled. It is possible to read a stale value 60 * from DRAM in that function, because the L2 cache is not flushed 61 * unless the cluster is entering CC6/CC7. 62 */ 63 clean_dcache_range((uint64_t)&tegra_percpu_data[cpu], 64 sizeof(tegra_percpu_data[cpu])); 65 66 /* Sanity check the requested state id */ 67 switch (state_id) { 68 case PSTATE_ID_CORE_IDLE: 69 case PSTATE_ID_CORE_POWERDN: 70 71 /* Core powerdown request */ 72 req_state->pwr_domain_state[MPIDR_AFFLVL0] = state_id; 73 req_state->pwr_domain_state[MPIDR_AFFLVL1] = state_id; 74 75 break; 76 77 default: 78 ERROR("%s: unsupported state id (%d)\n", __func__, state_id); 79 ret = PSCI_E_INVALID_PARAMS; 80 break; 81 } 82 83 return ret; 84 } 85 86 int32_t tegra_soc_pwr_domain_suspend(const psci_power_state_t *target_state) 87 { 88 const plat_local_state_t *pwr_domain_state; 89 uint8_t stateid_afflvl0, stateid_afflvl2; 90 uint32_t cpu = plat_my_core_pos(); 91 const plat_params_from_bl2_t *params_from_bl2 = bl31_get_plat_params(); 92 mce_cstate_info_t cstate_info = { 0 }; 93 uint64_t smmu_ctx_base; 94 uint32_t val; 95 96 /* get the state ID */ 97 pwr_domain_state = target_state->pwr_domain_state; 98 stateid_afflvl0 = pwr_domain_state[MPIDR_AFFLVL0] & 99 TEGRA186_STATE_ID_MASK; 100 stateid_afflvl2 = pwr_domain_state[PLAT_MAX_PWR_LVL] & 101 TEGRA186_STATE_ID_MASK; 102 103 if ((stateid_afflvl0 == PSTATE_ID_CORE_IDLE) || 104 (stateid_afflvl0 == PSTATE_ID_CORE_POWERDN)) { 105 106 /* Enter CPU idle/powerdown */ 107 val = (stateid_afflvl0 == PSTATE_ID_CORE_IDLE) ? 108 (uint32_t)TEGRA_ARI_CORE_C6 : (uint32_t)TEGRA_ARI_CORE_C7; 109 (void)mce_command_handler((uint64_t)MCE_CMD_ENTER_CSTATE, (uint64_t)val, 110 tegra_percpu_data[cpu].wake_time, 0U); 111 112 } else if (stateid_afflvl2 == PSTATE_ID_SOC_POWERDN) { 113 114 /* save SE registers */ 115 se_regs[0] = mmio_read_32(TEGRA_SE0_BASE + 116 SE_MUTEX_WATCHDOG_NS_LIMIT); 117 se_regs[1] = mmio_read_32(TEGRA_RNG1_BASE + 118 RNG_MUTEX_WATCHDOG_NS_LIMIT); 119 se_regs[2] = mmio_read_32(TEGRA_PKA1_BASE + 120 PKA_MUTEX_WATCHDOG_NS_LIMIT); 121 122 /* save 'Secure Boot' Processor Feature Config Register */ 123 val = mmio_read_32(TEGRA_MISC_BASE + MISCREG_PFCFG); 124 mmio_write_32(TEGRA_SCRATCH_BASE + SCRATCH_SECURE_BOOTP_FCFG, val); 125 126 /* save SMMU context to TZDRAM */ 127 smmu_ctx_base = params_from_bl2->tzdram_base + 128 tegra186_get_smmu_ctx_offset(); 129 tegra_smmu_save_context((uintptr_t)smmu_ctx_base); 130 131 /* Prepare for system suspend */ 132 cstate_info.cluster = (uint32_t)TEGRA_ARI_CLUSTER_CC7; 133 cstate_info.system = (uint32_t)TEGRA_ARI_SYSTEM_SC7; 134 cstate_info.system_state_force = 1; 135 cstate_info.update_wake_mask = 1; 136 mce_update_cstate_info(&cstate_info); 137 138 /* Loop until system suspend is allowed */ 139 do { 140 val = (uint32_t)mce_command_handler( 141 (uint64_t)MCE_CMD_IS_SC7_ALLOWED, 142 (uint64_t)TEGRA_ARI_CORE_C7, 143 MCE_CORE_SLEEP_TIME_INFINITE, 144 0U); 145 } while (val == 0U); 146 147 /* Instruct the MCE to enter system suspend state */ 148 (void)mce_command_handler((uint64_t)MCE_CMD_ENTER_CSTATE, 149 (uint64_t)TEGRA_ARI_CORE_C7, MCE_CORE_SLEEP_TIME_INFINITE, 0U); 150 151 /* set system suspend state for house-keeping */ 152 tegra186_set_system_suspend_entry(); 153 154 } else { 155 ; /* do nothing */ 156 } 157 158 return PSCI_E_SUCCESS; 159 } 160 161 /******************************************************************************* 162 * Helper function to check if this is the last ON CPU in the cluster 163 ******************************************************************************/ 164 static bool tegra_last_cpu_in_cluster(const plat_local_state_t *states, 165 uint32_t ncpu) 166 { 167 plat_local_state_t target; 168 bool last_on_cpu = true; 169 uint32_t num_cpus = ncpu, pos = 0; 170 171 do { 172 target = states[pos]; 173 if (target != PLAT_MAX_OFF_STATE) { 174 last_on_cpu = false; 175 } 176 --num_cpus; 177 pos++; 178 } while (num_cpus != 0U); 179 180 return last_on_cpu; 181 } 182 183 /******************************************************************************* 184 * Helper function to get target power state for the cluster 185 ******************************************************************************/ 186 static plat_local_state_t tegra_get_afflvl1_pwr_state(const plat_local_state_t *states, 187 uint32_t ncpu) 188 { 189 uint32_t core_pos = (uint32_t)read_mpidr() & (uint32_t)MPIDR_CPU_MASK; 190 uint32_t cpu = plat_my_core_pos(); 191 int32_t ret; 192 plat_local_state_t target = states[core_pos]; 193 mce_cstate_info_t cstate_info = { 0 }; 194 195 /* CPU suspend */ 196 if (target == PSTATE_ID_CORE_POWERDN) { 197 /* Program default wake mask */ 198 cstate_info.wake_mask = TEGRA186_CORE_WAKE_MASK; 199 cstate_info.update_wake_mask = 1; 200 mce_update_cstate_info(&cstate_info); 201 202 /* Check if CCx state is allowed. */ 203 ret = mce_command_handler((uint64_t)MCE_CMD_IS_CCX_ALLOWED, 204 (uint64_t)TEGRA_ARI_CORE_C7, 205 tegra_percpu_data[cpu].wake_time, 206 0U); 207 if (ret == 0) { 208 target = PSCI_LOCAL_STATE_RUN; 209 } 210 } 211 212 /* CPU off */ 213 if (target == PLAT_MAX_OFF_STATE) { 214 /* Enable cluster powerdn from last CPU in the cluster */ 215 if (tegra_last_cpu_in_cluster(states, ncpu)) { 216 /* Enable CC7 state and turn off wake mask */ 217 cstate_info.cluster = (uint32_t)TEGRA_ARI_CLUSTER_CC7; 218 cstate_info.update_wake_mask = 1; 219 mce_update_cstate_info(&cstate_info); 220 221 /* Check if CCx state is allowed. */ 222 ret = mce_command_handler((uint64_t)MCE_CMD_IS_CCX_ALLOWED, 223 (uint64_t)TEGRA_ARI_CORE_C7, 224 MCE_CORE_SLEEP_TIME_INFINITE, 225 0U); 226 if (ret == 0) { 227 target = PSCI_LOCAL_STATE_RUN; 228 } 229 230 } else { 231 232 /* Turn off wake_mask */ 233 cstate_info.update_wake_mask = 1; 234 mce_update_cstate_info(&cstate_info); 235 target = PSCI_LOCAL_STATE_RUN; 236 } 237 } 238 239 return target; 240 } 241 242 /******************************************************************************* 243 * Platform handler to calculate the proper target power level at the 244 * specified affinity level 245 ******************************************************************************/ 246 plat_local_state_t tegra_soc_get_target_pwr_state(uint32_t lvl, 247 const plat_local_state_t *states, 248 uint32_t ncpu) 249 { 250 plat_local_state_t target = PSCI_LOCAL_STATE_RUN; 251 uint32_t cpu = plat_my_core_pos(); 252 253 /* System Suspend */ 254 if ((lvl == (uint32_t)MPIDR_AFFLVL2) && 255 (states[cpu] == PSTATE_ID_SOC_POWERDN)) { 256 target = PSTATE_ID_SOC_POWERDN; 257 } 258 259 /* CPU off, CPU suspend */ 260 if (lvl == (uint32_t)MPIDR_AFFLVL1) { 261 target = tegra_get_afflvl1_pwr_state(states, ncpu); 262 } 263 264 /* target cluster/system state */ 265 return target; 266 } 267 268 int32_t tegra_soc_pwr_domain_power_down_wfi(const psci_power_state_t *target_state) 269 { 270 const plat_local_state_t *pwr_domain_state = 271 target_state->pwr_domain_state; 272 const plat_params_from_bl2_t *params_from_bl2 = bl31_get_plat_params(); 273 uint8_t stateid_afflvl2 = pwr_domain_state[PLAT_MAX_PWR_LVL] & 274 TEGRA186_STATE_ID_MASK; 275 uint64_t val; 276 277 if (stateid_afflvl2 == PSTATE_ID_SOC_POWERDN) { 278 /* 279 * The TZRAM loses power when we enter system suspend. To 280 * allow graceful exit from system suspend, we need to copy 281 * BL3-1 over to TZDRAM. 282 */ 283 val = params_from_bl2->tzdram_base + 284 tegra186_get_cpu_reset_handler_size(); 285 memcpy16((void *)(uintptr_t)val, (void *)(uintptr_t)BL31_BASE, 286 (uintptr_t)&__BL31_END__ - (uintptr_t)BL31_BASE); 287 } 288 289 return PSCI_E_SUCCESS; 290 } 291 292 int32_t tegra_soc_pwr_domain_on(u_register_t mpidr) 293 { 294 int32_t ret = PSCI_E_SUCCESS; 295 uint64_t target_cpu = mpidr & MPIDR_CPU_MASK; 296 uint64_t target_cluster = (mpidr & MPIDR_CLUSTER_MASK) >> 297 MPIDR_AFFINITY_BITS; 298 299 if (target_cluster > ((uint32_t)PLATFORM_CLUSTER_COUNT - 1U)) { 300 301 ERROR("%s: unsupported CPU (0x%lx)\n", __func__, mpidr); 302 ret = PSCI_E_NOT_PRESENT; 303 304 } else { 305 /* construct the target CPU # */ 306 target_cpu |= (target_cluster << 2); 307 308 (void)mce_command_handler((uint64_t)MCE_CMD_ONLINE_CORE, target_cpu, 0U, 0U); 309 } 310 311 return ret; 312 } 313 314 int32_t tegra_soc_pwr_domain_on_finish(const psci_power_state_t *target_state) 315 { 316 uint8_t stateid_afflvl2 = target_state->pwr_domain_state[PLAT_MAX_PWR_LVL]; 317 uint8_t stateid_afflvl0 = target_state->pwr_domain_state[MPIDR_AFFLVL0]; 318 mce_cstate_info_t cstate_info = { 0 }; 319 uint64_t impl, val; 320 const plat_params_from_bl2_t *plat_params = bl31_get_plat_params(); 321 322 impl = (read_midr() >> MIDR_IMPL_SHIFT) & MIDR_IMPL_MASK; 323 324 /* 325 * Enable ECC and Parity Protection for Cortex-A57 CPUs (Tegra186 326 * A02p and beyond). 327 */ 328 if ((plat_params->l2_ecc_parity_prot_dis != 1) && (impl != DENVER_IMPL)) { 329 330 val = read_l2ctlr_el1(); 331 val |= CORTEX_A57_L2_ECC_PARITY_PROTECTION_BIT; 332 write_l2ctlr_el1(val); 333 } 334 335 /* 336 * Reset power state info for CPUs when onlining, we set 337 * deepest power when offlining a core but that may not be 338 * requested by non-secure sw which controls idle states. It 339 * will re-init this info from non-secure software when the 340 * core come online. 341 */ 342 if (stateid_afflvl0 == PLAT_MAX_OFF_STATE) { 343 344 cstate_info.cluster = (uint32_t)TEGRA_ARI_CLUSTER_CC1; 345 cstate_info.update_wake_mask = 1; 346 mce_update_cstate_info(&cstate_info); 347 } 348 349 /* 350 * Check if we are exiting from deep sleep and restore SE 351 * context if we are. 352 */ 353 if (stateid_afflvl2 == PSTATE_ID_SOC_POWERDN) { 354 355 mmio_write_32(TEGRA_SE0_BASE + SE_MUTEX_WATCHDOG_NS_LIMIT, 356 se_regs[0]); 357 mmio_write_32(TEGRA_RNG1_BASE + RNG_MUTEX_WATCHDOG_NS_LIMIT, 358 se_regs[1]); 359 mmio_write_32(TEGRA_PKA1_BASE + PKA_MUTEX_WATCHDOG_NS_LIMIT, 360 se_regs[2]); 361 362 /* Init SMMU */ 363 tegra_smmu_init(); 364 365 /* 366 * Reset power state info for the last core doing SC7 367 * entry and exit, we set deepest power state as CC7 368 * and SC7 for SC7 entry which may not be requested by 369 * non-secure SW which controls idle states. 370 */ 371 cstate_info.cluster = (uint32_t)TEGRA_ARI_CLUSTER_CC7; 372 cstate_info.system = (uint32_t)TEGRA_ARI_SYSTEM_SC1; 373 cstate_info.update_wake_mask = 1; 374 mce_update_cstate_info(&cstate_info); 375 } 376 377 return PSCI_E_SUCCESS; 378 } 379 380 int32_t tegra_soc_pwr_domain_off(const psci_power_state_t *target_state) 381 { 382 uint64_t impl = (read_midr() >> MIDR_IMPL_SHIFT) & (uint64_t)MIDR_IMPL_MASK; 383 384 (void)target_state; 385 386 /* Disable Denver's DCO operations */ 387 if (impl == DENVER_IMPL) { 388 denver_disable_dco(); 389 } 390 391 /* Turn off CPU */ 392 (void)mce_command_handler((uint64_t)MCE_CMD_ENTER_CSTATE, 393 (uint64_t)TEGRA_ARI_CORE_C7, MCE_CORE_SLEEP_TIME_INFINITE, 0U); 394 395 return PSCI_E_SUCCESS; 396 } 397 398 __dead2 void tegra_soc_prepare_system_off(void) 399 { 400 /* power off the entire system */ 401 mce_enter_ccplex_state((uint32_t)TEGRA_ARI_MISC_CCPLEX_SHUTDOWN_POWER_OFF); 402 403 wfi(); 404 405 /* wait for the system to power down */ 406 for (;;) { 407 ; 408 } 409 } 410 411 int32_t tegra_soc_prepare_system_reset(void) 412 { 413 mce_enter_ccplex_state((uint32_t)TEGRA_ARI_MISC_CCPLEX_SHUTDOWN_REBOOT); 414 415 return PSCI_E_SUCCESS; 416 } 417