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