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