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