ARM: tegra: power: Force FW bit when SMP is enabled.
[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 #ifdef CONFIG_TEGRA_CLUSTER_CONTROL
45 #define CAR_CCLK_BURST_POLICY \
46         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x20)
47
48 #define CAR_SUPER_CCLK_DIVIDER \
49         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x24)
50
51 #define CAR_CCLKG_BURST_POLICY \
52         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x368)
53
54 #define CAR_SUPER_CCLKG_DIVIDER \
55         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x36C)
56
57 #define CAR_CCLKLP_BURST_POLICY \
58         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x370)
59 #define PLLX_DIV2_BYPASS_LP     (1<<16)
60
61 #define CAR_SUPER_CCLKLP_DIVIDER \
62         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x374)
63
64 #define CAR_BOND_OUT_V \
65         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x390)
66 #define CAR_BOND_OUT_V_CPU_G    (1<<0)
67 #define CAR_BOND_OUT_V_CPU_LP   (1<<1)
68
69 #define CAR_CLK_ENB_V_SET \
70         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x440)
71 #define CAR_CLK_ENB_V_CPU_G     (1<<0)
72 #define CAR_CLK_ENB_V_CPU_LP    (1<<1)
73
74 #define CAR_RST_CPUG_CMPLX_SET \
75         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x450)
76
77 #define CAR_RST_CPUG_CMPLX_CLR \
78         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x454)
79
80 #define CAR_RST_CPULP_CMPLX_SET \
81         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x458)
82
83 #define CAR_RST_CPULP_CMPLX_CLR \
84         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x45C)
85
86 #define CAR_CLK_CPUG_CMPLX_SET \
87         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x460)
88
89 #define CAR_CLK_CPUG_CMPLX_CLR \
90         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x464)
91
92 #define CAR_CLK_CPULP_CMPLX_SET \
93         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x468)
94
95 #define CAR_CLK_CPULP_CMPLX_CLR \
96         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x46C)
97
98 #define CPU_CLOCK(cpu)  (0x1<<(8+cpu))
99 #define CPU_RESET(cpu)  (0x1111ul<<(cpu))
100
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
230 static void cluster_switch_epilog_actlr(void)
231 {
232         u32 actlr;
233
234         /* TLB maintenance broadcast bit (FW) is stubbed out on LP CPU (reads
235            as zero, writes ignored). Hence, it is not preserved across G=>LP=>G
236            switch by CPU save/restore code, but SMP bit is restored correctly.
237            Synchronize these two bits here after LP=>G transition. Note that
238            only CPU0 core is powered on before and after the switch. See also
239            bug 807595. */
240
241         __asm__("mrc p15, 0, %0, c1, c0, 1\n" : "=r" (actlr));
242
243         if (actlr & (0x1 << 6)) {
244                 actlr |= 0x1;
245                 __asm__("mcr p15, 0, %0, c1, c0, 1\n" : : "r" (actlr));
246         }
247 }
248
249 static void cluster_switch_epilog_gic(void)
250 {
251         unsigned int max_irq, i;
252         void __iomem *gic_base = IO_ADDRESS(TEGRA_ARM_INT_DIST_BASE);
253
254         /* Reprogram the interrupt affinity because the on the LP CPU,
255            the interrupt distributor affinity regsiters are stubbed out
256            by ARM (reads as zero, writes ignored). So when the LP CPU
257            context save code runs, the affinity registers will read
258            as all zero. This causes all interrupts to be effectively
259            disabled when back on the G CPU because they aren't routable
260            to any CPU. See bug 667720 for details. */
261
262         max_irq = readl(gic_base + GIC_DIST_CTR) & 0x1f;
263         max_irq = (max_irq + 1) * 32;
264
265         for (i = 32; i < max_irq; i += 4)
266                 writel(0x01010101, gic_base + GIC_DIST_TARGET + i * 4 / 4);
267 }
268
269 void tegra_cluster_switch_epilog(unsigned int flags)
270 {
271         u32 reg;
272
273         /* Make sure the switch and immediate flags are cleared in
274            the flow controller to prevent undesirable side-effects
275            for future users of the flow controller. */
276         reg = flowctrl_read_cpu_csr(0);
277         reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
278                  FLOW_CTRL_CSR_SWITCH_CLUSTER);
279         flowctrl_write_cpu_csr(0, reg);
280
281         /* Perform post-switch LP=>G clean-up */
282         if (!is_lp_cluster()) {
283                 cluster_switch_epilog_actlr();
284                 cluster_switch_epilog_gic();
285         }
286
287         #if DEBUG_CLUSTER_SWITCH
288         {
289                 /* FIXME: clock functions below are taking mutex */
290                 struct clk *c = tegra_get_clock_by_name(
291                         is_lp_cluster() ? "cpu_lp" : "cpu_g");
292                 DEBUG_CLUSTER(("%s: %s freq %lu\r\n", __func__,
293                         is_lp_cluster() ? "LP" : "G", clk_get_rate(c)));
294         }
295         #endif
296 }
297
298 int tegra_cluster_control(unsigned int us, unsigned int flags)
299 {
300         static ktime_t last_g2lp;
301
302         unsigned int target_cluster = flags & TEGRA_POWER_CLUSTER_MASK;
303         unsigned int current_cluster = is_lp_cluster()
304                                         ? TEGRA_POWER_CLUSTER_LP
305                                         : TEGRA_POWER_CLUSTER_G;
306         unsigned long irq_flags;
307
308         if ((target_cluster == TEGRA_POWER_CLUSTER_MASK) || !target_cluster)
309                 return -EINVAL;
310
311         if (num_online_cpus() > 1)
312                 return -EBUSY;
313
314         if ((current_cluster == target_cluster)
315         && !(flags & TEGRA_POWER_CLUSTER_FORCE))
316                 return -EEXIST;
317
318         if (target_cluster == TEGRA_POWER_CLUSTER_G)
319                 if (!is_g_cluster_present())
320                         return -EPERM;
321
322         trace_power_start(POWER_PSTATE, target_cluster, 0);
323
324         if (flags & TEGRA_POWER_CLUSTER_IMMEDIATE)
325                 us = 0;
326
327         if (current_cluster != target_cluster && !timekeeping_suspended) {
328                 if (target_cluster == TEGRA_POWER_CLUSTER_G) {
329                         s64 t = ktime_to_us(ktime_sub(ktime_get(), last_g2lp));
330                         s64 t_off = tegra_cpu_power_off_time();
331                         if (t_off > t)
332                                 udelay((unsigned int)(t_off - t));
333                 }
334                 else
335                         last_g2lp = ktime_get();
336         }
337
338         DEBUG_CLUSTER(("%s(LP%d): %s->%s %s %s %d\r\n", __func__,
339                 (flags & TEGRA_POWER_SDRAM_SELFREFRESH) ? 1 : 2,
340                 is_lp_cluster() ? "LP" : "G",
341                 (target_cluster == TEGRA_POWER_CLUSTER_G) ? "G" : "LP",
342                 (flags & TEGRA_POWER_CLUSTER_IMMEDIATE) ? "immediate" : "",
343                 (flags & TEGRA_POWER_CLUSTER_FORCE) ? "force" : "",
344                 us));
345
346         local_irq_save(irq_flags);
347         if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
348                 if (us)
349                         tegra_lp2_set_trigger(us);
350
351                 tegra_cluster_switch_prolog(flags);
352                 tegra_suspend_dram(TEGRA_SUSPEND_LP1, flags);
353                 tegra_cluster_switch_epilog(flags);
354
355                 if (us)
356                         tegra_lp2_set_trigger(0);
357         } else {
358                 tegra_set_cpu_in_lp2(0);
359                 cpu_pm_enter();
360                 tegra_idle_lp2_last(0, flags);
361                 cpu_pm_exit();
362                 tegra_clear_cpu_in_lp2(0);
363         }
364         local_irq_restore(irq_flags);
365
366         DEBUG_CLUSTER(("%s: %s\r\n", __func__, is_lp_cluster() ? "LP" : "G"));
367
368         return 0;
369 }
370 #endif
371
372 #ifdef CONFIG_PM_SLEEP
373 static u32 mc_reserved_rsv;
374 static u32 mc_emem_arb_override;
375
376 void tegra_lp0_suspend_mc(void)
377 {
378         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
379         mc_reserved_rsv = readl(mc + MC_RESERVED_RSV);
380         mc_emem_arb_override = readl(mc + MC_EMEM_ARB_OVERRIDE);
381 }
382
383 void tegra_lp0_resume_mc(void)
384 {
385         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
386         writel(mc_reserved_rsv, mc + MC_RESERVED_RSV);
387         writel(mc_emem_arb_override, mc + MC_EMEM_ARB_OVERRIDE);
388 }
389
390 void tegra_lp0_cpu_mode(bool enter)
391 {
392         static bool entered_on_g = false;
393         unsigned int flags;
394
395         if (enter)
396                 entered_on_g = !is_lp_cluster();
397
398         if (entered_on_g) {
399                 flags = enter ? TEGRA_POWER_CLUSTER_LP : TEGRA_POWER_CLUSTER_G;
400                 flags |= TEGRA_POWER_CLUSTER_IMMEDIATE;
401                 tegra_cluster_control(0, flags);
402         }
403 }
404 #endif