ARM: tegra12: dvfs: Set override property for sdmmc
[linux-3.10.git] / arch / arm / mach-tegra / tegra12_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra12_dvfs.c
3  *
4  * Copyright (c) 2012-2013 NVIDIA CORPORATION. All rights reserved.
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  */
16
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/string.h>
20 #include <linux/module.h>
21 #include <linux/clk.h>
22 #include <linux/kobject.h>
23 #include <linux/err.h>
24 #include <linux/pm_qos.h>
25
26 #include "clock.h"
27 #include "dvfs.h"
28 #include "fuse.h"
29 #include "board.h"
30 #include "tegra_cl_dvfs.h"
31 #include "tegra_core_sysfs_limits.h"
32
33 static bool tegra_dvfs_cpu_disabled;
34 static bool tegra_dvfs_core_disabled;
35 static bool tegra_dvfs_gpu_disabled;
36
37 #define KHZ 1000
38 #define MHZ 1000000
39
40 /* FIXME: need tegra12 step */
41 #define VDD_SAFE_STEP                   100
42
43 static int vdd_core_therm_trips_table[MAX_THERMAL_LIMITS] = { 20, };
44 static int vdd_core_therm_floors_table[MAX_THERMAL_LIMITS] = { 900, };
45
46 static struct tegra_cooling_device cpu_vmin_cdev = {
47         .cdev_type = "cpu_cold",
48 };
49
50 static struct tegra_cooling_device core_vmin_cdev = {
51         .cdev_type = "core_cold",
52 };
53
54 static struct tegra_cooling_device gpu_vmin_cdev = {
55         .cdev_type = "gpu_cold",
56 };
57
58 static struct dvfs_rail tegra12_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         .alignment = {
66                 .step_uv = 10000, /* 10mV */
67         },
68         .stats = {
69                 .bin_uV = 10000, /* 10mV */
70         }
71 };
72
73 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
74         .reg_id = "vdd_core",
75         .max_millivolts = 1400,
76         .min_millivolts = 800,
77         .step = VDD_SAFE_STEP,
78         .vmin_cdev = &core_vmin_cdev,
79 };
80
81 /* TBD: fill in actual hw number */
82 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
83         .reg_id = "vdd_gpu",
84         .max_millivolts = 1350,
85         .min_millivolts = 700,
86         .step = VDD_SAFE_STEP,
87         .in_band_pm = true,
88         .vmin_cdev = &gpu_vmin_cdev,
89         .alignment = {
90                 .step_uv = 10000, /* 10mV */
91         },
92         .stats = {
93                 .bin_uV = 10000, /* 10mV */
94         }
95 };
96
97 static struct dvfs_rail *tegra12_dvfs_rails[] = {
98         &tegra12_dvfs_rail_vdd_cpu,
99         &tegra12_dvfs_rail_vdd_core,
100         &tegra12_dvfs_rail_vdd_gpu,
101 };
102
103 void __init tegra12x_vdd_cpu_align(int step_uv, int offset_uv)
104 {
105         tegra12_dvfs_rail_vdd_cpu.alignment.step_uv = step_uv;
106         tegra12_dvfs_rail_vdd_cpu.alignment.offset_uv = offset_uv;
107 }
108
109 /* CPU DVFS tables */
110 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
111         {
112                 .speedo_id = 0,
113                 .process_id = -1,
114                 .dfll_tune_data  = {
115                         .tune0          = 0x00662FFF,
116                         .tune0_high_mv  = 0x006640FF,
117                         .tune1          = 0x0000006E,
118                         .droop_rate_min = 1000000,
119                         .tune_high_min_millivolts = 900,
120                         .min_millivolts = 800,
121                 },
122                 .max_mv = 1260,
123                 .freqs_mult = KHZ,
124                 .speedo_scale = 100,
125                 .voltage_scale = 1000,
126                 .cvb_table = {
127                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
128                         {306000  , {1141577,  -30185,  454}, { 777000   , 0, 0}},
129                         {408000  , {1180454,  -31625,  454}, { 787500   , 0, 0}},
130                         {510000  , {1221370,  -33065,  454}, { 798000   , 0, 0}},
131                         {612000  , {1264325,  -34505,  454}, { 819000   , 0, 0}},
132                         {714000  , {1309319,  -35945,  454}, { 840000   , 0, 0}},
133                         {816000  , {1356353,  -37385,  454}, { 850500   , 0, 0}},
134                         {918000  , {1405425,  -38825,  454}, { 882000   , 0, 0}},
135                         {1020000 , {1456537,  -40265,  454}, { 903000   , 0, 0}},
136                         {1122000 , {1509687,  -41705,  454}, { 934500   , 0, 0}},
137                         {1224000 , {1564877,  -43145,  454}, { 955500   , 0, 0}},
138                         {1326000 , {1622106,  -44585,  454}, { 987000   , 0, 0}},
139                         {1428000 , {1681374,  -46025,  454}, { 1029000  , 0, 0}},
140                         {1530000 , {1742681,  -47465,  454}, { 1060500  , 0, 0}},
141                         {1632000 , {1806027,  -48915,  454}, { 1102500  , 0, 0}},
142                         {1734000 , {1871412,  -50355,  454}, { 1134000  , 0, 0}},
143                         {1836000 , {1938836,  -51795,  454}, { 1176000  , 0, 0}},
144                         {1938000 , {2008300,  -53235,  454}, { 1228500  , 0, 0}},
145                         {2014500 , {2061382,  -54305,  454}, { 1260000  , 0, 0}},
146                         {      0 , {      0,       0,    0}, {       0  , 0, 0}},
147                 },
148                 .vmin_trips_table = { 20, },
149                 .therm_floors_table = { 900, },
150         },
151         {
152                 .speedo_id = 1,
153                 .process_id = -1,
154                 .dfll_tune_data  = {
155                         .tune0          = 0x00662FFF,
156                         .tune0_high_mv  = 0x006640FF,
157                         .tune1          = 0x0000006E,
158                         .droop_rate_min = 1000000,
159                         .tune_high_min_millivolts = 900,
160                         .min_millivolts = 800,
161                 },
162                 .max_mv = 1260,
163                 .freqs_mult = KHZ,
164                 .speedo_scale = 100,
165                 .voltage_scale = 1000,
166                 .cvb_table = {
167                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
168                         {306000  , {1141577,  -30185,  454}, { 735000   , 0, 0}},
169                         {408000  , {1180454,  -31625,  454}, { 745500   , 0, 0}},
170                         {510000  , {1221370,  -33065,  454}, { 756000   , 0, 0}},
171                         {612000  , {1264325,  -34505,  454}, { 766500   , 0, 0}},
172                         {714000  , {1309319,  -35945,  454}, { 777000   , 0, 0}},
173                         {816000  , {1356353,  -37385,  454}, { 798000   , 0, 0}},
174                         {918000  , {1405425,  -38825,  454}, { 819000   , 0, 0}},
175                         {1020000 , {1456537,  -40265,  454}, { 840000   , 0, 0}},
176                         {1122000 , {1509687,  -41705,  454}, { 861000   , 0, 0}},
177                         {1224000 , {1564877,  -43145,  454}, { 882000   , 0, 0}},
178                         {1326000 , {1622106,  -44585,  454}, { 913500   , 0, 0}},
179                         {1428000 , {1681374,  -46025,  454}, { 945000   , 0, 0}},
180                         {1530000 , {1742681,  -47465,  454}, { 976500   , 0, 0}},
181                         {1632000 , {1806027,  -48915,  454}, { 1008000  , 0, 0}},
182                         {1734000 , {1871412,  -50355,  454}, { 1039500  , 0, 0}},
183                         {1836000 , {1938836,  -51795,  454}, { 1081500  , 0, 0}},
184                         {1938000 , {2008300,  -53235,  454}, { 1123500  , 0, 0}},
185                         {2014500 , {2061382,  -54305,  454}, { 1144500  , 0, 0}},
186                         {2116500 , {2134404,  -55745,  454}, { 1197000  , 0, 0}},
187                         {2218500 , {2209465,  -57185,  454}, { 1239000  , 0, 0}},
188                         {2320500 , {2286565,  -58625,  454}, { 1291500  , 0, 0}},
189                         {      0 , {      0,       0,    0}, {       0  , 0, 0}},
190                 },
191                 .vmin_trips_table = { 20, },
192                 .therm_floors_table = { 900, },
193         },
194 };
195
196 static int cpu_millivolts[MAX_DVFS_FREQS];
197 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
198
199 static struct dvfs cpu_dvfs = {
200         .clk_name       = "cpu_g",
201         .millivolts     = cpu_millivolts,
202         .dfll_millivolts = cpu_dfll_millivolts,
203         .auto_dvfs      = true,
204         .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,
205 };
206
207 /* Core DVFS tables */
208 static const int core_millivolts[MAX_DVFS_FREQS] = {
209         800, 850, 900, 950, 1000, 1050, 1100, 1150};
210
211 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
212         {                                                       \
213                 .clk_name       = _clk_name,                    \
214                 .speedo_id      = _speedo_id,                   \
215                 .process_id     = _process_id,                  \
216                 .freqs          = {_freqs},                     \
217                 .freqs_mult     = _mult,                        \
218                 .millivolts     = core_millivolts,              \
219                 .auto_dvfs      = _auto,                        \
220                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
221         }
222
223 #define OVRRD_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
224         {                                                       \
225                 .clk_name       = _clk_name,                    \
226                 .speedo_id      = _speedo_id,                   \
227                 .process_id     = _process_id,                  \
228                 .freqs          = {_freqs},                     \
229                 .freqs_mult     = _mult,                        \
230                 .millivolts     = core_millivolts,              \
231                 .auto_dvfs      = _auto,                        \
232                 .can_override   = true,                         \
233                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
234         }
235
236 static struct dvfs core_dvfs_table[] = {
237         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
238         /* Clock limits for internal blocks, PLLs */
239
240         CORE_DVFS("emc",        -1, -1, 1, KHZ, 264000, 348000, 384000, 384000, 528000, 528000, 924000, 924000),
241
242         CORE_DVFS("cpu_lp",     0, 0, 1, KHZ,   396000, 528000, 660000, 804000, 912000, 1044000, 1140000, 1188000),
243         CORE_DVFS("cpu_lp",     0, 1, 1, KHZ,   420000, 564000, 696000, 828000, 960000, 1092000, 1188000, 1188000),
244         CORE_DVFS("cpu_lp",     1, -1, 1, KHZ,  420000, 564000, 696000, 828000, 960000, 1092000, 1188000, 1284000),
245
246         CORE_DVFS("sbus",       0, 0, 1, KHZ,   156000, 192000, 228000, 264000, 312000, 348000, 372000, 384000),
247         CORE_DVFS("sbus",       0, 1, 1, KHZ,   156000, 204000, 252000, 288000, 324000, 360000, 384000, 384000),
248         CORE_DVFS("sbus",       1, -1, 1, KHZ,  156000, 204000, 252000, 288000, 324000, 360000, 384000, 420000),
249
250         CORE_DVFS("vic03",      0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
251         CORE_DVFS("vic03",      0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
252         CORE_DVFS("vic03",      1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
253
254         CORE_DVFS("tsec",       0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
255         CORE_DVFS("tsec",       0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
256         CORE_DVFS("tsec",       1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
257
258         CORE_DVFS("msenc",      0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
259         CORE_DVFS("msenc",      0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
260         CORE_DVFS("msenc",      1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
261
262         CORE_DVFS("se",         0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
263         CORE_DVFS("se",         0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
264         CORE_DVFS("se",         1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
265
266         CORE_DVFS("vde",        0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
267         CORE_DVFS("vde",        0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
268         CORE_DVFS("vde",        1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
269
270         CORE_DVFS("host1x",     0, 0, 1, KHZ,   108000, 156000, 204000, 240000, 348000, 372000, 408000, 432000),
271         CORE_DVFS("host1x",     0, 1, 1, KHZ,   108000, 156000, 204000, 252000, 348000, 384000, 432000, 432000),
272         CORE_DVFS("host1x",     1, -1, 1, KHZ,  108000, 156000, 204000, 252000, 348000, 384000, 444000, 456000),
273
274         CORE_DVFS("vi",         0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
275         CORE_DVFS("vi",         0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
276         CORE_DVFS("vi",         1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
277
278         CORE_DVFS("isp",        0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
279         CORE_DVFS("isp",        0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
280         CORE_DVFS("isp",        1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
281
282 #ifdef CONFIG_TEGRA_DUAL_CBUS
283         CORE_DVFS("c2bus",      0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
284         CORE_DVFS("c2bus",      0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
285         CORE_DVFS("c2bus",      1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
286
287         CORE_DVFS("c3bus",      0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
288         CORE_DVFS("c3bus",      0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
289         CORE_DVFS("c3bus",      1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
290 #else
291         CORE_DVFS("cbus",      -1, -1, 1, KHZ,  120000, 144000, 168000, 168000, 216000, 216000, 372000, 372000),
292 #endif
293
294         CORE_DVFS("c4bus",      0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
295         CORE_DVFS("c4bus",      0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
296         CORE_DVFS("c4bus",      1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
297
298         CORE_DVFS("pll_m",  -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
299         CORE_DVFS("pll_c",  -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
300         CORE_DVFS("pll_c2", -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
301         CORE_DVFS("pll_c3", -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
302
303         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
304         /* Clock limits for I/O peripherals */
305         CORE_DVFS("sbc1",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
306         CORE_DVFS("sbc2",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
307         CORE_DVFS("sbc3",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
308         CORE_DVFS("sbc4",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
309         CORE_DVFS("sbc5",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
310         CORE_DVFS("sbc6",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
311
312         OVRRD_DVFS("sdmmc1", -1, -1, 1, KHZ,  100000, 100000, 100000, 100000,  136000, 136000, 136000, 204000),
313         OVRRD_DVFS("sdmmc3", -1, -1, 1, KHZ,  100000, 100000, 100000, 100000,  136000, 136000, 136000, 204000),
314         OVRRD_DVFS("sdmmc4", -1, -1, 1, KHZ,  102000, 102000, 102000, 102000,  136000, 136000, 136000, 200000),
315
316         CORE_DVFS("hdmi",   -1, -1, 1, KHZ,   148500, 148500, 148500, 297000,  297000, 297000, 297000, 297000),
317         /* FIXME: Finalize these values for NOR after qual */
318         CORE_DVFS("nor",    -1, -1, 1, KHZ,   102000, 102000, 102000, 102000,  102000, 102000, 102000, 102000),
319
320         CORE_DVFS("pciex",  -1,  -1, 1, KHZ,  250000, 250000, 250000, 500000,  500000, 500000, 500000, 500000),
321
322         /*
323          * The clock rate for the display controllers that determines the
324          * necessary core voltage depends on a divider that is internal
325          * to the display block.  Disable auto-dvfs on the display clocks,
326          * and let the display driver call tegra_dvfs_set_rate manually
327          */
328         CORE_DVFS("disp1",       0, 0, 0, KHZ,   148500, 241000, 297000, 297000, 297000, 474000, 474000, 474000),
329         CORE_DVFS("disp1",       0, 1, 0, KHZ,   148500, 241000, 297000, 297000, 474000, 474000, 474000, 474000),
330         CORE_DVFS("disp1",       1, -1, 0, KHZ,  148500, 241000, 297000, 297000, 474000, 474000, 474000, 474000),
331
332         CORE_DVFS("disp2",       0, 0, 0, KHZ,   148500, 241000, 297000, 297000, 297000, 474000, 474000, 474000),
333         CORE_DVFS("disp2",       0, 1, 0, KHZ,   148500, 241000, 297000, 297000, 474000, 474000, 474000, 474000),
334         CORE_DVFS("disp2",       1, -1, 0, KHZ,  148500, 241000, 297000, 297000, 474000, 474000, 474000, 474000),
335
336         /* Core voltages (mV):                          800,    850,    900,     950,    1000,  1050,    1100,   1150 */
337         /* xusb clocks */
338         CORE_DVFS("xusb_falcon_src", -1, -1, 1, KHZ,  336000, 336000, 336000, 336000, 336000, 336000,  336000,  336000),
339         CORE_DVFS("xusb_host_src",   -1, -1, 1, KHZ,  112000, 112000, 112000, 112000, 112000, 112000,  112000,  112000),
340         CORE_DVFS("xusb_dev_src",    -1, -1, 1, KHZ,   58300,  58300,  58300,  58300, 112000, 112000,  112000,  112000),
341         CORE_DVFS("xusb_ss_src",     -1, -1, 1, KHZ,  120000, 120000, 120000, 120000, 120000, 120000,  120000,  120000),
342         CORE_DVFS("xusb_fs_src",     -1, -1, 1, KHZ,   48000,  48000,  48000,  48000,  48000,  48000,   48000,   48000),
343         CORE_DVFS("xusb_hs_src",     -1, -1, 1, KHZ,   60000,  60000,  60000,  60000,  60000,  60000,   60000,   60000),
344 };
345
346 /* TBD: fill in actual hw numbers */
347 static struct gpu_cvb_dvfs gpu_cvb_dvfs_table[] = {
348         {
349                 .speedo_id =   0,
350                 .process_id = -1,
351                 .max_mv = 1200,
352                 .min_mv = 800,
353                 .freqs_mult = KHZ,
354                 .speedo_scale = 100,
355                 .voltage_scale = 1000,
356                 .cvb_table = {
357                         /*f        dfll  pll:   c0,     c1,   c2 */
358                         {   72000, {  }, {  975248, -10755,  -56}, },
359                         {  108000, {  }, {  995948, -11645,  -56}, },
360                         {  180000, {  }, { 1041350, -13415,  -56}, },
361                         {  252000, {  }, { 1092088, -15195,  -56}, },
362                         {  324000, {  }, { 1148163, -16975,  -56}, },
363                         {  396000, {  }, { 1209574, -18745,  -56}, },
364                         {  468000, {  }, { 1276322, -20525,  -56}, },
365                         {  540000, {  }, { 1348406, -22295,  -56}, },
366                         {  612000, {  }, { 1425827, -24075,  -56}, },
367                         {  648000, {  }, { 1466538, -24965,  -56}, },
368                         {       0, {  }, {       0,      0,   0}, },
369                 },
370                 .vmin_trips_table = { 20, },
371                 .therm_floors_table = { 900, },
372         },
373         {
374                 .speedo_id =   1,
375                 .process_id = -1,
376                 .max_mv = 1200,
377                 .min_mv = 800,
378                 .freqs_mult = KHZ,
379                 .speedo_scale = 100,
380                 .voltage_scale = 1000,
381                 .cvb_table = {
382                         /*f        dfll  pll:   c0,     c1,   c2 */
383                         {   72000, {  }, {  975248, -10755,  -56}, },
384                         {  108000, {  }, {  995948, -11645,  -56}, },
385                         {  180000, {  }, { 1041350, -13415,  -56}, },
386                         {  252000, {  }, { 1092088, -15195,  -56}, },
387                         {  324000, {  }, { 1148163, -16975,  -56}, },
388                         {  396000, {  }, { 1209574, -18745,  -56}, },
389                         {  468000, {  }, { 1276322, -20525,  -56}, },
390                         {  540000, {  }, { 1348406, -22295,  -56}, },
391                         {  612000, {  }, { 1425827, -24075,  -56}, },
392                         {  648000, {  }, { 1466538, -24965,  -56}, },
393                         {  684000, {  }, { 1508583, -25855,  -56}, },
394                         {  708000, {  }, { 1537355, -26445,  -56}, },
395                         {  756000, {  }, { 1596677, -27625,  -56}, },
396                         {  804000, {  }, { 1658370, -28815,  -56}, },
397                         {       0, {  }, {       0,      0,   0}, },
398                 },
399                 .vmin_trips_table = { 20, },
400                 .therm_floors_table = { 900, },
401         }
402 };
403
404 static int gpu_millivolts[MAX_DVFS_FREQS];
405 static struct dvfs gpu_dvfs = {
406         .clk_name       = "gbus",
407         .millivolts     = gpu_millivolts,
408         .auto_dvfs      = true,
409         .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,
410 };
411
412 int read_gpu_dvfs_table(int **millivolts, unsigned long **freqs)
413 {
414         *millivolts = gpu_dvfs.millivolts;
415         *freqs = gpu_dvfs.freqs;
416
417         return 0;
418 }
419 EXPORT_SYMBOL(read_gpu_dvfs_table);
420
421 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
422 {
423         int ret;
424
425         ret = param_set_bool(arg, kp);
426         if (ret)
427                 return ret;
428
429         if (tegra_dvfs_core_disabled)
430                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
431         else
432                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
433
434         return 0;
435 }
436
437 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
438 {
439         int ret;
440
441         ret = param_set_bool(arg, kp);
442         if (ret)
443                 return ret;
444
445         if (tegra_dvfs_cpu_disabled)
446                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
447         else
448                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
449
450         return 0;
451 }
452
453 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
454 {
455         int ret;
456
457         ret = param_set_bool(arg, kp);
458         if (ret)
459                 return ret;
460
461         if (tegra_dvfs_gpu_disabled)
462                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
463         else
464                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
465
466         return 0;
467 }
468
469 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
470 {
471         return param_get_bool(buffer, kp);
472 }
473
474 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
475         .set = tegra_dvfs_disable_core_set,
476         .get = tegra_dvfs_disable_get,
477 };
478
479 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
480         .set = tegra_dvfs_disable_cpu_set,
481         .get = tegra_dvfs_disable_get,
482 };
483
484 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
485         .set = tegra_dvfs_disable_gpu_set,
486         .get = tegra_dvfs_disable_get,
487 };
488
489 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
490         &tegra_dvfs_core_disabled, 0644);
491 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
492         &tegra_dvfs_cpu_disabled, 0644);
493 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
494         &tegra_dvfs_gpu_disabled, 0644);
495
496 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
497 {
498         /* Don't update manual dvfs clocks */
499         if (!d->auto_dvfs)
500                 return false;
501
502         /*
503          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
504          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
505          * together with the image) and board specific EMC DFS table; we will
506          * check the scaling ladder against nominal core voltage when the table
507          * is loaded (and if on particular board the table is not loaded, EMC
508          * scaling is disabled).
509          */
510         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
511                 return false;
512
513         /*
514          * Don't update shared cbus, and don't propagate common cbus dvfs
515          * limit down to shared users, but set maximum rate for each user
516          * equal to the respective client limit.
517          */
518         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
519                 struct clk *user;
520                 unsigned long rate;
521
522                 list_for_each_entry(
523                         user, &c->shared_bus_list, u.shared_bus_user.node) {
524                         if (user->u.shared_bus_user.client) {
525                                 rate = user->u.shared_bus_user.client->max_rate;
526                                 user->max_rate = rate;
527                                 user->u.shared_bus_user.rate = rate;
528                         }
529                 }
530                 return false;
531         }
532
533         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
534         return true;
535 }
536
537 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
538 {
539         int ret;
540         struct clk *c = tegra_get_clock_by_name(d->clk_name);
541
542         if (!c) {
543                 pr_debug("tegra12_dvfs: no clock found for %s\n",
544                         d->clk_name);
545                 return;
546         }
547
548         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
549         if (can_update_max_rate(c, d)) {
550                 BUG_ON(!d->freqs[max_freq_index]);
551                 tegra_init_max_rate(
552                         c, d->freqs[max_freq_index] * d->freqs_mult);
553         }
554         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
555
556         ret = tegra_enable_dvfs_on_clk(c, d);
557         if (ret)
558                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
559 }
560
561 static bool __init match_dvfs_one(const char *name,
562         int dvfs_speedo_id, int dvfs_process_id,
563         int speedo_id, int process_id)
564 {
565         if ((dvfs_process_id != -1 && dvfs_process_id != process_id) ||
566                 (dvfs_speedo_id != -1 && dvfs_speedo_id != speedo_id)) {
567                 pr_debug("tegra12_dvfs: rejected %s speedo %d, process %d\n",
568                          name, dvfs_speedo_id, dvfs_process_id);
569                 return false;
570         }
571         return true;
572 }
573
574 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
575 static inline int get_cvb_voltage(int speedo, int s_scale,
576                                   struct cvb_dvfs_parameters *cvb)
577 {
578         /* apply only speedo scale: output mv = cvb_mv * v_scale */
579         int mv;
580         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
581         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
582         return mv;
583 }
584
585 static int round_cvb_voltage(int mv, int v_scale, struct rail_alignment *align)
586 {
587         /* combined: apply voltage scale and round to cvb alignment step */
588         int uv;
589         int step = (align->step_uv ? : 1000) * v_scale;
590         int offset = align->offset_uv * v_scale;
591
592         uv = max(mv * 1000, offset) - offset;
593         uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;
594         return uv / 1000;
595 }
596
597 static int round_voltage(int mv, struct rail_alignment *align, bool up)
598 {
599         if (align->step_uv) {
600                 int uv = max(mv * 1000, align->offset_uv) - align->offset_uv;
601                 uv = (uv + (up ? align->step_uv - 1 : 0)) / align->step_uv;
602                 return (uv * align->step_uv + align->offset_uv) / 1000;
603         }
604         return mv;
605 }
606
607 static int __init set_cpu_dvfs_data(
608         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
609 {
610         int i, j, mv, dfll_mv, min_dfll_mv;
611         unsigned long fmax_at_vmin = 0;
612         unsigned long fmax_pll_mode = 0;
613         unsigned long fmin_use_dfll = 0;
614         struct cvb_dvfs_table *table = NULL;
615         int speedo = tegra_cpu_speedo_value();
616         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_cpu.alignment;
617
618         min_dfll_mv = d->dfll_tune_data.min_millivolts;
619         min_dfll_mv =  round_voltage(min_dfll_mv, align, true);
620         d->max_mv = round_voltage(d->max_mv, align, false);
621         BUG_ON(min_dfll_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
622
623         /*
624          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
625          * CVB entry specifies CPU frequency and CVB coefficients to calculate
626          * the respective voltage when either DFLL or PLL is used as CPU clock
627          * source.
628          *
629          * Minimum voltage limit is applied only to DFLL source. For PLL source
630          * voltage can go as low as table specifies. Maximum voltage limit is
631          * applied to both sources, but differently: directly clip voltage for
632          * DFLL, and limit maximum frequency for PLL.
633          */
634         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
635                 table = &d->cvb_table[i];
636                 if (!table->freq)
637                         break;
638
639                 dfll_mv = get_cvb_voltage(
640                         speedo, d->speedo_scale, &table->cvb_dfll_param);
641                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale, align);
642
643                 mv = get_cvb_voltage(
644                         speedo, d->speedo_scale, &table->cvb_pll_param);
645                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
646
647                 /*
648                  * Check maximum frequency at minimum voltage for dfll source;
649                  * round down unless all table entries are above Vmin, then use
650                  * the 1st entry as is.
651                  */
652                 dfll_mv = max(dfll_mv, min_dfll_mv);
653                 if (dfll_mv > min_dfll_mv) {
654                         if (!j)
655                                 fmax_at_vmin = table->freq;
656                         if (!fmax_at_vmin)
657                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
658                 }
659
660                 /* Clip maximum frequency at maximum voltage for pll source */
661                 if (mv > d->max_mv) {
662                         if (!j)
663                                 break;  /* 1st entry already above Vmax */
664                         if (!fmax_pll_mode)
665                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
666                 }
667
668                 /* Minimum rate with pll source voltage above dfll Vmin */
669                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
670                         fmin_use_dfll = table->freq;
671
672                 /* fill in dvfs tables */
673                 cpu_dvfs->freqs[j] = table->freq;
674                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
675                 cpu_millivolts[j] = mv;
676                 j++;
677
678                 /*
679                  * "Round-up" frequency list cut-off (keep first entry that
680                  *  exceeds max voltage - the voltage limit will be enforced
681                  *  anyway, so when requested this frequency dfll will settle
682                  *  at whatever high frequency it can on the particular chip)
683                  */
684                 if (dfll_mv > d->max_mv)
685                         break;
686         }
687
688         /* Table must not be empty, must have at least one entry above Vmin */
689         if (!i || !j || !fmax_at_vmin) {
690                 pr_err("tegra12_dvfs: invalid cpu dvfs table\n");
691                 return -ENOENT;
692         }
693
694         /* In the dfll operating range dfll voltage at any rate should be
695            better (below) than pll voltage */
696         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
697                 WARN(1, "tegra12_dvfs: pll voltage is below dfll in the dfll"
698                         " operating range\n");
699                 fmin_use_dfll = fmax_at_vmin;
700         }
701
702         /* dvfs tables are successfully populated - fill in the rest */
703         cpu_dvfs->speedo_id = d->speedo_id;
704         cpu_dvfs->process_id = d->process_id;
705         cpu_dvfs->freqs_mult = d->freqs_mult;
706         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
707                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
708         *max_freq_index = j - 1;
709
710         cpu_dvfs->dfll_data = d->dfll_tune_data;
711         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
712                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
713         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
714         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
715         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
716
717         /* Init cpu thermal floors */
718         tegra_dvfs_rail_init_vmin_thermal_profile(
719                 d->vmin_trips_table, d->therm_floors_table,
720                 &tegra12_dvfs_rail_vdd_cpu, &cpu_dvfs->dfll_data);
721
722         return 0;
723 }
724
725 static int __init set_gpu_dvfs_data(
726         struct gpu_cvb_dvfs *d, struct dvfs *gpu_dvfs, int *max_freq_index)
727 {
728         int i, mv;
729         struct cvb_dvfs_table *table = NULL;
730         int speedo = tegra_gpu_speedo_value();
731         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_gpu.alignment;
732
733         d->max_mv = round_voltage(d->max_mv, align, false);
734         d->min_mv = round_voltage(d->min_mv, align, true);
735         BUG_ON(d->min_mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
736
737         /*
738          * Use CVB table to fill in gpu dvfs frequencies and voltages. Each
739          * CVB entry specifies gpu frequency and CVB coefficients to calculate
740          * the respective voltage.
741          */
742         for (i = 0; i < MAX_DVFS_FREQS; i++) {
743                 table = &d->cvb_table[i];
744                 if (!table->freq)
745                         break;
746
747                 mv = get_cvb_voltage(
748                         speedo, d->speedo_scale, &table->cvb_pll_param);
749                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
750
751                 if (mv > d->max_mv)
752                         break;
753
754                 /* fill in gpu dvfs tables */
755                 mv = max(mv, d->min_mv);
756                 gpu_millivolts[i] = mv;
757                 gpu_dvfs->freqs[i] = table->freq;
758         }
759         /* Table must not be empty, must have at least one entry in range */
760         if (!i || (gpu_millivolts[i - 1] <
761                    tegra12_dvfs_rail_vdd_gpu.min_millivolts)) {
762                 pr_err("tegra14_dvfs: invalid gpu dvfs table\n");
763                 return -ENOENT;
764         }
765
766         /* dvfs tables are successfully populated - fill in the gpu dvfs */
767         gpu_dvfs->speedo_id = d->speedo_id;
768         gpu_dvfs->process_id = d->process_id;
769         gpu_dvfs->freqs_mult = d->freqs_mult;
770         gpu_dvfs->dvfs_rail->nominal_millivolts =
771                 min(d->max_mv, gpu_millivolts[i - 1]);
772
773         *max_freq_index = i - 1;
774
775         /* Init thermal floors */
776         tegra_dvfs_rail_init_vmin_thermal_profile(d->vmin_trips_table,
777                 d->therm_floors_table, &tegra12_dvfs_rail_vdd_gpu, NULL);
778
779         return 0;
780 }
781
782 static int __init get_core_nominal_mv_index(int speedo_id)
783 {
784         int i;
785         int mv = tegra_core_speedo_mv();
786         int core_edp_voltage = get_core_edp();
787
788         /*
789          * Start with nominal level for the chips with this speedo_id. Then,
790          * make sure core nominal voltage is below edp limit for the board
791          * (if edp limit is set).
792          */
793         if (!core_edp_voltage)
794                 core_edp_voltage = 1150;        /* default 1.15V EDP limit */
795
796         mv = min(mv, core_edp_voltage);
797
798         /* Round nominal level down to the nearest core scaling step */
799         for (i = 0; i < MAX_DVFS_FREQS; i++) {
800                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
801                         break;
802         }
803
804         if (i == 0) {
805                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
806                        " nominal voltage %d\n", mv);
807                 return -ENOSYS;
808         }
809         return i - 1;
810 }
811
812 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
813                          bool before_clk_update, int cpu_event)
814 {
815         /* empty definition for tegra12 */
816         return 0;
817 }
818
819 void __init tegra12x_init_dvfs(void)
820 {
821         int cpu_speedo_id = tegra_cpu_speedo_id();
822         int cpu_process_id = tegra_cpu_process_id();
823         int soc_speedo_id = tegra_soc_speedo_id();
824         int core_process_id = tegra_core_process_id();
825         int gpu_speedo_id = tegra_gpu_speedo_id();
826         int gpu_process_id = tegra_gpu_process_id();
827
828         int i, ret;
829         int core_nominal_mv_index;
830         int gpu_max_freq_index = 0;
831         int cpu_max_freq_index = 0;
832
833 #ifndef CONFIG_TEGRA_CORE_DVFS
834         tegra_dvfs_core_disabled = true;
835 #endif
836 #ifndef CONFIG_TEGRA_CPU_DVFS
837         tegra_dvfs_cpu_disabled = true;
838 #endif
839 #ifndef CONFIG_TEGRA_GPU_DVFS
840         tegra_dvfs_gpu_disabled = true;
841 #endif
842 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
843         if (!tegra_platform_is_silicon()) {
844                 tegra_dvfs_core_disabled = true;
845                 tegra_dvfs_cpu_disabled = true;
846         }
847 #endif
848
849         /*
850          * Find nominal voltages for core (1st) and cpu rails before rail
851          * init. Nominal voltage index in core scaling ladder can also be
852          * used to determine max dvfs frequencies for all core clocks. In
853          * case of error disable core scaling and set index to 0, so that
854          * core clocks would not exceed rates allowed at minimum voltage.
855          */
856         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
857         if (core_nominal_mv_index < 0) {
858                 tegra12_dvfs_rail_vdd_core.disabled = true;
859                 tegra_dvfs_core_disabled = true;
860                 core_nominal_mv_index = 0;
861         }
862         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
863                 core_millivolts[core_nominal_mv_index];
864
865         /*
866          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
867          * voltage for cpu rail, and cpu maximum frequency. Note that entire
868          * frequency range is guaranteed only when dfll is used as cpu clock
869          * source. Reaching maximum frequency with pll as cpu clock source
870          * may not be possible within nominal voltage range (dvfs mechanism
871          * would automatically fail frequency request in this case, so that
872          * voltage limit is not violated). Error when cpu dvfs table can not
873          * be constructed must never happen.
874          */
875         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
876                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
877                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
878                                    cpu_speedo_id, cpu_process_id)) {
879                         ret = set_cpu_dvfs_data(
880                                 d, &cpu_dvfs, &cpu_max_freq_index);
881                         break;
882                 }
883         }
884         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
885
886         /*
887          * Setup gpu dvfs tables from cvb data, determine nominal voltage for
888          * gpu rail, and gpu maximum frequency. Error when gpu dvfs table can
889          * not be constructed must never happen.
890          */
891         for (ret = 0, i = 0; i < ARRAY_SIZE(gpu_cvb_dvfs_table); i++) {
892                 struct gpu_cvb_dvfs *d = &gpu_cvb_dvfs_table[i];
893                 if (match_dvfs_one("gpu cvb", d->speedo_id, d->process_id,
894                                    gpu_speedo_id, gpu_process_id)) {
895                         ret = set_gpu_dvfs_data(
896                                 d, &gpu_dvfs, &gpu_max_freq_index);
897                         break;
898                 }
899         }
900         BUG_ON((i == ARRAY_SIZE(gpu_cvb_dvfs_table)) || ret);
901
902         /* Init core thermal profile */
903         tegra_dvfs_rail_init_vmin_thermal_profile(vdd_core_therm_trips_table,
904                 vdd_core_therm_floors_table, &tegra12_dvfs_rail_vdd_core, NULL);
905
906         /* Init rail structures and dependencies */
907         tegra_dvfs_init_rails(tegra12_dvfs_rails,
908                 ARRAY_SIZE(tegra12_dvfs_rails));
909
910         /* Search core dvfs table for speedo/process matching entries and
911            initialize dvfs-ed clocks */
912         if (!tegra_platform_is_linsim()) {
913                 for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
914                         struct dvfs *d = &core_dvfs_table[i];
915                         if (!match_dvfs_one(d->clk_name, d->speedo_id,
916                                 d->process_id, soc_speedo_id, core_process_id))
917                                 continue;
918                         init_dvfs_one(d, core_nominal_mv_index);
919                 }
920         }
921
922         /* Initialize matching gpu dvfs entry already found when nominal
923            voltage was determined */
924         init_dvfs_one(&gpu_dvfs, gpu_max_freq_index);
925
926         /* Initialize matching cpu dvfs entry already found when nominal
927            voltage was determined */
928         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
929
930         /* Finally disable dvfs on rails if necessary */
931         if (tegra_dvfs_core_disabled)
932                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
933         if (tegra_dvfs_cpu_disabled)
934                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
935         if (tegra_dvfs_gpu_disabled)
936                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
937
938         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
939                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
940                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
941         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
942                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
943                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
944         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
945                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
946                 tegra_dvfs_gpu_disabled ? "disabled" : "enabled");
947 }
948
949 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
950 {
951         return 0;
952 }
953
954 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
955 {
956         return 0;
957 }
958
959 /* Core voltage and bus cap object and tables */
960 static struct kobject *cap_kobj;
961 static struct kobject *gpu_kobj;
962
963 static struct core_dvfs_cap_table tegra12_core_cap_table[] = {
964 #ifdef CONFIG_TEGRA_DUAL_CBUS
965         { .cap_name = "cap.c2bus" },
966         { .cap_name = "cap.c3bus" },
967 #else
968         { .cap_name = "cap.cbus" },
969 #endif
970         { .cap_name = "cap.sclk" },
971         { .cap_name = "cap.emc" },
972         { .cap_name = "cap.host1x" },
973 };
974
975 static struct core_bus_limit_table tegra12_gpu_cap_syfs = {
976         .limit_clk_name = "cap.profile.gbus",
977         .refcnt_attr = {.attr = {.name = "gpu_cap_state", .mode = 0644} },
978         .level_attr  = {.attr = {.name = "gpu_cap_level", .mode = 0644} },
979         .pm_qos_class = PM_QOS_GPU_FREQ_MAX,
980 };
981
982 static struct core_bus_limit_table tegra12_gpu_floor_sysfs = {
983         .limit_clk_name = "floor.profile.gbus",
984         .refcnt_attr = {.attr = {.name = "gpu_floor_state", .mode = 0644} },
985         .level_attr  = {.attr = {.name = "gpu_floor_level", .mode = 0644} },
986         .pm_qos_class = PM_QOS_GPU_FREQ_MIN,
987 };
988
989 static struct core_bus_rates_table tegra12_gpu_rates_sysfs = {
990         .bus_clk_name = "gbus",
991         .rate_attr = {.attr = {.name = "gpu_rate", .mode = 0444} },
992         .available_rates_attr = {
993                 .attr = {.name = "gpu_available_rates", .mode = 0444} },
994 };
995
996 static int __init tegra12_dvfs_init_core_cap(void)
997 {
998         int ret;
999
1000         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
1001         if (!cap_kobj) {
1002                 pr_err("tegra12_dvfs: failed to create sysfs cap object\n");
1003                 return 0;
1004         }
1005
1006         ret = tegra_init_core_cap(
1007                 tegra12_core_cap_table, ARRAY_SIZE(tegra12_core_cap_table),
1008                 core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
1009
1010         if (ret) {
1011                 pr_err("tegra12_dvfs: failed to init core cap interface (%d)\n",
1012                        ret);
1013                 kobject_del(cap_kobj);
1014                 return 0;
1015         }
1016         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
1017
1018         gpu_kobj = kobject_create_and_add("tegra_gpu", kernel_kobj);
1019         if (!gpu_kobj) {
1020                 pr_err("tegra12_dvfs: failed to create sysfs gpu object\n");
1021                 return 0;
1022         }
1023
1024         ret = tegra_init_shared_bus_cap(&tegra12_gpu_cap_syfs,
1025                                         1, gpu_kobj);
1026         if (ret) {
1027                 pr_err("tegra12_dvfs: failed to init gpu cap interface (%d)\n",
1028                        ret);
1029                 kobject_del(gpu_kobj);
1030                 return 0;
1031         }
1032
1033         ret = tegra_init_shared_bus_floor(&tegra12_gpu_floor_sysfs,
1034                                           1, gpu_kobj);
1035         if (ret) {
1036                 pr_err("tegra12_dvfs: failed to init gpu floor interface (%d)\n",
1037                        ret);
1038                 kobject_del(gpu_kobj);
1039                 return 0;
1040         }
1041
1042         ret = tegra_init_sysfs_shared_bus_rate(&tegra12_gpu_rates_sysfs,
1043                                                1, gpu_kobj);
1044         if (ret) {
1045                 pr_err("tegra12_dvfs: failed to init gpu rates interface (%d)\n",
1046                        ret);
1047                 kobject_del(gpu_kobj);
1048                 return 0;
1049         }
1050         pr_info("tegra dvfs: tegra sysfs gpu interface is initialized\n");
1051
1052         return 0;
1053 }
1054 late_initcall(tegra12_dvfs_init_core_cap);