1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * AM33XX Power Management Routines 4 * 5 * Copyright (C) 2012-2018 Texas Instruments Incorporated - http://www.ti.com/ 6 * Vaibhav Bedia, Dave Gerlach 7 */ 8 9 #include <linux/cpu.h> 10 #include <linux/err.h> 11 #include <linux/genalloc.h> 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/io.h> 15 #include <linux/module.h> 16 #include <linux/of.h> 17 #include <linux/platform_data/pm33xx.h> 18 #include <linux/platform_device.h> 19 #include <linux/sizes.h> 20 #include <linux/sram.h> 21 #include <linux/suspend.h> 22 #include <linux/ti-emif-sram.h> 23 #include <linux/wkup_m3_ipc.h> 24 25 #include <asm/proc-fns.h> 26 #include <asm/suspend.h> 27 #include <asm/system_misc.h> 28 29 #define AMX3_PM_SRAM_SYMBOL_OFFSET(sym) ((unsigned long)(sym) - \ 30 (unsigned long)pm_sram->do_wfi) 31 32 static int (*am33xx_do_wfi_sram)(unsigned long unused); 33 static phys_addr_t am33xx_do_wfi_sram_phys; 34 35 static struct gen_pool *sram_pool, *sram_pool_data; 36 static unsigned long ocmcram_location, ocmcram_location_data; 37 38 static struct am33xx_pm_platform_data *pm_ops; 39 static struct am33xx_pm_sram_addr *pm_sram; 40 41 static struct device *pm33xx_dev; 42 static struct wkup_m3_ipc *m3_ipc; 43 44 static u32 sram_suspend_address(unsigned long addr) 45 { 46 return ((unsigned long)am33xx_do_wfi_sram + 47 AMX3_PM_SRAM_SYMBOL_OFFSET(addr)); 48 } 49 50 #ifdef CONFIG_SUSPEND 51 static int am33xx_pm_suspend(suspend_state_t suspend_state) 52 { 53 int i, ret = 0; 54 55 ret = pm_ops->soc_suspend((unsigned long)suspend_state, 56 am33xx_do_wfi_sram); 57 58 if (ret) { 59 dev_err(pm33xx_dev, "PM: Kernel suspend failure\n"); 60 } else { 61 i = m3_ipc->ops->request_pm_status(m3_ipc); 62 63 switch (i) { 64 case 0: 65 dev_info(pm33xx_dev, 66 "PM: Successfully put all powerdomains to target state\n"); 67 break; 68 case 1: 69 dev_err(pm33xx_dev, 70 "PM: Could not transition all powerdomains to target state\n"); 71 ret = -1; 72 break; 73 default: 74 dev_err(pm33xx_dev, 75 "PM: CM3 returned unknown result = %d\n", i); 76 ret = -1; 77 } 78 } 79 80 return ret; 81 } 82 83 static int am33xx_pm_enter(suspend_state_t suspend_state) 84 { 85 int ret = 0; 86 87 switch (suspend_state) { 88 case PM_SUSPEND_MEM: 89 case PM_SUSPEND_STANDBY: 90 ret = am33xx_pm_suspend(suspend_state); 91 break; 92 default: 93 ret = -EINVAL; 94 } 95 96 return ret; 97 } 98 99 static int am33xx_pm_begin(suspend_state_t state) 100 { 101 int ret = -EINVAL; 102 103 switch (state) { 104 case PM_SUSPEND_MEM: 105 ret = m3_ipc->ops->prepare_low_power(m3_ipc, WKUP_M3_DEEPSLEEP); 106 break; 107 case PM_SUSPEND_STANDBY: 108 ret = m3_ipc->ops->prepare_low_power(m3_ipc, WKUP_M3_STANDBY); 109 break; 110 } 111 112 return ret; 113 } 114 115 static void am33xx_pm_end(void) 116 { 117 m3_ipc->ops->finish_low_power(m3_ipc); 118 } 119 120 static int am33xx_pm_valid(suspend_state_t state) 121 { 122 switch (state) { 123 case PM_SUSPEND_STANDBY: 124 case PM_SUSPEND_MEM: 125 return 1; 126 default: 127 return 0; 128 } 129 } 130 131 static const struct platform_suspend_ops am33xx_pm_ops = { 132 .begin = am33xx_pm_begin, 133 .end = am33xx_pm_end, 134 .enter = am33xx_pm_enter, 135 .valid = am33xx_pm_valid, 136 }; 137 #endif /* CONFIG_SUSPEND */ 138 139 static void am33xx_pm_set_ipc_ops(void) 140 { 141 u32 resume_address; 142 int temp; 143 144 temp = ti_emif_get_mem_type(); 145 if (temp < 0) { 146 dev_err(pm33xx_dev, "PM: Cannot determine memory type, no PM available\n"); 147 return; 148 } 149 m3_ipc->ops->set_mem_type(m3_ipc, temp); 150 151 /* Physical resume address to be used by ROM code */ 152 resume_address = am33xx_do_wfi_sram_phys + 153 *pm_sram->resume_offset + 0x4; 154 155 m3_ipc->ops->set_resume_address(m3_ipc, (void *)resume_address); 156 } 157 158 static void am33xx_pm_free_sram(void) 159 { 160 gen_pool_free(sram_pool, ocmcram_location, *pm_sram->do_wfi_sz); 161 gen_pool_free(sram_pool_data, ocmcram_location_data, 162 sizeof(struct am33xx_pm_ro_sram_data)); 163 } 164 165 /* 166 * Push the minimal suspend-resume code to SRAM 167 */ 168 static int am33xx_pm_alloc_sram(void) 169 { 170 struct device_node *np; 171 int ret = 0; 172 173 np = of_find_compatible_node(NULL, NULL, "ti,omap3-mpu"); 174 if (!np) { 175 np = of_find_compatible_node(NULL, NULL, "ti,omap4-mpu"); 176 if (!np) { 177 dev_err(pm33xx_dev, "PM: %s: Unable to find device node for mpu\n", 178 __func__); 179 return -ENODEV; 180 } 181 } 182 183 sram_pool = of_gen_pool_get(np, "pm-sram", 0); 184 if (!sram_pool) { 185 dev_err(pm33xx_dev, "PM: %s: Unable to get sram pool for ocmcram\n", 186 __func__); 187 ret = -ENODEV; 188 goto mpu_put_node; 189 } 190 191 sram_pool_data = of_gen_pool_get(np, "pm-sram", 1); 192 if (!sram_pool_data) { 193 dev_err(pm33xx_dev, "PM: %s: Unable to get sram data pool for ocmcram\n", 194 __func__); 195 ret = -ENODEV; 196 goto mpu_put_node; 197 } 198 199 ocmcram_location = gen_pool_alloc(sram_pool, *pm_sram->do_wfi_sz); 200 if (!ocmcram_location) { 201 dev_err(pm33xx_dev, "PM: %s: Unable to allocate memory from ocmcram\n", 202 __func__); 203 ret = -ENOMEM; 204 goto mpu_put_node; 205 } 206 207 ocmcram_location_data = gen_pool_alloc(sram_pool_data, 208 sizeof(struct emif_regs_amx3)); 209 if (!ocmcram_location_data) { 210 dev_err(pm33xx_dev, "PM: Unable to allocate memory from ocmcram\n"); 211 gen_pool_free(sram_pool, ocmcram_location, *pm_sram->do_wfi_sz); 212 ret = -ENOMEM; 213 } 214 215 mpu_put_node: 216 of_node_put(np); 217 return ret; 218 } 219 220 static int am33xx_push_sram_idle(void) 221 { 222 struct am33xx_pm_ro_sram_data ro_sram_data; 223 int ret; 224 u32 table_addr, ro_data_addr; 225 void *copy_addr; 226 227 ro_sram_data.amx3_pm_sram_data_virt = ocmcram_location_data; 228 ro_sram_data.amx3_pm_sram_data_phys = 229 gen_pool_virt_to_phys(sram_pool_data, ocmcram_location_data); 230 231 /* Save physical address to calculate resume offset during pm init */ 232 am33xx_do_wfi_sram_phys = gen_pool_virt_to_phys(sram_pool, 233 ocmcram_location); 234 235 am33xx_do_wfi_sram = sram_exec_copy(sram_pool, (void *)ocmcram_location, 236 pm_sram->do_wfi, 237 *pm_sram->do_wfi_sz); 238 if (!am33xx_do_wfi_sram) { 239 dev_err(pm33xx_dev, 240 "PM: %s: am33xx_do_wfi copy to sram failed\n", 241 __func__); 242 return -ENODEV; 243 } 244 245 table_addr = 246 sram_suspend_address((unsigned long)pm_sram->emif_sram_table); 247 ret = ti_emif_copy_pm_function_table(sram_pool, (void *)table_addr); 248 if (ret) { 249 dev_dbg(pm33xx_dev, 250 "PM: %s: EMIF function copy failed\n", __func__); 251 return -EPROBE_DEFER; 252 } 253 254 ro_data_addr = 255 sram_suspend_address((unsigned long)pm_sram->ro_sram_data); 256 copy_addr = sram_exec_copy(sram_pool, (void *)ro_data_addr, 257 &ro_sram_data, 258 sizeof(ro_sram_data)); 259 if (!copy_addr) { 260 dev_err(pm33xx_dev, 261 "PM: %s: ro_sram_data copy to sram failed\n", 262 __func__); 263 return -ENODEV; 264 } 265 266 return 0; 267 } 268 269 static int am33xx_pm_probe(struct platform_device *pdev) 270 { 271 struct device *dev = &pdev->dev; 272 int ret; 273 274 if (!of_machine_is_compatible("ti,am33xx") && 275 !of_machine_is_compatible("ti,am43")) 276 return -ENODEV; 277 278 pm_ops = dev->platform_data; 279 if (!pm_ops) { 280 dev_err(dev, "PM: Cannot get core PM ops!\n"); 281 return -ENODEV; 282 } 283 284 pm_sram = pm_ops->get_sram_addrs(); 285 if (!pm_sram) { 286 dev_err(dev, "PM: Cannot get PM asm function addresses!!\n"); 287 return -ENODEV; 288 } 289 290 pm33xx_dev = dev; 291 292 ret = am33xx_pm_alloc_sram(); 293 if (ret) 294 return ret; 295 296 ret = am33xx_push_sram_idle(); 297 if (ret) 298 goto err_free_sram; 299 300 m3_ipc = wkup_m3_ipc_get(); 301 if (!m3_ipc) { 302 dev_dbg(dev, "PM: Cannot get wkup_m3_ipc handle\n"); 303 ret = -EPROBE_DEFER; 304 goto err_free_sram; 305 } 306 307 am33xx_pm_set_ipc_ops(); 308 309 #ifdef CONFIG_SUSPEND 310 suspend_set_ops(&am33xx_pm_ops); 311 #endif /* CONFIG_SUSPEND */ 312 313 ret = pm_ops->init(); 314 if (ret) { 315 dev_err(dev, "Unable to call core pm init!\n"); 316 ret = -ENODEV; 317 goto err_put_wkup_m3_ipc; 318 } 319 320 return 0; 321 322 err_put_wkup_m3_ipc: 323 wkup_m3_ipc_put(m3_ipc); 324 err_free_sram: 325 am33xx_pm_free_sram(); 326 pm33xx_dev = NULL; 327 return ret; 328 } 329 330 static int am33xx_pm_remove(struct platform_device *pdev) 331 { 332 suspend_set_ops(NULL); 333 wkup_m3_ipc_put(m3_ipc); 334 am33xx_pm_free_sram(); 335 return 0; 336 } 337 338 static struct platform_driver am33xx_pm_driver = { 339 .driver = { 340 .name = "pm33xx", 341 }, 342 .probe = am33xx_pm_probe, 343 .remove = am33xx_pm_remove, 344 }; 345 module_platform_driver(am33xx_pm_driver); 346 347 MODULE_ALIAS("platform:pm33xx"); 348 MODULE_LICENSE("GPL v2"); 349 MODULE_DESCRIPTION("am33xx power management driver"); 350