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