dvfs: tegra21: Rename thermal safe maximum frequency
[linux-3.10.git] / drivers / platform / tegra / tegra21_dvfs.c
1 /*
2  * drivers/platform/tegra/tegra21_dvfs.c
3  *
4  * Copyright (c) 2012-2014 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/tegra-fuse.h>
25 #include <linux/pm_qos.h>
26
27 #include <linux/platform/tegra/clock.h>
28 #include <linux/platform/tegra/dvfs.h>
29 #include "board.h"
30 #include <linux/platform/tegra/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 tegra21 step */
41 #define VDD_SAFE_STEP                   100
42
43 /* FIXME: tegra21 data */
44 static int vdd_core_vmin_trips_table[MAX_THERMAL_LIMITS];
45 static int vdd_core_therm_floors_table[MAX_THERMAL_LIMITS];
46
47 static int vdd_core_vmax_trips_table[MAX_THERMAL_LIMITS];
48 static int vdd_core_therm_caps_table[MAX_THERMAL_LIMITS];
49
50 static struct tegra_cooling_device core_vmax_cdev = {
51         .cdev_type = "core_hot",
52 };
53
54 static struct tegra_cooling_device core_vmin_cdev = {
55         .cdev_type = "core_cold",
56 };
57
58 static struct tegra_cooling_device gpu_vts_cdev = {
59         .cdev_type = "gpu_scaling",
60 };
61
62 /* FIXME: fill in actual hw numbers for all rails */
63 static struct dvfs_rail tegra21_dvfs_rail_vdd_cpu = {
64         .reg_id = "vdd_cpu",
65         .max_millivolts = 1300,
66         .step = VDD_SAFE_STEP,
67         .jmp_to_zero = true,
68         .alignment = {
69                 .step_uv = 6250, /* 6.25mV */
70         },
71         .stats = {
72                 .bin_uV = 6250, /* 6.25mV */
73         },
74         .version = "p4v06",
75 };
76
77 static struct dvfs_rail tegra21_dvfs_rail_vdd_core = {
78         .reg_id = "vdd_core",
79         .max_millivolts = 1300,
80         .min_millivolts = 900,
81         .step = VDD_SAFE_STEP,
82         .step_up = 1300,
83         .vmin_cdev = &core_vmin_cdev,
84         .vmax_cdev = &core_vmax_cdev,
85         .alignment = {
86                 .step_uv = 6250, /* 6.25mV */
87         },
88         .version = "Safe p4v10",
89 };
90
91 static struct dvfs_rail tegra21_dvfs_rail_vdd_gpu = {
92         .reg_id = "vdd_gpu",
93         .max_millivolts = 1300,
94         .step = VDD_SAFE_STEP,
95         .step_up = 1300,
96         .in_band_pm = true,
97         .vts_cdev = &gpu_vts_cdev,
98         .alignment = {
99                 .step_uv = 6250, /* 6.25mV */
100         },
101         .stats = {
102                 .bin_uV = 6250, /* 6.25mV */
103         },
104         .version = "p4v06",
105 };
106
107 static struct dvfs_rail *tegra21_dvfs_rails[] = {
108         &tegra21_dvfs_rail_vdd_cpu,
109         &tegra21_dvfs_rail_vdd_core,
110         &tegra21_dvfs_rail_vdd_gpu,
111 };
112
113 void __init tegra21x_vdd_cpu_align(int step_uv, int offset_uv)
114 {
115         tegra21_dvfs_rail_vdd_cpu.alignment.step_uv = step_uv;
116         tegra21_dvfs_rail_vdd_cpu.alignment.offset_uv = offset_uv;
117 }
118
119 /* FIXME: Remove after bringup */
120 #define BRINGUP_CVB_V_MARGIN    25
121 #define BRINGUP_CVB_V_MARGIN_EX 5
122
123 /* CPU DVFS tables */
124 /* FIXME: real data */
125 static unsigned long cpu_max_freq[] = {
126 /* speedo_id    0        */
127                 2040000,
128 };
129
130 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
131         {
132                 .speedo_id = -1,
133                 .process_id = -1,
134                 .dfll_tune_data  = {
135                         .tune0          = 0x0000A0FF,
136                         .tune1          = 0x0222F1D3,
137                         .droop_rate_min = 1000000,
138                         .min_millivolts = 950,
139                 },
140                 .pll_tune_data = {
141                         .min_millivolts = 950,
142                 },
143                 .max_mv = 1170,
144                 .freqs_mult = KHZ,
145                 .speedo_scale = 100,
146                 .voltage_scale = 1000,
147                 .cvb_table = {
148                         /*f       dfll:  c0,     c1,   c2  pll:       c0,       c1,      c2 */
149                         {204000 , { 1065698, -27085,  411 }, {  0       ,  0      ,  0     } },
150                         {306000 , { 1106138, -28305,  411 }, {  0       ,  0      ,  0     } },
151                         {408000 , { 1148390, -29525,  411 }, {  0       ,  0      ,  0     } },
152                         {510000 , { 1192454, -30745,  411 }, {  0       ,  0      ,  0     } },
153                         {612000 , { 1238328, -31965,  411 }, {  0       ,  0      ,  0     } },
154                         {714000 , { 1286014, -33185,  411 }, {  0       ,  0      ,  0     } },
155                         {816000 , { 1335511, -34405,  411 }, {  0       ,  0      ,  0     } },
156                         {918000 , { 1386819, -35625,  411 }, {  0       ,  0      ,  0     } },
157                         {1020000, { 1439939, -36845,  411 }, { -2875621 ,  358099 , -8585  } },
158                         {1122000, { 1494870, -38075,  411 }, { -52225   ,  104159 , -2816  } },
159                         {1224000, { 1551612, -39295,  411 }, {  1076868 ,  8356   , -727   } },
160                         {1326000, { 1610165, -40515,  411 }, {  2208191 , -84659  ,  1240  } },
161                         {1428000, { 1670530, -41735,  411 }, {  2519460 , -105063 ,  1611  } },
162                         {1530000, { 1732705, -42955,  411 }, {  2639809 , -108729 ,  1626  } },
163                         {1632000, { 1796692, -44175,  411 }, {  2889664 , -122173 ,  1834  } },
164                         {1734000, { 1862491, -45395,  411 }, {  3386160 , -154021 ,  2393  } },
165                         {1836000, { 1930100, -46615,  411 }, {  5100873 , -279186 ,  4747  } },
166                         {      0, {        0,     0,   0  }, {         0,        0,       0} },
167                 },
168         },
169 };
170
171 static int cpu_millivolts[MAX_DVFS_FREQS];
172 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
173
174 static struct dvfs cpu_dvfs = {
175         .clk_name       = "cpu_g",
176         .millivolts     = cpu_millivolts,
177         .dfll_millivolts = cpu_dfll_millivolts,
178         .auto_dvfs      = true,
179         .dvfs_rail      = &tegra21_dvfs_rail_vdd_cpu,
180 };
181
182 /* CPU LP DVFS tables */
183 /* FIXME: real data */
184 static unsigned long cpu_lp_max_freq[] = {
185 /* speedo_id    0        */
186                 1300000,
187 };
188
189 static struct cpu_cvb_dvfs cpu_lp_cvb_dvfs_table[] = {
190         {
191                 .speedo_id = -1,
192                 .process_id = -1,
193                 .pll_tune_data = {
194                         .min_millivolts = 950,
195                 },
196                 .max_mv = 1170,
197                 .freqs_mult = KHZ,
198                 .speedo_scale = 100,
199                 .voltage_scale = 1000,
200                 .cvb_table = {
201                         /*f        dfll  pll:   c0,    c1,     c2 */
202                         { 204000 , {  }, { 706791 , 21825, -1033 } },
203                         { 307200 , {  }, { 750523 , 20835, -1033 } },
204                         { 409600 , {  }, { 798465 , 19835, -1033 } },
205                         { 512000 , {  }, { 850618 , 18845, -1033 } },
206                         { 614400 , {  }, { 906981 , 17845, -1033 } },
207                         { 716800 , {  }, { 967554 , 16855, -1033 } },
208                         { 819200 , {  }, { 1032338, 15855, -1033 } },
209                         { 921600 , {  }, { 1101333, 14865, -1033 } },
210                         { 1024000, {  }, { 1174537, 13875, -1033 } },
211                         { 1126400, {  }, { 1251952, 12875, -1033 } },
212                         { 1228800, {  }, { 1333578, 11885, -1033 } },
213                         { 1280000, {  }, { 1375970, 11385, -1033 } },
214                         {       0, {  }, { } },
215                 },
216         },
217 };
218
219 static int cpu_lp_millivolts[MAX_DVFS_FREQS];
220
221 static struct dvfs cpu_lp_dvfs = {
222         .clk_name       = "cpu_lp",
223         .millivolts     = cpu_lp_millivolts,
224         .auto_dvfs      = true,
225         .dvfs_rail      = &tegra21_dvfs_rail_vdd_cpu,
226 };
227
228 /* GPU DVFS tables */
229 /* FIXME: fill in actual hw numbers */
230 static unsigned long gpu_max_freq[] = {
231 /* speedo_id    0       */
232                 1075200,
233 };
234 static struct gpu_cvb_dvfs gpu_cvb_dvfs_table[] = {
235         {
236                 .speedo_id =  -1,
237                 .process_id = -1,
238 #ifdef CONFIG_TEGRA_GPU_DVFS
239                 .max_mv = 1150,
240 #else
241                 .max_mv = 1000,
242 #endif
243                 .freqs_mult = KHZ,
244                 .speedo_scale = 100,
245                 .thermal_scale = 10,
246                 .voltage_scale = 1000,
247 #ifdef CONFIG_TEGRA_USE_NA_GPCPLL
248                 .cvb_table = {
249                         /* f       dfll pll:    c0,       c1,       c2 */
250                         {   76800, { }, {  1735265,   -83905,     1632 }, },
251                         {  153600, { }, {  1791974,   -85805,     1632 }, },
252                         {  230400, { }, {  1852372,   -87695,     1632 }, },
253                         {  307200, { }, {  1916458,   -89595,     1632 }, },
254                         {  384000, { }, {  1984234,   -91495,     1632 }, },
255                         {  460800, { }, {  2054747,   -93365,     1632 }, },
256                         {  537600, { }, {  2129852,   -95265,     1632 }, },
257                         {  614400, { }, {  2208646,   -97165,     1632 }, },
258                         {  691200, { }, {  2291130,   -99055,     1632 }, },
259                         {  768000, { }, {  2377302,  -100955,     1632 }, },
260                         {  844800, { }, {  2465972,  -102835,     1632 }, },
261                         {  921600, { }, {  2559474,  -104725,     1632 }, },
262                         {  998400, { }, {  2656664,  -106625,     1632 }, },
263                         { 0,       { }, { }, },
264                 },
265 #else
266                 .cvb_table = {
267                         /* f       dfll pll:    c0,       c1,       c2 */
268                         {   76800, { }, {  1786666,   -85625,     1632 }, },
269                         {  153600, { }, {  1846729,   -87525,     1632 }, },
270                         {  230400, { }, {  1910480,   -89425,     1632 }, },
271                         {  307200, { }, {  1977920,   -91325,     1632 }, },
272                         {  384000, { }, {  2049049,   -93215,     1632 }, },
273                         {  460800, { }, {  2122872,   -95095,     1632 }, },
274                         {  537600, { }, {  2201331,   -96985,     1632 }, },
275                         {  614400, { }, {  2283479,   -98885,     1632 }, },
276                         {  691200, { }, {  2369315,  -100785,     1632 }, },
277                         {  768000, { }, {  2458841,  -102685,     1632 }, },
278                         {  844800, { }, {  2550821,  -104555,     1632 }, },
279                         {  921600, { }, {  2647676,  -106455,     1632 }, },
280                         { 0,       { }, { }, },
281                 },
282 #endif
283                 .cvb_vmin =  {  0, {  }, { 950000, }, },
284                 .vts_trips_table = { 0, 70, },
285         },
286 };
287
288 static int gpu_vmin[MAX_THERMAL_RANGES];
289 static int gpu_peak_millivolts[MAX_DVFS_FREQS];
290 static int gpu_millivolts[MAX_THERMAL_RANGES][MAX_DVFS_FREQS];
291 static struct dvfs gpu_dvfs = {
292         .clk_name       = "gbus",
293         .auto_dvfs      = true,
294         .dvfs_rail      = &tegra21_dvfs_rail_vdd_gpu,
295 };
296
297 /* Core DVFS tables */
298 /* FIXME: real data */
299 static const int core_millivolts[MAX_DVFS_FREQS] = {
300         830, 850, 875, 900, 925, 950, 975, 1000, 1025, 1050, 1075, 1100, 1125, 1150, 1175, 1200, 1225 };
301
302 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
303         {                                                       \
304                 .clk_name       = _clk_name,                    \
305                 .speedo_id      = _speedo_id,                   \
306                 .process_id     = _process_id,                  \
307                 .freqs          = {_freqs},                     \
308                 .freqs_mult     = _mult,                        \
309                 .millivolts     = core_millivolts,              \
310                 .auto_dvfs      = _auto,                        \
311                 .dvfs_rail      = &tegra21_dvfs_rail_vdd_core,  \
312         }
313
314 #define OVRRD_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
315         {                                                       \
316                 .clk_name       = _clk_name,                    \
317                 .speedo_id      = _speedo_id,                   \
318                 .process_id     = _process_id,                  \
319                 .freqs          = {_freqs},                     \
320                 .freqs_mult     = _mult,                        \
321                 .millivolts     = core_millivolts,              \
322                 .auto_dvfs      = _auto,                        \
323                 .can_override   = true,                         \
324                 .dvfs_rail      = &tegra21_dvfs_rail_vdd_core,  \
325         }
326
327 static struct dvfs core_dvfs_table[] = {
328         /* Core voltages (mV):                830,     850,     875,     900,     925,     950,     975,    1000,    1025,    1050,    1075,    1100,    1125,    1150,    1175,    1200,    1225 */
329         /* Clock limits for internal blocks, PLLs */
330         CORE_DVFS("emc",    -1, -1, 1, KHZ,        1,       1,       1,       1,       1,       1,       1, 1200000, 1200000, 1200000, 1200000, 1200000, 1200000, 1200000, 1200000, 1200000, 1800000),
331
332         CORE_DVFS("nvjpg",  -1, -1, 1, KHZ,   153600,  166400,  192000,  217600,  243200,  268800,  294400,  320000,  332800,  358400,  384000,  409600,  422400,  448000,  460800,  486400,  499200),
333         CORE_DVFS("se",     -1, -1, 1, KHZ,   153600,  166400,  192000,  217600,  243200,  268800,  294400,  320000,  332800,  358400,  384000,  409600,  422400,  448000,  460800,  486400,  499200),
334         CORE_DVFS("c2bus",  -1, -1, 1, KHZ,   153600,  166400,  192000,  217600,  243200,  268800,  294400,  320000,  332800,  358400,  384000,  409600,  422400,  448000,  460800,  486400,  499200),
335
336         CORE_DVFS("vic03",  -1, -1, 1, KHZ,   217600,  243200,  281600,  307200,  345600,  384000,  422400,  435200,  448000,  473600,  473600,  486400,  499200,  512000,  524800,  537600,  563200),
337         CORE_DVFS("msenc",  -1, -1, 1, KHZ,   217600,  243200,  281600,  307200,  345600,  384000,  422400,  435200,  448000,  473600,  473600,  486400,  499200,  512000,  524800,  537600,  563200),
338         CORE_DVFS("nvdec",  -1, -1, 1, KHZ,   217600,  243200,  281600,  307200,  345600,  384000,  422400,  435200,  448000,  473600,  473600,  486400,  499200,  512000,  524800,  537600,  563200),
339         CORE_DVFS("tsecb",  -1, -1, 1, KHZ,   217600,  243200,  281600,  307200,  345600,  384000,  422400,  435200,  448000,  473600,  473600,  486400,  499200,  512000,  524800,  537600,  563200),
340         CORE_DVFS("c3bus",  -1, -1, 1, KHZ,   217600,  243200,  281600,  307200,  345600,  384000,  422400,  435200,  448000,  473600,  473600,  486400,  499200,  512000,  524800,  537600,  563200),
341
342         CORE_DVFS("vi",     -1, -1, 1, KHZ,   243200,  256000,  294400,  320000,  345600,  371200,  396800,  422400,  448000,  473600,  486400,  499200,  524800,  537600,  563200,  576000,  601600),
343         CORE_DVFS("isp",    -1, -1, 1, KHZ,   243200,  256000,  294400,  320000,  345600,  371200,  396800,  422400,  448000,  473600,  486400,  499200,  524800,  537600,  563200,  576000,  601600),
344         CORE_DVFS("cbus",   -1, -1, 1, KHZ,   243200,  256000,  294400,  320000,  345600,  371200,  396800,  422400,  448000,  473600,  486400,  499200,  524800,  537600,  563200,  576000,  601600),
345
346         /*
347          * Disable framework auto-dvfs on sbus - let platform code to call
348          * tegra_dvfs_set_rate manually. It is necessary for special handling
349          * of system clock skipper enabled on T210
350          */
351         CORE_DVFS("sbus",    -1, -1, 0, KHZ,   107500,  119300,  136100,  153300,  169900,  188000,  204200,  222600,  238300,  255400,  271500,  287000,  299700,  312300,  325100,  336500,  349100),
352         CORE_DVFS("mselect", -1, -1, 1, KHZ,   178100,  197600,  225500,  253800,  281500,  311400,  338300,  368700,  394600,  423000,  449600,  475200,  496300,  517200,  538400,  557300,  578200),
353         CORE_DVFS("host1x",  -1, -1, 1, KHZ,   89000 ,  98700 ,  112700,  126900,  140700,  155600,  169100,  184300,  197200,  211400,  224700,  237500,  248100,  258500,  269100,  278600,  289000),
354         CORE_DVFS("tsec",    -1, -1, 1, KHZ,   178100,  197600,  225500,  253800,  281500,  311400,  338300,  368700,  394600,  423000,  449600,  475200,  496300,  517200,  538400,  557300,  578200),
355
356         CORE_DVFS("pll_c",  -1, -1, 1, KHZ,    611200,  678000,  773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
357         CORE_DVFS("pll_c2", -1, -1, 1, KHZ,    611200,  678000,  773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
358         CORE_DVFS("pll_c3", -1, -1, 1, KHZ,    611200,  678000,  773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
359         CORE_DVFS("pll_c4_out0", -1, -1, 1, KHZ, 611200, 678000, 773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
360         CORE_DVFS("pll_d_out0", -1, -1, 1, KHZ, 611200, 678000,  773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
361         CORE_DVFS("pll_d2", -1, -1, 1, KHZ,    611200,  678000,  773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
362         CORE_DVFS("pll_dp", -1, -1, 1, KHZ,    611200,  678000,  773900, 871100,  965900,  1068500, 1160800, 1265300, 1354100, 1451500, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
363
364         /* Clock limits for DC subsystem */
365         /* Core voltages (mV):                 830,     850,     875,     900,     925,     950,     975,    1000,    1025,    1050,    1075,    1100,    1125,    1150,    1175,    1200,    1225 */
366         CORE_DVFS("csi",  -1, -1, 0, KHZ,    791000,  877400, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000, 1000000),
367         CORE_DVFS("cilab", -1, -1, 0, KHZ,   102000,  102000, 136000 , 136000 , 136000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000),
368         CORE_DVFS("cilcd", -1, -1, 0, KHZ,   102000,  102000, 136000 , 136000 , 136000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000),
369         CORE_DVFS("cile",  -1, -1, 0, KHZ,   102000,  102000, 136000 , 136000 , 136000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000),
370
371         CORE_DVFS("dsia", -1, -1, 0, KHZ,    791000,  877400, 1001400, 1127200, 1249900, 1382700, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
372         CORE_DVFS("dsib", -1, -1, 0, KHZ,    791000,  877400, 1001400, 1127200, 1249900, 1382700, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000),
373         CORE_DVFS("dsialp", -1, -1, 0, KHZ,  102000,  102000, 136000 , 136000 , 136000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000),
374         CORE_DVFS("dsiblp", -1, -1, 0, KHZ,  102000,  102000, 136000 , 136000 , 136000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000 , 204000),
375         CORE_DVFS("sor0", -1, -1, 0, KHZ,    1     ,  1     , 270000 , 270000 , 270000 , 270000 , 270000 , 270000 , 270000 , 540000 , 540000 , 540000 , 540000 , 540000 , 540000 , 540000 , 540000),
376         CORE_DVFS("sor1", -1, -1, 0, KHZ,    235700,  261500, 298500 , 336000 , 372600 , 412100 , 447700 , 488000 , 522300 , 559900 , 595200 , 600000 , 600000 , 600000 , 600000 , 600000 , 600000),
377
378         /*
379          * The clock rate for the display controllers that determines the
380          * necessary core voltage depends on a divider that is internal
381          * to the display block.  Disable auto-dvfs on the display clocks,
382          * and let the display driver call tegra_dvfs_set_rate manually
383          */
384         CORE_DVFS("disp1",  -1, -1, 0, KHZ,    230400,  230400,  256000,  281600,  307200,  320000,  345600,  371200,  384000,  396800,  422400,  435200,  460800,  486400,  499200,  524800,  537600),
385         CORE_DVFS("disp2",  -1, -1, 0, KHZ,    230400,  230400,  256000,  281600,  307200,  320000,  345600,  371200,  384000,  396800,  422400,  435200,  460800,  486400,  499200,  524800,  537600),
386
387         /* Clock limits for audio subsystem */
388         /* Core voltages (mV):                 830,     850,     875,     900,     925,     950,     975,     1000,    1025,    1050,    1075,    1100,    1125,    1150,    1175,    1200,    1225 */
389         CORE_DVFS("i2s0",   -1, -1, 1, KHZ,    1    ,   1    ,   24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152),
390         CORE_DVFS("i2s1",   -1, -1, 1, KHZ,    1    ,   1    ,   24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152),
391         CORE_DVFS("i2s2",   -1, -1, 1, KHZ,    1    ,   1    ,   24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152),
392         CORE_DVFS("i2s3",   -1, -1, 1, KHZ,    1    ,   1    ,   24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152),
393         CORE_DVFS("i2s4",   -1, -1, 1, KHZ,    1    ,   1    ,   24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152),
394
395         CORE_DVFS("d_audio", -1, -1, 1, KHZ,   1    ,   1    ,   49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  98304 ,  98304 ,  98304 ,  98304 ,  98304 ,  98304 ,  98304 ,  98304),
396         CORE_DVFS("spdif_out", -1, -1, 1, KHZ, 1    ,   1    ,   24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  24576 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152 ,  49152),
397
398         CORE_DVFS("dmic1",  -1, -1, 1, KHZ,    1    ,   1    ,   12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288),
399         CORE_DVFS("dmic2",  -1, -1, 1, KHZ,    1    ,   1    ,   12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288),
400         CORE_DVFS("dmic3",  -1, -1, 1, KHZ,    1    ,   1    ,   12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288 ,  12288),
401
402         CORE_DVFS("hda",    -1, -1, 1, KHZ,    80600,   89400,   102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000),
403         CORE_DVFS("hda2codec_2x", -1, -1, 1, KHZ,  1,   1    ,   1     ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000),
404
405         CORE_DVFS("adsp_cpu", -1, -1, 1, KHZ,  179200,  192000,  230400,  256000,  281600,  320000,  345600,  371200,  396800,  422400,  460800,  486400,  499200,  524800,  550400,  563200,  588800),
406         CORE_DVFS("ape",      -1, -1, 1, KHZ,  130900,  145200,  165700,  186600,  206900,  228900,  248600,  271000,  290000,  300000,  300000,  300000,  300000,  300000,  300000,  300000,  300000),
407
408         /* Clock limits for I/O peripherals */
409         /* Core voltages (mV):                 830,     850,     875,     900,     925,     950,     975,     1000,    1025,    1050,    1075,    1100,    1125,    1150,    1175,    1200,    1225 */
410         OVRRD_DVFS("sdmmc1", -1, -1, 1, KHZ,   164500,  182500,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000),
411         OVRRD_DVFS("sdmmc3", -1, -1, 1, KHZ,   164500,  182500,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000,  208000),
412
413         OVRRD_DVFS("sdmmc2", -1, -1, 1, KHZ,   263600,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000),
414         OVRRD_DVFS("sdmmc4", -1, -1, 1, KHZ,   263600,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000),
415         OVRRD_DVFS("sdmmc2_ddr", -1, -1, 1, KHZ, 263600, 266000, 266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000),
416         OVRRD_DVFS("sdmmc4_ddr", -1, -1, 1, KHZ, 263600, 266000, 266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000,  266000),
417
418         CORE_DVFS("sbc1",    -1, -1, 1, KHZ,   1     ,  1     ,  1     ,  33000,   33000,   33000,   33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000),
419         CORE_DVFS("sbc2",    -1, -1, 1, KHZ,   1     ,  1     ,  1     ,  33000,   33000,   33000,   33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000),
420         CORE_DVFS("sbc3",    -1, -1, 1, KHZ,   1     ,  1     ,  1     ,  33000,   33000,   33000,   33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000),
421         CORE_DVFS("sbc4",    -1, -1, 1, KHZ,   1     ,  1     ,  1     ,  33000,   33000,   33000,   33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000 ,  33000),
422         CORE_DVFS("qspi",    -1, -1, 1, KHZ,   1     ,  1     ,  1     ,  72400,   80300,   91700,   103200,  114400,  126600,  137500,  149900,  160500,  166000,  166000,  166000,  166000,  166000),
423
424         /* xusb pcie, sata clocks */
425         CORE_DVFS("xusb_falcon_src", -1, -1, 1, KHZ,  1, 1    ,  1     ,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000,  312000),
426         CORE_DVFS("xusb_host_src",   -1, -1, 1, KHZ,  1, 1    ,  1     ,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000),
427         CORE_DVFS("xusb_dev_src",    -1, -1, 1, KHZ,  1, 1    ,  1     ,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000),
428         CORE_DVFS("xusb_ss_src",     -1, -1, 1, KHZ,  1, 1    ,  1     ,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000),
429         CORE_DVFS("xusb_ssp_src",    -1, -1, 1, KHZ,  1, 1    ,  1     ,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000),
430         CORE_DVFS("xusb_fs_src",     -1, -1, 1, KHZ,  1, 1    ,  1     ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000 ,  48000),
431         CORE_DVFS("xusb_hs_src",     -1, -1, 1, KHZ,  1, 1    ,  1     ,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000,  120000),
432
433         CORE_DVFS("usbd",  -1, -1, 1, KHZ,            1, 1    ,  1     ,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000),
434         CORE_DVFS("usb2",  -1, -1, 1, KHZ,            1, 1    ,  1     ,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000),
435         CORE_DVFS("usb3",  -1, -1, 1, KHZ,            1, 1    ,  1     ,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000,  480000),
436
437         CORE_DVFS("sata",   -1, -1, 1, KHZ,           1, 1    ,  1     ,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000,  102000),
438         CORE_DVFS("sata_oob", -1, -1, 1, KHZ,         1, 1    ,  1     ,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000,  204000),
439         CORE_DVFS("pciex",  -1, -1, 1, KHZ,           1, 1    ,  1     ,  250000,  250000,  500000,  500000,  500000,  500000,  500000,  500000,  500000,  500000,  500000,  500000,  500000,  500000),
440 };
441
442 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
443 {
444         int ret;
445
446         ret = param_set_bool(arg, kp);
447         if (ret)
448                 return ret;
449
450         if (tegra_dvfs_core_disabled)
451                 tegra_dvfs_rail_disable(&tegra21_dvfs_rail_vdd_core);
452         else
453                 tegra_dvfs_rail_enable(&tegra21_dvfs_rail_vdd_core);
454
455         return 0;
456 }
457
458 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
459 {
460         int ret;
461
462         ret = param_set_bool(arg, kp);
463         if (ret)
464                 return ret;
465
466         if (tegra_dvfs_cpu_disabled)
467                 tegra_dvfs_rail_disable(&tegra21_dvfs_rail_vdd_cpu);
468         else
469                 tegra_dvfs_rail_enable(&tegra21_dvfs_rail_vdd_cpu);
470
471         return 0;
472 }
473
474 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
475 {
476         int ret;
477
478         ret = param_set_bool(arg, kp);
479         if (ret)
480                 return ret;
481
482         if (tegra_dvfs_gpu_disabled)
483                 tegra_dvfs_rail_disable(&tegra21_dvfs_rail_vdd_gpu);
484         else
485                 tegra_dvfs_rail_enable(&tegra21_dvfs_rail_vdd_gpu);
486
487         return 0;
488 }
489
490 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
491 {
492         return param_get_bool(buffer, kp);
493 }
494
495 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
496         .set = tegra_dvfs_disable_core_set,
497         .get = tegra_dvfs_disable_get,
498 };
499
500 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
501         .set = tegra_dvfs_disable_cpu_set,
502         .get = tegra_dvfs_disable_get,
503 };
504
505 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
506         .set = tegra_dvfs_disable_gpu_set,
507         .get = tegra_dvfs_disable_get,
508 };
509
510 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
511         &tegra_dvfs_core_disabled, 0644);
512 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
513         &tegra_dvfs_cpu_disabled, 0644);
514 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
515         &tegra_dvfs_gpu_disabled, 0644);
516
517 static bool __init match_dvfs_one(const char *name,
518         int dvfs_speedo_id, int dvfs_process_id,
519         int speedo_id, int process_id)
520 {
521         if ((dvfs_process_id != -1 && dvfs_process_id != process_id) ||
522                 (dvfs_speedo_id != -1 && dvfs_speedo_id != speedo_id)) {
523                 pr_debug("tegra21_dvfs: rejected %s speedo %d, process %d\n",
524                          name, dvfs_speedo_id, dvfs_process_id);
525                 return false;
526         }
527         return true;
528 }
529
530 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
531 static inline int get_cvb_voltage(int speedo, int s_scale,
532                                   struct cvb_dvfs_parameters *cvb)
533 {
534         /* apply only speedo scale: output mv = cvb_mv * v_scale */
535         int mv;
536         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
537         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
538         return mv;
539 }
540
541 /* cvb_t_mv =
542    ((c3 * speedo / s_scale + c4 + c5 * T / t_scale) * T / t_scale) / v_scale */
543 static inline int get_cvb_t_voltage(int speedo, int s_scale, int t, int t_scale,
544                                     struct cvb_dvfs_parameters *cvb)
545 {
546         /* apply speedo & temperature scales: output mv = cvb_t_mv * v_scale */
547         int mv;
548         mv = DIV_ROUND_CLOSEST(cvb->c3 * speedo, s_scale) + cvb->c4 +
549                 DIV_ROUND_CLOSEST(cvb->c5 * t, t_scale);
550         mv = DIV_ROUND_CLOSEST(mv * t, t_scale);
551         return mv;
552 }
553
554 static int round_cvb_voltage(int mv, int v_scale, struct rail_alignment *align)
555 {
556         /* combined: apply voltage scale and round to cvb alignment step */
557         int uv;
558         int step = (align->step_uv ? : 1000) * v_scale;
559         int offset = align->offset_uv * v_scale;
560
561         uv = max(mv * 1000, offset) - offset;
562         uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;
563         return uv / 1000;
564 }
565
566 static int round_voltage(int mv, struct rail_alignment *align, bool up)
567 {
568         if (align->step_uv) {
569                 int uv = max(mv * 1000, align->offset_uv) - align->offset_uv;
570                 uv = (uv + (up ? align->step_uv - 1 : 0)) / align->step_uv;
571                 return (uv * align->step_uv + align->offset_uv) / 1000;
572         }
573         return mv;
574 }
575
576 /*
577  * Setup fast CPU DVFS tables in PLL and DFLL modes from CVB data, determine
578  * nominal voltage for CPU rail, and CPU maximum frequency. Note that entire
579  * frequency range is guaranteed only when DFLL is used as CPU clock source.
580  * Reaching maximum frequency on PLL may not be possible within nominal voltage
581  * range (DVFS core would fail frequency request in this case, so that voltage
582  * limit is not violated). Error when CPU DVFS table can not be constructed must
583  * never happen.
584  */
585 static int __init set_cpu_dvfs_data(unsigned long max_freq,
586         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
587 {
588         int j, mv, min_mv, dfll_mv, min_dfll_mv;
589         unsigned long fmax_at_vmin = 0;
590         unsigned long fmax_pll_mode = 0;
591         unsigned long fmin_use_dfll = 0;
592         int speedo = tegra_cpu_speedo_value();
593
594         struct cvb_dvfs_table *table = NULL;
595         struct dvfs_rail *rail = &tegra21_dvfs_rail_vdd_cpu;
596         struct rail_alignment *align = &rail->alignment;
597
598         min_dfll_mv = d->dfll_tune_data.min_millivolts;
599         if (min_dfll_mv < rail->min_millivolts) {
600                 pr_debug("tegra21_dvfs: dfll min %dmV below rail min %dmV\n",
601                      min_dfll_mv, rail->min_millivolts);
602                 min_dfll_mv = rail->min_millivolts;
603         }
604         min_dfll_mv =  round_voltage(min_dfll_mv, align, true);
605
606         min_mv = d->pll_tune_data.min_millivolts;
607         if (min_mv < rail->min_millivolts) {
608                 pr_debug("tegra21_dvfs: pll min %dmV below rail min %dmV\n",
609                      min_mv, rail->min_millivolts);
610                 min_mv = rail->min_millivolts;
611         }
612         min_mv =  round_voltage(min_mv, align, true);
613
614         d->max_mv = round_voltage(d->max_mv, align, false);
615         BUG_ON(d->max_mv > rail->max_millivolts);
616
617         /*
618          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
619          * CVB entry specifies CPU frequency and CVB coefficients to calculate
620          * the respective voltage when either DFLL or PLL is used as CPU clock
621          * source.
622          *
623          * Different minimum voltage limits are applied to DFLL and PLL sources.
624          * Same maximum voltage limit is used for both sources, but differently:
625          * directly limit voltage for DFLL, and limit maximum frequency for PLL.
626          */
627         for (j = 0; j < MAX_DVFS_FREQS; j++) {
628                 table = &d->cvb_table[j];
629                 if (!table->freq || (table->freq > max_freq))
630                         break;
631
632                 dfll_mv = get_cvb_voltage(
633                         speedo, d->speedo_scale, &table->cvb_dfll_param);
634                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale, align);
635                 dfll_mv = max(dfll_mv, min_dfll_mv);
636
637                 mv = get_cvb_voltage(
638                         speedo, d->speedo_scale, &table->cvb_pll_param);
639 #ifdef BRINGUP_CVB_V_MARGIN
640                 mv = mv * (100 + BRINGUP_CVB_V_MARGIN +
641                            BRINGUP_CVB_V_MARGIN_EX) / 100;
642 #endif
643                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
644                 mv = max(mv, min_mv);
645
646                 /*
647                  * Check maximum frequency at minimum voltage for dfll source;
648                  * round down unless all table entries are above Vmin, then use
649                  * the 1st entry as is.
650                  */
651                 if (dfll_mv > min_dfll_mv) {
652                         if (!j)
653                                 fmax_at_vmin = table->freq;
654                         if (!fmax_at_vmin)
655                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
656                 }
657
658                 /* Clip maximum frequency at maximum voltage for pll source */
659                 if (mv > d->max_mv) {
660                         if (!j)
661                                 break;  /* 1st entry already above Vmax */
662                         if (!fmax_pll_mode)
663                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
664                 }
665
666                 /* Minimum rate with pll source voltage above dfll Vmin */
667                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
668                         fmin_use_dfll = table->freq;
669
670                 /* fill in dvfs tables */
671                 cpu_dvfs->freqs[j] = table->freq;
672                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
673                 cpu_millivolts[j] = mv;
674         }
675
676         /* Table must not be empty, must have at least one entry above Vmin */
677         if (!j || !fmax_at_vmin) {
678                 pr_err("tegra21_dvfs: invalid cpu dvfs table\n");
679                 return -ENOENT;
680         }
681
682         /* In the dfll operating range dfll voltage at any rate should be
683            better (below) than pll voltage */
684         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
685                 WARN(1, "tegra21_dvfs: pll voltage is below dfll in the dfll"
686                         " operating range\n");
687                 fmin_use_dfll = fmax_at_vmin;
688         }
689
690         /* dvfs tables are successfully populated - fill in the rest */
691         cpu_dvfs->speedo_id = d->speedo_id;
692         cpu_dvfs->process_id = d->process_id;
693         cpu_dvfs->freqs_mult = d->freqs_mult;
694         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
695                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
696         *max_freq_index = j - 1;
697
698         cpu_dvfs->dfll_data = d->dfll_tune_data;
699         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
700                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
701         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
702         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
703         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
704
705         return 0;
706 }
707
708 static void __init init_cpu_dvfs_table(int *cpu_max_freq_index)
709 {
710         int i, ret;
711         int cpu_speedo_id = tegra_cpu_speedo_id();
712         int cpu_process_id = tegra_cpu_process_id();
713
714         BUG_ON(cpu_speedo_id >= ARRAY_SIZE(cpu_max_freq));
715         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
716                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
717                 unsigned long max_freq = cpu_max_freq[cpu_speedo_id];
718                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
719                                    cpu_speedo_id, cpu_process_id)) {
720                         ret = set_cpu_dvfs_data(max_freq,
721                                 d, &cpu_dvfs, cpu_max_freq_index);
722                         break;
723                 }
724         }
725         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
726 }
727
728 /*
729  * Setup slow CPU (a.k.a LP CPU) DVFS table from CVB data. Only PLL is used as
730  * a clock source for slow CPU. Its maximum frequency must be reached within
731  * nominal voltage -- CVB frequency list is cut off at rate that exceeds either
732  * sku-based maximum limit or requires voltage above nominal. Error when DVFS
733  * table can not be constructed must never happen.
734  *
735  * Final CPU rail nominal voltage is set as maximum of fast and slow CPUs
736  * nominal voltages.
737  */
738 static int __init set_cpu_lp_dvfs_data(unsigned long max_freq,
739         struct cpu_cvb_dvfs *d, struct dvfs *cpu_lp_dvfs, int *max_freq_index)
740 {
741         int j, mv, min_mv;
742         int speedo = tegra_cpu_speedo_value(); /* FIXME cpu_lp_speedo */
743
744         struct cvb_dvfs_table *table = NULL;
745         struct dvfs_rail *rail = &tegra21_dvfs_rail_vdd_cpu;
746         struct rail_alignment *align = &rail->alignment;
747
748         min_mv = d->pll_tune_data.min_millivolts;
749         if (min_mv < rail->min_millivolts) {
750                 pr_debug("tegra21_dvfs: scpu min %dmV below rail min %dmV\n",
751                      min_mv, rail->min_millivolts);
752                 min_mv = rail->min_millivolts;
753         }
754         min_mv =  round_voltage(min_mv, align, true);
755
756         d->max_mv = round_voltage(d->max_mv, align, false);
757         BUG_ON(d->max_mv > rail->max_millivolts);
758         rail->nominal_millivolts = max(rail->nominal_millivolts, d->max_mv);
759
760         /*
761          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
762          * CVB entry specifies CPU frequency and CVB coefficients to calculate
763          * the respective voltage. Only PLL is used as CPU LP clock source, and
764          * the respective minimum limit is applied to each table entry. Table
765          * construction is aborted if calculated voltage is above maximum limit.
766          */
767         for (j = 0; j < MAX_DVFS_FREQS; j++) {
768                 table = &d->cvb_table[j];
769                 if (!table->freq || (table->freq > max_freq))
770                         break;
771
772                 mv = get_cvb_voltage(
773                         speedo, d->speedo_scale, &table->cvb_pll_param);
774                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
775                 mv = max(mv, min_mv);
776
777                 if (mv > d->max_mv) {
778                         pr_warn("tegra21_dvfs: %dmV for %s rate %lu above limit %dmV\n",
779                              mv, cpu_lp_dvfs->clk_name, table->freq, d->max_mv);
780                         break;
781                 }
782
783                 /* fill in dvfs tables */
784                 cpu_lp_dvfs->freqs[j] = table->freq;
785                 cpu_lp_millivolts[j] = mv;
786         }
787
788         /* Table must not be empty */
789         if (!j) {
790                 pr_err("tegra21_dvfs: invalid cpu lp dvfs table\n");
791                 return -ENOENT;
792         }
793
794         /* dvfs tables are successfully populated - fill in the rest */
795         cpu_lp_dvfs->speedo_id = d->speedo_id;
796         cpu_lp_dvfs->process_id = d->process_id;
797         cpu_lp_dvfs->freqs_mult = d->freqs_mult;
798         *max_freq_index = j - 1;
799
800         return 0;
801 }
802
803 static void __init init_cpu_lp_dvfs_table(int *cpu_lp_max_freq_index)
804 {
805         int i, ret;
806         int cpu_lp_speedo_id = tegra_cpu_speedo_id(); /* FIXME cpu_lp_ */
807         int cpu_lp_process_id = tegra_cpu_process_id(); /* FIXME cpu_lp_ */
808
809         BUG_ON(cpu_lp_speedo_id >= ARRAY_SIZE(cpu_lp_max_freq));
810         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_lp_cvb_dvfs_table); i++) {
811                 struct cpu_cvb_dvfs *d = &cpu_lp_cvb_dvfs_table[i];
812                 unsigned long max_freq = cpu_lp_max_freq[cpu_lp_speedo_id];
813                 if (match_dvfs_one("cpu lp cvb", d->speedo_id, d->process_id,
814                                    cpu_lp_speedo_id, cpu_lp_process_id)) {
815                         ret = set_cpu_lp_dvfs_data(max_freq,
816                                 d, &cpu_lp_dvfs, cpu_lp_max_freq_index);
817                         break;
818                 }
819         }
820         BUG_ON((i == ARRAY_SIZE(cpu_lp_cvb_dvfs_table)) || ret);
821 }
822
823 /*
824  * Setup gpu dvfs tables from cvb data, determine nominal voltage for gpu rail,
825  * and gpu maximum frequency. Error when gpu dvfs table can not be constructed
826  * must never happen.
827  */
828 static unsigned long __init find_gpu_fmax_at_vmin(
829         struct dvfs *gpu_dvfs, int thermal_ranges, int freqs_num)
830 {
831         int i, j;
832         unsigned long fmax = ULONG_MAX;
833
834         /*
835          * For voltage scaling row in each temperature range, as well as peak
836          * voltage row find maximum frequency at lowest voltage, and return
837          * minimax. On Tegra21 all GPU DVFS thermal dependencies are integrated
838          * into thermal DVFS table (i.e., there is no separate thermal floors
839          * applied in the rail level). Hence, returned frequency specifies max
840          * frequency safe at minimum voltage across all temperature ranges.
841          */
842         for (j = 0; j < thermal_ranges; j++) {
843                 for (i = 1; i < freqs_num; i++) {
844                         if (gpu_millivolts[j][i] > gpu_millivolts[j][0])
845                                 break;
846                 }
847                 fmax = min(fmax, gpu_dvfs->freqs[i - 1]);
848         }
849
850         for (i = 1; i < freqs_num; i++) {
851                 if (gpu_peak_millivolts[i] > gpu_peak_millivolts[0])
852                         break;
853         }
854         fmax = min(fmax, gpu_dvfs->freqs[i - 1]);
855
856         return fmax;
857 }
858
859 static int __init set_gpu_dvfs_data(unsigned long max_freq,
860         struct gpu_cvb_dvfs *d, struct dvfs *gpu_dvfs, int *max_freq_index)
861 {
862         int i, j, thermal_ranges, mv;
863         struct cvb_dvfs_table *table = NULL;
864         int speedo = tegra_gpu_speedo_value();
865         struct dvfs_rail *rail = &tegra21_dvfs_rail_vdd_gpu;
866         struct rail_alignment *align = &rail->alignment;
867
868         d->max_mv = round_voltage(d->max_mv, align, false);
869
870         /*
871          * Init thermal trips, find number of thermal ranges; note that the
872          * first trip-point is used for voltage calculations within the lowest
873          * range, but should not be actually set. Hence, at least 2 trip-points
874          * must be specified.
875          */
876         if (tegra_dvfs_rail_init_thermal_dvfs_trips(d->vts_trips_table, rail))
877                 return -ENOENT;
878         thermal_ranges = rail->vts_cdev->trip_temperatures_num;
879         rail->vts_cdev->trip_temperatures_num--;
880
881         if (thermal_ranges < 2)
882                 WARN(1, "tegra21_dvfs: %d gpu trip: thermal dvfs is broken\n",
883                      thermal_ranges);
884
885         /*
886          * Use CVB table to calculate Vmin for each temperature range
887          */
888         mv = get_cvb_voltage(
889                 speedo, d->speedo_scale, &d->cvb_vmin.cvb_pll_param);
890         for (j = 0; j < thermal_ranges; j++) {
891                 int mvj = mv;
892                 int t = rail->vts_cdev->trip_temperatures[j];
893
894                 /* add Vmin thermal offset for this trip-point */
895                 mvj += get_cvb_t_voltage(speedo, d->speedo_scale,
896                         t, d->thermal_scale, &d->cvb_vmin.cvb_pll_param);
897                 mvj = round_cvb_voltage(mvj, d->voltage_scale, align);
898                 if (mvj < rail->min_millivolts) {
899                         pr_debug("tegra21_dvfs: gpu min %dmV below rail min %dmV\n",
900                              mvj, rail->min_millivolts);
901                         mvj = rail->min_millivolts;
902                 }
903
904                 gpu_vmin[j] = mvj;
905         }
906
907         /*
908          * Use CVB table to fill in gpu dvfs frequencies and voltages. Each
909          * CVB entry specifies gpu frequency and CVB coefficients to calculate
910          * the respective voltage.
911          */
912         for (i = 0; i < MAX_DVFS_FREQS; i++) {
913                 table = &d->cvb_table[i];
914                 if (!table->freq || (table->freq > max_freq))
915                         break;
916
917                 mv = get_cvb_voltage(
918                         speedo, d->speedo_scale, &table->cvb_pll_param);
919                 for (j = 0; j < thermal_ranges; j++) {
920                         int mvj = mv;
921                         int t = rail->vts_cdev->trip_temperatures[j];
922
923                         /* get thermal offset for this trip-point */
924                         mvj += get_cvb_t_voltage(speedo, d->speedo_scale,
925                                 t, d->thermal_scale, &table->cvb_pll_param);
926                         mvj = round_cvb_voltage(mvj, d->voltage_scale, align);
927
928                         /* clip to minimum, abort if above maximum */
929                         mvj = max(mvj, gpu_vmin[j]);
930                         if (mvj > d->max_mv)
931                                 break;
932
933                         /* update voltage for adjacent ranges bounded by this
934                            trip-point (cvb & dvfs are transpose matrices) */
935                         gpu_millivolts[j][i] = mvj;
936                         if (j && (gpu_millivolts[j-1][i] < mvj))
937                                 gpu_millivolts[j-1][i] = mvj;
938                 }
939                 /* Make sure all voltages for this frequency are below max */
940                 if (j < thermal_ranges)
941                         break;
942
943                 /* fill in gpu dvfs tables */
944                 gpu_dvfs->freqs[i] = table->freq;
945         }
946
947         /*
948          * Table must not be empty, must have at least one entry in range, and
949          * must specify monotonically increasing voltage on frequency dependency
950          * in each temperature range.
951          */
952         if (!i || tegra_dvfs_init_thermal_dvfs_voltages(&gpu_millivolts[0][0],
953                 gpu_peak_millivolts, i, thermal_ranges, gpu_dvfs)) {
954                 pr_err("tegra21_dvfs: invalid gpu dvfs table\n");
955                 return -ENOENT;
956         }
957
958         /* Shift out the 1st trip-point */
959         for (j = 1; j < thermal_ranges; j++)
960                 rail->vts_cdev->trip_temperatures[j - 1] =
961                 rail->vts_cdev->trip_temperatures[j];
962
963         /* dvfs tables are successfully populated - fill in the gpu dvfs */
964         gpu_dvfs->speedo_id = d->speedo_id;
965         gpu_dvfs->process_id = d->process_id;
966         gpu_dvfs->freqs_mult = d->freqs_mult;
967         gpu_dvfs->dvfs_rail->nominal_millivolts = d->max_mv;
968
969         *max_freq_index = i - 1;
970
971         gpu_dvfs->fmax_at_vmin_safe_t = d->freqs_mult *
972                 find_gpu_fmax_at_vmin(gpu_dvfs, thermal_ranges, i);
973         return 0;
974 }
975
976 static void __init init_gpu_dvfs_table(int *gpu_max_freq_index)
977 {
978         int i, ret;
979         int gpu_speedo_id = tegra_gpu_speedo_id();
980         int gpu_process_id = tegra_gpu_process_id();
981
982         BUG_ON(gpu_speedo_id >= ARRAY_SIZE(gpu_max_freq));
983         for (ret = 0, i = 0; i < ARRAY_SIZE(gpu_cvb_dvfs_table); i++) {
984                 struct gpu_cvb_dvfs *d = &gpu_cvb_dvfs_table[i];
985                 unsigned long max_freq = gpu_max_freq[gpu_speedo_id];
986                 if (match_dvfs_one("gpu cvb", d->speedo_id, d->process_id,
987                                    gpu_speedo_id, gpu_process_id)) {
988                         ret = set_gpu_dvfs_data(max_freq,
989                                 d, &gpu_dvfs, gpu_max_freq_index);
990                         break;
991                 }
992         }
993         BUG_ON((i == ARRAY_SIZE(gpu_cvb_dvfs_table)) || ret);
994 }
995
996 /*
997  * Clip sku-based core nominal voltage to core DVFS voltage ladder
998  */
999 static int __init get_core_nominal_mv_index(int speedo_id)
1000 {
1001         int i;
1002         int mv = tegra_core_speedo_mv();
1003         int core_edp_voltage = get_core_edp();
1004
1005         /*
1006          * Start with nominal level for the chips with this speedo_id. Then,
1007          * make sure core nominal voltage is below edp limit for the board
1008          * (if edp limit is set).
1009          */
1010         if (!core_edp_voltage)
1011                 core_edp_voltage = 1225;        /* default 1.225V EDP limit */
1012
1013         mv = min(mv, core_edp_voltage);
1014 #ifndef CONFIG_TEGRA_CORE_DVFS
1015         mv = min(mv, 1000);             /* Vmax if scaling is disabled */
1016 #endif
1017         /* Round nominal level down to the nearest core scaling step */
1018         for (i = 0; i < MAX_DVFS_FREQS; i++) {
1019                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
1020                         break;
1021         }
1022
1023         if (i == 0) {
1024                 pr_err("tegra21_dvfs: unable to adjust core dvfs table to"
1025                        " nominal voltage %d\n", mv);
1026                 return -ENOSYS;
1027         }
1028         return i - 1;
1029 }
1030
1031 static int __init of_rails_init(struct device_node *dn)
1032 {
1033         int i;
1034
1035         if (!of_device_is_available(dn))
1036                 return 0;
1037
1038         for (i = 0; i < ARRAY_SIZE(tegra21_dvfs_rails); i++) {
1039                 struct dvfs_rail *rail = tegra21_dvfs_rails[i];
1040                 if (!of_tegra_dvfs_rail_node_parse(dn, rail)) {
1041                         rail->stats.bin_uV = rail->alignment.step_uv;
1042                         return 0;
1043                 }
1044         }
1045         return -ENOENT;
1046 }
1047
1048 static __initdata struct of_device_id tegra21_dvfs_rail_of_match[] = {
1049         { .compatible = "nvidia,tegra210-dvfs-rail", .data = of_rails_init, },
1050         { },
1051 };
1052
1053 void __init tegra21x_init_dvfs(void)
1054 {
1055         int soc_speedo_id = tegra_soc_speedo_id();
1056         int core_process_id = tegra_core_process_id();
1057
1058         int i, ret;
1059         int core_nominal_mv_index;
1060         int gpu_max_freq_index = 0;
1061         int cpu_max_freq_index = 0;
1062         int cpu_lp_max_freq_index = 0;
1063
1064 #ifndef CONFIG_TEGRA_CORE_DVFS
1065         tegra_dvfs_core_disabled = true;
1066 #endif
1067 #ifndef CONFIG_TEGRA_CPU_DVFS
1068         tegra_dvfs_cpu_disabled = true;
1069 #endif
1070 #ifndef CONFIG_TEGRA_GPU_DVFS
1071         tegra_dvfs_gpu_disabled = true;
1072 #endif
1073
1074         of_tegra_dvfs_init(tegra21_dvfs_rail_of_match);
1075
1076         /*
1077          * Find nominal voltages for core (1st) and cpu rails before rail
1078          * init. Nominal voltage index in core scaling ladder can also be
1079          * used to determine max dvfs frequencies for all core clocks. In
1080          * case of error disable core scaling and set index to 0, so that
1081          * core clocks would not exceed rates allowed at minimum voltage.
1082          */
1083         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
1084         if (core_nominal_mv_index < 0) {
1085                 tegra21_dvfs_rail_vdd_core.disabled = true;
1086                 tegra_dvfs_core_disabled = true;
1087                 core_nominal_mv_index = 0;
1088         }
1089         tegra21_dvfs_rail_vdd_core.nominal_millivolts =
1090                 core_millivolts[core_nominal_mv_index];
1091
1092         /*
1093          * Construct fast and slow CPU DVFS tables from CVB data; find maximum
1094          * frequency, minimum  and nominal voltage for each CPU cluster, and
1095          * combined rail limits (fast CPU should be initialized 1st).
1096          */
1097         init_cpu_dvfs_table(&cpu_max_freq_index);
1098         init_cpu_lp_dvfs_table(&cpu_lp_max_freq_index);
1099
1100         /*
1101          * Construct GPU DVFS table from CVB data; find GPU maximum frequency,
1102          * and nominal voltage.
1103          */
1104         init_gpu_dvfs_table(&gpu_max_freq_index);
1105
1106         /* Init core thermal profile */
1107         if (vdd_core_therm_floors_table[0])
1108                 tegra_dvfs_rail_init_vmin_thermal_profile(
1109                         vdd_core_vmin_trips_table, vdd_core_therm_floors_table,
1110                         &tegra21_dvfs_rail_vdd_core, NULL);
1111         if (vdd_core_therm_caps_table[0])
1112                 tegra_dvfs_rail_init_vmax_thermal_profile(
1113                         vdd_core_vmax_trips_table, vdd_core_therm_caps_table,
1114                         &tegra21_dvfs_rail_vdd_core, NULL);
1115
1116         /* Init rail structures and dependencies */
1117         tegra_dvfs_init_rails(tegra21_dvfs_rails,
1118                 ARRAY_SIZE(tegra21_dvfs_rails));
1119
1120         /* Search core dvfs table for speedo/process matching entries and
1121            initialize dvfs-ed clocks */
1122         if (!tegra_platform_is_linsim()) {
1123                 for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
1124                         struct dvfs *d = &core_dvfs_table[i];
1125                         if (!match_dvfs_one(d->clk_name, d->speedo_id,
1126                                 d->process_id, soc_speedo_id, core_process_id))
1127                                 continue;
1128                         tegra_init_dvfs_one(d, core_nominal_mv_index);
1129                 }
1130         }
1131
1132         /* Initialize matching gpu dvfs entry already found when nominal
1133            voltage was determined */
1134         tegra_init_dvfs_one(&gpu_dvfs, gpu_max_freq_index);
1135
1136         /* Initialize matching cpu dvfs entry already found when nominal
1137            voltage was determined */
1138         tegra_init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
1139         tegra_init_dvfs_one(&cpu_lp_dvfs, cpu_lp_max_freq_index);
1140
1141         /* Finally disable dvfs on rails if necessary */
1142         if (tegra_dvfs_core_disabled)
1143                 tegra_dvfs_rail_disable(&tegra21_dvfs_rail_vdd_core);
1144         if (tegra_dvfs_cpu_disabled)
1145                 tegra_dvfs_rail_disable(&tegra21_dvfs_rail_vdd_cpu);
1146         if (tegra_dvfs_gpu_disabled)
1147                 tegra_dvfs_rail_disable(&tegra21_dvfs_rail_vdd_gpu);
1148
1149         for (i = 0; i < ARRAY_SIZE(tegra21_dvfs_rails); i++) {
1150                 struct dvfs_rail *rail = tegra21_dvfs_rails[i];
1151                 pr_info("tegra dvfs: %s: nominal %dmV, offset %duV, step %duV, scaling %s\n",
1152                         rail->reg_id, rail->nominal_millivolts,
1153                         rail->alignment.offset_uv, rail->alignment.step_uv,
1154                         rail->disabled ? "disabled" : "enabled");
1155         }
1156 }
1157
1158 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
1159 {
1160         return 0;
1161 }
1162
1163 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
1164 {
1165         return 0;
1166 }
1167
1168 /* Core voltage and bus cap object and tables */
1169 static struct kobject *cap_kobj;
1170 static struct kobject *gpu_kobj;
1171
1172 static struct core_dvfs_cap_table tegra21_core_cap_table[] = {
1173         { .cap_name = "cap.vcore.c2bus" },
1174         { .cap_name = "cap.vcore.c3bus" },
1175         { .cap_name = "cap.vcore.sclk" },
1176         { .cap_name = "cap.vcore.emc" },
1177         { .cap_name = "cap.vcore.host1x" },
1178         { .cap_name = "cap.vcore.mselect" },
1179 };
1180
1181 static struct core_bus_limit_table tegra21_gpu_cap_syfs = {
1182         .limit_clk_name = "cap.profile.gbus",
1183         .refcnt_attr = {.attr = {.name = "gpu_cap_state", .mode = 0644} },
1184         .level_attr  = {.attr = {.name = "gpu_cap_rate", .mode = 0644} },
1185         .pm_qos_class = PM_QOS_GPU_FREQ_MAX,
1186 };
1187
1188 static struct core_bus_limit_table tegra21_gpu_floor_sysfs = {
1189         .limit_clk_name = "floor.profile.gbus",
1190         .refcnt_attr = {.attr = {.name = "gpu_floor_state", .mode = 0644} },
1191         .level_attr  = {.attr = {.name = "gpu_floor_rate", .mode = 0644} },
1192         .pm_qos_class = PM_QOS_GPU_FREQ_MIN,
1193 };
1194
1195 static struct core_bus_rates_table tegra21_gpu_rates_sysfs = {
1196         .bus_clk_name = "gbus",
1197         .rate_attr = {.attr = {.name = "gpu_rate", .mode = 0444} },
1198         .available_rates_attr = {
1199                 .attr = {.name = "gpu_available_rates", .mode = 0444} },
1200 };
1201
1202
1203 static int __init tegra21_dvfs_init_core_cap(void)
1204 {
1205         int ret = 0;
1206
1207         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
1208         if (!cap_kobj) {
1209                 pr_err("tegra21_dvfs: failed to create sysfs cap object\n");
1210                 return 0;
1211         }
1212
1213         if (!tegra_platform_is_qt())
1214                 ret = tegra_init_core_cap(
1215                         tegra21_core_cap_table,
1216                         ARRAY_SIZE(tegra21_core_cap_table),
1217                         core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
1218
1219         if (ret) {
1220                 pr_err("tegra21_dvfs: failed to init core cap interface (%d)\n",
1221                        ret);
1222                 kobject_del(cap_kobj);
1223                 return 0;
1224         }
1225         tegra_core_cap_debug_init();
1226         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
1227
1228         gpu_kobj = kobject_create_and_add("tegra_gpu", kernel_kobj);
1229         if (!gpu_kobj) {
1230                 pr_err("tegra21_dvfs: failed to create sysfs gpu object\n");
1231                 return 0;
1232         }
1233
1234         ret = tegra_init_shared_bus_cap(&tegra21_gpu_cap_syfs,
1235                                         1, gpu_kobj);
1236         if (ret) {
1237                 pr_err("tegra21_dvfs: failed to init gpu cap interface (%d)\n",
1238                        ret);
1239                 kobject_del(gpu_kobj);
1240                 return 0;
1241         }
1242
1243         ret = tegra_init_shared_bus_floor(&tegra21_gpu_floor_sysfs,
1244                                           1, gpu_kobj);
1245         if (ret) {
1246                 pr_err("tegra21_dvfs: failed to init gpu floor interface (%d)\n",
1247                        ret);
1248                 kobject_del(gpu_kobj);
1249                 return 0;
1250         }
1251
1252         ret = tegra_init_sysfs_shared_bus_rate(&tegra21_gpu_rates_sysfs,
1253                                                1, gpu_kobj);
1254         if (ret) {
1255                 pr_err("tegra21_dvfs: failed to init gpu rates interface (%d)\n",
1256                        ret);
1257                 kobject_del(gpu_kobj);
1258                 return 0;
1259         }
1260
1261         pr_info("tegra dvfs: tegra sysfs gpu interface is initialized\n");
1262
1263         return 0;
1264 }
1265 late_initcall(tegra21_dvfs_init_core_cap);