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