ca567f0cf0e0afef65fb9a7b491cc06eef1875c1
[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/kernel.h>
18 #include <linux/init.h>
19 #include <linux/io.h>
20 #include <linux/smp.h>
21 #include <linux/delay.h>
22 #include <linux/clk.h>
23 #include <linux/clk/tegra.h>
24 #include <linux/cpumask.h>
25
26 #include <asm/cputype.h>
27 #include <asm/smp_plat.h>
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 #include "sleep.h"
38 #include "cpu-tegra.h"
39
40 #include "common.h"
41 #include "iomap.h"
42
43 bool tegra_all_cpus_booted;
44
45 static DECLARE_BITMAP(tegra_cpu_init_bits, CONFIG_NR_CPUS) __read_mostly;
46 const struct cpumask *const tegra_cpu_init_mask = to_cpumask(tegra_cpu_init_bits);
47 #define tegra_cpu_init_map      (*(cpumask_t *)tegra_cpu_init_mask)
48
49 static DECLARE_BITMAP(tegra_cpu_power_up_by_fc, CONFIG_NR_CPUS) __read_mostly;
50 struct cpumask *tegra_cpu_power_mask =
51                                 to_cpumask(tegra_cpu_power_up_by_fc);
52 #define tegra_cpu_power_map     (*(cpumask_t *)tegra_cpu_power_mask)
53
54 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
55 static struct cpumask tegra_cpu_power_mask_saved;
56 #endif
57
58 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
59 #define CAR_BOND_OUT_V \
60         (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x390)
61 #define CAR_BOND_OUT_V_CPU_G    (1<<0)
62 #endif
63
64 #define CLAMP_STATUS    0x2c
65 #define PWRGATE_TOGGLE  0x30
66
67 #define PMC_TOGGLE_START        0x100
68
69 #ifdef CONFIG_HAVE_ARM_SCU
70 static void __iomem *scu_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE);
71 #endif
72
73 static unsigned int number_of_cores;
74
75 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
76 #define pmc_writel(value, reg)  writel(value, pmc + (reg))
77 #define pmc_readl(reg)          readl(pmc + (reg))
78
79 static void __init setup_core_count(void)
80 {
81 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
82         u32 l2ctlr;
83
84         unsigned int cpuid = (read_cpuid_id() >> 4) & 0xFFF;
85
86         /* Cortex-A15? */
87         if (cpuid == 0xC0F) {
88                 __asm__("mrc p15, 1, %0, c9, c0, 2\n" : "=r" (l2ctlr));
89                 number_of_cores = ((l2ctlr >> 24) & 3) + 1;
90         }
91         else {
92 #endif
93 #ifdef CONFIG_HAVE_ARM_SCU
94                 number_of_cores = scu_get_core_count(scu_base);
95 #else
96                 number_of_cores = 1;
97 #endif
98 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
99         }
100         if (number_of_cores > 1) {
101                 u32 fuse_sku = readl(FUSE_SKU_DIRECT_CONFIG);
102                 number_of_cores -= FUSE_SKU_NUM_DISABLED_CPUS(fuse_sku);
103                 BUG_ON((int)number_of_cores <= 0);
104         }
105 #endif
106 }
107
108 static unsigned int available_cpus(void)
109 {
110
111         BUG_ON((int)number_of_cores <= 0);
112
113         return number_of_cores;
114 }
115
116 static int is_g_cluster_available(unsigned int cpu)
117 {
118 #ifdef CONFIG_TEGRA_CLUSTER_CONTROL
119         u32 fuse_sku = readl(FUSE_SKU_DIRECT_CONFIG);
120         u32 bond_out = readl(CAR_BOND_OUT_V);
121
122         /* Does the G CPU complex exist at all? */
123         if ((fuse_sku & FUSE_SKU_DISABLE_ALL_CPUS) ||
124             (bond_out & CAR_BOND_OUT_V_CPU_G))
125                 return -EPERM;
126
127         if (cpu >= available_cpus())
128                 return -EPERM;
129
130         /* FIXME: The G CPU can be unavailable for a number of reasons
131          *        (e.g., low battery, over temperature, etc.). Add checks for
132          *        these conditions. */
133         return 0;
134 #else
135         return -EPERM;
136 #endif
137 }
138
139 static bool is_cpu_powered(unsigned int cpu)
140 {
141         if (is_lp_cluster())
142                 return true;
143         else
144                 return tegra_powergate_is_powered(TEGRA_CPU_POWERGATE_ID(cpu));
145 }
146
147 static void __cpuinit tegra_secondary_init(unsigned int cpu)
148 {
149         cpumask_set_cpu(cpu, to_cpumask(tegra_cpu_init_bits));
150         cpumask_set_cpu(cpu, tegra_cpu_power_mask);
151         if (!tegra_all_cpus_booted)
152                 if (cpumask_equal(tegra_cpu_init_mask, cpu_present_mask))
153                         tegra_all_cpus_booted = true;
154 }
155
156 static int tegra20_power_up_cpu(unsigned int cpu)
157 {
158
159         /* Enable the CPU clock. */
160         tegra_enable_cpu_clock(cpu);
161
162         /* Clear flow controller CSR. */
163         flowctrl_write_cpu_csr(cpu, 0);
164
165         return 0;
166 }
167
168 static int tegra30_power_up_cpu(unsigned int cpu)
169 {
170         int ret;
171         unsigned long timeout;
172         bool booted = false;
173
174         BUG_ON(cpu == smp_processor_id());
175         BUG_ON(is_lp_cluster());
176
177         if (cpu_isset(cpu, tegra_cpu_init_map))
178                 booted = true;
179
180         cpu = cpu_logical_map(cpu);
181
182         /* If this cpu has booted this function is entered after
183          * CPU has been already un-gated by flow controller. Wait
184          * for confirmation that cpu is powered and remove clamps.
185          * On first boot entry do not wait - go to direct ungate.
186          */
187         if (booted) {
188                 timeout = jiffies + msecs_to_jiffies(50);
189                 do {
190                         if (is_cpu_powered(cpu))
191                                 goto remove_clamps;
192                         udelay(10);
193                 } while (time_before(jiffies, timeout));
194         }
195
196         /* First boot or Flow controller did not work as expected. Try to
197            directly toggle power gates. Error if direct power on also fails. */
198         if (!is_cpu_powered(cpu)) {
199                 ret = tegra_unpowergate_partition(TEGRA_CPU_POWERGATE_ID(cpu));
200                 if (ret)
201                         goto fail;
202
203                 /* Wait for the power to come up. */
204                 timeout = jiffies + 10*HZ;
205
206                 do {
207                         if (is_cpu_powered(cpu))
208                                 goto remove_clamps;
209                         udelay(10);
210                 } while (time_before(jiffies, timeout));
211                 ret = -ETIMEDOUT;
212                 goto fail;
213         }
214
215 remove_clamps:
216         /* CPU partition is powered. Enable the CPU clock. */
217         tegra_enable_cpu_clock(cpu);
218         udelay(10);
219
220         /* Remove I/O clamps. */
221         ret = tegra_powergate_remove_clamping(TEGRA_CPU_POWERGATE_ID(cpu));
222         if (ret)
223                 return ret;
224
225         udelay(10);
226 fail:
227
228         /* Clear flow controller CSR. */
229         flowctrl_write_cpu_csr(cpu, 0);
230
231         return 0;
232 }
233
234 static int tegra11x_power_up_cpu(unsigned int cpu)
235 {
236         BUG_ON(cpu == smp_processor_id());
237         BUG_ON(is_lp_cluster());
238
239         cpu = cpu_logical_map(cpu);
240
241         if (cpu_isset(cpu, tegra_cpu_power_map)) {
242                 /* set SCLK as event trigger for flow conroller */
243                 flowctrl_write_cpu_csr(cpu, 0x1);
244                 flowctrl_write_cpu_halt(cpu, 0x48000000);
245         } else {
246                 u32 reg;
247
248                 reg = PMC_TOGGLE_START | TEGRA_CPU_POWERGATE_ID(cpu);
249                 pmc_writel(reg, PWRGATE_TOGGLE);
250         }
251
252         return 0;
253 }
254
255 static int __cpuinit tegra_boot_secondary(unsigned int cpu, struct task_struct *idle)
256 {
257         int status;
258
259         cpu = cpu_logical_map(cpu);
260
261         /* Avoid timer calibration on slave cpus. Use the value calibrated
262          * on master cpu. This reduces the bringup time for each slave cpu
263          * by around 260ms.
264          */
265         preset_lpj = loops_per_jiffy;
266         if (is_lp_cluster()) {
267                 struct clk *cpu_clk, *cpu_g_clk;
268
269                 /* The G CPU may not be available for a variety of reasons. */
270                 status = is_g_cluster_available(cpu);
271                 if (status)
272                         goto done;
273
274                 cpu_clk = tegra_get_clock_by_name("cpu");
275                 cpu_g_clk = tegra_get_clock_by_name("cpu_g");
276
277                 /* Switch to G CPU before continuing. */
278                 if (!cpu_clk || !cpu_g_clk) {
279                         /* Early boot, clock infrastructure is not initialized
280                            - CPU mode switch is not allowed */
281                         status = -EINVAL;
282                 } else {
283 #ifdef CONFIG_CPU_FREQ
284                         /* set cpu rate is within g-mode range before switch */
285                         unsigned int speed = max(
286                                 (unsigned long)tegra_getspeed(0),
287                                 clk_get_min_rate(cpu_g_clk) / 1000);
288                         tegra_update_cpu_speed(speed);
289 #endif
290                         status = tegra_cluster_switch(cpu_clk, cpu_g_clk);
291                 }
292
293                 if (status)
294                         goto done;
295         }
296
297         smp_wmb();
298
299 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
300         /*
301          * Force the CPU into reset. The CPU must remain in reset when the
302          * flow controller state is cleared (which will cause the flow
303          * controller to stop driving reset if the CPU has been power-gated
304          * via the flow controller). This will have no effect on first boot
305          * of the CPU since it should already be in reset.
306          */
307         tegra_put_cpu_in_reset(cpu);
308 #endif
309
310         switch (tegra_chip_id) {
311         case TEGRA_CHIPID_TEGRA2:
312                 /*
313                  * Unhalt the CPU. If the flow controller was used to power-gate
314                  * the CPU this will cause the flow controller to stop driving
315                  * reset. The CPU will remain in reset because the clock and
316                  * reset block is now driving reset.
317                  */
318                 flowctrl_write_cpu_halt(cpu, 0);
319                 status = tegra20_power_up_cpu(cpu);
320                 break;
321         case TEGRA_CHIPID_TEGRA3:
322                 /*
323                  * Unhalt the CPU. If the flow controller was used to power-gate
324                  * the CPU this will cause the flow controller to stop driving
325                  * reset. The CPU will remain in reset because the clock and
326                  * reset block is now driving reset.
327                  */
328                 flowctrl_write_cpu_halt(cpu, 0);
329                 status = tegra30_power_up_cpu(cpu);
330                 break;
331         case TEGRA_CHIPID_TEGRA11:
332         case TEGRA_CHIPID_TEGRA14:
333                 status = tegra11x_power_up_cpu(cpu);
334                 break;
335         default:
336                 status = -EINVAL;
337                 break;
338         }
339
340 #if defined(CONFIG_ARCH_TEGRA_2x_SOC) || defined(CONFIG_ARCH_TEGRA_3x_SOC)
341         if (status)
342                 goto done;
343
344         /* Take the CPU out of reset. */
345         tegra_cpu_out_of_reset(cpu);
346 #endif
347 done:
348         return status;
349 }
350
351 /*
352  * Initialise the CPU possible map early - this describes the CPUs
353  * which may be present or become present in the system.
354  */
355 static void __init tegra_smp_init_cpus(void)
356 {
357         unsigned int ncores;
358         unsigned int i;
359
360         setup_core_count();
361
362         ncores = available_cpus();
363
364         if (ncores > nr_cpu_ids) {
365                 pr_warn("SMP: %u cores greater than maximum (%u), clipping\n",
366                         ncores, nr_cpu_ids);
367                 ncores = nr_cpu_ids;
368         }
369
370         for (i = 0; i < ncores; i++)
371                 set_cpu_possible(i, true);
372
373         /* If only one CPU is possible, platform_smp_prepare_cpus() will
374            never get called. We must therefore initialize the reset handler
375            here. If there is more than one CPU, we must wait until after
376            the cpu_present_mask has been updated with all present CPUs in
377            platform_smp_prepare_cpus() before initializing the reset handler. */
378         if (ncores == 1) {
379                 tegra_cpu_reset_handler_init();
380                 tegra_all_cpus_booted = true;
381         }
382 }
383
384 static void __init tegra_smp_prepare_cpus(unsigned int max_cpus)
385 {
386         /* Always mark the boot CPU as initialized. */
387         cpumask_set_cpu(0, to_cpumask(tegra_cpu_init_bits));
388
389         /* Always mark the boot CPU as initially powered up */
390         cpumask_set_cpu(0, tegra_cpu_power_mask);
391
392         if (max_cpus == 1)
393                 tegra_all_cpus_booted = true;
394
395         /* If we're here, it means that more than one CPU was found by
396            smp_init_cpus() which also means that it did not initialize the
397            reset handler. Do it now before the secondary CPUs are started. */
398         tegra_cpu_reset_handler_init();
399
400 #ifdef CONFIG_HAVE_ARM_SCU
401         scu_enable(scu_base);
402 #endif
403 }
404
405 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC) && !defined(CONFIG_ARCH_TEGRA_3x_SOC)
406 void tegra_smp_clear_power_mask()
407 {
408         cpumask_clear(tegra_cpu_power_mask);
409         cpumask_set_cpu(0, tegra_cpu_power_mask);
410 }
411 #endif
412
413 #if defined(CONFIG_ARCH_TEGRA_14x_SOC)
414 void tegra_smp_save_power_mask()
415 {
416         tegra_cpu_power_mask_saved = *((struct cpumask *)tegra_cpu_power_mask);
417 }
418
419 void tegra_smp_restore_power_mask()
420 {
421         *tegra_cpu_power_mask = tegra_cpu_power_mask_saved;
422 }
423 #endif
424
425 #ifdef CONFIG_TEGRA_VIRTUAL_CPUID
426 static int tegra_cpu_disable(unsigned int cpu)
427 {
428         return 0;
429 }
430 #endif
431
432 struct smp_operations tegra_smp_ops __initdata = {
433         .smp_init_cpus          = tegra_smp_init_cpus,
434         .smp_prepare_cpus       = tegra_smp_prepare_cpus,
435         .smp_secondary_init     = tegra_secondary_init,
436         .smp_boot_secondary     = tegra_boot_secondary,
437 #ifdef CONFIG_HOTPLUG_CPU
438         .cpu_kill               = tegra_cpu_kill,
439         .cpu_die                = tegra_cpu_die,
440 #ifdef CONFIG_TEGRA_VIRTUAL_CPUID
441         .cpu_disable            = tegra_cpu_disable,
442 #endif
443 #endif
444 };