0c6a2f0474d37bd9886e053316c8e67984109af1
[linux-3.10.git] / arch / arm / mach-tegra / platsmp.c
1 /*
2  *  linux/arch/arm/mach-tegra/platsmp.c
3  *
4  *  Copyright (C) 2002 ARM Ltd.
5  *  All Rights Reserved
6  *
7  *  Copyright (C) 2009 Palm
8  *  All Rights Reserved
9  *
10  *  Copyright (C) 2010-2011 NVIDIA Corporation
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License version 2 as
14  * published by the Free Software Foundation.
15  */
16
17 #include <linux/init.h>
18 #include <linux/errno.h>
19 #include <linux/delay.h>
20 #include <linux/device.h>
21 #include <linux/jiffies.h>
22 #include <linux/smp.h>
23 #include <linux/io.h>
24 #include <linux/clk.h>
25 #include <linux/clk/tegra.h>
26 #include <linux/cpumask.h>
27
28 #include <asm/smp_scu.h>
29
30 #include <mach/powergate.h>
31
32 #include "fuse.h"
33 #include "flowctrl.h"
34 #include "reset.h"
35 #include "pm.h"
36 #include "clock.h"
37
38 #include "common.h"
39 #include "iomap.h"
40
41 bool tegra_all_cpus_booted;
42
43 static DECLARE_BITMAP(tegra_cpu_init_bits, CONFIG_NR_CPUS) __read_mostly;
44 const struct cpumask *const tegra_cpu_init_mask = to_cpumask(tegra_cpu_init_bits);
45 #define tegra_cpu_init_map      (*(cpumask_t *)tegra_cpu_init_mask)
46
47 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
48 #define CLK_RST_CONTROLLER_CLK_CPU_CMPLX_CLR \
49         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x34c)
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 #endif
54
55 static void __iomem *scu_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE);
56
57 static unsigned int available_cpus(void)
58 {
59         static unsigned int ncores;
60
61         if (ncores == 0) {
62                 ncores = scu_get_core_count(scu_base);
63 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
64                 if (ncores > 1) {
65                         u32 fuse_sku = readl(FUSE_SKU_DIRECT_CONFIG);
66                         ncores -= FUSE_SKU_NUM_DISABLED_CPUS(fuse_sku);
67                         BUG_ON((int)ncores <= 0);
68                 }
69 #endif
70         }
71         return ncores;
72 }
73
74 static int is_g_cluster_available(unsigned int cpu)
75 {
76 #ifdef CONFIG_TEGRA_CLUSTER_CONTROL
77         u32 fuse_sku = readl(FUSE_SKU_DIRECT_CONFIG);
78         u32 bond_out = readl(CAR_BOND_OUT_V);
79
80         /* Does the G CPU complex exist at all? */
81         if ((fuse_sku & FUSE_SKU_DISABLE_ALL_CPUS) ||
82             (bond_out & CAR_BOND_OUT_V_CPU_G))
83                 return -EPERM;
84
85         if (cpu >= available_cpus())
86                 return -EPERM;
87
88         /* FIXME: The G CPU can be unavailable for a number of reasons
89          *        (e.g., low battery, over temperature, etc.). Add checks for
90          *        these conditions. */
91         return 0;
92 #else
93         return -EPERM;
94 #endif
95 }
96
97 static void __cpuinit tegra_secondary_init(unsigned int cpu)
98 {
99         cpumask_set_cpu(cpu, to_cpumask(tegra_cpu_init_bits));
100         if (!tegra_all_cpus_booted)
101                 if (cpumask_equal(tegra_cpu_init_mask, cpu_present_mask))
102                         tegra_all_cpus_booted = true;
103 }
104
105 static int tegra20_power_up_cpu(unsigned int cpu)
106 {
107         int status;
108
109         /* Enable the CPU clock. */
110         tegra_enable_cpu_clock(cpu);
111
112         /* Clear flow controller CSR. */
113         flowctrl_write_cpu_csr(cpu, 0);
114
115         return 0;
116 }
117
118 static int tegra30_power_up_cpu(unsigned int cpu)
119 {
120         int ret, pwrgateid;
121         unsigned long timeout;
122
123         BUG_ON(is_lp_cluster());
124
125         pwrgateid = tegra_cpu_powergate_id(cpu);
126         if (pwrgateid < 0)
127                 return pwrgateid;
128
129         /* If this cpu has booted this function is entered after
130          * CPU has been already un-gated by flow controller. Wait
131          * for confirmation that cpu is powered and remove clamps.
132          * On first boot entry do not wait - go to direct ungate.
133          */
134         if (cpu_isset(cpu, tegra_cpu_init_map)) {
135                 timeout = jiffies + 5;
136                 do {
137                         if (tegra_powergate_is_powered(pwrgateid))
138                                 goto remove_clamps;
139                         udelay(10);
140                 } while (time_before(jiffies, timeout));
141         }
142
143         /* If this is the first boot, toggle powergates directly. */
144         if (!tegra_powergate_is_powered(pwrgateid)) {
145                 ret = tegra_unpowergate_partition(pwrgateid);
146                 if (ret)
147                         return ret;
148
149                 /* Wait for the power to come up. */
150                 timeout = jiffies + 10*HZ;
151                 while (tegra_powergate_is_powered(pwrgateid)) {
152                         if (time_after(jiffies, timeout))
153                                 return -ETIMEDOUT;
154                         udelay(10);
155                 }
156         }
157
158 remove_clamps:
159         /* CPU partition is powered. Enable the CPU clock. */
160         tegra_enable_cpu_clock(cpu);
161         udelay(10);
162
163         /* Remove I/O clamps. */
164         ret = tegra_powergate_remove_clamping(pwrgateid);
165         if (ret)
166                 return ret;
167
168         udelay(10);
169
170         /* Clear flow controller CSR. */
171         flowctrl_write_cpu_csr(cpu, 0);
172
173         return 0;
174 }
175
176 static int __cpuinit tegra_boot_secondary(unsigned int cpu, struct task_struct *idle)
177 {
178         int status;
179
180         BUG_ON(cpu == smp_processor_id());
181
182         /* Avoid timer calibration on slave cpus. Use the value calibrated
183          * on master cpu. This reduces the bringup time for each slave cpu
184          * by around 260ms.
185          */
186         preset_lpj = loops_per_jiffy;
187
188         /*
189          * Force the CPU into reset. The CPU must remain in reset when the
190          * flow controller state is cleared (which will cause the flow
191          * controller to stop driving reset if the CPU has been power-gated
192          * via the flow controller). This will have no effect on first boot
193          * of the CPU since it should already be in reset.
194          */
195         tegra_put_cpu_in_reset(cpu);
196
197         /*
198          * Unhalt the CPU. If the flow controller was used to power-gate the
199          * CPU this will cause the flow controller to stop driving reset.
200          * The CPU will remain in reset because the clock and reset block
201          * is now driving reset.
202          */
203         flowctrl_write_cpu_halt(cpu, 0);
204
205         switch (tegra_chip_id) {
206         case TEGRA20:
207                 status = tegra20_power_up_cpu(cpu);
208                 break;
209         case TEGRA30:
210                 status = tegra30_power_up_cpu(cpu);
211                 break;
212         default:
213                 status = -EINVAL;
214                 break;
215         }
216
217         if (status)
218                 goto done;
219
220         /* Take the CPU out of reset. */
221         tegra_cpu_out_of_reset(cpu);
222 done:
223         return status;
224 }
225
226 /*
227  * Initialise the CPU possible map early - this describes the CPUs
228  * which may be present or become present in the system.
229  */
230 static void __init tegra_smp_init_cpus(void)
231 {
232         unsigned int ncores = available_cpus();
233         unsigned int i;
234
235         if (ncores > nr_cpu_ids) {
236                 pr_warn("SMP: %u cores greater than maximum (%u), clipping\n",
237                         ncores, nr_cpu_ids);
238                 ncores = nr_cpu_ids;
239         }
240
241         for (i = 0; i < ncores; i++)
242                 set_cpu_possible(i, true);
243
244         /* If only one CPU is possible, platform_smp_prepare_cpus() will
245            never get called. We must therefore initialize the reset handler
246            here. If there is more than one CPU, we must wait until after
247            the cpu_present_mask has been updated with all present CPUs in
248            platform_smp_prepare_cpus() before initializing the reset handler. */
249         if (ncores == 1) {
250                 tegra_cpu_reset_handler_init();
251                 tegra_all_cpus_booted = true;
252         }
253 }
254
255 static void __init tegra_smp_prepare_cpus(unsigned int max_cpus)
256 {
257
258         /* Always mark the boot CPU as initialized. */
259         cpumask_set_cpu(0, to_cpumask(tegra_cpu_init_bits));
260
261         if (max_cpus == 1)
262                 tegra_all_cpus_booted = true;
263
264         /* If we're here, it means that more than one CPU was found by
265            smp_init_cpus() which also means that it did not initialize the
266            reset handler. Do it now before the secondary CPUs are started. */
267         tegra_cpu_reset_handler_init();
268
269 #if defined(CONFIG_HAVE_ARM_SCU)
270         {
271                 u32 scu_ctrl = __raw_readl(scu_base) |
272                                 1 << 3 | /* Enable speculative line fill*/
273                                 1 << 5 | /* Enable IC standby */
274                                 1 << 6; /* Enable SCU standby */
275                 if (!(scu_ctrl & 1))
276                         __raw_writel(scu_ctrl, scu_base);
277         }
278 #endif
279         scu_enable(scu_base);
280 }
281
282 struct smp_operations tegra_smp_ops __initdata = {
283         .smp_init_cpus          = tegra_smp_init_cpus,
284         .smp_prepare_cpus       = tegra_smp_prepare_cpus,
285         .smp_secondary_init     = tegra_secondary_init,
286         .smp_boot_secondary     = tegra_boot_secondary,
287 #ifdef CONFIG_HOTPLUG_CPU
288         .cpu_kill               = tegra_cpu_kill,
289         .cpu_die                = tegra_cpu_die,
290 #endif
291 };