pxa2xx-cpufreq.c 13.4 KB
Newer Older
R
Russell King 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*
 *  Copyright (C) 2002,2003 Intrinsyc Software
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * History:
 *   31-Jul-2002 : Initial version [FB]
 *   29-Jan-2003 : added PXA255 support [FB]
 *   20-Apr-2003 : ported to v2.5 (Dustin McIntire, Sensoria Corp.)
 *
 * Note:
 *   This driver may change the memory bus clock rate, but will not do any
 *   platform specific access timing changes... for example if you have flash
 *   memory connected to CS0, you will need to register a platform specific
 *   notifier which will adjust the memory access strobes to maintain a
 *   minimum strobe width.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
37 38
#include <linux/err.h>
#include <linux/regulator/consumer.h>
39
#include <linux/io.h>
R
Russell King 已提交
40

41
#include <mach/pxa2xx-regs.h>
42
#include <mach/smemc.h>
R
Russell King 已提交
43 44 45

#ifdef DEBUG
static unsigned int freq_debug;
46
module_param(freq_debug, uint, 0);
R
Russell King 已提交
47 48 49 50 51
MODULE_PARM_DESC(freq_debug, "Set the debug messages to on=1/off=0");
#else
#define freq_debug  0
#endif

52 53
static struct regulator *vcc_core;

54 55 56 57 58
static unsigned int pxa27x_maxfreq;
module_param(pxa27x_maxfreq, uint, 0);
MODULE_PARM_DESC(pxa27x_maxfreq, "Set the pxa27x maxfreq in MHz"
		 "(typically 624=>pxa270, 416=>pxa271, 520=>pxa272)");

59
struct pxa_freqs {
R
Russell King 已提交
60 61 62 63
	unsigned int khz;
	unsigned int membus;
	unsigned int cccr;
	unsigned int div2;
64
	unsigned int cclkcfg;
65 66
	int vmin;
	int vmax;
67
};
R
Russell King 已提交
68 69

/* Define the refresh period in mSec for the SDRAM and the number of rows */
70
#define SDRAM_TREF	64	/* standard 64ms SDRAM */
71
static unsigned int sdram_rows;
R
Russell King 已提交
72

73 74
#define CCLKCFG_TURBO		0x1
#define CCLKCFG_FCS		0x2
75 76
#define CCLKCFG_HALFTURBO	0x4
#define CCLKCFG_FASTBUS		0x8
77 78
#define MDREFR_DB2_MASK		(MDREFR_K2DB2 | MDREFR_K1DB2)
#define MDREFR_DRI_MASK		0xFFF
R
Russell King 已提交
79

80 81 82
#define MDCNFG_DRAC2(mdcnfg) (((mdcnfg) >> 21) & 0x3)
#define MDCNFG_DRAC0(mdcnfg) (((mdcnfg) >> 5) & 0x3)

83 84 85
/*
 * PXA255 definitions
 */
R
Russell King 已提交
86
/* Use the run mode frequencies for the CPUFREQ_POLICY_PERFORMANCE policy */
87 88
#define CCLKCFG			CCLKCFG_TURBO | CCLKCFG_FCS

89
static const struct pxa_freqs pxa255_run_freqs[] =
R
Russell King 已提交
90
{
91 92 93 94 95 96 97
	/* CPU   MEMBUS  CCCR  DIV2 CCLKCFG	           run  turbo PXbus SDRAM */
	{ 99500,  99500, 0x121, 1,  CCLKCFG, -1, -1},	/*  99,   99,   50,   50  */
	{132700, 132700, 0x123, 1,  CCLKCFG, -1, -1},	/* 133,  133,   66,   66  */
	{199100,  99500, 0x141, 0,  CCLKCFG, -1, -1},	/* 199,  199,   99,   99  */
	{265400, 132700, 0x143, 1,  CCLKCFG, -1, -1},	/* 265,  265,  133,   66  */
	{331800, 165900, 0x145, 1,  CCLKCFG, -1, -1},	/* 331,  331,  166,   83  */
	{398100,  99500, 0x161, 0,  CCLKCFG, -1, -1},	/* 398,  398,  196,   99  */
R
Russell King 已提交
98 99 100
};

