drivers/soc/ti/pm33xx.c

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