ARM: tegra12: set CPU rate to 2.2GHz for sku 0x87
[linux-3.10.git] / arch / arm / mach-tegra / tegra14_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra14_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 "board.h"
28 #include "tegra_cl_dvfs.h"
29 #include "tegra_core_sysfs_limits.h"
30
31 static bool tegra_dvfs_cpu_disabled;
32 static bool tegra_dvfs_core_disabled;
33
34 #define KHZ 1000
35 #define MHZ 1000000
36
37 /* FIXME: need tegra14 step */
38 #define VDD_SAFE_STEP                   100
39
40 static int vdd_core_vmin_trips_table[MAX_THERMAL_LIMITS] = { 20, };
41 static int vdd_core_therm_floors_table[MAX_THERMAL_LIMITS] = { 900, };
42
43 static int vdd_cpu_vmax_trips_table[MAX_THERMAL_LIMITS] = { 62,   72, };
44 static int vdd_cpu_therm_caps_table[MAX_THERMAL_LIMITS] = { 1180, 1150, };
45
46 static struct tegra_cooling_device cpu_vmax_cdev = {
47         .cdev_type = "cpu_hot",
48 };
49
50 static struct tegra_cooling_device cpu_vmin_cdev = {
51         .cdev_type = "cpu_cold",
52 };
53
54 static struct tegra_cooling_device core_vmin_cdev = {
55         .cdev_type = "core_cold",
56 };
57
58 static struct dvfs_rail tegra14_dvfs_rail_vdd_cpu = {
59         .reg_id = "vdd_cpu",
60         .max_millivolts = 1400,
61         .min_millivolts = 800,
62         .step = VDD_SAFE_STEP,
63         .jmp_to_zero = true,
64         .vmin_cdev = &cpu_vmin_cdev,
65         .vmax_cdev = &cpu_vmax_cdev,
66 };
67
68 static struct dvfs_rail tegra14_dvfs_rail_vdd_core = {
69         .reg_id = "vdd_core",
70         .max_millivolts = 1400,
71         .min_millivolts = 800,
72         .step = VDD_SAFE_STEP,
73         .vmin_cdev = &core_vmin_cdev,
74 };
75
76 static struct dvfs_rail *tegra14_dvfs_rails[] = {
77         &tegra14_dvfs_rail_vdd_cpu,
78         &tegra14_dvfs_rail_vdd_core,
79 };
80
81 /* default cvb alignment on Tegra14 - 10mV */
82 int __attribute__((weak)) tegra_get_cvb_alignment_uV(void)
83 {
84         return 10000;
85 }
86
87 int __attribute__((weak)) tegra_get_core_cvb_alignment_uV(void)
88 {
89         return  6250;
90 }
91
92 /* CPU DVFS tables */
93 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
94         {
95                 .speedo_id = 0,
96                 .process_id = -1,
97                 .dfll_tune_data  = {
98                         .tune0          = 0x0041061F,
99                         .tune0_high_mv  = 0x0041001F,
100                         .tune1          = 0x00000007,
101                         .droop_rate_min = 1000000,
102                         .tune_high_min_millivolts = 900,
103                         .tune_high_margin_mv = 40,
104                         .min_millivolts = 800,
105                 },
106                 .max_mv = 1230,
107                 .freqs_mult = KHZ,
108                 .speedo_scale = 100,
109                 .voltage_scale = 1000,
110                 .cvb_table = {
111                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
112                         { 408000, { 2167974,  -118652,   2434}, {  812396,    0,    0} },
113                         { 510000, { 2210727,  -119982,   2434}, {  824163,    0,    0} },
114                         { 612000, { 2255116,  -121322,   2434}, {  837498,    0,    0} },
115                         { 714000, { 2301137,  -122662,   2434}, {  852671,    0,    0} },
116                         { 816000, { 2348792,  -124002,   2434}, {  869680,    0,    0} },
117                         { 918000, { 2398075,  -125332,   2434}, {  888794,    0,    0} },
118                         {1020000, { 2448994,  -126672,   2434}, {  909476,    0,    0} },
119                         {1122000, { 2501546,  -128012,   2434}, {  931995,    0,    0} },
120                         {1224000, { 2555727,  -129342,   2434}, {  956619,    0,    0} },
121                         {1326000, { 2611544,  -130682,   2434}, {  982812,    0,    0} },
122                         {1428000, { 2668994,  -132022,   2434}, { 1010841,    0,    0} },
123                         {1530000, { 2728076,  -133362,   2434}, { 1040706,    0,    0} },
124                         {1632000, { 2788787,  -134692,   2434}, { 1072677,    0,    0} },
125                         {1734000, { 2851134,  -136032,   2434}, { 1106216,    0,    0} },
126                         {      0, {      0,      0,   0}, {      0,    0,    0} },
127                 },
128                 .vmin_trips_table = { 20 },
129                 .therm_floors_table = { 900 },
130         },
131         {
132                 .speedo_id = 1,
133                 .process_id = 1,
134                 .dfll_tune_data  = {
135                         .tune0          = 0x0041061F,
136                         .tune0_high_mv  = 0x0041001F,
137                         .tune1          = 0x00000007,
138                         .droop_rate_min = 1000000,
139                         .tune_high_min_millivolts = 900,
140                         .tune_high_margin_mv = 40,
141                         .min_millivolts = 800,
142                 },
143                 .max_mv = 1230,
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                         { 408000, { 2167974,  -118652,   2434}, {  812396,    0,    0} },
150                         { 510000, { 2210727,  -119982,   2434}, {  824163,    0,    0} },
151                         { 612000, { 2255116,  -121322,   2434}, {  837498,    0,    0} },
152                         { 714000, { 2301137,  -122662,   2434}, {  852671,    0,    0} },
153                         { 816000, { 2348792,  -124002,   2434}, {  869680,    0,    0} },
154                         { 918000, { 2398075,  -125332,   2434}, {  888794,    0,    0} },
155                         {1020000, { 2448994,  -126672,   2434}, {  909476,    0,    0} },
156                         {1122000, { 2501546,  -128012,   2434}, {  931995,    0,    0} },
157                         {1224000, { 2555727,  -129342,   2434}, {  956619,    0,    0} },
158                         {1326000, { 2611544,  -130682,   2434}, {  982812,    0,    0} },
159                         {1428000, { 2668994,  -132022,   2434}, { 1010841,    0,    0} },
160                         {1530000, { 2728076,  -133362,   2434}, { 1040706,    0,    0} },
161                         {1632000, { 2788787,  -134692,   2434}, { 1072677,    0,    0} },
162                         {1734000, { 2851134,  -136032,   2434}, { 1106216,    0,    0} },
163                         {1836000, { 2915114,  -137372,   2434}, { 1141591,    0,    0} },
164                         {1938000, { 2980727,  -138712,   2434}, { 1178803,    0,    0} },
165                         {2014500, { 3030673,  -139702,   2434}, { 1207951,    0,    0} },
166                         {2116500, { 3099135,  -141042,   2434}, { 1248368,    0,    0} },
167                         {      0, {      0,      0,   0}, {      0,    0,    0} },
168                 },
169                 .vmin_trips_table = { 20 },
170                 .therm_floors_table = { 900 },
171         },
172 };
173
174 static int cpu_millivolts[MAX_DVFS_FREQS];
175 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
176
177 static struct dvfs cpu_dvfs = {
178         .clk_name       = "cpu_g",
179         .millivolts     = cpu_millivolts,
180         .dfll_millivolts = cpu_dfll_millivolts,
181         .auto_dvfs      = true,
182         .dvfs_rail      = &tegra14_dvfs_rail_vdd_cpu,
183 };
184
185 /* Core DVFS tables */
186 static const int core_millivolts[MAX_DVFS_FREQS] = {
187         800, 850, 900, 950, 1000, 1050, 1100, 1150, 1200, 1230};
188
189 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...)  \
190         {                                                       \
191                 .clk_name       = _clk_name,                    \
192                 .speedo_id      = _speedo_id,                   \
193                 .process_id     = _process_id,                  \
194                 .freqs          = {_freqs},                     \
195                 .freqs_mult     = _mult,                        \
196                 .millivolts     = core_millivolts,              \
197                 .auto_dvfs      = _auto,                        \
198                 .dvfs_rail      = &tegra14_dvfs_rail_vdd_core,  \
199         }
200
201 #define OVRRD_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
202         {                                                       \
203                 .clk_name       = _clk_name,                    \
204                 .speedo_id      = _speedo_id,                   \
205                 .process_id     = _process_id,                  \
206                 .freqs          = {_freqs},                     \
207                 .freqs_mult     = _mult,                        \
208                 .millivolts     = core_millivolts,              \
209                 .auto_dvfs      = _auto,                        \
210                 .can_override   = true,                         \
211                 .dvfs_rail      = &tegra14_dvfs_rail_vdd_core,  \
212         }
213
214
215 static struct dvfs core_dvfs_table[] = {
216         /* Core voltages (mV):                       800,    850,    900,    950,   1000,   1050,   1100,   1150,   1200,   1230 */
217         CORE_DVFS("cpu_lp",   0,  0, 1, KHZ,      249600, 364800, 460800, 556800, 633600, 691200, 729600, 768000, 768000, 768000),
218         CORE_DVFS("cpu_lp",   0,  1, 1, KHZ,      307200, 393600, 489600, 556800, 652800, 729600, 768000, 768000, 768000, 768000),
219         CORE_DVFS("cpu_lp",   1,  1, 1, KHZ,      307200, 393600, 489600, 556800, 652800, 729600, 768000, 806400, 806400, 806400),
220
221 #ifndef CONFIG_TEGRA_DUAL_CBUS
222         CORE_DVFS("3d",       0,  0, 1, KHZ,      153600, 230400, 307200, 384000, 499200, 556800, 600000, 600000, 600000, 600000),
223         CORE_DVFS("2d",       0,  0, 1, KHZ,      153600, 230400, 307200, 384000, 499200, 556800, 600000, 600000, 600000, 600000),
224         CORE_DVFS("epp",      0,  0, 1, KHZ,      153600, 230400, 307200, 384000, 499200, 556800, 600000, 600000, 600000, 600000),
225         CORE_DVFS("3d",       0,  1, 1, KHZ,      192000, 268800, 345600, 384000, 499200, 556800, 600000, 600000, 600000, 600000),
226         CORE_DVFS("2d",       0,  1, 1, KHZ,      192000, 268800, 345600, 384000, 499200, 556800, 600000, 600000, 600000, 600000),
227         CORE_DVFS("epp",      0,  1, 1, KHZ,      192000, 268800, 345600, 384000, 499200, 556800, 600000, 600000, 600000, 600000),
228         CORE_DVFS("3d",       1,  1, 1, KHZ,      192000, 268800, 345600, 384000, 499200, 556800, 595200, 672000, 710400, 748800),
229         CORE_DVFS("2d",       1,  1, 1, KHZ,      192000, 268800, 345600, 384000, 499200, 556800, 595200, 672000, 710400, 748800),
230         CORE_DVFS("epp",      1,  1, 1, KHZ,      192000, 268800, 345600, 384000, 499200, 556800, 595200, 672000, 710400, 748800),
231 #endif
232         CORE_DVFS("se",       0,  0, 1, KHZ,      115200, 192000, 249600, 326400, 364800, 441600, 480000, 518400, 518400, 518400),
233         CORE_DVFS("vde",      0,  0, 1, KHZ,      115200, 192000, 249600, 326400, 364800, 441600, 480000, 518400, 518400, 518400),
234         CORE_DVFS("se",       0,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 518400, 518400, 518400),
235         CORE_DVFS("vde",      0,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 518400, 518400, 518400),
236         CORE_DVFS("se",       1,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 537600, 537600, 537600),
237         CORE_DVFS("vde",      1,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 537600, 537600, 537600),
238
239         CORE_DVFS("msenc",    0,  0, 1, KHZ,       68000, 102000, 136000, 204000, 204000, 204000, 384000, 408000, 408000, 408000),
240         CORE_DVFS("msenc",    0,  1, 1, KHZ,       81600, 136000, 204000, 204000, 204000, 204000, 408000, 408000, 408000, 408000),
241         CORE_DVFS("msenc",    1,  1, 1, KHZ,       81600, 136000, 204000, 204000, 204000, 204000, 408000, 408000, 408000, 408000),
242
243         CORE_DVFS("tsec",     0,  0, 1, KHZ,      136000, 204000, 204000, 408000, 408000, 408000, 408000, 408000, 408000, 408000),
244         CORE_DVFS("tsec",     0,  1, 1, KHZ,      136000, 204000, 384000, 408000, 408000, 408000, 408000, 408000, 408000, 408000),
245         CORE_DVFS("tsec",     1,  1, 1, KHZ,      136000, 204000, 384000, 408000, 408000, 408000, 408000, 408000, 408000, 408000),
246
247         CORE_DVFS("host1x",   0,  0, 1, KHZ,      102000, 102000, 204000, 204000, 204000, 204000, 384000, 408000, 408000, 408000),
248         CORE_DVFS("host1x",   0,  1, 1, KHZ,      136000, 136000, 204000, 204000, 204000, 384000, 384000, 408000, 408000, 408000),
249         CORE_DVFS("host1x",   1,  1, 1, KHZ,      136000, 136000, 204000, 204000, 204000, 384000, 384000, 408000, 408000, 408000),
250
251         CORE_DVFS("vi",      -1, -1, 1, KHZ,      136000, 204000, 204000, 408000, 408000, 408000, 408000, 408000, 408000, 408000),
252         CORE_DVFS("isp",     -1, -1, 1, KHZ,      136000, 204000, 204000, 408000, 408000, 408000, 408000, 408000, 408000, 408000),
253
254         CORE_DVFS("sbus",     0,  0, 1, KHZ,      102000, 102000, 102000, 102000, 204000, 384000, 384000, 408000, 408000, 408000),
255         CORE_DVFS("sbus",     0,  1, 1, KHZ,      136000, 136000, 204000, 204000, 204000, 384000, 384000, 408000, 408000, 408000),
256         CORE_DVFS("sbus",     1,  1, 1, KHZ,      136000, 136000, 204000, 204000, 204000, 384000, 384000, 408000, 408000, 408000),
257
258         CORE_DVFS("emc",     -1, -1, 1, KHZ,           1,      1,      1,      1,      1,      1,1066000,1066000,1066000,1066000),
259
260 #ifdef CONFIG_TEGRA_DUAL_CBUS
261         CORE_DVFS("c3bus",    0,  0, 1, KHZ,      115200, 192000, 249600, 326400, 364800, 441600, 480000, 518400, 518400, 518400),
262         CORE_DVFS("c3bus",    0,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 518400, 518400, 518400),
263         CORE_DVFS("c3bus",    1,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 537600, 537600, 537600),
264 #else
265         CORE_DVFS("cbus",     0,  0, 1, KHZ,      115200, 192000, 249600, 326400, 364800, 441600, 480000, 518400, 518400, 518400),
266         CORE_DVFS("cbus",     0,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 518400, 518400, 518400),
267         CORE_DVFS("cbus",     1,  1, 1, KHZ,      153600, 211200, 288000, 345600, 403200, 460800, 499200, 537600, 537600, 537600),
268 #endif
269         /* Core voltages (mV):                       800,    850,    900,    950,   1000,   1050,   1100,   1150,   1200,   1230 */
270         /* Clock limits for I/O peripherals */
271         CORE_DVFS("cilab",  -1, -1, 1, KHZ,       102000, 102000, 102000, 102000, 102000, 114700, 136000, 136000, 136000, 136000),
272         CORE_DVFS("cilcd",  -1, -1, 1, KHZ,       102000, 102000, 102000, 102000, 102000, 114700, 136000, 136000, 136000, 136000),
273         CORE_DVFS("cile",   -1, -1, 1, KHZ,       102000, 102000, 102000, 102000, 102000, 114700, 136000, 136000, 136000, 136000),
274         CORE_DVFS("dsia",  -1, -1, 1, KHZ,        252000, 431000, 431000, 431000, 431000, 431000, 431000, 431000, 431000, 431000),
275         CORE_DVFS("dsib",  -1, -1, 1, KHZ,        252000, 431000, 431000, 431000, 431000, 431000, 431000, 431000, 431000, 431000),
276         CORE_DVFS("hdmi",   -1, -1, 1, KHZ,       111300, 111300, 111300, 135600, 173200, 212300, 270000, 270000, 270000, 270000),
277
278         CORE_DVFS("pll_m",   0,  0, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
279         CORE_DVFS("pll_c",   0,  0, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
280         CORE_DVFS("pll_c2",  0,  0, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
281         CORE_DVFS("pll_c3",  0,  0, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
282         CORE_DVFS("pll_m",   0,  1, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
283         CORE_DVFS("pll_c",   0,  1, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
284         CORE_DVFS("pll_c2",  0,  1, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
285         CORE_DVFS("pll_c3",  0,  1, 1, KHZ,       408000, 667000, 800000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
286         CORE_DVFS("pll_m",   1,  1, 1, KHZ,       533000, 667000, 933000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
287         CORE_DVFS("pll_c",   1,  1, 1, KHZ,       533000, 667000, 933000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
288         CORE_DVFS("pll_c2",  1,  1, 1, KHZ,       533000, 667000, 933000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
289         CORE_DVFS("pll_c3",  1,  1, 1, KHZ,       533000, 667000, 933000,1066000,1066000,1066000,1066000,1066000,1066000,1066000),
290
291         /* Core voltages (mV):» »                    800,    850,    900,    950,   1000,   1050,   1100,   1150,   1200,   1230 */
292         /* Clock limits for IO Peripherals */
293         CORE_DVFS("sbc1",   -1, -1, 1, KHZ,        33000,  33000,  33000,  30000,  30000,  50000,  50000,  50000,  50000,  50000),
294         CORE_DVFS("sbc2",   -1, -1, 1, KHZ,        33000,  33000,  33000,  30000,  30000,  50000,  50000,  50000,  50000,  50000),
295         CORE_DVFS("sbc3",   -1, -1, 1, KHZ,        33000,  33000,  33000,  30000,  30000,  50000,  50000,  50000,  50000,  50000),
296
297         OVRRD_DVFS("sdmmc1", -1, -1, 1, KHZ,       51000,  51000,  51000,  51000,  51000,  51000, 136000, 136000, 136000, 204000),
298         OVRRD_DVFS("sdmmc3", -1, -1, 1, KHZ,       51000,  51000,  51000,  51000,  51000,  51000, 136000, 136000, 136000, 204000),
299         OVRRD_DVFS("sdmmc4", -1, -1, 1, KHZ,       51000,  51000,  51000,  51000,  51000,  51000, 136000, 136000, 136000, 192000),
300
301         /*
302          * The clock rate for the display controllers that determines the
303          * necessary core voltage depends on a divider that is internal
304          * to the display block. Disable auto-dvfs on the display clocks,
305          * and let the display driver call tegra_dvfs_set_rate manually
306          */
307         CORE_DVFS("disp1",  -1, -1, 0, KHZ,        74250, 165000, 165000, 165000, 165000, 165000, 165000, 165000, 165000, 165000),
308         CORE_DVFS("disp2",  -1, -1, 0, KHZ,        74250, 165000, 165000, 165000, 165000, 165000, 165000, 165000, 165000, 165000),
309 };
310
311 /* C2BUS dvfs tables */
312 static struct core_cvb_dvfs c2bus_cvb_dvfs_table[] = {
313         {
314                 .speedo_id =  0,
315                 .process_id = 0,
316                 .freqs_mult = KHZ,
317                 .speedo_scale = 100,
318                 .voltage_scale = 1000,
319                 .cvb_table = {
320                         /*f       dfll  pll:   c0,     c1,   c2 */
321                         { 153600, {  }, {  800000,      0,   0}, },
322                         { 230400, {  }, {  850000,      0,   0}, },
323                         { 307200, {  }, {  900000,      0,   0}, },
324                         { 384000, {  }, {  950000,      0,   0}, },
325                         { 499200, {  }, { 1000000,      0,   0}, },
326                         { 556800, {  }, { 1050000,      0,   0}, },
327                         { 600000, {  }, { 1100000,      0,   0}, },
328                         { 600000, {  }, { 1150000,      0,   0}, },
329                         { 600000, {  }, { 1200000,      0,   0}, },
330                         { 600000, {  }, { 1230000,      0,   0}, },
331                         {      0, {  }, {       0,      0,   0}, },
332                 },
333         },
334         {
335                 .speedo_id =  0,
336                 .process_id = 1,
337                 .freqs_mult = KHZ,
338                 .speedo_scale = 100,
339                 .voltage_scale = 1000,
340                 .cvb_table = {
341                         /*f       dfll  pll:   c0,     c1,   c2 */
342                         { 192000, {  }, {  800000,      0,   0}, },
343                         { 268800, {  }, {  850000,      0,   0}, },
344                         { 345600, {  }, {  900000,      0,   0}, },
345                         { 384000, {  }, {  950000,      0,   0}, },
346                         { 499200, {  }, { 1000000,      0,   0}, },
347                         { 556800, {  }, { 1050000,      0,   0}, },
348                         { 600000, {  }, { 1100000,      0,   0}, },
349                         { 600000, {  }, { 1150000,      0,   0}, },
350                         { 600000, {  }, { 1200000,      0,   0}, },
351                         { 600000, {  }, { 1230000,      0,   0}, },
352                         {      0, {  }, {       0,      0,   0}, },
353                 },
354         },
355         {
356                 .speedo_id =  1,
357                 .process_id = 1,
358                 .freqs_mult = KHZ,
359                 .speedo_scale = 100,
360                 .voltage_scale = 1000,
361                 .cvb_table = {
362                         /*f       dfll  pll:   c0,     c1,   c2 */
363                         { 192000, {  }, {  800000,      0,   0}, },
364                         { 268800, {  }, {  850000,      0,   0}, },
365                         { 345600, {  }, {  900000,      0,   0}, },
366                         { 384000, {  }, {  950000,      0,   0}, },
367                         { 499200, {  }, { 1000000,      0,   0}, },
368                         { 556800, {  }, { 1050000,      0,   0}, },
369                         { 595200, {  }, { 1100000,      0,   0}, },
370                         { 672000, {  }, { 1150000,      0,   0}, },
371                         { 710400, {  }, { 1200000,      0,   0}, },
372                         { 748800, {  }, { 1230000,      0,   0}, },
373                         {      0, {  }, {      0,       0,   0}, },
374                 },
375         },
376 };
377
378 static int c2bus_millivolts[MAX_DVFS_FREQS];
379 static struct dvfs c2bus_dvfs_table[] = {
380         { .clk_name = "3d", },
381         { .clk_name = "2d", },
382         { .clk_name = "epp", },
383         { .clk_name = "c2bus", },       /* must be the last */
384 };
385
386 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
387 {
388         int ret;
389
390         ret = param_set_bool(arg, kp);
391         if (ret)
392                 return ret;
393
394         if (tegra_dvfs_core_disabled)
395                 tegra_dvfs_rail_disable(&tegra14_dvfs_rail_vdd_core);
396         else
397                 tegra_dvfs_rail_enable(&tegra14_dvfs_rail_vdd_core);
398
399         return 0;
400 }
401
402 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
403 {
404         int ret;
405
406         ret = param_set_bool(arg, kp);
407         if (ret)
408                 return ret;
409
410         if (tegra_dvfs_cpu_disabled)
411                 tegra_dvfs_rail_disable(&tegra14_dvfs_rail_vdd_cpu);
412         else
413                 tegra_dvfs_rail_enable(&tegra14_dvfs_rail_vdd_cpu);
414
415         return 0;
416 }
417
418 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
419 {
420         return param_get_bool(buffer, kp);
421 }
422
423 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
424         .set = tegra_dvfs_disable_core_set,
425         .get = tegra_dvfs_disable_get,
426 };
427
428 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
429         .set = tegra_dvfs_disable_cpu_set,
430         .get = tegra_dvfs_disable_get,
431 };
432
433 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
434         &tegra_dvfs_core_disabled, 0644);
435 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
436         &tegra_dvfs_cpu_disabled, 0644);
437
438 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
439 {
440         /* Don't update manual dvfs clocks */
441         if (!d->auto_dvfs)
442                 return false;
443
444         /*
445          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
446          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
447          * together with the image) and board specific EMC DFS table; we will
448          * check the scaling ladder against nominal core voltage when the table
449          * is loaded (and if on particular board the table is not loaded, EMC
450          * scaling is disabled).
451          */
452         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
453                 return false;
454
455         /*
456          * Don't update shared cbus, and don't propagate common cbus dvfs
457          * limit down to shared users, but set maximum rate for each user
458          * equal to the respective client limit.
459          */
460         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
461                 struct clk *user;
462                 unsigned long rate;
463
464                 list_for_each_entry(
465                         user, &c->shared_bus_list, u.shared_bus_user.node) {
466                         if (user->u.shared_bus_user.client) {
467                                 rate = user->u.shared_bus_user.client->max_rate;
468                                 user->max_rate = rate;
469                                 user->u.shared_bus_user.rate = rate;
470                         }
471                 }
472                 return false;
473         }
474
475         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
476         return true;
477 }
478
479 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
480 {
481         int ret;
482         struct clk *c = tegra_get_clock_by_name(d->clk_name);
483
484         if (!c) {
485                 pr_debug("tegra14_dvfs: no clock found for %s\n",
486                         d->clk_name);
487                 return;
488         }
489
490         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
491         if (can_update_max_rate(c, d)) {
492                 BUG_ON(!d->freqs[max_freq_index]);
493                 tegra_init_max_rate(
494                         c, d->freqs[max_freq_index] * d->freqs_mult);
495         }
496         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
497
498         ret = tegra_enable_dvfs_on_clk(c, d);
499         if (ret)
500                 pr_err("tegra14_dvfs: failed to enable dvfs on %s\n", c->name);
501 }
502
503 static bool __init match_dvfs_one(const char *name,
504         int dvfs_speedo_id, int dvfs_process_id,
505         int speedo_id, int process_id)
506 {
507         if ((dvfs_process_id != -1 && dvfs_process_id != process_id) ||
508                 (dvfs_speedo_id != -1 && dvfs_speedo_id != speedo_id)) {
509                 pr_debug("tegra14_dvfs: rejected %s speedo %d, process %d\n",
510                          name, dvfs_speedo_id, dvfs_process_id);
511                 return false;
512         }
513         return true;
514 }
515
516 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
517 static inline int get_cvb_voltage(int speedo, int s_scale,
518                                   struct cvb_dvfs_parameters *cvb)
519 {
520         /* apply only speedo scale: output mv = cvb_mv * v_scale */
521         int mv;
522         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
523         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
524         return mv;
525 }
526
527 static inline int round_cvb_voltage(int mv, int v_scale)
528 {
529         /* combined: apply voltage scale and round to cvb alignment step */
530         int cvb_align_step_uv = tegra_get_cvb_alignment_uV();
531
532         return DIV_ROUND_UP(mv * 1000, v_scale * cvb_align_step_uv) *
533                 cvb_align_step_uv / 1000;
534 }
535
536 static inline int round_core_cvb_voltage(int mv, int v_scale)
537 {
538         /* combined: apply voltage scale and round to cvb alignment step */
539         int cvb_align_step_uv = tegra_get_core_cvb_alignment_uV();
540
541         return DIV_ROUND_UP(mv * 1000, v_scale * cvb_align_step_uv) *
542                 cvb_align_step_uv / 1000;
543 }
544
545 static int __init set_cpu_dvfs_data(
546         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
547 {
548         int i, j, mv, dfll_mv, min_dfll_mv;
549         unsigned long fmax_at_vmin = 0;
550         unsigned long fmax_pll_mode = 0;
551         unsigned long fmin_use_dfll = 0;
552         struct cvb_dvfs_table *table = NULL;
553         int speedo = tegra_cpu_speedo_value();
554
555         min_dfll_mv = d->dfll_tune_data.min_millivolts;
556         min_dfll_mv =  round_cvb_voltage(min_dfll_mv * 1000, 1000);
557         d->max_mv = round_cvb_voltage(d->max_mv * 1000, 1000);
558         BUG_ON(min_dfll_mv < tegra14_dvfs_rail_vdd_cpu.min_millivolts);
559
560         /*
561          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
562          * CVB entry specifies CPU frequency and CVB coefficients to calculate
563          * the respective voltage when either DFLL or PLL is used as CPU clock
564          * source.
565          *
566          * Minimum voltage limit is applied only to DFLL source. For PLL source
567          * voltage can go as low as table specifies. Maximum voltage limit is
568          * applied to both sources, but differently: directly clip voltage for
569          * DFLL, and limit maximum frequency for PLL.
570          */
571         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
572                 table = &d->cvb_table[i];
573                 if (!table->freq)
574                         break;
575
576                 dfll_mv = get_cvb_voltage(
577                         speedo, d->speedo_scale, &table->cvb_dfll_param);
578                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale);
579
580                 mv = get_cvb_voltage(
581                         speedo, d->speedo_scale, &table->cvb_pll_param);
582                 mv = round_cvb_voltage(mv, d->voltage_scale);
583
584                 /*
585                  * Check maximum frequency at minimum voltage for dfll source;
586                  * round down unless all table entries are above Vmin, then use
587                  * the 1st entry as is.
588                  */
589                 dfll_mv = max(dfll_mv, min_dfll_mv);
590                 if (dfll_mv > min_dfll_mv) {
591                         if (!j)
592                                 fmax_at_vmin = table->freq;
593                         if (!fmax_at_vmin)
594                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
595                 }
596
597                 /* Clip maximum frequency at maximum voltage for pll source */
598                 if (mv > d->max_mv) {
599                         if (!j)
600                                 break;  /* 1st entry already above Vmax */
601                         if (!fmax_pll_mode)
602                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
603                 }
604
605                 /* Minimum rate with pll source voltage above dfll Vmin */
606                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
607                         fmin_use_dfll = table->freq;
608
609                 /* fill in dvfs tables */
610                 cpu_dvfs->freqs[j] = table->freq;
611                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
612                 cpu_millivolts[j] = mv;
613                 j++;
614
615                 /*
616                  * "Round-up" frequency list cut-off (keep first entry that
617                  *  exceeds max voltage - the voltage limit will be enforced
618                  *  anyway, so when requested this frequency dfll will settle
619                  *  at whatever high frequency it can on the particular chip)
620                  */
621                 if (dfll_mv > d->max_mv)
622                         break;
623         }
624         /* Table must not be empty, must have at least one entry above Vmin */
625         if (!i || !j || !fmax_at_vmin) {
626                 pr_err("tegra14_dvfs: invalid cpu dvfs table\n");
627                 return -ENOENT;
628         }
629
630         /* In the dfll operating range dfll voltage at any rate should be
631            better (below) than pll voltage */
632         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
633                 WARN(1, "tegra14_dvfs: pll voltage is below dfll in the dfll"
634                         " operating range\n");
635                 fmin_use_dfll = fmax_at_vmin;
636         }
637
638         /* dvfs tables are successfully populated - fill in the rest */
639         cpu_dvfs->speedo_id = d->speedo_id;
640         cpu_dvfs->process_id = d->process_id;
641         cpu_dvfs->freqs_mult = d->freqs_mult;
642         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
643                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
644         *max_freq_index = j - 1;
645
646         cpu_dvfs->dfll_data = d->dfll_tune_data;
647         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
648                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
649         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
650         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
651         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
652         return 0;
653 }
654
655 static int __init set_c2bus_dvfs_data(
656         struct core_cvb_dvfs *d, struct dvfs *c2bus_dvfs, int *max_freq_index)
657 {
658         int i, j, mv, min_mv, max_mv;
659         struct cvb_dvfs_table *table = NULL;
660         int speedo = 0; /* FIXME: tegra_core_speedo_value(); */
661
662         min_mv = round_core_cvb_voltage(core_millivolts[0] * 1000, 1000);
663         max_mv = tegra14_dvfs_rail_vdd_core.nominal_millivolts;
664
665         /*
666          * Use CVB table to fill in c2bus dvfs frequencies and voltages. Each
667          * CVB entry specifies c2bus frequency and CVB coefficients to calculate
668          * the respective voltage.
669          */
670         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
671                 table = &d->cvb_table[i];
672                 if (!table->freq)
673                         break;
674
675                 mv = get_cvb_voltage(
676                         speedo, d->speedo_scale, &table->cvb_pll_param);
677                 mv = round_core_cvb_voltage(mv, d->voltage_scale);
678
679                 if (mv > max_mv)
680                         break;
681
682                 /* fill in c2bus dvfs tables */
683                 mv = max(mv, min_mv);
684                 if (!j || (mv > c2bus_millivolts[j - 1])) {
685                         c2bus_millivolts[j] = mv;
686                         c2bus_dvfs->freqs[j] = table->freq;
687                         j++;
688                 } else {
689                         c2bus_dvfs->freqs[j - 1] = table->freq;
690                 }
691         }
692         /* Table must not be empty, must have at least one entry above Vmin */
693         if (!i || !j) {
694                 pr_err("tegra14_dvfs: invalid c2bus dvfs table\n");
695                 return -ENOENT;
696         }
697
698         /* dvfs tables are successfully populated - fill in the c2bus dvfs */
699         c2bus_dvfs->speedo_id = d->speedo_id;
700         c2bus_dvfs->process_id = d->process_id;
701         c2bus_dvfs->freqs_mult = d->freqs_mult;
702         c2bus_dvfs->millivolts = c2bus_millivolts;
703         c2bus_dvfs->dvfs_rail = &tegra14_dvfs_rail_vdd_core;
704         c2bus_dvfs->auto_dvfs = 1;
705
706         *max_freq_index = j - 1;
707         return 0;
708 }
709
710 static int __init init_c2bus_cvb_dvfs(int soc_speedo_id, int core_process_id)
711 {
712         int i, ret;
713         int max_freq_index = 0;
714         int n = ARRAY_SIZE(c2bus_cvb_dvfs_table);
715         int m = ARRAY_SIZE(c2bus_dvfs_table);
716         struct dvfs *bus_dvfs = &c2bus_dvfs_table[m - 1];
717
718         /*
719          * Setup bus (last) entry in c2bus legacy dvfs table from cvb data;
720          * determine maximum frequency index (cvb may devine for c2bus modules
721          * number of frequencies, and voltage levels different from other core
722          * dvfs modules). Error when c2bus legacy dvfs table can not be
723          * constructed must never happen.
724          */
725         for (ret = 0, i = 0; i < n; i++) {
726                 struct core_cvb_dvfs *d = &c2bus_cvb_dvfs_table[i];
727                 if (match_dvfs_one("c2bus cvb", d->speedo_id, d->process_id,
728                                    soc_speedo_id, core_process_id)) {
729                         ret = set_c2bus_dvfs_data(d, bus_dvfs, &max_freq_index);
730                         break;
731                 }
732         }
733         BUG_ON((i == n) || ret);
734
735         /*
736          * Copy bus dvfs entry across all entries in c2bus legacy devfs table,
737          * and bind each entry to clock
738          */
739         for (i = 0; i < m; i++) {
740                 struct dvfs *d = &c2bus_dvfs_table[i];
741                 if (d != bus_dvfs) {
742                         const char *name = d->clk_name;
743                         *d = *bus_dvfs;
744                         d->clk_name = name;
745                 }
746 #ifdef CONFIG_TEGRA_DUAL_CBUS
747                 init_dvfs_one(d, max_freq_index);
748 #endif
749         }
750         return 0;
751 }
752
753 static int __init get_core_nominal_mv_index(int speedo_id)
754 {
755         int i;
756         int mv = tegra_core_speedo_mv();
757         int core_edp_limit = get_core_edp();
758
759         /*
760          * Start with nominal level for the chips with this speedo_id. Then,
761          * make sure core nominal voltage is below edp limit for the board
762          * (if edp limit is set).
763          */
764         if (core_edp_limit)
765                 mv = min(mv, core_edp_limit);
766         mv = round_core_cvb_voltage(mv * 1000, 1000);
767
768         /* Round nominal level down to the nearest core scaling step */
769         for (i = 0; i < MAX_DVFS_FREQS; i++) {
770                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
771                         break;
772         }
773
774         if (i == 0) {
775                 pr_err("tegra14_dvfs: unable to adjust core dvfs table to"
776                        " nominal voltage %d\n", mv);
777                 return -ENOSYS;
778         }
779         return i - 1;
780 }
781
782 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
783                          bool before_clk_update, int cpu_event)
784 {
785         /* empty definition for tegra14 */
786         return 0;
787 }
788
789 void __init tegra14x_init_dvfs(void)
790 {
791         int cpu_speedo_id = tegra_cpu_speedo_id();
792         int cpu_process_id = tegra_cpu_process_id();
793         int soc_speedo_id = tegra_soc_speedo_id();
794         int core_process_id = tegra_core_process_id();
795
796         int i, ret;
797         int core_nominal_mv_index;
798         int cpu_max_freq_index = 0;
799
800 #ifndef CONFIG_TEGRA_CORE_DVFS
801         tegra_dvfs_core_disabled = true;
802 #endif
803 #ifndef CONFIG_TEGRA_CPU_DVFS
804         tegra_dvfs_cpu_disabled = true;
805 #endif
806         /* Setup rail bins */
807         tegra14_dvfs_rail_vdd_cpu.stats.bin_uV = tegra_get_cvb_alignment_uV();
808         tegra14_dvfs_rail_vdd_core.stats.bin_uV =
809                 tegra_get_core_cvb_alignment_uV();
810
811         /* Align dvfs voltages */
812         for (i = 0; (i < MAX_DVFS_FREQS) && (core_millivolts[i] != 0); i++) {
813                 ((int *)core_millivolts)[i] =
814                         round_core_cvb_voltage(core_millivolts[i] * 1000, 1000);
815         }
816
817         /*
818          * Find nominal voltages for core (1st) and cpu rails before rail
819          * init. Nominal voltage index in core scaling ladder can also be
820          * used to determine max dvfs frequencies for all core clocks. In
821          * case of error disable core scaling and set index to 0, so that
822          * core clocks would not exceed rates allowed at minimum voltage.
823          */
824         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
825         if (core_nominal_mv_index < 0) {
826                 tegra14_dvfs_rail_vdd_core.disabled = true;
827                 tegra_dvfs_core_disabled = true;
828                 core_nominal_mv_index = 0;
829         }
830         tegra14_dvfs_rail_vdd_core.nominal_millivolts =
831                         core_millivolts[core_nominal_mv_index];
832
833         /*
834          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
835          * voltage for cpu rail, and cpu maximum frequency. Note that entire
836          * frequency range is guaranteed only when dfll is used as cpu clock
837          * source. Reaching maximum frequency with pll as cpu clock source
838          * may not be possible within nominal voltage range (dvfs mechanism
839          * would automatically fail frequency request in this case, so that
840          * voltage limit is not violated). Error when cpu dvfs table can not
841          * be constructed must never happen.
842          */
843         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
844                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
845                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
846                                    cpu_speedo_id, cpu_process_id)) {
847                         ret = set_cpu_dvfs_data(
848                                 d, &cpu_dvfs, &cpu_max_freq_index);
849                         break;
850                 }
851         }
852         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
853
854         /* Init thermal limits */
855         tegra_dvfs_rail_init_vmax_thermal_profile(
856                 vdd_cpu_vmax_trips_table, vdd_cpu_therm_caps_table,
857                 &tegra14_dvfs_rail_vdd_cpu, &cpu_dvfs.dfll_data);
858         tegra_dvfs_rail_init_vmin_thermal_profile(
859                 cpu_cvb_dvfs_table[i].vmin_trips_table,
860                 cpu_cvb_dvfs_table[i].therm_floors_table,
861                 &tegra14_dvfs_rail_vdd_cpu, &cpu_dvfs.dfll_data);
862         tegra_dvfs_rail_init_vmin_thermal_profile(vdd_core_vmin_trips_table,
863                 vdd_core_therm_floors_table, &tegra14_dvfs_rail_vdd_core, NULL);
864
865         /* Init rail structures and dependencies */
866         tegra_dvfs_init_rails(tegra14_dvfs_rails,
867                 ARRAY_SIZE(tegra14_dvfs_rails));
868
869         /* Init c2bus modules (a subset of core dvfs) that have cvb data */
870         init_c2bus_cvb_dvfs(soc_speedo_id, core_process_id);
871
872         /* Search core dvfs table for speedo/process matching entries and
873            initialize dvfs-ed clocks */
874         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
875                 struct dvfs *d = &core_dvfs_table[i];
876                 if (!match_dvfs_one(d->clk_name, d->speedo_id, d->process_id,
877                                     soc_speedo_id, core_process_id))
878                         continue;
879                 init_dvfs_one(d, core_nominal_mv_index);
880         }
881
882         /* Initialize matching cpu dvfs entry already found when nominal
883            voltage was determined */
884         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
885
886         /* Finally disable dvfs on rails if necessary */
887         if (tegra_dvfs_core_disabled)
888                 tegra_dvfs_rail_disable(&tegra14_dvfs_rail_vdd_core);
889         if (tegra_dvfs_cpu_disabled)
890                 tegra_dvfs_rail_disable(&tegra14_dvfs_rail_vdd_cpu);
891
892         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
893                 tegra14_dvfs_rail_vdd_cpu.nominal_millivolts,
894                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
895         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
896                 tegra14_dvfs_rail_vdd_core.nominal_millivolts,
897                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
898 }
899
900 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
901 {
902         return 0;
903 }
904
905 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
906 {
907         return 0;
908 }
909
910 /* Core voltage and bus cap object and tables */
911 static struct kobject *cap_kobj;
912
913 static struct core_dvfs_cap_table tegra14_core_cap_table[] = {
914 #ifdef CONFIG_TEGRA_DUAL_CBUS
915         { .cap_name = "cap.c2bus" },
916         { .cap_name = "cap.c3bus" },
917 #else
918         { .cap_name = "cap.cbus" },
919 #endif
920         { .cap_name = "cap.sclk" },
921         { .cap_name = "cap.emc" },
922         { .cap_name = "cap.host1x" },
923         { .cap_name = "cap.msenc" },
924 };
925
926 /*
927  * Keep sys file names the same for dual and single cbus configurations to
928  * avoid changes in user space GPU capping interface.
929  */
930 static struct core_bus_limit_table tegra14_bus_cap_table[] = {
931 #ifdef CONFIG_TEGRA_DUAL_CBUS
932         { .limit_clk_name = "cap.profile.c2bus",
933           .refcnt_attr = {.attr = {.name = "cbus_cap_state", .mode = 0644} },
934           .level_attr  = {.attr = {.name = "cbus_cap_level", .mode = 0644} },
935         },
936 #else
937         { .limit_clk_name = "cap.profile.cbus",
938           .refcnt_attr = {.attr = {.name = "cbus_cap_state", .mode = 0644} },
939           .level_attr  = {.attr = {.name = "cbus_cap_level", .mode = 0644} },
940         },
941 #endif
942 };
943
944 static int __init tegra14_dvfs_init_core_cap(void)
945 {
946         int ret;
947
948         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
949         if (!cap_kobj) {
950                 pr_err("tegra14_dvfs: failed to create sysfs cap object\n");
951                 return 0;
952         }
953
954         ret = tegra_init_shared_bus_cap(
955                 tegra14_bus_cap_table, ARRAY_SIZE(tegra14_bus_cap_table),
956                 cap_kobj);
957         if (ret) {
958                 pr_err("tegra14_dvfs: failed to init bus cap interface (%d)\n",
959                        ret);
960                 kobject_del(cap_kobj);
961                 return 0;
962         }
963
964         ret = tegra_init_core_cap(
965                 tegra14_core_cap_table, ARRAY_SIZE(tegra14_core_cap_table),
966                 core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
967
968         if (ret) {
969                 pr_err("tegra14_dvfs: failed to init core cap interface (%d)\n",
970                        ret);
971                 kobject_del(cap_kobj);
972                 return 0;
973         }
974         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
975
976         return 0;
977 }
978 late_initcall(tegra14_dvfs_init_core_cap);