ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / pmc.c
1 /*
2  * Copyright (C) 2012,2013 NVIDIA CORPORATION. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15  *
16  */
17
18 #include <linux/kernel.h>
19 #include <linux/clk.h>
20 #include <linux/io.h>
21 #include <linux/of.h>
22 #include <linux/of_address.h>
23 #include <linux/export.h>
24 #include <linux/tegra-pmc.h>
25
26
27 #include "pmc.h"
28
29 #define PMC_CTRL                        0x0
30 #define PMC_CTRL_INTR_LOW               (1 << 17)
31 #define PMC_PWRGATE_TOGGLE              0x30
32 #define PMC_PWRGATE_TOGGLE_START        (1 << 8)
33 #define PMC_REMOVE_CLAMPING             0x34
34 #define PMC_PWRGATE_STATUS              0x38
35
36 #define PMC_CPUPWRGOOD_TIMER    0xc8
37 #define PMC_CPUPWROFF_TIMER     0xcc
38
39 #define TEGRA_POWERGATE_PCIE    3
40 #define TEGRA_POWERGATE_VDEC    4
41 #define TEGRA_POWERGATE_CPU1    9
42 #define TEGRA_POWERGATE_CPU2    10
43 #define TEGRA_POWERGATE_CPU3    11
44
45 #define PMC_DPD_SAMPLE          0x20
46 #define PMC_IO_DPD_REQ          0x1B8
47 #define PMC_IO_DPD2_REQ         0x1C0
48
49 static u8 tegra_cpu_domains[] = {
50         0xFF,                   /* not available for CPU0 */
51         TEGRA_POWERGATE_CPU1,
52         TEGRA_POWERGATE_CPU2,
53         TEGRA_POWERGATE_CPU3,
54 };
55 static DEFINE_SPINLOCK(tegra_powergate_lock);
56
57 static void __iomem *tegra_pmc_base;
58 static bool tegra_pmc_invert_interrupt;
59 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
60 static struct clk *tegra_pclk;
61 #endif
62
63 #ifdef CONFIG_OF
64 static struct pmc_pm_data pmc_pm_data;
65 #endif
66 struct pmc_pm_data *tegra_get_pm_data()
67 {
68 #ifdef CONFIG_OF
69         /*
70          * Some boards have CONFIG_OF defined but no dts files
71          */
72         if (!tegra_pmc_base)
73                 return NULL;
74         return &pmc_pm_data;
75 #else
76         return NULL;
77 #endif
78 }
79 EXPORT_SYMBOL(tegra_get_pm_data);
80
81 static inline u32 tegra_pmc_readl(u32 reg)
82 {
83         return readl(tegra_pmc_base + reg);
84 }
85
86 static inline void tegra_pmc_writel(u32 val, u32 reg)
87 {
88         writel(val, tegra_pmc_base + reg);
89 }
90
91 void tegra_pmc_set_dpd_sample()
92 {
93         tegra_pmc_writel(0x1, PMC_DPD_SAMPLE);
94 }
95 EXPORT_SYMBOL(tegra_pmc_set_dpd_sample);
96
97 void tegra_pmc_clear_dpd_sample()
98 {
99         tegra_pmc_writel(0x0, PMC_DPD_SAMPLE);
100 }
101 EXPORT_SYMBOL(tegra_pmc_clear_dpd_sample);
102
103 void tegra_pmc_remove_dpd_req()
104 {
105         tegra_pmc_writel(0x400fffff, PMC_IO_DPD_REQ);
106         tegra_pmc_writel(0x40001fff, PMC_IO_DPD2_REQ);
107 }
108 EXPORT_SYMBOL(tegra_pmc_remove_dpd_req);
109
110 static int tegra_pmc_get_cpu_powerdomain_id(int cpuid)
111 {
112         if (cpuid <= 0 || cpuid >= num_possible_cpus())
113                 return -EINVAL;
114         return tegra_cpu_domains[cpuid];
115 }
116
117 static bool tegra_pmc_powergate_is_powered(int id)
118 {
119         return (tegra_pmc_readl(PMC_PWRGATE_STATUS) >> id) & 1;
120 }
121
122 static int tegra_pmc_powergate_set(int id, bool new_state)
123 {
124         bool old_state;
125         unsigned long flags;
126
127         spin_lock_irqsave(&tegra_powergate_lock, flags);
128
129         old_state = tegra_pmc_powergate_is_powered(id);
130         WARN_ON(old_state == new_state);
131
132         tegra_pmc_writel(PMC_PWRGATE_TOGGLE_START | id, PMC_PWRGATE_TOGGLE);
133
134         spin_unlock_irqrestore(&tegra_powergate_lock, flags);
135
136         return 0;
137 }
138
139 static int tegra_pmc_powergate_remove_clamping(int id)
140 {
141         u32 mask;
142
143         /*
144          * Tegra has a bug where PCIE and VDE clamping masks are
145          * swapped relatively to the partition ids.
146          */
147         if (id ==  TEGRA_POWERGATE_VDEC)
148                 mask = (1 << TEGRA_POWERGATE_PCIE);
149         else if (id == TEGRA_POWERGATE_PCIE)
150                 mask = (1 << TEGRA_POWERGATE_VDEC);
151         else
152                 mask = (1 << id);
153
154         tegra_pmc_writel(mask, PMC_REMOVE_CLAMPING);
155
156         return 0;
157 }
158
159 bool tegra_pmc_cpu_is_powered(int cpuid)
160 {
161         int id;
162
163         id = tegra_pmc_get_cpu_powerdomain_id(cpuid);
164         if (id < 0)
165                 return false;
166         return tegra_pmc_powergate_is_powered(id);
167 }
168
169 int tegra_pmc_cpu_power_on(int cpuid)
170 {
171         int id;
172
173         id = tegra_pmc_get_cpu_powerdomain_id(cpuid);
174         if (id < 0)
175                 return id;
176         return tegra_pmc_powergate_set(id, true);
177 }
178
179 int tegra_pmc_cpu_remove_clamping(int cpuid)
180 {
181         int id;
182
183         id = tegra_pmc_get_cpu_powerdomain_id(cpuid);
184         if (id < 0)
185                 return id;
186         return tegra_pmc_powergate_remove_clamping(id);
187 }
188
189 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) && defined(CONFIG_PM_SLEEP)
190 void set_power_timers(unsigned long us_on, unsigned long us_off)
191 {
192         unsigned long long ticks;
193         unsigned long long pclk;
194         unsigned long rate;
195         static unsigned long tegra_last_pclk;
196
197         rate = clk_get_rate(tegra_pclk);
198         if (WARN_ON_ONCE(rate <= 0))
199                 pclk = 100000000;
200         else
201                 pclk = rate;
202
203         if ((rate != tegra_last_pclk)) {
204                 ticks = (us_on * pclk) + 999999ull;
205                 do_div(ticks, 1000000);
206                 tegra_pmc_writel((unsigned long)ticks, PMC_CPUPWRGOOD_TIMER);
207
208                 ticks = (us_off * pclk) + 999999ull;
209                 do_div(ticks, 1000000);
210                 tegra_pmc_writel((unsigned long)ticks, PMC_CPUPWROFF_TIMER);
211                 wmb();
212         }
213         tegra_last_pclk = pclk;
214 }
215 #endif
216
217 static const struct of_device_id matches[] __initconst = {
218         { .compatible = "nvidia,tegra124-pmc" },
219         { .compatible = "nvidia,tegra148-pmc" },
220         { .compatible = "nvidia,tegra114-pmc" },
221         { .compatible = "nvidia,tegra30-pmc" },
222         { .compatible = "nvidia,tegra20-pmc" },
223         { }
224 };
225
226 static void tegra_pmc_parse_dt(void)
227 {
228         struct device_node *np;
229         u32 prop;
230         enum tegra_suspend_mode suspend_mode;
231         u32 core_good_time[2] = {0, 0};
232         u32 lp0_vec[2] = {0, 0};
233
234         np = of_find_matching_node(NULL, matches);
235         BUG_ON(!np);
236
237         tegra_pmc_base = of_iomap(np, 0);
238
239         tegra_pmc_invert_interrupt = of_property_read_bool(np,
240                                      "nvidia,invert-interrupt");
241 #if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK)
242         tegra_pclk = of_clk_get_by_name(np, "pclk");
243         WARN_ON(IS_ERR(tegra_pclk));
244 #endif
245
246         /* Grabbing the power management configurations */
247         if (of_property_read_u32(np, "nvidia,suspend-mode", &prop)) {
248                 suspend_mode = TEGRA_SUSPEND_NONE;
249         } else {
250                 switch (prop) {
251                 case 0:
252                         suspend_mode = TEGRA_SUSPEND_LP0;
253                         break;
254                 case 1:
255                         suspend_mode = TEGRA_SUSPEND_LP1;
256                         break;
257                 case 2:
258                         suspend_mode = TEGRA_SUSPEND_LP2;
259                         break;
260                 default:
261                         suspend_mode = TEGRA_SUSPEND_NONE;
262                         break;
263                 }
264         }
265
266         if (of_property_read_u32(np, "nvidia,cpu-pwr-good-time", &prop))
267                 suspend_mode = TEGRA_SUSPEND_NONE;
268         pmc_pm_data.cpu_good_time = prop;
269
270         if (of_property_read_u32(np, "nvidia,cpu-pwr-off-time", &prop))
271                 suspend_mode = TEGRA_SUSPEND_NONE;
272         pmc_pm_data.cpu_off_time = prop;
273
274         if (of_property_read_u32_array(np, "nvidia,core-pwr-good-time",
275                         core_good_time, ARRAY_SIZE(core_good_time)))
276                 suspend_mode = TEGRA_SUSPEND_NONE;
277         pmc_pm_data.core_osc_time = core_good_time[0];
278         pmc_pm_data.core_pmu_time = core_good_time[1];
279
280         if (of_property_read_u32(np, "nvidia,core-pwr-off-time",
281                                  &prop))
282                 suspend_mode = TEGRA_SUSPEND_NONE;
283         pmc_pm_data.core_off_time = prop;
284
285         pmc_pm_data.corereq_high = of_property_read_bool(np,
286                                 "nvidia,core-power-req-active-high");
287
288         pmc_pm_data.sysclkreq_high = of_property_read_bool(np,
289                                 "nvidia,sys-clock-req-active-high");
290
291         pmc_pm_data.combined_req = of_property_read_bool(np,
292                                 "nvidia,combined-power-req");
293
294         pmc_pm_data.cpu_pwr_good_en = of_property_read_bool(np,
295                                 "nvidia,cpu-pwr-good-en");
296
297         if (of_property_read_u32_array(np, "nvidia,lp0-vec", lp0_vec,
298                                        ARRAY_SIZE(lp0_vec)))
299                 if (suspend_mode == TEGRA_SUSPEND_LP0)
300                         suspend_mode = TEGRA_SUSPEND_LP1;
301
302         pmc_pm_data.lp0_vec_phy_addr = lp0_vec[0];
303         pmc_pm_data.lp0_vec_size = lp0_vec[1];
304
305         pmc_pm_data.suspend_mode = suspend_mode;
306 }
307
308 void __init tegra_pmc_init(void)
309 {
310         u32 val;
311
312         tegra_pmc_parse_dt();
313
314         val = tegra_pmc_readl(PMC_CTRL);
315         if (tegra_pmc_invert_interrupt)
316                 val |= PMC_CTRL_INTR_LOW;
317         else
318                 val &= ~PMC_CTRL_INTR_LOW;
319         tegra_pmc_writel(val, PMC_CTRL);
320 }