/* Use the turbo mode frequencies for the CPUFREQ_POLICY_POWERSAVE policy */
101
static const struct pxa_freqs pxa255_turbo_freqs[] =
R
Russell King 已提交
102
{
103
	/* CPU   MEMBUS  CCCR  DIV2 CCLKCFG	   run  turbo PXbus SDRAM */
104 105 106 107 108
	{ 99500, 99500,  0x121, 1,  CCLKCFG, -1, -1},	/*  99,   99,   50,   50  */
	{199100, 99500,  0x221, 0,  CCLKCFG, -1, -1},	/*  99,  199,   50,   99  */
	{298500, 99500,  0x321, 0,  CCLKCFG, -1, -1},	/*  99,  287,   50,   99  */
	{298600, 99500,  0x1c1, 0,  CCLKCFG, -1, -1},	/* 199,  287,   99,   99  */
	{398100, 99500,  0x241, 0,  CCLKCFG, -1, -1},	/* 199,  398,   99,   99  */
R
Russell King 已提交
109 110
};

111 112 113 114 115
#define NUM_PXA25x_RUN_FREQS ARRAY_SIZE(pxa255_run_freqs)
#define NUM_PXA25x_TURBO_FREQS ARRAY_SIZE(pxa255_turbo_freqs)

static struct cpufreq_frequency_table
	pxa255_run_freq_table[NUM_PXA25x_RUN_FREQS+1];
116
static struct cpufreq_frequency_table
117 118
	pxa255_turbo_freq_table[NUM_PXA25x_TURBO_FREQS+1];

119 120 121 122
static unsigned int pxa255_turbo_table;
module_param(pxa255_turbo_table, uint, 0);
MODULE_PARM_DESC(pxa255_turbo_table, "Selects the frequency table (0 = run table, !0 = turbo table)");

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
/*
 * PXA270 definitions
 *
 * For the PXA27x:
 * Control variables are A, L, 2N for CCCR; B, HT, T for CLKCFG.
 *
 * A = 0 => memory controller clock from table 3-7,
 * A = 1 => memory controller clock = system bus clock
 * Run mode frequency	= 13 MHz * L
 * Turbo mode frequency = 13 MHz * L * N
 * System bus frequency = 13 MHz * L / (B + 1)
 *
 * In CCCR:
 * A = 1
 * L = 16	  oscillator to run mode ratio
 * 2N = 6	  2 * (turbo mode to run mode ratio)
 *
 * In CCLKCFG:
 * B = 1	  Fast bus mode
 * HT = 0	  Half-Turbo mode
 * T = 1	  Turbo mode
 *
 * For now, just support some of the combinations in table 3-7 of
 * PXA27x Processor Family Developer's Manual to simplify frequency
 * change sequences.
 */
#define PXA27x_CCCR(A, L, N2) (A << 25 | N2 << 7 | L)
#define CCLKCFG2(B, HT, T) \
  (CCLKCFG_FCS | \
   ((B)  ? CCLKCFG_FASTBUS : 0) | \
   ((HT) ? CCLKCFG_HALFTURBO : 0) | \
   ((T)  ? CCLKCFG_TURBO : 0))

156
static struct pxa_freqs pxa27x_freqs[] = {
157
	{104000, 104000, PXA27x_CCCR(1,	 8, 2), 0, CCLKCFG2(1, 0, 1),  900000, 1705000 },
158
	{156000, 104000, PXA27x_CCCR(1,	 8, 3), 0, CCLKCFG2(1, 0, 1), 1000000, 1705000 },
159 160 161 162 163
	{208000, 208000, PXA27x_CCCR(0, 16, 2), 1, CCLKCFG2(0, 0, 1), 1180000, 1705000 },
	{312000, 208000, PXA27x_CCCR(1, 16, 3), 1, CCLKCFG2(1, 0, 1), 1250000, 1705000 },
	{416000, 208000, PXA27x_CCCR(1, 16, 4), 1, CCLKCFG2(1, 0, 1), 1350000, 1705000 },
	{520000, 208000, PXA27x_CCCR(1, 16, 5), 1, CCLKCFG2(1, 0, 1), 1450000, 1705000 },
	{624000, 208000, PXA27x_CCCR(1, 16, 6), 1, CCLKCFG2(1, 0, 1), 1550000, 1705000 }
164 165 166 167 168
};

