1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * AM33XX Arch Power Management Routines 4 * 5 * Copyright (C) 2016-2018 Texas Instruments Incorporated - https://www.ti.com/ 6 * Dave Gerlach 7 */ 8 9 #include <linux/cpuidle.h> 10 #include <linux/platform_data/pm33xx.h> 11 #include <linux/suspend.h> 12 #include <asm/cpuidle.h> 13 #include <asm/smp_scu.h> 14 #include <asm/suspend.h> 15 #include <linux/errno.h> 16 #include <linux/clk.h> 17 #include <linux/cpu.h> 18 #include <linux/platform_data/gpio-omap.h> 19 #include <linux/wkup_m3_ipc.h> 20 #include <linux/of.h> 21 #include <linux/rtc.h> 22 23 #include "cm33xx.h" 24 #include "common.h" 25 #include "control.h" 26 #include "clockdomain.h" 27 #include "iomap.h" 28 #include "pm.h" 29 #include "powerdomain.h" 30 #include "prm33xx.h" 31 #include "soc.h" 32 #include "sram.h" 33 #include "omap-secure.h" 34 35 static struct powerdomain *cefuse_pwrdm, *gfx_pwrdm, *per_pwrdm, *mpu_pwrdm; 36 static struct clockdomain *gfx_l4ls_clkdm; 37 static void __iomem *scu_base; 38 39 static int (*idle_fn)(u32 wfi_flags); 40 41 struct amx3_idle_state { 42 int wfi_flags; 43 }; 44 45 static struct amx3_idle_state *idle_states; 46 47 static int am43xx_map_scu(void) 48 { 49 scu_base = ioremap(scu_a9_get_base(), SZ_256); 50 51 if (!scu_base) 52 return -ENOMEM; 53 54 return 0; 55 } 56 57 static int am33xx_check_off_mode_enable(void) 58 { 59 if (enable_off_mode) 60 pr_warn("WARNING: This platform does not support off-mode, entering DeepSleep suspend.\n"); 61 62 /* off mode not supported on am335x so return 0 always */ 63 return 0; 64 } 65 66 static int am43xx_check_off_mode_enable(void) 67 { 68 /* 69 * Check for am437x-gp-evm which has the right Hardware design to 70 * support this mode reliably. 71 */ 72 if (of_machine_is_compatible("ti,am437x-gp-evm") && enable_off_mode) 73 return enable_off_mode; 74 else if (enable_off_mode) 75 pr_warn("WARNING: This platform does not support off-mode, entering DeepSleep suspend.\n"); 76 77 return 0; 78 } 79 80 static int amx3_common_init(int (*idle)(u32 wfi_flags)) 81 { 82 gfx_pwrdm = pwrdm_lookup("gfx_pwrdm"); 83 per_pwrdm = pwrdm_lookup("per_pwrdm"); 84 mpu_pwrdm = pwrdm_lookup("mpu_pwrdm"); 85 86 if ((!gfx_pwrdm) || (!per_pwrdm) || (!mpu_pwrdm)) 87 return -ENODEV; 88 89 (void)clkdm_for_each(omap_pm_clkdms_setup, NULL); 90 91 /* CEFUSE domain can be turned off post bootup */ 92 cefuse_pwrdm = pwrdm_lookup("cefuse_pwrdm"); 93 if (!cefuse_pwrdm) 94 pr_err("PM: Failed to get cefuse_pwrdm\n"); 95 else if (omap_type() != OMAP2_DEVICE_TYPE_GP) 96 pr_info("PM: Leaving EFUSE power domain active\n"); 97 else 98 omap_set_pwrdm_state(cefuse_pwrdm, PWRDM_POWER_OFF); 99 100 idle_fn = idle; 101 102 return 0; 103 } 104 105 static int am33xx_suspend_init(int (*idle)(u32 wfi_flags)) 106 { 107 int ret; 108 109 gfx_l4ls_clkdm = clkdm_lookup("gfx_l4ls_gfx_clkdm"); 110 111 if (!gfx_l4ls_clkdm) { 112 pr_err("PM: Cannot lookup gfx_l4ls_clkdm clockdomains\n"); 113 return -ENODEV; 114 } 115 116 ret = amx3_common_init(idle); 117 118 return ret; 119 } 120 121 static int am43xx_suspend_init(int (*idle)(u32 wfi_flags)) 122 { 123 int ret = 0; 124 125 ret = am43xx_map_scu(); 126 if (ret) { 127 pr_err("PM: Could not ioremap SCU\n"); 128 return ret; 129 } 130 131 ret = amx3_common_init(idle); 132 133 return ret; 134 } 135 136 static int amx3_suspend_deinit(void) 137 { 138 idle_fn = NULL; 139 return 0; 140 } 141 142 static void amx3_pre_suspend_common(void) 143 { 144 omap_set_pwrdm_state(gfx_pwrdm, PWRDM_POWER_OFF); 145 } 146 147 static void amx3_post_suspend_common(void) 148 { 149 int status; 150 /* 151 * Because gfx_pwrdm is the only one under MPU control, 152 * comment on transition status 153 */ 154 status = pwrdm_read_pwrst(gfx_pwrdm); 155 if (status != PWRDM_POWER_OFF) 156 pr_err("PM: GFX domain did not transition: %x\n", status); 157 } 158 159 static int am33xx_suspend(unsigned int state, int (*fn)(unsigned long), 160 unsigned long args) 161 { 162 int ret = 0; 163 164 amx3_pre_suspend_common(); 165 ret = cpu_suspend(args, fn); 166 amx3_post_suspend_common(); 167 168 /* 169 * BUG: GFX_L4LS clock domain needs to be woken up to 170 * ensure thet L4LS clock domain does not get stuck in 171 * transition. If that happens L3 module does not get 172 * disabled, thereby leading to PER power domain 173 * transition failing 174 */ 175 176 clkdm_wakeup(gfx_l4ls_clkdm); 177 clkdm_sleep(gfx_l4ls_clkdm); 178 179 return ret; 180 } 181 182 static int am43xx_suspend(unsigned int state, int (*fn)(unsigned long), 183 unsigned long args) 184 { 185 int ret = 0; 186 187 /* Suspend secure side on HS devices */ 188 if (omap_type() != OMAP2_DEVICE_TYPE_GP) { 189 if (optee_available) 190 omap_smccc_smc(AM43xx_PPA_SVC_PM_SUSPEND, 0); 191 else 192 omap_secure_dispatcher(AM43xx_PPA_SVC_PM_SUSPEND, 193 FLAG_START_CRITICAL, 194 0, 0, 0, 0, 0); 195 } 196 197 amx3_pre_suspend_common(); 198 scu_power_mode(scu_base, SCU_PM_POWEROFF); 199 ret = cpu_suspend(args, fn); 200 scu_power_mode(scu_base, SCU_PM_NORMAL); 201 202 if (!am43xx_check_off_mode_enable()) 203 amx3_post_suspend_common(); 204 205 /* 206 * Resume secure side on HS devices. 207 * 208 * Note that even on systems with OP-TEE available this resume call is 209 * issued to the ROM. This is because upon waking from suspend the ROM 210 * is restored as the secure monitor. On systems with OP-TEE ROM will 211 * restore OP-TEE during this call. 212 */ 213 if (omap_type() != OMAP2_DEVICE_TYPE_GP) 214 omap_secure_dispatcher(AM43xx_PPA_SVC_PM_RESUME, 215 FLAG_START_CRITICAL, 216 0, 0, 0, 0, 0); 217 218 return ret; 219 } 220 221 static int am33xx_cpu_suspend(int (*fn)(unsigned long), unsigned long args) 222 { 223 int ret = 0; 224 225 if (omap_irq_pending() || need_resched()) 226 return ret; 227 228 ret = cpu_suspend(args, fn); 229 230 return ret; 231 } 232 233 static int am43xx_cpu_suspend(int (*fn)(unsigned long), unsigned long args) 234 { 235 int ret = 0; 236 237 if (!scu_base) 238 return 0; 239 240 scu_power_mode(scu_base, SCU_PM_DORMANT); 241 ret = cpu_suspend(args, fn); 242 scu_power_mode(scu_base, SCU_PM_NORMAL); 243 244 return ret; 245 } 246 247 static void amx3_begin_suspend(void) 248 { 249 cpu_idle_poll_ctrl(true); 250 } 251 252 static void amx3_finish_suspend(void) 253 { 254 cpu_idle_poll_ctrl(false); 255 } 256 257 258 static struct am33xx_pm_sram_addr *amx3_get_sram_addrs(void) 259 { 260 if (soc_is_am33xx()) 261 return &am33xx_pm_sram; 262 else if (soc_is_am437x()) 263 return &am43xx_pm_sram; 264 else 265 return NULL; 266 } 267 268 static void am43xx_save_context(void) 269 { 270 } 271 272 static void am33xx_save_context(void) 273 { 274 omap_intc_save_context(); 275 } 276 277 static void am33xx_restore_context(void) 278 { 279 omap_intc_restore_context(); 280 } 281 282 static void am43xx_restore_context(void) 283 { 284 /* 285 * HACK: restore dpll_per_clkdcoldo register contents, to avoid 286 * breaking suspend-resume 287 */ 288 writel_relaxed(0x0, AM33XX_L4_WK_IO_ADDRESS(0x44df2e14)); 289 } 290 291 static struct am33xx_pm_platform_data am33xx_ops = { 292 .init = am33xx_suspend_init, 293 .deinit = amx3_suspend_deinit, 294 .soc_suspend = am33xx_suspend, 295 .cpu_suspend = am33xx_cpu_suspend, 296 .begin_suspend = amx3_begin_suspend, 297 .finish_suspend = amx3_finish_suspend, 298 .get_sram_addrs = amx3_get_sram_addrs, 299 .save_context = am33xx_save_context, 300 .restore_context = am33xx_restore_context, 301 .check_off_mode_enable = am33xx_check_off_mode_enable, 302 }; 303 304 static struct am33xx_pm_platform_data am43xx_ops = { 305 .init = am43xx_suspend_init, 306 .deinit = amx3_suspend_deinit, 307 .soc_suspend = am43xx_suspend, 308 .cpu_suspend = am43xx_cpu_suspend, 309 .begin_suspend = amx3_begin_suspend, 310 .finish_suspend = amx3_finish_suspend, 311 .get_sram_addrs = amx3_get_sram_addrs, 312 .save_context = am43xx_save_context, 313 .restore_context = am43xx_restore_context, 314 .check_off_mode_enable = am43xx_check_off_mode_enable, 315 }; 316 317 static struct am33xx_pm_platform_data *am33xx_pm_get_pdata(void) 318 { 319 if (soc_is_am33xx()) 320 return &am33xx_ops; 321 else if (soc_is_am437x()) 322 return &am43xx_ops; 323 else 324 return NULL; 325 } 326 327 #ifdef CONFIG_SUSPEND 328 /* 329 * Block system suspend initially. Later on pm33xx sets up it's own 330 * platform_suspend_ops after probe. That depends also on loaded 331 * wkup_m3_ipc and booted am335x-pm-firmware.elf. 332 */ 333 static int amx3_suspend_block(suspend_state_t state) 334 { 335 pr_warn("PM not initialized for pm33xx, wkup_m3_ipc, or am335x-pm-firmware.elf\n"); 336 337 return -EINVAL; 338 } 339 340 static int amx3_pm_valid(suspend_state_t state) 341 { 342 switch (state) { 343 case PM_SUSPEND_STANDBY: 344 return 1; 345 default: 346 return 0; 347 } 348 } 349 350 static const struct platform_suspend_ops amx3_blocked_pm_ops = { 351 .begin = amx3_suspend_block, 352 .valid = amx3_pm_valid, 353 }; 354 355 static void __init amx3_block_suspend(void) 356 { 357 suspend_set_ops(&amx3_blocked_pm_ops); 358 } 359 #else 360 static inline void amx3_block_suspend(void) 361 { 362 } 363 #endif /* CONFIG_SUSPEND */ 364 365 int __init amx3_common_pm_init(void) 366 { 367 struct am33xx_pm_platform_data *pdata; 368 struct platform_device_info devinfo; 369 370 pdata = am33xx_pm_get_pdata(); 371 372 memset(&devinfo, 0, sizeof(devinfo)); 373 devinfo.name = "pm33xx"; 374 devinfo.data = pdata; 375 devinfo.size_data = sizeof(*pdata); 376 devinfo.id = -1; 377 platform_device_register_full(&devinfo); 378 amx3_block_suspend(); 379 380 return 0; 381 } 382 383 static int __init amx3_idle_init(struct device_node *cpu_node, int cpu) 384 { 385 struct device_node *state_node; 386 struct amx3_idle_state states[CPUIDLE_STATE_MAX]; 387 int i; 388 int state_count = 1; 389 390 for (i = 0; ; i++) { 391 state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i); 392 if (!state_node) 393 break; 394 395 if (!of_device_is_available(state_node)) 396 continue; 397 398 if (i == CPUIDLE_STATE_MAX) { 399 pr_warn("%s: cpuidle states reached max possible\n", 400 __func__); 401 break; 402 } 403 404 states[state_count].wfi_flags = 0; 405 406 if (of_property_read_bool(state_node, "ti,idle-wkup-m3")) 407 states[state_count].wfi_flags |= WFI_FLAG_WAKE_M3 | 408 WFI_FLAG_FLUSH_CACHE; 409 410 state_count++; 411 } 412 413 idle_states = kcalloc(state_count, sizeof(*idle_states), GFP_KERNEL); 414 if (!idle_states) 415 return -ENOMEM; 416 417 for (i = 1; i < state_count; i++) 418 idle_states[i].wfi_flags = states[i].wfi_flags; 419 420 return 0; 421 } 422 423 static int amx3_idle_enter(unsigned long index) 424 { 425 struct amx3_idle_state *idle_state = &idle_states[index]; 426 427 if (!idle_state) 428 return -EINVAL; 429 430 if (idle_fn) 431 idle_fn(idle_state->wfi_flags); 432 433 return 0; 434 } 435 436 static struct cpuidle_ops amx3_cpuidle_ops __initdata = { 437 .init = amx3_idle_init, 438 .suspend = amx3_idle_enter, 439 }; 440 441 CPUIDLE_METHOD_OF_DECLARE(pm33xx_idle, "ti,am3352", &amx3_cpuidle_ops); 442 CPUIDLE_METHOD_OF_DECLARE(pm43xx_idle, "ti,am4372", &amx3_cpuidle_ops); 443