arm: tegra12: clock: bring up to tegra11 level
[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 = 1250,
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 = 1350,
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 /* CPU DVFS tables */
76 /* FIXME: real data */
77 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
78         {
79                 .speedo_id = 0,
80                 .min_mv = 850,
81                 .margin = 103,
82                 .cvb_table = {
83                         /*f      c0,   c1,   c2 */
84                         { 306,  800,    0,    0},
85                         { 408,  812,    0,    0},
86                         { 510,  825,    0,    0},
87                         { 612,  850,    0,    0},
88                         { 714,  850,    0,    0},
89                         { 816,  858,    0,    0},
90                         { 918,  900,    0,    0},
91                         {1020,  912,    0,    0},
92                         {1122,  937,    0,    0},
93                         {1224,  937,    0,    0},
94                         {1326,  975,    0,    0},
95                         {1428, 1000,    0,    0},
96                         {1530, 1000,    0,    0},
97                         {1632, 1100,    0,    0},
98                         {1734, 1150,    0,    0},
99                         {1836, 1200,    0,    0},
100                         {   0,    0,    0,    0},
101                 },
102         }
103 };
104
105 /* FIXME: remove */
106 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
107 #define CPU_AUTO true
108 #else
109 #define CPU_AUTO false
110 #endif
111
112 static int cpu_millivolts[MAX_DVFS_FREQS];
113 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
114
115 static struct dvfs cpu_dvfs = {
116         .clk_name       = "cpu_g",
117         .process_id     = -1,
118         .freqs_mult     = MHZ,
119         .millivolts     = cpu_millivolts,
120         .dfll_millivolts = cpu_dfll_millivolts,
121         .auto_dvfs      = CPU_AUTO,
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          = 0x030201,
128                 .tune1          = 0x000BB0AA,
129                 .droop_rate_min = 640000000,
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, 163000,  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         CORE_DVFS("sdmmc1", -1, 1, KHZ,       1, 102000, 102000, 163000, 163000,  163000,  163000),
200         CORE_DVFS("sdmmc2", -1, 1, KHZ,       1, 102000, 102000, 163000, 163000,  163000,  163000),
201         CORE_DVFS("sdmmc3", -1, 1, KHZ,       1, 102000, 102000, 163000, 163000,  163000,  163000),
202         CORE_DVFS("sdmmc4", -1, 1, KHZ,       1, 102000, 102000, 163000, 163000,  163000,  163000),
203
204         CORE_DVFS("pwm",  -1, 1, KHZ,         1,  40800,  48000,  48000,  48000,   48000,   48000),
205
206         CORE_DVFS("csi",  -1, 1, KHZ,         1,      1,      1, 102000, 102000,  102000,  102000),
207         CORE_DVFS("dsia", -1, 1, KHZ,         1, 100000, 125000, 125000, 125000,  125000,  125000),
208         CORE_DVFS("dsib", -1, 1, KHZ,         1, 100000, 125000, 125000, 125000,  125000,  125000),
209         CORE_DVFS("dsialp", -1, 1, KHZ,       1, 102000, 102000, 102000, 102000,  156000,  156000),
210         CORE_DVFS("dsiblp", -1, 1, KHZ,       1, 102000, 102000, 102000, 102000,  156000,  156000),
211         CORE_DVFS("hdmi", -1, 1, KHZ,         1,  99000, 118800, 148500, 198000,  198000,  198000),
212
213         /*
214          * The clock rate for the display controllers that determines the
215          * necessary core voltage depends on a divider that is internal
216          * to the display block.  Disable auto-dvfs on the display clocks,
217          * and let the display driver call tegra_dvfs_set_rate manually
218          */
219         CORE_DVFS("disp1", -1, 0, KHZ,         1, 108000, 120000, 144000, 192000,  240000,  240000),
220         CORE_DVFS("disp2", -1, 0, KHZ,         1, 108000, 120000, 144000, 192000,  240000,  240000),
221 #endif
222 };
223
224 #define GPU_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)        \
225         {                                                       \
226                 .clk_name       = _clk_name,                    \
227                 .speedo_id      = _speedo_id,                   \
228                 .process_id     = -1,                           \
229                 .freqs          = {_freqs},                     \
230                 .freqs_mult     = _mult,                        \
231                 .millivolts     = gpu_millivolts,               \
232                 .auto_dvfs      = _auto,                        \
233                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,   \
234         }
235
236 /* TBD: fill in actual hw numbers */
237 static struct dvfs gpu_dvfs_table[] = {
238         /* Gpu voltages (mV):               850,    900,    950,   1000,   1050,    1100,    1150,    1200,    1250 */
239         /* Clock limits for internal blocks, PLLs */
240         GPU_DVFS("gpu",     -1, 1, KHZ,    624000, 650000, 676000, 702000, 728000,  754000,  780000,  806000),
241 };
242
243 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
244 {
245         int ret;
246
247         ret = param_set_bool(arg, kp);
248         if (ret)
249                 return ret;
250
251         if (tegra_dvfs_core_disabled)
252                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
253         else
254                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
255
256         return 0;
257 }
258
259 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
260 {
261         int ret;
262
263         ret = param_set_bool(arg, kp);
264         if (ret)
265                 return ret;
266
267         if (tegra_dvfs_cpu_disabled)
268                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
269         else
270                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
271
272         return 0;
273 }
274
275 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
276 {
277         int ret;
278
279         ret = param_set_bool(arg, kp);
280         if (ret)
281                 return ret;
282
283         if (tegra_dvfs_gpu_disabled)
284                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
285         else
286                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
287
288         return 0;
289 }
290
291 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
292 {
293         return param_get_bool(buffer, kp);
294 }
295
296 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
297         .set = tegra_dvfs_disable_core_set,
298         .get = tegra_dvfs_disable_get,
299 };
300
301 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
302         .set = tegra_dvfs_disable_cpu_set,
303         .get = tegra_dvfs_disable_get,
304 };
305
306 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
307         .set = tegra_dvfs_disable_gpu_set,
308         .get = tegra_dvfs_disable_get,
309 };
310
311 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
312         &tegra_dvfs_core_disabled, 0644);
313 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
314         &tegra_dvfs_cpu_disabled, 0644);
315 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
316         &tegra_dvfs_gpu_disabled, 0644);
317
318
319 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
320 {
321         /* Don't update manual dvfs clocks */
322         if (!d->auto_dvfs)
323                 return false;
324
325         /*
326          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
327          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
328          * together with the image) and board specific EMC DFS table; we will
329          * check the scaling ladder against nominal core voltage when the table
330          * is loaded (and if on particular board the table is not loaded, EMC
331          * scaling is disabled).
332          */
333         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
334                 return false;
335
336         /*
337          * Don't update shared cbus, and don't propagate common cbus dvfs
338          * limit down to shared users, but set maximum rate for each user
339          * equal to the respective client limit.
340          */
341         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
342                 struct clk *user;
343                 unsigned long rate;
344
345                 list_for_each_entry(
346                         user, &c->shared_bus_list, u.shared_bus_user.node) {
347                         if (user->u.shared_bus_user.client) {
348                                 rate = user->u.shared_bus_user.client->max_rate;
349                                 user->max_rate = rate;
350                                 user->u.shared_bus_user.rate = rate;
351                         }
352                 }
353                 return false;
354         }
355
356         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
357         return true;
358 }
359
360 static void __init init_dvfs_one(struct dvfs *d, int nominal_mv_index)
361 {
362         int ret;
363         struct clk *c = tegra_get_clock_by_name(d->clk_name);
364
365         if (!c) {
366                 pr_debug("tegra12_dvfs: no clock found for %s\n",
367                         d->clk_name);
368                 return;
369         }
370
371         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
372         if (can_update_max_rate(c, d)) {
373                 BUG_ON(!d->freqs[nominal_mv_index]);
374                 tegra_init_max_rate(
375                         c, d->freqs[nominal_mv_index] * d->freqs_mult);
376         }
377         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
378
379         ret = tegra_enable_dvfs_on_clk(c, d);
380         if (ret)
381                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
382 }
383
384 static bool __init match_dvfs_one(struct dvfs *d, int speedo_id, int process_id)
385 {
386         if ((d->process_id != -1 && d->process_id != process_id) ||
387                 (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
388                 pr_debug("tegra12_dvfs: rejected %s speedo %d,"
389                         " process %d\n", d->clk_name, d->speedo_id,
390                         d->process_id);
391                 return false;
392         }
393         return true;
394 }
395
396 static inline int round_cvb_voltage(int mv)
397 {
398         /* round to 12.5mV */
399         return DIV_ROUND_UP(mv * 2, 25) * 25 / 2;
400 }
401
402 static inline int get_cvb_voltage(int speedo,
403                                   struct cpu_cvb_dvfs_parameters *cvb)
404 {
405         /* FIXME: normalize */
406         int mv = cvb->c0 + cvb->c1 * speedo + cvb->c2 * speedo * speedo;
407         return mv;
408 }
409
410 static int __init get_cpu_nominal_mv_index(int speedo_id,
411         struct dvfs *cpu_dvfs, struct tegra_cl_dvfs_dfll_data *dfll_data)
412 {
413         int i, j, mv, dfll_mv;
414         unsigned long fmax_at_vmin = 0;
415         struct cpu_cvb_dvfs *d = NULL;
416         struct cpu_cvb_dvfs_parameters *cvb = NULL;
417         int speedo = 0; /* FIXME: tegra_cpu_speedo_val(); */
418
419         /* Find matching cvb dvfs entry */
420         for (i = 0; i < ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
421                 d = &cpu_cvb_dvfs_table[i];
422                 if (speedo_id == d->speedo_id)
423                         break;
424         }
425
426         if (!d) {
427                 pr_err("tegra12_dvfs: no cpu dvfs table for speedo_id %d\n",
428                        speedo_id);
429                 return -ENOENT;
430         }
431         BUG_ON(d->min_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
432
433         /*
434          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
435          * CVB entry specifies CPU frequency and CVB coefficients to calculate
436          * the respective voltage when DFLL is used as CPU clock source. Common
437          * margin is applied to determine voltage requirements for PLL source.
438          */
439         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
440                 cvb = &d->cvb_table[i];
441                 if (!cvb->freq_mhz)
442                         break;
443
444                 mv = get_cvb_voltage(speedo, cvb);
445                 dfll_mv = round_cvb_voltage(mv);
446                 dfll_mv = max(dfll_mv, d->min_mv);
447
448                 /* Check maximum frequency at minimum voltage */
449                 if (dfll_mv > d->min_mv) {
450                         if (!j)
451                                 break;  /* 1st entry already above Vmin */
452                         if (!fmax_at_vmin)
453                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
454                 }
455
456                 /* dvfs tables with maximum frequency at any distinct voltage */
457                 if (!j || (dfll_mv > cpu_dfll_millivolts[j - 1])) {
458                         cpu_dvfs->freqs[j] = cvb->freq_mhz;
459                         cpu_dfll_millivolts[j] = dfll_mv;
460                         mv = round_cvb_voltage(mv * d->margin / 100);
461                         cpu_millivolts[j] = max(mv, d->min_mv);
462                         j++;
463                 } else {
464                         cpu_dvfs->freqs[j - 1] = cvb->freq_mhz;
465                 }
466
467         }
468         /* Table must not be empty and must have and at least one entry below,
469            and one entry above Vmin */
470         if (!i || !j || !fmax_at_vmin) {
471                 pr_err("tegra12_dvfs: invalid cpu dvfs table for speedo_id %d\n",
472                        speedo_id);
473                 return -ENOENT;
474         }
475
476         cpu_dvfs->speedo_id = speedo_id;
477         dfll_data->out_rate_min = fmax_at_vmin * MHZ;
478         dfll_data->millivolts_min = d->min_mv;
479         return j - 1;
480 }
481
482 static int __init get_core_nominal_mv_index(int speedo_id)
483 {
484         int i;
485 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
486         int mv = 1100; /* FIXME: tegra_core_speedo_mv(); */
487 #else
488         int mv = 1100;
489 #endif
490         int core_edp_limit = get_core_edp();
491
492         /*
493          * Start with nominal level for the chips with this speedo_id. Then,
494          * make sure core nominal voltage is below edp limit for the board
495          * (if edp limit is set).
496          */
497         if (core_edp_limit)
498                 mv = min(mv, core_edp_limit);
499
500         /* Round nominal level down to the nearest core scaling step */
501         for (i = 0; i < MAX_DVFS_FREQS; i++) {
502                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
503                         break;
504         }
505
506         if (i == 0) {
507                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
508                        " nominal voltage %d\n", mv);
509                 return -ENOSYS;
510         }
511         return i - 1;
512 }
513
514 static int __init get_gpu_nominal_mv_index(
515         int speedo_id, int process_id, struct dvfs **gpu_dvfs)
516 {
517         int i, j, mv;
518         struct dvfs *d;
519         struct clk *c;
520
521         /* TBD: do we have dependency between gpu and core ??
522          * Find maximum gpu voltage that satisfies gpu_to_core dependency for
523          * nominal core voltage ("solve from cpu to core at nominal"). Clip
524          * result to the nominal cpu level for the chips with this speedo_id.
525          */
526         mv = tegra12_dvfs_rail_vdd_core.nominal_millivolts;
527         for (i = 0; i < MAX_DVFS_FREQS; i++) {
528                 if (gpu_millivolts[i] == 0)
529                         break;
530         }
531         BUG_ON(i == 0);
532         mv = gpu_millivolts[i - 1];
533         BUG_ON(mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
534         mv = min(mv, 1250/* TBD: tegra_gpu_speedo_mv() */);
535
536         /*
537          * Find matching gpu dvfs entry, and use it to determine index to the
538          * final nominal voltage, that satisfies the following requirements:
539          * - allows GPU to run at minimum of the maximum rates specified in
540          *   the dvfs entry and clock tree
541          * - does not violate gpu_to_core dependency as determined above
542          */
543         for (i = 0, j = 0; j <  ARRAY_SIZE(gpu_dvfs_table); j++) {
544                 d = &gpu_dvfs_table[j];
545                 if (match_dvfs_one(d, speedo_id, process_id)) {
546                         c = tegra_get_clock_by_name(d->clk_name);
547                         BUG_ON(!c);
548
549                         for (; i < MAX_DVFS_FREQS; i++) {
550                                 if ((d->freqs[i] == 0) ||
551                                     (gpu_millivolts[i] == 0) ||
552                                     (mv < gpu_millivolts[i]))
553                                         break;
554
555                                 if (c->max_rate <= d->freqs[i]*d->freqs_mult) {
556                                         i++;
557                                         break;
558                                 }
559                         }
560                         break;
561                 }
562         }
563
564         BUG_ON(i == 0);
565         if (j == (ARRAY_SIZE(gpu_dvfs_table) - 1))
566                 pr_err("tegra12_dvfs: WARNING!!!\n"
567                        "tegra12_dvfs: no gpu dvfs table found for chip speedo_id"
568                        " %d and process_id %d: set GPU rate limit at %lu\n"
569                        "tegra12_dvfs: WARNING!!!\n",
570                        speedo_id, process_id, d->freqs[i-1] * d->freqs_mult);
571
572         *gpu_dvfs = d;
573         return i - 1;
574 }
575
576 void __init tegra12x_init_dvfs(void)
577 {
578         int cpu_speedo_id = tegra_cpu_speedo_id();
579         int soc_speedo_id = tegra_soc_speedo_id();
580         int gpu_speedo_id = -1; /* TBD: use gpu speedo */
581         int core_process_id = tegra_core_process_id();
582         int gpu_process_id = -1; /* TBD: use gpu process */
583
584         int i;
585         int core_nominal_mv_index;
586         int cpu_nominal_mv_index;
587         int gpu_nominal_mv_index;
588
589 #ifndef CONFIG_TEGRA_CORE_DVFS
590         tegra_dvfs_core_disabled = true;
591 #endif
592 #ifndef CONFIG_TEGRA_CPU_DVFS
593         tegra_dvfs_cpu_disabled = true;
594 #endif
595 #ifndef CONFIG_TEGRA_GPU_DVFS
596         tegra_dvfs_gpu_disabled = true;
597 #endif
598
599         /*
600          * Find nominal voltages for core (1st) and cpu rails before rail
601          * init. Nominal voltage index in the scaling ladder will also be
602          * used to determine max dvfs frequency for the respective domains.
603          */
604         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
605         if (core_nominal_mv_index < 0) {
606                 tegra12_dvfs_rail_vdd_core.disabled = true;
607                 tegra_dvfs_core_disabled = true;
608                 core_nominal_mv_index = 0;
609         }
610         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
611                 core_millivolts[core_nominal_mv_index];
612
613         cpu_nominal_mv_index = get_cpu_nominal_mv_index(
614                 cpu_speedo_id, &cpu_dvfs, &cpu_dfll_data);
615         BUG_ON(cpu_nominal_mv_index < 0);
616         tegra12_dvfs_rail_vdd_cpu.nominal_millivolts =
617                 cpu_millivolts[cpu_nominal_mv_index];
618
619         gpu_nominal_mv_index = get_gpu_nominal_mv_index(
620                 gpu_speedo_id, gpu_process_id, &gpu_dvfs);
621         BUG_ON((gpu_nominal_mv_index < 0) || (!gpu_dvfs));
622         tegra12_dvfs_rail_vdd_gpu.nominal_millivolts =
623                 gpu_millivolts[gpu_nominal_mv_index];
624
625         /* Init rail structures and dependencies */
626         tegra_dvfs_init_rails(tegra12_dvfs_rails,
627                 ARRAY_SIZE(tegra12_dvfs_rails));
628
629         /* Search core dvfs table for speedo/process matching entries and
630            initialize dvfs-ed clocks */
631         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
632                 struct dvfs *d = &core_dvfs_table[i];
633                 if (!match_dvfs_one(d, soc_speedo_id, core_process_id))
634                         continue;
635                 init_dvfs_one(d, core_nominal_mv_index);
636         }
637
638         /* Initialize matching cpu dvfs entry already found when nominal
639            voltage was determined */
640         init_dvfs_one(&cpu_dvfs, cpu_nominal_mv_index);
641
642         /* CL DVFS characterization data */
643         tegra_cl_dvfs_set_dfll_data(&cpu_dfll_data);
644
645         /* Finally disable dvfs on rails if necessary */
646         if (tegra_dvfs_core_disabled)
647                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
648         if (tegra_dvfs_cpu_disabled)
649                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
650         if (tegra_dvfs_gpu_disabled)
651                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
652
653         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
654                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
655                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
656         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
657                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
658                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
659         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
660                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
661                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
662 }
663
664 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
665 {
666         return 0;
667 }
668
669 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
670 {
671         return 0;
672 }
673