ARM: tegra: power: Don't use suspended kernel time
[linux-3.10.git] / arch / arm / mach-tegra / pm-t3.c
1 /*
2  * arch/arm/mach-tegra/pm-t3.c
3  *
4  * Tegra3 SOC-specific power and cluster management
5  *
6  * Copyright (c) 2009-2011, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/io.h>
22 #include <linux/smp.h>
23 #include <linux/interrupt.h>
24 #include <linux/clk.h>
25 #include <linux/cpu_pm.h>
26 #include <linux/delay.h>
27
28 #include <mach/gpio.h>
29 #include <mach/irqs.h>
30
31 #include <asm/hardware/gic.h>
32
33 #include <trace/events/power.h>
34
35 #include "clock.h"
36 #include "cpuidle.h"
37 #include "flowctrl.h"
38 #include "gpio-names.h"
39 #include "iomap.h"
40 #include "pm.h"
41 #include "sleep.h"
42 #include "tegra3_emc.h"
43
44 #define CAR_CCLK_BURST_POLICY \
45         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x20)
46
47 #define CAR_SUPER_CCLK_DIVIDER \
48         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x24)
49
50 #define CAR_CCLKG_BURST_POLICY \
51         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x368)
52
53 #define CAR_SUPER_CCLKG_DIVIDER \
54         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x36C)
55
56 #define CAR_CCLKLP_BURST_POLICY \
57         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x370)
58 #define PLLX_DIV2_BYPASS_LP     (1<<16)
59
60 #define CAR_SUPER_CCLKLP_DIVIDER \
61         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x374)
62
63 #define CAR_BOND_OUT_V \
64         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x390)
65 #define CAR_BOND_OUT_V_CPU_G    (1<<0)
66 #define CAR_BOND_OUT_V_CPU_LP   (1<<1)
67
68 #define CAR_CLK_ENB_V_SET \
69         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x440)
70 #define CAR_CLK_ENB_V_CPU_G     (1<<0)
71 #define CAR_CLK_ENB_V_CPU_LP    (1<<1)
72
73 #define CAR_RST_CPUG_CMPLX_SET \
74         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x450)
75
76 #define CAR_RST_CPUG_CMPLX_CLR \
77         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x454)
78
79 #define CAR_RST_CPULP_CMPLX_SET \
80         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x458)
81
82 #define CAR_RST_CPULP_CMPLX_CLR \
83         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x45C)
84
85 #define CAR_CLK_CPUG_CMPLX_SET \
86         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x460)
87
88 #define CAR_CLK_CPUG_CMPLX_CLR \
89         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x464)
90
91 #define CAR_CLK_CPULP_CMPLX_SET \
92         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x468)
93
94 #define CAR_CLK_CPULP_CMPLX_CLR \
95         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x46C)
96
97 #define CPU_CLOCK(cpu)  (0x1<<(8+cpu))
98 #define CPU_RESET(cpu)  (0x1111ul<<(cpu))
99
100 #ifdef CONFIG_PM_SLEEP
101 static int cluster_switch_prolog_clock(unsigned int flags)
102 {
103         u32 reg;
104         u32 CclkBurstPolicy;
105         u32 SuperCclkDivier;
106
107         /* Read the bond out register containing the G and LP CPUs. */
108         reg = readl(CAR_BOND_OUT_V);
109
110         /* Sync G-PLLX divider bypass with LP (no effect on G, just to prevent
111            LP settings overwrite by save/restore code */
112         CclkBurstPolicy = ~PLLX_DIV2_BYPASS_LP & readl(CAR_CCLKG_BURST_POLICY);
113         CclkBurstPolicy |= PLLX_DIV2_BYPASS_LP & readl(CAR_CCLKLP_BURST_POLICY);
114         writel(CclkBurstPolicy, CAR_CCLKG_BURST_POLICY);
115
116         /* Switching to G? */
117         if (flags & TEGRA_POWER_CLUSTER_G) {
118                 /* Do the G CPUs exist? */
119                 if (reg & CAR_BOND_OUT_V_CPU_G)
120                         return -ENXIO;
121
122                 /* Keep G CPU clock policy set by upper laayer, with the
123                    exception of the transition via LP1 */
124                 if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
125                         /* In LP1 power mode come up on CLKM (oscillator) */
126                         CclkBurstPolicy = readl(CAR_CCLKG_BURST_POLICY);
127                         CclkBurstPolicy |= ~0xF;
128                         SuperCclkDivier = 0;
129
130                         writel(CclkBurstPolicy, CAR_CCLKG_BURST_POLICY);
131                         writel(SuperCclkDivier, CAR_SUPER_CCLKG_DIVIDER);
132                 }
133
134                 /* Hold G CPUs 1-3 in reset after the switch */
135                 reg = CPU_RESET(1) | CPU_RESET(2) | CPU_RESET(3);
136                 writel(reg, CAR_RST_CPUG_CMPLX_SET);
137
138                 /* Take G CPU 0 out of reset after the switch */
139                 reg = CPU_RESET(0);
140                 writel(reg, CAR_RST_CPUG_CMPLX_CLR);
141
142                 /* Disable the clocks on G CPUs 1-3 after the switch */
143                 reg = CPU_CLOCK(1) | CPU_CLOCK(2) | CPU_CLOCK(3);
144                 writel(reg, CAR_CLK_CPUG_CMPLX_SET);
145
146                 /* Enable the clock on G CPU 0 after the switch */
147                 reg = CPU_CLOCK(0);
148                 writel(reg, CAR_CLK_CPUG_CMPLX_CLR);
149
150                 /* Enable the G CPU complex clock after the switch */
151                 reg = CAR_CLK_ENB_V_CPU_G;
152                 writel(reg, CAR_CLK_ENB_V_SET);
153         }
154         /* Switching to LP? */
155         else if (flags & TEGRA_POWER_CLUSTER_LP) {
156                 /* Does the LP CPU exist? */
157                 if (reg & CAR_BOND_OUT_V_CPU_LP)
158                         return -ENXIO;
159
160                 /* Keep LP CPU clock policy set by upper layer, with the
161                    exception of the transition via LP1 */
162                 if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
163                         /* In LP1 power mode come up on CLKM (oscillator) */
164                         CclkBurstPolicy = readl(CAR_CCLKLP_BURST_POLICY);
165                         CclkBurstPolicy |= ~0xF;
166                         SuperCclkDivier = 0;
167
168                         writel(CclkBurstPolicy, CAR_CCLKLP_BURST_POLICY);
169                         writel(SuperCclkDivier, CAR_SUPER_CCLKLP_DIVIDER);
170                 }
171
172                 /* Take the LP CPU ut of reset after the switch */
173                 reg = CPU_RESET(0);
174                 writel(reg, CAR_RST_CPULP_CMPLX_CLR);
175
176                 /* Enable the clock on the LP CPU after the switch */
177                 reg = CPU_CLOCK(0);
178                 writel(reg, CAR_CLK_CPULP_CMPLX_CLR);
179
180                 /* Enable the LP CPU complex clock after the switch */
181                 reg = CAR_CLK_ENB_V_CPU_LP;
182                 writel(reg, CAR_CLK_ENB_V_SET);
183         }
184
185         return 0;
186 }
187
188 void tegra_cluster_switch_prolog(unsigned int flags)
189 {
190         unsigned int target_cluster = flags & TEGRA_POWER_CLUSTER_MASK;
191         unsigned int current_cluster = is_lp_cluster()
192                                         ? TEGRA_POWER_CLUSTER_LP
193                                         : TEGRA_POWER_CLUSTER_G;
194         u32 reg;
195
196         /* Read the flow controler CSR register and clear the CPU switch
197            and immediate flags. If an actual CPU switch is to be performed,
198            re-write the CSR register with the desired values. */
199         reg = flowctrl_read_cpu_csr(0);
200         reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
201                  FLOW_CTRL_CSR_SWITCH_CLUSTER);
202
203         /* Program flow controller for immediate wake if requested */
204         if (flags & TEGRA_POWER_CLUSTER_IMMEDIATE)
205                 reg |= FLOW_CTRL_CSR_IMMEDIATE_WAKE;
206
207         /* Do nothing if no switch actions requested */
208         if (!target_cluster)
209                 goto done;
210
211         if ((current_cluster != target_cluster) ||
212                 (flags & TEGRA_POWER_CLUSTER_FORCE)) {
213                 if (current_cluster != target_cluster) {
214                         // Set up the clocks for the target CPU.
215                         if (cluster_switch_prolog_clock(flags)) {
216                                 /* The target CPU does not exist */
217                                 goto done;
218                         }
219
220                         /* Set up the flow controller to switch CPUs. */
221                         reg |= FLOW_CTRL_CSR_SWITCH_CLUSTER;
222                 }
223         }
224
225 done:
226         flowctrl_write_cpu_csr(0, reg);
227 }
228
229 static void cluster_switch_epilog_gic(void)
230 {
231         unsigned int max_irq, i;
232         void __iomem *gic_base = IO_ADDRESS(TEGRA_ARM_INT_DIST_BASE);
233
234         /* Nothing to do if currently running on the LP CPU. */
235         if (is_lp_cluster())
236                 return;
237
238         /* Reprogram the interrupt affinity because the on the LP CPU,
239            the interrupt distributor affinity regsiters are stubbed out
240            by ARM (reads as zero, writes ignored). So when the LP CPU
241            context save code runs, the affinity registers will read
242            as all zero. This causes all interrupts to be effectively
243            disabled when back on the G CPU because they aren't routable
244            to any CPU. See bug 667720 for details. */
245
246         max_irq = readl(gic_base + GIC_DIST_CTR) & 0x1f;
247         max_irq = (max_irq + 1) * 32;
248
249         for (i = 32; i < max_irq; i += 4)
250                 writel(0x01010101, gic_base + GIC_DIST_TARGET + i * 4 / 4);
251 }
252
253 void tegra_cluster_switch_epilog(unsigned int flags)
254 {
255         u32 reg;
256
257         /* Make sure the switch and immediate flags are cleared in
258            the flow controller to prevent undesirable side-effects
259            for future users of the flow controller. */
260         reg = flowctrl_read_cpu_csr(0);
261         reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
262                  FLOW_CTRL_CSR_SWITCH_CLUSTER);
263         flowctrl_write_cpu_csr(0, reg);
264
265         /* Perform post-switch clean-up of the interrupt distributor */
266         cluster_switch_epilog_gic();
267
268         #if DEBUG_CLUSTER_SWITCH
269         {
270                 /* FIXME: clock functions below are taking mutex */
271                 struct clk *c = tegra_get_clock_by_name(
272                         is_lp_cluster() ? "cpu_lp" : "cpu_g");
273                 DEBUG_CLUSTER(("%s: %s freq %lu\r\n", __func__,
274                         is_lp_cluster() ? "LP" : "G", clk_get_rate(c)));
275         }
276         #endif
277 }
278
279 int tegra_cluster_control(unsigned int us, unsigned int flags)
280 {
281 #ifdef CONFIG_PM_SLEEP
282         static ktime_t last_g2lp;
283
284         unsigned int target_cluster = flags & TEGRA_POWER_CLUSTER_MASK;
285         unsigned int current_cluster = is_lp_cluster()
286                                         ? TEGRA_POWER_CLUSTER_LP
287                                         : TEGRA_POWER_CLUSTER_G;
288         unsigned long irq_flags;
289
290         if ((target_cluster == TEGRA_POWER_CLUSTER_MASK) || !target_cluster)
291                 return -EINVAL;
292
293         if (num_online_cpus() > 1)
294                 return -EBUSY;
295
296         if ((current_cluster == target_cluster)
297         && !(flags & TEGRA_POWER_CLUSTER_FORCE))
298                 return -EEXIST;
299
300         if (target_cluster == TEGRA_POWER_CLUSTER_G)
301                 if (!is_g_cluster_present())
302                         return -EPERM;
303
304         trace_power_start(POWER_PSTATE, target_cluster, 0);
305
306         if (flags & TEGRA_POWER_CLUSTER_IMMEDIATE)
307                 us = 0;
308
309         if ((current_cluster != target_cluster) && (!timekeeping_suspended)) {
310                 if (target_cluster == TEGRA_POWER_CLUSTER_G) {
311                         s64 t = ktime_to_us(ktime_sub(ktime_get(), last_g2lp));
312                         s64 t_off = tegra_cpu_power_off_time();
313                         if (t_off > t)
314                                 udelay((unsigned int)(t_off - t));
315                 }
316                 else
317                         last_g2lp = ktime_get();
318         }
319
320         DEBUG_CLUSTER(("%s(LP%d): %s->%s %s %s %d\r\n", __func__,
321                 (flags & TEGRA_POWER_SDRAM_SELFREFRESH) ? 1 : 2,
322                 is_lp_cluster() ? "LP" : "G",
323                 (target_cluster == TEGRA_POWER_CLUSTER_G) ? "G" : "LP",
324                 (flags & TEGRA_POWER_CLUSTER_IMMEDIATE) ? "immediate" : "",
325                 (flags & TEGRA_POWER_CLUSTER_FORCE) ? "force" : "",
326                 us));
327
328         local_irq_save(irq_flags);
329         if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
330                 if (us)
331                         tegra_lp2_set_trigger(us);
332
333                 tegra_suspend_dram(TEGRA_SUSPEND_LP1);
334
335                 if (us)
336                         tegra_lp2_set_trigger(0);
337         } else {
338                 tegra_set_cpu_in_lp2(0);
339                 cpu_pm_enter();
340                 tegra_idle_lp2_last(0, flags);
341                 cpu_pm_exit();
342                 tegra_clear_cpu_in_lp2(0);
343         }
344         local_irq_restore(irq_flags);
345
346         DEBUG_CLUSTER(("%s: %s\r\n", __func__, is_lp_cluster() ? "LP" : "G"));
347
348         return 0;
349 #else
350         return -ENODEV;
351 #endif
352 }
353
354 static u32 mc_reserved_rsv;
355 static u32 mc_emem_arb_override;
356
357 void tegra_lp0_suspend_mc(void)
358 {
359         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
360         mc_reserved_rsv = readl(mc + MC_RESERVED_RSV);
361         mc_emem_arb_override = readl(mc + MC_EMEM_ARB_OVERRIDE);
362 }
363
364 void tegra_lp0_resume_mc(void)
365 {
366         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
367         writel(mc_reserved_rsv, mc + MC_RESERVED_RSV);
368         writel(mc_emem_arb_override, mc + MC_EMEM_ARB_OVERRIDE);
369 }
370
371 void tegra_lp0_cpu_mode(bool enter)
372 {
373         static bool entered_on_g = false;
374         unsigned int flags;
375
376         if (enter)
377                 entered_on_g = !is_lp_cluster();
378
379         if (entered_on_g) {
380                 flags = enter ? TEGRA_POWER_CLUSTER_LP : TEGRA_POWER_CLUSTER_G;
381                 flags |= TEGRA_POWER_CLUSTER_IMMEDIATE;
382                 tegra_cluster_control(0, flags);
383         }
384 }
385 #endif