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