ARM: Tegra12: Clocks: Update clocks frequency for display block
[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
25 #include "clock.h"
26 #include "dvfs.h"
27 #include "fuse.h"
28 #include "board.h"
29 #include "tegra_cl_dvfs.h"
30 #include "tegra_core_sysfs_limits.h"
31
32 static bool tegra_dvfs_cpu_disabled;
33 static bool tegra_dvfs_core_disabled;
34 static bool tegra_dvfs_gpu_disabled;
35
36 #define KHZ 1000
37 #define MHZ 1000000
38
39 /* FIXME: need tegra12 step */
40 #define VDD_SAFE_STEP                   100
41
42 static int vdd_core_therm_trips_table[MAX_THERMAL_LIMITS] = { 20, };
43 static int vdd_core_therm_floors_table[MAX_THERMAL_LIMITS] = { 950, };
44
45 static struct tegra_cooling_device cpu_cdev = {
46         .cdev_type = "cpu_cold",
47 };
48
49 static struct tegra_cooling_device core_cdev = {
50         .cdev_type = "core_cold",
51 };
52
53 static struct dvfs_rail tegra12_dvfs_rail_vdd_cpu = {
54         .reg_id = "vdd_cpu",
55         .max_millivolts = 1400,
56         .min_millivolts = 800,
57         .step = VDD_SAFE_STEP,
58         .jmp_to_zero = true,
59         .vmin_cdev = &cpu_cdev,
60         .alignment = {
61                 .step_uv = 10000, /* 10mV */
62         },
63         .stats = {
64                 .bin_uV = 10000, /* 10mV */
65         }
66 };
67
68 static struct dvfs_rail tegra12_dvfs_rail_vdd_core = {
69         .reg_id = "vdd_core",
70         .max_millivolts = 1400,
71         .min_millivolts = 800,
72         .step = VDD_SAFE_STEP,
73         .vmin_cdev = &core_cdev,
74 };
75
76 /* TBD: fill in actual hw number */
77 static struct dvfs_rail tegra12_dvfs_rail_vdd_gpu = {
78         .reg_id = "vdd_gpu",
79         .max_millivolts = 1350,
80         .min_millivolts = 700,
81         .step = VDD_SAFE_STEP,
82         .alignment = {
83                 .step_uv = 10000, /* 10mV */
84         },
85         .stats = {
86                 .bin_uV = 10000, /* 10mV */
87         }
88 };
89
90 static struct dvfs_rail *tegra12_dvfs_rails[] = {
91         &tegra12_dvfs_rail_vdd_cpu,
92         &tegra12_dvfs_rail_vdd_core,
93         &tegra12_dvfs_rail_vdd_gpu,
94 };
95
96 void __init tegra12x_vdd_cpu_align(int step_uv, int offset_uv)
97 {
98         tegra12_dvfs_rail_vdd_cpu.alignment.step_uv = step_uv;
99         tegra12_dvfs_rail_vdd_cpu.alignment.offset_uv = offset_uv;
100 }
101
102 /* CPU DVFS tables */
103 static struct cpu_cvb_dvfs cpu_cvb_dvfs_table[] = {
104         {
105                 .speedo_id = 0,
106                 .process_id = 0,
107                 .dfll_tune_data  = {
108                         .tune0          = 0x00f0409f,
109                         .tune0_high_mv  = 0x00f0409f,
110                         .tune1          = 0x000000a0,
111                         .droop_rate_min = 1000000,
112                         .min_millivolts = 800,
113                 },
114                 .max_mv = 1260,
115                 .freqs_mult = KHZ,
116                 .speedo_scale = 100,
117                 .voltage_scale = 1000,
118                 .cvb_table = {
119                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
120                         {408000 , {2244479,  -117955,  2292}, { 960000,  0,  0}},
121                         {510000 , {2279779,  -119575,  2292}, { 960000,  0,  0}},
122                         {612000 , {2317504,  -121185,  2292}, { 960000,  0,  0}},
123                         {714000 , {2357653,  -122795,  2292}, { 972000,  0,  0}},
124                         {816000 , {2400228,  -124415,  2292}, { 984000,  0,  0}},
125                         {918000 , {2445228,  -126025,  2292}, { 996000,  0,  0}},
126                         {1020000, {2492653,  -127635,  2292}, { 1020000, 0,  0}},
127                         {1122000, {2542502,  -129255,  2292}, { 1032000, 0,  0}},
128                         {1224000, {2594777,  -130865,  2292}, { 1056000, 0,  0}},
129                         {1326000, {2649477,  -132475,  2292}, { 1092000, 0,  0}},
130                         {1428000, {2706601,  -134095,  2292}, { 1116000, 0,  0}},
131                         {1530000, {2766150,  -135705,  2292}, { 1152000, 0,  0}},
132                         {1632000, {2828125,  -137315,  2292}, { 1188000, 0,  0}},
133                         {1734000, {2892524,  -138935,  2292}, { 1224000, 0,  0}},
134                         {1836000, {2959348,  -140545,  2292}, { 1260000, 0,  0}},
135                         {1913000, {3028598,  -142155,  2292}, { 1308000, 0,  0}},
136                         {2015000, {3100272,  -143775,  2292}, { 1356000, 0,  0}},
137                         {2117000, {3174371,  -145385,  2292}, { 1404000, 0,  0}},
138                         {      0, {      0,        0,     0}, {       0, 0,  0}},
139                 },
140                 .therm_trips_table = { 20, },
141                 .therm_floors_table = { 1000, },
142         },
143         {
144                 .speedo_id = 0,
145                 .process_id = 1,
146                 .dfll_tune_data  = {
147                         .tune0          = 0x00f0409f,
148                         .tune0_high_mv  = 0x00f0409f,
149                         .tune1          = 0x000000a0,
150                         .droop_rate_min = 1000000,
151                         .min_millivolts = 800,
152                 },
153                 .max_mv = 1260,
154                 .freqs_mult = KHZ,
155                 .speedo_scale = 100,
156                 .voltage_scale = 1000,
157                 .cvb_table = {
158                         /*f       dfll: c0,     c1,   c2  pll:  c0,   c1,    c2 */
159                         {408000 , {2244479,  -117955,  2292}, { 912000  , 0,    0}},
160                         {510000 , {2279779,  -119575,  2292}, { 912000  , 0,    0}},
161                         {612000 , {2317504,  -121185,  2292}, { 924000  , 0,    0}},
162                         {714000 , {2357653,  -122795,  2292}, { 924000  , 0,    0}},
163                         {816000 , {2400228,  -124415,  2292}, { 936000  , 0,    0}},
164                         {918000 , {2445228,  -126025,  2292}, { 948000  , 0,    0}},
165                         {1020000, {2492653,  -127635,  2292}, { 960000  , 0,    0}},
166                         {1122000, {2542502,  -129255,  2292}, { 972000  , 0,    0}},
167                         {1224000, {2594777,  -130865,  2292}, { 996000  , 0,    0}},
168                         {1326000, {2649477,  -132475,  2292}, { 1020000 , 0,    0}},
169                         {1428000, {2706601,  -134095,  2292}, { 1044000 , 0,    0}},
170                         {1530000, {2766150,  -135705,  2292}, { 1068000 , 0,    0}},
171                         {1632000, {2828125,  -137315,  2292}, { 1104000 , 0,    0}},
172                         {1734000, {2892524,  -138935,  2292}, { 1140000 , 0,    0}},
173                         {1836000, {2959348,  -140545,  2292}, { 1176000 , 0,    0}},
174                         {1913000, {3028598,  -142155,  2292}, { 1224000 , 0,    0}},
175                         {2015000, {3100272,  -143775,  2292}, { 1260000 , 0,    0}},
176                         {2117000, {3174371,  -145385,  2292}, { 1308000 , 0,    0}},
177                         {2219000, {3250895,  -146995,  2292}, { 1356000 , 0,    0}},
178                         {2321000, {3329844,  -148615,  2292}, { 1404000 , 0,    0}},
179                         {      0, {      0,        0,     0}, {       0,  0,    0}},
180                 },
181                 .therm_trips_table = { 20, },
182                 .therm_floors_table = { 1000, },
183         },
184 };
185
186 static int cpu_millivolts[MAX_DVFS_FREQS];
187 static int cpu_dfll_millivolts[MAX_DVFS_FREQS];
188
189 static struct dvfs cpu_dvfs = {
190         .clk_name       = "cpu_g",
191         .millivolts     = cpu_millivolts,
192         .dfll_millivolts = cpu_dfll_millivolts,
193         .auto_dvfs      = true,
194         .dvfs_rail      = &tegra12_dvfs_rail_vdd_cpu,
195 };
196
197 /* Core DVFS tables */
198 /* FIXME: real data */
199 static const int core_millivolts[MAX_DVFS_FREQS] = {
200         810, 860, 900, 1000, 1100};
201
202 #define CORE_DVFS(_clk_name, _speedo_id, _process_id, _auto, _mult, _freqs...) \
203         {                                                       \
204                 .clk_name       = _clk_name,                    \
205                 .speedo_id      = _speedo_id,                   \
206                 .process_id     = _process_id,                  \
207                 .freqs          = {_freqs},                     \
208                 .freqs_mult     = _mult,                        \
209                 .millivolts     = core_millivolts,              \
210                 .auto_dvfs      = _auto,                        \
211                 .dvfs_rail      = &tegra12_dvfs_rail_vdd_core,  \
212         }
213
214 static struct dvfs core_dvfs_table[] = {
215         /* Core voltages (mV):                   810,    860,    900,    1000,    1100*/
216         /* Clock limits for internal blocks, PLLs */
217         CORE_DVFS("emc",    -1, -1, 1, KHZ,   264000, 348000, 384000, 528000,  924000),
218
219         CORE_DVFS("cpu_lp", -1, -1, 1, KHZ,   144000, 252000, 288000, 444000,  624000),
220
221         CORE_DVFS("sbus",   -1, -1, 1, KHZ,    81600, 102000, 136000, 204000,  204000),
222
223         CORE_DVFS("vic03",  -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
224         CORE_DVFS("tsec",   -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
225
226         CORE_DVFS("msenc",  -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
227         CORE_DVFS("se",     -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
228         CORE_DVFS("vde",    -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
229
230         CORE_DVFS("host1x", -1, -1, 1, KHZ,    81600, 102000, 136000, 163000,  204000),
231
232         CORE_DVFS("vi",     -1, -1, 1, KHZ,   120000, 156000, 182000, 312000,  444000),
233         CORE_DVFS("isp",    -1, -1, 1, KHZ,   120000, 156000, 182000, 312000,  444000),
234
235 #ifdef CONFIG_TEGRA_DUAL_CBUS
236         CORE_DVFS("c2bus",  -1, -1, 1, KHZ,    72000,  84000, 102000, 180000,  252000),
237         CORE_DVFS("c3bus",  -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
238 #else
239         CORE_DVFS("cbus",   -1, -1, 1, KHZ,   120000, 144000, 168000, 216000,  372000),
240 #endif
241         CORE_DVFS("c4bus",  -1, -1, 1, KHZ,   120000, 156000, 182000, 312000,  444000),
242
243         CORE_DVFS("pll_m",  -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
244         CORE_DVFS("pll_c",  -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
245         CORE_DVFS("pll_c2", -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
246         CORE_DVFS("pll_c3", -1, -1, 1, KHZ,   800000, 800000, 1066000, 1066000, 1066000),
247
248         /* Core voltages (mV):                   810,    860,    900,    990,    1080*/
249         /* Clock limits for I/O peripherals */
250         CORE_DVFS("sbc1",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
251         CORE_DVFS("sbc2",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
252         CORE_DVFS("sbc3",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
253         CORE_DVFS("sbc4",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
254         CORE_DVFS("sbc5",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
255         CORE_DVFS("sbc6",   -1, -1, 1, KHZ,    24000,  24000,  48000,  48000,   48000),
256
257         CORE_DVFS("sdmmc1", -1, -1, 1, KHZ,   102000, 102000, 163200, 163200,  163200),
258         CORE_DVFS("sdmmc3", -1, -1, 1, KHZ,   102000, 102000, 163200, 163200,  163200),
259         CORE_DVFS("sdmmc4", -1, -1, 1, KHZ,   102000, 102000, 178200, 178200,  178200),
260
261         CORE_DVFS("hdmi",   -1, -1, 1, KHZ,    99000, 118800, 148500, 198000,  198000),
262
263         /*
264          * The clock rate for the display controllers that determines the
265          * necessary core voltage depends on a divider that is internal
266          * to the display block.  Disable auto-dvfs on the display clocks,
267          * and let the display driver call tegra_dvfs_set_rate manually
268          */
269         CORE_DVFS("disp1",  -1, -1, 0, KHZ,   108000, 120000, 144000, 297000,  474000),
270         CORE_DVFS("disp2",  -1, -1, 0, KHZ,   108000, 120000, 144000, 297000,  474000),
271
272         /* xusb clocks */
273         CORE_DVFS("xusb_falcon_src", -1, -1, 1, KHZ,  204000, 204000, 204000, 336000, 336000),
274         CORE_DVFS("xusb_host_src",   -1, -1, 1, KHZ,   58300,  58300,  58300, 112000, 112000),
275         CORE_DVFS("xusb_dev_src",    -1, -1, 1, KHZ,   58300,  58300,  58300, 112000, 112000),
276         CORE_DVFS("xusb_ss_src",     -1, -1, 1, KHZ,   60000,  60000,  60000, 120000, 120000),
277         CORE_DVFS("xusb_fs_src",     -1, -1, 1, KHZ,       0,  48000,  48000,  48000,  48000),
278         CORE_DVFS("xusb_hs_src",     -1, -1, 1, KHZ,       0,  60000,  60000,  60000,  60000),
279 };
280
281 /* TBD: fill in actual hw numbers */
282 static struct gpu_cvb_dvfs gpu_cvb_dvfs_table[] = {
283         {
284                 .speedo_id =  0,
285                 .process_id = -1,
286                 .max_mv = 1100,
287                 .min_mv = 800,
288                 .freqs_mult = KHZ,
289                 .speedo_scale = 100,
290                 .voltage_scale = 1000,
291                 .cvb_table = {
292                         /*f        dfll  pll:   c0,     c1,   c2 */
293                         {  204000, {  }, {  810000,      0,   0}, },
294                         {  264000, {  }, {  860000,      0,   0}, },
295                         {  351000, {  }, {  900000,      0,   0}, },
296                         {  492000, {  }, {  990000,      0,   0}, },
297                         {  624000, {  }, { 1080000,      0,   0}, },
298                         {       0, {  }, {       0,      0,   0}, },
299                 },
300         },
301 };
302
303 static int gpu_millivolts[MAX_DVFS_FREQS];
304 static struct dvfs gpu_dvfs = {
305         .clk_name       = "gbus",
306         .millivolts     = gpu_millivolts,
307         .auto_dvfs      = true,
308         .dvfs_rail      = &tegra12_dvfs_rail_vdd_gpu,
309 };
310
311 int read_gpu_dvfs_table(int **millivolts, unsigned long **freqs)
312 {
313         *millivolts = gpu_dvfs.millivolts;
314         *freqs = gpu_dvfs.freqs;
315
316         return 0;
317 }
318 EXPORT_SYMBOL(read_gpu_dvfs_table);
319
320 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
321 {
322         int ret;
323
324         ret = param_set_bool(arg, kp);
325         if (ret)
326                 return ret;
327
328         if (tegra_dvfs_core_disabled)
329                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
330         else
331                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_core);
332
333         return 0;
334 }
335
336 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
337 {
338         int ret;
339
340         ret = param_set_bool(arg, kp);
341         if (ret)
342                 return ret;
343
344         if (tegra_dvfs_cpu_disabled)
345                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
346         else
347                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_cpu);
348
349         return 0;
350 }
351
352 int tegra_dvfs_disable_gpu_set(const char *arg, const struct kernel_param *kp)
353 {
354         int ret;
355
356         ret = param_set_bool(arg, kp);
357         if (ret)
358                 return ret;
359
360         if (tegra_dvfs_gpu_disabled)
361                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
362         else
363                 tegra_dvfs_rail_enable(&tegra12_dvfs_rail_vdd_gpu);
364
365         return 0;
366 }
367
368 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
369 {
370         return param_get_bool(buffer, kp);
371 }
372
373 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
374         .set = tegra_dvfs_disable_core_set,
375         .get = tegra_dvfs_disable_get,
376 };
377
378 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
379         .set = tegra_dvfs_disable_cpu_set,
380         .get = tegra_dvfs_disable_get,
381 };
382
383 static struct kernel_param_ops tegra_dvfs_disable_gpu_ops = {
384         .set = tegra_dvfs_disable_gpu_set,
385         .get = tegra_dvfs_disable_get,
386 };
387
388 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
389         &tegra_dvfs_core_disabled, 0644);
390 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
391         &tegra_dvfs_cpu_disabled, 0644);
392 module_param_cb(disable_gpu, &tegra_dvfs_disable_gpu_ops,
393         &tegra_dvfs_gpu_disabled, 0644);
394
395 /*
396  * Install rail thermal profile provided:
397  * - voltage floors are descending with temperature increasing
398  * - and the lowest floor is above rail minimum voltage in pll and
399  *   in dfll mode (if applicable)
400  */
401 static void __init init_rail_thermal_profile(
402         int *therm_trips_table, int *therm_floors_table,
403         struct dvfs_rail *rail, struct dvfs_dfll_data *d)
404 {
405         int i, min_mv;
406
407         for (i = 0; i < MAX_THERMAL_LIMITS - 1; i++) {
408                 if (!therm_floors_table[i+1])
409                         break;
410
411                 if ((therm_trips_table[i] >= therm_trips_table[i+1]) ||
412                     (therm_floors_table[i] < therm_floors_table[i+1])) {
413                         WARN(1, "%s: invalid thermal floors\n", rail->reg_id);
414                         return;
415                 }
416         }
417
418         min_mv = max(rail->min_millivolts, d ? d->min_millivolts : 0);
419         if (therm_floors_table[i] < min_mv) {
420                 WARN(1, "%s: thermal floor below Vmin\n", rail->reg_id);
421                 return;
422         }
423
424         /* Install validated thermal floors */
425         rail->therm_mv_floors = therm_floors_table;
426         rail->therm_mv_floors_num = i + 1;
427
428         /* Setup trip-points, use the same trips in dfll mode (if applicable) */
429         if (rail->vmin_cdev) {
430                 rail->vmin_cdev->trip_temperatures_num = i + 1;
431                 rail->vmin_cdev->trip_temperatures = therm_trips_table;
432         }
433 }
434
435 static bool __init can_update_max_rate(struct clk *c, struct dvfs *d)
436 {
437         /* Don't update manual dvfs clocks */
438         if (!d->auto_dvfs)
439                 return false;
440
441         /*
442          * Don't update EMC shared bus, since EMC dvfs is board dependent: max
443          * rate and EMC scaling frequencies are determined by tegra BCT (flashed
444          * together with the image) and board specific EMC DFS table; we will
445          * check the scaling ladder against nominal core voltage when the table
446          * is loaded (and if on particular board the table is not loaded, EMC
447          * scaling is disabled).
448          */
449         if (c->ops->shared_bus_update && (c->flags & PERIPH_EMC_ENB))
450                 return false;
451
452         /*
453          * Don't update shared cbus, and don't propagate common cbus dvfs
454          * limit down to shared users, but set maximum rate for each user
455          * equal to the respective client limit.
456          */
457         if (c->ops->shared_bus_update && (c->flags & PERIPH_ON_CBUS)) {
458                 struct clk *user;
459                 unsigned long rate;
460
461                 list_for_each_entry(
462                         user, &c->shared_bus_list, u.shared_bus_user.node) {
463                         if (user->u.shared_bus_user.client) {
464                                 rate = user->u.shared_bus_user.client->max_rate;
465                                 user->max_rate = rate;
466                                 user->u.shared_bus_user.rate = rate;
467                         }
468                 }
469                 return false;
470         }
471
472         /* Other, than EMC and cbus, auto-dvfs clocks can be updated */
473         return true;
474 }
475
476 static void __init init_dvfs_one(struct dvfs *d, int max_freq_index)
477 {
478         int ret;
479         struct clk *c = tegra_get_clock_by_name(d->clk_name);
480
481         if (!c) {
482                 pr_debug("tegra12_dvfs: no clock found for %s\n",
483                         d->clk_name);
484                 return;
485         }
486
487         /* Update max rate for auto-dvfs clocks, with shared bus exceptions */
488         if (can_update_max_rate(c, d)) {
489                 BUG_ON(!d->freqs[max_freq_index]);
490                 tegra_init_max_rate(
491                         c, d->freqs[max_freq_index] * d->freqs_mult);
492         }
493         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
494
495         ret = tegra_enable_dvfs_on_clk(c, d);
496         if (ret)
497                 pr_err("tegra12_dvfs: failed to enable dvfs on %s\n", c->name);
498 }
499
500 static bool __init match_dvfs_one(const char *name,
501         int dvfs_speedo_id, int dvfs_process_id,
502         int speedo_id, int process_id)
503 {
504         if ((dvfs_process_id != -1 && dvfs_process_id != process_id) ||
505                 (dvfs_speedo_id != -1 && dvfs_speedo_id != speedo_id)) {
506                 pr_debug("tegra12_dvfs: rejected %s speedo %d, process %d\n",
507                          name, dvfs_speedo_id, dvfs_process_id);
508                 return false;
509         }
510         return true;
511 }
512
513 /* cvb_mv = ((c2 * speedo / s_scale + c1) * speedo / s_scale + c0) / v_scale */
514 static inline int get_cvb_voltage(int speedo, int s_scale,
515                                   struct cvb_dvfs_parameters *cvb)
516 {
517         /* apply only speedo scale: output mv = cvb_mv * v_scale */
518         int mv;
519         mv = DIV_ROUND_CLOSEST(cvb->c2 * speedo, s_scale);
520         mv = DIV_ROUND_CLOSEST((mv + cvb->c1) * speedo, s_scale) + cvb->c0;
521         return mv;
522 }
523
524 static int round_cvb_voltage(int mv, int v_scale, struct rail_alignment *align)
525 {
526         /* combined: apply voltage scale and round to cvb alignment step */
527         int uv;
528         int step = (align->step_uv ? : 1000) * v_scale;
529         int offset = align->offset_uv * v_scale;
530
531         uv = max(mv * 1000, offset) - offset;
532         uv = DIV_ROUND_UP(uv, step) * align->step_uv + align->offset_uv;
533         return uv / 1000;
534 }
535
536 static int __init set_cpu_dvfs_data(
537         struct cpu_cvb_dvfs *d, struct dvfs *cpu_dvfs, int *max_freq_index)
538 {
539         int i, j, mv, dfll_mv, min_dfll_mv;
540         unsigned long fmax_at_vmin = 0;
541         unsigned long fmax_pll_mode = 0;
542         unsigned long fmin_use_dfll = 0;
543         struct cvb_dvfs_table *table = NULL;
544         int speedo = tegra_cpu_speedo_value();
545         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_cpu.alignment;
546
547         min_dfll_mv = d->dfll_tune_data.min_millivolts;
548         min_dfll_mv =  round_cvb_voltage(min_dfll_mv * 1000, 1000, align);
549         d->max_mv = round_cvb_voltage(d->max_mv * 1000, 1000, align);
550         BUG_ON(min_dfll_mv < tegra12_dvfs_rail_vdd_cpu.min_millivolts);
551
552         /*
553          * Use CVB table to fill in CPU dvfs frequencies and voltages. Each
554          * CVB entry specifies CPU frequency and CVB coefficients to calculate
555          * the respective voltage when either DFLL or PLL is used as CPU clock
556          * source.
557          *
558          * Minimum voltage limit is applied only to DFLL source. For PLL source
559          * voltage can go as low as table specifies. Maximum voltage limit is
560          * applied to both sources, but differently: directly clip voltage for
561          * DFLL, and limit maximum frequency for PLL.
562          */
563         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
564                 table = &d->cvb_table[i];
565                 if (!table->freq)
566                         break;
567
568                 dfll_mv = get_cvb_voltage(
569                         speedo, d->speedo_scale, &table->cvb_dfll_param);
570                 dfll_mv = round_cvb_voltage(dfll_mv, d->voltage_scale, align);
571
572                 mv = get_cvb_voltage(
573                         speedo, d->speedo_scale, &table->cvb_pll_param);
574                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
575
576                 /*
577                  * Check maximum frequency at minimum voltage for dfll source;
578                  * round down unless all table entries are above Vmin, then use
579                  * the 1st entry as is.
580                  */
581                 dfll_mv = max(dfll_mv, min_dfll_mv);
582                 if (dfll_mv > min_dfll_mv) {
583                         if (!j)
584                                 fmax_at_vmin = table->freq;
585                         if (!fmax_at_vmin)
586                                 fmax_at_vmin = cpu_dvfs->freqs[j - 1];
587                 }
588
589                 /* Clip maximum frequency at maximum voltage for pll source */
590                 if (mv > d->max_mv) {
591                         if (!j)
592                                 break;  /* 1st entry already above Vmax */
593                         if (!fmax_pll_mode)
594                                 fmax_pll_mode = cpu_dvfs->freqs[j - 1];
595                 }
596
597                 /* Minimum rate with pll source voltage above dfll Vmin */
598                 if ((mv >= min_dfll_mv) && (!fmin_use_dfll))
599                         fmin_use_dfll = table->freq;
600
601                 /* fill in dvfs tables */
602                 cpu_dvfs->freqs[j] = table->freq;
603                 cpu_dfll_millivolts[j] = min(dfll_mv, d->max_mv);
604                 cpu_millivolts[j] = mv;
605                 j++;
606
607                 /*
608                  * "Round-up" frequency list cut-off (keep first entry that
609                  *  exceeds max voltage - the voltage limit will be enforced
610                  *  anyway, so when requested this frequency dfll will settle
611                  *  at whatever high frequency it can on the particular chip)
612                  */
613                 if (dfll_mv > d->max_mv)
614                         break;
615         }
616
617         /* Table must not be empty, must have at least one entry above Vmin */
618         if (!i || !j || !fmax_at_vmin) {
619                 pr_err("tegra12_dvfs: invalid cpu dvfs table\n");
620                 return -ENOENT;
621         }
622
623         /* In the dfll operating range dfll voltage at any rate should be
624            better (below) than pll voltage */
625         if (!fmin_use_dfll || (fmin_use_dfll > fmax_at_vmin)) {
626                 WARN(1, "tegra12_dvfs: pll voltage is below dfll in the dfll"
627                         " operating range\n");
628                 fmin_use_dfll = fmax_at_vmin;
629         }
630
631         /* dvfs tables are successfully populated - fill in the rest */
632         cpu_dvfs->speedo_id = d->speedo_id;
633         cpu_dvfs->process_id = d->process_id;
634         cpu_dvfs->freqs_mult = d->freqs_mult;
635         cpu_dvfs->dvfs_rail->nominal_millivolts = min(d->max_mv,
636                 max(cpu_millivolts[j - 1], cpu_dfll_millivolts[j - 1]));
637         *max_freq_index = j - 1;
638
639         cpu_dvfs->dfll_data = d->dfll_tune_data;
640         cpu_dvfs->dfll_data.max_rate_boost = fmax_pll_mode ?
641                 (cpu_dvfs->freqs[j - 1] - fmax_pll_mode) * d->freqs_mult : 0;
642         cpu_dvfs->dfll_data.out_rate_min = fmax_at_vmin * d->freqs_mult;
643         cpu_dvfs->dfll_data.use_dfll_rate_min = fmin_use_dfll * d->freqs_mult;
644         cpu_dvfs->dfll_data.min_millivolts = min_dfll_mv;
645
646         return 0;
647 }
648
649 static int __init set_gpu_dvfs_data(
650         struct gpu_cvb_dvfs *d, struct dvfs *gpu_dvfs, int *max_freq_index)
651 {
652         int i, j, mv;
653         struct cvb_dvfs_table *table = NULL;
654         int speedo = tegra_gpu_speedo_value();
655         struct rail_alignment *align = &tegra12_dvfs_rail_vdd_gpu.alignment;
656
657         d->max_mv = round_cvb_voltage(d->max_mv * 1000, 1000, align);
658         d->min_mv = round_cvb_voltage(d->min_mv * 1000, 1000, align);
659         BUG_ON(d->min_mv < tegra12_dvfs_rail_vdd_gpu.min_millivolts);
660
661         /*
662          * Use CVB table to fill in gpu dvfs frequencies and voltages. Each
663          * CVB entry specifies gpu frequency and CVB coefficients to calculate
664          * the respective voltage.
665          */
666         for (i = 0, j = 0; i < MAX_DVFS_FREQS; i++) {
667                 table = &d->cvb_table[i];
668                 if (!table->freq)
669                         break;
670
671                 mv = get_cvb_voltage(
672                         speedo, d->speedo_scale, &table->cvb_pll_param);
673                 mv = round_cvb_voltage(mv, d->voltage_scale, align);
674
675                 if (mv > d->max_mv)
676                         break;
677
678                 /* fill in gpu dvfs tables */
679                 mv = max(mv, d->min_mv);
680                 if (!j || (mv > gpu_millivolts[j - 1])) {
681                         gpu_millivolts[j] = mv;
682                         gpu_dvfs->freqs[j] = table->freq;
683                         j++;
684                 } else {
685                         gpu_dvfs->freqs[j - 1] = table->freq;
686                 }
687         }
688         /* Table must not be empty, must have at least one entry in range */
689         if (!i || !j || (gpu_millivolts[j - 1] <
690                          tegra12_dvfs_rail_vdd_gpu.min_millivolts)) {
691                 pr_err("tegra14_dvfs: invalid gpu dvfs table\n");
692                 return -ENOENT;
693         }
694
695         /* dvfs tables are successfully populated - fill in the gpu dvfs */
696         gpu_dvfs->speedo_id = d->speedo_id;
697         gpu_dvfs->process_id = d->process_id;
698         gpu_dvfs->freqs_mult = d->freqs_mult;
699         gpu_dvfs->dvfs_rail->nominal_millivolts =
700                 min(d->max_mv, gpu_millivolts[j - 1]);
701
702         *max_freq_index = j - 1;
703         return 0;
704 }
705
706 static int __init get_core_nominal_mv_index(int speedo_id)
707 {
708         int i;
709         int mv = tegra_core_speedo_mv();
710         int core_edp_voltage = get_core_edp();
711
712         /*
713          * Start with nominal level for the chips with this speedo_id. Then,
714          * make sure core nominal voltage is below edp limit for the board
715          * (if edp limit is set).
716          */
717         if (!core_edp_voltage)
718                 core_edp_voltage = 1100;        /* default 1.1V EDP limit */
719
720         mv = min(mv, core_edp_voltage);
721
722         /* Round nominal level down to the nearest core scaling step */
723         for (i = 0; i < MAX_DVFS_FREQS; i++) {
724                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
725                         break;
726         }
727
728         if (i == 0) {
729                 pr_err("tegra12_dvfs: unable to adjust core dvfs table to"
730                        " nominal voltage %d\n", mv);
731                 return -ENOSYS;
732         }
733         return i - 1;
734 }
735
736 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
737                          bool before_clk_update, int cpu_event)
738 {
739         /* empty definition for tegra12 */
740         return 0;
741 }
742
743 void __init tegra12x_init_dvfs(void)
744 {
745         int cpu_speedo_id = tegra_cpu_speedo_id();
746         int cpu_process_id = tegra_cpu_process_id();
747         int soc_speedo_id = tegra_soc_speedo_id();
748         int core_process_id = tegra_core_process_id();
749         int gpu_speedo_id = tegra_gpu_speedo_id();
750         int gpu_process_id = tegra_gpu_process_id();
751
752         int i, ret;
753         int core_nominal_mv_index;
754         int gpu_max_freq_index = 0;
755         int cpu_max_freq_index = 0;
756
757 #ifndef CONFIG_TEGRA_CORE_DVFS
758         tegra_dvfs_core_disabled = true;
759 #endif
760 #ifndef CONFIG_TEGRA_CPU_DVFS
761         tegra_dvfs_cpu_disabled = true;
762 #endif
763 #ifndef CONFIG_TEGRA_GPU_DVFS
764         tegra_dvfs_gpu_disabled = true;
765 #endif
766 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
767         if (!tegra_platform_is_silicon()) {
768                 tegra_dvfs_core_disabled = true;
769                 tegra_dvfs_cpu_disabled = true;
770         }
771 #endif
772
773         /*
774          * Find nominal voltages for core (1st) and cpu rails before rail
775          * init. Nominal voltage index in core scaling ladder can also be
776          * used to determine max dvfs frequencies for all core clocks. In
777          * case of error disable core scaling and set index to 0, so that
778          * core clocks would not exceed rates allowed at minimum voltage.
779          */
780         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
781         if (core_nominal_mv_index < 0) {
782                 tegra12_dvfs_rail_vdd_core.disabled = true;
783                 tegra_dvfs_core_disabled = true;
784                 core_nominal_mv_index = 0;
785         }
786         tegra12_dvfs_rail_vdd_core.nominal_millivolts =
787                 core_millivolts[core_nominal_mv_index];
788
789         /*
790          * Setup cpu dvfs and dfll tables from cvb data, determine nominal
791          * voltage for cpu rail, and cpu maximum frequency. Note that entire
792          * frequency range is guaranteed only when dfll is used as cpu clock
793          * source. Reaching maximum frequency with pll as cpu clock source
794          * may not be possible within nominal voltage range (dvfs mechanism
795          * would automatically fail frequency request in this case, so that
796          * voltage limit is not violated). Error when cpu dvfs table can not
797          * be constructed must never happen.
798          */
799         for (ret = 0, i = 0; i <  ARRAY_SIZE(cpu_cvb_dvfs_table); i++) {
800                 struct cpu_cvb_dvfs *d = &cpu_cvb_dvfs_table[i];
801                 if (match_dvfs_one("cpu cvb", d->speedo_id, d->process_id,
802                                    cpu_speedo_id, cpu_process_id)) {
803                         ret = set_cpu_dvfs_data(
804                                 d, &cpu_dvfs, &cpu_max_freq_index);
805                         break;
806                 }
807         }
808         BUG_ON((i == ARRAY_SIZE(cpu_cvb_dvfs_table)) || ret);
809
810         /*
811          * Setup gpu dvfs tables from cvb data, determine nominal voltage for
812          * gpu rail, and gpu maximum frequency. Error when gpu dvfs table can
813          * not be constructed must never happen.
814          */
815         for (ret = 0, i = 0; i < ARRAY_SIZE(gpu_cvb_dvfs_table); i++) {
816                 struct gpu_cvb_dvfs *d = &gpu_cvb_dvfs_table[i];
817                 if (match_dvfs_one("gpu cvb", d->speedo_id, d->process_id,
818                                    gpu_speedo_id, gpu_process_id)) {
819                         ret = set_gpu_dvfs_data(
820                                 d, &gpu_dvfs, &gpu_max_freq_index);
821                         break;
822                 }
823         }
824         BUG_ON((i == ARRAY_SIZE(gpu_cvb_dvfs_table)) || ret);
825
826         /* Init thermal floors */
827         /* FIXME: Uncomment when proper values are available later */
828         /* init_rail_thermal_profile(cpu_cvb_dvfs_table[i].therm_trips_table,
829                 cpu_cvb_dvfs_table[i].therm_floors_table,
830                 &tegra12_dvfs_rail_vdd_cpu, &cpu_dvfs.dfll_data);
831         init_rail_thermal_profile(vdd_core_therm_trips_table,
832                 vdd_core_therm_floors_table, &tegra12_dvfs_rail_vdd_core, NULL);*/
833
834         /* Init rail structures and dependencies */
835         tegra_dvfs_init_rails(tegra12_dvfs_rails,
836                 ARRAY_SIZE(tegra12_dvfs_rails));
837
838         /* Search core dvfs table for speedo/process matching entries and
839            initialize dvfs-ed clocks */
840         if (!tegra_platform_is_linsim()) {
841                 for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
842                         struct dvfs *d = &core_dvfs_table[i];
843                         if (!match_dvfs_one(d->clk_name, d->speedo_id,
844                                 d->process_id, soc_speedo_id, core_process_id))
845                                 continue;
846                         init_dvfs_one(d, core_nominal_mv_index);
847                 }
848         }
849
850         /* Initialize matching gpu dvfs entry already found when nominal
851            voltage was determined */
852         init_dvfs_one(&gpu_dvfs, gpu_max_freq_index);
853
854         /* Initialize matching cpu dvfs entry already found when nominal
855            voltage was determined */
856         init_dvfs_one(&cpu_dvfs, cpu_max_freq_index);
857
858         /* Finally disable dvfs on rails if necessary */
859         if (tegra_dvfs_core_disabled)
860                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_core);
861         if (tegra_dvfs_cpu_disabled)
862                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_cpu);
863         if (tegra_dvfs_gpu_disabled)
864                 tegra_dvfs_rail_disable(&tegra12_dvfs_rail_vdd_gpu);
865
866         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
867                 tegra12_dvfs_rail_vdd_cpu.nominal_millivolts,
868                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
869         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
870                 tegra12_dvfs_rail_vdd_core.nominal_millivolts,
871                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
872         pr_info("tegra dvfs: VDD_GPU nominal %dmV, scaling %s\n",
873                 tegra12_dvfs_rail_vdd_gpu.nominal_millivolts,
874                 tegra_dvfs_gpu_disabled ? "disabled" : "enabled");
875 }
876
877 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
878 {
879         return 0;
880 }
881
882 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
883 {
884         return 0;
885 }
886
887 /* Core voltage and bus cap object and tables */
888 static struct kobject *cap_kobj;
889
890 static struct core_dvfs_cap_table tegra12_core_cap_table[] = {
891 #ifdef CONFIG_TEGRA_DUAL_CBUS
892         { .cap_name = "cap.c2bus" },
893         { .cap_name = "cap.c3bus" },
894 #else
895         { .cap_name = "cap.cbus" },
896 #endif
897         { .cap_name = "cap.sclk" },
898         { .cap_name = "cap.emc" },
899 };
900
901 /*
902  * Keep sys file names the same for dual and single cbus configurations to
903  * avoid changes in user space GPU capping interface.
904  */
905 static struct core_bus_limit_table tegra12_bus_cap_table[] = {
906 #ifdef CONFIG_TEGRA_DUAL_CBUS
907         { .limit_clk_name = "cap.profile.c2bus",
908           .refcnt_attr = {.attr = {.name = "cbus_cap_state", .mode = 0644} },
909           .level_attr  = {.attr = {.name = "cbus_cap_level", .mode = 0644} },
910         },
911 #else
912         { .limit_clk_name = "cap.profile.cbus",
913           .refcnt_attr = {.attr = {.name = "cbus_cap_state", .mode = 0644} },
914           .level_attr  = {.attr = {.name = "cbus_cap_level", .mode = 0644} },
915         },
916 #endif
917 };
918
919 static int __init tegra12_dvfs_init_core_cap(void)
920 {
921         int ret;
922
923         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
924         if (!cap_kobj) {
925                 pr_err("tegra12_dvfs: failed to create sysfs cap object\n");
926                 return 0;
927         }
928
929         ret = tegra_init_shared_bus_cap(
930                 tegra12_bus_cap_table, ARRAY_SIZE(tegra12_bus_cap_table),
931                 cap_kobj);
932         if (ret) {
933                 pr_err("tegra12_dvfs: failed to init bus cap interface (%d)\n",
934                        ret);
935                 kobject_del(cap_kobj);
936                 return 0;
937         }
938
939         ret = tegra_init_core_cap(
940                 tegra12_core_cap_table, ARRAY_SIZE(tegra12_core_cap_table),
941                 core_millivolts, ARRAY_SIZE(core_millivolts), cap_kobj);
942
943         if (ret) {
944                 pr_err("tegra12_dvfs: failed to init core cap interface (%d)\n",
945                        ret);
946                 kobject_del(cap_kobj);
947                 return 0;
948         }
949         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
950
951         return 0;
952 }
953 late_initcall(tegra12_dvfs_init_core_cap);