ARM: tegra: dvfs: Expand CPU 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};
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 #define KHZ 1000
50 #define MHZ 1000000
51
52 static struct dvfs_rail tegra2_dvfs_rail_vdd_cpu = {
53         .reg_id = "vdd_cpu",
54         .max_millivolts = 1125,
55         .min_millivolts = 750,
56         .nominal_millivolts = 1125,
57 };
58
59 static struct dvfs_rail tegra2_dvfs_rail_vdd_core = {
60         .reg_id = "vdd_core",
61         .max_millivolts = 1275,
62         .min_millivolts = 950,
63         .nominal_millivolts = 1200,
64         .step = 150, /* step vdd_core by 150 mV to allow vdd_aon to follow */
65 };
66
67 static struct dvfs_rail tegra2_dvfs_rail_vdd_aon = {
68         .reg_id = "vdd_aon",
69         .max_millivolts = 1275,
70         .min_millivolts = 950,
71         .nominal_millivolts = 1200,
72 #ifndef CONFIG_TEGRA_CORE_DVFS
73         .disabled = true,
74 #endif
75 };
76
77 /* vdd_core and vdd_aon must be 50 mV higher than vdd_cpu */
78 static int tegra2_dvfs_rel_vdd_cpu_vdd_core(struct dvfs_rail *vdd_cpu,
79         struct dvfs_rail *vdd_core)
80 {
81         if (vdd_cpu->new_millivolts > vdd_cpu->millivolts &&
82             vdd_core->new_millivolts < vdd_cpu->new_millivolts + 50)
83                 return vdd_cpu->new_millivolts + 50;
84
85         if (vdd_core->new_millivolts < vdd_cpu->millivolts + 50)
86                 return vdd_cpu->millivolts + 50;
87
88         return vdd_core->new_millivolts;
89 }
90
91 /* vdd_aon must be within 170 mV of vdd_core */
92 static int tegra2_dvfs_rel_vdd_core_vdd_aon(struct dvfs_rail *vdd_core,
93         struct dvfs_rail *vdd_aon)
94 {
95         BUG_ON(abs(vdd_aon->millivolts - vdd_core->millivolts) >
96                 vdd_aon->step);
97         return vdd_core->millivolts;
98 }
99
100 static struct dvfs_relationship tegra2_dvfs_relationships[] = {
101         {
102                 /* vdd_core must be 50 mV higher than vdd_cpu */
103                 .from = &tegra2_dvfs_rail_vdd_cpu,
104                 .to = &tegra2_dvfs_rail_vdd_core,
105                 .solve = tegra2_dvfs_rel_vdd_cpu_vdd_core,
106         },
107         {
108                 /* vdd_aon must be 50 mV higher than vdd_cpu */
109                 .from = &tegra2_dvfs_rail_vdd_cpu,
110                 .to = &tegra2_dvfs_rail_vdd_aon,
111                 .solve = tegra2_dvfs_rel_vdd_cpu_vdd_core,
112         },
113         {
114                 /* vdd_aon must be within 170 mV of vdd_core */
115                 .from = &tegra2_dvfs_rail_vdd_core,
116                 .to = &tegra2_dvfs_rail_vdd_aon,
117                 .solve = tegra2_dvfs_rel_vdd_core_vdd_aon,
118         },
119 };
120
121 static struct dvfs_rail *tegra2_dvfs_rails[] = {
122         &tegra2_dvfs_rail_vdd_cpu,
123         &tegra2_dvfs_rail_vdd_core,
124         &tegra2_dvfs_rail_vdd_aon,
125 };
126
127 #define CPU_DVFS(_clk_name, _speedo_id, _process_id, _mult, _freqs...)  \
128         {                                                       \
129                 .clk_name       = _clk_name,                    \
130                 .speedo_id      = _speedo_id,                   \
131                 .process_id     = _process_id,                  \
132                 .freqs          = {_freqs},                     \
133                 .freqs_mult     = _mult,                        \
134                 .millivolts     = cpu_millivolts,               \
135                 .auto_dvfs      = true,                         \
136                 .dvfs_rail      = &tegra2_dvfs_rail_vdd_cpu,    \
137         }
138
139 #define CORE_DVFS(_clk_name, _auto, _mult, _freqs...)           \
140         {                                                       \
141                 .clk_name       = _clk_name,                    \
142                 .speedo_id      = -1,                           \
143                 .process_id     = -1,                           \
144                 .freqs          = {_freqs},                     \
145                 .freqs_mult     = _mult,                        \
146                 .millivolts     = core_millivolts,              \
147                 .auto_dvfs      = _auto,                        \
148                 .dvfs_rail      = &tegra2_dvfs_rail_vdd_core,   \
149         }
150
151 static struct dvfs dvfs_init[] = {
152         /* Cpu voltages (mV):      750, 775, 800, 825, 850, 875,  900,  925,  950,  975,  1000, 1025, 1050, 1100, 1125 */
153         CPU_DVFS("cpu", 0, 0, MHZ, 314, 314, 314, 456, 456, 456,  608,  608,  608,  760,  817,  817,  912,  1000),
154         CPU_DVFS("cpu", 0, 1, MHZ, 314, 314, 314, 456, 456, 456,  618,  618,  618,  770,  827,  827,  922,  1000),
155         CPU_DVFS("cpu", 0, 2, MHZ, 494, 494, 494, 675, 675, 817,  817,  922,  922,  1000),
156         CPU_DVFS("cpu", 0, 3, MHZ, 730, 760, 845, 845, 940, 1000),
157
158         CPU_DVFS("cpu", 1, 0, MHZ, 380, 380, 503, 503, 655, 655,  798,  798,  902,  902,  960,  1000),
159         CPU_DVFS("cpu", 1, 1, MHZ, 389, 389, 503, 503, 655, 760,  798,  798,  950,  950,  1000),
160         CPU_DVFS("cpu", 1, 2, MHZ, 598, 598, 750, 750, 893, 893,  1000),
161         CPU_DVFS("cpu", 1, 3, MHZ, 730, 760, 845, 845, 940, 1000),
162
163         CPU_DVFS("cpu", 2, 0, MHZ,   0,   0,   0,   0, 655, 655,  798,  798,  902,  902,  960,  1000, 1100, 1100, 1200),
164         CPU_DVFS("cpu", 2, 1, MHZ,   0,   0,   0,   0, 655, 760,  798,  798,  950,  950,  1015, 1015, 1100, 1200),
165         CPU_DVFS("cpu", 2, 2, MHZ,   0,   0,   0,   0, 769, 769,  902,  902,  1026, 1026, 1140, 1140, 1200),
166         CPU_DVFS("cpu", 2, 3, MHZ,   0,   0,   0,   0, 940, 1000, 1000, 1000, 1130, 1130, 1200),
167
168         /* Core voltages (mV):       950,    1000,   1100,   1200,   1275 */
169         CORE_DVFS("emc",     1, KHZ, 57000,  333000, 333000, 666000, 666000),
170
171 #if 0
172         /*
173          * The sdhci core calls the clock ops with a spinlock held, which
174          * conflicts with the sleeping dvfs api.
175          * For now, boards must ensure that the core voltage does not drop
176          * below 1V, or that the sdmmc busses are set to 44 MHz or less.
177          */
178         CORE_DVFS("sdmmc1",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
179         CORE_DVFS("sdmmc2",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
180         CORE_DVFS("sdmmc3",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
181         CORE_DVFS("sdmmc4",  1, KHZ, 44000,  52000,  52000,  52000,  52000),
182 #endif
183
184         CORE_DVFS("ndflash", 1, KHZ, 130000, 150000, 158000, 164000, 164000),
185         CORE_DVFS("nor",     1, KHZ, 0,      92000,  92000,  92000,  92000),
186         CORE_DVFS("ide",     1, KHZ, 0,      0,      100000, 100000, 100000),
187         CORE_DVFS("mipi",    1, KHZ, 0,      40000,  40000,  40000, 60000),
188         CORE_DVFS("usbd",    1, KHZ, 0,      0,      0,      480000, 480000),
189         CORE_DVFS("usb2",    1, KHZ, 0,      0,      0,      480000, 480000),
190         CORE_DVFS("usb3",    1, KHZ, 0,      0,      0,      480000, 480000),
191         CORE_DVFS("pcie",    1, KHZ, 0,      0,      0,      250000, 250000),
192         CORE_DVFS("dsi",     1, KHZ, 100000, 100000, 100000, 500000, 500000),
193         CORE_DVFS("tvo",     1, KHZ, 0,      0,      0,      250000, 250000),
194
195         /*
196          * The clock rate for the display controllers that determines the
197          * necessary core voltage depends on a divider that is internal
198          * to the display block.  Disable auto-dvfs on the display clocks,
199          * and let the display driver call tegra_dvfs_set_rate manually
200          */
201         CORE_DVFS("disp1",   0, KHZ, 158000, 158000, 190000, 190000, 190000),
202         CORE_DVFS("disp2",   0, KHZ, 158000, 158000, 190000, 190000, 190000),
203         CORE_DVFS("hdmi",    0, KHZ, 0,      0,      0,      148500, 148500),
204
205         /*
206          * These clocks technically depend on the core process id,
207          * but just use the worst case value for now
208          */
209         CORE_DVFS("host1x",  1, KHZ, 104500, 133000, 166000, 166000, 166000),
210         CORE_DVFS("epp",     1, KHZ, 133000, 171000, 247000, 300000, 300000),
211         CORE_DVFS("2d",      1, KHZ, 133000, 171000, 247000, 300000, 300000),
212         CORE_DVFS("3d",      1, KHZ, 114000, 161500, 247000, 300000, 300000),
213         CORE_DVFS("mpe",     1, KHZ, 104500, 152000, 228000, 250000, 250000),
214         CORE_DVFS("vi",      1, KHZ, 85000,  100000, 150000, 150000, 150000),
215         CORE_DVFS("sclk",    1, KHZ, 95000,  133000, 190000, 250000, 250000),
216         CORE_DVFS("vde",     1, KHZ, 95000,  123500, 209000, 250000, 250000),
217         /* What is this? */
218         CORE_DVFS("NVRM_DEVID_CLK_SRC", 1, MHZ, 480, 600, 800, 1067, 1067),
219 };
220
221 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
222 {
223         int ret;
224
225         ret = param_set_bool(arg, kp);
226         if (ret)
227                 return ret;
228
229         if (tegra_dvfs_core_disabled)
230                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_core);
231         else
232                 tegra_dvfs_rail_enable(&tegra2_dvfs_rail_vdd_core);
233
234         return 0;
235 }
236
237 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
238 {
239         int ret;
240
241         ret = param_set_bool(arg, kp);
242         if (ret)
243                 return ret;
244
245         if (tegra_dvfs_cpu_disabled)
246                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_cpu);
247         else
248                 tegra_dvfs_rail_enable(&tegra2_dvfs_rail_vdd_cpu);
249
250         return 0;
251 }
252
253 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
254 {
255         return param_get_bool(buffer, kp);
256 }
257
258 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
259         .set = tegra_dvfs_disable_core_set,
260         .get = tegra_dvfs_disable_get,
261 };
262
263 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
264         .set = tegra_dvfs_disable_cpu_set,
265         .get = tegra_dvfs_disable_get,
266 };
267
268 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
269         &tegra_dvfs_core_disabled, 0644);
270 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
271         &tegra_dvfs_cpu_disabled, 0644);
272
273 void __init tegra2_init_dvfs(void)
274 {
275         int i;
276         struct clk *c;
277         struct dvfs *d;
278         int process_id;
279         int ret;
280         int cpu_process_id = tegra_cpu_process_id();
281         int core_process_id = tegra_core_process_id();
282         int speedo_id = tegra_soc_speedo_id();
283
284         BUG_ON(speedo_id >= ARRAY_SIZE(cpu_speedo_nominal_millivolts));
285         tegra2_dvfs_rail_vdd_cpu.nominal_millivolts =
286                 cpu_speedo_nominal_millivolts[speedo_id];
287
288         tegra_dvfs_init_rails(tegra2_dvfs_rails, ARRAY_SIZE(tegra2_dvfs_rails));
289         tegra_dvfs_add_relationships(tegra2_dvfs_relationships,
290                 ARRAY_SIZE(tegra2_dvfs_relationships));
291         /*
292          * VDD_CORE must always be at least 50 mV higher than VDD_CPU
293          * Fill out cpu_core_millivolts based on cpu_millivolts
294          */
295         for (i = 0; i < ARRAY_SIZE(dvfs_init); i++) {
296                 d = &dvfs_init[i];
297
298                 process_id = strcmp(d->clk_name, "cpu") ?
299                         core_process_id : cpu_process_id;
300                 if ((d->process_id != -1 && d->process_id != process_id) ||
301                     (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
302                         pr_debug("tegra_dvfs: rejected %s speedo %d,"
303                                 " process %d\n", d->clk_name, d->speedo_id,
304                                 d->process_id);
305                         continue;
306                 }
307
308                 c = tegra_get_clock_by_name(d->clk_name);
309
310                 if (!c) {
311                         pr_debug("tegra_dvfs: no clock found for %s\n",
312                                 d->clk_name);
313                         continue;
314                 }
315
316                 ret = tegra_enable_dvfs_on_clk(c, d);
317                 if (ret)
318                         pr_err("tegra_dvfs: failed to enable dvfs on %s\n",
319                                 c->name);
320         }
321
322         if (tegra_dvfs_core_disabled)
323                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_core);
324
325         if (tegra_dvfs_cpu_disabled)
326                 tegra_dvfs_rail_disable(&tegra2_dvfs_rail_vdd_cpu);
327 }