Merge commit 'main-jb-2012.08.03-B4' into t114-0806
[linux-2.6.git] / arch / arm / mach-tegra / tegra3_dvfs.c
1 /*
2  * arch/arm/mach-tegra/tegra3_dvfs.c
3  *
4  * Copyright (C) 2010-2012, 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 #include <linux/time.h>
25
26 #include "clock.h"
27 #include "dvfs.h"
28 #include "fuse.h"
29 #include "board.h"
30 #include "tegra3_emc.h"
31
32 #define CPU_MILLIVOLTS {\
33         750, 762, 775, 787, 800, 825, 837, 850, 862, 875, 887, 900, 912, 916, 925, 937, 950, 962, 975, 987, 1000, 1007, 1012, 1025, 1037, 1050, 1062, 1075, 1087, 1100, 1112, 1125, 1137, 1150, 1162, 1175, 1187, 1200, 1212, 1237};
34
35 static bool tegra_dvfs_cpu_disabled;
36 static bool tegra_dvfs_core_disabled;
37 static struct dvfs *cpu_dvfs;
38
39 static int cpu_millivolts[MAX_DVFS_FREQS] = CPU_MILLIVOLTS;
40
41 static const int cpu_millivolts_aged[MAX_DVFS_FREQS] = CPU_MILLIVOLTS;
42
43 static const unsigned int cpu_cold_offs_mhz[MAX_DVFS_FREQS] = {
44          50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50,   50};
45
46 static const int core_millivolts[MAX_DVFS_FREQS] = {
47         950, 1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350};
48
49 #define KHZ 1000
50 #define MHZ 1000000
51
52 /* VDD_CPU >= (VDD_CORE - cpu_below_core) */
53 /* VDD_CORE >= min_level(VDD_CPU), see tegra3_get_core_floor_mv() below */
54 #define VDD_CPU_BELOW_VDD_CORE          300
55 static int cpu_below_core = VDD_CPU_BELOW_VDD_CORE;
56
57 #define VDD_SAFE_STEP                   100
58
59 static struct dvfs_rail tegra3_dvfs_rail_vdd_cpu = {
60         .reg_id = "vdd_cpu",
61         .max_millivolts = 1250,
62         .min_millivolts = 725,
63         .step = VDD_SAFE_STEP,
64         .jmp_to_zero = true,
65 };
66
67 static struct dvfs_rail tegra3_dvfs_rail_vdd_core = {
68         .reg_id = "vdd_core",
69         .max_millivolts = 1350,
70         .min_millivolts = 950,
71         .step = VDD_SAFE_STEP,
72 };
73
74 static struct dvfs_rail *tegra3_dvfs_rails[] = {
75         &tegra3_dvfs_rail_vdd_cpu,
76         &tegra3_dvfs_rail_vdd_core,
77 };
78
79 static int tegra3_get_core_floor_mv(int cpu_mv)
80 {
81         if (cpu_mv < 800)
82                 return  950;
83         if (cpu_mv < 900)
84                 return 1000;
85         if (cpu_mv < 1000)
86                 return 1100;
87         if ((tegra_cpu_speedo_id() < 2) ||
88             (tegra_cpu_speedo_id() == 4) ||
89             (tegra_cpu_speedo_id() == 7) ||
90             (tegra_cpu_speedo_id() == 8))
91                 return 1200;
92         if (cpu_mv < 1100)
93                 return 1200;
94         if (cpu_mv <= 1250)
95                 return 1300;
96         BUG();
97 }
98
99 /* vdd_core must be >= min_level as a function of vdd_cpu */
100 static int tegra3_dvfs_rel_vdd_cpu_vdd_core(struct dvfs_rail *vdd_cpu,
101         struct dvfs_rail *vdd_core)
102 {
103         int core_floor = max(vdd_cpu->new_millivolts, vdd_cpu->millivolts);
104         core_floor = tegra3_get_core_floor_mv(core_floor);
105         return max(vdd_core->new_millivolts, core_floor);
106 }
107
108 /* vdd_cpu must be >= (vdd_core - cpu_below_core) */
109 static int tegra3_dvfs_rel_vdd_core_vdd_cpu(struct dvfs_rail *vdd_core,
110         struct dvfs_rail *vdd_cpu)
111 {
112         int cpu_floor;
113
114         if (vdd_cpu->new_millivolts == 0)
115                 return 0; /* If G CPU is off, core relations can be ignored */
116
117         cpu_floor = max(vdd_core->new_millivolts, vdd_core->millivolts) -
118                 cpu_below_core;
119         return max(vdd_cpu->new_millivolts, cpu_floor);
120 }
121
122 static struct dvfs_relationship tegra3_dvfs_relationships[] = {
123         {
124                 .from = &tegra3_dvfs_rail_vdd_cpu,
125                 .to = &tegra3_dvfs_rail_vdd_core,
126                 .solve = tegra3_dvfs_rel_vdd_cpu_vdd_core,
127                 .solved_at_nominal = true,
128         },
129         {
130                 .from = &tegra3_dvfs_rail_vdd_core,
131                 .to = &tegra3_dvfs_rail_vdd_cpu,
132                 .solve = tegra3_dvfs_rel_vdd_core_vdd_cpu,
133         },
134 };
135
136 #define CPU_DVFS(_clk_name, _speedo_id, _process_id, _mult, _freqs...)  \
137         {                                                               \
138                 .clk_name       = _clk_name,                            \
139                 .speedo_id      = _speedo_id,                           \
140                 .process_id     = _process_id,                          \
141                 .freqs          = {_freqs},                             \
142                 .freqs_mult     = _mult,                                \
143                 .millivolts     = cpu_millivolts,                       \
144                 .auto_dvfs      = true,                                 \
145                 .dvfs_rail      = &tegra3_dvfs_rail_vdd_cpu,            \
146         }
147
148 static struct dvfs cpu_dvfs_table[] = {
149         /* Cpu voltages (mV):         750, 762, 775, 787, 800, 825, 837, 850, 862, 875, 887,  900,  912,  916,  925,  937,  950,  962,  975,  987, 1000, 1007, 1012, 1025, 1037, 1050, 1062, 1075, 1087, 1100, 1112, 1125, 1137, 1150, 1162, 1175, 1187, 1200, 1212, 1237 */
150         CPU_DVFS("cpu_g",  0, 0, MHZ,   1,   1,   1,   1,   1,   1,   1, 684, 684, 684, 684,  817,  817,  817,  817,  817,  817,  817, 1026, 1026, 1102, 1102, 1102, 1149, 1149, 1187, 1187, 1225, 1225, 1282, 1282, 1300),
151         CPU_DVFS("cpu_g",  0, 1, MHZ,   1,   1,   1,   1,   1,   1,   1, 807, 807, 807, 807,  948,  948,  948,  948,  948,  948,  948, 1117, 1117, 1171, 1171, 1171, 1206, 1206, 1300),
152         CPU_DVFS("cpu_g",  0, 2, MHZ,   1,   1,   1,   1,   1,   1,   1, 883, 883, 883, 883, 1039, 1039, 1039, 1039, 1039, 1039, 1039, 1178, 1178, 1206, 1206, 1206, 1300),
153         CPU_DVFS("cpu_g",  0, 3, MHZ,   1,   1,   1,   1,   1,   1,   1, 931, 931, 931, 931, 1102, 1102, 1102, 1102, 1102, 1102, 1102, 1216, 1216, 1300, 1300, 1300),
154
155         CPU_DVFS("cpu_g",  1, 0, MHZ,   1,   1,   1,   1, 460, 460, 460, 550, 550, 550, 550,  680,  680,  680,  680,  680,  680,  680,  820,  820,  970,  970,  970, 1040, 1040, 1080, 1080, 1150, 1150, 1200, 1200, 1280, 1280, 1300),
156         CPU_DVFS("cpu_g",  1, 1, MHZ,   1,   1,   1,   1, 480, 480, 480, 650, 650, 650, 650,  780,  780,  780,  780,  780,  780,  780,  990,  990, 1040, 1040, 1040, 1100, 1100, 1200, 1200, 1300),
157         CPU_DVFS("cpu_g",  1, 2, MHZ,   1,   1,   1,   1, 520, 520, 520, 700, 700, 700, 700,  860,  860,  860,  860,  860,  860,  860, 1050, 1050, 1150, 1150, 1150, 1200, 1200, 1300),
158         CPU_DVFS("cpu_g",  1, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1300),
159
160         CPU_DVFS("cpu_g",  2, 1, MHZ,   1,   1,   1,   1, 480, 480, 480, 650, 650, 650, 650,  780,  780,  780,  780,  780,  780,  780,  990,  990, 1040, 1040, 1040, 1100, 1100, 1200, 1200, 1250, 1250, 1300, 1300, 1330, 1330, 1400),
161         CPU_DVFS("cpu_g",  2, 2, MHZ,   1,   1,   1,   1, 520, 520, 520, 700, 700, 700, 700,  860,  860,  860,  860,  860,  860,  860, 1050, 1050, 1150, 1150, 1150, 1200, 1200, 1280, 1280, 1300, 1300, 1350, 1350, 1400),
162         CPU_DVFS("cpu_g",  2, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1280, 1280, 1300, 1300, 1350, 1350, 1400),
163
164         CPU_DVFS("cpu_g",  3, 1, MHZ,   1,   1,   1,   1, 480, 480, 480, 650, 650, 650, 650,  780,  780,  780,  780,  780,  780,  780,  990,  990, 1040, 1040, 1040, 1100, 1100, 1200, 1200, 1250, 1250, 1300, 1300, 1330, 1330, 1400),
165         CPU_DVFS("cpu_g",  3, 2, MHZ,   1,   1,   1,   1, 520, 520, 520, 700, 700, 700, 700,  860,  860,  860,  860,  860,  860,  860, 1050, 1050, 1150, 1150, 1150, 1200, 1200, 1280, 1280, 1300, 1300, 1350, 1350, 1400),
166         CPU_DVFS("cpu_g",  3, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1280, 1280, 1300, 1300, 1350, 1350, 1400),
167
168         CPU_DVFS("cpu_g",  4, 0, MHZ,   1,   1,   1,   1, 460, 460, 460, 550, 550, 550, 550,  680,  680,  680,  680,  680,  680,  680,  820,  820,  970,  970,  970, 1040, 1040, 1080, 1080, 1150, 1150, 1200, 1200, 1240, 1240, 1280, 1280, 1320, 1320, 1360, 1360, 1500),
169         CPU_DVFS("cpu_g",  4, 1, MHZ,   1,   1,   1,   1, 480, 480, 480, 650, 650, 650, 650,  780,  780,  780,  780,  780,  780,  780,  990,  990, 1040, 1040, 1040, 1100, 1100, 1200, 1200, 1250, 1250, 1300, 1300, 1330, 1330, 1360, 1360, 1400, 1400, 1500),
170         CPU_DVFS("cpu_g",  4, 2, MHZ,   1,   1,   1,   1, 520, 520, 520, 700, 700, 700, 700,  860,  860,  860,  860,  860,  860,  860, 1050, 1050, 1150, 1150, 1150, 1200, 1200, 1280, 1280, 1300, 1300, 1340, 1340, 1380, 1380, 1500),
171         CPU_DVFS("cpu_g",  4, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1280, 1280, 1330, 1330, 1370, 1370, 1400, 1400, 1500),
172
173         CPU_DVFS("cpu_g",  5, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1280, 1280, 1330, 1330, 1370, 1370, 1400, 1400, 1470, 1470, 1500, 1500, 1500, 1500, 1540, 1540, 1700),
174         CPU_DVFS("cpu_g",  5, 4, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  940,  940,  940,  940,  940,  940,  940, 1160, 1160, 1240, 1240, 1240, 1280, 1280, 1360, 1360, 1390, 1390, 1470, 1470, 1500, 1500, 1520, 1520, 1520, 1520, 1590, 1700),
175
176         CPU_DVFS("cpu_g",  6, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1280, 1280, 1330, 1330, 1370, 1370, 1400, 1400, 1470, 1470, 1500, 1500, 1500, 1500, 1540, 1540, 1700),
177         CPU_DVFS("cpu_g",  6, 4, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  940,  940,  940,  940,  940,  940,  940, 1160, 1160, 1240, 1240, 1240, 1280, 1280, 1360, 1360, 1390, 1390, 1470, 1470, 1500, 1500, 1520, 1520, 1520, 1520, 1590, 1700),
178
179         CPU_DVFS("cpu_g",  7, 0, MHZ,   1,   1,   1,   1, 460, 460, 460, 550, 550, 550, 550,  680,  680,  680,  680,  680,  680,  680,  820,  820,  970,  970,  970, 1040, 1040, 1080, 1080, 1150, 1150, 1200, 1200, 1280, 1280, 1300),
180         CPU_DVFS("cpu_g",  7, 1, MHZ,   1,   1,   1,   1, 480, 480, 480, 650, 650, 650, 650,  780,  780,  780,  780,  780,  780,  780,  990,  990, 1040, 1040, 1040, 1100, 1100, 1200, 1200, 1300),
181         CPU_DVFS("cpu_g",  7, 2, MHZ,   1,   1,   1,   1, 520, 520, 520, 700, 700, 700, 700,  860,  860,  860,  860,  860,  860,  860, 1050, 1050, 1150, 1150, 1150, 1200, 1200, 1300),
182         CPU_DVFS("cpu_g",  7, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1300),
183         CPU_DVFS("cpu_g",  7, 4, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  940,  940,  940,  940,  940,  940,  940, 1160, 1160, 1300, 1300, 1300),
184
185         CPU_DVFS("cpu_g",  8, 0, MHZ,   1,   1,   1,   1, 460, 460, 460, 550, 550, 550, 550,  680,  680,  680,  680,  680,  680,  680,  820,  820,  970,  970,  970, 1040, 1040, 1080, 1080, 1150, 1150, 1200, 1200, 1280, 1280, 1300),
186         CPU_DVFS("cpu_g",  8, 1, MHZ,   1,   1,   1,   1, 480, 480, 480, 650, 650, 650, 650,  780,  780,  780,  780,  780,  780,  780,  990,  990, 1040, 1040, 1040, 1100, 1100, 1200, 1200, 1300),
187         CPU_DVFS("cpu_g",  8, 2, MHZ,   1,   1,   1,   1, 520, 520, 520, 700, 700, 700, 700,  860,  860,  860,  860,  860,  860,  860, 1050, 1050, 1150, 1150, 1150, 1200, 1200, 1300),
188         CPU_DVFS("cpu_g",  8, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1300),
189         CPU_DVFS("cpu_g",  8, 4, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  940,  940,  940,  940,  940,  940,  940, 1160, 1160, 1300, 1300, 1300),
190
191         CPU_DVFS("cpu_g",  9, -1, MHZ,  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900),
192         CPU_DVFS("cpu_g", 10, -1, MHZ,  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,    1,    1,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900),
193         CPU_DVFS("cpu_g", 11, -1, MHZ,  1,   1,   1,   1,   1,   1,   1, 600, 600, 600, 600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600,  600),
194         CPU_DVFS("cpu_g", 14, -1, MHZ,  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,    1,    1,    1,    1,    1,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900),
195         CPU_DVFS("cpu_g", 15, -1, MHZ,  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900,  900),
196
197         CPU_DVFS("cpu_g", 12, 3, MHZ,   1,   475, 475, 475, 475, 620, 620, 620, 620, 760, 760, 760, 760,  760,  910,  910,  1000,  1000, 1000, 1000, 1150, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1500, 1500, 1700),
198         CPU_DVFS("cpu_g", 12, 4, MHZ,   475, 475, 475, 475, 475, 620, 620, 620, 760, 760, 760, 760, 910,  910,  910, 1000,  1000,  1000, 1000, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1700),
199
200         CPU_DVFS("cpu_g", 13, 3, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  910,  910,  910,  910,  910,  910,  910, 1150, 1150, 1230, 1230, 1230, 1280, 1280, 1330, 1330, 1370, 1370, 1400, 1400, 1470, 1470, 1500, 1500, 1500, 1500, 1540, 1540, 1700),
201         CPU_DVFS("cpu_g", 13, 4, MHZ,   1,   1,   1,   1, 550, 550, 550, 770, 770, 770, 770,  940,  940,  940,  940,  940,  940,  940, 1160, 1160, 1240, 1240, 1240, 1280, 1280, 1360, 1360, 1390, 1390, 1470, 1470, 1500, 1500, 1520, 1520, 1520, 1520, 1590, 1700),
202
203         /*
204          * "Safe entry" to be used when no match for chip speedo, process
205          *  corner is found (just to boot at low rate); must be the last one
206          */
207         CPU_DVFS("cpu_g", -1, -1, MHZ, 1,   1, 216, 216, 300),
208 };
209
210 static struct dvfs cpu_0_dvfs_table[] = {
211         /* Cpu voltages (mV):         750, 762, 775, 787, 800, 825, 837, 850, 862,  875,  887,  900,  912,  916,  925,  937,  950,  962,  975,  987, 1000, 1007, 1012, 1025, 1037, 1050, 1062, 1075, 1087, 1100, 1112, 1125, 1137, 1150, 1162, 1175, 1187, 1200, 1212, 1237*/
212         CPU_DVFS("cpu_0",  4, 0, MHZ,   1,   1,   1, 475, 475, 475, 475, 640, 640,  640,  760,  760,  760,  760,  860,  860,  860,  860,  860, 1000, 1000, 1000, 1000, 1100, 1100, 1100, 1100, 1200, 1200, 1200, 1200, 1200, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1500),
213         CPU_DVFS("cpu_0",  4, 1, MHZ,   1, 475, 475, 475, 475, 640, 640, 640, 760,  760,  760,  860,  860,  860,  860,  860, 1000, 1000, 1000, 1100, 1100, 1100, 1100, 1100, 1200, 1200, 1200, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1400, 1400, 1500),
214         CPU_DVFS("cpu_0",  4, 2, MHZ, 475, 475, 475, 640, 640, 640, 760, 760, 760,  860,  860,  860, 1000, 1000, 1000, 1000, 1000, 1100, 1100, 1200, 1200, 1200, 1200, 1200, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1400, 1500),
215         CPU_DVFS("cpu_0",  4, 3, MHZ, 475, 475, 640, 640, 640, 760, 760, 860, 860,  860,  860, 1000, 1000, 1000, 1100, 1100, 1100, 1100, 1200, 1200, 1200, 1200, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1400, 1500),
216
217         CPU_DVFS("cpu_0",  5, 3, MHZ, 475, 475, 620, 620, 620, 760, 760, 760, 910,  910,  910, 1000, 1000, 1000, 1000, 1000, 1000, 1150, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1500, 1600, 1600, 1600, 1600, 1700),
218         CPU_DVFS("cpu_0",  5, 4, MHZ, 475, 620, 620, 620, 760, 760, 760, 910, 910, 1000, 1000, 1000, 1000, 1000, 1150, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1600, 1600, 1600, 1600, 1600, 1600, 1600, 1600, 1700),
219
220         CPU_DVFS("cpu_0",  6, 3, MHZ, 475, 475, 620, 620, 620, 760, 760, 760, 910,  910,  910, 1000, 1000, 1000, 1000, 1000, 1000, 1150, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1500, 1600, 1600, 1600, 1600, 1700),
221         CPU_DVFS("cpu_0",  6, 4, MHZ, 475, 620, 620, 620, 760, 760, 760, 910, 910, 1000, 1000, 1000, 1000, 1000, 1150, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1600, 1600, 1600, 1600, 1600, 1600, 1600, 1600, 1700),
222
223         CPU_DVFS("cpu_0", 12, 3, MHZ, 475, 475, 620, 620, 620, 760, 760, 760, 910,  910,  910, 1000, 1000, 1000, 1000, 1000, 1000, 1150, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1500, 1600, 1600, 1600, 1600, 1700),
224         CPU_DVFS("cpu_0", 12, 4, MHZ, 475, 620, 620, 620, 760, 760, 760, 910, 910, 1000, 1000, 1000, 1000, 1000, 1000, 1150, 1150, 1150, 1150, 1300, 1300, 1300, 1300, 1400, 1400, 1400, 1500, 1500, 1500, 1500, 1500, 1600, 1600, 1600, 1600, 1600, 1600, 1600, 1700),
225 };
226
227 #define CORE_DVFS(_clk_name, _speedo_id, _auto, _mult, _freqs...)       \
228         {                                                       \
229                 .clk_name       = _clk_name,                    \
230                 .speedo_id      = _speedo_id,                   \
231                 .process_id     = -1,                           \
232                 .freqs          = {_freqs},                     \
233                 .freqs_mult     = _mult,                        \
234                 .millivolts     = core_millivolts,              \
235                 .auto_dvfs      = _auto,                        \
236                 .dvfs_rail      = &tegra3_dvfs_rail_vdd_core,   \
237         }
238
239 static struct dvfs core_dvfs_table[] = {
240         /* Core voltages (mV):              950,   1000,   1050,   1100,   1150,    1200,    1250,    1300,    1350 */
241         /* Clock limits for internal blocks, PLLs */
242         CORE_DVFS("cpu_lp", 0, 1, KHZ,        1, 294000, 342000, 427000, 475000,  500000,  500000,  500000,  500000),
243         CORE_DVFS("cpu_lp", 1, 1, KHZ,   204000, 294000, 342000, 427000, 475000,  500000,  500000,  500000,  500000),
244         CORE_DVFS("cpu_lp", 2, 1, KHZ,   204000, 295000, 370000, 428000, 475000,  513000,  579000,  620000,  620000),
245         CORE_DVFS("cpu_lp", 3, 1, KHZ,        1,      1,      1,      1,      1,       1,  450000,  450000,  450000),
246
247         CORE_DVFS("emc",    0, 1, KHZ,        1, 266500, 266500, 266500, 266500,  533000,  533000,  533000,  533000),
248         CORE_DVFS("emc",    1, 1, KHZ,   102000, 408000, 408000, 408000, 408000,  667000,  667000,  667000,  667000),
249         CORE_DVFS("emc",    2, 1, KHZ,   102000, 450000, 450000, 450000, 450000,  667000,  667000,  800000,  900000),
250         CORE_DVFS("emc",    3, 1, KHZ,        1,      1,      1,      1,      1,       1,  625000,  625000,  625000),
251
252         CORE_DVFS("sbus",   0, 1, KHZ,        1, 136000, 164000, 191000, 216000,  216000,  216000,  216000,  216000),
253         CORE_DVFS("sbus",   1, 1, KHZ,   102000, 205000, 205000, 227000, 227000,  267000,  267000,  267000,  267000),
254         CORE_DVFS("sbus",   2, 1, KHZ,   102000, 205000, 205000, 227000, 227000,  267000,  334000,  334000,  334000),
255         CORE_DVFS("sbus",   3, 1, KHZ,        1,      1,      1,      1,      1,       1,  334000,  334000,  334000),
256
257         CORE_DVFS("vi",     0, 1, KHZ,        1, 216000, 285000, 300000, 300000,  300000,  300000,  300000,  300000),
258         CORE_DVFS("vi",     1, 1, KHZ,        1, 216000, 267000, 300000, 371000,  409000,  409000,  409000,  409000),
259         CORE_DVFS("vi",     2, 1, KHZ,        1, 219000, 267000, 300000, 371000,  409000,  425000,  425000,  425000),
260         CORE_DVFS("vi",     3, 1, KHZ,        1,      1,      1,      1,      1,       1,  470000,  470000,  470000),
261
262         CORE_DVFS("vde",    0, 1, KHZ,        1, 228000, 275000, 332000, 380000,  416000,  416000,  416000,  416000),
263         CORE_DVFS("mpe",    0, 1, KHZ,        1, 234000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
264         CORE_DVFS("2d",     0, 1, KHZ,        1, 267000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
265         CORE_DVFS("epp",    0, 1, KHZ,        1, 267000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
266         CORE_DVFS("3d",     0, 1, KHZ,        1, 234000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
267         CORE_DVFS("3d2",    0, 1, KHZ,        1, 234000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
268         CORE_DVFS("se",     0, 1, KHZ,        1, 267000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
269
270         CORE_DVFS("vde",    1, 1, KHZ,   200000, 228000, 275000, 332000, 380000,  416000,  416000,  416000,  416000),
271         CORE_DVFS("mpe",    1, 1, KHZ,   200000, 234000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
272         CORE_DVFS("2d",     1, 1, KHZ,   200000, 267000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
273         CORE_DVFS("epp",    1, 1, KHZ,   200000, 267000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
274         CORE_DVFS("3d",     1, 1, KHZ,   200000, 234000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
275         CORE_DVFS("3d2",    1, 1, KHZ,   200000, 234000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
276         CORE_DVFS("se",     1, 1, KHZ,   200000, 267000, 285000, 332000, 380000,  416000,  416000,  416000,  416000),
277
278         CORE_DVFS("vde",    2, 1, KHZ,   200000, 247000, 304000, 352000, 400000,  437000,  484000,  520000,  600000),
279         CORE_DVFS("mpe",    2, 1, KHZ,   200000, 247000, 304000, 361000, 408000,  446000,  484000,  520000,  600000),
280         CORE_DVFS("2d",     2, 1, KHZ,   200000, 267000, 304000, 361000, 408000,  446000,  484000,  520000,  600000),
281         CORE_DVFS("epp",    2, 1, KHZ,   200000, 267000, 304000, 361000, 408000,  446000,  484000,  520000,  600000),
282         CORE_DVFS("3d",     2, 1, KHZ,   200000, 247000, 304000, 361000, 408000,  446000,  484000,  520000,  600000),
283         CORE_DVFS("3d2",    2, 1, KHZ,   200000, 247000, 304000, 361000, 408000,  446000,  484000,  520000,  600000),
284         CORE_DVFS("se",     2, 1, KHZ,   200000, 267000, 304000, 361000, 408000,  446000,  484000,  520000,  600000),
285
286         CORE_DVFS("vde",    3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
287         CORE_DVFS("mpe",    3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
288         CORE_DVFS("2d",     3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
289         CORE_DVFS("epp",    3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
290         CORE_DVFS("3d",     3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
291         CORE_DVFS("3d2",    3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
292         CORE_DVFS("se",     3, 1, KHZ,        1,      1,      1,      1,      1,       1,  625000,  625000,  625000),
293
294         CORE_DVFS("host1x", 0, 1, KHZ,        1, 152000, 188000, 222000, 254000,  267000,  267000,  267000,  267000),
295         CORE_DVFS("host1x", 1, 1, KHZ,   100000, 152000, 188000, 222000, 254000,  267000,  267000,  267000,  267000),
296         CORE_DVFS("host1x", 2, 1, KHZ,   100000, 152000, 188000, 222000, 254000,  267000,  267000,  267000,  300000),
297         CORE_DVFS("host1x", 3, 1, KHZ,        1,      1,      1,      1,      1,       1,  242000,  242000,  242000),
298
299         CORE_DVFS("cbus",   0, 1, KHZ,        1, 228000, 275000, 332000, 380000,  416000,  416000,  416000,  416000),
300         CORE_DVFS("cbus",   1, 1, KHZ,   200000, 228000, 275000, 332000, 380000,  416000,  416000,  416000,  416000),
301         CORE_DVFS("cbus",   2, 1, KHZ,   200000, 247000, 304000, 352000, 400000,  437000,  484000,  520000,  600000),
302         CORE_DVFS("cbus",   3, 1, KHZ,        1,      1,      1,      1,      1,       1,  484000,  484000,  484000),
303
304         CORE_DVFS("pll_c",  -1, 1, KHZ,  533000, 667000, 667000, 800000, 800000, 1066000, 1066000, 1066000, 1200000),
305
306         /*
307          * PLLM dvfs is common across all speedo IDs with one special exception
308          * for T30 and T33, rev A02+, provided PLLM usage is restricted. Both
309          * common and restricted table are included, and table selection is
310          * handled by is_pllm_dvfs() below.
311          */
312         CORE_DVFS("pll_m",  -1, 1, KHZ,  533000, 667000, 667000, 800000, 800000, 1066000, 1066000, 1066000, 1066000),
313 #ifdef CONFIG_TEGRA_PLLM_RESTRICTED
314         CORE_DVFS("pll_m",   2, 1, KHZ,  533000, 900000, 900000, 900000, 900000, 1066000, 1066000, 1066000, 1066000),
315 #endif
316         /* Core voltages (mV):              950,   1000,   1050,   1100,   1150,   1200,    1250,     1300,    1350 */
317         /* Clock limits for I/O peripherals */
318         CORE_DVFS("mipi",   0, 1, KHZ,        1,      1,      1,      1,      1,      1,       1,        1,       1),
319         CORE_DVFS("mipi",   1, 1, KHZ,        1,      1,      1,      1,      1,  60000,   60000,    60000,   60000),
320         CORE_DVFS("mipi",   2, 1, KHZ,        1,      1,      1,      1,      1,  60000,   60000,    60000,   60000),
321         CORE_DVFS("mipi",   3, 1, KHZ,        1,      1,      1,      1,      1,      1,       1,        1,       1),
322
323         CORE_DVFS("fuse_burn", -1, 1, KHZ,    1,      1,      1,      1,  26000,  26000,   26000,    26000,   26000),
324         CORE_DVFS("sdmmc1", -1, 1, KHZ,  104000, 104000, 104000, 104000, 104000, 208000,  208000,   208000,  208000),
325         CORE_DVFS("sdmmc3", -1, 1, KHZ,  104000, 104000, 104000, 104000, 104000, 208000,  208000,   208000,  208000),
326         CORE_DVFS("sdmmc4", -1, 1, KHZ,   51000, 102000, 102000, 102000, 102000, 102000,  102000,   102000,  102000),
327         CORE_DVFS("ndflash", -1, 1, KHZ, 120000, 120000, 120000, 120000, 200000, 200000,  200000,   200000,  200000),
328
329         CORE_DVFS("nor",    0, 1, KHZ,        1, 115000, 130000, 130000, 133000, 133000,  133000,   133000,  133000),
330         CORE_DVFS("nor",    1, 1, KHZ,   102000, 115000, 130000, 130000, 133000, 133000,  133000,   133000,  133000),
331         CORE_DVFS("nor",    2, 1, KHZ,   102000, 115000, 130000, 130000, 133000, 133000,  133000,   133000,  133000),
332         CORE_DVFS("nor",    3, 1, KHZ,        1,      1,      1,      1,      1,      1,  108000,   108000,  108000),
333
334         CORE_DVFS("sbc1",  -1, 1, KHZ,    36000,  52000,  60000,  60000,  60000, 100000,  100000,   100000,  100000),
335         CORE_DVFS("sbc2",  -1, 1, KHZ,    36000,  52000,  60000,  60000,  60000, 100000,  100000,   100000,  100000),
336         CORE_DVFS("sbc3",  -1, 1, KHZ,    36000,  52000,  60000,  60000,  60000, 100000,  100000,   100000,  100000),
337         CORE_DVFS("sbc4",  -1, 1, KHZ,    36000,  52000,  60000,  60000,  60000, 100000,  100000,   100000,  100000),
338         CORE_DVFS("sbc5",  -1, 1, KHZ,    36000,  52000,  60000,  60000,  60000, 100000,  100000,   100000,  100000),
339         CORE_DVFS("sbc6",  -1, 1, KHZ,    36000,  52000,  60000,  60000,  60000, 100000,  100000,   100000,  100000),
340
341         CORE_DVFS("sata",  -1, 1, KHZ,        1, 216000, 216000, 216000, 216000, 216000,  216000,   216000,  216000),
342         CORE_DVFS("sata_oob", -1, 1, KHZ,     1, 216000, 216000, 216000, 216000, 216000,  216000,   216000,  216000),
343
344         CORE_DVFS("tvo",   -1, 1, KHZ,        1,      1, 297000, 297000, 297000, 297000,  297000,   297000,  297000),
345         CORE_DVFS("cve",   -1, 1, KHZ,        1,      1, 297000, 297000, 297000, 297000,  297000,   297000,  297000),
346         CORE_DVFS("dsia",  -1, 1, KHZ,   432500, 432500, 432500, 432500, 432500, 432500,  432500,   432500,  432500),
347         CORE_DVFS("dsib",  -1, 1, KHZ,   432500, 432500, 432500, 432500, 432500, 432500,  432500,   432500,  432500),
348
349         /*
350          * The clock rate for the display controllers that determines the
351          * necessary core voltage depends on a divider that is internal
352          * to the display block.  Disable auto-dvfs on the display clocks,
353          * and let the display driver call tegra_dvfs_set_rate manually
354          */
355         CORE_DVFS("disp1",  0, 0, KHZ,        1, 120000, 120000, 120000, 120000, 190000,  190000,   190000,  190000),
356         CORE_DVFS("disp1",  1, 0, KHZ,   155000, 155000, 268000, 268000, 268000, 268000,  268000,   268000,  268000),
357         CORE_DVFS("disp1",  2, 0, KHZ,   155000, 155000, 268000, 268000, 268000, 268000,  268000,   268000,  268000),
358         CORE_DVFS("disp1",  3, 0, KHZ,        1, 120000, 120000, 120000, 120000, 190000,  190000,   190000,  190000),
359
360         CORE_DVFS("disp2",  0, 0, KHZ,        1, 120000, 120000, 120000, 120000, 190000,  190000,   190000,  190000),
361         CORE_DVFS("disp2",  1, 0, KHZ,   155000, 155000, 268000, 268000, 268000, 268000,  268000,   268000,  268000),
362         CORE_DVFS("disp2",  2, 0, KHZ,   155000, 155000, 268000, 268000, 268000, 268000,  268000,   268000,  268000),
363         CORE_DVFS("disp2",  3, 0, KHZ,        1, 120000, 120000, 120000, 120000, 190000,  190000,   190000,  190000),
364
365         CORE_DVFS("pwm",   -1, 1, KHZ,   204000, 408000, 408000, 408000, 408000, 408000,  408000,   408000,  408000),
366 };
367
368 /* CPU alternative DVFS table for cold zone */
369 static unsigned long cpu_cold_freqs[MAX_DVFS_FREQS];
370
371 /* CPU alternative DVFS table for single G CPU core 0 */
372 static unsigned long *cpu_0_freqs;
373
374 int tegra_dvfs_disable_core_set(const char *arg, const struct kernel_param *kp)
375 {
376         int ret;
377
378         ret = param_set_bool(arg, kp);
379         if (ret)
380                 return ret;
381
382         if (tegra_dvfs_core_disabled)
383                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_core);
384         else
385                 tegra_dvfs_rail_enable(&tegra3_dvfs_rail_vdd_core);
386
387         return 0;
388 }
389
390 int tegra_dvfs_disable_cpu_set(const char *arg, const struct kernel_param *kp)
391 {
392         int ret;
393
394         ret = param_set_bool(arg, kp);
395         if (ret)
396                 return ret;
397
398         if (tegra_dvfs_cpu_disabled)
399                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_cpu);
400         else
401                 tegra_dvfs_rail_enable(&tegra3_dvfs_rail_vdd_cpu);
402
403         return 0;
404 }
405
406 int tegra_dvfs_disable_get(char *buffer, const struct kernel_param *kp)
407 {
408         return param_get_bool(buffer, kp);
409 }
410
411 static struct kernel_param_ops tegra_dvfs_disable_core_ops = {
412         .set = tegra_dvfs_disable_core_set,
413         .get = tegra_dvfs_disable_get,
414 };
415
416 static struct kernel_param_ops tegra_dvfs_disable_cpu_ops = {
417         .set = tegra_dvfs_disable_cpu_set,
418         .get = tegra_dvfs_disable_get,
419 };
420
421 module_param_cb(disable_core, &tegra_dvfs_disable_core_ops,
422         &tegra_dvfs_core_disabled, 0644);
423 module_param_cb(disable_cpu, &tegra_dvfs_disable_cpu_ops,
424         &tegra_dvfs_cpu_disabled, 0644);
425
426 static bool __init is_pllm_dvfs(struct clk *c, struct dvfs *d)
427 {
428 #ifdef CONFIG_TEGRA_PLLM_RESTRICTED
429         /* Do not apply common PLLM dvfs table on T30, T33, T37 rev A02+ and
430            do not apply restricted PLLM dvfs table for other SKUs/revs */
431         int cpu = tegra_cpu_speedo_id();
432         if (((cpu == 2) || (cpu == 5) || (cpu == 13)) ==
433             (d->speedo_id == -1))
434                 return false;
435 #endif
436         /* Check if PLLM boot frequency can be applied to clock tree at
437            minimum voltage. If yes, no need to enable dvfs on PLLM */
438         if (clk_get_rate_all_locked(c) <= d->freqs[0] * d->freqs_mult)
439                 return false;
440
441         return true;
442 }
443
444 static void __init init_dvfs_one(struct dvfs *d, int nominal_mv_index)
445 {
446         int ret;
447         struct clk *c = tegra_get_clock_by_name(d->clk_name);
448
449         if (!c) {
450                 pr_debug("tegra3_dvfs: no clock found for %s\n",
451                         d->clk_name);
452                 return;
453         }
454
455         /*
456          * Update max rate for auto-dvfs clocks, except EMC.
457          * EMC is a special case, since EMC dvfs is board dependent: max rate
458          * and EMC scaling frequencies are determined by tegra BCT (flashed
459          * together with the image) and board specific EMC DFS table; we will
460          * check the scaling ladder against nominal core voltage when the table
461          * is loaded (and if on particular board the table is not loaded, EMC
462          * scaling is disabled).
463          */
464         if (!(c->flags & PERIPH_EMC_ENB) && d->auto_dvfs) {
465                 BUG_ON(!d->freqs[nominal_mv_index]);
466                 tegra_init_max_rate(
467                         c, d->freqs[nominal_mv_index] * d->freqs_mult);
468         }
469         d->max_millivolts = d->dvfs_rail->nominal_millivolts;
470
471         /*
472          * Check if we may skip enabling dvfs on PLLM. PLLM is a special case,
473          * since its frequency never exceeds boot rate, and configuration with
474          * restricted PLLM usage is possible.
475          */
476         if (!(c->flags & PLLM) || is_pllm_dvfs(c, d)) {
477                 ret = tegra_enable_dvfs_on_clk(c, d);
478                 if (ret)
479                         pr_err("tegra3_dvfs: failed to enable dvfs on %s\n",
480                                 c->name);
481         }
482 }
483
484 static void __init init_dvfs_cold(struct dvfs *d, int nominal_mv_index)
485 {
486         int i;
487         unsigned long offs;
488
489         BUG_ON((nominal_mv_index == 0) || (nominal_mv_index > d->num_freqs));
490
491         for (i = 0; i < d->num_freqs; i++) {
492                 offs = cpu_cold_offs_mhz[i] * MHZ;
493                 if (i > nominal_mv_index)
494                         cpu_cold_freqs[i] = cpu_cold_freqs[i - 1];
495                 else if (d->freqs[i] > offs)
496                         cpu_cold_freqs[i] = d->freqs[i] - offs;
497                 else {
498                         cpu_cold_freqs[i] = d->freqs[i];
499                         pr_warn("tegra3_dvfs: cold offset %lu is too high for"
500                                 " regular dvfs limit %lu\n", offs, d->freqs[i]);
501                 }
502
503                 if (i)
504                         BUG_ON(cpu_cold_freqs[i] < cpu_cold_freqs[i - 1]);
505         }
506 }
507
508 static bool __init match_dvfs_one(struct dvfs *d, int speedo_id, int process_id)
509 {
510         if ((d->process_id != -1 && d->process_id != process_id) ||
511                 (d->speedo_id != -1 && d->speedo_id != speedo_id)) {
512                 pr_debug("tegra3_dvfs: rejected %s speedo %d,"
513                         " process %d\n", d->clk_name, d->speedo_id,
514                         d->process_id);
515                 return false;
516         }
517         return true;
518 }
519
520 static void __init init_cpu_0_dvfs(struct dvfs *cpud)
521 {
522         int i;
523         struct dvfs *d = NULL;
524
525         /* Init single G CPU core 0 dvfs if this particular SKU/bin has it.
526            Max rates in multi-core and single-core tables must be the same */
527         for (i = 0; i <  ARRAY_SIZE(cpu_0_dvfs_table); i++) {
528                 if (match_dvfs_one(&cpu_0_dvfs_table[i],
529                                    cpud->speedo_id, cpud->process_id)) {
530                         d = &cpu_0_dvfs_table[i];
531                         break;
532                 }
533         }
534
535         if (d) {
536                 for (i = 0; i < cpud->num_freqs; i++) {
537                         d->freqs[i] *= d->freqs_mult;
538                         if (d->freqs[i] == 0) {
539                                 BUG_ON(i == 0);
540                                 d->freqs[i] = d->freqs[i - 1];
541                         }
542                 }
543                 BUG_ON(cpud->freqs[cpud->num_freqs - 1] !=
544                        d->freqs[cpud->num_freqs - 1]);
545                 cpu_0_freqs = d->freqs;
546         }
547 }
548
549 static int __init get_cpu_nominal_mv_index(
550         int speedo_id, int process_id, struct dvfs **cpu_dvfs)
551 {
552         int i, j, mv;
553         struct dvfs *d;
554         struct clk *c;
555
556         /*
557          * Find maximum cpu voltage that satisfies cpu_to_core dependency for
558          * nominal core voltage ("solve from cpu to core at nominal"). Clip
559          * result to the nominal cpu level for the chips with this speedo_id.
560          */
561         mv = tegra3_dvfs_rail_vdd_core.nominal_millivolts;
562         for (i = 0; i < MAX_DVFS_FREQS; i++) {
563                 if ((cpu_millivolts[i] == 0) ||
564                     tegra3_get_core_floor_mv(cpu_millivolts[i]) > mv)
565                         break;
566         }
567         BUG_ON(i == 0);
568         mv = cpu_millivolts[i - 1];
569         BUG_ON(mv < tegra3_dvfs_rail_vdd_cpu.min_millivolts);
570         mv = min(mv, tegra_cpu_speedo_mv());
571
572         /*
573          * Find matching cpu dvfs entry, and use it to determine index to the
574          * final nominal voltage, that satisfies the following requirements:
575          * - allows CPU to run at minimum of the maximum rates specified in
576          *   the dvfs entry and clock tree
577          * - does not violate cpu_to_core dependency as determined above
578          */
579         for (i = 0, j = 0; j <  ARRAY_SIZE(cpu_dvfs_table); j++) {
580                 d = &cpu_dvfs_table[j];
581                 if (match_dvfs_one(d, speedo_id, process_id)) {
582                         c = tegra_get_clock_by_name(d->clk_name);
583                         BUG_ON(!c);
584
585                         for (; i < MAX_DVFS_FREQS; i++) {
586                                 if ((d->freqs[i] == 0) ||
587                                     (cpu_millivolts[i] == 0) ||
588                                     (mv < cpu_millivolts[i]))
589                                         break;
590
591                                 if (c->max_rate <= d->freqs[i]*d->freqs_mult) {
592                                         i++;
593                                         break;
594                                 }
595                         }
596                         break;
597                 }
598         }
599
600         BUG_ON(i == 0);
601         if (j == (ARRAY_SIZE(cpu_dvfs_table) - 1))
602                 pr_err("tegra3_dvfs: WARNING!!!\n"
603                        "tegra3_dvfs: no cpu dvfs table found for chip speedo_id"
604                        " %d and process_id %d: set CPU rate limit at %lu\n"
605                        "tegra3_dvfs: WARNING!!!\n",
606                        speedo_id, process_id, d->freqs[i-1] * d->freqs_mult);
607
608         *cpu_dvfs = d;
609         return (i - 1);
610 }
611
612 static int __init get_core_nominal_mv_index(int speedo_id)
613 {
614         int i;
615         int mv = tegra_core_speedo_mv();
616         int core_edp_limit = get_core_edp();
617
618         /*
619          * Start with nominal level for the chips with this speedo_id. Then,
620          * make sure core nominal voltage is below edp limit for the board
621          * (if edp limit is set).
622          */
623         if (core_edp_limit)
624                 mv = min(mv, core_edp_limit);
625
626         /* Round nominal level down to the nearest core scaling step */
627         for (i = 0; i < MAX_DVFS_FREQS; i++) {
628                 if ((core_millivolts[i] == 0) || (mv < core_millivolts[i]))
629                         break;
630         }
631
632         if (i == 0) {
633                 pr_err("tegra3_dvfs: unable to adjust core dvfs table to"
634                        " nominal voltage %d\n", mv);
635                 return -ENOSYS;
636         }
637         return (i - 1);
638 }
639
640 static void tegra_adjust_cpu_mvs(int mvs)
641 {
642         int i;
643
644         BUG_ON(ARRAY_SIZE(cpu_millivolts) != ARRAY_SIZE(cpu_millivolts_aged));
645
646         for (i = 0; i < ARRAY_SIZE(cpu_millivolts); i++)
647                 cpu_millivolts[i] = cpu_millivolts_aged[i] - mvs;
648 }
649
650 /**
651  * Adjust VDD_CPU to offset aging.
652  * 25mV for 1st year
653  * 12mV for 2nd and 3rd year
654  * 0mV for 4th year onwards
655  */
656 void tegra_dvfs_age_cpu(int cur_linear_age)
657 {
658         int chip_linear_age;
659         int chip_life;
660         chip_linear_age = tegra_get_age();
661         chip_life = cur_linear_age - chip_linear_age;
662
663         /*For T37 and AP37*/
664         if (tegra_cpu_speedo_id() == 12 || tegra_cpu_speedo_id() == 13) {
665                 if (chip_linear_age <= 0) {
666                         return;
667                 } else if (chip_life <= 12) {
668                         tegra_adjust_cpu_mvs(25);
669                 } else if (chip_life <= 36) {
670                         tegra_adjust_cpu_mvs(13);
671                 }
672         }
673 }
674
675 void __init tegra3_init_dvfs(void)
676 {
677         int cpu_speedo_id = tegra_cpu_speedo_id();
678         int soc_speedo_id = tegra_soc_speedo_id();
679         int cpu_process_id = tegra_cpu_process_id();
680         int core_process_id = tegra_core_process_id();
681
682         int i;
683         int core_nominal_mv_index;
684         int cpu_nominal_mv_index;
685
686 #ifndef CONFIG_TEGRA_CORE_DVFS
687         tegra_dvfs_core_disabled = true;
688 #endif
689 #ifndef CONFIG_TEGRA_CPU_DVFS
690         tegra_dvfs_cpu_disabled = true;
691 #endif
692
693         /*
694          * Find nominal voltages for core (1st) and cpu rails before rail
695          * init. Nominal voltage index in the scaling ladder will also be
696          * used to determine max dvfs frequency for the respective domains.
697          */
698         core_nominal_mv_index = get_core_nominal_mv_index(soc_speedo_id);
699         if (core_nominal_mv_index < 0) {
700                 tegra3_dvfs_rail_vdd_core.disabled = true;
701                 tegra_dvfs_core_disabled = true;
702                 core_nominal_mv_index = 0;
703         }
704         tegra3_dvfs_rail_vdd_core.nominal_millivolts =
705                 core_millivolts[core_nominal_mv_index];
706
707         cpu_nominal_mv_index = get_cpu_nominal_mv_index(
708                 cpu_speedo_id, cpu_process_id, &cpu_dvfs);
709         BUG_ON((cpu_nominal_mv_index < 0) || (!cpu_dvfs));
710         tegra3_dvfs_rail_vdd_cpu.nominal_millivolts =
711                 cpu_millivolts[cpu_nominal_mv_index];
712
713         /* Init rail structures and dependencies */
714         tegra_dvfs_init_rails(tegra3_dvfs_rails, ARRAY_SIZE(tegra3_dvfs_rails));
715         tegra_dvfs_add_relationships(tegra3_dvfs_relationships,
716                 ARRAY_SIZE(tegra3_dvfs_relationships));
717
718         /* Search core dvfs table for speedo/process matching entries and
719            initialize dvfs-ed clocks */
720         for (i = 0; i <  ARRAY_SIZE(core_dvfs_table); i++) {
721                 struct dvfs *d = &core_dvfs_table[i];
722                 if (!match_dvfs_one(d, soc_speedo_id, core_process_id))
723                         continue;
724                 init_dvfs_one(d, core_nominal_mv_index);
725         }
726
727         /* Initialize matching cpu dvfs entry already found when nominal
728            voltage was determined */
729         init_dvfs_one(cpu_dvfs, cpu_nominal_mv_index);
730
731         /* Initialize alternative cold zone and single core tables */
732         init_dvfs_cold(cpu_dvfs, cpu_nominal_mv_index);
733         init_cpu_0_dvfs(cpu_dvfs);
734
735         /* Finally disable dvfs on rails if necessary */
736         if (tegra_dvfs_core_disabled)
737                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_core);
738         if (tegra_dvfs_cpu_disabled)
739                 tegra_dvfs_rail_disable(&tegra3_dvfs_rail_vdd_cpu);
740
741         pr_info("tegra dvfs: VDD_CPU nominal %dmV, scaling %s\n",
742                 tegra3_dvfs_rail_vdd_cpu.nominal_millivolts,
743                 tegra_dvfs_cpu_disabled ? "disabled" : "enabled");
744         pr_info("tegra dvfs: VDD_CORE nominal %dmV, scaling %s\n",
745                 tegra3_dvfs_rail_vdd_core.nominal_millivolts,
746                 tegra_dvfs_core_disabled ? "disabled" : "enabled");
747 }
748
749 int tegra_cpu_dvfs_alter(int edp_thermal_index, const cpumask_t *cpus,
750                           bool before_clk_update, int cpu_event)
751 {
752         bool cpu_warm = !!edp_thermal_index;
753         unsigned int n = cpumask_weight(cpus);
754         unsigned long *alt_freqs = cpu_warm ?
755                 (n > 1 ? NULL : cpu_0_freqs) : cpu_cold_freqs;
756
757         if (cpu_event || (cpu_warm == before_clk_update)) {
758                 int ret = tegra_dvfs_alt_freqs_set(cpu_dvfs, alt_freqs);
759                 if (ret) {
760                         pr_err("tegra dvfs: failed to set alternative dvfs on "
761                                "%u %s CPUs\n", n, cpu_warm ? "warm" : "cold");
762                         return ret;
763                 }
764         }
765         return 0;
766 }
767
768 int tegra_dvfs_rail_disable_prepare(struct dvfs_rail *rail)
769 {
770         int ret = 0;
771
772         if (tegra_emc_get_dram_type() != DRAM_TYPE_DDR3)
773                 return ret;
774
775         if (((&tegra3_dvfs_rail_vdd_core == rail) &&
776              (rail->nominal_millivolts > TEGRA_EMC_BRIDGE_MVOLTS_MIN)) ||
777             ((&tegra3_dvfs_rail_vdd_cpu == rail) &&
778              (tegra3_get_core_floor_mv(rail->nominal_millivolts) >
779               TEGRA_EMC_BRIDGE_MVOLTS_MIN))) {
780                 struct clk *bridge = tegra_get_clock_by_name("bridge.emc");
781                 BUG_ON(!bridge);
782
783                 ret = clk_enable(bridge);
784                 pr_info("%s: %s: %s bridge.emc\n", __func__,
785                         rail->reg_id, ret ? "failed to enable" : "enabled");
786         }
787         return ret;
788 }
789
790 int tegra_dvfs_rail_post_enable(struct dvfs_rail *rail)
791 {
792         if (tegra_emc_get_dram_type() != DRAM_TYPE_DDR3)
793                 return 0;
794
795         if (((&tegra3_dvfs_rail_vdd_core == rail) &&
796              (rail->nominal_millivolts > TEGRA_EMC_BRIDGE_MVOLTS_MIN)) ||
797             ((&tegra3_dvfs_rail_vdd_cpu == rail) &&
798              (tegra3_get_core_floor_mv(rail->nominal_millivolts) >
799               TEGRA_EMC_BRIDGE_MVOLTS_MIN))) {
800                 struct clk *bridge = tegra_get_clock_by_name("bridge.emc");
801                 BUG_ON(!bridge);
802
803                 clk_disable(bridge);
804                 pr_info("%s: %s: disabled bridge.emc\n",
805                         __func__, rail->reg_id);
806         }
807         return 0;
808 }
809
810 /*
811  * sysfs and dvfs interfaces to cap tegra core domains frequencies
812  */
813 static DEFINE_MUTEX(core_cap_lock);
814
815 struct core_cap {
816         int refcnt;
817         int level;
818 };
819 static struct core_cap tegra3_core_cap;
820 static struct core_cap kdvfs_core_cap;
821 static struct core_cap user_core_cap;
822
823 static struct core_cap user_cbus_cap;
824
825 static struct kobject *cap_kobj;
826
827 /* Arranged in order required for enabling/lowering the cap */
828 static struct {
829         const char *cap_name;
830         struct clk *cap_clk;
831         unsigned long freqs[MAX_DVFS_FREQS];
832 } core_cap_table[] = {
833         { .cap_name = "cap.cbus" },
834         { .cap_name = "cap.sclk" },
835         { .cap_name = "cap.emc" },
836 };
837
838
839 static void core_cap_level_set(int level)
840 {
841         int i, j;
842
843         for (j = 0; j < ARRAY_SIZE(core_millivolts); j++) {
844                 int v = core_millivolts[j];
845                 if ((v == 0) || (level < v))
846                         break;
847         }
848         j = (j == 0) ? 0 : j - 1;
849         level = core_millivolts[j];
850
851         if (level < tegra3_core_cap.level) {
852                 for (i = 0; i < ARRAY_SIZE(core_cap_table); i++)
853                         if (core_cap_table[i].cap_clk)
854                                 clk_set_rate(core_cap_table[i].cap_clk,
855                                              core_cap_table[i].freqs[j]);
856         } else if (level > tegra3_core_cap.level) {
857                 for (i = ARRAY_SIZE(core_cap_table) - 1; i >= 0; i--)
858                         if (core_cap_table[i].cap_clk)
859                                 clk_set_rate(core_cap_table[i].cap_clk,
860                                              core_cap_table[i].freqs[j]);
861         }
862         tegra3_core_cap.level = level;
863 }
864
865 static void core_cap_update(void)
866 {
867         int new_level = tegra3_dvfs_rail_vdd_core.max_millivolts;
868
869         if (kdvfs_core_cap.refcnt)
870                 new_level = min(new_level, kdvfs_core_cap.level);
871         if (user_core_cap.refcnt)
872                 new_level = min(new_level, user_core_cap.level);
873
874         if (tegra3_core_cap.level != new_level)
875                 core_cap_level_set(new_level);
876 }
877
878 static void core_cap_enable(bool enable)
879 {
880         if (enable)
881                 tegra3_core_cap.refcnt++;
882         else if (tegra3_core_cap.refcnt)
883                 tegra3_core_cap.refcnt--;
884
885         core_cap_update();
886 }
887
888 static ssize_t
889 core_cap_state_show(struct kobject *kobj, struct kobj_attribute *attr,
890                     char *buf)
891 {
892         return sprintf(buf, "%d (%d)\n", tegra3_core_cap.refcnt ? 1 : 0,
893                         user_core_cap.refcnt ? 1 : 0);
894 }
895 static ssize_t
896 core_cap_state_store(struct kobject *kobj, struct kobj_attribute *attr,
897                      const char *buf, size_t count)
898 {
899         int state;
900
901         if (sscanf(buf, "%d", &state) != 1)
902                 return -1;
903
904         mutex_lock(&core_cap_lock);
905
906         if (state) {
907                 user_core_cap.refcnt++;
908                 if (user_core_cap.refcnt == 1)
909                         core_cap_enable(true);
910         } else if (user_core_cap.refcnt) {
911                 user_core_cap.refcnt--;
912                 if (user_core_cap.refcnt == 0)
913                         core_cap_enable(false);
914         }
915
916         mutex_unlock(&core_cap_lock);
917         return count;
918 }
919
920 static ssize_t
921 core_cap_level_show(struct kobject *kobj, struct kobj_attribute *attr,
922                     char *buf)
923 {
924         return sprintf(buf, "%d (%d)\n", tegra3_core_cap.level,
925                         user_core_cap.level);
926 }
927 static ssize_t
928 core_cap_level_store(struct kobject *kobj, struct kobj_attribute *attr,
929                      const char *buf, size_t count)
930 {
931         int level;
932
933         if (sscanf(buf, "%d", &level) != 1)
934                 return -1;
935
936         mutex_lock(&core_cap_lock);
937         user_core_cap.level = level;
938         core_cap_update();
939         mutex_unlock(&core_cap_lock);
940         return count;
941 }
942
943 static void cbus_cap_update(void)
944 {
945         static struct clk *cbus_cap;
946
947         if (!cbus_cap) {
948                 cbus_cap = tegra_get_clock_by_name("cap.profile.cbus");
949                 if (!cbus_cap) {
950                         WARN_ONCE(1, "tegra3_dvfs: cbus profiling is not supported");
951                         return;
952                 }
953         }
954
955         if (user_cbus_cap.refcnt)
956                 clk_set_rate(cbus_cap, user_cbus_cap.level);
957         else
958                 clk_set_rate(cbus_cap, clk_get_max_rate(cbus_cap));
959 }
960
961 static ssize_t
962 cbus_cap_state_show(struct kobject *kobj, struct kobj_attribute *attr,
963                     char *buf)
964 {
965         return sprintf(buf, "%d\n", user_cbus_cap.refcnt ? 1 : 0);
966 }
967 static ssize_t
968 cbus_cap_state_store(struct kobject *kobj, struct kobj_attribute *attr,
969                      const char *buf, size_t count)
970 {
971         int state;
972
973         if (sscanf(buf, "%d", &state) != 1)
974                 return -1;
975
976         mutex_lock(&core_cap_lock);
977
978         if (state) {
979                 user_cbus_cap.refcnt++;
980                 if (user_cbus_cap.refcnt == 1)
981                         cbus_cap_update();
982         } else if (user_cbus_cap.refcnt) {
983                 user_cbus_cap.refcnt--;
984                 if (user_cbus_cap.refcnt == 0)
985                         cbus_cap_update();
986         }
987
988         mutex_unlock(&core_cap_lock);
989         return count;
990 }
991
992 static ssize_t
993 cbus_cap_level_show(struct kobject *kobj, struct kobj_attribute *attr,
994                     char *buf)
995 {
996         return sprintf(buf, "%d\n", user_cbus_cap.level);
997 }
998 static ssize_t
999 cbus_cap_level_store(struct kobject *kobj, struct kobj_attribute *attr,
1000                      const char *buf, size_t count)
1001 {
1002         int level;
1003
1004         if (sscanf(buf, "%d", &level) != 1)
1005                 return -1;
1006
1007         mutex_lock(&core_cap_lock);
1008         user_cbus_cap.level = level;
1009         cbus_cap_update();
1010         mutex_unlock(&core_cap_lock);
1011         return count;
1012 }
1013
1014 static struct kobj_attribute cap_state_attribute =
1015         __ATTR(core_cap_state, 0644, core_cap_state_show, core_cap_state_store);
1016 static struct kobj_attribute cap_level_attribute =
1017         __ATTR(core_cap_level, 0644, core_cap_level_show, core_cap_level_store);
1018 static struct kobj_attribute cbus_state_attribute =
1019         __ATTR(cbus_cap_state, 0644, cbus_cap_state_show, cbus_cap_state_store);
1020 static struct kobj_attribute cbus_level_attribute =
1021         __ATTR(cbus_cap_level, 0644, cbus_cap_level_show, cbus_cap_level_store);
1022
1023 const struct attribute *cap_attributes[] = {
1024         &cap_state_attribute.attr,
1025         &cap_level_attribute.attr,
1026         &cbus_state_attribute.attr,
1027         &cbus_level_attribute.attr,
1028         NULL,
1029 };
1030
1031 void tegra_dvfs_core_cap_enable(bool enable)
1032 {
1033         mutex_lock(&core_cap_lock);
1034
1035         if (enable) {
1036                 kdvfs_core_cap.refcnt++;
1037                 if (kdvfs_core_cap.refcnt == 1)
1038                         core_cap_enable(true);
1039         } else if (kdvfs_core_cap.refcnt) {
1040                 kdvfs_core_cap.refcnt--;
1041                 if (kdvfs_core_cap.refcnt == 0)
1042                         core_cap_enable(false);
1043         }
1044         mutex_unlock(&core_cap_lock);
1045 }
1046
1047 void tegra_dvfs_core_cap_level_set(int level)
1048 {
1049         mutex_lock(&core_cap_lock);
1050         kdvfs_core_cap.level = level;
1051         core_cap_update();
1052         mutex_unlock(&core_cap_lock);
1053 }
1054
1055 static int __init init_core_cap_one(struct clk *c, unsigned long *freqs)
1056 {
1057         int i, v, next_v = 0;
1058         unsigned long rate, next_rate = 0;
1059
1060         for (i = 0; i < ARRAY_SIZE(core_millivolts); i++) {
1061                 v = core_millivolts[i];
1062                 if (v == 0)
1063                         break;
1064
1065                 for (;;) {
1066                         rate = next_rate;
1067                         next_rate = clk_round_rate(c, rate + 1000);
1068                         if (IS_ERR_VALUE(next_rate)) {
1069                                 pr_debug("tegra3_dvfs: failed to round %s"
1070                                            " rate %lu", c->name, rate);
1071                                 return -EINVAL;
1072                         }
1073                         if (rate == next_rate)
1074                                 break;
1075
1076                         next_v = tegra_dvfs_predict_millivolts(
1077                                 c->parent, next_rate);
1078                         if (IS_ERR_VALUE(next_v)) {
1079                                 pr_debug("tegra3_dvfs: failed to predict %s mV"
1080                                          " for rate %lu", c->name, next_rate);
1081                                 return -EINVAL;
1082                         }
1083                         if (next_v > v)
1084                                 break;
1085                 }
1086
1087                 if (rate == 0) {
1088                         rate = next_rate;
1089                         pr_warn("tegra3_dvfs: minimum %s rate %lu requires"
1090                                 " %d mV", c->name, rate, next_v);
1091                 }
1092                 freqs[i] = rate;
1093                 next_rate = rate;
1094         }
1095         return 0;
1096 }
1097
1098 static int __init tegra_dvfs_init_core_cap(void)
1099 {
1100         int i;
1101         struct clk *c = NULL;
1102
1103         tegra3_core_cap.level = kdvfs_core_cap.level = user_core_cap.level =
1104                 tegra3_dvfs_rail_vdd_core.max_millivolts;
1105
1106         for (i = 0; i < ARRAY_SIZE(core_cap_table); i++) {
1107                 c = tegra_get_clock_by_name(core_cap_table[i].cap_name);
1108                 if (!c || !c->parent ||
1109                     init_core_cap_one(c, core_cap_table[i].freqs)) {
1110                         pr_err("tegra3_dvfs: failed to initialize %s frequency"
1111                                " table", core_cap_table[i].cap_name);
1112                         continue;
1113                 }
1114                 core_cap_table[i].cap_clk = c;
1115         }
1116
1117         cap_kobj = kobject_create_and_add("tegra_cap", kernel_kobj);
1118         if (!cap_kobj) {
1119                 pr_err("tegra3_dvfs: failed to create sysfs cap object");
1120                 return 0;
1121         }
1122
1123         if (sysfs_create_files(cap_kobj, cap_attributes)) {
1124                 pr_err("tegra3_dvfs: failed to create sysfs cap interface");
1125                 return 0;
1126         }
1127         pr_info("tegra dvfs: tegra sysfs cap interface is initialized\n");
1128
1129         return 0;
1130 }
1131 late_initcall(tegra_dvfs_init_core_cap);