ARM: tegra: Add Tegra12x clock and dvfs files
[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 *cpu_dvfs;
35 static struct dvfs *gpu_dvfs;
36
37 static const int cpu_millivolts[MAX_DVFS_FREQS] = {
38         800, 825, 850, 900, 912, 975, 1000, 1025, 1050, 1075, 1100, 1125, 1150, 1175, 1200, 1237, 1250};
39
40 static const int core_millivolts[MAX_DVFS_FREQS] = {
41         850,  900,  950, 1000, 1050, 1100, 1150, 1200, 1250};
42
43 /* TBD: fill in actual hw numbers */
44 static const int gpu_millivolts[MAX_DVFS_FREQS] = {
45         850,  900,  950, 1000, 1050, 1100, 1150, 1200, 1250};
46
47 #define KHZ 1000
48 #define MHZ 1000000
49
50 /* FIXME: need tegra12 step */
51 #define VDD_SAFE_STEP                   100
52
53 static struct dvfs_rail tegra12_dvfs_rail_vdd_cpu = {
54         .reg_id = "vdd_cpu",
55         .max_millivolts = 1250,
56         .min_millivolts = 800,
57         .step = VDD_SAFE_STEP,
58         .jmp_to_zero = true,
59 };
60
61 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
62         .reg_id = "vdd_core",
63         .max_millivolts = 1350,
64         .min_millivolts = 850,
65         .step = VDD_SAFE_STEP,
66 };
67
68 /* TBD: fill in actual hw number */
69 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
70         .reg_id = "vdd_gpu",
71         .max_millivolts = 1350,
72         .min_millivolts = 850,
73         .step = VDD_SAFE_STEP,
74 };
75
76 static struct dvfs_rail *tegra12_dvfs_rails[] = {
77         &tegra12_dvfs_rail_vdd_cpu,
78         &tegra12_dvfs_rail_vdd_core,
79         &tegra12_dvfs_rail_vdd_gpu,
80 };
81
82 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
83 #define CPU_AUTO true
84 #else
85 #define CPU_AUTO false
86 #endif
87
88 #define CPU_DVFS(_clk_name, _speedo_id, _process_id, _mult, _freqs...)  \
89         {                                                               \
90                 .clk_name       = _clk_name,                            \
91                 .speedo_id      = _speedo_id,                           \
92                 .process_id     = _process_id,                          \
93                 .freqs          = {_freqs},                             \
94                 .freqs_mult     = _mult,                                \
95                 .millivolts     = cpu_millivolts,                       \
96                 .auto_dvfs      = CPU_AUTO,                             \
97                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,           \
98         }
99
100 static struct dvfs cpu_dvfs_table[] = {
101         /* Cpu voltages (mV):         800, 825, 850, 900,  912,  975, 1000, 1025, 1050, 1075, 1100, 1125, 1150, 1175, 1200, 1237 */
102         CPU_DVFS("cpu_g",  0, 0, MHZ,   1, 460, 550, 680,  680,  820,  970, 1040, 1080, 1150, 1200, 1240, 1280, 1320, 1360, 1500),
103
104         /*
105          * "Safe entry" to be used when no match for chip speedo, process
106          *  corner is found (just to boot at low rate); must be the last one
107          */
108         CPU_DVFS("cpu_g", -1, -1, MHZ,  1,   1, 216, 216, 300),
109 };
110
111 #define CORE_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)       \
112         {                                                       \
113                 .clk_name       = _clk_name,                    \
114                 .speedo_id      = _speedo_id,                   \
115                 .process_id     = -1,                           \
116                 .freqs          = {_freqs},                     \
117                 .freqs_mult     = _mult,                        \
118                 .millivolts     = core_millivolts,              \
119                 .auto_dvfs      = _auto,                        \
120                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
121         }
122
123 static struct dvfs core_dvfs_table[] = {
124         /* Core voltages (mV):              850,    900,    950,   1000,   1050,    1100,    1150,    1200,    1250 */
125         /* Clock limits for internal blocks, PLLs */
126 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
127         CORE_DVFS("epp",    0, 1, KHZ,    60400, 110500, 148000, 186400, 248500,  248500,  313000,  391800),
128         CORE_DVFS("2d",     0, 1, KHZ,    77200, 141200, 189200, 238200, 317500,  317500,  400000,  500700),
129         CORE_DVFS("3d",     0, 1, KHZ,    86800, 158900, 212800, 267900, 357200,  357200,  450000,  563300),
130         CORE_DVFS("msenc",  0, 1, KHZ,    64200, 117600, 157500, 198300, 264300,  264300,  333000,  416900),
131         CORE_DVFS("se",     0, 1, KHZ,    67500, 123600, 165500, 208400, 277800,  277800,  350000,  438100),
132         CORE_DVFS("tsec",   0, 1, KHZ,    67500, 123600, 165500, 208400, 277800,  277800,  350000,  438100),
133         CORE_DVFS("vde",    0, 1, KHZ,    70600, 129200, 173100, 217900, 290500,  290500,  366000,  458200),
134
135         CORE_DVFS("host1x", 0, 1, KHZ,    57900, 105900, 141900, 178600, 238200,  238200,  300000,  300000),
136
137 #ifdef CONFIG_TEGRA_DUAL_CBUS
138         CORE_DVFS("c2bus",  0, 1, KHZ,    77200, 141200, 189200, 238200, 317500,  317500,  400000,  500700),
139         CORE_DVFS("c3bus",  0, 1, KHZ,    60400, 110500, 148000, 186400, 248500,  248500,  313000,  391800),
140 #else
141         CORE_DVFS("cbus",   0, 1, KHZ,    60400, 110500, 148000, 186400, 248500,  248500,  313000,  391800),
142 #endif
143 #endif
144 };
145
146 #define CL_DVFS(_speedo_id, _tune0, _tune1, _droop_min, _out_min, _mv_min) \
147         {                                                       \
148                 .dfll_clk_name  = "dfll_cpu",                   \
149                 .speedo_id      = _speedo_id,                   \
150                 .tune0          = _tune0,                       \
151                 .tune1          = _tune1,                       \
152                 .dfll_droop_rate_min = _droop_min,              \
153                 .dfll_out_rate_min = _out_min,                  \
154                 .dfll_millivolts_min = _mv_min,                 \
155         }
156
157 static struct tegra_cl_dvfs_soc_data cl_dvfs_table[] = {
158         CL_DVFS(0, 0x030201, 0x000BB0AA, 640000000, 670000000, 750),
159 };
160
161 #define GPU_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)        \
162         {                                                       \
163                 .clk_name       = _clk_name,                    \
164                 .speedo_id      = _speedo_id,                   \
165                 .process_id     = -1,                           \
166                 .freqs          = {_freqs},                     \
167                 .freqs_mult     = _mult,                        \
168                 .millivolts     = gpu_millivolts,               \
169                 .auto_dvfs      = _auto,                        \
170                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,   \
171         }
172
173 /* TBD: fill in actual hw numbers */
174 static struct dvfs gpu_dvfs_table[] = {
175         /* Gpu voltages (mV):               850,    900,    950,   1000,   1050,    1100,    1150,    1200,    1250 */
176         /* Clock limits for internal blocks, PLLs */
177         GPU_DVFS("gpu",     -1, 1, KHZ,    624000, 650000, 676000, 702000, 728000,  754000,  780000,  806000),
178 };
179
180 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
181 {
182         int ret;
183
184         ret = param_set_bool(arg, kp);
185         if (ret)
186                 return ret;
187
188         if (tegra_dvfs_core_disabled)
189                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
190         else
191                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
192
193         return 0;
194 }
195
196 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
197 {
198         int ret;
199
200         ret = param_set_bool(arg, kp);
201         if (ret)
202                 return ret;
203
204         if (tegra_dvfs_cpu_disabled)
205                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
206         else
207                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
208
209         return 0;
210 }
211
212 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
213 {
214         int ret;
215
216         ret = param_set_bool(arg, kp);
217         if (ret)
218                 return ret;
219
220         if (tegra_dvfs_gpu_disabled)
221                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
222         else
223                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
224
225         return 0;
226 }
227
228 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
229 {
230         return param_get_bool(buffer, kp);
231 }
232
233 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
234         .set = tegra_dvfs_disable_core_set,
235         .get = tegra_dvfs_disable_get,
236 };
237
238 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
239         .set = tegra_dvfs_disable_cpu_set,
240         .get = tegra_dvfs_disable_get,
241 };
242
243 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
244         .set = tegra_dvfs_disable_gpu_set,
245         .get = tegra_dvfs_disable_get,
246 };
247
248 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
249         &tegra_dvfs_core_disabled, 0644);
250 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
251         &tegra_dvfs_cpu_disabled, 0644);
252 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
253         &tegra_dvfs_gpu_disabled, 0644);
254
255 static void __init init_cl_dvfs_soc_data(int speedo_id)
256 {
257         tegra_cl_dvfs_set_soc_data(cl_dvfs_table);
258 }
259
260 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
261 {
262         /* Don't update manual dvfs clocks */
263         if (!d->auto_dvfs)
264                 return false;
265
266         /*
267          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
268          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
269          * together with the image) and board specific EMC DFS table; we will
270          * check the scaling ladder against nominal core voltage when the table
271          * is loaded (and if on particular board the table is not loaded, EMC
272          * scaling is disabled).
273          */
274         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
275                 return false;
276
277         /*
278          * Don't update shared cbus, and don't propagate common cbus dvfs
279          * limit down to shared users, but set maximum rate for each user
280          * equal to the respective client limit.
281          */
282         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
283                 struct clk *user;
284                 unsigned long rate;
285
286                 list_for_each_entry(
287                         user, &c->shared_bus_list, u.shared_bus_user.node) {
288                         if (user->u.shared_bus_user.client) {
289                                 rate = user->u.shared_bus_user.client->max_rate;
290                                 user->max_rate = rate;
291                                 user->u.shared_bus_user.rate = rate;
292                         }
293                 }
294                 return false;
295         }
296
297         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
298         return true;
299 }
300
301 static void __init init_dvfs_one(struct dvfs *d, int nominal_mv_index)
302 {
303         int ret;
304         struct clk *c = tegra_get_clock_by_name(d->clk_name);
305
306         if (!c) {
307                 pr_debug("tegra12_dvfs: no clock found for %s\n",
308                         d->clk_name);
309                 return;
310         }
311
312         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
313         if (can_update_max_rate(c, d)) {
314                 BUG_ON(!d->freqs[nominal_mv_index]);
315                 tegra_init_max_rate(
316                         c, d->freqs[nominal_mv_index] * d->freqs_mult);
317         }
318         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
319
320         ret = tegra_enable_dvfs_on_clk(c, d);
321         if (ret)
322                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
323 }
324
325 static bool __init match_dvfs_one(struct dvfs *d, int speedo_id, int process_id)
326 {
327         if ((d->process_id != -1 && d->process_id != process_id) ||
328                 (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
329                 pr_debug("tegra12_dvfs: rejected %s speedo %d,"
330                         " process %d\n", d->clk_name, d->speedo_id,
331                         d->process_id);
332                 return false;
333         }
334         return true;
335 }
336
337 static int __init get_cpu_nominal_mv_index(
338         int speedo_id, int process_id, struct dvfs **cpu_dvfs)
339 {
340         int i, j, mv;
341         struct dvfs *d;
342         struct clk *c;
343
344         /*
345          * Find maximum cpu voltage that satisfies cpu_to_core dependency for
346          * nominal core voltage ("solve from cpu to core at nominal"). Clip
347          * result to the nominal cpu level for the chips with this speedo_id.
348          */
349         mv = tegra12_dvfs_rail_vdd_core.nominal_millivolts;
350         for (i = 0; i < MAX_DVFS_FREQS; i++) {
351                 if (cpu_millivolts[i] == 0)
352                         break;
353         }
354         BUG_ON(i == 0);
355         mv = cpu_millivolts[i - 1];
356         BUG_ON(mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
357         mv = min(mv, tegra_cpu_speedo_mv());
358
359         /*
360          * Find matching cpu dvfs entry, and use it to determine index to the
361          * final nominal voltage, that satisfies the following requirements:
362          * - allows CPU to run at minimum of the maximum rates specified in
363          *   the dvfs entry and clock tree
364          * - does not violate cpu_to_core dependency as determined above
365          */
366         for (i = 0, j = 0; j <  ARRAY_SIZE(cpu_dvfs_table); j++) {
367                 d = &cpu_dvfs_table[j];
368                 if (match_dvfs_one(d, speedo_id, process_id)) {
369                         c = tegra_get_clock_by_name(d->clk_name);
370                         BUG_ON(!c);
371
372                         for (; i < MAX_DVFS_FREQS; i++) {
373                                 if ((d->freqs[i] == 0) ||
374                                     (cpu_millivolts[i] == 0) ||
375                                     (mv < cpu_millivolts[i]))
376                                         break;
377
378                                 if (c->max_rate <= d->freqs[i]*d->freqs_mult) {
379                                         i++;
380                                         break;
381                                 }
382                         }
383                         break;
384                 }
385         }
386
387         BUG_ON(i == 0);
388         if (j == (ARRAY_SIZE(cpu_dvfs_table) - 1))
389                 pr_err("tegra12_dvfs: WARNING!!!\n"
390                        "tegra12_dvfs: no cpu dvfs table found for chip speedo_id"
391                        " %d and process_id %d: set CPU rate limit at %lu\n"
392                        "tegra12_dvfs: WARNING!!!\n",
393                        speedo_id, process_id, d->freqs[i-1] * d->freqs_mult);
394
395         *cpu_dvfs = d;
396         return i - 1;
397 }
398
399 static int __init get_core_nominal_mv_index(int speedo_id)
400 {
401         int i;
402 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
403         int mv = tegra_core_speedo_mv();
404 #else
405         int mv = 1150;
406 #endif
407         int core_edp_limit = get_core_edp();
408
409         /*
410          * Start with nominal level for the chips with this speedo_id. Then,
411          * make sure core nominal voltage is below edp limit for the board
412          * (if edp limit is set).
413          */
414         if (core_edp_limit)
415                 mv = min(mv, core_edp_limit);
416
417         /* Round nominal level down to the nearest core scaling step */
418         for (i = 0; i < MAX_DVFS_FREQS; i++) {
419                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
420                         break;
421         }
422
423         if (i == 0) {
424                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
425                        " nominal voltage %d\n", mv);
426                 return -ENOSYS;
427         }
428         return i - 1;
429 }
430
431 static int __init get_gpu_nominal_mv_index(
432         int speedo_id, int process_id, struct dvfs **gpu_dvfs)
433 {
434         int i, j, mv;
435         struct dvfs *d;
436         struct clk *c;
437
438         /* TBD: do we have dependency between gpu and core ??
439          * Find maximum gpu voltage that satisfies gpu_to_core dependency for
440          * nominal core voltage ("solve from cpu to core at nominal"). Clip
441          * result to the nominal cpu level for the chips with this speedo_id.
442          */
443         mv = tegra12_dvfs_rail_vdd_core.nominal_millivolts;
444         for (i = 0; i < MAX_DVFS_FREQS; i++) {
445                 if (gpu_millivolts[i] == 0)
446                         break;
447         }
448         BUG_ON(i == 0);
449         mv = gpu_millivolts[i - 1];
450         BUG_ON(mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
451         mv = min(mv, 1250/* TBD: tegra_gpu_speedo_mv() */);
452
453         /*
454          * Find matching gpu dvfs entry, and use it to determine index to the
455          * final nominal voltage, that satisfies the following requirements:
456          * - allows GPU to run at minimum of the maximum rates specified in
457          *   the dvfs entry and clock tree
458          * - does not violate gpu_to_core dependency as determined above
459          */
460         for (i = 0, j = 0; j <  ARRAY_SIZE(gpu_dvfs_table); j++) {
461                 d = &gpu_dvfs_table[j];
462                 if (match_dvfs_one(d, speedo_id, process_id)) {
463                         c = tegra_get_clock_by_name(d->clk_name);
464                         BUG_ON(!c);
465
466                         for (; i < MAX_DVFS_FREQS; i++) {
467                                 if ((d->freqs[i] == 0) ||
468                                     (gpu_millivolts[i] == 0) ||
469                                     (mv < gpu_millivolts[i]))
470                                         break;
471
472                                 if (c->max_rate <= d->freqs[i]*d->freqs_mult) {
473                                         i++;
474                                         break;
475                                 }
476                         }
477                         break;
478                 }
479         }
480
481         BUG_ON(i == 0);
482         if (j == (ARRAY_SIZE(gpu_dvfs_table) - 1))
483                 pr_err("tegra12_dvfs: WARNING!!!\n"
484                        "tegra12_dvfs: no gpu dvfs table found for chip speedo_id"
485                        " %d and process_id %d: set GPU rate limit at %lu\n"
486                        "tegra12_dvfs: WARNING!!!\n",
487                        speedo_id, process_id, d->freqs[i-1] * d->freqs_mult);
488
489         *gpu_dvfs = d;
490         return i - 1;
491 }
492
493 void __init tegra12x_init_dvfs(void)
494 {
495         int cpu_speedo_id = tegra_cpu_speedo_id();
496         int soc_speedo_id = tegra_soc_speedo_id();
497         int gpu_speedo_id = -1; /* TBD: use gpu speedo */
498         int cpu_process_id = tegra_cpu_process_id();
499         int core_process_id = tegra_core_process_id();
500         int gpu_process_id = -1; /* TBD: use gpu process */
501
502         int i;
503         int core_nominal_mv_index;
504         int cpu_nominal_mv_index;
505         int gpu_nominal_mv_index;
506
507 #ifndef CONFIG_TEGRA_CORE_DVFS
508         tegra_dvfs_core_disabled = true;
509 #endif
510 #ifndef CONFIG_TEGRA_CPU_DVFS
511         tegra_dvfs_cpu_disabled = true;
512 #endif
513 #ifndef CONFIG_TEGRA_GPU_DVFS
514         tegra_dvfs_gpu_disabled = true;
515 #endif
516
517         /*
518          * Find nominal voltages for core (1st) and cpu rails before rail
519          * init. Nominal voltage index in the scaling ladder will also be
520          * used to determine max dvfs frequency for the respective domains.
521          */
522         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
523         if (core_nominal_mv_index < 0) {
524                 tegra12_dvfs_rail_vdd_core.disabled = true;
525                 tegra_dvfs_core_disabled = true;
526                 core_nominal_mv_index = 0;
527         }
528         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
529                 core_millivolts[core_nominal_mv_index];
530
531         cpu_nominal_mv_index = get_cpu_nominal_mv_index(
532                 cpu_speedo_id, cpu_process_id, &cpu_dvfs);
533         BUG_ON((cpu_nominal_mv_index < 0) || (!cpu_dvfs));
534         tegra12_dvfs_rail_vdd_cpu.nominal_millivolts =
535                 cpu_millivolts[cpu_nominal_mv_index];
536
537         gpu_nominal_mv_index = get_gpu_nominal_mv_index(
538                 gpu_speedo_id, gpu_process_id, &gpu_dvfs);
539         BUG_ON((gpu_nominal_mv_index < 0) || (!gpu_dvfs));
540         tegra12_dvfs_rail_vdd_gpu.nominal_millivolts =
541                 gpu_millivolts[gpu_nominal_mv_index];
542
543         /* Init rail structures and dependencies */
544         tegra_dvfs_init_rails(tegra12_dvfs_rails,
545                 ARRAY_SIZE(tegra12_dvfs_rails));
546
547         /* Search core dvfs table for speedo/process matching entries and
548            initialize dvfs-ed clocks */
549         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
550                 struct dvfs *d = &core_dvfs_table[i];
551                 if (!match_dvfs_one(d, soc_speedo_id, core_process_id))
552                         continue;
553                 init_dvfs_one(d, core_nominal_mv_index);
554         }
555
556         /* Initialize matching cpu dvfs entry already found when nominal
557            voltage was determined */
558         init_dvfs_one(cpu_dvfs, cpu_nominal_mv_index);
559
560         /* CL DVFS characterization data */
561         init_cl_dvfs_soc_data(soc_speedo_id);
562
563         init_dvfs_one(gpu_dvfs, gpu_nominal_mv_index);
564
565         /* Finally disable dvfs on rails if necessary */
566         if (tegra_dvfs_core_disabled)
567                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
568         if (tegra_dvfs_cpu_disabled)
569                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
570         if (tegra_dvfs_gpu_disabled)
571                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
572
573         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
574                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
575                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
576         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
577                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
578                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
579         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
580                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
581                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
582 }
583
584 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
585 {
586         return 0;
587 }
588
589 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
590 {
591         return 0;
592 }
593