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