abf5f88778f4ed120d0ea0a1c6c87dff6e95f7d0
[muen/linux.git] / arch / arm / mach-tegra / pm.c
1 /*
2  * CPU complex suspend & resume functions for Tegra SoCs
3  *
4  * Copyright (c) 2009-2012, NVIDIA Corporation. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/clk/tegra.h>
20 #include <linux/cpumask.h>
21 #include <linux/cpu_pm.h>
22 #include <linux/delay.h>
23 #include <linux/err.h>
24 #include <linux/io.h>
25 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/spinlock.h>
28 #include <linux/suspend.h>
29
30 #include <soc/tegra/flowctrl.h>
31 #include <soc/tegra/fuse.h>
32 #include <soc/tegra/pm.h>
33 #include <soc/tegra/pmc.h>
34
35 #include <asm/cacheflush.h>
36 #include <asm/firmware.h>
37 #include <asm/idmap.h>
38 #include <asm/proc-fns.h>
39 #include <asm/smp_plat.h>
40 #include <asm/suspend.h>
41 #include <asm/tlbflush.h>
42 #include <asm/trusted_foundations.h>
43
44 #include "iomap.h"
45 #include "pm.h"
46 #include "reset.h"
47 #include "sleep.h"
48
49 #ifdef CONFIG_PM_SLEEP
50 static DEFINE_SPINLOCK(tegra_lp2_lock);
51 static u32 iram_save_size;
52 static void *iram_save_addr;
53 struct tegra_lp1_iram tegra_lp1_iram;
54 void (*tegra_tear_down_cpu)(void);
55 void (*tegra_sleep_core_finish)(unsigned long v2p);
56 static int (*tegra_sleep_func)(unsigned long v2p);
57
58 static void tegra_tear_down_cpu_init(void)
59 {
60         switch (tegra_get_chip_id()) {
61         case TEGRA20:
62                 if (IS_ENABLED(CONFIG_ARCH_TEGRA_2x_SOC))
63                         tegra_tear_down_cpu = tegra20_tear_down_cpu;
64                 break;
65         case TEGRA30:
66         case TEGRA114:
67         case TEGRA124:
68                 if (IS_ENABLED(CONFIG_ARCH_TEGRA_3x_SOC) ||
69                     IS_ENABLED(CONFIG_ARCH_TEGRA_114_SOC) ||
70                     IS_ENABLED(CONFIG_ARCH_TEGRA_124_SOC))
71                         tegra_tear_down_cpu = tegra30_tear_down_cpu;
72                 break;
73         }
74 }
75
76 /*
77  * restore_cpu_complex
78  *
79  * restores cpu clock setting, clears flow controller
80  *
81  * Always called on CPU 0.
82  */
83 static void restore_cpu_complex(void)
84 {
85         int cpu = smp_processor_id();
86
87         BUG_ON(cpu != 0);
88
89 #ifdef CONFIG_SMP
90         cpu = cpu_logical_map(cpu);
91 #endif
92
93         /* Restore the CPU clock settings */
94         tegra_cpu_clock_resume();
95
96         flowctrl_cpu_suspend_exit(cpu);
97 }
98
99 /*
100  * suspend_cpu_complex
101  *
102  * saves pll state for use by restart_plls, prepares flow controller for
103  * transition to suspend state
104  *
105  * Must always be called on cpu 0.
106  */
107 static void suspend_cpu_complex(void)
108 {
109         int cpu = smp_processor_id();
110
111         BUG_ON(cpu != 0);
112
113 #ifdef CONFIG_SMP
114         cpu = cpu_logical_map(cpu);
115 #endif
116
117         /* Save the CPU clock settings */
118         tegra_cpu_clock_suspend();
119
120         flowctrl_cpu_suspend_enter(cpu);
121 }
122
123 void tegra_clear_cpu_in_lp2(void)
124 {
125         int phy_cpu_id = cpu_logical_map(smp_processor_id());
126         u32 *cpu_in_lp2 = tegra_cpu_lp2_mask;
127
128         spin_lock(&tegra_lp2_lock);
129
130         BUG_ON(!(*cpu_in_lp2 & BIT(phy_cpu_id)));
131         *cpu_in_lp2 &= ~BIT(phy_cpu_id);
132
133         spin_unlock(&tegra_lp2_lock);
134 }
135
136 bool tegra_set_cpu_in_lp2(void)
137 {
138         int phy_cpu_id = cpu_logical_map(smp_processor_id());
139         bool last_cpu = false;
140         cpumask_t *cpu_lp2_mask = tegra_cpu_lp2_mask;
141         u32 *cpu_in_lp2 = tegra_cpu_lp2_mask;
142
143         spin_lock(&tegra_lp2_lock);
144
145         BUG_ON((*cpu_in_lp2 & BIT(phy_cpu_id)));
146         *cpu_in_lp2 |= BIT(phy_cpu_id);
147
148         if ((phy_cpu_id == 0) && cpumask_equal(cpu_lp2_mask, cpu_online_mask))
149                 last_cpu = true;
150         else if (tegra_get_chip_id() == TEGRA20 && phy_cpu_id == 1)
151                 tegra20_cpu_set_resettable_soon();
152
153         spin_unlock(&tegra_lp2_lock);
154         return last_cpu;
155 }
156
157 int tegra_cpu_do_idle(void)
158 {
159         return cpu_do_idle();
160 }
161
162 static int tegra_sleep_cpu(unsigned long v2p)
163 {
164         /*
165          * L2 cache disabling using kernel API only allowed when all
166          * secondary CPU's are offline. Cache have to be disabled with
167          * MMU-on if cache maintenance is done via Trusted Foundations
168          * firmware. Note that CPUIDLE won't ever enter powergate on Tegra30
169          * if any of secondary CPU's is online and this is the LP2-idle
170          * code-path only for Tegra20/30.
171          */
172         if (trusted_foundations_registered())
173                 outer_disable();
174
175         /*
176          * Note that besides of setting up CPU reset vector this firmware
177          * call may also do the following, depending on the FW version:
178          *  1) Disable L2. But this doesn't matter since we already
179          *     disabled the L2.
180          *  2) Disable D-cache. This need to be taken into account in
181          *     particular by the tegra_disable_clean_inv_dcache() which
182          *     shall avoid the re-disable.
183          */
184         call_firmware_op(prepare_idle, TF_PM_MODE_LP2);
185
186         setup_mm_for_reboot();
187         tegra_sleep_cpu_finish(v2p);
188
189         /* should never here */
190         BUG();
191
192         return 0;
193 }
194
195 static void tegra_pm_set(enum tegra_suspend_mode mode)
196 {
197         u32 value;
198
199         switch (tegra_get_chip_id()) {
200         case TEGRA20:
201         case TEGRA30:
202                 break;
203         default:
204                 /* Turn off CRAIL */
205                 value = flowctrl_read_cpu_csr(0);
206                 value &= ~FLOW_CTRL_CSR_ENABLE_EXT_MASK;
207                 value |= FLOW_CTRL_CSR_ENABLE_EXT_CRAIL;
208                 flowctrl_write_cpu_csr(0, value);
209                 break;
210         }
211
212         tegra_pmc_enter_suspend_mode(mode);
213 }
214
215 void tegra_idle_lp2_last(void)
216 {
217         tegra_pm_set(TEGRA_SUSPEND_LP2);
218
219         cpu_cluster_pm_enter();
220         suspend_cpu_complex();
221
222         cpu_suspend(PHYS_OFFSET - PAGE_OFFSET, &tegra_sleep_cpu);
223
224         /*
225          * Resume L2 cache if it wasn't re-enabled early during resume,
226          * which is the case for Tegra30 that has to re-enable the cache
227          * via firmware call. In other cases cache is already enabled and
228          * hence re-enabling is a no-op. This is always a no-op on Tegra114+.
229          */
230         outer_resume();
231
232         restore_cpu_complex();
233         cpu_cluster_pm_exit();
234 }
235
236 enum tegra_suspend_mode tegra_pm_validate_suspend_mode(
237                                 enum tegra_suspend_mode mode)
238 {
239         /*
240          * The Tegra devices support suspending to LP1 or lower currently.
241          */
242         if (mode > TEGRA_SUSPEND_LP1)
243                 return TEGRA_SUSPEND_LP1;
244
245         return mode;
246 }
247
248 static int tegra_sleep_core(unsigned long v2p)
249 {
250         /*
251          * Cache have to be disabled with MMU-on if cache maintenance is done
252          * via Trusted Foundations firmware. This is a no-op on Tegra114+.
253          */
254         if (trusted_foundations_registered())
255                 outer_disable();
256
257         call_firmware_op(prepare_idle, TF_PM_MODE_LP1);
258
259         setup_mm_for_reboot();
260         tegra_sleep_core_finish(v2p);
261
262         /* should never here */
263         BUG();
264
265         return 0;
266 }
267
268 /*
269  * tegra_lp1_iram_hook
270  *
271  * Hooking the address of LP1 reset vector and SDRAM self-refresh code in
272  * SDRAM. These codes not be copied to IRAM in this fuction. We need to
273  * copy these code to IRAM before LP0/LP1 suspend and restore the content
274  * of IRAM after resume.
275  */
276 static bool tegra_lp1_iram_hook(void)
277 {
278         switch (tegra_get_chip_id()) {
279         case TEGRA20:
280                 if (IS_ENABLED(CONFIG_ARCH_TEGRA_2x_SOC))
281                         tegra20_lp1_iram_hook();
282                 break;
283         case TEGRA30:
284         case TEGRA114:
285         case TEGRA124:
286                 if (IS_ENABLED(CONFIG_ARCH_TEGRA_3x_SOC) ||
287                     IS_ENABLED(CONFIG_ARCH_TEGRA_114_SOC) ||
288                     IS_ENABLED(CONFIG_ARCH_TEGRA_124_SOC))
289                         tegra30_lp1_iram_hook();
290                 break;
291         default:
292                 break;
293         }
294
295         if (!tegra_lp1_iram.start_addr || !tegra_lp1_iram.end_addr)
296                 return false;
297
298         iram_save_size = tegra_lp1_iram.end_addr - tegra_lp1_iram.start_addr;
299         iram_save_addr = kmalloc(iram_save_size, GFP_KERNEL);
300         if (!iram_save_addr)
301                 return false;
302
303         return true;
304 }
305
306 static bool tegra_sleep_core_init(void)
307 {
308         switch (tegra_get_chip_id()) {
309         case TEGRA20:
310                 if (IS_ENABLED(CONFIG_ARCH_TEGRA_2x_SOC))
311                         tegra20_sleep_core_init();
312                 break;
313         case TEGRA30:
314         case TEGRA114:
315         case TEGRA124:
316                 if (IS_ENABLED(CONFIG_ARCH_TEGRA_3x_SOC) ||
317                     IS_ENABLED(CONFIG_ARCH_TEGRA_114_SOC) ||
318                     IS_ENABLED(CONFIG_ARCH_TEGRA_124_SOC))
319                         tegra30_sleep_core_init();
320                 break;
321         default:
322                 break;
323         }
324
325         if (!tegra_sleep_core_finish)
326                 return false;
327
328         return true;
329 }
330
331 static void tegra_suspend_enter_lp1(void)
332 {
333         /* copy the reset vector & SDRAM shutdown code into IRAM */
334         memcpy(iram_save_addr, IO_ADDRESS(TEGRA_IRAM_LPx_RESUME_AREA),
335                 iram_save_size);
336         memcpy(IO_ADDRESS(TEGRA_IRAM_LPx_RESUME_AREA),
337                 tegra_lp1_iram.start_addr, iram_save_size);
338
339         *((u32 *)tegra_cpu_lp1_mask) = 1;
340 }
341
342 static void tegra_suspend_exit_lp1(void)
343 {
344         /* restore IRAM */
345         memcpy(IO_ADDRESS(TEGRA_IRAM_LPx_RESUME_AREA), iram_save_addr,
346                 iram_save_size);
347
348         *(u32 *)tegra_cpu_lp1_mask = 0;
349 }
350
351 static const char *lp_state[TEGRA_MAX_SUSPEND_MODE] = {
352         [TEGRA_SUSPEND_NONE] = "none",
353         [TEGRA_SUSPEND_LP2] = "LP2",
354         [TEGRA_SUSPEND_LP1] = "LP1",
355         [TEGRA_SUSPEND_LP0] = "LP0",
356 };
357
358 static int tegra_suspend_enter(suspend_state_t state)
359 {
360         enum tegra_suspend_mode mode = tegra_pmc_get_suspend_mode();
361
362         if (WARN_ON(mode < TEGRA_SUSPEND_NONE ||
363                     mode >= TEGRA_MAX_SUSPEND_MODE))
364                 return -EINVAL;
365
366         pr_info("Entering suspend state %s\n", lp_state[mode]);
367
368         tegra_pm_set(mode);
369
370         local_fiq_disable();
371
372         suspend_cpu_complex();
373         switch (mode) {
374         case TEGRA_SUSPEND_LP1:
375                 tegra_suspend_enter_lp1();
376                 break;
377         case TEGRA_SUSPEND_LP2:
378                 tegra_set_cpu_in_lp2();
379                 break;
380         default:
381                 break;
382         }
383
384         cpu_suspend(PHYS_OFFSET - PAGE_OFFSET, tegra_sleep_func);
385
386         /*
387          * Resume L2 cache if it wasn't re-enabled early during resume,
388          * which is the case for Tegra30 that has to re-enable the cache
389          * via firmware call. In other cases cache is already enabled and
390          * hence re-enabling is a no-op.
391          */
392         outer_resume();
393
394         switch (mode) {
395         case TEGRA_SUSPEND_LP1:
396                 tegra_suspend_exit_lp1();
397                 break;
398         case TEGRA_SUSPEND_LP2:
399                 tegra_clear_cpu_in_lp2();
400                 break;
401         default:
402                 break;
403         }
404         restore_cpu_complex();
405
406         local_fiq_enable();
407
408         return 0;
409 }
410
411 static const struct platform_suspend_ops tegra_suspend_ops = {
412         .valid          = suspend_valid_only_mem,
413         .enter          = tegra_suspend_enter,
414 };
415
416 void __init tegra_init_suspend(void)
417 {
418         enum tegra_suspend_mode mode = tegra_pmc_get_suspend_mode();
419
420         if (mode == TEGRA_SUSPEND_NONE)
421                 return;
422
423         tegra_tear_down_cpu_init();
424
425         if (mode >= TEGRA_SUSPEND_LP1) {
426                 if (!tegra_lp1_iram_hook() || !tegra_sleep_core_init()) {
427                         pr_err("%s: unable to allocate memory for SDRAM"
428                                "self-refresh -- LP0/LP1 unavailable\n",
429                                __func__);
430                         tegra_pmc_set_suspend_mode(TEGRA_SUSPEND_LP2);
431                         mode = TEGRA_SUSPEND_LP2;
432                 }
433         }
434
435         /* set up sleep function for cpu_suspend */
436         switch (mode) {
437         case TEGRA_SUSPEND_LP1:
438                 tegra_sleep_func = tegra_sleep_core;
439                 break;
440         case TEGRA_SUSPEND_LP2:
441                 tegra_sleep_func = tegra_sleep_cpu;
442                 break;
443         default:
444                 break;
445         }
446
447         suspend_set_ops(&tegra_suspend_ops);
448 }
449 #endif