#define NUM_PXA27x_FREQS ARRAY_SIZE(pxa27x_freqs)
static struct cpufreq_frequency_table
	pxa27x_freq_table[NUM_PXA27x_FREQS+1];
R
Russell King 已提交
169 170 171

extern unsigned get_clk_frequency_khz(int info);

172 173
#ifdef CONFIG_REGULATOR

174
static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
{
	int ret = 0;
	int vmin, vmax;

	if (!cpu_is_pxa27x())
		return 0;

	vmin = pxa_freq->vmin;
	vmax = pxa_freq->vmax;
	if ((vmin == -1) || (vmax == -1))
		return 0;

	ret = regulator_set_voltage(vcc_core, vmin, vmax);
	if (ret)
		pr_err("cpufreq: Failed to set vcc_core in [%dmV..%dmV]\n",
		       vmin, vmax);
	return ret;
}

194
static void __init pxa_cpufreq_init_voltages(void)
195 196 197 198 199 200 201 202 203 204
{
	vcc_core = regulator_get(NULL, "vcc_core");
	if (IS_ERR(vcc_core)) {
		pr_info("cpufreq: Didn't find vcc_core regulator\n");
		vcc_core = NULL;
	} else {
		pr_info("cpufreq: Found vcc_core regulator\n");
	}
}
#else
205
static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
206 207 208 209
{
	return 0;
}

210
static void __init pxa_cpufreq_init_voltages(void) { }
211 212
#endif

213
static void find_freq_tables(struct cpufreq_frequency_table **freq_table,
214
			     const struct pxa_freqs **pxa_freqs)
215 216
{
	if (cpu_is_pxa25x()) {
217
		if (!pxa255_turbo_table) {
218 219
			*pxa_freqs = pxa255_run_freqs;
			*freq_table = pxa255_run_freq_table;
220
		} else {
221 222 223
			*pxa_freqs = pxa255_turbo_freqs;
			*freq_table = pxa255_turbo_freq_table;
		}
224
	} else if (cpu_is_pxa27x()) {
225 226
		*pxa_freqs = pxa27x_freqs;
		*freq_table = pxa27x_freq_table;
227 228
	} else {
		BUG();
229 230 231 232 233 234 235
	}
}

static void pxa27x_guess_max_freq(void)
{
	if (!pxa27x_maxfreq) {
		pxa27x_maxfreq = 416000;
236 237
		pr_info("PXA CPU 27x max frequency not defined (pxa27x_maxfreq), assuming pxa271 with %dkHz maxfreq\n",
			pxa27x_maxfreq);
238 239 240 241 242
	} else {
		pxa27x_maxfreq *= 1000;
	}
}

243 244
static void init_sdram_rows(void)
{
245
	uint32_t mdcnfg = __raw_readl(MDCNFG);
246 247 248 249 250 251 252 253 254 255 256
	unsigned int drac2 = 0, drac0 = 0;

	if (mdcnfg & (MDCNFG_DE2 | MDCNFG_DE3))
		drac2 = MDCNFG_DRAC2(mdcnfg);

	if (mdcnfg & (MDCNFG_DE0 | MDCNFG_DE1))
		drac0 = MDCNFG_DRAC0(mdcnfg);

	sdram_rows = 1 << (11 + max(drac0, drac2));
}

257 258
static u32 mdrefr_dri(unsigned int freq)
{
259
	u32 interval = freq * SDRAM_TREF / sdram_rows;
260

261
	return (interval - (cpu_is_pxa27x() ? 31 : 0)) / 32;
262 263 264 265 266 267 268
}

static unsigned int pxa_cpufreq_get(unsigned int cpu)
{
	return get_clk_frequency_khz(0);
}

