ARM: tegra12: dvfs: Update XUSB clocks dvfs table
[linux-3.10.git] / arch / arm / mach-tegra / tegra12_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra12_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 static bool tegra_dvfs_gpu_disabled;
34 static struct dvfs *gpu_dvfs;
35
36 /* TBD: fill in actual hw numbers */
37 static const int gpu_millivolts[MAX_DVFS_FREQS] = {
38         850,  900,  950, 1000, 1050, 1100, 1150, 1200, 1250};
39
40 #define KHZ 1000
41 #define MHZ 1000000
42
43 /* FIXME: need tegra12 step */
44 #define VDD_SAFE_STEP                   100
45
46 static struct dvfs_rail tegra12_dvfs_rail_vdd_cpu = {
47         .reg_id = "vdd_cpu",
48         .max_millivolts = 1400,
49         .min_millivolts = 800,
50         .step = VDD_SAFE_STEP,
51         .jmp_to_zero = true,
52 };
53
54 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
55         .reg_id = "vdd_core",
56         .max_millivolts = 1400,
57         .min_millivolts = 800,
58         .step = VDD_SAFE_STEP,
59 };
60
61 /* TBD: fill in actual hw number */
62 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
63         .reg_id = "vdd_gpu",
64         .max_millivolts = 1350,
65         .min_millivolts = 850,
66         .step = VDD_SAFE_STEP,
67 };
68
69 static struct dvfs_rail *tegra12_dvfs_rails[] = {
70         &tegra12_dvfs_rail_vdd_cpu,
71         &tegra12_dvfs_rail_vdd_core,
72         &tegra12_dvfs_rail_vdd_gpu,
73 };
74
75 /* default cvb alignment on Tegra11 - 10mV */
76 int __attribute__((weak)) tegra_get_cvb_alignment_uV(void)
77 {
78         return 10000;
79 }
80
81 /* CPU DVFS tables */
82 /* FIXME: real data */
83 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
84         {
85                 .speedo_id = 0,
86                 .max_mv = 1250,
87                 .min_mv = 850,
88                 .margin = 112,
89                 .freqs_mult = MHZ,
90                 .speedo_scale = 100,
91                 .voltage_scale = 100,
92                 .cvb_table = {
93                         /*f      c0,    c1,    c2 */
94                         { 306,  9251,  12837, -570},
95                         { 408,  11737, 12957, -570},
96                         { 510,  14282, 13076, -570},
97                         { 612,  16887, 13196, -570},
98                         { 714,  19552, 13315, -570},
99                         { 816,  22277, 13435, -570},
100                         { 918,  25061, 13554, -570},
101                         {1020,  27905, 13674, -570},
102                         {1122,  30809, 13793, -570},
103                         {1224,  33773, 13913, -570},
104                         {1326,  36797, 14032, -570},
105                         {1428,  39880, 14152, -570},
106                         {1530,  43023, 14271, -570},
107                         {1632,  46226, 14391, -570},
108                         {   0,      0,     0,    0},
109                 },
110         }
111 };
112
113 static int cpu_millivolts[MAX_DVFS_FREQS];
114 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
115
116 static struct dvfs cpu_dvfs = {
117         .clk_name       = "cpu_g",
118         .process_id     = -1,
119         .millivolts     = cpu_millivolts,
120         .dfll_millivolts = cpu_dfll_millivolts,
121         .auto_dvfs      = true,
122         .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,
123 };
124
125 static struct tegra_cl_dvfs_dfll_data cpu_dfll_data = {
126                 .dfll_clk_name  = "dfll_cpu",
127                 .tune0          = 0x000B0380,
128                 .tune1          = 0x000005e0,
129                 .droop_rate_min = 1000000,
130 };
131
132 /* Core DVFS tables */
133 /* FIXME: real data */
134 static const int core_millivolts[MAX_DVFS_FREQS] = {
135         837,  900,  950, 1000, 1050, 1100, 1125};
136
137 #define CORE_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)       \
138         {                                                       \
139                 .clk_name       = _clk_name,                    \
140                 .speedo_id      = _speedo_id,                   \
141                 .process_id     = -1,                           \
142                 .freqs          = {_freqs},                     \
143                 .freqs_mult     = _mult,                        \
144                 .millivolts     = core_millivolts,              \
145                 .auto_dvfs      = _auto,                        \
146                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
147         }
148
149 static struct dvfs core_dvfs_table[] = {
150         /* Core voltages (mV):              837,    900,    950,   1000,   1050,    1100,    1125, */
151         /* Clock limits for internal blocks, PLLs */
152 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
153         CORE_DVFS("cpu_lp", -1, 1, KHZ,       1, 144000, 252000, 288000, 372000,  468000,  468000),
154         CORE_DVFS("emc",   -1, 1, KHZ,        1, 264000, 348000, 384000, 528000,  666000,  666000),
155         CORE_DVFS("sbus",  -1, 1, KHZ,        1,  81600, 102000, 136000, 204000,  204000,  204000),
156
157         CORE_DVFS("vi",    -1, 1, KHZ,        1, 102000, 144000, 144000, 192000,  240000,  240000),
158
159         CORE_DVFS("2d",    -1, 1, KHZ,        1, 132000, 180000, 204000, 264000,  336000,  336000),
160         CORE_DVFS("3d",    -1, 1, KHZ,        1, 132000, 180000, 204000, 264000,  336000,  336000),
161
162         CORE_DVFS("epp",   -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
163         CORE_DVFS("msenc", -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
164         CORE_DVFS("se",    -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
165         CORE_DVFS("tsec",  -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
166         CORE_DVFS("vde",   -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
167
168         CORE_DVFS("host1x", -1, 1, KHZ,       1,  81600, 102000, 136000, 163200,  204000,  204000),
169
170 #ifdef CONFIG_TEGRA_DUAL_CBUS
171         CORE_DVFS("c2bus", -1, 1, KHZ,        1, 132000, 180000, 204000, 264000,  336000,  336000),
172         CORE_DVFS("c3bus", -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
173 #else
174         CORE_DVFS("cbus",  -1, 1, KHZ,        1, 120000, 144000, 168000, 216000,  276000,  276000),
175 #endif
176
177         CORE_DVFS("pll_m", -1, 1, KHZ,        1, 480000, 588000, 660000, 792000,  936000,  936000),
178         CORE_DVFS("pll_c", -1, 1, KHZ,        1, 480000, 588000, 660000, 792000,  936000,  936000),
179         CORE_DVFS("pll_c2", -1, 1, KHZ,       1, 480000, 588000, 660000, 792000,  936000,  936000),
180         CORE_DVFS("pll_c3", -1, 1, KHZ,       1, 480000, 588000, 660000, 792000,  936000,  936000),
181         CORE_DVFS("pll_d_out0", -1, 1, KHZ,   1, 480000, 588000, 660000, 792000,  936000,  936000),
182         CORE_DVFS("pll_d2_out0", -1, 1, KHZ,  1, 480000, 588000, 660000, 792000,  936000,  936000),
183         CORE_DVFS("pll_re_out", -1, 1, KHZ,   1, 480000, 588000, 660000, 792000,  936000,  936000),
184
185         /* Core voltages (mV):              837,    900,    950,   1000,   1050,    1100,    1125, */
186         /* Clock limits for I/O peripherals */
187         CORE_DVFS("i2c1", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
188         CORE_DVFS("i2c2", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
189         CORE_DVFS("i2c3", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
190         CORE_DVFS("i2c4", -1, 1, KHZ,         1,  58300,  68000,  81600, 102000,  136000,  136000),
191
192         CORE_DVFS("sbc1", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
193         CORE_DVFS("sbc2", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
194         CORE_DVFS("sbc3", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
195         CORE_DVFS("sbc4", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
196         CORE_DVFS("sbc5", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
197         CORE_DVFS("sbc6", -1, 1, KHZ,         1,  24000,  24000,  48000,  48000,   48000,   48000),
198
199         /* FIXME: re-enable after UART hs driver is updated */
200 #if 0
201         CORE_DVFS("uarta", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
202         CORE_DVFS("uartb", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
203         CORE_DVFS("uartc", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
204         CORE_DVFS("uartd", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
205         CORE_DVFS("uarte", -1, 1, KHZ,        1,  58300,  58300, 102000, 102000,  102000,  102000),
206 #endif
207         CORE_DVFS("sdmmc1", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
208         CORE_DVFS("sdmmc2", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
209         CORE_DVFS("sdmmc3", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
210         CORE_DVFS("sdmmc4", -1, 1, KHZ,       1, 102000, 102000, 163200, 163200,  163200,  163200),
211
212         CORE_DVFS("pwm",  -1, 1, KHZ,         1,  40800,  48000,  48000,  48000,   48000,   48000),
213
214         CORE_DVFS("csi",  -1, 1, KHZ,         1,      1,      1, 102000, 102000,  102000,  102000),
215         CORE_DVFS("dsia", -1, 1, KHZ,         1, 100000, 125000, 125000, 125000,  125000,  125000),
216         CORE_DVFS("dsib", -1, 1, KHZ,         1, 100000, 125000, 125000, 125000,  125000,  125000),
217         CORE_DVFS("dsialp", -1, 1, KHZ,       1, 102000, 102000, 102000, 102000,  156000,  156000),
218         CORE_DVFS("dsiblp", -1, 1, KHZ,       1, 102000, 102000, 102000, 102000,  156000,  156000),
219         CORE_DVFS("hdmi", -1, 1, KHZ,         1,  99000, 118800, 148500, 198000,  198000,  198000),
220
221         /*
222          * The clock rate for the display controllers that determines the
223          * necessary core voltage depends on a divider that is internal
224          * to the display block.  Disable auto-dvfs on the display clocks,
225          * and let the display driver call tegra_dvfs_set_rate manually
226          */
227         CORE_DVFS("disp1", -1, 0, KHZ,         1, 108000, 120000, 144000, 192000,  240000,  240000),
228         CORE_DVFS("disp2", -1, 0, KHZ,         1, 108000, 120000, 144000, 192000,  240000,  240000),
229
230         CORE_DVFS("xusb_falcon_src", -1, 1, KHZ, 1, 204000, 204000, 204000, 336000,  336000,  336000),
231         CORE_DVFS("xusb_host_src",   -1, 1, KHZ, 1,  58300,  58300,  58300, 112000,  112000,  112000),
232         CORE_DVFS("xusb_dev_src",    -1, 1, KHZ, 1,  58300,  58300,  58300, 112000,  112000,  112000),
233         CORE_DVFS("xusb_ss_src",     -1, 1, KHZ, 1,  60000,  60000,  60000, 120000,  120000,  120000),
234         CORE_DVFS("xusb_fs_src",     -1, 1, KHZ, 1,      1,  48000,  48000,  48000,   48000,   48000),
235         CORE_DVFS("xusb_hs_src",     -1, 1, KHZ, 1,      1,  60000,  60000,  60000,   60000,   60000),
236 #endif
237 };
238
239 #define GPU_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)        \
240         {                                                       \
241                 .clk_name       = _clk_name,                    \
242                 .speedo_id      = _speedo_id,                   \
243                 .process_id     = -1,                           \
244                 .freqs          = {_freqs},                     \
245                 .freqs_mult     = _mult,                        \
246                 .millivolts     = gpu_millivolts,               \
247                 .auto_dvfs      = _auto,                        \
248                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,   \
249         }
250
251 /* TBD: fill in actual hw numbers */
252 static struct dvfs gpu_dvfs_table[] = {
253         /* Gpu voltages (mV):               850,    900,    950,   1000,   1050,    1100,    1150,    1200,    1250 */
254         /* Clock limits for internal blocks, PLLs */
255         GPU_DVFS("gpu",     -1, 1, KHZ,    624000, 650000, 676000, 702000, 728000,  754000,  780000,  806000),
256 };
257
258 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
259 {
260         int ret;
261
262         ret = param_set_bool(arg, kp);
263         if (ret)
264                 return ret;
265
266         if (tegra_dvfs_core_disabled)
267                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
268         else
269                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
270
271         return 0;
272 }
273
274 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
275 {
276         int ret;
277
278         ret = param_set_bool(arg, kp);
279         if (ret)
280                 return ret;
281
282         if (tegra_dvfs_cpu_disabled)
283                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
284         else
285                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
286
287         return 0;
288 }
289
290 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
291 {
292         int ret;
293
294         ret = param_set_bool(arg, kp);
295         if (ret)
296                 return ret;
297
298         if (tegra_dvfs_gpu_disabled)
299                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
300         else
301                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
302
303         return 0;
304 }
305
306 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
307 {
308         return param_get_bool(buffer, kp);
309 }
310
311 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
312         .set = tegra_dvfs_disable_core_set,
313         .get = tegra_dvfs_disable_get,
314 };
315
316 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
317         .set = tegra_dvfs_disable_cpu_set,
318         .get = tegra_dvfs_disable_get,
319 };
320
321 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
322         .set = tegra_dvfs_disable_gpu_set,
323         .get = tegra_dvfs_disable_get,
324 };
325
326 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
327         &tegra_dvfs_core_disabled, 0644);
328 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
329         &tegra_dvfs_cpu_disabled, 0644);
330 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
331         &tegra_dvfs_gpu_disabled, 0644);
332
333
334 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
335 {
336         /* Don't update manual dvfs clocks */
337         if (!d->auto_dvfs)
338                 return false;
339
340         /*
341          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
342          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
343          * together with the image) and board specific EMC DFS table; we will
344          * check the scaling ladder against nominal core voltage when the table
345          * is loaded (and if on particular board the table is not loaded, EMC
346          * scaling is disabled).
347          */
348         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
349                 return false;
350
351         /*
352          * Don't update shared cbus, and don't propagate common cbus dvfs
353          * limit down to shared users, but set maximum rate for each user
354          * equal to the respective client limit.
355          */
356         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
357                 struct clk *user;
358                 unsigned long rate;
359
360                 list_for_each_entry(
361                         user, &c->shared_bus_list, u.shared_bus_user.node) {
362                         if (user->u.shared_bus_user.client) {
363                                 rate = user->u.shared_bus_user.client->max_rate;
364                                 user->max_rate = rate;
365                                 user->u.shared_bus_user.rate = rate;
366                         }
367                 }
368                 return false;
369         }
370
371         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
372         return true;
373 }
374
375 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
376 {
377         int ret;
378         struct clk *c = tegra_get_clock_by_name(d->clk_name);
379
380         if (!c) {
381                 pr_debug("tegra12_dvfs: no clock found for %s\n",
382                         d->clk_name);
383                 return;
384         }
385
386         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
387         if (can_update_max_rate(c, d)) {
388                 BUG_ON(!d->freqs[max_freq_index]);
389                 tegra_init_max_rate(
390                         c, d->freqs[max_freq_index] * d->freqs_mult);
391         }
392         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
393
394         ret = tegra_enable_dvfs_on_clk(c, d);
395         if (ret)
396                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
397 }
398
399 static bool __init match_dvfs_one(struct dvfs *d, int speedo_id, int process_id)
400 {
401         if ((d->process_id != -1 && d->process_id != process_id) ||
402                 (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
403                 pr_debug("tegra12_dvfs: rejected %s speedo %d,"
404                         " process %d\n", d->clk_name, d->speedo_id,
405                         d->process_id);
406                 return false;
407         }
408         return true;
409 }
410
411
412 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
413 static inline int get_cvb_voltage(int speedo, int s_scale,
414                                   struct cpu_cvb_dvfs_parameters *cvb)
415 {
416         /* apply only speedo scale: output mv = cvb_mv * v_scale */
417         int mv;
418         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
419         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
420         return mv;
421 }
422
423 static inline int round_cvb_voltage(int mv, int v_scale)
424 {
425         /* combined: apply voltage scale and round to cvb alignment step */
426         int cvb_align_step_uv = tegra_get_cvb_alignment_uV();
427
428         return DIV_ROUND_UP(mv * 1000, v_scale * cvb_align_step_uv) *
429                 cvb_align_step_uv / 1000;
430 }
431
432 static int __init set_cpu_dvfs_data(int speedo_id, struct dvfs *cpu_dvfs,
433         struct tegra_cl_dvfs_dfll_data *dfll_data, int *max_freq_index)
434 {
435         int i, j, mv, dfll_mv;
436         unsigned long fmax_at_vmin = 0;
437         unsigned long fmax_pll_mode = 0;
438         struct cpu_cvb_dvfs *d = NULL;
439         struct cpu_cvb_dvfs_parameters *cvb = NULL;
440         int speedo = tegra_cpu_speedo_value();
441
442         /* Find matching cvb dvfs entry */
443         for (i = 0; i < ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
444                 d = &cpu_cvb_dvfs_table[i];
445                 if (speedo_id == d->speedo_id)
446                         break;
447         }
448
449         if (!d) {
450                 pr_err("tegra12_dvfs: no cpu dvfs table for speedo_id %d\n",
451                        speedo_id);
452                 return -ENOENT;
453         }
454         BUG_ON(d->min_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
455
456         /*
457          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
458          * CVB entry specifies CPU frequency and CVB coefficients to calculate
459          * the respective voltage when DFLL is used as CPU clock source. Common
460          * margin is applied to determine voltage requirements for PLL source.
461          */
462         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
463                 cvb = &d->cvb_table[i];
464                 if (!cvb->freq)
465                         break;
466
467                 mv = get_cvb_voltage(speedo, d->speedo_scale, cvb);
468                 dfll_mv = round_cvb_voltage(mv, d->voltage_scale);
469                 dfll_mv = max(dfll_mv, d->min_mv);
470                 if (dfll_mv > d->max_mv)
471                         break;
472
473                 /* Check maximum frequency at minimum voltage for dfll source */
474                 if (dfll_mv > d->min_mv) {
475                         if (!j)
476                                 break;  /* 1st entry already above Vmin */
477                         if (!fmax_at_vmin)
478                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
479                 }
480
481                 /* Clip maximum frequency at maximum voltage for pll source */
482                 mv = mv * d->margin / 100;
483                 mv = round_cvb_voltage(mv, d->voltage_scale);
484                 if (mv > d->max_mv) {
485                         if (!j)
486                                 break;  /* 1st entry already above Vmax */
487                         if (!fmax_pll_mode)
488                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
489                 }
490
491                 /* dvfs tables with maximum frequency at any distinct voltage */
492                 if (!j || (dfll_mv > cpu_dfll_millivolts[j - 1])) {
493                         cpu_dvfs->freqs[j] = cvb->freq;
494                         cpu_dfll_millivolts[j] = dfll_mv;
495                         j++;
496                 } else {
497                         cpu_dvfs->freqs[j - 1] = cvb->freq;
498                 }
499                 cpu_millivolts[j - 1] = max(mv, d->min_mv);
500         }
501         /* Table must not be empty and must have and at least one entry below,
502            and one entry above Vmin */
503         if (!i || !j || !fmax_at_vmin) {
504                 pr_err("tegra12_dvfs: invalid cpu dvfs table for speedo_id %d\n",
505                        speedo_id);
506                 return -ENOENT;
507         }
508
509         /* dvfs tables are successfully populated - fill in the rest */
510         cpu_dvfs->speedo_id = speedo_id;
511         cpu_dvfs->freqs_mult = d->freqs_mult;
512         cpu_dvfs->dvfs_rail->nominal_millivolts =
513                 min(cpu_millivolts[j - 1], d->max_mv);
514         *max_freq_index = j - 1;
515
516         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
517                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
518
519
520         dfll_data->out_rate_min = fmax_at_vmin * d->freqs_mult;
521         dfll_data->millivolts_min = d->min_mv;
522         return 0;
523 }
524
525 static int __init get_core_nominal_mv_index(int speedo_id)
526 {
527         int i;
528         int mv = tegra_core_speedo_mv();
529         int core_edp_limit = get_core_edp();
530
531         /*
532          * Start with nominal level for the chips with this speedo_id. Then,
533          * make sure core nominal voltage is below edp limit for the board
534          * (if edp limit is set).
535          */
536         if (core_edp_limit)
537                 mv = min(mv, core_edp_limit);
538
539         /* Round nominal level down to the nearest core scaling step */
540         for (i = 0; i < MAX_DVFS_FREQS; i++) {
541                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
542                         break;
543         }
544
545         if (i == 0) {
546                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
547                        " nominal voltage %d\n", mv);
548                 return -ENOSYS;
549         }
550         return i - 1;
551 }
552
553 static int __init get_gpu_nominal_mv_index(
554         int speedo_id, int process_id, struct dvfs **gpu_dvfs)
555 {
556         int i, j, mv;
557         struct dvfs *d;
558         struct clk *c;
559
560         /* TBD: do we have dependency between gpu and core ??
561          * Find maximum gpu voltage that satisfies gpu_to_core dependency for
562          * nominal core voltage ("solve from cpu to core at nominal"). Clip
563          * result to the nominal cpu level for the chips with this speedo_id.
564          */
565         mv = tegra12_dvfs_rail_vdd_core.nominal_millivolts;
566         for (i = 0; i < MAX_DVFS_FREQS; i++) {
567                 if (gpu_millivolts[i] == 0)
568                         break;
569         }
570         BUG_ON(i == 0);
571         mv = gpu_millivolts[i - 1];
572         BUG_ON(mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
573         mv = min(mv, 1250/* TBD: tegra_gpu_speedo_mv() */);
574
575         /*
576          * Find matching gpu dvfs entry, and use it to determine index to the
577          * final nominal voltage, that satisfies the following requirements:
578          * - allows GPU to run at minimum of the maximum rates specified in
579          *   the dvfs entry and clock tree
580          * - does not violate gpu_to_core dependency as determined above
581          */
582         for (i = 0, j = 0; j <  ARRAY_SIZE(gpu_dvfs_table); j++) {
583                 d = &gpu_dvfs_table[j];
584                 if (match_dvfs_one(d, speedo_id, process_id)) {
585                         c = tegra_get_clock_by_name(d->clk_name);
586                         BUG_ON(!c);
587
588                         for (; i < MAX_DVFS_FREQS; i++) {
589                                 if ((d->freqs[i] == 0) ||
590                                     (gpu_millivolts[i] == 0) ||
591                                     (mv < gpu_millivolts[i]))
592                                         break;
593
594                                 if (c->max_rate <= d->freqs[i]*d->freqs_mult) {
595                                         i++;
596                                         break;
597                                 }
598                         }
599                         break;
600                 }
601         }
602
603         BUG_ON(i == 0);
604         if (j == (ARRAY_SIZE(gpu_dvfs_table) - 1))
605                 pr_err("tegra12_dvfs: WARNING!!!\n"
606                        "tegra12_dvfs: no gpu dvfs table found for chip speedo_id"
607                        " %d and process_id %d: set GPU rate limit at %lu\n"
608                        "tegra12_dvfs: WARNING!!!\n",
609                        speedo_id, process_id, d->freqs[i-1] * d->freqs_mult);
610
611         *gpu_dvfs = d;
612         return i - 1;
613 }
614
615 void __init tegra12x_init_dvfs(void)
616 {
617         int cpu_speedo_id = tegra_cpu_speedo_id();
618         int soc_speedo_id = tegra_soc_speedo_id();
619         int gpu_speedo_id = -1; /* TBD: use gpu speedo */
620         int core_process_id = tegra_core_process_id();
621         int gpu_process_id = -1; /* TBD: use gpu process */
622
623         int i;
624         int core_nominal_mv_index;
625         int cpu_max_freq_index;
626         int gpu_nominal_mv_index;
627
628 #ifndef CONFIG_TEGRA_CORE_DVFS
629         tegra_dvfs_core_disabled = true;
630 #endif
631 #ifndef CONFIG_TEGRA_CPU_DVFS
632         tegra_dvfs_cpu_disabled = true;
633 #endif
634 #ifndef CONFIG_TEGRA_GPU_DVFS
635         tegra_dvfs_gpu_disabled = true;
636 #endif
637
638         /*
639          * Find nominal voltages for core (1st) and cpu rails before rail
640          * init. Nominal voltage index in core scaling ladder can also be
641          * used to determine max dvfs frequencies for all core clocks. In
642          * case of error disable core scaling and set index to 0, so that
643          * core clocks would not exceed rates allowed at minimum voltage.
644          */
645         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
646         if (core_nominal_mv_index < 0) {
647                 tegra12_dvfs_rail_vdd_core.disabled = true;
648                 tegra_dvfs_core_disabled = true;
649                 core_nominal_mv_index = 0;
650         }
651         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
652                 core_millivolts[core_nominal_mv_index];
653
654         /*
655          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
656          * voltage for cpu rail, and cpu maximum frequency. Note that entire
657          * frequency range is guaranteed only when dfll is used as cpu clock
658          * source. Reaching maximum frequency with pll as cpu clock source
659          * may not be possible within nominal voltage range (dvfs mechanism
660          * would automatically fail frequency request in this case, so that
661          * voltage limit is not violated). Error when cpu dvfs table can not
662          * be constructed must never happen.
663          */
664         if (set_cpu_dvfs_data(cpu_speedo_id, &cpu_dvfs,
665                               &cpu_dfll_data, &cpu_max_freq_index))
666                 BUG();
667
668         gpu_nominal_mv_index = get_gpu_nominal_mv_index(
669                 gpu_speedo_id, gpu_process_id, &gpu_dvfs);
670         BUG_ON((gpu_nominal_mv_index < 0) || (!gpu_dvfs));
671         tegra12_dvfs_rail_vdd_gpu.nominal_millivolts =
672                 gpu_millivolts[gpu_nominal_mv_index];
673
674         /* Init rail structures and dependencies */
675         tegra_dvfs_init_rails(tegra12_dvfs_rails,
676                 ARRAY_SIZE(tegra12_dvfs_rails));
677
678         /* Search core dvfs table for speedo/process matching entries and
679            initialize dvfs-ed clocks */
680         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
681                 struct dvfs *d = &core_dvfs_table[i];
682                 if (!match_dvfs_one(d, soc_speedo_id, core_process_id))
683                         continue;
684                 init_dvfs_one(d, core_nominal_mv_index);
685         }
686
687         /* Initialize matching cpu dvfs entry already found when nominal
688            voltage was determined */
689         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
690
691         /* CL DVFS characterization data */
692         tegra_cl_dvfs_set_dfll_data(&cpu_dfll_data);
693
694         /* Finally disable dvfs on rails if necessary */
695         if (tegra_dvfs_core_disabled)
696                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
697         if (tegra_dvfs_cpu_disabled)
698                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
699         if (tegra_dvfs_gpu_disabled)
700                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
701
702         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
703                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
704                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
705         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
706                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
707                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
708         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
709                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
710                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
711 }
712
713 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
714 {
715         return 0;
716 }
717
718 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
719 {
720         return 0;
721 }
722
723 /*
724  * sysfs and dvfs interfaces to cap tegra core domains frequencies
725  */
726 static DEFINE_MUTEX(core_cap_lock);
727
728 struct core_cap {
729         int refcnt;
730         int level;
731 };
732 static struct core_cap core_buses_cap;
733 static struct core_cap kdvfs_core_cap;
734 static struct core_cap user_core_cap;
735
736 static struct kobject *cap_kobj;
737
738 /* Arranged in order required for enabling/lowering the cap */
739 static struct {
740         const char *cap_name;
741         struct clk *cap_clk;
742         unsigned long freqs[MAX_DVFS_FREQS];
743 } core_cap_table[] = {
744 #ifdef CONFIG_TEGRA_DUAL_CBUS
745         { .cap_name = "cap.c2bus" },
746         { .cap_name = "cap.c3bus" },
747 #else
748         { .cap_name = "cap.cbus" },
749 #endif
750         { .cap_name = "cap.sclk" },
751         { .cap_name = "cap.emc" },
752 };
753
754
755 static void core_cap_level_set(int level)
756 {
757         int i, j;
758
759         for (j = 0; j < ARRAY_SIZE(core_millivolts); j++) {
760                 int v = core_millivolts[j];
761                 if ((v == 0) || (level < v))
762                         break;
763         }
764         j = (j == 0) ? 0 : j - 1;
765         level = core_millivolts[j];
766
767         if (level < core_buses_cap.level) {
768                 for (i = 0; i < ARRAY_SIZE(core_cap_table); i++)
769                         if (core_cap_table[i].cap_clk)
770                                 clk_set_rate(core_cap_table[i].cap_clk,
771                                              core_cap_table[i].freqs[j]);
772         } else if (level > core_buses_cap.level) {
773                 for (i = ARRAY_SIZE(core_cap_table) - 1; i >= 0; i--)
774                         if (core_cap_table[i].cap_clk)
775                                 clk_set_rate(core_cap_table[i].cap_clk,
776                                              core_cap_table[i].freqs[j]);
777         }
778         core_buses_cap.level = level;
779 }
780
781 static void core_cap_update(void)
782 {
783         int new_level = tegra12_dvfs_rail_vdd_core.max_millivolts;
784
785         if (kdvfs_core_cap.refcnt)
786                 new_level = min(new_level, kdvfs_core_cap.level);
787         if (user_core_cap.refcnt)
788                 new_level = min(new_level, user_core_cap.level);
789
790         if (core_buses_cap.level != new_level)
791                 core_cap_level_set(new_level);
792 }
793
794 static void core_cap_enable(bool enable)
795 {
796         if (enable)
797                 core_buses_cap.refcnt++;
798         else if (core_buses_cap.refcnt)
799                 core_buses_cap.refcnt--;
800
801         core_cap_update();
802 }
803
804 static ssize_t
805 core_cap_state_show(struct kobject *kobj, struct kobj_attribute *attr,
806                     char *buf)
807 {
808         return sprintf(buf, "%d (%d)\n", core_buses_cap.refcnt ? 1 : 0,
809                         user_core_cap.refcnt ? 1 : 0);
810 }
811 static ssize_t
812 core_cap_state_store(struct kobject *kobj, struct kobj_attribute *attr,
813                      const char *buf, size_t count)
814 {
815         int state;
816
817         if (sscanf(buf, "%d", &state) != 1)
818                 return -1;
819
820         mutex_lock(&core_cap_lock);
821
822         if (state) {
823                 user_core_cap.refcnt++;
824                 if (user_core_cap.refcnt == 1)
825                         core_cap_enable(true);
826         } else if (user_core_cap.refcnt) {
827                 user_core_cap.refcnt--;
828                 if (user_core_cap.refcnt == 0)
829                         core_cap_enable(false);
830         }
831
832         mutex_unlock(&core_cap_lock);
833         return count;
834 }
835
836 static ssize_t
837 core_cap_level_show(struct kobject *kobj, struct kobj_attribute *attr,
838                     char *buf)
839 {
840         return sprintf(buf, "%d (%d)\n", core_buses_cap.level,
841                         user_core_cap.level);
842 }
843 static ssize_t
844 core_cap_level_store(struct kobject *kobj, struct kobj_attribute *attr,
845                      const char *buf, size_t count)
846 {
847         int level;
848
849         if (sscanf(buf, "%d", &level) != 1)
850                 return -1;
851
852         mutex_lock(&core_cap_lock);
853         user_core_cap.level = level;
854         core_cap_update();
855         mutex_unlock(&core_cap_lock);
856         return count;
857 }
858
859 static struct kobj_attribute cap_state_attribute =
860         __ATTR(core_cap_state, 0644, core_cap_state_show, core_cap_state_store);
861 static struct kobj_attribute cap_level_attribute =
862         __ATTR(core_cap_level, 0644, core_cap_level_show, core_cap_level_store);
863
864 const struct attribute *cap_attributes[] = {
865         &cap_state_attribute.attr,
866         &cap_level_attribute.attr,
867         NULL,
868 };
869
870 void tegra_dvfs_core_cap_enable(bool enable)
871 {
872         mutex_lock(&core_cap_lock);
873
874         if (enable) {
875                 kdvfs_core_cap.refcnt++;
876                 if (kdvfs_core_cap.refcnt == 1)
877                         core_cap_enable(true);
878         } else if (kdvfs_core_cap.refcnt) {
879                 kdvfs_core_cap.refcnt--;
880                 if (kdvfs_core_cap.refcnt == 0)
881                         core_cap_enable(false);
882         }
883         mutex_unlock(&core_cap_lock);
884 }
885
886 void tegra_dvfs_core_cap_level_set(int level)
887 {
888         mutex_lock(&core_cap_lock);
889         kdvfs_core_cap.level = level;
890         core_cap_update();
891         mutex_unlock(&core_cap_lock);
892 }
893
894 static int __init init_core_cap_one(struct clk *c, unsigned long *freqs)
895 {
896         int i, v, next_v = 0;
897         unsigned long rate, next_rate = 0;
898
899         for (i = 0; i < ARRAY_SIZE(core_millivolts); i++) {
900                 v = core_millivolts[i];
901                 if (v == 0)
902                         break;
903
904                 for (;;) {
905                         rate = next_rate;
906                         next_rate = clk_round_rate(c->parent, rate + 1000);
907                         if (IS_ERR_VALUE(next_rate)) {
908                                 pr_debug("tegra12_dvfs: failed to round %s rate %lu\n",
909                                          c->name, rate);
910                                 return -EINVAL;
911                         }
912                         if (rate == next_rate)
913                                 break;
914
915                         next_v = tegra_dvfs_predict_millivolts(
916                                 c->parent, next_rate);
917                         if (IS_ERR_VALUE(next_v)) {
918                                 pr_debug("tegra12_dvfs: failed to predict %s mV for rate %lu\n",
919                                          c->name, next_rate);
920                                 return -EINVAL;
921                         }
922                         if (next_v > v)
923                                 break;
924                 }
925
926                 if (rate == 0) {
927                         rate = next_rate;
928                         pr_warn("tegra12_dvfs: minimum %s rate %lu requires %d mV\n",
929                                 c->name, rate, next_v);
930                 }
931                 freqs[i] = rate;
932                 next_rate = rate;
933         }
934         return 0;
935 }
936
937 static int __init tegra_dvfs_init_core_cap(void)
938 {
939         int i;
940         struct clk *c = NULL;
941
942         core_buses_cap.level = kdvfs_core_cap.level = user_core_cap.level =
943                 tegra12_dvfs_rail_vdd_core.max_millivolts;
944
945         for (i = 0; i < ARRAY_SIZE(core_cap_table); i++) {
946                 c = tegra_get_clock_by_name(core_cap_table[i].cap_name);
947                 if (!c || !c->parent ||
948                     init_core_cap_one(c, core_cap_table[i].freqs)) {
949                         pr_err("tegra12_dvfs: failed to initialize %s table\n",
950                                core_cap_table[i].cap_name);
951                         continue;
952                 }
953                 core_cap_table[i].cap_clk = c;
954         }
955
956         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
957         if (!cap_kobj) {
958                 pr_err("tegra12_dvfs: failed to create sysfs cap object\n");
959                 return 0;
960         }
961
962         if (sysfs_create_files(cap_kobj, cap_attributes)) {
963                 pr_err("tegra12_dvfs: failed to create sysfs cap interface\n");
964                 return 0;
965         }
966         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
967
968         return 0;
969 }
970 late_initcall(tegra_dvfs_init_core_cap);