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