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