269
static int pxa_set_target(struct cpufreq_policy *policy, unsigned int idx)
R
Russell King 已提交
270 271
{
	struct cpufreq_frequency_table *pxa_freqs_table;
272
	const struct pxa_freqs *pxa_freq_settings;
R
Russell King 已提交
273
	unsigned long flags;
274 275
	unsigned int new_freq_cpu, new_freq_mem;
	unsigned int unused, preset_mdrefr, postset_mdrefr, cclkcfg;
276
	int ret = 0;
R
Russell King 已提交
277 278

	/* Get the current policy */
279
	find_freq_tables(&pxa_freqs_table, &pxa_freq_settings);
R
Russell King 已提交
280

281 282
	new_freq_cpu = pxa_freq_settings[idx].khz;
	new_freq_mem = pxa_freq_settings[idx].membus;
R
Russell King 已提交
283 284

	if (freq_debug)
285
		pr_debug("Changing CPU frequency to %d Mhz, (SDRAM %d Mhz)\n",
286
			 new_freq_cpu / 1000, (pxa_freq_settings[idx].div2) ?
287
			 (new_freq_mem / 2000) : (new_freq_mem / 1000));
R
Russell King 已提交
288

289
	if (vcc_core && new_freq_cpu > policy->cur) {
290
		ret = pxa_cpufreq_change_voltage(&pxa_freq_settings[idx]);
291 292 293
		if (ret)
			return ret;
	}
R
Russell King 已提交
294 295

	/* Calculate the next MDREFR.  If we're slowing down the SDRAM clock
296 297
	 * we need to preset the smaller DRI before the change.	 If we're
	 * speeding up we need to set the larger DRI value after the change.
R
Russell King 已提交
298
	 */
299 300
	preset_mdrefr = postset_mdrefr = __raw_readl(MDREFR);
	if ((preset_mdrefr & MDREFR_DRI_MASK) > mdrefr_dri(new_freq_mem)) {
301 302
		preset_mdrefr = (preset_mdrefr & ~MDREFR_DRI_MASK);
		preset_mdrefr |= mdrefr_dri(new_freq_mem);
R
Russell King 已提交
303
	}
304 305
	postset_mdrefr =
		(postset_mdrefr & ~MDREFR_DRI_MASK) | mdrefr_dri(new_freq_mem);
R
Russell King 已提交
306 307 308 309 310 311 312 313 314 315 316 317 318 319

	/* If we're dividing the memory clock by two for the SDRAM clock, this
	 * must be set prior to the change.  Clearing the divide must be done
	 * after the change.
	 */
	if (pxa_freq_settings[idx].div2) {
		preset_mdrefr  |= MDREFR_DB2_MASK;
		postset_mdrefr |= MDREFR_DB2_MASK;
	} else {
		postset_mdrefr &= ~MDREFR_DB2_MASK;
	}

	local_irq_save(flags);

320
	/* Set new the CCCR and prepare CCLKCFG */
321
	writel(pxa_freq_settings[idx].cccr, CCCR);
322
	cclkcfg = pxa_freq_settings[idx].cclkcfg;
R
Russell King 已提交
323 324 325 326

	asm volatile("							\n\
		ldr	r4, [%1]		/* load MDREFR */	\n\
		b	2f						\n\
327
		.align	5						\n\
R
Russell King 已提交
328
1:									\n\
329
		str	%3, [%1]		/* preset the MDREFR */	\n\
R
Russell King 已提交
330
		mcr	p14, 0, %2, c6, c0, 0	/* set CCLKCFG[FCS] */	\n\
331
		str	%4, [%1]		/* postset the MDREFR */ \n\
R
Russell King 已提交
332 333 334 335 336
									\n\
		b	3f						\n\
2:		b	1b						\n\
3:		nop							\n\
	  "
337
		     : "=&r" (unused)
338
		     : "r" (MDREFR), "r" (cclkcfg),
339
		       "r" (preset_mdrefr), "r" (postset_mdrefr)
340
		     : "r4", "r5");
R
Russell King 已提交
341 342
	local_irq_restore(flags);

343 344 345 346 347 348 349 350 351
	/*
	 * Even if voltage setting fails, we don't report it, as the frequency
	 * change succeeded. The voltage reduction is not a critical failure,
	 * only power savings will suffer from this.
	 *
	 * Note: if the voltage change fails, and a return value is returned, a
	 * bug is triggered (seems a deadlock). Should anybody find out where,
	 * the "return 0" should become a "return ret".
	 */
352
	if (vcc_core && new_freq_cpu < policy->cur)
353 354
		ret = pxa_cpufreq_change_voltage(&pxa_freq_settings[idx]);

R
Russell King 已提交
355 356 357
	return 0;
}

