ARM: tegra: dvfs: Expand core voltage scaling tables
[linux-2.6.git] / arch / arm / mach-tegra / tegra2_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra2_dvfs.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *
9  * This software is licensed under the terms of the GNU General Public
10  * License version 2, as published by the Free Software Foundation, and
11  * may be copied, distributed, and modified under those terms.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/init.h>
22 #include <linux/string.h>
23 #include <linux/module.h>
24
25 #include "clock.h"
26 #include "dvfs.h"
27 #include "fuse.h"
28
29 #ifdef CONFIG_TEGRA_CORE_DVFS
30 static bool tegra_dvfs_core_disabled;
31 #else
32 static bool tegra_dvfs_core_disabled = true;
33 #endif
34 #ifdef CONFIG_TEGRA_CPU_DVFS
35 static bool tegra_dvfs_cpu_disabled;
36 #else
37 static bool tegra_dvfs_cpu_disabled = true;
38 #endif
39
40 static const int core_millivolts[MAX_DVFS_FREQS] =
41         {950, 1000, 1100, 1200, 1275, 1300};
42 static const int cpu_millivolts[MAX_DVFS_FREQS] =
43         {750, 775, 800, 825, 850, 875, 900, 925, 950, 975, 1000, 1025, 1050, 1100, 1125};
44
45 static const int cpu_speedo_nominal_millivolts[] =
46 /* spedo_id  0,    1,    2 */
47         { 1100, 1025, 1125 };
48
49 static const int core_speedo_nominal_millivolts[] =
50 /* spedo_id  0,    1,    2 */
51         { 1200, 1200, 1300 };
52
53 #define KHZ 1000
54 #define MHZ 1000000
55
56 static struct dvfs_rail tegra2_dvfs_rail_vdd_cpu = {
57         .reg_id = "vdd_cpu",
58         .max_millivolts = 1125,
59         .min_millivolts = 750,
60         .nominal_millivolts = 1125,
61 };
62
63 static struct dvfs_rail tegra2_dvfs_rail_vdd_core = {
64         .reg_id = "vdd_core",
65         .max_millivolts = 1300,
66         .min_millivolts = 950,
67         .nominal_millivolts = 1200,
68         .step = 150, /* step vdd_core by 150 mV to allow vdd_aon to follow */
69 };
70
71 static struct dvfs_rail tegra2_dvfs_rail_vdd_aon = {
72         .reg_id = "vdd_aon",
73         .max_millivolts = 1300,
74         .min_millivolts = 950,
75         .nominal_millivolts = 1200,
76 #ifndef CONFIG_TEGRA_CORE_DVFS
77         .disabled = true,
78 #endif
79 };
80
81 /* vdd_core and vdd_aon must be 50 mV higher than vdd_cpu */
82 static int tegra2_dvfs_rel_vdd_cpu_vdd_core(struct dvfs_rail *vdd_cpu,
83         struct dvfs_rail *vdd_core)
84 {
85         if (vdd_cpu->new_millivolts > vdd_cpu->millivolts &&
86             vdd_core->new_millivolts < vdd_cpu->new_millivolts + 50)
87                 return vdd_cpu->new_millivolts + 50;
88
89         if (vdd_core->new_millivolts < vdd_cpu->millivolts + 50)
90                 return vdd_cpu->millivolts + 50;
91
92         return vdd_core->new_millivolts;
93 }
94
95 /* vdd_aon must be within 170 mV of vdd_core */
96 static int tegra2_dvfs_rel_vdd_core_vdd_aon(struct dvfs_rail *vdd_core,
97         struct dvfs_rail *vdd_aon)
98 {
99         BUG_ON(abs(vdd_aon->millivolts - vdd_core->millivolts) >
100                 vdd_aon->step);
101         return vdd_core->millivolts;
102 }
103
104 static struct dvfs_relationship tegra2_dvfs_relationships[] = {
105         {
106                 /* vdd_core must be 50 mV higher than vdd_cpu */
107                 .from = &tegra2_dvfs_rail_vdd_cpu,
108                 .to = &tegra2_dvfs_rail_vdd_core,
109                 .solve = tegra2_dvfs_rel_vdd_cpu_vdd_core,
110         },
111         {
112                 /* vdd_aon must be 50 mV higher than vdd_cpu */
113                 .from = &tegra2_dvfs_rail_vdd_cpu,
114                 .to = &tegra2_dvfs_rail_vdd_aon,
115                 .solve = tegra2_dvfs_rel_vdd_cpu_vdd_core,
116         },
117         {
118                 /* vdd_aon must be within 170 mV of vdd_core */
119                 .from = &tegra2_dvfs_rail_vdd_core,
120                 .to = &tegra2_dvfs_rail_vdd_aon,
121                 .solve = tegra2_dvfs_rel_vdd_core_vdd_aon,
122         },
123 };
124
125 static struct dvfs_rail *tegra2_dvfs_rails[] = {
126         &tegra2_dvfs_rail_vdd_cpu,
127         &tegra2_dvfs_rail_vdd_core,
128         &tegra2_dvfs_rail_vdd_aon,
129 };
130
131 #define CPU_DVFS(_clk_name, _speedo_id, _process_id, _mult, _freqs...)  \
132         {                                                       \
133                 .clk_name       = _clk_name,                    \
134                 .speedo_id      = _speedo_id,                   \
135                 .process_id     = _process_id,                  \
136                 .freqs          = {_freqs},                     \
137                 .freqs_mult     = _mult,                        \
138                 .millivolts     = cpu_millivolts,               \
139                 .auto_dvfs      = true,                         \
140                 .dvfs_rail      = &tegra2_dvfs_rail_vdd_cpu,    \
141         }
142
143 #define CORE_DVFS(_clk_name, _process_id, _auto, _mult, _freqs...)      \
144         {                                                       \
145                 .clk_name       = _clk_name,                    \
146                 .speedo_id      = -1,                           \
147                 .process_id     = _process_id,                          \
148                 .freqs          = {_freqs},                     \
149                 .freqs_mult     = _mult,                        \
150                 .millivolts     = core_millivolts,              \
151                 .auto_dvfs      = _auto,                        \
152                 .dvfs_rail      = &tegra2_dvfs_rail_vdd_core,   \
153         }
154
155 static struct dvfs dvfs_init[] = {
156         /* Cpu voltages (mV):      750, 775, 800, 825, 850, 875,  900,  925,  950,  975,  1000, 1025, 1050, 1100, 1125 */
157         CPU_DVFS("cpu", 0, 0, MHZ, 314, 314, 314, 456, 456, 456,  608,  608,  608,  760,  817,  817,  912,  1000),
158         CPU_DVFS("cpu", 0, 1, MHZ, 314, 314, 314, 456, 456, 456,  618,  618,  618,  770,  827,  827,  922,  1000),
159         CPU_DVFS("cpu", 0, 2, MHZ, 494, 494, 494, 675, 675, 817,  817,  922,  922,  1000),
160         CPU_DVFS("cpu", 0, 3, MHZ, 730, 760, 845, 845, 940, 1000),
161
162         CPU_DVFS("cpu", 1, 0, MHZ, 380, 380, 503, 503, 655, 655,  798,  798,  902,  902,  960,  1000),
163         CPU_DVFS("cpu", 1, 1, MHZ, 389, 389, 503, 503, 655, 760,  798,  798,  950,  950,  1000),
164         CPU_DVFS("cpu", 1, 2, MHZ, 598, 598, 750, 750, 893, 893,  1000),
165         CPU_DVFS("cpu", 1, 3, MHZ, 730, 760, 845, 845, 940, 1000),
166
167         CPU_DVFS("cpu", 2, 0, MHZ,   0,   0,   0,   0, 655, 655,  798,  798,  902,  902,  960,  1000, 1100, 1100, 1200),
168         CPU_DVFS("cpu", 2, 1, MHZ,   0,   0,   0,   0, 655, 760,  798,  798,  950,  950,  1015, 1015, 1100, 1200),
169         CPU_DVFS("cpu", 2, 2, MHZ,   0,   0,   0,   0, 769, 769,  902,  902,  1026, 1026, 1140, 1140, 1200),
170         CPU_DVFS("cpu", 2, 3, MHZ,   0,   0,   0,   0, 940, 1000, 1000, 1000, 1130, 1130, 1200),
171
172         /* Core voltages (mV):       950,    1000,   1100,   1200,   1275,   1300 */
173         CORE_DVFS("emc", -1,  1, KHZ, 57000,  333000, 380000, 666000, 666000, 760000),
174
175 #if 0
176         /*
177          * The sdhci core calls the clock ops with a spinlock held, which
178          * conflicts with the sleeping dvfs api.
179          * For now, boards must ensure that the core voltage does not drop
180          * below 1V, or that the sdmmc busses are set to 44 MHz or less.
181          */
182         CORE_DVFS("sdmmc1",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
183         CORE_DVFS("sdmmc2",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
184         CORE_DVFS("sdmmc3",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
185         CORE_DVFS("sdmmc4",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
186 #endif
187
188         CORE_DVFS("ndflash", -1, 1, KHZ, 130000, 150000, 158000, 164000, 164000, 164000),
189         CORE_DVFS("nor",     -1, 1, KHZ, 0,      92000,  92000,  92000,  92000,  92000),
190         CORE_DVFS("ide",     -1, 1, KHZ, 0,      0,      100000, 100000, 100000, 100000),
191         CORE_DVFS("mipi",    -1, 1, KHZ, 0,      40000,  40000,  40000,  60000,  60000),
192         CORE_DVFS("usbd",    -1, 1, KHZ, 0,      0,      0,      480000, 480000, 480000),
193         CORE_DVFS("usb2",    -1, 1, KHZ, 0,      0,      0,      480000, 480000, 480000),
194         CORE_DVFS("usb3",    -1, 1, KHZ, 0,      0,      0,      480000, 480000, 480000),
195         CORE_DVFS("pcie",    -1, 1, KHZ, 0,      0,      0,      250000, 250000, 250000),
196         CORE_DVFS("dsi",     -1, 1, KHZ, 100000, 100000, 100000, 500000, 500000, 500000),
197         CORE_DVFS("tvo",     -1, 1, KHZ, 0,      0,      0,      250000, 250000, 250000),
198
199         /*
200          * The clock rate for the display controllers that determines the
201          * necessary core voltage depends on a divider that is internal
202          * to the display block.  Disable auto-dvfs on the display clocks,
203          * and let the display driver call tegra_dvfs_set_rate manually
204          */
205         CORE_DVFS("disp1",   -1, 0, KHZ, 158000, 158000, 190000, 190000, 190000, 190000),
206         CORE_DVFS("disp2",   -1, 0, KHZ, 158000, 158000, 190000, 190000, 190000, 190000),
207         CORE_DVFS("hdmi",    -1, 0, KHZ, 0,      0,      0,      148500, 148500, 148500),
208
209         /*
210          * Clocks below depend on the core process id. Define per process_id
211          * tables for SCLK/VDE/3D clocks (maximum rate for these clocks is
212          * increased depending on tegra2 sku). Use the worst case value for
213          * other clocks for now.
214          */
215         CORE_DVFS("host1x", -1, 1, KHZ, 104500, 133000, 166000, 166000, 166000, 166000),
216         CORE_DVFS("epp",    -1, 1, KHZ, 133000, 171000, 247000, 300000, 300000, 300000),
217         CORE_DVFS("2d",     -1, 1, KHZ, 133000, 171000, 247000, 300000, 300000, 300000),
218
219         CORE_DVFS("3d",      0, 1, KHZ, 114000, 161500, 247000, 304000, 333500, 333500),
220         CORE_DVFS("3d",      1, 1, KHZ, 161500, 209000, 285000, 333500, 361000, 361000),
221         CORE_DVFS("3d",      2, 1, KHZ, 218500, 256500, 323000, 380000, 400000, 400000),
222         CORE_DVFS("3d",      3, 1, KHZ, 247000, 285000, 351500, 400000, 400000, 400000),
223
224         CORE_DVFS("mpe",    -1, 1, KHZ, 104500, 152000, 228000, 250000, 250000, 250000),
225         CORE_DVFS("vi",     -1, 1, KHZ, 85000,  100000, 150000, 150000, 150000, 150000),
226
227         CORE_DVFS("sclk",    0, 1, KHZ, 95000,  133000, 190000, 240000, 247000, 262000),
228         CORE_DVFS("sclk",    1, 1, KHZ, 123500, 159500, 207000, 240000, 264000, 277500),
229         CORE_DVFS("sclk",    2, 1, KHZ, 152000, 180500, 229500, 260000, 285000, 300000),
230         CORE_DVFS("sclk",    3, 1, KHZ, 171000, 218500, 256500, 292500, 300000, 300000),
231
232         CORE_DVFS("vde",     0, 1, KHZ, 95000,  123500, 209000, 275500, 300000, 300000),
233         CORE_DVFS("vde",     1, 1, KHZ, 123500, 152000, 237500, 300000, 300000, 300000),
234         CORE_DVFS("vde",     2, 1, KHZ, 152000, 209000, 285000, 300000, 300000, 300000),
235         CORE_DVFS("vde",     3, 1, KHZ, 171000, 218500, 300000, 300000, 300000, 300000),
236         /* What is this? */
237         CORE_DVFS("NVRM_DEVID_CLK_SRC", -1, 1, MHZ, 480, 600, 800, 1067, 1067, 1067),
238 };
239
240 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
241 {
242         int ret;
243
244         ret = param_set_bool(arg, kp);
245         if (ret)
246                 return ret;
247
248         if (tegra_dvfs_core_disabled)
249                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_core);
250         else
251                 tegra_dvfs_rail_enable(&tegra2_dvfs_rail_vdd_core);
252
253         return 0;
254 }
255
256 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
257 {
258         int ret;
259
260         ret = param_set_bool(arg, kp);
261         if (ret)
262                 return ret;
263
264         if (tegra_dvfs_cpu_disabled)
265                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_cpu);
266         else
267                 tegra_dvfs_rail_enable(&tegra2_dvfs_rail_vdd_cpu);
268
269         return 0;
270 }
271
272 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
273 {
274         return param_get_bool(buffer, kp);
275 }
276
277 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
278         .set = tegra_dvfs_disable_core_set,
279         .get = tegra_dvfs_disable_get,
280 };
281
282 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
283         .set = tegra_dvfs_disable_cpu_set,
284         .get = tegra_dvfs_disable_get,
285 };
286
287 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
288         &tegra_dvfs_core_disabled, 0644);
289 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
290         &tegra_dvfs_cpu_disabled, 0644);
291
292 void __init tegra2_init_dvfs(void)
293 {
294         int i;
295         struct clk *c;
296         struct dvfs *d;
297         int process_id;
298         int ret;
299         int cpu_process_id = tegra_cpu_process_id();
300         int core_process_id = tegra_core_process_id();
301         int speedo_id = tegra_soc_speedo_id();
302
303         BUG_ON(speedo_id >= ARRAY_SIZE(cpu_speedo_nominal_millivolts));
304         tegra2_dvfs_rail_vdd_cpu.nominal_millivolts =
305                 cpu_speedo_nominal_millivolts[speedo_id];
306         BUG_ON(speedo_id >= ARRAY_SIZE(core_speedo_nominal_millivolts));
307         tegra2_dvfs_rail_vdd_core.nominal_millivolts =
308                 core_speedo_nominal_millivolts[speedo_id];
309         tegra2_dvfs_rail_vdd_aon.nominal_millivolts =
310                 core_speedo_nominal_millivolts[speedo_id];
311
312         tegra_dvfs_init_rails(tegra2_dvfs_rails, ARRAY_SIZE(tegra2_dvfs_rails));
313         tegra_dvfs_add_relationships(tegra2_dvfs_relationships,
314                 ARRAY_SIZE(tegra2_dvfs_relationships));
315         /*
316          * VDD_CORE must always be at least 50 mV higher than VDD_CPU
317          * Fill out cpu_core_millivolts based on cpu_millivolts
318          */
319         for (i = 0; i < ARRAY_SIZE(dvfs_init); i++) {
320                 d = &dvfs_init[i];
321
322                 process_id = strcmp(d->clk_name, "cpu") ?
323                         core_process_id : cpu_process_id;
324                 if ((d->process_id != -1 && d->process_id != process_id) ||
325                     (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
326                         pr_debug("tegra_dvfs: rejected %s speedo %d,"
327                                 " process %d\n", d->clk_name, d->speedo_id,
328                                 d->process_id);
329                         continue;
330                 }
331
332                 c = tegra_get_clock_by_name(d->clk_name);
333
334                 if (!c) {
335                         pr_debug("tegra_dvfs: no clock found for %s\n",
336                                 d->clk_name);
337                         continue;
338                 }
339
340                 ret = tegra_enable_dvfs_on_clk(c, d);
341                 if (ret)
342                         pr_err("tegra_dvfs: failed to enable dvfs on %s\n",
343                                 c->name);
344         }
345
346         if (tegra_dvfs_core_disabled)
347                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_core);
348
349         if (tegra_dvfs_cpu_disabled)
350                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_cpu);
351 }