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