ARM: tegra: dvfs: Update rail statistic
[linux-2.6.git] / arch / arm / mach-tegra / tegra11_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra11_dvfs.c
3  *
4  * Copyright (C) 2012 NVIDIA Corporation.
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/string.h>
20 #include <linux/module.h>
21 #include <linux/clk.h>
22 #include <linux/kobject.h>
23 #include <linux/err.h>
24
25 #include "clock.h"
26 #include "dvfs.h"
27 #include "fuse.h"
28 #include "board.h"
29 #include "tegra_cl_dvfs.h"
30
31 static bool tegra_dvfs_cpu_disabled;
32 static bool tegra_dvfs_core_disabled;
33
34 #define KHZ 1000
35 #define MHZ 1000000
36
37 /* FIXME: need tegra11 step */
38 #define VDD_SAFE_STEP                   100
39
40 static struct dvfs_rail tegra11_dvfs_rail_vdd_cpu = {
41         .reg_id = "vdd_cpu",
42         .max_millivolts = 1400,
43         .min_millivolts = 800,
44         .step = VDD_SAFE_STEP,
45         .jmp_to_zero = true,
46 };
47
48 static struct dvfs_rail tegra11_dvfs_rail_vdd_core = {
49         .reg_id = "vdd_core",
50         .max_millivolts = 1400,
51         .min_millivolts = 800,
52         .step = VDD_SAFE_STEP,
53 };
54
55 static struct dvfs_rail *tegra11_dvfs_rails[] = {
56         &tegra11_dvfs_rail_vdd_cpu,
57         &tegra11_dvfs_rail_vdd_core,
58 };
59
60 /* default cvb alignment on Tegra11 - 10mV */
61 int __attribute__((weak)) tegra_get_cvb_alignment_uV(void)
62 {
63         return 10000;
64 }
65
66 /* CPU DVFS tables */
67 /* FIXME: real data */
68 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
69         {
70                 .speedo_id = 0,
71                 .max_mv = 1250,
72                 .min_dfll_mv = 1000,
73                 .freqs_mult = MHZ,
74                 .speedo_scale = 100,
75                 .voltage_scale = 100,
76                 .cvb_table = {
77                         /*f    dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
78                         { 306, { 107330,  -1569,   0}, {  90000,    0,    0} },
79                         { 408, { 111250,  -1666,   0}, {  90000,    0,    0} },
80                         { 510, { 110000,  -1460,   0}, {  94000,    0,    0} },
81                         { 612, { 117290,  -1745,   0}, {  94000,    0,    0} },
82                         { 714, { 122700,  -1910,   0}, {  99000,    0,    0} },
83                         { 816, { 125620,  -1945,   0}, {  99000,    0,    0} },
84                         { 918, { 130560,  -2076,   0}, { 103000,    0,    0} },
85                         {1020, { 137280,  -2303,   0}, { 103000,    0,    0} },
86                         {1122, { 146440,  -2660,   0}, { 109000,    0,    0} },
87                         {1224, { 152190,  -2825,   0}, { 109000,    0,    0} },
88                         {1326, { 157520,  -2953,   0}, { 112000,    0,    0} },
89                         {1428, { 166100,  -3261,   0}, { 140000,    0,    0} },
90                         {1530, { 176410,  -3647,   0}, { 140000,    0,    0} },
91                         {1632, { 189620,  -4186,   0}, { 140000,    0,    0} },
92                         {1734, { 203190,  -4725,   0}, { 140000,    0,    0} },
93                         {1836, { 222670,  -5573,   0}, { 140000,    0,    0} },
94                         {1938, { 256210,  -7165,   0}, { 140000,    0,    0} },
95                         {2040, { 250050,  -6544,   0}, { 140000,    0,    0} },
96                         {   0, {      0,      0,   0}, {      0,    0,    0} },
97                 },
98         }
99 };
100
101 static int cpu_millivolts[MAX_DVFS_FREQS];
102 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
103
104 static struct dvfs cpu_dvfs = {
105         .clk_name       = "cpu_g",
106         .process_id     = -1,
107         .millivolts     = cpu_millivolts,
108         .dfll_millivolts = cpu_dfll_millivolts,
109         .auto_dvfs      = true,
110         .dvfs_rail      = &tegra11_dvfs_rail_vdd_cpu,
111         .dfll_data      = {
112                 .tune0          = 0x00b0019d,
113                 .tune1          = 0x0000001f,
114                 .droop_rate_min = 1000000,
115         },
116 };
117
118 /* Core DVFS tables */
119 /* FIXME: real data */
120 static const int core_millivolts[MAX_DVFS_FREQS] = {
121         837,  900,  950, 1000, 1050, 1100, 1125};
122
123 #define CORE_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)       \
124         {                                                       \
125                 .clk_name       = _clk_name,                    \
126                 .speedo_id      = _speedo_id,                   \
127                 .process_id     = -1,                           \
128                 .freqs          = {_freqs},                     \
129                 .freqs_mult     = _mult,                        \
130                 .millivolts     = core_millivolts,              \
131                 .auto_dvfs      = _auto,                        \
132                 .dvfs_rail      = &tegra11_dvfs_rail_vdd_core,  \
133         }
134
135 static struct dvfs core_dvfs_table[] = {
136         /* Core voltages (mV):              837,    900,    950,   1000,   1050,    1100,    1125, */
137         /* Clock limits for internal blocks, PLLs */
138 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
139         CORE_DVFS("cpu_lp", -1, 1, KHZ,       1, 144000, 252000, 288000, 372000,  468000,  468000),
140         CORE_DVFS("emc",   -1, 1, KHZ,        1, 264000, 348000, 384000, 528000,  800000,  800000),
141         CORE_DVFS("sbus",  -1, 1, KHZ,        1,  81600, 102000, 136000, 204000,  204000,  204000),
142
143         CORE_DVFS("vi",    -1, 1, KHZ,        1, 102000, 144000, 144000, 192000,  240000,  240000),
144
145         CORE_DVFS("2d",    -1, 1, KHZ,        1, 132000, 180000, 204000, 264000,  336000,  336000),
146         CORE_DVFS("3d",    -1, 1, KHZ,        1, 132000, 180000, 204000, 264000,  336000,  336000),
147
148         CORE_DVFS("epp",   -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
149         CORE_DVFS("msenc", -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
150         CORE_DVFS("se",    -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
151         CORE_DVFS("tsec",  -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
152         CORE_DVFS("vde",   -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
153
154         CORE_DVFS("host1x", -1, 1, KHZ,       1,  81600, 102000, 136000, 163200,  204000,  204000),
155
156 #ifdef CONFIG_TEGRA_DUAL_CBUS
157         CORE_DVFS("c2bus", -1, 1, KHZ,        1, 132000, 180000, 204000, 264000,  336000,  336000),
158         CORE_DVFS("c3bus", -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
159 #else
160         CORE_DVFS("cbus",  -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
161 #endif
162
163         CORE_DVFS("pll_m", -1, 1, KHZ,        1, 480000, 588000, 660000, 792000,  936000,  936000),
164         CORE_DVFS("pll_c", -1, 1, KHZ,        1, 480000, 588000, 660000, 792000,  936000,  936000),
165         CORE_DVFS("pll_c2", -1, 1, KHZ,       1, 480000, 588000, 660000, 792000,  936000,  936000),
166         CORE_DVFS("pll_c3", -1, 1, KHZ,       1, 480000, 588000, 660000, 792000,  936000,  936000),
167         CORE_DVFS("pll_d_out0", -1, 1, KHZ,   1, 480000, 588000, 660000, 792000,  936000,  936000),
168         CORE_DVFS("pll_d2_out0", -1, 1, KHZ,  1, 480000, 588000, 660000, 792000,  936000,  936000),
169         CORE_DVFS("pll_re_out", -1, 1, KHZ,   1, 480000, 588000, 660000, 792000,  936000,  936000),
170
171         /* Core voltages (mV):              837,    900,    950,   1000,   1050,    1100,    1125, */
172         /* Clock limits for I/O peripherals */
173         CORE_DVFS("i2c1", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
174         CORE_DVFS("i2c2", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
175         CORE_DVFS("i2c3", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
176         CORE_DVFS("i2c4", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
177
178         CORE_DVFS("sbc1", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
179         CORE_DVFS("sbc2", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
180         CORE_DVFS("sbc3", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
181         CORE_DVFS("sbc4", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
182         CORE_DVFS("sbc5", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
183         CORE_DVFS("sbc6", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
184
185         /* FIXME: re-enable after UART hs driver is updated */
186 #if 0
187         CORE_DVFS("uarta", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
188         CORE_DVFS("uartb", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
189         CORE_DVFS("uartc", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
190         CORE_DVFS("uartd", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
191         CORE_DVFS("uarte", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
192 #endif
193         CORE_DVFS("sdmmc1", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
194         CORE_DVFS("sdmmc2", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
195         CORE_DVFS("sdmmc3", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
196         CORE_DVFS("sdmmc4", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
197
198         CORE_DVFS("pwm",  -1, 1, KHZ,         1,  40800,  48000,  48000,  48000,   48000,   48000),
199
200         CORE_DVFS("csi",  -1, 1, KHZ,         1,      1,      1, 102000, 102000,  102000,  102000),
201         CORE_DVFS("dsia", -1, 1, KHZ,         1, 100000, 125000, 125000, 125000,  500000,  500000),
202         CORE_DVFS("dsib", -1, 1, KHZ,         1, 100000, 125000, 125000, 125000,  500000,  500000),
203         CORE_DVFS("dsialp", -1, 1, KHZ,       1, 102000, 102000, 102000, 102000,  156000,  156000),
204         CORE_DVFS("dsiblp", -1, 1, KHZ,       1, 102000, 102000, 102000, 102000,  156000,  156000),
205         CORE_DVFS("hdmi", -1, 1, KHZ,         1,  99000, 118800, 148500, 198000,  198000,  198000),
206
207         /*
208          * The clock rate for the display controllers that determines the
209          * necessary core voltage depends on a divider that is internal
210          * to the display block.  Disable auto-dvfs on the display clocks,
211          * and let the display driver call tegra_dvfs_set_rate manually
212          */
213         CORE_DVFS("disp1", -1, 0, KHZ,         1, 108000, 120000, 144000, 192000,  240000,  240000),
214         CORE_DVFS("disp2", -1, 0, KHZ,         1, 108000, 120000, 144000, 192000,  240000,  240000),
215
216         CORE_DVFS("xusb_falcon_src", -1, 1, KHZ, 1, 204000, 204000, 204000, 336000,  336000,  336000),
217         CORE_DVFS("xusb_host_src",   -1, 1, KHZ, 1,  58300,  58300,  58300, 112000,  112000,  112000),
218         CORE_DVFS("xusb_dev_src",    -1, 1, KHZ, 1,  58300,  58300,  58300, 112000,  112000,  112000),
219         CORE_DVFS("xusb_ss_src",     -1, 1, KHZ, 1,  60000,  60000,  60000, 120000,  120000,  120000),
220         CORE_DVFS("xusb_fs_src",     -1, 1, KHZ, 1,      1,  48000,  48000,  48000,   48000,   48000),
221         CORE_DVFS("xusb_hs_src",     -1, 1, KHZ, 1,      1,  60000,  60000,  60000,   60000,   60000),
222 #endif
223 };
224
225 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
226 {
227         int ret;
228
229         ret = param_set_bool(arg, kp);
230         if (ret)
231                 return ret;
232
233         if (tegra_dvfs_core_disabled)
234                 tegra_dvfs_rail_disable(&tegra11_dvfs_rail_vdd_core);
235         else
236                 tegra_dvfs_rail_enable(&tegra11_dvfs_rail_vdd_core);
237
238         return 0;
239 }
240
241 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
242 {
243         int ret;
244
245         ret = param_set_bool(arg, kp);
246         if (ret)
247                 return ret;
248
249         if (tegra_dvfs_cpu_disabled)
250                 tegra_dvfs_rail_disable(&tegra11_dvfs_rail_vdd_cpu);
251         else
252                 tegra_dvfs_rail_enable(&tegra11_dvfs_rail_vdd_cpu);
253
254         return 0;
255 }
256
257 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
258 {
259         return param_get_bool(buffer, kp);
260 }
261
262 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
263         .set = tegra_dvfs_disable_core_set,
264         .get = tegra_dvfs_disable_get,
265 };
266
267 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
268         .set = tegra_dvfs_disable_cpu_set,
269         .get = tegra_dvfs_disable_get,
270 };
271
272 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
273         &tegra_dvfs_core_disabled, 0644);
274 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
275         &tegra_dvfs_cpu_disabled, 0644);
276
277
278 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
279 {
280         /* Don't update manual dvfs clocks */
281         if (!d->auto_dvfs)
282                 return false;
283
284         /*
285          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
286          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
287          * together with the image) and board specific EMC DFS table; we will
288          * check the scaling ladder against nominal core voltage when the table
289          * is loaded (and if on particular board the table is not loaded, EMC
290          * scaling is disabled).
291          */
292         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
293                 return false;
294
295         /*
296          * Don't update shared cbus, and don't propagate common cbus dvfs
297          * limit down to shared users, but set maximum rate for each user
298          * equal to the respective client limit.
299          */
300         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
301                 struct clk *user;
302                 unsigned long rate;
303
304                 list_for_each_entry(
305                         user, &c->shared_bus_list, u.shared_bus_user.node) {
306                         if (user->u.shared_bus_user.client) {
307                                 rate = user->u.shared_bus_user.client->max_rate;
308                                 user->max_rate = rate;
309                                 user->u.shared_bus_user.rate = rate;
310                         }
311                 }
312                 return false;
313         }
314
315         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
316         return true;
317 }
318
319 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
320 {
321         int ret;
322         struct clk *c = tegra_get_clock_by_name(d->clk_name);
323
324         if (!c) {
325                 pr_debug("tegra11_dvfs: no clock found for %s\n",
326                         d->clk_name);
327                 return;
328         }
329
330         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
331         if (can_update_max_rate(c, d)) {
332                 BUG_ON(!d->freqs[max_freq_index]);
333                 tegra_init_max_rate(
334                         c, d->freqs[max_freq_index] * d->freqs_mult);
335         }
336         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
337
338         ret = tegra_enable_dvfs_on_clk(c, d);
339         if (ret)
340                 pr_err("tegra11_dvfs: failed to enable dvfs on %s\n", c->name);
341 }
342
343 static bool __init match_dvfs_one(struct dvfs *d, int speedo_id, int process_id)
344 {
345         if ((d->process_id != -1 && d->process_id != process_id) ||
346                 (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
347                 pr_debug("tegra11_dvfs: rejected %s speedo %d,"
348                         " process %d\n", d->clk_name, d->speedo_id,
349                         d->process_id);
350                 return false;
351         }
352         return true;
353 }
354
355
356 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
357 static inline int get_cvb_voltage(int speedo, int s_scale,
358                                   struct cpu_cvb_dvfs_parameters *cvb)
359 {
360         /* apply only speedo scale: output mv = cvb_mv * v_scale */
361         int mv;
362         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
363         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
364         return mv;
365 }
366
367 static inline int round_cvb_voltage(int mv, int v_scale)
368 {
369         /* combined: apply voltage scale and round to cvb alignment step */
370         int cvb_align_step_uv = tegra_get_cvb_alignment_uV();
371
372         return DIV_ROUND_UP(mv * 1000, v_scale * cvb_align_step_uv) *
373                 cvb_align_step_uv / 1000;
374 }
375
376 static int __init set_cpu_dvfs_data(int speedo_id, struct dvfs *cpu_dvfs,
377                                     int *max_freq_index)
378 {
379         int i, j, mv, dfll_mv;
380         unsigned long fmax_at_vmin = 0;
381         unsigned long fmax_pll_mode = 0;
382         unsigned long fmin_use_dfll = 0;
383         struct cpu_cvb_dvfs *d = NULL;
384         struct cpu_cvb_dvfs_table *table = NULL;
385         int speedo = tegra_cpu_speedo_value();
386
387         /* Find matching cvb dvfs entry */
388         for (i = 0; i < ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
389                 d = &cpu_cvb_dvfs_table[i];
390                 if (speedo_id == d->speedo_id)
391                         break;
392         }
393
394         if (!d) {
395                 pr_err("tegra11_dvfs: no cpu dvfs table for speedo_id %d\n",
396                        speedo_id);
397                 return -ENOENT;
398         }
399         BUG_ON(d->min_dfll_mv < tegra11_dvfs_rail_vdd_cpu.min_millivolts);
400
401         /*
402          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
403          * CVB entry specifies CPU frequency and CVB coefficients to calculate
404          * the respective voltage when either DFLL or PLL is used as CPU clock
405          * source.
406          *
407          * Minimum voltage limit is applied only to DFLL source. For PLL source
408          * voltage can go as low as table specifies. Maximum voltage limit is
409          * applied to both sources, but differently: directly clip voltage for
410          * DFLL, and limit maximum frequency for PLL.
411          */
412         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
413                 table = &d->cvb_table[i];
414                 if (!table->freq)
415                         break;
416
417                 dfll_mv = get_cvb_voltage(
418                         speedo, d->speedo_scale, &table->cvb_dfll_param);
419                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale);
420
421                 mv = get_cvb_voltage(
422                         speedo, d->speedo_scale, &table->cvb_pll_param);
423                 mv = round_cvb_voltage(mv, d->voltage_scale);
424
425                 /* Check maximum frequency at minimum voltage for dfll source */
426                 dfll_mv = max(dfll_mv, d->min_dfll_mv);
427                 if (dfll_mv > d->min_dfll_mv) {
428                         if (!j)
429                                 break;  /* 1st entry already above Vmin */
430                         if (!fmax_at_vmin)
431                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
432                 }
433
434                 /* Clip maximum frequency at maximum voltage for pll source */
435                 if (mv > d->max_mv) {
436                         if (!j)
437                                 break;  /* 1st entry already above Vmax */
438                         if (!fmax_pll_mode)
439                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
440                 }
441
442                 /* Minimum rate with pll source voltage above dfll Vmin */
443                 if ((mv >= d->min_dfll_mv) && (!fmin_use_dfll))
444                         fmin_use_dfll = table->freq;
445
446                 /* fill in dvfs tables */
447                 cpu_dvfs->freqs[j] = table->freq;
448                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
449                 cpu_millivolts[j] = mv;
450                 j++;
451
452                 /*
453                  * "Round-up" frequency list cut-off (keep first entry that
454                  *  exceeds max voltage - the voltage limit will be enforced
455                  *  anyway, so when requested this frequency dfll will settle
456                  *  at whatever high frequency it can on the particular chip)
457                  */
458                 if (dfll_mv > d->max_mv)
459                         break;
460         }
461         /* Table must not be empty and must have and at least one entry below,
462            and one entry above Vmin */
463         if (!i || !j || !fmax_at_vmin) {
464                 pr_err("tegra11_dvfs: invalid cpu dvfs table for speedo_id %d\n",
465                        speedo_id);
466                 return -ENOENT;
467         }
468
469         /* In the dfll operating range dfll voltage at any rate should be
470            better (below) than pll voltage */
471         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
472                 WARN(1, "tegra11_dvfs: pll voltage is below dfll in the dfll"
473                         " operating range\n");
474                 fmin_use_dfll = fmax_at_vmin;
475         }
476
477         /* dvfs tables are successfully populated - fill in the rest */
478         cpu_dvfs->speedo_id = speedo_id;
479         cpu_dvfs->freqs_mult = d->freqs_mult;
480         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
481                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
482         *max_freq_index = j - 1;
483
484         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
485                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
486         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
487         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
488         cpu_dvfs->dfll_data.min_millivolts = d->min_dfll_mv;
489         return 0;
490 }
491
492 static int __init get_core_nominal_mv_index(int speedo_id)
493 {
494         int i;
495         int mv = tegra_core_speedo_mv();
496         int core_edp_limit = get_core_edp();
497
498         /*
499          * Start with nominal level for the chips with this speedo_id. Then,
500          * make sure core nominal voltage is below edp limit for the board
501          * (if edp limit is set).
502          */
503         if (core_edp_limit)
504                 mv = min(mv, core_edp_limit);
505
506         /* Round nominal level down to the nearest core scaling step */
507         for (i = 0; i < MAX_DVFS_FREQS; i++) {
508                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
509                         break;
510         }
511
512         if (i == 0) {
513                 pr_err("tegra11_dvfs: unable to adjust core dvfs table to"
514                        " nominal voltage %d\n", mv);
515                 return -ENOSYS;
516         }
517         return i - 1;
518 }
519
520 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
521                          bool before_clk_update, int cpu_event)
522 {
523         /* empty definition for tegra11 */
524         return 0;
525 }
526
527 void __init tegra11x_init_dvfs(void)
528 {
529         int cpu_speedo_id = tegra_cpu_speedo_id();
530         int soc_speedo_id = tegra_soc_speedo_id();
531         int core_process_id = tegra_core_process_id();
532
533         int i;
534         int core_nominal_mv_index;
535         int cpu_max_freq_index;
536
537 #ifndef CONFIG_TEGRA_CORE_DVFS
538         tegra_dvfs_core_disabled = true;
539 #endif
540 #ifndef CONFIG_TEGRA_CPU_DVFS
541         tegra_dvfs_cpu_disabled = true;
542 #endif
543         /* Setup rail bins */
544         tegra11_dvfs_rail_vdd_cpu.stats.bin_uV = tegra_get_cvb_alignment_uV();
545         tegra11_dvfs_rail_vdd_core.stats.bin_uV = tegra_get_cvb_alignment_uV();
546
547         /*
548          * Find nominal voltages for core (1st) and cpu rails before rail
549          * init. Nominal voltage index in core scaling ladder can also be
550          * used to determine max dvfs frequencies for all core clocks. In
551          * case of error disable core scaling and set index to 0, so that
552          * core clocks would not exceed rates allowed at minimum voltage.
553          */
554         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
555         if (core_nominal_mv_index < 0) {
556                 tegra11_dvfs_rail_vdd_core.disabled = true;
557                 tegra_dvfs_core_disabled = true;
558                 core_nominal_mv_index = 0;
559         }
560         tegra11_dvfs_rail_vdd_core.nominal_millivolts =
561                 core_millivolts[core_nominal_mv_index];
562
563         /*
564          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
565          * voltage for cpu rail, and cpu maximum frequency. Note that entire
566          * frequency range is guaranteed only when dfll is used as cpu clock
567          * source. Reaching maximum frequency with pll as cpu clock source
568          * may not be possible within nominal voltage range (dvfs mechanism
569          * would automatically fail frequency request in this case, so that
570          * voltage limit is not violated). Error when cpu dvfs table can not
571          * be constructed must never happen.
572          */
573         if (set_cpu_dvfs_data(cpu_speedo_id, &cpu_dvfs, &cpu_max_freq_index))
574                 BUG();
575
576         /* Init rail structures and dependencies */
577         tegra_dvfs_init_rails(tegra11_dvfs_rails,
578                 ARRAY_SIZE(tegra11_dvfs_rails));
579
580         /* Search core dvfs table for speedo/process matching entries and
581            initialize dvfs-ed clocks */
582         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
583                 struct dvfs *d = &core_dvfs_table[i];
584                 if (!match_dvfs_one(d, soc_speedo_id, core_process_id))
585                         continue;
586                 init_dvfs_one(d, core_nominal_mv_index);
587         }
588
589         /* Initialize matching cpu dvfs entry already found when nominal
590            voltage was determined */
591         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
592
593         /* Finally disable dvfs on rails if necessary */
594         if (tegra_dvfs_core_disabled)
595                 tegra_dvfs_rail_disable(&tegra11_dvfs_rail_vdd_core);
596         if (tegra_dvfs_cpu_disabled)
597                 tegra_dvfs_rail_disable(&tegra11_dvfs_rail_vdd_cpu);
598
599         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
600                 tegra11_dvfs_rail_vdd_cpu.nominal_millivolts,
601                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
602         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
603                 tegra11_dvfs_rail_vdd_core.nominal_millivolts,
604                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
605 }
606
607 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
608 {
609         return 0;
610 }
611
612 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
613 {
614         return 0;
615 }
616
617 /*
618  * sysfs and dvfs interfaces to cap tegra core domains frequencies
619  */
620 static DEFINE_MUTEX(core_cap_lock);
621
622 struct core_cap {
623         int refcnt;
624         int level;
625 };
626 static struct core_cap core_buses_cap;
627 static struct core_cap kdvfs_core_cap;
628 static struct core_cap user_core_cap;
629
630 static struct kobject *cap_kobj;
631
632 /* Arranged in order required for enabling/lowering the cap */
633 static struct {
634         const char *cap_name;
635         struct clk *cap_clk;
636         unsigned long freqs[MAX_DVFS_FREQS];
637 } core_cap_table[] = {
638 #ifdef CONFIG_TEGRA_DUAL_CBUS
639         { .cap_name = "cap.c2bus" },
640         { .cap_name = "cap.c3bus" },
641 #else
642         { .cap_name = "cap.cbus" },
643 #endif
644         { .cap_name = "cap.sclk" },
645         { .cap_name = "cap.emc" },
646 };
647
648
649 static void core_cap_level_set(int level)
650 {
651         int i, j;
652
653         for (j = 0; j < ARRAY_SIZE(core_millivolts); j++) {
654                 int v = core_millivolts[j];
655                 if ((v == 0) || (level < v))
656                         break;
657         }
658         j = (j == 0) ? 0 : j - 1;
659         level = core_millivolts[j];
660
661         if (level < core_buses_cap.level) {
662                 for (i = 0; i < ARRAY_SIZE(core_cap_table); i++)
663                         if (core_cap_table[i].cap_clk)
664                                 clk_set_rate(core_cap_table[i].cap_clk,
665                                              core_cap_table[i].freqs[j]);
666         } else if (level > core_buses_cap.level) {
667                 for (i = ARRAY_SIZE(core_cap_table) - 1; i >= 0; i--)
668                         if (core_cap_table[i].cap_clk)
669                                 clk_set_rate(core_cap_table[i].cap_clk,
670                                              core_cap_table[i].freqs[j]);
671         }
672         core_buses_cap.level = level;
673 }
674
675 static void core_cap_update(void)
676 {
677         int new_level = tegra11_dvfs_rail_vdd_core.max_millivolts;
678
679         if (kdvfs_core_cap.refcnt)
680                 new_level = min(new_level, kdvfs_core_cap.level);
681         if (user_core_cap.refcnt)
682                 new_level = min(new_level, user_core_cap.level);
683
684         if (core_buses_cap.level != new_level)
685                 core_cap_level_set(new_level);
686 }
687
688 static void core_cap_enable(bool enable)
689 {
690         if (enable)
691                 core_buses_cap.refcnt++;
692         else if (core_buses_cap.refcnt)
693                 core_buses_cap.refcnt--;
694
695         core_cap_update();
696 }
697
698 static ssize_t
699 core_cap_state_show(struct kobject *kobj, struct kobj_attribute *attr,
700                     char *buf)
701 {
702         return sprintf(buf, "%d (%d)\n", core_buses_cap.refcnt ? 1 : 0,
703                         user_core_cap.refcnt ? 1 : 0);
704 }
705 static ssize_t
706 core_cap_state_store(struct kobject *kobj, struct kobj_attribute *attr,
707                      const char *buf, size_t count)
708 {
709         int state;
710
711         if (sscanf(buf, "%d", &state) != 1)
712                 return -1;
713
714         mutex_lock(&core_cap_lock);
715
716         if (state) {
717                 user_core_cap.refcnt++;
718                 if (user_core_cap.refcnt == 1)
719                         core_cap_enable(true);
720         } else if (user_core_cap.refcnt) {
721                 user_core_cap.refcnt--;
722                 if (user_core_cap.refcnt == 0)
723                         core_cap_enable(false);
724         }
725
726         mutex_unlock(&core_cap_lock);
727         return count;
728 }
729
730 static ssize_t
731 core_cap_level_show(struct kobject *kobj, struct kobj_attribute *attr,
732                     char *buf)
733 {
734         return sprintf(buf, "%d (%d)\n", core_buses_cap.level,
735                         user_core_cap.level);
736 }
737 static ssize_t
738 core_cap_level_store(struct kobject *kobj, struct kobj_attribute *attr,
739                      const char *buf, size_t count)
740 {
741         int level;
742
743         if (sscanf(buf, "%d", &level) != 1)
744                 return -1;
745
746         mutex_lock(&core_cap_lock);
747         user_core_cap.level = level;
748         core_cap_update();
749         mutex_unlock(&core_cap_lock);
750         return count;
751 }
752
753 static struct kobj_attribute cap_state_attribute =
754         __ATTR(core_cap_state, 0644, core_cap_state_show, core_cap_state_store);
755 static struct kobj_attribute cap_level_attribute =
756         __ATTR(core_cap_level, 0644, core_cap_level_show, core_cap_level_store);
757
758 const struct attribute *cap_attributes[] = {
759         &cap_state_attribute.attr,
760         &cap_level_attribute.attr,
761         NULL,
762 };
763
764 void tegra_dvfs_core_cap_enable(bool enable)
765 {
766         mutex_lock(&core_cap_lock);
767
768         if (enable) {
769                 kdvfs_core_cap.refcnt++;
770                 if (kdvfs_core_cap.refcnt == 1)
771                         core_cap_enable(true);
772         } else if (kdvfs_core_cap.refcnt) {
773                 kdvfs_core_cap.refcnt--;
774                 if (kdvfs_core_cap.refcnt == 0)
775                         core_cap_enable(false);
776         }
777         mutex_unlock(&core_cap_lock);
778 }
779
780 void tegra_dvfs_core_cap_level_set(int level)
781 {
782         mutex_lock(&core_cap_lock);
783         kdvfs_core_cap.level = level;
784         core_cap_update();
785         mutex_unlock(&core_cap_lock);
786 }
787
788 static int __init init_core_cap_one(struct clk *c, unsigned long *freqs)
789 {
790         int i, v, next_v = 0;
791         unsigned long rate, next_rate = 0;
792
793         for (i = 0; i < ARRAY_SIZE(core_millivolts); i++) {
794                 v = core_millivolts[i];
795                 if (v == 0)
796                         break;
797
798                 for (;;) {
799                         rate = next_rate;
800                         next_rate = clk_round_rate(c->parent, rate + 1000);
801                         if (IS_ERR_VALUE(next_rate)) {
802                                 pr_debug("tegra11_dvfs: failed to round %s rate %lu\n",
803                                          c->name, rate);
804                                 return -EINVAL;
805                         }
806                         if (rate == next_rate)
807                                 break;
808
809                         next_v = tegra_dvfs_predict_millivolts(
810                                 c->parent, next_rate);
811                         if (IS_ERR_VALUE(next_v)) {
812                                 pr_debug("tegra11_dvfs: failed to predict %s mV for rate %lu\n",
813                                          c->name, next_rate);
814                                 return -EINVAL;
815                         }
816                         if (next_v > v)
817                                 break;
818                 }
819
820                 if (rate == 0) {
821                         rate = next_rate;
822                         pr_warn("tegra11_dvfs: minimum %s rate %lu requires %d mV\n",
823                                 c->name, rate, next_v);
824                 }
825                 freqs[i] = rate;
826                 next_rate = rate;
827         }
828         return 0;
829 }
830
831 static int __init tegra_dvfs_init_core_cap(void)
832 {
833         int i;
834         struct clk *c = NULL;
835
836         core_buses_cap.level = kdvfs_core_cap.level = user_core_cap.level =
837                 tegra11_dvfs_rail_vdd_core.max_millivolts;
838
839         for (i = 0; i < ARRAY_SIZE(core_cap_table); i++) {
840                 c = tegra_get_clock_by_name(core_cap_table[i].cap_name);
841                 if (!c || !c->parent ||
842                     init_core_cap_one(c, core_cap_table[i].freqs)) {
843                         pr_err("tegra11_dvfs: failed to initialize %s table\n",
844                                core_cap_table[i].cap_name);
845                         continue;
846                 }
847                 core_cap_table[i].cap_clk = c;
848         }
849
850         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
851         if (!cap_kobj) {
852                 pr_err("tegra11_dvfs: failed to create sysfs cap object\n");
853                 return 0;
854         }
855
856         if (sysfs_create_files(cap_kobj, cap_attributes)) {
857                 pr_err("tegra11_dvfs: failed to create sysfs cap interface\n");
858                 return 0;
859         }
860         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
861
862         return 0;
863 }
864 late_initcall(tegra_dvfs_init_core_cap);