ARM: Tegra12: DVFS: Add audio codec clocks to dvfs table
[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/io.h>
22 #include <linux/clk.h>
23 #include <linux/kobject.h>
24 #include <linux/err.h>
25 #include <linux/pm_qos.h>
26 #include <linux/tegra-fuse.h>
27
28 #include "clock.h"
29 #include "dvfs.h"
30 #include "board.h"
31 #include "tegra_cl_dvfs.h"
32 #include "tegra_core_sysfs_limits.h"
33 #include "pm.h"
34
35 static bool tegra_dvfs_cpu_disabled;
36 static bool tegra_dvfs_core_disabled;
37 static bool tegra_dvfs_gpu_disabled;
38
39 #define KHZ 1000
40 #define MHZ 1000000
41
42 /* FIXME: need tegra12 step */
43 #define VDD_SAFE_STEP                   100
44
45 static int vdd_core_therm_trips_table[MAX_THERMAL_LIMITS] = { 20, };
46 static int vdd_core_therm_floors_table[MAX_THERMAL_LIMITS] = { 900, };
47
48 #ifndef CONFIG_TEGRA_CPU_VOLT_CAP
49 static int vdd_cpu_vmax_trips_table[MAX_THERMAL_LIMITS] = { 62,   72,   82, };
50 static int vdd_cpu_therm_caps_table[MAX_THERMAL_LIMITS] = { 1230, 1210, 1180, };
51
52 static struct tegra_cooling_device cpu_vmax_cdev = {
53         .cdev_type = "cpu_hot",
54 };
55 #endif
56
57 static struct tegra_cooling_device cpu_vmin_cdev = {
58         .cdev_type = "cpu_cold",
59 };
60
61 static struct tegra_cooling_device core_vmin_cdev = {
62         .cdev_type = "core_cold",
63 };
64
65 static struct tegra_cooling_device gpu_vmin_cdev = {
66         .cdev_type = "gpu_cold",
67 };
68
69 static struct tegra_cooling_device gpu_vts_cdev = {
70         .cdev_type = "gpu_scaling",
71 };
72
73 static struct dvfs_rail tegra12_dvfs_rail_vdd_cpu = {
74         .reg_id = "vdd_cpu",
75         .max_millivolts = 1400,
76         .min_millivolts = 800,
77         .step = VDD_SAFE_STEP,
78         .jmp_to_zero = true,
79         .vmin_cdev = &cpu_vmin_cdev,
80 #ifndef CONFIG_TEGRA_CPU_VOLT_CAP
81         .vmax_cdev = &cpu_vmax_cdev,
82 #endif
83         .alignment = {
84                 .step_uv = 10000, /* 10mV */
85         },
86         .stats = {
87                 .bin_uV = 10000, /* 10mV */
88         }
89 };
90
91 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
92         .reg_id = "vdd_core",
93         .max_millivolts = 1400,
94         .min_millivolts = 800,
95         .step = VDD_SAFE_STEP,
96         .step_up = 1400,
97         .vmin_cdev = &core_vmin_cdev,
98 };
99
100 /* TBD: fill in actual hw number */
101 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
102         .reg_id = "vdd_gpu",
103         .max_millivolts = 1350,
104         .min_millivolts = 680,
105         .step = VDD_SAFE_STEP,
106         .step_up = 1350,
107         .in_band_pm = true,
108         .vts_cdev = &gpu_vts_cdev,
109         .vmin_cdev = &gpu_vmin_cdev,
110         .alignment = {
111                 .step_uv = 10000, /* 10mV */
112         },
113         .stats = {
114                 .bin_uV = 10000, /* 10mV */
115         }
116 };
117
118 static struct dvfs_rail *tegra12_dvfs_rails[] = {
119         &tegra12_dvfs_rail_vdd_cpu,
120         &tegra12_dvfs_rail_vdd_core,
121         &tegra12_dvfs_rail_vdd_gpu,
122 };
123
124 void __init tegra12x_vdd_cpu_align(int step_uv, int offset_uv)
125 {
126         tegra12_dvfs_rail_vdd_cpu.alignment.step_uv = step_uv;
127         tegra12_dvfs_rail_vdd_cpu.alignment.offset_uv = offset_uv;
128 }
129
130 /* CPU DVFS tables */
131 static unsigned long cpu_max_freq[] = {
132 /* speedo_id    0        1        2        3      */
133                 2014500, 2320500, 2116500, 2524500,
134 };
135
136 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
137         {
138                 .speedo_id = -1,
139                 .process_id = -1,
140                 .dfll_tune_data  = {
141                         .tune0          = 0x005020FF,
142                         .tune0_high_mv  = 0x005040FF,
143                         .tune1          = 0x00000060,
144                         .droop_rate_min = 1000000,
145                         .tune_high_min_millivolts = 900,
146                         .min_millivolts = 800,
147                 },
148                 .max_mv = 1260,
149                 .freqs_mult = KHZ,
150                 .speedo_scale = 100,
151                 .voltage_scale = 1000,
152                 .cvb_table = {
153                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
154                         {204000,        {1112619, -29295, 402}, {720000, 0, 0}},
155                         {306000,        {1150460, -30585, 402}, {740000, 0, 0}},
156                         {408000,        {1190122, -31865, 402}, {750000, 0, 0}},
157                         {510000,        {1231606, -33155, 402}, {760000, 0, 0}},
158                         {612000,        {1274912, -34435, 402}, {780000, 0, 0}},
159                         {714000,        {1320040, -35725, 402}, {800000, 0, 0}},
160                         {816000,        {1366990, -37005, 402}, {820000, 0, 0}},
161                         {918000,        {1415762, -38295, 402}, {840000, 0, 0}},
162                         {1020000,       {1466355, -39575, 402}, {880000, 0, 0}},
163                         {1122000,       {1518771, -40865, 402}, {900000, 0, 0}},
164                         {1224000,       {1573009, -42145, 402}, {930000, 0, 0}},
165                         {1326000,       {1629068, -43435, 402}, {960000, 0, 0}},
166                         {1428000,       {1686950, -44715, 402}, {990000, 0, 0}},
167                         {1530000,       {1746653, -46005, 402}, {1020000, 0, 0}},
168                         {1632000,       {1808179, -47285, 402}, {1070000, 0, 0}},
169                         {1734000,       {1871526, -48575, 402}, {1100000, 0, 0}},
170                         {1836000,       {1936696, -49855, 402}, {1140000, 0, 0}},
171                         {1938000,       {2003687, -51145, 402}, {1180000, 0, 0}},
172                         {2014500,       {2054787, -52095, 402}, {1220000, 0, 0}},
173                         {2116500,       {2124957, -53385, 402}, {1260000, 0, 0}},
174                         {2218500,       {2196950, -54665, 402}, {1310000, 0, 0}},
175                         {2320500,       {2270765, -55955, 402}, {1360000, 0, 0}},
176                         {2422500,       {2346401, -57235, 402}, {1400000, 0, 0}},
177                         {2524500,       {2437299, -58535, 402}, {1400000, 0, 0}},
178                         {      0 ,      {      0,      0,   0}, {      0, 0, 0}},
179                 },
180                 .vmin_trips_table = { 20, },
181                 .therm_floors_table = { 900, },
182         },
183 };
184
185 static int cpu_millivolts[MAX_DVFS_FREQS];
186 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
187
188 static struct dvfs cpu_dvfs = {
189         .clk_name       = "cpu_g",
190         .millivolts     = cpu_millivolts,
191         .dfll_millivolts = cpu_dfll_millivolts,
192         .auto_dvfs      = true,
193         .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,
194 };
195
196 /* Core DVFS tables */
197 static const int core_millivolts[MAX_DVFS_FREQS] = {
198         800, 850, 900, 950, 1000, 1050, 1100, 1150};
199
200 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
201         {                                                       \
202                 .clk_name       = _clk_name,                    \
203                 .speedo_id      = _speedo_id,                   \
204                 .process_id     = _process_id,                  \
205                 .freqs          = {_freqs},                     \
206                 .freqs_mult     = _mult,                        \
207                 .millivolts     = core_millivolts,              \
208                 .auto_dvfs      = _auto,                        \
209                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
210         }
211
212 static struct dvfs core_dvfs_table[] = {
213         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
214         /* Clock limits for internal blocks, PLLs */
215
216         CORE_DVFS("emc",        -1, -1, 1, KHZ, 264000, 348000, 384000, 384000, 528000, 528000, 1066000, 1066000),
217
218         CORE_DVFS("cpu_lp",     0, 0, 1, KHZ,   312000, 528000, 660000, 804000, 912000, 1044000, 1044000, 1044000),
219         CORE_DVFS("cpu_lp",     0, 1, 1, KHZ,   312000, 564000, 696000, 828000, 960000, 1044000, 1044000, 1044000),
220         CORE_DVFS("cpu_lp",     1, -1, 1, KHZ,  312000, 564000, 696000, 828000, 960000, 1092000, 1092000, 1092000),
221
222         CORE_DVFS("sbus",       0, 0, 1, KHZ,   120000, 192000, 228000, 264000, 312000, 348000, 372000, 372000),
223         CORE_DVFS("sbus",       0, 1, 1, KHZ,   120000, 204000, 252000, 288000, 324000, 360000, 372000, 372000),
224         CORE_DVFS("sbus",       1, -1, 1, KHZ,  120000, 204000, 252000, 288000, 324000, 360000, 384000, 384000),
225
226         CORE_DVFS("vic03",      0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
227         CORE_DVFS("vic03",      0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
228         CORE_DVFS("vic03",      1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
229
230         CORE_DVFS("tsec",       0, 0, 1, KHZ,   228000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
231         CORE_DVFS("tsec",       0, 1, 1, KHZ,   228000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
232         CORE_DVFS("tsec",       1, -1, 1, KHZ,  228000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
233
234         CORE_DVFS("msenc",      0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
235         CORE_DVFS("msenc",      0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
236         CORE_DVFS("msenc",      1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
237
238         CORE_DVFS("se",         0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
239         CORE_DVFS("se",         0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
240         CORE_DVFS("se",         1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
241
242         CORE_DVFS("vde",        0, 0, 1, KHZ,   156000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
243         CORE_DVFS("vde",        0, 1, 1, KHZ,   168000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
244         CORE_DVFS("vde",        1, -1, 1, KHZ,  168000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
245
246         CORE_DVFS("host1x",     0, 0, 1, KHZ,   108000, 156000, 204000, 240000, 348000, 372000, 408000, 408000),
247         CORE_DVFS("host1x",     0, 1, 1, KHZ,   108000, 156000, 204000, 252000, 348000, 384000, 408000, 408000),
248         CORE_DVFS("host1x",     1, -1, 1, KHZ,  108000, 156000, 204000, 252000, 348000, 384000, 444000, 444000),
249
250         CORE_DVFS("vi",         0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
251         CORE_DVFS("vi",         0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
252         CORE_DVFS("vi",         1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
253
254         CORE_DVFS("isp",        0, 0, 1, KHZ,   300000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
255         CORE_DVFS("isp",        0, 1, 1, KHZ,   300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
256         CORE_DVFS("isp",        1, -1, 1, KHZ,  300000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
257
258 #ifdef CONFIG_TEGRA_DUAL_CBUS
259         CORE_DVFS("c2bus",      0, 0, 1, KHZ,   120000, 216000, 288000, 336000, 384000, 432000, 456000, 480000),
260         CORE_DVFS("c2bus",      0, 1, 1, KHZ,   120000, 228000, 276000, 348000, 396000, 444000, 480000, 480000),
261         CORE_DVFS("c2bus",      1, -1, 1, KHZ,  120000, 228000, 276000, 348000, 396000, 444000, 480000, 528000),
262
263         CORE_DVFS("c3bus",      0, 0, 1, KHZ,   180000, 324000, 408000, 492000, 588000, 660000, 708000, 756000),
264         CORE_DVFS("c3bus",      0, 1, 1, KHZ,   180000, 336000, 420000, 504000, 600000, 684000, 756000, 756000),
265         CORE_DVFS("c3bus",      1, -1, 1, KHZ,  180000, 336000, 420000, 504000, 600000, 684000, 756000, 828000),
266 #else
267         CORE_DVFS("cbus",      -1, -1, 1, KHZ,  120000, 144000, 168000, 168000, 216000, 216000, 372000, 372000),
268 #endif
269
270         CORE_DVFS("c4bus",      0, 0, 1, KHZ,   228000, 408000, 480000, 600000, 600000, 600000, 600000, 600000),
271         CORE_DVFS("c4bus",      0, 1, 1, KHZ,   228000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
272         CORE_DVFS("c4bus",      1, -1, 1, KHZ,  228000, 420000, 480000, 600000, 600000, 600000, 600000, 600000),
273
274         CORE_DVFS("pll_m",  -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
275         CORE_DVFS("pll_c",  -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
276         CORE_DVFS("pll_c2", -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
277         CORE_DVFS("pll_c3", -1, -1, 1, KHZ,   800000,  800000, 1066000, 1066000, 1066000, 1066000, 1066000, 1066000),
278
279         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
280         /* Clock limits for I/O peripherals */
281         CORE_DVFS("sbc1",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
282         CORE_DVFS("sbc2",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
283         CORE_DVFS("sbc3",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
284         CORE_DVFS("sbc4",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
285         CORE_DVFS("sbc5",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
286         CORE_DVFS("sbc6",   -1, -1, 1, KHZ,    33000,  33000,  33000,  33000,   33000,  33000,  51000,  51000),
287
288         CORE_DVFS("hdmi",   -1, -1, 1, KHZ,        1, 148500, 148500, 297000,  297000, 297000, 297000, 297000),
289         /* FIXME: Finalize these values for NOR after qual */
290         CORE_DVFS("nor",    -1, -1, 1, KHZ,   102000, 102000, 102000, 102000,  102000, 102000, 102000, 102000),
291
292         CORE_DVFS("pciex",  -1,  -1, 1, KHZ,  250000, 250000, 250000, 500000,  500000, 500000, 500000, 500000),
293         CORE_DVFS("mselect", -1, -1, 1, KHZ,  102000, 102000, 204000, 204000,  408000, 408000, 408000, 408000),
294
295         /* Core voltages (mV):                          800,    850,    900,     950,    1000,  1050,    1100,   1150 */
296         /* xusb clocks */
297         CORE_DVFS("xusb_falcon_src", -1, -1, 1, KHZ,      1, 336000, 336000, 336000, 336000, 336000 ,  336000,  336000),
298         CORE_DVFS("xusb_host_src",   -1, -1, 1, KHZ,      1, 112000, 112000, 112000, 112000, 112000 ,  112000,  112000),
299         CORE_DVFS("xusb_dev_src",    -1, -1, 1, KHZ,      1,  58300,  58300,  58300, 112000, 112000 ,  112000,  112000),
300         CORE_DVFS("xusb_ss_src",     -1, -1, 1, KHZ,      1, 120000, 120000, 120000, 120000, 120000 ,  120000,  120000),
301         CORE_DVFS("xusb_fs_src",     -1, -1, 1, KHZ,      1,  48000,  48000,  48000,  48000,  48000 ,   48000,   48000),
302         CORE_DVFS("xusb_hs_src",     -1, -1, 1, KHZ,      1,  60000,  60000,  60000,  60000,  60000 ,   60000,   60000),
303
304         CORE_DVFS("hda",             -1, -1, 1, KHZ,      1, 108000, 108000, 108000, 108000, 108000 ,  108000,  108000),
305         CORE_DVFS("hda2codec_2x",    -1, -1, 1, KHZ,      1,  48000,  48000,  48000,  48000,  48000 ,   48000,   48000),
306 };
307
308 /*
309  * Separate sdmmc and display dvfs table to handle dependency of sdmmc
310  * tuning on display maximum rate.
311  *
312  * FIXME: details
313  */
314 #define OVRRD_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
315         {                                                       \
316                 .clk_name       = _clk_name,                    \
317                 .speedo_id      = _speedo_id,                   \
318                 .process_id     = _process_id,                  \
319                 .freqs          = {_freqs},                     \
320                 .freqs_mult     = _mult,                        \
321                 .millivolts     = core_millivolts,              \
322                 .auto_dvfs      = _auto,                        \
323                 .can_override   = true,                         \
324                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
325         }
326
327 #define DEFER_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
328         {                                                       \
329                 .clk_name       = _clk_name,                    \
330                 .speedo_id      = _speedo_id,                   \
331                 .process_id     = _process_id,                  \
332                 .freqs          = {_freqs},                     \
333                 .freqs_mult     = _mult,                        \
334                 .millivolts     = core_millivolts,              \
335                 .auto_dvfs      = _auto,                        \
336                 .defer_override = true,                         \
337                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
338         }
339
340         /* Core voltages (mV):                   800,    850,    900,    950,    1000,  1050,    1100,   1150 */
341 static struct dvfs sdmmc_dvfs_table[] = {
342         OVRRD_DVFS("sdmmc1", -1, -1, 1, KHZ,       1,      1,  50000,  50000,   50000,  50000,  50000, 204000),
343         OVRRD_DVFS("sdmmc3", -1, -1, 1, KHZ,       1,      1,  50000,  50000,   50000,  50000,  50000, 204000),
344         OVRRD_DVFS("sdmmc4", -1, -1, 1, KHZ,       1,      1,  50000,  50000,   50000,  50000,  50000, 200000),
345 };
346
347 static struct dvfs sdmmc_tune2_dvfs_table[] = {
348         OVRRD_DVFS("sdmmc1", -1, -1, 1, KHZ,       1,      1,  82000,  82000,  136000, 136000, 136000, 204000),
349         OVRRD_DVFS("sdmmc3", -1, -1, 1, KHZ,       1,      1,  82000,  82000,  136000, 136000, 136000, 204000),
350         OVRRD_DVFS("sdmmc4", -1, -1, 1, KHZ,       1,      1,  82000,  82000,  136000, 136000, 136000, 200000),
351 };
352
353 static struct dvfs disp_dvfs_table[] = {
354         /*
355          * The clock rate for the display controllers that determines the
356          * necessary core voltage depends on a divider that is internal
357          * to the display block.  Disable auto-dvfs on the display clocks,
358          * and let the display driver call tegra_dvfs_set_rate manually
359          */
360         /* Core voltages (mV)                     800,    850,    900,    950,    1000,   1050,   1100,   1150 */
361         DEFER_DVFS("disp1",       0,  0, 0, KHZ,  180000, 240000, 282000, 330000, 388000, 408000, 456000, 490000),
362         DEFER_DVFS("disp1",       0,  1, 0, KHZ,  192000, 247000, 306000, 342000, 400000, 432000, 474000, 490000),
363         DEFER_DVFS("disp1",       1, -1, 0, KHZ,  192000, 247000, 306000, 342000, 400000, 432000, 474000, 535000),
364
365         DEFER_DVFS("disp2",       0,  0, 0, KHZ,  180000, 240000, 282000, 330000, 388000, 408000, 456000, 490000),
366         DEFER_DVFS("disp2",       0,  1, 0, KHZ,  192000, 247000, 306000, 342000, 400000, 432000, 474000, 490000),
367         DEFER_DVFS("disp2",       1, -1, 0, KHZ,  192000, 247000, 306000, 342000, 400000, 432000, 474000, 535000),
368 };
369
370 static int resolve_core_override(int min_override_mv)
371 {
372         int i, j;
373         struct dvfs *d = sdmmc_dvfs_table;
374         struct dvfs *d_tune = sdmmc_tune2_dvfs_table;
375
376         BUILD_BUG_ON(ARRAY_SIZE(sdmmc_dvfs_table) !=
377                      ARRAY_SIZE(sdmmc_tune2_dvfs_table));
378
379         if (min_override_mv >=
380             tegra12_dvfs_rail_vdd_core.nominal_millivolts)
381                 return 0;
382
383         /* Override range is not 0: 2+ points for SDMMC tuning are available */
384         for (i = 0; i < ARRAY_SIZE(sdmmc_dvfs_table); i++, d++, d_tune++) {
385                 for (j = 0; j < d->num_freqs; j++)
386                         d->freqs[j] = d_tune->freqs[j] * d_tune->freqs_mult;
387         }
388         return 0;
389 }
390
391 /* GPU DVFS tables */
392 static unsigned long gpu_max_freq[] = {
393 /* speedo_id    0       1       2       */
394                 648000, 852000, 1032000,
395 };
396 static struct gpu_cvb_dvfs gpu_cvb_dvfs_table[] = {
397         {
398                 .speedo_id =  -1,
399                 .process_id = -1,
400                 .max_mv = 1200,
401                 .freqs_mult = KHZ,
402                 .speedo_scale = 100,
403                 .thermal_scale = 10,
404                 .voltage_scale = 1000,
405                 .cvb_table = {
406                         /*f        dfll  pll:   c0,     c1,   c2,   c3,      c4,   c5 */
407                         {   72000, {  }, { 1013806, -14060, -127,   954, -27008,  781}, },
408                         {  108000, {  }, {  983062,  -9373, -263,   954, -26703,  650}, },
409                         {  180000, {  }, { 1040909, -12008, -224,   775, -23193,  376}, },
410                         {  252000, {  }, { 1150002, -20683,  -17,   298, -13428,  232}, },
411                         {  324000, {  }, { 1081549, -10827, -274,   179, -10681,  238}, },
412                         {  396000, {  }, { 1136931, -12086, -274,   119, -10071,  238}, },
413                         {  468000, {  }, { 1195664, -13329, -274,    60,  -8850,  221}, },
414                         {  540000, {  }, { 1257766, -14587, -274,     0,  -7019,  179}, },
415                         {  612000, {  }, { 1323069, -15830, -274,     0,  -4578,  113}, },
416                         {  648000, {  }, { 1356986, -16459, -274,     0,  -3204,   72}, },
417                         {  684000, {  }, { 1391884, -17078, -274,   -60,  -1526,   30}, },
418                         {  708000, {  }, { 1415522, -17497, -274,   -60,   -458,    0}, },
419                         {  756000, {  }, { 1464061, -18331, -274,  -119,   1831,  -72}, },
420                         {  804000, {  }, { 1524225, -20064, -254,  -119,   4272, -155}, },
421                         {  852000, {  }, { 1608418, -21643, -269,     0,    763,  -48}, },
422                         {  900000, {  }, { 1706383, -25155, -209,     0,    305,    0}, },
423                         {  924000, {  }, { 1739600, -26289, -194,     0,    763,    0}, },
424                         {  960000, {  }, { 1889996, -35353,   14,  -179,   4120,   24}, },
425                         {  984000, {  }, { 1898000, -35353,   14,  -179,   4120,   24}, },
426                         { 1008000, {  }, { 1875901, -31345,  -80,  -358,   7477,   89}, },
427                         { 1032000, {  }, { 1842464, -25088, -236,  -477,   9155,  173}, },
428                         {       0, {  }, { }, },
429                 },
430                 .cvb_vmin =  {  0, {  }, { 1160000, -18900,    0,     0,  -6110,    0}, },
431                 .vmin_trips_table = { 15, },
432                 .therm_floors_table = { 900, },
433                 .vts_trips_table = { -10, 10, 30, 50, 70, },
434         }
435 };
436
437 static int gpu_vmin[MAX_THERMAL_RANGES];
438 static int gpu_peak_millivolts[MAX_DVFS_FREQS];
439 static int gpu_millivolts[MAX_THERMAL_RANGES][MAX_DVFS_FREQS];
440 static struct dvfs gpu_dvfs = {
441         .clk_name       = "gbus",
442         .auto_dvfs      = true,
443         .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,
444 };
445
446 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
447 {
448         int ret;
449
450         ret = param_set_bool(arg, kp);
451         if (ret)
452                 return ret;
453
454         if (tegra_dvfs_core_disabled)
455                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
456         else
457                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
458
459         return 0;
460 }
461
462 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
463 {
464         int ret;
465
466         ret = param_set_bool(arg, kp);
467         if (ret)
468                 return ret;
469
470         if (tegra_dvfs_cpu_disabled)
471                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
472         else
473                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
474
475         return 0;
476 }
477
478 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
479 {
480         int ret;
481
482         ret = param_set_bool(arg, kp);
483         if (ret)
484                 return ret;
485
486         if (tegra_dvfs_gpu_disabled)
487                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
488         else
489                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
490
491         return 0;
492 }
493
494 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
495 {
496         return param_get_bool(buffer, kp);
497 }
498
499 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
500         .set = tegra_dvfs_disable_core_set,
501         .get = tegra_dvfs_disable_get,
502 };
503
504 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
505         .set = tegra_dvfs_disable_cpu_set,
506         .get = tegra_dvfs_disable_get,
507 };
508
509 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
510         .set = tegra_dvfs_disable_gpu_set,
511         .get = tegra_dvfs_disable_get,
512 };
513
514 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
515         &tegra_dvfs_core_disabled, 0644);
516 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
517         &tegra_dvfs_cpu_disabled, 0644);
518 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
519         &tegra_dvfs_gpu_disabled, 0644);
520
521 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
522 {
523         /* Don't update manual dvfs clocks */
524         if (!d->auto_dvfs)
525                 return false;
526
527         /*
528          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
529          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
530          * together with the image) and board specific EMC DFS table; we will
531          * check the scaling ladder against nominal core voltage when the table
532          * is loaded (and if on particular board the table is not loaded, EMC
533          * scaling is disabled).
534          */
535         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
536                 return false;
537
538         /*
539          * Don't update shared cbus, and don't propagate common cbus dvfs
540          * limit down to shared users, but set maximum rate for each user
541          * equal to the respective client limit.
542          */
543         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
544                 struct clk *user;
545                 unsigned long rate;
546
547                 list_for_each_entry(
548                         user, &c->shared_bus_list, u.shared_bus_user.node) {
549                         if (user->u.shared_bus_user.client) {
550                                 rate = user->u.shared_bus_user.client->max_rate;
551                                 user->max_rate = rate;
552                                 user->u.shared_bus_user.rate = rate;
553                         }
554                 }
555                 return false;
556         }
557
558         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
559         return true;
560 }
561
562 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
563 {
564         int ret;
565         struct clk *c = tegra_get_clock_by_name(d->clk_name);
566
567         if (!c) {
568                 pr_debug("tegra12_dvfs: no clock found for %s\n",
569                         d->clk_name);
570                 return;
571         }
572
573         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
574         if (can_update_max_rate(c, d)) {
575                 BUG_ON(!d->freqs[max_freq_index]);
576                 tegra_init_max_rate(
577                         c, d->freqs[max_freq_index] * d->freqs_mult);
578         }
579         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
580
581         ret = tegra_enable_dvfs_on_clk(c, d);
582         if (ret)
583                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
584 }
585
586 static bool __init match_dvfs_one(const char *name,
587         int dvfs_speedo_id, int dvfs_process_id,
588         int speedo_id, int process_id)
589 {
590         if ((dvfs_process_id != -1 && dvfs_process_id != process_id) ||
591                 (dvfs_speedo_id != -1 && dvfs_speedo_id != speedo_id)) {
592                 pr_debug("tegra12_dvfs: rejected %s speedo %d, process %d\n",
593                          name, dvfs_speedo_id, dvfs_process_id);
594                 return false;
595         }
596         return true;
597 }
598
599 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
600 static inline int get_cvb_voltage(int speedo, int s_scale,
601                                   struct cvb_dvfs_parameters *cvb)
602 {
603         /* apply only speedo scale: output mv = cvb_mv * v_scale */
604         int mv;
605         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
606         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
607         return mv;
608 }
609
610 /* cvb_t_mv =
611    ((c3 * speedo / s_scale + c4 + c5 * T / t_scale) * T / t_scale) / v_scale */
612 static inline int get_cvb_t_voltage(int speedo, int s_scale, int t, int t_scale,
613                                     struct cvb_dvfs_parameters *cvb)
614 {
615         /* apply speedo & temperature scales: output mv = cvb_t_mv * v_scale */
616         int mv;
617         mv = DIV_ROUND_CLOSEST(cvb->c3 * speedo, s_scale) + cvb->c4 +
618                 DIV_ROUND_CLOSEST(cvb->c5 * t, t_scale);
619         mv = DIV_ROUND_CLOSEST(mv * t, t_scale);
620         return mv;
621 }
622
623 static int round_cvb_voltage(int mv, int v_scale, struct rail_alignment *align)
624 {
625         /* combined: apply voltage scale and round to cvb alignment step */
626         int uv;
627         int step = (align->step_uv ? : 1000) * v_scale;
628         int offset = align->offset_uv * v_scale;
629
630         uv = max(mv * 1000, offset) - offset;
631         uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;
632         return uv / 1000;
633 }
634
635 static int round_voltage(int mv, struct rail_alignment *align, bool up)
636 {
637         if (align->step_uv) {
638                 int uv = max(mv * 1000, align->offset_uv) - align->offset_uv;
639                 uv = (uv + (up ? align->step_uv - 1 : 0)) / align->step_uv;
640                 return (uv * align->step_uv + align->offset_uv) / 1000;
641         }
642         return mv;
643 }
644
645 static int __init set_cpu_dvfs_data(unsigned long max_freq,
646         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
647 {
648         int j, mv, dfll_mv, min_dfll_mv;
649         unsigned long fmax_at_vmin = 0;
650         unsigned long fmax_pll_mode = 0;
651         unsigned long fmin_use_dfll = 0;
652         struct cvb_dvfs_table *table = NULL;
653         int speedo = tegra_cpu_speedo_value();
654         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_cpu.alignment;
655
656         min_dfll_mv = d->dfll_tune_data.min_millivolts;
657         min_dfll_mv =  round_voltage(min_dfll_mv, align, true);
658         d->max_mv = round_voltage(d->max_mv, align, false);
659         BUG_ON(min_dfll_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
660
661         /*
662          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
663          * CVB entry specifies CPU frequency and CVB coefficients to calculate
664          * the respective voltage when either DFLL or PLL is used as CPU clock
665          * source.
666          *
667          * Minimum voltage limit is applied only to DFLL source. For PLL source
668          * voltage can go as low as table specifies. Maximum voltage limit is
669          * applied to both sources, but differently: directly clip voltage for
670          * DFLL, and limit maximum frequency for PLL.
671          */
672         for (j = 0; j < MAX_DVFS_FREQS; j++) {
673                 table = &d->cvb_table[j];
674                 if (!table->freq || (table->freq > max_freq))
675                         break;
676
677                 dfll_mv = get_cvb_voltage(
678                         speedo, d->speedo_scale, &table->cvb_dfll_param);
679                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale, align);
680
681                 mv = get_cvb_voltage(
682                         speedo, d->speedo_scale, &table->cvb_pll_param);
683                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
684
685                 /*
686                  * Check maximum frequency at minimum voltage for dfll source;
687                  * round down unless all table entries are above Vmin, then use
688                  * the 1st entry as is.
689                  */
690                 dfll_mv = max(dfll_mv, min_dfll_mv);
691                 if (dfll_mv > min_dfll_mv) {
692                         if (!j)
693                                 fmax_at_vmin = table->freq;
694                         if (!fmax_at_vmin)
695                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
696                 }
697
698                 /* Clip maximum frequency at maximum voltage for pll source */
699                 if (mv > d->max_mv) {
700                         if (!j)
701                                 break;  /* 1st entry already above Vmax */
702                         if (!fmax_pll_mode)
703                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
704                 }
705
706                 /* Minimum rate with pll source voltage above dfll Vmin */
707                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
708                         fmin_use_dfll = table->freq;
709
710                 /* fill in dvfs tables */
711                 cpu_dvfs->freqs[j] = table->freq;
712                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
713                 cpu_millivolts[j] = mv;
714         }
715
716         /* Table must not be empty, must have at least one entry above Vmin */
717         if (!j || !fmax_at_vmin) {
718                 pr_err("tegra12_dvfs: invalid cpu dvfs table\n");
719                 return -ENOENT;
720         }
721
722         /* In the dfll operating range dfll voltage at any rate should be
723            better (below) than pll voltage */
724         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
725                 WARN(1, "tegra12_dvfs: pll voltage is below dfll in the dfll"
726                         " operating range\n");
727                 fmin_use_dfll = fmax_at_vmin;
728         }
729
730         /* dvfs tables are successfully populated - fill in the rest */
731         cpu_dvfs->speedo_id = d->speedo_id;
732         cpu_dvfs->process_id = d->process_id;
733         cpu_dvfs->freqs_mult = d->freqs_mult;
734         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
735                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
736         *max_freq_index = j - 1;
737
738         cpu_dvfs->dfll_data = d->dfll_tune_data;
739         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
740                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
741         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
742         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
743         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
744         cpu_dvfs->dfll_data.is_bypass_down = is_lp_cluster;
745
746         /* Init cpu thermal floors */
747         tegra_dvfs_rail_init_vmin_thermal_profile(
748                 d->vmin_trips_table, d->therm_floors_table,
749                 &tegra12_dvfs_rail_vdd_cpu, &cpu_dvfs->dfll_data);
750
751         /* Init cpu thermal caps */
752 #ifndef CONFIG_TEGRA_CPU_VOLT_CAP
753         tegra_dvfs_rail_init_vmax_thermal_profile(
754                 vdd_cpu_vmax_trips_table, vdd_cpu_therm_caps_table,
755                 &tegra12_dvfs_rail_vdd_cpu, &cpu_dvfs->dfll_data);
756 #endif
757
758         return 0;
759 }
760
761 static int __init set_gpu_dvfs_data(unsigned long max_freq,
762         struct gpu_cvb_dvfs *d, struct dvfs *gpu_dvfs, int *max_freq_index)
763 {
764         int i, j, thermal_ranges, mv;
765         struct cvb_dvfs_table *table = NULL;
766         int speedo = tegra_gpu_speedo_value();
767         struct dvfs_rail *rail = &tegra12_dvfs_rail_vdd_gpu;
768         struct rail_alignment *align = &rail->alignment;
769
770         d->max_mv = round_voltage(d->max_mv, align, false);
771
772         /*
773          * Init thermal trips, find number of thermal ranges; note that the
774          * first trip-point is used for voltage calculations within the lowest
775          * range, but should not be actually set. Hence, at least 2 trip-points
776          * must be specified.
777          */
778         if (tegra_dvfs_rail_init_thermal_dvfs_trips(d->vts_trips_table, rail))
779                 return -ENOENT;
780         thermal_ranges = rail->vts_cdev->trip_temperatures_num;
781         rail->vts_cdev->trip_temperatures_num--;
782
783         if (thermal_ranges < 2)
784                 WARN(1, "tegra12_dvfs: %d gpu trip: thermal dvfs is broken\n",
785                      thermal_ranges);
786
787         /*
788          * Use CVB table to calculate Vmin for each temperature range
789          */
790         mv = get_cvb_voltage(
791                 speedo, d->speedo_scale, &d->cvb_vmin.cvb_pll_param);
792         for (j = 0; j < thermal_ranges; j++) {
793                 int mvj = mv;
794                 int t = rail->vts_cdev->trip_temperatures[j];
795
796                 /* add Vmin thermal offset for this trip-point */
797                 mvj += get_cvb_t_voltage(speedo, d->speedo_scale,
798                         t, d->thermal_scale, &d->cvb_vmin.cvb_pll_param);
799                 mvj = round_cvb_voltage(mvj, d->voltage_scale, align);
800                 if (mvj < rail->min_millivolts) {
801                         WARN(1, "tegra12_dvfs: gpu Vmin %d below rail min %d\n",
802                              mvj, rail->min_millivolts);
803                         mvj = rail->min_millivolts;
804                 }
805                 gpu_vmin[j] = mvj;
806         }
807
808         /*
809          * Use CVB table to fill in gpu dvfs frequencies and voltages. Each
810          * CVB entry specifies gpu frequency and CVB coefficients to calculate
811          * the respective voltage.
812          */
813         for (i = 0; i < MAX_DVFS_FREQS; i++) {
814                 table = &d->cvb_table[i];
815                 if (!table->freq || (table->freq > max_freq))
816                         break;
817
818                 mv = get_cvb_voltage(
819                         speedo, d->speedo_scale, &table->cvb_pll_param);
820
821                 for (j = 0; j < thermal_ranges; j++) {
822                         int mvj = mv;
823                         int t = rail->vts_cdev->trip_temperatures[j];
824
825                         /* get thermal offset for this trip-point */
826                         mvj += get_cvb_t_voltage(speedo, d->speedo_scale,
827                                 t, d->thermal_scale, &table->cvb_pll_param);
828                         mvj = round_cvb_voltage(mvj, d->voltage_scale, align);
829
830                         /* clip to minimum, abort if above maximum */
831                         mvj = max(mvj, gpu_vmin[j]);
832                         if (mvj > d->max_mv)
833                                 break;
834
835                         /* update voltage for adjacent ranges bounded by this
836                            trip-point (cvb & dvfs are transpose matrices) */
837                         gpu_millivolts[j][i] = mvj;
838                         if (j && (gpu_millivolts[j-1][i] < mvj))
839                                 gpu_millivolts[j-1][i] = mvj;
840                 }
841                 /* Make sure all voltages for this frequency are below max */
842                 if (j < thermal_ranges)
843                         break;
844
845                 /* fill in gpu dvfs tables */
846                 gpu_dvfs->freqs[i] = table->freq;
847         }
848
849         /*
850          * Table must not be empty, must have at least one entry in range, and
851          * must specify monotonically increasing voltage on frequency dependency
852          * in each temperature range.
853          */
854         if (!i || tegra_dvfs_init_thermal_dvfs_voltages(&gpu_millivolts[0][0],
855                 gpu_peak_millivolts, i, thermal_ranges, gpu_dvfs)) {
856                 pr_err("tegra12_dvfs: invalid gpu dvfs table\n");
857                 return -ENOENT;
858         }
859
860         /* Shift out the 1st trip-point */
861         for (j = 1; j < thermal_ranges; j++)
862                 rail->vts_cdev->trip_temperatures[j - 1] =
863                 rail->vts_cdev->trip_temperatures[j];
864
865         /* dvfs tables are successfully populated - fill in the gpu dvfs */
866         gpu_dvfs->speedo_id = d->speedo_id;
867         gpu_dvfs->process_id = d->process_id;
868         gpu_dvfs->freqs_mult = d->freqs_mult;
869         gpu_dvfs->dvfs_rail->nominal_millivolts = d->max_mv;
870
871         *max_freq_index = i - 1;
872
873         /* Init thermal floors */
874         tegra_dvfs_rail_init_vmin_thermal_profile(d->vmin_trips_table,
875                 d->therm_floors_table, &tegra12_dvfs_rail_vdd_gpu, NULL);
876
877         return 0;
878 }
879
880 static int __init get_core_nominal_mv_index(int speedo_id)
881 {
882         int i;
883         int mv = tegra_core_speedo_mv();
884         int core_edp_voltage = get_core_edp();
885
886         /*
887          * Start with nominal level for the chips with this speedo_id. Then,
888          * make sure core nominal voltage is below edp limit for the board
889          * (if edp limit is set).
890          */
891         if (!core_edp_voltage)
892                 core_edp_voltage = 1150;        /* default 1.15V EDP limit */
893
894         mv = min(mv, core_edp_voltage);
895
896         /* Round nominal level down to the nearest core scaling step */
897         for (i = 0; i < MAX_DVFS_FREQS; i++) {
898                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
899                         break;
900         }
901
902         if (i == 0) {
903                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
904                        " nominal voltage %d\n", mv);
905                 return -ENOSYS;
906         }
907         return i - 1;
908 }
909
910 #define INIT_CORE_DVFS_TABLE(table, table_size)                                \
911         do {                                                                   \
912                 for (i = 0; i < (table_size); i++) {                           \
913                         struct dvfs *d = &(table)[i];                          \
914                         if (!match_dvfs_one(d->clk_name, d->speedo_id,         \
915                                 d->process_id, soc_speedo_id, core_process_id))\
916                                 continue;                                      \
917                         init_dvfs_one(d, core_nominal_mv_index);               \
918                 }                                                              \
919         } while (0)
920
921 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
922                          bool before_clk_update, int cpu_event)
923 {
924         /* empty definition for tegra12 */
925         return 0;
926 }
927
928 void __init tegra12x_init_dvfs(void)
929 {
930         int cpu_speedo_id = tegra_cpu_speedo_id();
931         int cpu_process_id = tegra_cpu_process_id();
932         int soc_speedo_id = tegra_soc_speedo_id();
933         int core_process_id = tegra_core_process_id();
934         int gpu_speedo_id = tegra_gpu_speedo_id();
935         int gpu_process_id = tegra_gpu_process_id();
936
937         int i, ret;
938         int core_nominal_mv_index;
939         int gpu_max_freq_index = 0;
940         int cpu_max_freq_index = 0;
941
942 #ifndef CONFIG_TEGRA_CORE_DVFS
943         tegra_dvfs_core_disabled = true;
944 #endif
945 #ifndef CONFIG_TEGRA_CPU_DVFS
946         tegra_dvfs_cpu_disabled = true;
947 #endif
948 #ifndef CONFIG_TEGRA_GPU_DVFS
949         tegra_dvfs_gpu_disabled = true;
950 #endif
951 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
952         if (!tegra_platform_is_silicon()) {
953                 tegra_dvfs_core_disabled = true;
954                 tegra_dvfs_cpu_disabled = true;
955         }
956 #endif
957
958         /*
959          * Find nominal voltages for core (1st) and cpu rails before rail
960          * init. Nominal voltage index in core scaling ladder can also be
961          * used to determine max dvfs frequencies for all core clocks. In
962          * case of error disable core scaling and set index to 0, so that
963          * core clocks would not exceed rates allowed at minimum voltage.
964          */
965         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
966         if (core_nominal_mv_index < 0) {
967                 tegra12_dvfs_rail_vdd_core.disabled = true;
968                 tegra_dvfs_core_disabled = true;
969                 core_nominal_mv_index = 0;
970         }
971         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
972                 core_millivolts[core_nominal_mv_index];
973
974         tegra12_dvfs_rail_vdd_core.resolve_override = resolve_core_override;
975
976         /*
977          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
978          * voltage for cpu rail, and cpu maximum frequency. Note that entire
979          * frequency range is guaranteed only when dfll is used as cpu clock
980          * source. Reaching maximum frequency with pll as cpu clock source
981          * may not be possible within nominal voltage range (dvfs mechanism
982          * would automatically fail frequency request in this case, so that
983          * voltage limit is not violated). Error when cpu dvfs table can not
984          * be constructed must never happen.
985          */
986         BUG_ON(cpu_speedo_id >= ARRAY_SIZE(cpu_max_freq));
987         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
988                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
989                 unsigned long max_freq = cpu_max_freq[cpu_speedo_id];
990                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
991                                    cpu_speedo_id, cpu_process_id)) {
992                         ret = set_cpu_dvfs_data(max_freq,
993                                 d, &cpu_dvfs, &cpu_max_freq_index);
994                         break;
995                 }
996         }
997         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
998
999         /*
1000          * Setup gpu dvfs tables from cvb data, determine nominal voltage for
1001          * gpu rail, and gpu maximum frequency. Error when gpu dvfs table can
1002          * not be constructed must never happen.
1003          */
1004         BUG_ON(gpu_speedo_id >= ARRAY_SIZE(gpu_max_freq));
1005         for (ret = 0, i = 0; i < ARRAY_SIZE(gpu_cvb_dvfs_table); i++) {
1006                 struct gpu_cvb_dvfs *d = &gpu_cvb_dvfs_table[i];
1007                 unsigned long max_freq = gpu_max_freq[gpu_speedo_id];
1008                 if (match_dvfs_one("gpu cvb", d->speedo_id, d->process_id,
1009                                    gpu_speedo_id, gpu_process_id)) {
1010                         ret = set_gpu_dvfs_data(max_freq,
1011                                 d, &gpu_dvfs, &gpu_max_freq_index);
1012                         break;
1013                 }
1014         }
1015         BUG_ON((i == ARRAY_SIZE(gpu_cvb_dvfs_table)) || ret);
1016
1017         /* Init core thermal profile */
1018         tegra_dvfs_rail_init_vmin_thermal_profile(vdd_core_therm_trips_table,
1019                 vdd_core_therm_floors_table, &tegra12_dvfs_rail_vdd_core, NULL);
1020
1021         /* Init rail structures and dependencies */
1022         tegra_dvfs_init_rails(tegra12_dvfs_rails,
1023                 ARRAY_SIZE(tegra12_dvfs_rails));
1024
1025         /* Search core dvfs table for speedo/process matching entries and
1026            initialize dvfs-ed clocks */
1027         if (!tegra_platform_is_linsim()) {
1028                 INIT_CORE_DVFS_TABLE(core_dvfs_table,
1029                                      ARRAY_SIZE(core_dvfs_table));
1030                 INIT_CORE_DVFS_TABLE(sdmmc_dvfs_table,
1031                                      ARRAY_SIZE(sdmmc_dvfs_table));
1032                 INIT_CORE_DVFS_TABLE(disp_dvfs_table,
1033                                      ARRAY_SIZE(disp_dvfs_table));
1034         }
1035
1036         /* Initialize matching gpu dvfs entry already found when nominal
1037            voltage was determined */
1038         init_dvfs_one(&gpu_dvfs, gpu_max_freq_index);
1039
1040         /* Initialize matching cpu dvfs entry already found when nominal
1041            voltage was determined */
1042         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
1043
1044         /* Finally disable dvfs on rails if necessary */
1045         if (tegra_dvfs_core_disabled)
1046                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
1047         if (tegra_dvfs_cpu_disabled)
1048                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
1049         if (tegra_dvfs_gpu_disabled)
1050                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
1051
1052         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
1053                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
1054                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
1055         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
1056                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
1057                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
1058         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
1059                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
1060                 tegra_dvfs_gpu_disabled ? "disabled" : "enabled");
1061 }
1062
1063 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
1064 {
1065         return 0;
1066 }
1067
1068 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
1069 {
1070         return 0;
1071 }
1072
1073 /* Core voltage and bus cap object and tables */
1074 static struct kobject *cap_kobj;
1075 static struct kobject *gpu_kobj;
1076
1077 static struct core_dvfs_cap_table tegra12_core_cap_table[] = {
1078 #ifdef CONFIG_TEGRA_DUAL_CBUS
1079         { .cap_name = "cap.c2bus" },
1080         { .cap_name = "cap.c3bus" },
1081 #else
1082         { .cap_name = "cap.cbus" },
1083 #endif
1084         { .cap_name = "cap.sclk" },
1085         { .cap_name = "cap.emc" },
1086         { .cap_name = "cap.host1x" },
1087 };
1088
1089 static struct core_bus_limit_table tegra12_gpu_cap_syfs = {
1090         .limit_clk_name = "cap.profile.gbus",
1091         .refcnt_attr = {.attr = {.name = "gpu_cap_state", .mode = 0644} },
1092         .level_attr  = {.attr = {.name = "gpu_cap_rate", .mode = 0644} },
1093         .pm_qos_class = PM_QOS_GPU_FREQ_MAX,
1094 };
1095
1096 static struct core_bus_limit_table tegra12_gpu_floor_sysfs = {
1097         .limit_clk_name = "floor.profile.gbus",
1098         .refcnt_attr = {.attr = {.name = "gpu_floor_state", .mode = 0644} },
1099         .level_attr  = {.attr = {.name = "gpu_floor_rate", .mode = 0644} },
1100         .pm_qos_class = PM_QOS_GPU_FREQ_MIN,
1101 };
1102
1103 static struct core_bus_rates_table tegra12_gpu_rates_sysfs = {
1104         .bus_clk_name = "gbus",
1105         .rate_attr = {.attr = {.name = "gpu_rate", .mode = 0444} },
1106         .available_rates_attr = {
1107                 .attr = {.name = "gpu_available_rates", .mode = 0444} },
1108 };
1109
1110 static int __init tegra12_dvfs_init_core_cap(void)
1111 {
1112         int ret;
1113
1114         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
1115         if (!cap_kobj) {
1116                 pr_err("tegra12_dvfs: failed to create sysfs cap object\n");
1117                 return 0;
1118         }
1119
1120         ret = tegra_init_core_cap(
1121                 tegra12_core_cap_table, ARRAY_SIZE(tegra12_core_cap_table),
1122                 core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
1123
1124         if (ret) {
1125                 pr_err("tegra12_dvfs: failed to init core cap interface (%d)\n",
1126                        ret);
1127                 kobject_del(cap_kobj);
1128                 return 0;
1129         }
1130         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
1131
1132         gpu_kobj = kobject_create_and_add("tegra_gpu", kernel_kobj);
1133         if (!gpu_kobj) {
1134                 pr_err("tegra12_dvfs: failed to create sysfs gpu object\n");
1135                 return 0;
1136         }
1137
1138         ret = tegra_init_shared_bus_cap(&tegra12_gpu_cap_syfs,
1139                                         1, gpu_kobj);
1140         if (ret) {
1141                 pr_err("tegra12_dvfs: failed to init gpu cap interface (%d)\n",
1142                        ret);
1143                 kobject_del(gpu_kobj);
1144                 return 0;
1145         }
1146
1147         ret = tegra_init_shared_bus_floor(&tegra12_gpu_floor_sysfs,
1148                                           1, gpu_kobj);
1149         if (ret) {
1150                 pr_err("tegra12_dvfs: failed to init gpu floor interface (%d)\n",
1151                        ret);
1152                 kobject_del(gpu_kobj);
1153                 return 0;
1154         }
1155
1156         ret = tegra_init_sysfs_shared_bus_rate(&tegra12_gpu_rates_sysfs,
1157                                                1, gpu_kobj);
1158         if (ret) {
1159                 pr_err("tegra12_dvfs: failed to init gpu rates interface (%d)\n",
1160                        ret);
1161                 kobject_del(gpu_kobj);
1162                 return 0;
1163         }
1164         pr_info("tegra dvfs: tegra sysfs gpu interface is initialized\n");
1165
1166         return 0;
1167 }
1168 late_initcall(tegra12_dvfs_init_core_cap);