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