ARM: tegra12: dvfs: Add GPU thermal CVB and DVFS tables
[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 tegra_cooling_device gpu_vts_cdev = {
59         .cdev_type = "gpu_scaling",
60 };
61
62 static struct dvfs_rail tegra12_dvfs_rail_vdd_cpu = {
63         .reg_id = "vdd_cpu",
64         .max_millivolts = 1400,
65         .min_millivolts = 800,
66         .step = VDD_SAFE_STEP,
67         .jmp_to_zero = true,
68         .vmin_cdev = &cpu_vmin_cdev,
69         .alignment = {
70                 .step_uv = 10000, /* 10mV */
71         },
72         .stats = {
73                 .bin_uV = 10000, /* 10mV */
74         }
75 };
76
77 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
78         .reg_id = "vdd_core",
79         .max_millivolts = 1400,
80         .min_millivolts = 800,
81         .step = VDD_SAFE_STEP,
82         .vmin_cdev = &core_vmin_cdev,
83 };
84
85 /* TBD: fill in actual hw number */
86 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
87         .reg_id = "vdd_gpu",
88         .max_millivolts = 1350,
89         .min_millivolts = 700,
90         .step = VDD_SAFE_STEP,
91         .in_band_pm = true,
92         .vts_cdev = &gpu_vts_cdev,
93         .vmin_cdev = &gpu_vmin_cdev,
94         .alignment = {
95                 .step_uv = 10000, /* 10mV */
96         },
97         .stats = {
98                 .bin_uV = 10000, /* 10mV */
99         }
100 };
101
102 static struct dvfs_rail *tegra12_dvfs_rails[] = {
103         &tegra12_dvfs_rail_vdd_cpu,
104         &tegra12_dvfs_rail_vdd_core,
105         &tegra12_dvfs_rail_vdd_gpu,
106 };
107
108 void __init tegra12x_vdd_cpu_align(int step_uv, int offset_uv)
109 {
110         tegra12_dvfs_rail_vdd_cpu.alignment.step_uv = step_uv;
111         tegra12_dvfs_rail_vdd_cpu.alignment.offset_uv = offset_uv;
112 }
113
114 /* CPU DVFS tables */
115 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
116         {
117                 .speedo_id = 0,
118                 .process_id = -1,
119                 .dfll_tune_data  = {
120                         .tune0          = 0x005020FF,
121                         .tune0_high_mv  = 0x005040FF,
122                         .tune1          = 0x00000060,
123                         .droop_rate_min = 1000000,
124                         .tune_high_min_millivolts = 900,
125                         .min_millivolts = 800,
126                 },
127                 .max_mv = 1260,
128                 .freqs_mult = KHZ,
129                 .speedo_scale = 100,
130                 .voltage_scale = 1000,
131                 .cvb_table = {
132                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
133                         {306000,        {1150460, -30585, 402}, {740000, 0, 0}},
134                         {408000,        {1190122, -31865, 402}, {750000, 0, 0}},
135                         {510000,        {1231606, -33155, 402}, {760000, 0, 0}},
136                         {612000,        {1274912, -34435, 402}, {780000, 0, 0}},
137                         {714000,        {1320040, -35725, 402}, {800000, 0, 0}},
138                         {816000,        {1366990, -37005, 402}, {820000, 0, 0}},
139                         {918000,        {1415762, -38295, 402}, {840000, 0, 0}},
140                         {1020000,       {1466355, -39575, 402}, {880000, 0, 0}},
141                         {1122000,       {1518771, -40865, 402}, {900000, 0, 0}},
142                         {1224000,       {1573009, -42145, 402}, {930000, 0, 0}},
143                         {1326000,       {1629068, -43435, 402}, {960000, 0, 0}},
144                         {1428000,       {1686950, -44715, 402}, {990000, 0, 0}},
145                         {1530000,       {1746653, -46005, 402}, {1020000, 0, 0}},
146                         {1632000,       {1808179, -47285, 402}, {1070000, 0, 0}},
147                         {1734000,       {1871526, -48575, 402}, {1100000, 0, 0}},
148                         {1836000,       {1936696, -49855, 402}, {1140000, 0, 0}},
149                         {1938000,       {2003687, -51145, 402}, {1180000, 0, 0}},
150                         {2014500,       {2054787, -52095, 402}, {1220000, 0, 0}},
151                         {      0 ,      {      0,      0,   0}, {      0, 0, 0}},
152                 },
153                 .vmin_trips_table = { 20, },
154                 .therm_floors_table = { 900, },
155         },
156         {
157                 .speedo_id = 1,
158                 .process_id = -1,
159                 .dfll_tune_data  = {
160                         .tune0          = 0x005020FF,
161                         .tune0_high_mv  = 0x005040FF,
162                         .tune1          = 0x00000060,
163                         .droop_rate_min = 1000000,
164                         .tune_high_min_millivolts = 900,
165                         .min_millivolts = 800,
166                 },
167                 .max_mv = 1260,
168                 .freqs_mult = KHZ,
169                 .speedo_scale = 100,
170                 .voltage_scale = 1000,
171                 .cvb_table = {
172                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
173                         {306000,        {1150460, -30585, 402}, {710000, 0, 0}},
174                         {408000,        {1190122, -31865, 402}, {730000, 0, 0}},
175                         {510000,        {1231606, -33155, 402}, {740000, 0, 0}},
176                         {612000,        {1274912, -34435, 402}, {750000, 0, 0}},
177                         {714000,        {1320040, -35725, 402}, {770000, 0, 0}},
178                         {816000,        {1366990, -37005, 402}, {790000, 0, 0}},
179                         {918000,        {1415762, -38295, 402}, {810000, 0, 0}},
180                         {1020000,       {1466355, -39575, 402}, {830000, 0, 0}},
181                         {1122000,       {1518771, -40865, 402}, {860000, 0, 0}},
182                         {1224000,       {1573009, -42145, 402}, {890000, 0, 0}},
183                         {1326000,       {1629068, -43435, 402}, {920000, 0, 0}},
184                         {1428000,       {1686950, -44715, 402}, {950000, 0, 0}},
185                         {1530000,       {1746653, -46005, 402}, {980000, 0, 0}},
186                         {1632000,       {1808179, -47285, 402}, {1010000, 0, 0}},
187                         {1734000,       {1871526, -48575, 402}, {1050000, 0, 0}},
188                         {1836000,       {1936696, -49855, 402}, {1090000, 0, 0}},
189                         {1938000,       {2003687, -51145, 402}, {1130000, 0, 0}},
190                         {2014500,       {2054787, -52095, 402}, {1160000, 0, 0}},
191                         {2116500,       {2124957, -53385, 402}, {1200000, 0, 0}},
192                         {2218500,       {2196950, -54665, 402}, {1250000, 0, 0}},
193                         {2320500,       {2270765, -55955, 402}, {1300000, 0, 0}},
194                         {      0 ,      {      0,      0,   0}, {      0, 0, 0}},
195                 },
196                 .vmin_trips_table = { 20, },
197                 .therm_floors_table = { 900, },
198         },
199 };
200
201 static int cpu_millivolts[MAX_DVFS_FREQS];
202 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
203
204 static struct dvfs cpu_dvfs = {
205         .clk_name       = "cpu_g",
206         .millivolts     = cpu_millivolts,
207         .dfll_millivolts = cpu_dfll_millivolts,
208         .auto_dvfs      = true,
209         .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,
210 };
211
212 /* Core DVFS tables */
213 static const int core_millivolts[MAX_DVFS_FREQS] = {
214         800, 850, 900, 950, 1000, 1050, 1100, 1150};
215
216 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
217         {                                                       \
218                 .clk_name       = _clk_name,                    \
219                 .speedo_id      = _speedo_id,                   \
220                 .process_id     = _process_id,                  \
221                 .freqs          = {_freqs},                     \
222                 .freqs_mult     = _mult,                        \
223                 .millivolts     = core_millivolts,              \
224                 .auto_dvfs      = _auto,                        \
225                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
226         }
227
228 #define OVRRD_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
229         {                                                       \
230                 .clk_name       = _clk_name,                    \
231                 .speedo_id      = _speedo_id,                   \
232                 .process_id     = _process_id,                  \
233                 .freqs          = {_freqs},                     \
234                 .freqs_mult     = _mult,                        \
235                 .millivolts     = core_millivolts,              \
236                 .auto_dvfs      = _auto,                        \
237                 .can_override   = true,                         \
238                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
239         }
240
241 static struct dvfs core_dvfs_table[] = {
242         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
243         /* Clock limits for internal blocks, PLLs */
244
245         CORE_DVFS("emc",        -1, -1, 1, KHZ, 264000, 348000, 384000, 384000, 528000, 528000, 924000, 924000),
246
247         CORE_DVFS("cpu_lp",     0, 0, 1, KHZ,   396000, 528000, 660000, 804000, 912000, 1044000, 1140000, 1140000),
248         CORE_DVFS("cpu_lp",     0, 1, 1, KHZ,   420000, 564000, 696000, 828000, 960000, 1092000, 1140000, 1140000),
249         CORE_DVFS("cpu_lp",     1, -1, 1, KHZ,  420000, 564000, 696000, 828000, 960000, 1092000, 1188000, 1188000),
250
251         CORE_DVFS("sbus",       0, 0, 1, KHZ,   156000, 192000, 228000, 264000, 312000, 348000, 372000, 372000),
252         CORE_DVFS("sbus",       0, 1, 1, KHZ,   156000, 204000, 252000, 288000, 324000, 360000, 372000, 372000),
253         CORE_DVFS("sbus",       1, -1, 1, KHZ,  156000, 204000, 252000, 288000, 324000, 360000, 384000, 384000),
254
255         CORE_DVFS("vic03",      0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
256         CORE_DVFS("vic03",      0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
257         CORE_DVFS("vic03",      1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
258
259         CORE_DVFS("tsec",       0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
260         CORE_DVFS("tsec",       0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
261         CORE_DVFS("tsec",       1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
262
263         CORE_DVFS("msenc",      0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
264         CORE_DVFS("msenc",      0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
265         CORE_DVFS("msenc",      1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
266
267         CORE_DVFS("se",         0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
268         CORE_DVFS("se",         0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
269         CORE_DVFS("se",         1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
270
271         CORE_DVFS("vde",        0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
272         CORE_DVFS("vde",        0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
273         CORE_DVFS("vde",        1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
274
275         CORE_DVFS("host1x",     0, 0, 1, KHZ,   108000, 156000, 204000, 240000, 348000, 372000, 408000, 408000),
276         CORE_DVFS("host1x",     0, 1, 1, KHZ,   108000, 156000, 204000, 252000, 348000, 384000, 408000, 408000),
277         CORE_DVFS("host1x",     1, -1, 1, KHZ,  108000, 156000, 204000, 252000, 348000, 384000, 444000, 444000),
278
279         CORE_DVFS("vi",         0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
280         CORE_DVFS("vi",         0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
281         CORE_DVFS("vi",         1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
282
283         CORE_DVFS("isp",        0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
284         CORE_DVFS("isp",        0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
285         CORE_DVFS("isp",        1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
286
287 #ifdef CONFIG_TEGRA_DUAL_CBUS
288         CORE_DVFS("c2bus",      0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
289         CORE_DVFS("c2bus",      0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
290         CORE_DVFS("c2bus",      1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
291
292         CORE_DVFS("c3bus",      0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
293         CORE_DVFS("c3bus",      0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
294         CORE_DVFS("c3bus",      1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
295 #else
296         CORE_DVFS("cbus",      -1, -1, 1, KHZ,  120000, 144000, 168000, 168000, 216000, 216000, 372000, 372000),
297 #endif
298
299         CORE_DVFS("c4bus",      0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
300         CORE_DVFS("c4bus",      0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
301         CORE_DVFS("c4bus",      1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
302
303         CORE_DVFS("pll_m",  -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
304         CORE_DVFS("pll_c",  -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
305         CORE_DVFS("pll_c2", -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
306         CORE_DVFS("pll_c3", -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
307
308         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
309         /* Clock limits for I/O peripherals */
310         CORE_DVFS("sbc1",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
311         CORE_DVFS("sbc2",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
312         CORE_DVFS("sbc3",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
313         CORE_DVFS("sbc4",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
314         CORE_DVFS("sbc5",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
315         CORE_DVFS("sbc6",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
316
317         OVRRD_DVFS("sdmmc1", -1, -1, 1, KHZ,  100000, 100000, 100000, 100000,  136000, 136000, 136000, 204000),
318         OVRRD_DVFS("sdmmc3", -1, -1, 1, KHZ,  100000, 100000, 100000, 100000,  136000, 136000, 136000, 204000),
319         OVRRD_DVFS("sdmmc4", -1, -1, 1, KHZ,  102000, 102000, 102000, 102000,  136000, 136000, 136000, 200000),
320
321         CORE_DVFS("hdmi",   -1, -1, 1, KHZ,        1, 148500, 148500, 297000,  297000, 297000, 297000, 297000),
322         /* FIXME: Finalize these values for NOR after qual */
323         CORE_DVFS("nor",    -1, -1, 1, KHZ,   102000, 102000, 102000, 102000,  102000, 102000, 102000, 102000),
324
325         CORE_DVFS("pciex",  -1,  -1, 1, KHZ,  250000, 250000, 250000, 500000,  500000, 500000, 500000, 500000),
326
327         /*
328          * The clock rate for the display controllers that determines the
329          * necessary core voltage depends on a divider that is internal
330          * to the display block.  Disable auto-dvfs on the display clocks,
331          * and let the display driver call tegra_dvfs_set_rate manually
332          */
333         CORE_DVFS("disp1",       0, 0, 0, KHZ,   148500, 241000, 297000, 297000, 297000, 474000, 474000, 474000),
334         CORE_DVFS("disp1",       0, 1, 0, KHZ,   148500, 241000, 297000, 297000, 474000, 474000, 474000, 474000),
335         CORE_DVFS("disp1",       1, -1, 0, KHZ,  148500, 241000, 297000, 297000, 474000, 474000, 474000, 533000),
336
337         CORE_DVFS("disp2",       0, 0, 0, KHZ,   148500, 241000, 297000, 297000, 297000, 474000, 474000, 474000),
338         CORE_DVFS("disp2",       0, 1, 0, KHZ,   148500, 241000, 297000, 297000, 474000, 474000, 474000, 474000),
339         CORE_DVFS("disp2",       1, -1, 0, KHZ,  148500, 241000, 297000, 297000, 474000, 474000, 474000, 533000),
340
341 };
342
343 static struct gpu_cvb_dvfs gpu_cvb_dvfs_table[] = {
344         {
345                 .speedo_id =   0,
346                 .process_id = -1,
347                 .max_mv = 1200,
348                 .min_mv = 800,
349                 .freqs_mult = KHZ,
350                 .speedo_scale = 100,
351                 .thermal_scale = 10,
352                 .voltage_scale = 1000,
353                 .cvb_table = {
354                         /*f        dfll  pll:   c0,     c1,   c2,   c3,      c4,   c5 */
355                         {   72000, {  }, { 1013806, -14060, -127,   954, -27008,  781}, },
356                         {  108000, {  }, {  983062,  -9373, -263,   954, -26703,  650}, },
357                         {  180000, {  }, { 1040909, -12008, -224,   775, -23193,  376}, },
358                         {  252000, {  }, { 1150002, -20683,  -17,   298, -13428,  232}, },
359                         {  324000, {  }, { 1081549, -10827, -274,   179, -10681,  238}, },
360                         {  396000, {  }, { 1136931, -12086, -274,   119, -10071,  238}, },
361                         {  468000, {  }, { 1195664, -13329, -274,    60,  -8850,  221}, },
362                         {  540000, {  }, { 1257766, -14587, -274,     0,  -7019,  179}, },
363                         {  612000, {  }, { 1323069, -15830, -274,     0,  -4578,  113}, },
364                         {  648000, {  }, { 1356986, -16459, -274,     0,  -3204,   72}, },
365                         {       0, {  }, { }, },
366                 },
367                 .vmin_trips_table = { 20, },
368                 .therm_floors_table = { 900, },
369                 .vts_trips_table = { -10, 10, 30, 50, 70, },
370         },
371         {
372                 .speedo_id =   1,
373                 .process_id = -1,
374                 .max_mv = 1200,
375                 .min_mv = 800,
376                 .freqs_mult = KHZ,
377                 .speedo_scale = 100,
378                 .thermal_scale = 10,
379                 .voltage_scale = 1000,
380                 .cvb_table = {
381                         /*f        dfll  pll:   c0,     c1,   c2,   c3,      c4,   c5 */
382                         {   72000, {  }, { 1013806, -14060, -127,   954, -27008,  781}, },
383                         {  108000, {  }, {  983062,  -9373, -263,   954, -26703,  650}, },
384                         {  180000, {  }, { 1040909, -12008, -224,   775, -23193,  376}, },
385                         {  252000, {  }, { 1150002, -20683,  -17,   298, -13428,  232}, },
386                         {  324000, {  }, { 1081549, -10827, -274,   179, -10681,  238}, },
387                         {  396000, {  }, { 1136931, -12086, -274,   119, -10071,  238}, },
388                         {  468000, {  }, { 1195664, -13329, -274,    60,  -8850,  221}, },
389                         {  540000, {  }, { 1257766, -14587, -274,     0,  -7019,  179}, },
390                         {  612000, {  }, { 1323069, -15830, -274,     0,  -4578,  113}, },
391                         {  648000, {  }, { 1356986, -16459, -274,     0,  -3204,   72}, },
392                         {  684000, {  }, { 1391884, -17078, -274,   -60,  -1526,   30}, },
393                         {  708000, {  }, { 1415522, -17497, -274,   -60,   -458,    0}, },
394                         {  756000, {  }, { 1464061, -18331, -274,  -119,   1831,  -72}, },
395                         {  804000, {  }, { 1524225, -20064, -254,  -119,   4272, -155}, },
396                         {  852000, {  }, { 1608418, -21643, -269,     0,    763,  -48}, },
397                         {       0, {  }, { }, },
398                 },
399                 .vmin_trips_table = { 20, },
400                 .therm_floors_table = { 900, },
401                 .vts_trips_table = { -10, 10, 30, 50, 70, },
402         }
403 };
404
405 static int gpu_millivolts[MAX_THERMAL_RANGES][MAX_DVFS_FREQS];
406 static struct dvfs gpu_dvfs = {
407         .clk_name       = "gbus",
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 /* cvb_t_mv =
586    ((c3 * speedo / s_scale + c4 + c5 * T / t_scale) * T / t_scale) / v_scale */
587 static inline int get_cvb_t_voltage(int speedo, int s_scale, int t, int t_scale,
588                                     struct cvb_dvfs_parameters *cvb)
589 {
590         /* apply speedo & temperature scales: output mv = cvb_t_mv * v_scale */
591         int mv;
592         mv = DIV_ROUND_CLOSEST(cvb->c3 * speedo, s_scale) + cvb->c4 +
593                 DIV_ROUND_CLOSEST(cvb->c5 * t, t_scale);
594         mv = DIV_ROUND_CLOSEST(mv * t, t_scale);
595         return mv;
596 }
597
598 static int round_cvb_voltage(int mv, int v_scale, struct rail_alignment *align)
599 {
600         /* combined: apply voltage scale and round to cvb alignment step */
601         int uv;
602         int step = (align->step_uv ? : 1000) * v_scale;
603         int offset = align->offset_uv * v_scale;
604
605         uv = max(mv * 1000, offset) - offset;
606         uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;
607         return uv / 1000;
608 }
609
610 static int round_voltage(int mv, struct rail_alignment *align, bool up)
611 {
612         if (align->step_uv) {
613                 int uv = max(mv * 1000, align->offset_uv) - align->offset_uv;
614                 uv = (uv + (up ? align->step_uv - 1 : 0)) / align->step_uv;
615                 return (uv * align->step_uv + align->offset_uv) / 1000;
616         }
617         return mv;
618 }
619
620 static int __init set_cpu_dvfs_data(
621         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
622 {
623         int i, j, mv, dfll_mv, min_dfll_mv;
624         unsigned long fmax_at_vmin = 0;
625         unsigned long fmax_pll_mode = 0;
626         unsigned long fmin_use_dfll = 0;
627         struct cvb_dvfs_table *table = NULL;
628         int speedo = tegra_cpu_speedo_value();
629         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_cpu.alignment;
630
631         min_dfll_mv = d->dfll_tune_data.min_millivolts;
632         min_dfll_mv =  round_voltage(min_dfll_mv, align, true);
633         d->max_mv = round_voltage(d->max_mv, align, false);
634         BUG_ON(min_dfll_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
635
636         /*
637          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
638          * CVB entry specifies CPU frequency and CVB coefficients to calculate
639          * the respective voltage when either DFLL or PLL is used as CPU clock
640          * source.
641          *
642          * Minimum voltage limit is applied only to DFLL source. For PLL source
643          * voltage can go as low as table specifies. Maximum voltage limit is
644          * applied to both sources, but differently: directly clip voltage for
645          * DFLL, and limit maximum frequency for PLL.
646          */
647         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
648                 table = &d->cvb_table[i];
649                 if (!table->freq)
650                         break;
651
652                 dfll_mv = get_cvb_voltage(
653                         speedo, d->speedo_scale, &table->cvb_dfll_param);
654                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale, align);
655
656                 mv = get_cvb_voltage(
657                         speedo, d->speedo_scale, &table->cvb_pll_param);
658                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
659
660                 /*
661                  * Check maximum frequency at minimum voltage for dfll source;
662                  * round down unless all table entries are above Vmin, then use
663                  * the 1st entry as is.
664                  */
665                 dfll_mv = max(dfll_mv, min_dfll_mv);
666                 if (dfll_mv > min_dfll_mv) {
667                         if (!j)
668                                 fmax_at_vmin = table->freq;
669                         if (!fmax_at_vmin)
670                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
671                 }
672
673                 /* Clip maximum frequency at maximum voltage for pll source */
674                 if (mv > d->max_mv) {
675                         if (!j)
676                                 break;  /* 1st entry already above Vmax */
677                         if (!fmax_pll_mode)
678                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
679                 }
680
681                 /* Minimum rate with pll source voltage above dfll Vmin */
682                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
683                         fmin_use_dfll = table->freq;
684
685                 /* fill in dvfs tables */
686                 cpu_dvfs->freqs[j] = table->freq;
687                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
688                 cpu_millivolts[j] = mv;
689                 j++;
690
691                 /*
692                  * "Round-up" frequency list cut-off (keep first entry that
693                  *  exceeds max voltage - the voltage limit will be enforced
694                  *  anyway, so when requested this frequency dfll will settle
695                  *  at whatever high frequency it can on the particular chip)
696                  */
697                 if (dfll_mv > d->max_mv)
698                         break;
699         }
700
701         /* Table must not be empty, must have at least one entry above Vmin */
702         if (!i || !j || !fmax_at_vmin) {
703                 pr_err("tegra12_dvfs: invalid cpu dvfs table\n");
704                 return -ENOENT;
705         }
706
707         /* In the dfll operating range dfll voltage at any rate should be
708            better (below) than pll voltage */
709         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
710                 WARN(1, "tegra12_dvfs: pll voltage is below dfll in the dfll"
711                         " operating range\n");
712                 fmin_use_dfll = fmax_at_vmin;
713         }
714
715         /* dvfs tables are successfully populated - fill in the rest */
716         cpu_dvfs->speedo_id = d->speedo_id;
717         cpu_dvfs->process_id = d->process_id;
718         cpu_dvfs->freqs_mult = d->freqs_mult;
719         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
720                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
721         *max_freq_index = j - 1;
722
723         cpu_dvfs->dfll_data = d->dfll_tune_data;
724         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
725                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
726         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
727         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
728         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
729
730         /* Init cpu thermal floors */
731         tegra_dvfs_rail_init_vmin_thermal_profile(
732                 d->vmin_trips_table, d->therm_floors_table,
733                 &tegra12_dvfs_rail_vdd_cpu, &cpu_dvfs->dfll_data);
734
735         return 0;
736 }
737
738 static int __init set_gpu_dvfs_data(
739         struct gpu_cvb_dvfs *d, struct dvfs *gpu_dvfs, int *max_freq_index)
740 {
741         int i, j, thermal_ranges, mv;
742         struct cvb_dvfs_table *table = NULL;
743         int speedo = tegra_gpu_speedo_value();
744         struct dvfs_rail *rail = &tegra12_dvfs_rail_vdd_gpu;
745         struct rail_alignment *align = &rail->alignment;
746
747         d->max_mv = round_voltage(d->max_mv, align, false);
748         d->min_mv = round_voltage(d->min_mv, align, true);
749         BUG_ON(d->min_mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
750
751         /*
752          * Init thermal trips, find number of thermal ranges; note that the
753          * first trip-point is used for voltage calculations within the lowest
754          * range, but should not be actually set. Hence, at least 2 trip-points
755          * must be specified.
756          */
757         if (tegra_dvfs_rail_init_thermal_dvfs_trips(d->vts_trips_table, rail))
758                 return -ENOENT;
759         thermal_ranges = rail->vts_cdev->trip_temperatures_num;
760         rail->vts_cdev->trip_temperatures_num--;
761
762         if (thermal_ranges < 2)
763                 WARN(1, "tegra12_dvfs: %d gpu trip: thermal dvfs is broken\n",
764                      thermal_ranges);
765
766         /*
767          * Use CVB table to fill in gpu dvfs frequencies and voltages. Each
768          * CVB entry specifies gpu frequency and CVB coefficients to calculate
769          * the respective voltage.
770          */
771         for (i = 0; i < MAX_DVFS_FREQS; i++) {
772                 table = &d->cvb_table[i];
773                 if (!table->freq)
774                         break;
775
776                 mv = get_cvb_voltage(
777                         speedo, d->speedo_scale, &table->cvb_pll_param);
778
779                 for (j = 0; j < thermal_ranges; j++) {
780                         int mvj = mv;
781                         int t = rail->vts_cdev->trip_temperatures[j];
782
783                         /* get thermal offset for this trip-point */
784                         mvj += get_cvb_t_voltage(speedo, d->speedo_scale,
785                                 t, d->thermal_scale, &table->cvb_pll_param);
786                         mvj = round_cvb_voltage(mvj, d->voltage_scale, align);
787
788                         /* clip to minimum, abort if above maximum */
789                         mvj = max(mvj, d->min_mv);
790                         if (mvj > d->max_mv)
791                                 break;
792
793                         /* update voltage for adjacent ranges bounded by this
794                            trip-point (cvb & dvfs are transpose matrices) */
795                         gpu_millivolts[j][i] = mvj;
796                         if (j && (gpu_millivolts[j-1][i] < mvj))
797                                 gpu_millivolts[j-1][i] = mvj;
798                 }
799                 /* Make sure all voltages for this frequency are below max */
800                 if (j < thermal_ranges)
801                         break;
802
803                 /* fill in gpu dvfs tables */
804                 gpu_dvfs->freqs[i] = table->freq;
805         }
806
807         /*
808          * Table must not be empty, must have at least one entry in range, and
809          * must specify monotonically increasing voltage on frequency dependency
810          * in each temperature range.
811          */
812         if (!i || tegra_dvfs_init_thermal_dvfs_voltages(
813                 &gpu_millivolts[0][0], i, thermal_ranges, gpu_dvfs)) {
814                 pr_err("tegra12_dvfs: invalid gpu dvfs table\n");
815                 return -ENOENT;
816         }
817
818         /* Shift out the 1st trip-point */
819         for (j = 1; j < thermal_ranges; j++)
820                 rail->vts_cdev->trip_temperatures[j - 1] =
821                 rail->vts_cdev->trip_temperatures[j];
822
823         /* dvfs tables are successfully populated - fill in the gpu dvfs */
824         gpu_dvfs->speedo_id = d->speedo_id;
825         gpu_dvfs->process_id = d->process_id;
826         gpu_dvfs->freqs_mult = d->freqs_mult;
827         gpu_dvfs->dvfs_rail->nominal_millivolts = d->max_mv;
828
829         *max_freq_index = i - 1;
830
831         /* Init thermal floors */
832         tegra_dvfs_rail_init_vmin_thermal_profile(d->vmin_trips_table,
833                 d->therm_floors_table, &tegra12_dvfs_rail_vdd_gpu, NULL);
834
835         return 0;
836 }
837
838 static int __init get_core_nominal_mv_index(int speedo_id)
839 {
840         int i;
841         int mv = tegra_core_speedo_mv();
842         int core_edp_voltage = get_core_edp();
843
844         /*
845          * Start with nominal level for the chips with this speedo_id. Then,
846          * make sure core nominal voltage is below edp limit for the board
847          * (if edp limit is set).
848          */
849         if (!core_edp_voltage)
850                 core_edp_voltage = 1150;        /* default 1.15V EDP limit */
851
852         mv = min(mv, core_edp_voltage);
853
854         /* Round nominal level down to the nearest core scaling step */
855         for (i = 0; i < MAX_DVFS_FREQS; i++) {
856                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
857                         break;
858         }
859
860         if (i == 0) {
861                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
862                        " nominal voltage %d\n", mv);
863                 return -ENOSYS;
864         }
865         return i - 1;
866 }
867
868 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
869                          bool before_clk_update, int cpu_event)
870 {
871         /* empty definition for tegra12 */
872         return 0;
873 }
874
875 void __init tegra12x_init_dvfs(void)
876 {
877         int cpu_speedo_id = tegra_cpu_speedo_id();
878         int cpu_process_id = tegra_cpu_process_id();
879         int soc_speedo_id = tegra_soc_speedo_id();
880         int core_process_id = tegra_core_process_id();
881         int gpu_speedo_id = tegra_gpu_speedo_id();
882         int gpu_process_id = tegra_gpu_process_id();
883
884         int i, ret;
885         int core_nominal_mv_index;
886         int gpu_max_freq_index = 0;
887         int cpu_max_freq_index = 0;
888
889 #ifndef CONFIG_TEGRA_CORE_DVFS
890         tegra_dvfs_core_disabled = true;
891 #endif
892 #ifndef CONFIG_TEGRA_CPU_DVFS
893         tegra_dvfs_cpu_disabled = true;
894 #endif
895 #ifndef CONFIG_TEGRA_GPU_DVFS
896         tegra_dvfs_gpu_disabled = true;
897 #endif
898 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
899         if (!tegra_platform_is_silicon()) {
900                 tegra_dvfs_core_disabled = true;
901                 tegra_dvfs_cpu_disabled = true;
902         }
903 #endif
904
905         /*
906          * Find nominal voltages for core (1st) and cpu rails before rail
907          * init. Nominal voltage index in core scaling ladder can also be
908          * used to determine max dvfs frequencies for all core clocks. In
909          * case of error disable core scaling and set index to 0, so that
910          * core clocks would not exceed rates allowed at minimum voltage.
911          */
912         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
913         if (core_nominal_mv_index < 0) {
914                 tegra12_dvfs_rail_vdd_core.disabled = true;
915                 tegra_dvfs_core_disabled = true;
916                 core_nominal_mv_index = 0;
917         }
918         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
919                 core_millivolts[core_nominal_mv_index];
920
921         /*
922          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
923          * voltage for cpu rail, and cpu maximum frequency. Note that entire
924          * frequency range is guaranteed only when dfll is used as cpu clock
925          * source. Reaching maximum frequency with pll as cpu clock source
926          * may not be possible within nominal voltage range (dvfs mechanism
927          * would automatically fail frequency request in this case, so that
928          * voltage limit is not violated). Error when cpu dvfs table can not
929          * be constructed must never happen.
930          */
931         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
932                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
933                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
934                                    cpu_speedo_id, cpu_process_id)) {
935                         ret = set_cpu_dvfs_data(
936                                 d, &cpu_dvfs, &cpu_max_freq_index);
937                         break;
938                 }
939         }
940         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
941
942         /*
943          * Setup gpu dvfs tables from cvb data, determine nominal voltage for
944          * gpu rail, and gpu maximum frequency. Error when gpu dvfs table can
945          * not be constructed must never happen.
946          */
947         for (ret = 0, i = 0; i < ARRAY_SIZE(gpu_cvb_dvfs_table); i++) {
948                 struct gpu_cvb_dvfs *d = &gpu_cvb_dvfs_table[i];
949                 if (match_dvfs_one("gpu cvb", d->speedo_id, d->process_id,
950                                    gpu_speedo_id, gpu_process_id)) {
951                         ret = set_gpu_dvfs_data(
952                                 d, &gpu_dvfs, &gpu_max_freq_index);
953                         break;
954                 }
955         }
956         BUG_ON((i == ARRAY_SIZE(gpu_cvb_dvfs_table)) || ret);
957
958         /* Init core thermal profile */
959         tegra_dvfs_rail_init_vmin_thermal_profile(vdd_core_therm_trips_table,
960                 vdd_core_therm_floors_table, &tegra12_dvfs_rail_vdd_core, NULL);
961
962         /* Init rail structures and dependencies */
963         tegra_dvfs_init_rails(tegra12_dvfs_rails,
964                 ARRAY_SIZE(tegra12_dvfs_rails));
965
966         /* Search core dvfs table for speedo/process matching entries and
967            initialize dvfs-ed clocks */
968         if (!tegra_platform_is_linsim()) {
969                 for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
970                         struct dvfs *d = &core_dvfs_table[i];
971                         if (!match_dvfs_one(d->clk_name, d->speedo_id,
972                                 d->process_id, soc_speedo_id, core_process_id))
973                                 continue;
974                         init_dvfs_one(d, core_nominal_mv_index);
975                 }
976         }
977
978         /* Initialize matching gpu dvfs entry already found when nominal
979            voltage was determined */
980         init_dvfs_one(&gpu_dvfs, gpu_max_freq_index);
981
982         /* Initialize matching cpu dvfs entry already found when nominal
983            voltage was determined */
984         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
985
986         /* Finally disable dvfs on rails if necessary */
987         if (tegra_dvfs_core_disabled)
988                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
989         if (tegra_dvfs_cpu_disabled)
990                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
991         if (tegra_dvfs_gpu_disabled)
992                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
993
994         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
995                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
996                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
997         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
998                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
999                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
1000         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
1001                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
1002                 tegra_dvfs_gpu_disabled ? "disabled" : "enabled");
1003 }
1004
1005 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
1006 {
1007         return 0;
1008 }
1009
1010 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
1011 {
1012         return 0;
1013 }
1014
1015 /* Core voltage and bus cap object and tables */
1016 static struct kobject *cap_kobj;
1017 static struct kobject *gpu_kobj;
1018
1019 static struct core_dvfs_cap_table tegra12_core_cap_table[] = {
1020 #ifdef CONFIG_TEGRA_DUAL_CBUS
1021         { .cap_name = "cap.c2bus" },
1022         { .cap_name = "cap.c3bus" },
1023 #else
1024         { .cap_name = "cap.cbus" },
1025 #endif
1026         { .cap_name = "cap.sclk" },
1027         { .cap_name = "cap.emc" },
1028         { .cap_name = "cap.host1x" },
1029 };
1030
1031 static struct core_bus_limit_table tegra12_gpu_cap_syfs = {
1032         .limit_clk_name = "cap.profile.gbus",
1033         .refcnt_attr = {.attr = {.name = "gpu_cap_state", .mode = 0644} },
1034         .level_attr  = {.attr = {.name = "gpu_cap_rate", .mode = 0644} },
1035         .pm_qos_class = PM_QOS_GPU_FREQ_MAX,
1036 };
1037
1038 static struct core_bus_limit_table tegra12_gpu_floor_sysfs = {
1039         .limit_clk_name = "floor.profile.gbus",
1040         .refcnt_attr = {.attr = {.name = "gpu_floor_state", .mode = 0644} },
1041         .level_attr  = {.attr = {.name = "gpu_floor_rate", .mode = 0644} },
1042         .pm_qos_class = PM_QOS_GPU_FREQ_MIN,
1043 };
1044
1045 static struct core_bus_rates_table tegra12_gpu_rates_sysfs = {
1046         .bus_clk_name = "gbus",
1047         .rate_attr = {.attr = {.name = "gpu_rate", .mode = 0444} },
1048         .available_rates_attr = {
1049                 .attr = {.name = "gpu_available_rates", .mode = 0444} },
1050 };
1051
1052 static int __init tegra12_dvfs_init_core_cap(void)
1053 {
1054         int ret;
1055
1056         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
1057         if (!cap_kobj) {
1058                 pr_err("tegra12_dvfs: failed to create sysfs cap object\n");
1059                 return 0;
1060         }
1061
1062         ret = tegra_init_core_cap(
1063                 tegra12_core_cap_table, ARRAY_SIZE(tegra12_core_cap_table),
1064                 core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
1065
1066         if (ret) {
1067                 pr_err("tegra12_dvfs: failed to init core cap interface (%d)\n",
1068                        ret);
1069                 kobject_del(cap_kobj);
1070                 return 0;
1071         }
1072         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
1073
1074         gpu_kobj = kobject_create_and_add("tegra_gpu", kernel_kobj);
1075         if (!gpu_kobj) {
1076                 pr_err("tegra12_dvfs: failed to create sysfs gpu object\n");
1077                 return 0;
1078         }
1079
1080         ret = tegra_init_shared_bus_cap(&tegra12_gpu_cap_syfs,
1081                                         1, gpu_kobj);
1082         if (ret) {
1083                 pr_err("tegra12_dvfs: failed to init gpu cap interface (%d)\n",
1084                        ret);
1085                 kobject_del(gpu_kobj);
1086                 return 0;
1087         }
1088
1089         ret = tegra_init_shared_bus_floor(&tegra12_gpu_floor_sysfs,
1090                                           1, gpu_kobj);
1091         if (ret) {
1092                 pr_err("tegra12_dvfs: failed to init gpu floor interface (%d)\n",
1093                        ret);
1094                 kobject_del(gpu_kobj);
1095                 return 0;
1096         }
1097
1098         ret = tegra_init_sysfs_shared_bus_rate(&tegra12_gpu_rates_sysfs,
1099                                                1, gpu_kobj);
1100         if (ret) {
1101                 pr_err("tegra12_dvfs: failed to init gpu rates interface (%d)\n",
1102                        ret);
1103                 kobject_del(gpu_kobj);
1104                 return 0;
1105         }
1106         pr_info("tegra dvfs: tegra sysfs gpu interface is initialized\n");
1107
1108         return 0;
1109 }
1110 late_initcall(tegra12_dvfs_init_core_cap);