358
static int pxa_cpufreq_init(struct cpufreq_policy *policy)
R
Russell King 已提交
359 360
{
	int i;
361
	unsigned int freq;
362
	struct cpufreq_frequency_table *pxa255_freq_table;
363
	const struct pxa_freqs *pxa255_freqs;
364 365 366 367

	/* try to guess pxa27x cpu */
	if (cpu_is_pxa27x())
		pxa27x_guess_max_freq();
R
Russell King 已提交
368

369 370
	pxa_cpufreq_init_voltages();

371 372
	init_sdram_rows();

R
Russell King 已提交
373 374 375
	/* set default policy and cpuinfo */
	policy->cpuinfo.transition_latency = 1000; /* FIXME: 1 ms, assumed */

376 377
	/* Generate pxa25x the run cpufreq_frequency_table struct */
	for (i = 0; i < NUM_PXA25x_RUN_FREQS; i++) {
R
Russell King 已提交
378
		pxa255_run_freq_table[i].frequency = pxa255_run_freqs[i].khz;
379
		pxa255_run_freq_table[i].driver_data = i;
R
Russell King 已提交
380 381
	}
	pxa255_run_freq_table[i].frequency = CPUFREQ_TABLE_END;
382 383 384

	/* Generate pxa25x the turbo cpufreq_frequency_table struct */
	for (i = 0; i < NUM_PXA25x_TURBO_FREQS; i++) {
385 386
		pxa255_turbo_freq_table[i].frequency =
			pxa255_turbo_freqs[i].khz;
387
		pxa255_turbo_freq_table[i].driver_data = i;
R
Russell King 已提交
388 389 390
	}
	pxa255_turbo_freq_table[i].frequency = CPUFREQ_TABLE_END;

391 392
	pxa255_turbo_table = !!pxa255_turbo_table;

393 394 395 396 397 398
	/* Generate the pxa27x cpufreq_frequency_table struct */
	for (i = 0; i < NUM_PXA27x_FREQS; i++) {
		freq = pxa27x_freqs[i].khz;
		if (freq > pxa27x_maxfreq)
			break;
		pxa27x_freq_table[i].frequency = freq;
399
		pxa27x_freq_table[i].driver_data = i;
400
	}
401
	pxa27x_freq_table[i].driver_data = i;
402 403 404 405 406 407
	pxa27x_freq_table[i].frequency = CPUFREQ_TABLE_END;

	/*
	 * Set the policy's minimum and maximum frequencies from the tables
	 * just constructed.  This sets cpuinfo.mxx_freq, min and max.
	 */
408 409 410 411
	if (cpu_is_pxa25x()) {
		find_freq_tables(&pxa255_freq_table, &pxa255_freqs);
		pr_info("PXA255 cpufreq using %s frequency table\n",
			pxa255_turbo_table ? "turbo" : "run");
412

413
		cpufreq_table_validate_and_show(policy, pxa255_freq_table);
414
	}
415
	else if (cpu_is_pxa27x()) {
416
		cpufreq_table_validate_and_show(policy, pxa27x_freq_table);
417
	}
418

419
	pr_info("PXA CPU frequency change support initialized\n");
R
Russell King 已提交
420 421 422 423 424

	return 0;
}

static struct cpufreq_driver pxa_cpufreq_driver = {
425
	.flags	= CPUFREQ_NEED_INITIAL_FREQ_CHECK,
426
	.verify	= cpufreq_generic_frequency_table_verify,
427
	.target_index = pxa_set_target,
R
Russell King 已提交
428
	.init	= pxa_cpufreq_init,
429
	.get	= pxa_cpufreq_get,
430
	.name	= "PXA2xx",
R
Russell King 已提交
431 432 433 434 435
};

static int __init pxa_cpu_init(void)
{
	int ret = -ENODEV;
436
	if (cpu_is_pxa25x() || cpu_is_pxa27x())
R
Russell King 已提交
437 438 439 440 441 442
		ret = cpufreq_register_driver(&pxa_cpufreq_driver);
	return ret;
}

static void __exit pxa_cpu_exit(void)
{
443
	cpufreq_unregister_driver(&pxa_cpufreq_driver);
R
Russell King 已提交
444 445 446
}


447 448
MODULE_AUTHOR("Intrinsyc Software Inc.");
MODULE_DESCRIPTION("CPU frequency changing driver for the PXA architecture");
R
Russell King 已提交
449 450 451
MODULE_LICENSE("GPL");
module_init(pxa_cpu_init);
module_exit(pxa_cpu_exit);