ARM: tegra: power: Refactored kernel powergate code
[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 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_ARCH_TEGRA_2x_SOC
77         return -EPERM;
78 #else
79         u32 fuse_sku = readl(FUSE_SKU_DIRECT_CONFIG);
80         u32 bond_out = readl(CAR_BOND_OUT_V);
81
82         /* Does the G CPU complex exist at all? */
83         if ((fuse_sku & FUSE_SKU_DISABLE_ALL_CPUS) ||
84             (bond_out & CAR_BOND_OUT_V_CPU_G))
85                 return -EPERM;
86
87         if (cpu >= available_cpus())
88                 return -EPERM;
89
90         /* FIXME: The G CPU can be unavailable for a number of reasons
91          *        (e.g., low battery, over temperature, etc.). Add checks for
92          *        these conditions. */
93         return 0;
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 + HZ;
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 done:
174         return status;
175 }
176
177 static int __cpuinit tegra_boot_secondary(unsigned int cpu, struct task_struct *idle)
178 {
179         int status;
180
181         BUG_ON(cpu == smp_processor_id());
182
183         /*
184          * Force the CPU into reset. The CPU must remain in reset when the
185          * flow controller state is cleared (which will cause the flow
186          * controller to stop driving reset if the CPU has been power-gated
187          * via the flow controller). This will have no effect on first boot
188          * of the CPU since it should already be in reset.
189          */
190         tegra_put_cpu_in_reset(cpu);
191
192         /*
193          * Unhalt the CPU. If the flow controller was used to power-gate the
194          * CPU this will cause the flow controller to stop driving reset.
195          * The CPU will remain in reset because the clock and reset block
196          * is now driving reset.
197          */
198         flowctrl_write_cpu_halt(cpu, 0);
199
200         switch (tegra_chip_id) {
201         case TEGRA20:
202                 status = tegra20_power_up_cpu(cpu);
203                 break;
204         case TEGRA30:
205                 status = tegra30_power_up_cpu(cpu);
206                 break;
207         default:
208                 status = -EINVAL;
209                 break;
210         }
211
212         if (status)
213                 goto done;
214
215         /* Take the CPU out of reset. */
216         tegra_cpu_out_of_reset(cpu);
217 done:
218         return status;
219 }
220
221 /*
222  * Initialise the CPU possible map early - this describes the CPUs
223  * which may be present or become present in the system.
224  */
225 static void __init tegra_smp_init_cpus(void)
226 {
227         unsigned int ncores = available_cpus();
228         unsigned int i;
229
230         if (ncores > nr_cpu_ids) {
231                 pr_warn("SMP: %u cores greater than maximum (%u), clipping\n",
232                         ncores, nr_cpu_ids);
233                 ncores = nr_cpu_ids;
234         }
235
236         for (i = 0; i < ncores; i++)
237                 set_cpu_possible(i, true);
238
239         /* If only one CPU is possible, platform_smp_prepare_cpus() will
240            never get called. We must therefore initialize the reset handler
241            here. If there is more than one CPU, we must wait until after
242            the cpu_present_mask has been updated with all present CPUs in
243            platform_smp_prepare_cpus() before initializing the reset handler. */
244         if (ncores == 1) {
245                 tegra_cpu_reset_handler_init();
246                 tegra_all_cpus_booted = true;
247         }
248 }
249
250 static void __init tegra_smp_prepare_cpus(unsigned int max_cpus)
251 {
252
253         /* Always mark the boot CPU as initialized. */
254         cpumask_set_cpu(0, to_cpumask(tegra_cpu_init_bits));
255
256         if (max_cpus == 1)
257                 tegra_all_cpus_booted = true;
258
259         /* If we're here, it means that more than one CPU was found by
260            smp_init_cpus() which also means that it did not initialize the
261            reset handler. Do it now before the secondary CPUs are started. */
262         tegra_cpu_reset_handler_init();
263         scu_enable(scu_base);
264 }
265
266 struct smp_operations tegra_smp_ops __initdata = {
267         .smp_init_cpus          = tegra_smp_init_cpus,
268         .smp_prepare_cpus       = tegra_smp_prepare_cpus,
269         .smp_secondary_init     = tegra_secondary_init,
270         .smp_boot_secondary     = tegra_boot_secondary,
271 #ifdef CONFIG_HOTPLUG_CPU
272         .cpu_kill               = tegra_cpu_kill,
273         .cpu_die                = tegra_cpu_die,
274 #endif
275 };