Merge tag 'pm-5.1-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[muen/linux.git] / drivers / cpufreq / pxa2xx-cpufreq.c
1 /*
2  *  Copyright (C) 2002,2003 Intrinsyc Software
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  *
18  * History:
19  *   31-Jul-2002 : Initial version [FB]
20  *   29-Jan-2003 : added PXA255 support [FB]
21  *   20-Apr-2003 : ported to v2.5 (Dustin McIntire, Sensoria Corp.)
22  *
23  * Note:
24  *   This driver may change the memory bus clock rate, but will not do any
25  *   platform specific access timing changes... for example if you have flash
26  *   memory connected to CS0, you will need to register a platform specific
27  *   notifier which will adjust the memory access strobes to maintain a
28  *   minimum strobe width.
29  *
30  */
31
32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
33
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/sched.h>
37 #include <linux/init.h>
38 #include <linux/cpufreq.h>
39 #include <linux/err.h>
40 #include <linux/regulator/consumer.h>
41 #include <linux/io.h>
42
43 #include <mach/pxa2xx-regs.h>
44 #include <mach/smemc.h>
45
46 #ifdef DEBUG
47 static unsigned int freq_debug;
48 module_param(freq_debug, uint, 0);
49 MODULE_PARM_DESC(freq_debug, "Set the debug messages to on=1/off=0");
50 #else
51 #define freq_debug  0
52 #endif
53
54 static struct regulator *vcc_core;
55
56 static unsigned int pxa27x_maxfreq;
57 module_param(pxa27x_maxfreq, uint, 0);
58 MODULE_PARM_DESC(pxa27x_maxfreq, "Set the pxa27x maxfreq in MHz"
59                  "(typically 624=>pxa270, 416=>pxa271, 520=>pxa272)");
60
61 struct pxa_cpufreq_data {
62         struct clk *clk_core;
63 };
64 static struct pxa_cpufreq_data  pxa_cpufreq_data;
65
66 struct pxa_freqs {
67         unsigned int khz;
68         int vmin;
69         int vmax;
70 };
71
72 /*
73  * PXA255 definitions
74  */
75 static const struct pxa_freqs pxa255_run_freqs[] =
76 {
77         /* CPU   MEMBUS            run  turbo PXbus SDRAM */
78         { 99500, -1, -1},       /*  99,   99,   50,   50  */
79         {132700, -1, -1},       /* 133,  133,   66,   66  */
80         {199100, -1, -1},       /* 199,  199,   99,   99  */
81         {265400, -1, -1},       /* 265,  265,  133,   66  */
82         {331800, -1, -1},       /* 331,  331,  166,   83  */
83         {398100, -1, -1},       /* 398,  398,  196,   99  */
84 };
85
86 /* Use the turbo mode frequencies for the CPUFREQ_POLICY_POWERSAVE policy */
87 static const struct pxa_freqs pxa255_turbo_freqs[] =
88 {
89         /* CPU                     run  turbo PXbus SDRAM */
90         { 99500, -1, -1},       /*  99,   99,   50,   50  */
91         {199100, -1, -1},       /*  99,  199,   50,   99  */
92         {298500, -1, -1},       /*  99,  287,   50,   99  */
93         {298600, -1, -1},       /* 199,  287,   99,   99  */
94         {398100, -1, -1},       /* 199,  398,   99,   99  */
95 };
96
97 #define NUM_PXA25x_RUN_FREQS ARRAY_SIZE(pxa255_run_freqs)
98 #define NUM_PXA25x_TURBO_FREQS ARRAY_SIZE(pxa255_turbo_freqs)
99
100 static struct cpufreq_frequency_table
101         pxa255_run_freq_table[NUM_PXA25x_RUN_FREQS+1];
102 static struct cpufreq_frequency_table
103         pxa255_turbo_freq_table[NUM_PXA25x_TURBO_FREQS+1];
104
105 static unsigned int pxa255_turbo_table;
106 module_param(pxa255_turbo_table, uint, 0);
107 MODULE_PARM_DESC(pxa255_turbo_table, "Selects the frequency table (0 = run table, !0 = turbo table)");
108
109 static struct pxa_freqs pxa27x_freqs[] = {
110         {104000,  900000, 1705000 },
111         {156000, 1000000, 1705000 },
112         {208000, 1180000, 1705000 },
113         {312000, 1250000, 1705000 },
114         {416000, 1350000, 1705000 },
115         {520000, 1450000, 1705000 },
116         {624000, 1550000, 1705000 }
117 };
118
119 #define NUM_PXA27x_FREQS ARRAY_SIZE(pxa27x_freqs)
120 static struct cpufreq_frequency_table
121         pxa27x_freq_table[NUM_PXA27x_FREQS+1];
122
123 extern unsigned get_clk_frequency_khz(int info);
124
125 #ifdef CONFIG_REGULATOR
126
127 static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
128 {
129         int ret = 0;
130         int vmin, vmax;
131
132         if (!cpu_is_pxa27x())
133                 return 0;
134
135         vmin = pxa_freq->vmin;
136         vmax = pxa_freq->vmax;
137         if ((vmin == -1) || (vmax == -1))
138                 return 0;
139
140         ret = regulator_set_voltage(vcc_core, vmin, vmax);
141         if (ret)
142                 pr_err("Failed to set vcc_core in [%dmV..%dmV]\n", vmin, vmax);
143         return ret;
144 }
145
146 static void pxa_cpufreq_init_voltages(void)
147 {
148         vcc_core = regulator_get(NULL, "vcc_core");
149         if (IS_ERR(vcc_core)) {
150                 pr_info("Didn't find vcc_core regulator\n");
151                 vcc_core = NULL;
152         } else {
153                 pr_info("Found vcc_core regulator\n");
154         }
155 }
156 #else
157 static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
158 {
159         return 0;
160 }
161
162 static void pxa_cpufreq_init_voltages(void) { }
163 #endif
164
165 static void find_freq_tables(struct cpufreq_frequency_table **freq_table,
166                              const struct pxa_freqs **pxa_freqs)
167 {
168         if (cpu_is_pxa25x()) {
169                 if (!pxa255_turbo_table) {
170                         *pxa_freqs = pxa255_run_freqs;
171                         *freq_table = pxa255_run_freq_table;
172                 } else {
173                         *pxa_freqs = pxa255_turbo_freqs;
174                         *freq_table = pxa255_turbo_freq_table;
175                 }
176         } else if (cpu_is_pxa27x()) {
177                 *pxa_freqs = pxa27x_freqs;
178                 *freq_table = pxa27x_freq_table;
179         } else {
180                 BUG();
181         }
182 }
183
184 static void pxa27x_guess_max_freq(void)
185 {
186         if (!pxa27x_maxfreq) {
187                 pxa27x_maxfreq = 416000;
188                 pr_info("PXA CPU 27x max frequency not defined (pxa27x_maxfreq), assuming pxa271 with %dkHz maxfreq\n",
189                         pxa27x_maxfreq);
190         } else {
191                 pxa27x_maxfreq *= 1000;
192         }
193 }
194
195 static unsigned int pxa_cpufreq_get(unsigned int cpu)
196 {
197         struct pxa_cpufreq_data *data = cpufreq_get_driver_data();
198
199         return (unsigned int) clk_get_rate(data->clk_core) / 1000;
200 }
201
202 static int pxa_set_target(struct cpufreq_policy *policy, unsigned int idx)
203 {
204         struct cpufreq_frequency_table *pxa_freqs_table;
205         const struct pxa_freqs *pxa_freq_settings;
206         struct pxa_cpufreq_data *data = cpufreq_get_driver_data();
207         unsigned int new_freq_cpu;
208         int ret = 0;
209
210         /* Get the current policy */
211         find_freq_tables(&pxa_freqs_table, &pxa_freq_settings);
212
213         new_freq_cpu = pxa_freq_settings[idx].khz;
214
215         if (freq_debug)
216                 pr_debug("Changing CPU frequency from %d Mhz to %d Mhz\n",
217                          policy->cur / 1000,  new_freq_cpu / 1000);
218
219         if (vcc_core && new_freq_cpu > policy->cur) {
220                 ret = pxa_cpufreq_change_voltage(&pxa_freq_settings[idx]);
221                 if (ret)
222                         return ret;
223         }
224
225         clk_set_rate(data->clk_core, new_freq_cpu * 1000);
226
227         /*
228          * Even if voltage setting fails, we don't report it, as the frequency
229          * change succeeded. The voltage reduction is not a critical failure,
230          * only power savings will suffer from this.
231          *
232          * Note: if the voltage change fails, and a return value is returned, a
233          * bug is triggered (seems a deadlock). Should anybody find out where,
234          * the "return 0" should become a "return ret".
235          */
236         if (vcc_core && new_freq_cpu < policy->cur)
237                 ret = pxa_cpufreq_change_voltage(&pxa_freq_settings[idx]);
238
239         return 0;
240 }
241
242 static int pxa_cpufreq_init(struct cpufreq_policy *policy)
243 {
244         int i;
245         unsigned int freq;
246         struct cpufreq_frequency_table *pxa255_freq_table;
247         const struct pxa_freqs *pxa255_freqs;
248
249         /* try to guess pxa27x cpu */
250         if (cpu_is_pxa27x())
251                 pxa27x_guess_max_freq();
252
253         pxa_cpufreq_init_voltages();
254
255         /* set default policy and cpuinfo */
256         policy->cpuinfo.transition_latency = 1000; /* FIXME: 1 ms, assumed */
257
258         /* Generate pxa25x the run cpufreq_frequency_table struct */
259         for (i = 0; i < NUM_PXA25x_RUN_FREQS; i++) {
260                 pxa255_run_freq_table[i].frequency = pxa255_run_freqs[i].khz;
261                 pxa255_run_freq_table[i].driver_data = i;
262         }
263         pxa255_run_freq_table[i].frequency = CPUFREQ_TABLE_END;
264
265         /* Generate pxa25x the turbo cpufreq_frequency_table struct */
266         for (i = 0; i < NUM_PXA25x_TURBO_FREQS; i++) {
267                 pxa255_turbo_freq_table[i].frequency =
268                         pxa255_turbo_freqs[i].khz;
269                 pxa255_turbo_freq_table[i].driver_data = i;
270         }
271         pxa255_turbo_freq_table[i].frequency = CPUFREQ_TABLE_END;
272
273         pxa255_turbo_table = !!pxa255_turbo_table;
274
275         /* Generate the pxa27x cpufreq_frequency_table struct */
276         for (i = 0; i < NUM_PXA27x_FREQS; i++) {
277                 freq = pxa27x_freqs[i].khz;
278                 if (freq > pxa27x_maxfreq)
279                         break;
280                 pxa27x_freq_table[i].frequency = freq;
281                 pxa27x_freq_table[i].driver_data = i;
282         }
283         pxa27x_freq_table[i].driver_data = i;
284         pxa27x_freq_table[i].frequency = CPUFREQ_TABLE_END;
285
286         /*
287          * Set the policy's minimum and maximum frequencies from the tables
288          * just constructed.  This sets cpuinfo.mxx_freq, min and max.
289          */
290         if (cpu_is_pxa25x()) {
291                 find_freq_tables(&pxa255_freq_table, &pxa255_freqs);
292                 pr_info("using %s frequency table\n",
293                         pxa255_turbo_table ? "turbo" : "run");
294
295                 policy->freq_table = pxa255_freq_table;
296         }
297         else if (cpu_is_pxa27x()) {
298                 policy->freq_table = pxa27x_freq_table;
299         }
300
301         pr_info("frequency change support initialized\n");
302
303         return 0;
304 }
305
306 static struct cpufreq_driver pxa_cpufreq_driver = {
307         .flags  = CPUFREQ_NEED_INITIAL_FREQ_CHECK,
308         .verify = cpufreq_generic_frequency_table_verify,
309         .target_index = pxa_set_target,
310         .init   = pxa_cpufreq_init,
311         .get    = pxa_cpufreq_get,
312         .name   = "PXA2xx",
313         .driver_data = &pxa_cpufreq_data,
314 };
315
316 static int __init pxa_cpu_init(void)
317 {
318         int ret = -ENODEV;
319
320         pxa_cpufreq_data.clk_core = clk_get_sys(NULL, "core");
321         if (IS_ERR(pxa_cpufreq_data.clk_core))
322                 return PTR_ERR(pxa_cpufreq_data.clk_core);
323
324         if (cpu_is_pxa25x() || cpu_is_pxa27x())
325                 ret = cpufreq_register_driver(&pxa_cpufreq_driver);
326         return ret;
327 }
328
329 static void __exit pxa_cpu_exit(void)
330 {
331         cpufreq_unregister_driver(&pxa_cpufreq_driver);
332 }
333
334
335 MODULE_AUTHOR("Intrinsyc Software Inc.");
336 MODULE_DESCRIPTION("CPU frequency changing driver for the PXA architecture");
337 MODULE_LICENSE("GPL");
338 module_init(pxa_cpu_init);
339 module_exit(pxa_cpu_exit);