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