1d80ad4a9079486a50cc171250011e4304ae9878
[linux-2.6.git] / arch / arm / mach-tegra / tegra3_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra3_dvfs.c
3  *
4  * Copyright (C) 2010-2011 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
30 static bool tegra_dvfs_cpu_disabled;
31 static bool tegra_dvfs_core_disabled;
32
33 static const int cpu_millivolts[MAX_DVFS_FREQS] =
34         {750, 775, 800, 825, 850, 875, 900, 925, 950, 975, 1000, 1025, 1050, 1075, 1100, 1125, 1150};
35
36 static const int core_millivolts[MAX_DVFS_FREQS] =
37         {1000, 1050, 1100, 1150, 1200, 1250, 1300};
38
39 static const int core_speedo_nominal_millivolts[] =
40 /* speedo_id 0,    1,    2 */
41         { 1200, 1200, 1300 };
42
43 static const int cpu_speedo_nominal_millivolts[] =
44 /* speedo_id 0,    1,    2,    3 */
45         { 1125, 1150, 1125, 1150 };
46
47 #define KHZ 1000
48 #define MHZ 1000000
49
50 /* (VDD_CORE - cpu_below_core) <= VDD_CPU <= (VDD_CORE + core_below_cpu)]  */
51 /* (VDD_CPU - core_below_cpu) <= VDD_CORE <= (VDD_CPU + cpu_below_core)]  */
52 #define VDD_CPU_BELOW_VDD_CORE          300
53 static int cpu_below_core = VDD_CPU_BELOW_VDD_CORE;
54 #define VDD_CORE_BELOW_VDD_CPU          0
55 static int core_below_cpu = VDD_CORE_BELOW_VDD_CPU;
56
57 #define VDD_SAFE_STEP                   100
58
59 static struct dvfs_rail tegra3_dvfs_rail_vdd_cpu = {
60         .reg_id = "vdd_cpu",
61         .max_millivolts = 1150,
62         .min_millivolts = 750,
63         .step = VDD_SAFE_STEP,
64 };
65
66 static struct dvfs_rail tegra3_dvfs_rail_vdd_core = {
67         .reg_id = "vdd_core",
68         .max_millivolts = 1300,
69         .min_millivolts = 950,
70         .step = VDD_SAFE_STEP,
71 };
72
73 static struct dvfs_rail *tegra3_dvfs_rails[] = {
74         &tegra3_dvfs_rail_vdd_cpu,
75         &tegra3_dvfs_rail_vdd_core,
76 };
77
78
79 /* vdd_core must be >= (vdd_cpu - core_below_cpu) */
80 static int tegra3_dvfs_rel_vdd_cpu_vdd_core(struct dvfs_rail *vdd_cpu,
81         struct dvfs_rail *vdd_core)
82 {
83         int core_floor = max(vdd_cpu->new_millivolts, vdd_cpu->millivolts) -
84                 core_below_cpu;
85         return max(vdd_core->new_millivolts, core_floor);
86 }
87
88 /* vdd_cpu must be >= (vdd_core - cpu_below_core) */
89 static int tegra3_dvfs_rel_vdd_core_vdd_cpu(struct dvfs_rail *vdd_core,
90         struct dvfs_rail *vdd_cpu)
91 {
92         int cpu_floor = max(vdd_core->new_millivolts, vdd_core->millivolts) -
93                 cpu_below_core;
94         return max(vdd_cpu->new_millivolts, cpu_floor);
95 }
96
97 static struct dvfs_relationship tegra3_dvfs_relationships[] = {
98         {
99                 .from = &tegra3_dvfs_rail_vdd_cpu,
100                 .to = &tegra3_dvfs_rail_vdd_core,
101                 .solve = tegra3_dvfs_rel_vdd_cpu_vdd_core,
102                 .solved_at_nominal = true,
103         },
104         {
105                 .from = &tegra3_dvfs_rail_vdd_core,
106                 .to = &tegra3_dvfs_rail_vdd_cpu,
107                 .solve = tegra3_dvfs_rel_vdd_core_vdd_cpu,
108         },
109 };
110
111 #define CPU_DVFS(_clk_name, _speedo_id, _process_id, _mult, _freqs...)  \
112         {                                                               \
113                 .clk_name       = _clk_name,                            \
114                 .speedo_id      = _speedo_id,                           \
115                 .process_id     = _process_id,                          \
116                 .freqs          = {_freqs},                             \
117                 .freqs_mult     = _mult,                                \
118                 .millivolts     = cpu_millivolts,                       \
119                 .auto_dvfs      = true,                                 \
120                 .dvfs_rail      = &tegra3_dvfs_rail_vdd_cpu,            \
121         }
122
123 static struct dvfs cpu_dvfs_table[] = {
124 #if 0
125         /* Cpu voltages (mV):        750, 775, 800, 825, 850, 875,  900,  925,  950,  975, 1000, 1025, 1050, 1075, 1100, 1125, 1150*/
126         CPU_DVFS("cpu_g", 0, 0, MHZ, 399, 399, 541, 541, 684, 684,  817,  817,  817, 1026, 1102, 1149, 1187, 1225, 1282, 1300),
127         CPU_DVFS("cpu_g", 0, 1, MHZ, 481, 481, 652, 652, 807, 807,  948,  948,  948, 1117, 1171, 1206, 1300),
128         CPU_DVFS("cpu_g", 0, 2, MHZ, 540, 540, 711, 711, 883, 883, 1039, 1039, 1039, 1178, 1206, 1300),
129         CPU_DVFS("cpu_g", 0, 3, MHZ, 570, 570, 777, 777, 931, 931, 1102, 1102, 1102, 1216, 1300),
130
131         CPU_DVFS("cpu_g", 1, 0, MHZ,   1, 399, 399, 541, 541, 684,  684,  817,  817,  817, 1026, 1102, 1149, 1187, 1225, 1282, 1300),
132         CPU_DVFS("cpu_g", 1, 1, MHZ,   1, 481, 481, 652, 652, 807,  807,  948,  948,  948, 1117, 1171, 1206, 1300),
133         CPU_DVFS("cpu_g", 1, 2, MHZ,   1, 540, 540, 711, 711, 883,  883, 1039, 1039, 1039, 1178, 1206, 1300),
134         CPU_DVFS("cpu_g", 1, 3, MHZ,   1, 570, 570, 777, 777, 931,  931, 1102, 1102, 1102, 1216, 1300),
135
136         CPU_DVFS("cpu_g", 2, 1, MHZ, 481, 481, 652, 652, 807, 807,  948,  948,  948, 1117, 1171, 1206, 1254, 1292, 1311, 1400),
137         CPU_DVFS("cpu_g", 2, 2, MHZ, 540, 540, 711, 711, 883, 883, 1039, 1039, 1039, 1178, 1206, 1263, 1301, 1400),
138         CPU_DVFS("cpu_g", 2, 3, MHZ, 570, 570, 777, 777, 931, 931, 1102, 1102, 1102, 1216, 1255, 1304, 1400),
139
140         CPU_DVFS("cpu_g", 3, 1, MHZ,   1, 481, 481, 652, 652, 807,  807,  948,  948,  948, 1117, 1171, 1206, 1254, 1292, 1311, 1400),
141         CPU_DVFS("cpu_g", 3, 2, MHZ,   1, 540, 540, 711, 711, 883,  883, 1039, 1039, 1039, 1178, 1206, 1263, 1301, 1400),
142         CPU_DVFS("cpu_g", 3, 3, MHZ,   1, 570, 570, 777, 777, 931,  931, 1102, 1102, 1102, 1216, 1255, 1304, 1400),
143
144 #endif
145         /*
146          * "Safe entry" to be used when no match for chip speedo, process
147          *  corner is found (just to boot at low rate); must be the last one
148          */
149         CPU_DVFS("cpu_g",-1,-1, MHZ,   1,   1, 216, 216, 300),
150 };
151
152 #define CORE_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)       \
153         {                                                       \
154                 .clk_name       = _clk_name,                    \
155                 .speedo_id      = _speedo_id,                   \
156                 .process_id     = -1,                           \
157                 .freqs          = {_freqs},                     \
158                 .freqs_mult     = _mult,                        \
159                 .millivolts     = core_millivolts,              \
160                 .auto_dvfs      = _auto,                        \
161                 .dvfs_rail      = &tegra3_dvfs_rail_vdd_core,   \
162         }
163
164 static struct dvfs core_dvfs_table[] = {
165 #if 0
166         /* Core voltages (mV):             1000,   1050,   1100,   1150,    1200,    1250,    1300 */
167         /* Clock limits for internal blocks, PLLs */
168         CORE_DVFS("cpu_lp", 0, 1, KHZ,   294500, 342000, 427000, 484000,  500000,  500000,  500000),
169         CORE_DVFS("cpu_lp", 1, 1, KHZ,   294500, 342000, 427000, 484000,  500000,  500000,  500000),
170         CORE_DVFS("cpu_lp", 2, 1, KHZ,   304000, 370000, 437000, 503000,  541000,  579000,  620000),
171
172         CORE_DVFS("emc",    0, 1, KHZ,   266500, 266500, 266500, 266500,  533000,  533000,  533000),
173         CORE_DVFS("emc",    1, 1, KHZ,   408000, 408000, 408000, 408000,  667000,  667000,  667000),
174         CORE_DVFS("emc",    2, 1, KHZ,   408000, 408000, 408000, 408000,  667000,  667000,  800000),
175
176         CORE_DVFS("sbus",   0, 1, KHZ,   136000, 164000, 191000, 216000,  216000,  216000,  216000),
177         CORE_DVFS("sbus",   1, 1, KHZ,   205000, 205000, 227000, 227000,  267000,  267000,  267000),
178         CORE_DVFS("sbus",   2, 1, KHZ,   205000, 205000, 227000, 227000,  267000,  334000,  334000),
179
180         CORE_DVFS("vde",    0, 1, KHZ,   228000, 275000, 332000, 380000,  416000,  416000,  416000),
181         CORE_DVFS("mpe",    0, 1, KHZ,   234000, 285000, 332000, 380000,  416000,  416000,  416000),
182         CORE_DVFS("2d",     0, 1, KHZ,   267000, 285000, 332000, 380000,  416000,  416000,  416000),
183         CORE_DVFS("epp",    0, 1, KHZ,   267000, 285000, 332000, 380000,  416000,  416000,  416000),
184         CORE_DVFS("3d",     0, 1, KHZ,   234000, 285000, 332000, 380000,  416000,  416000,  416000),
185         CORE_DVFS("3d2",    0, 1, KHZ,   234000, 285000, 332000, 380000,  416000,  416000,  416000),
186         CORE_DVFS("vi",     0, 1, KHZ,   216000, 285000, 300000, 300000,  300000,  300000,  300000),
187         CORE_DVFS("se",     0, 1, KHZ,   267000, 285000, 332000, 380000,  416000,  416000,  416000),
188
189         CORE_DVFS("vde",    1, 1, KHZ,   228000, 275000, 332000, 380000,  416000,  416000,  416000),
190         CORE_DVFS("mpe",    1, 1, KHZ,   234000, 285000, 332000, 380000,  416000,  416000,  416000),
191         CORE_DVFS("2d",     1, 1, KHZ,   267000, 285000, 332000, 380000,  416000,  416000,  416000),
192         CORE_DVFS("epp",    1, 1, KHZ,   267000, 285000, 332000, 380000,  416000,  416000,  416000),
193         CORE_DVFS("3d",     1, 1, KHZ,   234000, 285000, 332000, 380000,  416000,  416000,  416000),
194         CORE_DVFS("3d2",    1, 1, KHZ,   234000, 285000, 332000, 380000,  416000,  416000,  416000),
195         CORE_DVFS("vi",     1, 1, KHZ,   216000, 285000, 300000, 300000,  300000,  300000,  300000),
196         CORE_DVFS("se",     1, 1, KHZ,   267000, 285000, 332000, 380000,  416000,  416000,  416000),
197
198         CORE_DVFS("vde",    2, 1, KHZ,   247000, 304000, 361000, 408000,  446000,  484000,  520000),
199         CORE_DVFS("mpe",    2, 1, KHZ,   247000, 304000, 361000, 408000,  446000,  484000,  520000),
200         CORE_DVFS("2d",     2, 1, KHZ,   267000, 304000, 361000, 408000,  446000,  484000,  520000),
201         CORE_DVFS("epp",    2, 1, KHZ,   267000, 304000, 361000, 408000,  446000,  484000,  520000),
202         CORE_DVFS("3d",     2, 1, KHZ,   247000, 304000, 361000, 408000,  446000,  484000,  520000),
203         CORE_DVFS("3d2",    2, 1, KHZ,   247000, 304000, 361000, 408000,  446000,  484000,  520000),
204         CORE_DVFS("vi",     2, 1, KHZ,   247000, 300000, 300000, 300000,  300000,  300000,  300000),
205         CORE_DVFS("se",     2, 1, KHZ,   267000, 304000, 361000, 408000,  446000,  484000,  520000),
206
207         CORE_DVFS("host1x",-1, 1, KHZ,   152000, 188000, 222000, 254000,  267000,  267000,  267000),
208
209         CORE_DVFS("cbus",   0, 1, KHZ,   228000, 275000, 332000, 380000,  416000,  416000,  416000),
210         CORE_DVFS("cbus",   1, 1, KHZ,   228000, 275000, 332000, 380000,  416000,  416000,  416000),
211         CORE_DVFS("cbus",   2, 1, KHZ,   247000, 304000, 361000, 408000,  446000,  484000,  520000),
212
213         CORE_DVFS("pll_c",  -1, 1, KHZ,   600000, 600000, 800000, 800000, 1066000, 1066000, 1066000),
214         CORE_DVFS("pll_m",  -1, 1, KHZ,   600000, 600000, 800000, 800000, 1066000, 1066000, 1066000),
215
216         /* Core voltages (mV):             1000,   1050,   1100,   1150,    1200,   1250,    1300 */
217         /* Clock limits for I/O peripherals */
218         CORE_DVFS("mipi",   0, 1, KHZ,        1,      1,      1,      1,      1,       1,       1),
219         CORE_DVFS("mipi",   1, 1, KHZ,        1,      1,      1,      1,  60000,   60000,   60000),
220         CORE_DVFS("mipi",   2, 1, KHZ,        1,      1,      1,      1,  60000,   60000,   60000),
221
222         CORE_DVFS("sdmmc1",-1, 1, KHZ,   104000, 104000, 104000, 104000, 208000,  208000,  208000),
223         CORE_DVFS("sdmmc3",-1, 1, KHZ,   104000, 104000, 104000, 104000, 208000,  208000,  208000),
224         CORE_DVFS("ndflash",-1,1, KHZ,   110000, 166000, 166000, 166000, 166000,  166000,  166000),
225         CORE_DVFS("nor",   -1, 1, KHZ,   100000, 126000, 126000, 133000, 133000,  133000,  133000),
226         CORE_DVFS("sbc1",  -1, 1, KHZ,    40000,  60000,  60000,  60000, 100000,  100000,  100000),
227         CORE_DVFS("sbc2",  -1, 1, KHZ,    40000,  60000,  60000,  60000, 100000,  100000,  100000),
228         CORE_DVFS("sbc3",  -1, 1, KHZ,    40000,  60000,  60000,  60000, 100000,  100000,  100000),
229         CORE_DVFS("sbc4",  -1, 1, KHZ,    40000,  60000,  60000,  60000, 100000,  100000,  100000),
230         CORE_DVFS("sbc5",  -1, 1, KHZ,    40000,  60000,  60000,  60000, 100000,  100000,  100000),
231         CORE_DVFS("sbc6",  -1, 1, KHZ,    40000,  60000,  60000,  60000, 100000,  100000,  100000),
232         CORE_DVFS("tvo",   -1, 1, KHZ,        1, 297000, 297000, 297000, 297000,  297000,  297000),
233         CORE_DVFS("dsi",   -1, 1, KHZ,   430000, 430000, 430000, 430000, 500000,  500000,  500000),
234         CORE_DVFS("fuse_burn", -1, 1, KHZ,        0,      0,      0,  26000,  26000,   26000,   26000),
235
236         /*
237          * The clock rate for the display controllers that determines the
238          * necessary core voltage depends on a divider that is internal
239          * to the display block.  Disable auto-dvfs on the display clocks,
240          * and let the display driver call tegra_dvfs_set_rate manually
241          */
242         CORE_DVFS("disp1", -1, 0, KHZ,   120000, 120000, 120000, 120000, 190000,  190000,  190000),
243         CORE_DVFS("disp2", -1, 0, KHZ,   120000, 120000, 120000, 120000, 190000,  190000,  190000),
244 #endif
245 };
246
247
248 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
249 {
250         int ret;
251
252         ret = param_set_bool(arg, kp);
253         if (ret)
254                 return ret;
255
256         if (tegra_dvfs_core_disabled)
257                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_core);
258         else
259                 tegra_dvfs_rail_enable(&tegra3_dvfs_rail_vdd_core);
260
261         return 0;
262 }
263
264 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
265 {
266         int ret;
267
268         ret = param_set_bool(arg, kp);
269         if (ret)
270                 return ret;
271
272         if (tegra_dvfs_cpu_disabled)
273                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_cpu);
274         else
275                 tegra_dvfs_rail_enable(&tegra3_dvfs_rail_vdd_cpu);
276
277         return 0;
278 }
279
280 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
281 {
282         return param_get_bool(buffer, kp);
283 }
284
285 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
286         .set = tegra_dvfs_disable_core_set,
287         .get = tegra_dvfs_disable_get,
288 };
289
290 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
291         .set = tegra_dvfs_disable_cpu_set,
292         .get = tegra_dvfs_disable_get,
293 };
294
295 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
296         &tegra_dvfs_core_disabled, 0644);
297 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
298         &tegra_dvfs_cpu_disabled, 0644);
299
300 static void __init init_dvfs_one(struct dvfs *d, int nominal_mv_index)
301 {
302         int ret;
303         struct clk *c = tegra_get_clock_by_name(d->clk_name);
304
305         if (!c) {
306                 pr_debug("tegra3_dvfs: no clock found for %s\n",
307                         d->clk_name);
308                 return;
309         }
310
311         if (d->auto_dvfs) {
312                 /* Update max rate for auto-dvfs clocks */
313                 BUG_ON(!d->freqs[nominal_mv_index]);
314                 tegra_init_max_rate(
315                         c, d->freqs[nominal_mv_index] * d->freqs_mult);
316         }
317         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
318
319         ret = tegra_enable_dvfs_on_clk(c, d);
320         if (ret)
321                 pr_err("tegra3_dvfs: failed to enable dvfs on %s\n",
322                         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("tegra3_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          * Start with nominal level for the chips with this speedo_id. Then,
346          * make sure cpu nominal voltage is below core ("solve from cpu to
347          * core at nominal").
348          */
349         BUG_ON(speedo_id >= ARRAY_SIZE(cpu_speedo_nominal_millivolts));
350         mv = cpu_speedo_nominal_millivolts[speedo_id];
351         if (tegra3_dvfs_rail_vdd_core.nominal_millivolts)
352                 mv = min(mv, tegra3_dvfs_rail_vdd_core.nominal_millivolts +
353                         core_below_cpu);
354
355         /*
356          * Find matching cpu dvfs entry, and use it to determine index to the
357          * final nominal voltage, that satisfies the following requirements:
358          * - allows CPU to run at minimum of the maximum rates specified in
359          *   the dvfs entry and clock tree
360          * - does not violate cpu_to_core dependency as determined above
361          */
362         for (i = 0, j = 0; j <  ARRAY_SIZE(cpu_dvfs_table); j++) {
363                 d = &cpu_dvfs_table[j];
364                 if (match_dvfs_one(d, speedo_id, process_id)) {
365                         c = tegra_get_clock_by_name(d->clk_name);
366                         BUG_ON(!c);
367
368                         for (; i < MAX_DVFS_FREQS; i++) {
369                                 if ((d->freqs[i] == 0) ||
370                                     (cpu_millivolts[i] == 0) ||
371                                     (mv < cpu_millivolts[i]))
372                                         break;
373
374                                 if (c->max_rate <= d->freqs[i]*d->freqs_mult) {
375                                         i++;
376                                         break;
377                                 }
378                         }
379                         break;
380                 }
381         }
382
383         BUG_ON(i == 0);
384         if (j == (ARRAY_SIZE(cpu_dvfs_table) - 1))
385                 pr_err("tegra3_dvfs: WARNING!!!\n"
386                        "tegra3_dvfs: no cpu dvfs table found for chip speedo_id"
387                        " %d and process_id %d: set CPU rate limit at %lu\n"
388                        "tegra3_dvfs: WARNING!!!\n",
389                        speedo_id, process_id, d->freqs[i-1] * d->freqs_mult);
390
391         *cpu_dvfs = d;
392         return (i - 1);
393 }
394
395 static int __init get_core_nominal_mv_index(int speedo_id)
396 {
397         int i, mv;
398         int core_edp_limit = get_core_edp();
399
400         /*
401          * Start with nominal level for the chips with this speedo_id. Then,
402          * make sure core nominal voltage is below edp limit for the board
403          * (if edp limit is set).
404          */
405         BUG_ON(speedo_id >= ARRAY_SIZE(core_speedo_nominal_millivolts));
406         mv = core_speedo_nominal_millivolts[speedo_id];
407
408         if (core_edp_limit)
409                 mv = min(mv, core_edp_limit);
410
411         /* Round nominal level down to the nearest core scaling step */
412         for (i = 0; i < MAX_DVFS_FREQS; i++) {
413                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
414                         break;
415         }
416
417         if (i == 0) {
418                 pr_err("tegra3_dvfs: unable to adjust core dvfs table to"
419                        " nominal voltage %d\n", mv);
420                 return -ENOSYS;
421         }
422         return (i - 1);
423 }
424
425 void __init tegra_soc_init_dvfs(void)
426 {
427         int cpu_speedo_id = tegra_cpu_speedo_id();
428         int soc_speedo_id = tegra_soc_speedo_id();
429         int cpu_process_id = tegra_cpu_process_id();
430         int core_process_id = tegra_core_process_id();
431
432         int i;
433         int core_nominal_mv_index;
434         int cpu_nominal_mv_index;
435         struct dvfs *cpu_dvfs = NULL;
436
437 #ifndef CONFIG_TEGRA_CORE_DVFS
438         tegra_dvfs_core_disabled = true;
439 #endif
440 #ifndef CONFIG_TEGRA_CPU_DVFS
441         tegra_dvfs_cpu_disabled = true;
442 #endif
443
444         BUG_ON(VDD_SAFE_STEP > (cpu_below_core + core_below_cpu));
445
446         /*
447          * Find nominal voltages for core (1st) and cpu rails before rail
448          * init. Nominal voltage index in the scaling ladder will also be
449          * used to determine max dvfs frequency for the respective domains.
450          */
451         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
452         if (core_nominal_mv_index < 0) {
453                 tegra3_dvfs_rail_vdd_core.disabled = true;
454                 tegra_dvfs_core_disabled = true;
455                 core_nominal_mv_index = 0;
456         }
457         tegra3_dvfs_rail_vdd_core.nominal_millivolts =
458                 core_millivolts[core_nominal_mv_index];
459
460         cpu_nominal_mv_index = get_cpu_nominal_mv_index(
461                 cpu_speedo_id, cpu_process_id, &cpu_dvfs);
462         BUG_ON((cpu_nominal_mv_index < 0) || (!cpu_dvfs));
463         tegra3_dvfs_rail_vdd_cpu.nominal_millivolts =
464                 cpu_millivolts[cpu_nominal_mv_index];
465
466         /* Init rail structures and dependencies */
467         tegra_dvfs_init_rails(tegra3_dvfs_rails, ARRAY_SIZE(tegra3_dvfs_rails));
468         tegra_dvfs_add_relationships(tegra3_dvfs_relationships,
469                 ARRAY_SIZE(tegra3_dvfs_relationships));
470
471         /* Search core dvfs table for speedo/process matching entries and
472            initialize dvfs-ed clocks */
473         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
474                 struct dvfs *d = &core_dvfs_table[i];
475                 if (!match_dvfs_one(d, soc_speedo_id, core_process_id))
476                         continue;
477                 init_dvfs_one(d, core_nominal_mv_index);
478         }
479
480         /* Initialize matching cpu dvfs entry already found when nominal
481            voltage was determined */
482         init_dvfs_one(cpu_dvfs, cpu_nominal_mv_index);
483
484         /* Finally disable dvfs on rails if necessary */
485         if (tegra_dvfs_core_disabled)
486                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_core);
487         if (tegra_dvfs_cpu_disabled)
488                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_cpu);
489
490         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
491                 tegra3_dvfs_rail_vdd_cpu.nominal_millivolts,
492                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
493         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
494                 tegra3_dvfs_rail_vdd_core.nominal_millivolts,
495                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
496 }
497
498 /*
499  * sysfs interface to cap tegra dvsf domains frequencies
500  */
501 static struct kobject *cap_kobj;
502 static int core_cap_count;
503 static int core_cap_level;
504
505 /* Arranged in order required for enabling/lowering the cap */
506 static struct {
507         const char *cap_name;
508         struct clk *cap_clk;
509         unsigned long freqs[MAX_DVFS_FREQS];
510 } core_cap_table[] = {
511         { .cap_name = "cap.cbus" },
512         { .cap_name = "cap.sclk" },
513         { .cap_name = "cap.emc" },
514 };
515
516 static ssize_t
517 core_cap_state_show(struct kobject *kobj, struct kobj_attribute *attr,
518                     char *buf)
519 {
520         return sprintf(buf, "%d\n", core_cap_count ? 1 : 0);
521 }
522 static ssize_t
523 core_cap_state_store(struct kobject *kobj, struct kobj_attribute *attr,
524                      const char *buf, size_t count)
525 {
526         int i, state;
527
528         if (sscanf(buf, "%d", &state) != 1)
529                 return -1;
530
531         if (state) {
532                 core_cap_count++;
533                 for (i = 0; i < ARRAY_SIZE(core_cap_table); i++)
534                         if (core_cap_table[i].cap_clk)
535                                 clk_enable(core_cap_table[i].cap_clk);
536         } else if (core_cap_count) {
537                 core_cap_count--;
538                 for (i = ARRAY_SIZE(core_cap_table) - 1; i >= 0; i--)
539                         if (core_cap_table[i].cap_clk)
540                                 clk_disable(core_cap_table[i].cap_clk);
541         }
542         return count;
543 }
544
545 static ssize_t
546 core_cap_level_show(struct kobject *kobj, struct kobj_attribute *attr,
547                     char *buf)
548 {
549         return sprintf(buf, "%d\n", core_cap_level);
550 }
551 static ssize_t
552 core_cap_level_store(struct kobject *kobj, struct kobj_attribute *attr,
553                      const char *buf, size_t count)
554 {
555         int i, j, level;
556
557         if (sscanf(buf, "%d", &level) != 1)
558                 return -1;
559
560         for (j = 0; j < ARRAY_SIZE(core_millivolts); j++) {
561                 int v = core_millivolts[j];
562                 if ((v == 0) || (level < v))
563                         break;
564         }
565         j = (j == 0) ? : j - 1;
566         level = core_millivolts[j];
567
568         if (level < core_cap_level) {
569                 for (i = 0; i < ARRAY_SIZE(core_cap_table); i++)
570                         if (core_cap_table[i].cap_clk)
571                                 clk_set_rate(core_cap_table[i].cap_clk,
572                                              core_cap_table[i].freqs[j]);
573         } else if (level > core_cap_level) {
574                 for (i = ARRAY_SIZE(core_cap_table) - 1; i >= 0; i--)
575                         if (core_cap_table[i].cap_clk)
576                                 clk_set_rate(core_cap_table[i].cap_clk,
577                                              core_cap_table[i].freqs[j]);
578         }
579         core_cap_level = level;
580         return count;
581 }
582
583 static struct kobj_attribute cap_state_attribute =
584         __ATTR(core_cap_state, 0644, core_cap_state_show, core_cap_state_store);
585 static struct kobj_attribute cap_level_attribute =
586         __ATTR(core_cap_level, 0644, core_cap_level_show, core_cap_level_store);
587
588 const struct attribute *cap_attributes[] = {
589         &cap_state_attribute.attr,
590         &cap_level_attribute.attr,
591         NULL,
592 };
593
594 static int __init init_core_cap_one(struct clk *c, unsigned long *freqs)
595 {
596         int i, v, next_v;
597         unsigned long rate, next_rate = 0;
598
599         for (i = 0; i < ARRAY_SIZE(core_millivolts); i++) {
600                 v = core_millivolts[i];
601                 if (v == 0)
602                         break;
603
604                 for (;;) {
605                         rate = next_rate;
606                         next_rate = clk_round_rate(c, rate + 1000);
607                         if (IS_ERR_VALUE(next_rate)) {
608                                 pr_debug("tegra3_dvfs: failed to round %s"
609                                            " rate %lu", c->name, rate);
610                                 return -EINVAL;
611                         }
612                         if (rate == next_rate)
613                                 break;
614
615                         next_v = tegra_dvfs_predict_millivolts(
616                                 c->parent, next_rate);
617                         if (IS_ERR_VALUE(next_rate)) {
618                                 pr_debug("tegra3_dvfs: failed to predict %s mV"
619                                          " for rate %lu", c->name, next_rate);
620                                 return -EINVAL;
621                         }
622                         if (next_v > v)
623                                 break;
624                 }
625
626                 if (rate == 0) {
627                         rate = next_rate;
628                         pr_warn("tegra3_dvfs: minimum %s cap %lu requires"
629                                 " %d mV", c->name, rate, next_v);
630                 }
631                 freqs[i] = rate;
632                 next_rate = rate;
633         }
634         return 0;
635 }
636
637 static int __init tegra_dvfs_init_core_cap(void)
638 {
639         int i;
640         struct clk *c = NULL;
641
642         for (i = 0; i < ARRAY_SIZE(core_cap_table); i++) {
643                 c = tegra_get_clock_by_name(core_cap_table[i].cap_name);
644                 if (!c || !c->parent ||
645                     init_core_cap_one(c, core_cap_table[i].freqs)) {
646                         pr_err("tegra3_dvfs: failed to initialize %s frequency"
647                                " table", core_cap_table[i].cap_name);
648                         continue;
649                 }
650                 core_cap_table[i].cap_clk = c;
651         }
652         core_cap_level = tegra3_dvfs_rail_vdd_core.max_millivolts;
653
654         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
655         if (!cap_kobj) {
656                 pr_err("tegra3_dvfs: failed to create sysfs cap object");
657                 return 0;
658         }
659
660         if (sysfs_create_files(cap_kobj, cap_attributes)) {
661                 pr_err("tegra3_dvfs: failed to create sysfs cap interface");
662                 return 0;
663         }
664         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
665
666         return 0;
667 }
668 late_initcall(tegra_dvfs_init_core_cap);