ARM: tegra3: Cluster Switch and LP0 require PM_SLEEP
[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
26 #include <mach/gpio.h>
27 #include <mach/irqs.h>
28 #include <asm/hardware/gic.h>
29
30 #include "clock.h"
31 #include "flowctrl.h"
32 #include "gpio-names.h"
33 #include "iomap.h"
34 #include "pm.h"
35 #include "tegra3_emc.h"
36
37 #define CAR_CCLK_BURST_POLICY \
38         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x20)
39
40 #define CAR_SUPER_CCLK_DIVIDER \
41         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x24)
42
43 #define CAR_CCLKG_BURST_POLICY \
44         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x368)
45
46 #define CAR_SUPER_CCLKG_DIVIDER \
47         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x36C)
48
49 #define CAR_CCLKLP_BURST_POLICY \
50         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x370)
51 #define PLLX_DIV2_BYPASS_LP     (1<<16)
52
53 #define CAR_SUPER_CCLKLP_DIVIDER \
54         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x374)
55
56 #define CAR_BOND_OUT_V \
57         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x390)
58 #define CAR_BOND_OUT_V_CPU_G    (1<<0)
59 #define CAR_BOND_OUT_V_CPU_LP   (1<<1)
60
61 #define CAR_CLK_ENB_V_SET \
62         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x440)
63 #define CAR_CLK_ENB_V_CPU_G     (1<<0)
64 #define CAR_CLK_ENB_V_CPU_LP    (1<<1)
65
66 #define CAR_RST_CPUG_CMPLX_SET \
67         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x450)
68
69 #define CAR_RST_CPUG_CMPLX_CLR \
70         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x454)
71
72 #define CAR_RST_CPULP_CMPLX_SET \
73         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x458)
74
75 #define CAR_RST_CPULP_CMPLX_CLR \
76         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x45C)
77
78 #define CAR_CLK_CPUG_CMPLX_SET \
79         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x460)
80
81 #define CAR_CLK_CPUG_CMPLX_CLR \
82         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x464)
83
84 #define CAR_CLK_CPULP_CMPLX_SET \
85         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x468)
86
87 #define CAR_CLK_CPULP_CMPLX_CLR \
88         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x46C)
89
90 #define CPU_CLOCK(cpu)  (0x1<<(8+cpu))
91 #define CPU_RESET(cpu)  (0x1111ul<<(cpu))
92
93 #ifdef CONFIG_PM_SLEEP
94 static int cluster_switch_prolog_clock(unsigned int flags)
95 {
96         u32 reg;
97         u32 CclkBurstPolicy;
98         u32 SuperCclkDivier;
99
100         /* Read the bond out register containing the G and LP CPUs. */
101         reg = readl(CAR_BOND_OUT_V);
102
103         /* Sync G-PLLX divider bypass with LP (no effect on G, just to prevent
104            LP settings overwrite by save/restore code */
105         CclkBurstPolicy = ~PLLX_DIV2_BYPASS_LP & readl(CAR_CCLKG_BURST_POLICY);
106         CclkBurstPolicy |= PLLX_DIV2_BYPASS_LP & readl(CAR_CCLKLP_BURST_POLICY);
107         writel(CclkBurstPolicy, CAR_CCLKG_BURST_POLICY);
108
109         /* Switching to G? */
110         if (flags & TEGRA_POWER_CLUSTER_G) {
111                 /* Do the G CPUs exist? */
112                 if (reg & CAR_BOND_OUT_V_CPU_G)
113                         return -ENXIO;
114
115                 /* Keep G CPU clock policy set by upper laayer, with the
116                    exception of the transition via LP1 */
117                 if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
118                         /* In LP1 power mode come up on CLKM (oscillator) */
119                         CclkBurstPolicy = readl(CAR_CCLKG_BURST_POLICY);
120                         CclkBurstPolicy |= ~0xF;
121                         SuperCclkDivier = 0;
122
123                         writel(CclkBurstPolicy, CAR_CCLKG_BURST_POLICY);
124                         writel(SuperCclkDivier, CAR_SUPER_CCLKG_DIVIDER);
125                 }
126
127                 /* Hold G CPUs 1-3 in reset after the switch */
128                 reg = CPU_RESET(1) | CPU_RESET(2) | CPU_RESET(3);
129                 writel(reg, CAR_RST_CPUG_CMPLX_SET);
130
131                 /* Take G CPU 0 out of reset after the switch */
132                 reg = CPU_RESET(0);
133                 writel(reg, CAR_RST_CPUG_CMPLX_CLR);
134
135                 /* Disable the clocks on G CPUs 1-3 after the switch */
136                 reg = CPU_CLOCK(1) | CPU_CLOCK(2) | CPU_CLOCK(3);
137                 writel(reg, CAR_CLK_CPUG_CMPLX_SET);
138
139                 /* Enable the clock on G CPU 0 after the switch */
140                 reg = CPU_CLOCK(0);
141                 writel(reg, CAR_CLK_CPUG_CMPLX_CLR);
142
143                 /* Enable the G CPU complex clock after the switch */
144                 reg = CAR_CLK_ENB_V_CPU_G;
145                 writel(reg, CAR_CLK_ENB_V_SET);
146         }
147         /* Switching to LP? */
148         else if (flags & TEGRA_POWER_CLUSTER_LP) {
149                 /* Does the LP CPU exist? */
150                 if (reg & CAR_BOND_OUT_V_CPU_LP)
151                         return -ENXIO;
152
153                 /* Keep LP CPU clock policy set by upper layer, with the
154                    exception of the transition via LP1 */
155                 if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
156                         /* In LP1 power mode come up on CLKM (oscillator) */
157                         CclkBurstPolicy = readl(CAR_CCLKLP_BURST_POLICY);
158                         CclkBurstPolicy |= ~0xF;
159                         SuperCclkDivier = 0;
160
161                         writel(CclkBurstPolicy, CAR_CCLKLP_BURST_POLICY);
162                         writel(SuperCclkDivier, CAR_SUPER_CCLKLP_DIVIDER);
163                 }
164
165                 /* Take the LP CPU ut of reset after the switch */
166                 reg = CPU_RESET(0);
167                 writel(reg, CAR_RST_CPULP_CMPLX_CLR);
168
169                 /* Enable the clock on the LP CPU after the switch */
170                 reg = CPU_CLOCK(0);
171                 writel(reg, CAR_CLK_CPULP_CMPLX_CLR);
172
173                 /* Enable the LP CPU complex clock after the switch */
174                 reg = CAR_CLK_ENB_V_CPU_LP;
175                 writel(reg, CAR_CLK_ENB_V_SET);
176         }
177
178         return 0;
179 }
180
181 void tegra_cluster_switch_prolog(unsigned int flags)
182 {
183         unsigned int target_cluster = flags & TEGRA_POWER_CLUSTER_MASK;
184         unsigned int current_cluster = is_lp_cluster()
185                                         ? TEGRA_POWER_CLUSTER_LP
186                                         : TEGRA_POWER_CLUSTER_G;
187         u32 reg;
188
189         /* Read the flow controler CSR register and clear the CPU switch
190            and immediate flags. If an actual CPU switch is to be performed,
191            re-write the CSR register with the desired values. */
192         reg = flowctrl_read_cpu_csr(0);
193         reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
194                  FLOW_CTRL_CSR_SWITCH_CLUSTER);
195
196         /* Program flow controller for immediate wake if requested */
197         if (flags & TEGRA_POWER_CLUSTER_IMMEDIATE)
198                 reg |= FLOW_CTRL_CSR_IMMEDIATE_WAKE;
199
200         /* Do nothing if no switch actions requested */
201         if (!target_cluster)
202                 goto done;
203
204         if ((current_cluster != target_cluster) ||
205                 (flags & TEGRA_POWER_CLUSTER_FORCE)) {
206                 if (current_cluster != target_cluster) {
207                         // Set up the clocks for the target CPU.
208                         if (cluster_switch_prolog_clock(flags)) {
209                                 /* The target CPU does not exist */
210                                 goto done;
211                         }
212
213                         /* Set up the flow controller to switch CPUs. */
214                         reg |= FLOW_CTRL_CSR_SWITCH_CLUSTER;
215                 }
216         }
217
218 done:
219         flowctrl_write_cpu_csr(0, reg);
220 }
221
222 static void cluster_switch_epilog_gic(void)
223 {
224         unsigned int max_irq, i;
225         void __iomem *gic_base = IO_ADDRESS(TEGRA_ARM_INT_DIST_BASE);
226
227         /* Nothing to do if currently running on the LP CPU. */
228         if (is_lp_cluster())
229                 return;
230
231         /* Reprogram the interrupt affinity because the on the LP CPU,
232            the interrupt distributor affinity regsiters are stubbed out
233            by ARM (reads as zero, writes ignored). So when the LP CPU
234            context save code runs, the affinity registers will read
235            as all zero. This causes all interrupts to be effectively
236            disabled when back on the G CPU because they aren't routable
237            to any CPU. See bug 667720 for details. */
238
239         max_irq = readl(gic_base + GIC_DIST_CTR) & 0x1f;
240         max_irq = (max_irq + 1) * 32;
241
242         for (i = 32; i < max_irq; i += 4)
243                 writel(0x01010101, gic_base + GIC_DIST_TARGET + i * 4 / 4);
244 }
245
246 void tegra_cluster_switch_epilog(unsigned int flags)
247 {
248         u32 reg;
249
250         /* Make sure the switch and immediate flags are cleared in
251            the flow controller to prevent undesirable side-effects
252            for future users of the flow controller. */
253         reg = flowctrl_read_cpu_csr(0);
254         reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
255                  FLOW_CTRL_CSR_SWITCH_CLUSTER);
256         flowctrl_write_cpu_csr(0, reg);
257
258         /* Perform post-switch clean-up of the interrupt distributor */
259         cluster_switch_epilog_gic();
260
261         #if DEBUG_CLUSTER_SWITCH
262         {
263                 /* FIXME: clock functions below are taking mutex */
264                 struct clk *c = tegra_get_clock_by_name(
265                         is_lp_cluster() ? "cpu_lp" : "cpu_g");
266                 DEBUG_CLUSTER(("%s: %s freq %lu\r\n", __func__,
267                         is_lp_cluster() ? "LP" : "G", clk_get_rate(c)));
268         }
269         #endif
270 }
271
272 int tegra_cluster_control(unsigned int us, unsigned int flags)
273 {
274         unsigned int target_cluster = flags & TEGRA_POWER_CLUSTER_MASK;
275         unsigned int current_cluster = is_lp_cluster()
276                                         ? TEGRA_POWER_CLUSTER_LP
277                                         : TEGRA_POWER_CLUSTER_G;
278
279         if ((target_cluster == TEGRA_POWER_CLUSTER_MASK) || !target_cluster)
280                 return -EINVAL;
281
282         if (num_online_cpus() > 1)
283                 return -EBUSY;
284
285         if ((current_cluster == target_cluster)
286         && !(flags & TEGRA_POWER_CLUSTER_FORCE))
287                 return -EEXIST;
288
289         if (target_cluster == TEGRA_POWER_CLUSTER_G)
290                 if (!is_g_cluster_present())
291                         return -EPERM;
292
293         if (flags & TEGRA_POWER_CLUSTER_IMMEDIATE)
294                 us = 0;
295
296         DEBUG_CLUSTER(("%s(LP%d): %s->%s %s %s %d\r\n", __func__,
297                 (flags & TEGRA_POWER_SDRAM_SELFREFRESH) ? 1 : 2,
298                 is_lp_cluster() ? "LP" : "G",
299                 (target_cluster == TEGRA_POWER_CLUSTER_G) ? "G" : "LP",
300                 (flags & TEGRA_POWER_CLUSTER_IMMEDIATE) ? "immediate" : "",
301                 (flags & TEGRA_POWER_CLUSTER_FORCE) ? "force" : "",
302                 us));
303
304         local_irq_disable();
305         if (flags & TEGRA_POWER_SDRAM_SELFREFRESH) {
306                 if (us)
307                         tegra_lp2_set_trigger(us);
308
309                 tegra_suspend_dram(TEGRA_SUSPEND_LP1);
310
311                 if (us)
312                         tegra_lp2_set_trigger(0);
313         } else
314                 tegra_idle_lp2_last(0, flags);
315         local_irq_enable();
316
317         DEBUG_CLUSTER(("%s: %s\r\n", __func__, is_lp_cluster() ? "LP" : "G"));
318
319         return 0;
320 }
321
322 static u32 mc_reserved_rsv;
323 static u32 mc_emem_arb_override;
324
325 void tegra_lp0_suspend_mc(void)
326 {
327         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
328         mc_reserved_rsv = readl(mc + MC_RESERVED_RSV);
329         mc_emem_arb_override = readl(mc + MC_EMEM_ARB_OVERRIDE);
330 }
331
332 void tegra_lp0_resume_mc(void)
333 {
334         void __iomem *mc = IO_ADDRESS(TEGRA_MC_BASE);
335         writel(mc_reserved_rsv, mc + MC_RESERVED_RSV);
336         writel(mc_emem_arb_override, mc + MC_EMEM_ARB_OVERRIDE);
337 }
338 #endif