ARM: Tegra12: Clocks: Update CPU dvfs table
[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 #include <linux/pm_qos.h>
25
26 #include "clock.h"
27 #include "dvfs.h"
28 #include "fuse.h"
29 #include "board.h"
30 #include "tegra_cl_dvfs.h"
31 #include "tegra_core_sysfs_limits.h"
32
33 static bool tegra_dvfs_cpu_disabled;
34 static bool tegra_dvfs_core_disabled;
35 static bool tegra_dvfs_gpu_disabled;
36
37 #define KHZ 1000
38 #define MHZ 1000000
39
40 /* FIXME: need tegra12 step */
41 #define VDD_SAFE_STEP                   100
42
43 static int vdd_core_therm_trips_table[MAX_THERMAL_LIMITS] = { 20, };
44 static int vdd_core_therm_floors_table[MAX_THERMAL_LIMITS] = { 950, };
45
46 static int vdd_gpu_therm_trips_table[MAX_THERMAL_LIMITS] = { 20, };
47 static int vdd_gpu_therm_floors_table[MAX_THERMAL_LIMITS] = { 900, };
48
49 static struct tegra_cooling_device cpu_cdev = {
50         .cdev_type = "cpu_cold",
51 };
52
53 static struct tegra_cooling_device core_cdev = {
54         .cdev_type = "core_cold",
55 };
56
57 static struct tegra_cooling_device gpu_cdev = {
58         .cdev_type = "gpu_cold",
59 };
60
61 static struct dvfs_rail tegra12_dvfs_rail_vdd_cpu = {
62         .reg_id = "vdd_cpu",
63         .max_millivolts = 1400,
64         .min_millivolts = 800,
65         .step = VDD_SAFE_STEP,
66         .jmp_to_zero = true,
67         .vmin_cdev = &cpu_cdev,
68         .alignment = {
69                 .step_uv = 10000, /* 10mV */
70         },
71         .stats = {
72                 .bin_uV = 10000, /* 10mV */
73         }
74 };
75
76 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
77         .reg_id = "vdd_core",
78         .max_millivolts = 1400,
79         .min_millivolts = 800,
80         .step = VDD_SAFE_STEP,
81         .vmin_cdev = &core_cdev,
82 };
83
84 /* TBD: fill in actual hw number */
85 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
86         .reg_id = "vdd_gpu",
87         .max_millivolts = 1350,
88         .min_millivolts = 700,
89         .step = VDD_SAFE_STEP,
90         .vmin_cdev = &gpu_cdev,
91         .alignment = {
92                 .step_uv = 10000, /* 10mV */
93         },
94         .stats = {
95                 .bin_uV = 10000, /* 10mV */
96         }
97 };
98
99 static struct dvfs_rail *tegra12_dvfs_rails[] = {
100         &tegra12_dvfs_rail_vdd_cpu,
101         &tegra12_dvfs_rail_vdd_core,
102         &tegra12_dvfs_rail_vdd_gpu,
103 };
104
105 void __init tegra12x_vdd_cpu_align(int step_uv, int offset_uv)
106 {
107         tegra12_dvfs_rail_vdd_cpu.alignment.step_uv = step_uv;
108         tegra12_dvfs_rail_vdd_cpu.alignment.offset_uv = offset_uv;
109 }
110
111 /* CPU DVFS tables */
112 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
113         {
114                 .speedo_id = 0,
115                 .process_id = -1,
116                 .dfll_tune_data  = {
117                         .tune0          = 0x00662FFF,
118                         .tune0_high_mv  = 0x006640FF,
119                         .tune1          = 0x0000006E,
120                         .droop_rate_min = 1000000,
121                         .tune_high_min_millivolts = 900,
122                         .min_millivolts = 800,
123                 },
124                 .max_mv = 1260,
125                 .freqs_mult = KHZ,
126                 .speedo_scale = 100,
127                 .voltage_scale = 1000,
128                 .cvb_table = {
129                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
130                         {306000  , {1141577,  -30185,  454}, { 777000   , 0, 0}},
131                         {408000  , {1180454,  -31625,  454}, { 787500   , 0, 0}},
132                         {510000  , {1221370,  -33065,  454}, { 798000   , 0, 0}},
133                         {612000  , {1264325,  -34505,  454}, { 819000   , 0, 0}},
134                         {714000  , {1309319,  -35945,  454}, { 840000   , 0, 0}},
135                         {816000  , {1356353,  -37385,  454}, { 850500   , 0, 0}},
136                         {918000  , {1405425,  -38825,  454}, { 882000   , 0, 0}},
137                         {1020000 , {1456537,  -40265,  454}, { 903000   , 0, 0}},
138                         {1122000 , {1509687,  -41705,  454}, { 934500   , 0, 0}},
139                         {1224000 , {1564877,  -43145,  454}, { 955500   , 0, 0}},
140                         {1326000 , {1622106,  -44585,  454}, { 987000   , 0, 0}},
141                         {1428000 , {1681374,  -46025,  454}, { 1029000  , 0, 0}},
142                         {1530000 , {1742681,  -47465,  454}, { 1060500  , 0, 0}},
143                         {1632000 , {1806027,  -48915,  454}, { 1102500  , 0, 0}},
144                         {1734000 , {1871412,  -50355,  454}, { 1134000  , 0, 0}},
145                         {1836000 , {1938836,  -51795,  454}, { 1176000  , 0, 0}},
146                         {1938000 , {2008300,  -53235,  454}, { 1228500  , 0, 0}},
147                         {2014500 , {2061382,  -54305,  454}, { 1260000  , 0, 0}},
148                         {      0 , {      0,       0,    0}, {       0  , 0, 0}},
149                 },
150                 .therm_trips_table = { 20, },
151                 .therm_floors_table = { 900, },
152         },
153         {
154                 .speedo_id = 1,
155                 .process_id = -1,
156                 .dfll_tune_data  = {
157                         .tune0          = 0x00662FFF,
158                         .tune0_high_mv  = 0x006640FF,
159                         .tune1          = 0x0000006E,
160                         .droop_rate_min = 1000000,
161                         .tune_high_min_millivolts = 900,
162                         .min_millivolts = 800,
163                 },
164                 .max_mv = 1260,
165                 .freqs_mult = KHZ,
166                 .speedo_scale = 100,
167                 .voltage_scale = 1000,
168                 .cvb_table = {
169                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
170                         {306000  , {1141577,  -30185,  454}, { 735000   , 0, 0}},
171                         {408000  , {1180454,  -31625,  454}, { 745500   , 0, 0}},
172                         {510000  , {1221370,  -33065,  454}, { 756000   , 0, 0}},
173                         {612000  , {1264325,  -34505,  454}, { 766500   , 0, 0}},
174                         {714000  , {1309319,  -35945,  454}, { 777000   , 0, 0}},
175                         {816000  , {1356353,  -37385,  454}, { 798000   , 0, 0}},
176                         {918000  , {1405425,  -38825,  454}, { 819000   , 0, 0}},
177                         {1020000 , {1456537,  -40265,  454}, { 840000   , 0, 0}},
178                         {1122000 , {1509687,  -41705,  454}, { 861000   , 0, 0}},
179                         {1224000 , {1564877,  -43145,  454}, { 882000   , 0, 0}},
180                         {1326000 , {1622106,  -44585,  454}, { 913500   , 0, 0}},
181                         {1428000 , {1681374,  -46025,  454}, { 945000   , 0, 0}},
182                         {1530000 , {1742681,  -47465,  454}, { 976500   , 0, 0}},
183                         {1632000 , {1806027,  -48915,  454}, { 1008000  , 0, 0}},
184                         {1734000 , {1871412,  -50355,  454}, { 1039500  , 0, 0}},
185                         {1836000 , {1938836,  -51795,  454}, { 1081500  , 0, 0}},
186                         {1938000 , {2008300,  -53235,  454}, { 1123500  , 0, 0}},
187                         {2014500 , {2061382,  -54305,  454}, { 1144500  , 0, 0}},
188                         {2116500 , {2134404,  -55745,  454}, { 1197000  , 0, 0}},
189                         {2218500 , {2209465,  -57185,  454}, { 1239000  , 0, 0}},
190                         {2320500 , {2286565,  -58625,  454}, { 1291500  , 0, 0}},
191                         {      0 , {      0,       0,    0}, {       0  , 0, 0}},
192                 },
193                 .therm_trips_table = { 20, },
194                 .therm_floors_table = { 900, },
195         },
196 };
197
198 static int cpu_millivolts[MAX_DVFS_FREQS];
199 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
200
201 static struct dvfs cpu_dvfs = {
202         .clk_name       = "cpu_g",
203         .millivolts     = cpu_millivolts,
204         .dfll_millivolts = cpu_dfll_millivolts,
205         .auto_dvfs      = true,
206         .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,
207 };
208
209 /* Core DVFS tables */
210 /* FIXME: real data */
211 static const int core_millivolts[MAX_DVFS_FREQS] = {
212         810, 860, 900, 1000, 1100};
213
214 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
215         {                                                       \
216                 .clk_name       = _clk_name,                    \
217                 .speedo_id      = _speedo_id,                   \
218                 .process_id     = _process_id,                  \
219                 .freqs          = {_freqs},                     \
220                 .freqs_mult     = _mult,                        \
221                 .millivolts     = core_millivolts,              \
222                 .auto_dvfs      = _auto,                        \
223                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
224         }
225
226 static struct dvfs core_dvfs_table[] = {
227         /* Core voltages (mV):                   810,    860,    900,    1000,    1100*/
228         /* Clock limits for internal blocks, PLLs */
229         CORE_DVFS("emc",    -1, -1, 1, KHZ,   264000, 348000, 384000, 528000,  924000),
230
231         CORE_DVFS("cpu_lp", -1, -1, 1, KHZ,   144000, 252000, 288000, 444000,  624000),
232
233         CORE_DVFS("sbus",   -1, -1, 1, KHZ,    81600, 102000, 136000, 204000,  204000),
234
235         CORE_DVFS("vic03",  -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
236         CORE_DVFS("tsec",   -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
237
238         CORE_DVFS("msenc",  -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
239         CORE_DVFS("se",     -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
240         CORE_DVFS("vde",    -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
241
242         CORE_DVFS("host1x", -1, -1, 1, KHZ,    81600, 102000, 136000, 163000,  204000),
243
244         CORE_DVFS("vi",     -1, -1, 1, KHZ,   120000, 156000, 182000, 312000,  444000),
245         CORE_DVFS("isp",    -1, -1, 1, KHZ,   120000, 156000, 182000, 312000,  444000),
246
247 #ifdef CONFIG_TEGRA_DUAL_CBUS
248         CORE_DVFS("c2bus",  -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
249         CORE_DVFS("c3bus",  -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
250 #else
251         CORE_DVFS("cbus",   -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
252 #endif
253         CORE_DVFS("c4bus",  -1, -1, 1, KHZ,   120000, 156000, 182000, 312000,  444000),
254
255         CORE_DVFS("pll_m",  -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
256         CORE_DVFS("pll_c",  -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
257         CORE_DVFS("pll_c2", -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
258         CORE_DVFS("pll_c3", -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
259
260         /* Core voltages (mV):                   810,    860,    900,    990,    1080*/
261         /* Clock limits for I/O peripherals */
262         CORE_DVFS("sbc1",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
263         CORE_DVFS("sbc2",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
264         CORE_DVFS("sbc3",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
265         CORE_DVFS("sbc4",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
266         CORE_DVFS("sbc5",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
267         CORE_DVFS("sbc6",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
268
269         CORE_DVFS("sdmmc1", -1, -1, 1, KHZ,   102000, 102000, 163200, 163200,  163200),
270         CORE_DVFS("sdmmc3", -1, -1, 1, KHZ,   102000, 102000, 163200, 163200,  163200),
271         CORE_DVFS("sdmmc4", -1, -1, 1, KHZ,   102000, 102000, 178200, 178200,  178200),
272
273         CORE_DVFS("hdmi",   -1, -1, 1, KHZ,    99000, 118800, 148500, 198000,  198000),
274         /* FIXME: Finalize these values for NOR after qual */
275         CORE_DVFS("nor",    -1, -1, 1, KHZ,   102000, 102000, 102000, 102000,  102000),
276
277         /*
278          * The clock rate for the display controllers that determines the
279          * necessary core voltage depends on a divider that is internal
280          * to the display block.  Disable auto-dvfs on the display clocks,
281          * and let the display driver call tegra_dvfs_set_rate manually
282          */
283         CORE_DVFS("disp1",  -1, -1, 0, KHZ,   108000, 120000, 144000, 297000,  474000),
284         CORE_DVFS("disp2",  -1, -1, 0, KHZ,   108000, 120000, 144000, 297000,  474000),
285
286         /* xusb clocks */
287         CORE_DVFS("xusb_falcon_src", -1, -1, 1, KHZ,  204000, 204000, 204000, 336000, 336000),
288         CORE_DVFS("xusb_host_src",   -1, -1, 1, KHZ,   58300,  58300,  58300, 112000, 112000),
289         CORE_DVFS("xusb_dev_src",    -1, -1, 1, KHZ,   58300,  58300,  58300, 112000, 112000),
290         CORE_DVFS("xusb_ss_src",     -1, -1, 1, KHZ,   60000,  60000,  60000, 120000, 120000),
291         CORE_DVFS("xusb_fs_src",     -1, -1, 1, KHZ,       0,  48000,  48000,  48000,  48000),
292         CORE_DVFS("xusb_hs_src",     -1, -1, 1, KHZ,       0,  60000,  60000,  60000,  60000),
293 };
294
295 /* TBD: fill in actual hw numbers */
296 static struct gpu_cvb_dvfs gpu_cvb_dvfs_table[] = {
297         {
298                 .speedo_id =   0,
299                 .process_id = -1,
300                 .max_mv = 1200,
301                 .min_mv = 800,
302                 .freqs_mult = KHZ,
303                 .speedo_scale = 100,
304                 .voltage_scale = 1000,
305                 .cvb_table = {
306                         /*f        dfll  pll:   c0,     c1,   c2 */
307                         {   72000, {  }, {  975248, -10755,  -56}, },
308                         {  108000, {  }, {  995948, -11645,  -56}, },
309                         {  180000, {  }, { 1041350, -13415,  -56}, },
310                         {  252000, {  }, { 1092088, -15195,  -56}, },
311                         {  324000, {  }, { 1148163, -16975,  -56}, },
312                         {  396000, {  }, { 1209574, -18745,  -56}, },
313                         {  468000, {  }, { 1276322, -20525,  -56}, },
314                         {  540000, {  }, { 1348406, -22295,  -56}, },
315                         {  612000, {  }, { 1425827, -24075,  -56}, },
316                         {  636000, {  }, { 1452819, -24665,  -56}, },
317                         {  684000, {  }, { 1508583, -25855,  -56}, },
318                         {  708000, {  }, { 1537355, -26445,  -56}, },
319                         {       0, {  }, {       0,      0,   0}, },
320                 },
321         },
322         {
323                 .speedo_id =   1,
324                 .process_id = -1,
325                 .max_mv = 1200,
326                 .min_mv = 800,
327                 .freqs_mult = KHZ,
328                 .speedo_scale = 100,
329                 .voltage_scale = 1000,
330                 .cvb_table = {
331                         /*f        dfll  pll:   c0,     c1,   c2 */
332                         {   72000, {  }, {  975248, -10755,  -56}, },
333                         {  108000, {  }, {  995948, -11645,  -56}, },
334                         {  180000, {  }, { 1041350, -13415,  -56}, },
335                         {  252000, {  }, { 1092088, -15195,  -56}, },
336                         {  324000, {  }, { 1148163, -16975,  -56}, },
337                         {  396000, {  }, { 1209574, -18745,  -56}, },
338                         {  468000, {  }, { 1276322, -20525,  -56}, },
339                         {  540000, {  }, { 1348406, -22295,  -56}, },
340                         {  612000, {  }, { 1425827, -24075,  -56}, },
341                         {  636000, {  }, { 1452819, -24665,  -56}, },
342                         {  684000, {  }, { 1508583, -25855,  -56}, },
343                         {  708000, {  }, { 1537355, -26445,  -56}, },
344                         {  756000, {  }, { 1596677, -27625,  -56}, },
345                         {  804000, {  }, { 1658370, -28815,  -56}, },
346                         {       0, {  }, {       0,      0,   0}, },
347                 },
348         }
349 };
350
351 static int gpu_millivolts[MAX_DVFS_FREQS];
352 static struct dvfs gpu_dvfs = {
353         .clk_name       = "gbus",
354         .millivolts     = gpu_millivolts,
355         .auto_dvfs      = true,
356         .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,
357 };
358
359 int read_gpu_dvfs_table(int **millivolts, unsigned long **freqs)
360 {
361         *millivolts = gpu_dvfs.millivolts;
362         *freqs = gpu_dvfs.freqs;
363
364         return 0;
365 }
366 EXPORT_SYMBOL(read_gpu_dvfs_table);
367
368 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
369 {
370         int ret;
371
372         ret = param_set_bool(arg, kp);
373         if (ret)
374                 return ret;
375
376         if (tegra_dvfs_core_disabled)
377                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
378         else
379                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
380
381         return 0;
382 }
383
384 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
385 {
386         int ret;
387
388         ret = param_set_bool(arg, kp);
389         if (ret)
390                 return ret;
391
392         if (tegra_dvfs_cpu_disabled)
393                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
394         else
395                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
396
397         return 0;
398 }
399
400 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
401 {
402         int ret;
403
404         ret = param_set_bool(arg, kp);
405         if (ret)
406                 return ret;
407
408         if (tegra_dvfs_gpu_disabled)
409                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
410         else
411                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
412
413         return 0;
414 }
415
416 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
417 {
418         return param_get_bool(buffer, kp);
419 }
420
421 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
422         .set = tegra_dvfs_disable_core_set,
423         .get = tegra_dvfs_disable_get,
424 };
425
426 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
427         .set = tegra_dvfs_disable_cpu_set,
428         .get = tegra_dvfs_disable_get,
429 };
430
431 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
432         .set = tegra_dvfs_disable_gpu_set,
433         .get = tegra_dvfs_disable_get,
434 };
435
436 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
437         &tegra_dvfs_core_disabled, 0644);
438 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
439         &tegra_dvfs_cpu_disabled, 0644);
440 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
441         &tegra_dvfs_gpu_disabled, 0644);
442
443 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
444 {
445         /* Don't update manual dvfs clocks */
446         if (!d->auto_dvfs)
447                 return false;
448
449         /*
450          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
451          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
452          * together with the image) and board specific EMC DFS table; we will
453          * check the scaling ladder against nominal core voltage when the table
454          * is loaded (and if on particular board the table is not loaded, EMC
455          * scaling is disabled).
456          */
457         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
458                 return false;
459
460         /*
461          * Don't update shared cbus, and don't propagate common cbus dvfs
462          * limit down to shared users, but set maximum rate for each user
463          * equal to the respective client limit.
464          */
465         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
466                 struct clk *user;
467                 unsigned long rate;
468
469                 list_for_each_entry(
470                         user, &c->shared_bus_list, u.shared_bus_user.node) {
471                         if (user->u.shared_bus_user.client) {
472                                 rate = user->u.shared_bus_user.client->max_rate;
473                                 user->max_rate = rate;
474                                 user->u.shared_bus_user.rate = rate;
475                         }
476                 }
477                 return false;
478         }
479
480         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
481         return true;
482 }
483
484 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
485 {
486         int ret;
487         struct clk *c = tegra_get_clock_by_name(d->clk_name);
488
489         if (!c) {
490                 pr_debug("tegra12_dvfs: no clock found for %s\n",
491                         d->clk_name);
492                 return;
493         }
494
495         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
496         if (can_update_max_rate(c, d)) {
497                 BUG_ON(!d->freqs[max_freq_index]);
498                 tegra_init_max_rate(
499                         c, d->freqs[max_freq_index] * d->freqs_mult);
500         }
501         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
502
503         ret = tegra_enable_dvfs_on_clk(c, d);
504         if (ret)
505                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
506 }
507
508 static bool __init match_dvfs_one(const char *name,
509         int dvfs_speedo_id, int dvfs_process_id,
510         int speedo_id, int process_id)
511 {
512         if ((dvfs_process_id != -1 && dvfs_process_id != process_id) ||
513                 (dvfs_speedo_id != -1 && dvfs_speedo_id != speedo_id)) {
514                 pr_debug("tegra12_dvfs: rejected %s speedo %d, process %d\n",
515                          name, dvfs_speedo_id, dvfs_process_id);
516                 return false;
517         }
518         return true;
519 }
520
521 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
522 static inline int get_cvb_voltage(int speedo, int s_scale,
523                                   struct cvb_dvfs_parameters *cvb)
524 {
525         /* apply only speedo scale: output mv = cvb_mv * v_scale */
526         int mv;
527         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
528         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
529         return mv;
530 }
531
532 static int round_cvb_voltage(int mv, int v_scale, struct rail_alignment *align)
533 {
534         /* combined: apply voltage scale and round to cvb alignment step */
535         int uv;
536         int step = (align->step_uv ? : 1000) * v_scale;
537         int offset = align->offset_uv * v_scale;
538
539         uv = max(mv * 1000, offset) - offset;
540         uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;
541         return uv / 1000;
542 }
543
544 static int __init set_cpu_dvfs_data(
545         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
546 {
547         int i, j, mv, dfll_mv, min_dfll_mv;
548         unsigned long fmax_at_vmin = 0;
549         unsigned long fmax_pll_mode = 0;
550         unsigned long fmin_use_dfll = 0;
551         struct cvb_dvfs_table *table = NULL;
552         int speedo = tegra_cpu_speedo_value();
553         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_cpu.alignment;
554
555         min_dfll_mv = d->dfll_tune_data.min_millivolts;
556         min_dfll_mv =  round_cvb_voltage(min_dfll_mv * 1000, 1000, align);
557         d->max_mv = round_cvb_voltage(d->max_mv * 1000, 1000, align);
558         BUG_ON(min_dfll_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
559
560         /*
561          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
562          * CVB entry specifies CPU frequency and CVB coefficients to calculate
563          * the respective voltage when either DFLL or PLL is used as CPU clock
564          * source.
565          *
566          * Minimum voltage limit is applied only to DFLL source. For PLL source
567          * voltage can go as low as table specifies. Maximum voltage limit is
568          * applied to both sources, but differently: directly clip voltage for
569          * DFLL, and limit maximum frequency for PLL.
570          */
571         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
572                 table = &d->cvb_table[i];
573                 if (!table->freq)
574                         break;
575
576                 dfll_mv = get_cvb_voltage(
577                         speedo, d->speedo_scale, &table->cvb_dfll_param);
578                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale, align);
579
580                 mv = get_cvb_voltage(
581                         speedo, d->speedo_scale, &table->cvb_pll_param);
582                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
583
584                 /*
585                  * Check maximum frequency at minimum voltage for dfll source;
586                  * round down unless all table entries are above Vmin, then use
587                  * the 1st entry as is.
588                  */
589                 dfll_mv = max(dfll_mv, min_dfll_mv);
590                 if (dfll_mv > min_dfll_mv) {
591                         if (!j)
592                                 fmax_at_vmin = table->freq;
593                         if (!fmax_at_vmin)
594                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
595                 }
596
597                 /* Clip maximum frequency at maximum voltage for pll source */
598                 if (mv > d->max_mv) {
599                         if (!j)
600                                 break;  /* 1st entry already above Vmax */
601                         if (!fmax_pll_mode)
602                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
603                 }
604
605                 /* Minimum rate with pll source voltage above dfll Vmin */
606                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
607                         fmin_use_dfll = table->freq;
608
609                 /* fill in dvfs tables */
610                 cpu_dvfs->freqs[j] = table->freq;
611                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
612                 cpu_millivolts[j] = mv;
613                 j++;
614
615                 /*
616                  * "Round-up" frequency list cut-off (keep first entry that
617                  *  exceeds max voltage - the voltage limit will be enforced
618                  *  anyway, so when requested this frequency dfll will settle
619                  *  at whatever high frequency it can on the particular chip)
620                  */
621                 if (dfll_mv > d->max_mv)
622                         break;
623         }
624
625         /* Table must not be empty, must have at least one entry above Vmin */
626         if (!i || !j || !fmax_at_vmin) {
627                 pr_err("tegra12_dvfs: invalid cpu dvfs table\n");
628                 return -ENOENT;
629         }
630
631         /* In the dfll operating range dfll voltage at any rate should be
632            better (below) than pll voltage */
633         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
634                 WARN(1, "tegra12_dvfs: pll voltage is below dfll in the dfll"
635                         " operating range\n");
636                 fmin_use_dfll = fmax_at_vmin;
637         }
638
639         /* dvfs tables are successfully populated - fill in the rest */
640         cpu_dvfs->speedo_id = d->speedo_id;
641         cpu_dvfs->process_id = d->process_id;
642         cpu_dvfs->freqs_mult = d->freqs_mult;
643         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
644                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
645         *max_freq_index = j - 1;
646
647         cpu_dvfs->dfll_data = d->dfll_tune_data;
648         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
649                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
650         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
651         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
652         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
653
654         return 0;
655 }
656
657 static int __init set_gpu_dvfs_data(
658         struct gpu_cvb_dvfs *d, struct dvfs *gpu_dvfs, int *max_freq_index)
659 {
660         int i, mv;
661         struct cvb_dvfs_table *table = NULL;
662         int speedo = tegra_gpu_speedo_value();
663         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_gpu.alignment;
664
665         d->max_mv = round_cvb_voltage(d->max_mv * 1000, 1000, align);
666         d->min_mv = round_cvb_voltage(d->min_mv * 1000, 1000, align);
667         BUG_ON(d->min_mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
668
669         /*
670          * Use CVB table to fill in gpu dvfs frequencies and voltages. Each
671          * CVB entry specifies gpu frequency and CVB coefficients to calculate
672          * the respective voltage.
673          */
674         for (i = 0; i < MAX_DVFS_FREQS; i++) {
675                 table = &d->cvb_table[i];
676                 if (!table->freq)
677                         break;
678
679                 mv = get_cvb_voltage(
680                         speedo, d->speedo_scale, &table->cvb_pll_param);
681                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
682
683                 if (mv > d->max_mv)
684                         break;
685
686                 /* fill in gpu dvfs tables */
687                 mv = max(mv, d->min_mv);
688                 gpu_millivolts[i] = mv;
689                 gpu_dvfs->freqs[i] = table->freq;
690         }
691         /* Table must not be empty, must have at least one entry in range */
692         if (!i || (gpu_millivolts[i - 1] <
693                    tegra12_dvfs_rail_vdd_gpu.min_millivolts)) {
694                 pr_err("tegra14_dvfs: invalid gpu dvfs table\n");
695                 return -ENOENT;
696         }
697
698         /* dvfs tables are successfully populated - fill in the gpu dvfs */
699         gpu_dvfs->speedo_id = d->speedo_id;
700         gpu_dvfs->process_id = d->process_id;
701         gpu_dvfs->freqs_mult = d->freqs_mult;
702         gpu_dvfs->dvfs_rail->nominal_millivolts =
703                 min(d->max_mv, gpu_millivolts[i - 1]);
704
705         *max_freq_index = i - 1;
706         return 0;
707 }
708
709 static int __init get_core_nominal_mv_index(int speedo_id)
710 {
711         int i;
712         int mv = tegra_core_speedo_mv();
713         int core_edp_voltage = get_core_edp();
714
715         /*
716          * Start with nominal level for the chips with this speedo_id. Then,
717          * make sure core nominal voltage is below edp limit for the board
718          * (if edp limit is set).
719          */
720         if (!core_edp_voltage)
721                 core_edp_voltage = 1100;        /* default 1.1V EDP limit */
722
723         mv = min(mv, core_edp_voltage);
724
725         /* Round nominal level down to the nearest core scaling step */
726         for (i = 0; i < MAX_DVFS_FREQS; i++) {
727                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
728                         break;
729         }
730
731         if (i == 0) {
732                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
733                        " nominal voltage %d\n", mv);
734                 return -ENOSYS;
735         }
736         return i - 1;
737 }
738
739 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
740                          bool before_clk_update, int cpu_event)
741 {
742         /* empty definition for tegra12 */
743         return 0;
744 }
745
746 void __init tegra12x_init_dvfs(void)
747 {
748         int cpu_speedo_id = tegra_cpu_speedo_id();
749         int cpu_process_id = tegra_cpu_process_id();
750         int soc_speedo_id = tegra_soc_speedo_id();
751         int core_process_id = tegra_core_process_id();
752         int gpu_speedo_id = tegra_gpu_speedo_id();
753         int gpu_process_id = tegra_gpu_process_id();
754
755         int i, ret;
756         int core_nominal_mv_index;
757         int gpu_max_freq_index = 0;
758         int cpu_max_freq_index = 0;
759
760 #ifndef CONFIG_TEGRA_CORE_DVFS
761         tegra_dvfs_core_disabled = true;
762 #endif
763 #ifndef CONFIG_TEGRA_CPU_DVFS
764         tegra_dvfs_cpu_disabled = true;
765 #endif
766 #ifndef CONFIG_TEGRA_GPU_DVFS
767         tegra_dvfs_gpu_disabled = true;
768 #endif
769 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
770         if (!tegra_platform_is_silicon()) {
771                 tegra_dvfs_core_disabled = true;
772                 tegra_dvfs_cpu_disabled = true;
773         }
774 #endif
775
776         /*
777          * Find nominal voltages for core (1st) and cpu rails before rail
778          * init. Nominal voltage index in core scaling ladder can also be
779          * used to determine max dvfs frequencies for all core clocks. In
780          * case of error disable core scaling and set index to 0, so that
781          * core clocks would not exceed rates allowed at minimum voltage.
782          */
783         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
784         if (core_nominal_mv_index < 0) {
785                 tegra12_dvfs_rail_vdd_core.disabled = true;
786                 tegra_dvfs_core_disabled = true;
787                 core_nominal_mv_index = 0;
788         }
789         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
790                 core_millivolts[core_nominal_mv_index];
791
792         /*
793          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
794          * voltage for cpu rail, and cpu maximum frequency. Note that entire
795          * frequency range is guaranteed only when dfll is used as cpu clock
796          * source. Reaching maximum frequency with pll as cpu clock source
797          * may not be possible within nominal voltage range (dvfs mechanism
798          * would automatically fail frequency request in this case, so that
799          * voltage limit is not violated). Error when cpu dvfs table can not
800          * be constructed must never happen.
801          */
802         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
803                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
804                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
805                                    cpu_speedo_id, cpu_process_id)) {
806                         ret = set_cpu_dvfs_data(
807                                 d, &cpu_dvfs, &cpu_max_freq_index);
808                         break;
809                 }
810         }
811         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
812
813         /*
814          * Setup gpu dvfs tables from cvb data, determine nominal voltage for
815          * gpu rail, and gpu maximum frequency. Error when gpu dvfs table can
816          * not be constructed must never happen.
817          */
818         for (ret = 0, i = 0; i < ARRAY_SIZE(gpu_cvb_dvfs_table); i++) {
819                 struct gpu_cvb_dvfs *d = &gpu_cvb_dvfs_table[i];
820                 if (match_dvfs_one("gpu cvb", d->speedo_id, d->process_id,
821                                    gpu_speedo_id, gpu_process_id)) {
822                         ret = set_gpu_dvfs_data(
823                                 d, &gpu_dvfs, &gpu_max_freq_index);
824                         break;
825                 }
826         }
827         BUG_ON((i == ARRAY_SIZE(gpu_cvb_dvfs_table)) || ret);
828
829         /* Init thermal floors */
830         /* FIXME: Uncomment when proper values are available later */
831         /* init_rail_thermal_profile(cpu_cvb_dvfs_table[i].therm_trips_table,
832                 cpu_cvb_dvfs_table[i].therm_floors_table,
833                 &tegra12_dvfs_rail_vdd_cpu, &cpu_dvfs.dfll_data);
834         init_rail_thermal_profile(vdd_core_therm_trips_table,
835                 vdd_core_therm_floors_table, &tegra12_dvfs_rail_vdd_core, NULL);*/
836         tegra_dvfs_rail_init_vmin_thermal_profile(vdd_gpu_therm_trips_table,
837                 vdd_gpu_therm_floors_table, &tegra12_dvfs_rail_vdd_gpu, NULL);
838
839         /* Init rail structures and dependencies */
840         tegra_dvfs_init_rails(tegra12_dvfs_rails,
841                 ARRAY_SIZE(tegra12_dvfs_rails));
842
843         /* Search core dvfs table for speedo/process matching entries and
844            initialize dvfs-ed clocks */
845         if (!tegra_platform_is_linsim()) {
846                 for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
847                         struct dvfs *d = &core_dvfs_table[i];
848                         if (!match_dvfs_one(d->clk_name, d->speedo_id,
849                                 d->process_id, soc_speedo_id, core_process_id))
850                                 continue;
851                         init_dvfs_one(d, core_nominal_mv_index);
852                 }
853         }
854
855         /* Initialize matching gpu dvfs entry already found when nominal
856            voltage was determined */
857         init_dvfs_one(&gpu_dvfs, gpu_max_freq_index);
858
859         /* Initialize matching cpu dvfs entry already found when nominal
860            voltage was determined */
861         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
862
863         /* Finally disable dvfs on rails if necessary */
864         if (tegra_dvfs_core_disabled)
865                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
866         if (tegra_dvfs_cpu_disabled)
867                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
868         if (tegra_dvfs_gpu_disabled)
869                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
870
871         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
872                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
873                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
874         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
875                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
876                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
877         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
878                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
879                 tegra_dvfs_gpu_disabled ? "disabled" : "enabled");
880 }
881
882 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
883 {
884         return 0;
885 }
886
887 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
888 {
889         return 0;
890 }
891
892 /* Core voltage and bus cap object and tables */
893 static struct kobject *cap_kobj;
894 static struct kobject *gpu_kobj;
895
896 static struct core_dvfs_cap_table tegra12_core_cap_table[] = {
897 #ifdef CONFIG_TEGRA_DUAL_CBUS
898         { .cap_name = "cap.c2bus" },
899         { .cap_name = "cap.c3bus" },
900 #else
901         { .cap_name = "cap.cbus" },
902 #endif
903         { .cap_name = "cap.sclk" },
904         { .cap_name = "cap.emc" },
905         { .cap_name = "cap.host1x" },
906 };
907
908 static struct core_bus_limit_table tegra12_gpu_cap_syfs = {
909         .limit_clk_name = "cap.profile.gbus",
910         .refcnt_attr = {.attr = {.name = "gpu_cap_state", .mode = 0644} },
911         .level_attr  = {.attr = {.name = "gpu_cap_level", .mode = 0644} },
912         .pm_qos_class = PM_QOS_GPU_FREQ_MAX,
913 };
914
915 static struct core_bus_limit_table tegra12_gpu_floor_sysfs = {
916         .limit_clk_name = "floor.profile.gbus",
917         .refcnt_attr = {.attr = {.name = "gpu_floor_state", .mode = 0644} },
918         .level_attr  = {.attr = {.name = "gpu_floor_level", .mode = 0644} },
919         .pm_qos_class = PM_QOS_GPU_FREQ_MIN,
920 };
921
922 static struct core_bus_rates_table tegra12_gpu_rates_sysfs = {
923         .bus_clk_name = "gbus",
924         .rate_attr = {.attr = {.name = "gpu_rate", .mode = 0444} },
925         .available_rates_attr = {
926                 .attr = {.name = "gpu_available_rates", .mode = 0444} },
927 };
928
929 static int __init tegra12_dvfs_init_core_cap(void)
930 {
931         int ret;
932
933         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
934         if (!cap_kobj) {
935                 pr_err("tegra12_dvfs: failed to create sysfs cap object\n");
936                 return 0;
937         }
938
939         ret = tegra_init_core_cap(
940                 tegra12_core_cap_table, ARRAY_SIZE(tegra12_core_cap_table),
941                 core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
942
943         if (ret) {
944                 pr_err("tegra12_dvfs: failed to init core cap interface (%d)\n",
945                        ret);
946                 kobject_del(cap_kobj);
947                 return 0;
948         }
949         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
950
951         gpu_kobj = kobject_create_and_add("tegra_gpu", kernel_kobj);
952         if (!gpu_kobj) {
953                 pr_err("tegra12_dvfs: failed to create sysfs gpu object\n");
954                 return 0;
955         }
956
957         ret = tegra_init_shared_bus_cap(&tegra12_gpu_cap_syfs,
958                                         1, gpu_kobj);
959         if (ret) {
960                 pr_err("tegra12_dvfs: failed to init gpu cap interface (%d)\n",
961                        ret);
962                 kobject_del(gpu_kobj);
963                 return 0;
964         }
965
966         ret = tegra_init_shared_bus_floor(&tegra12_gpu_floor_sysfs,
967                                           1, gpu_kobj);
968         if (ret) {
969                 pr_err("tegra12_dvfs: failed to init gpu floor interface (%d)\n",
970                        ret);
971                 kobject_del(gpu_kobj);
972                 return 0;
973         }
974
975         ret = tegra_init_sysfs_shared_bus_rate(&tegra12_gpu_rates_sysfs,
976                                                1, gpu_kobj);
977         if (ret) {
978                 pr_err("tegra12_dvfs: failed to init gpu rates interface (%d)\n",
979                        ret);
980                 kobject_del(gpu_kobj);
981                 return 0;
982         }
983         pr_info("tegra dvfs: tegra sysfs gpu interface is initialized\n");
984
985         return 0;
986 }
987 late_initcall(tegra12_dvfs_init_core_cap);