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