[net-next-2.6.git] / arch / arm / mach-integrator / cpu.c

/*
 *  linux/arch/arm/mach-integrator/cpu.c
 *
 *  Copyright (C) 2001-2002 Deep Blue Solutions Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * CPU support functions
 */
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/cpufreq.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/init.h>
#include <linux/io.h>

#include <mach/hardware.h>
#include <mach/platform.h>
#include <asm/mach-types.h>
#include <asm/hardware/icst525.h>

static struct cpufreq_driver integrator_driver;

#define CM_ID  	IO_ADDRESS(INTEGRATOR_HDR_ID)
#define CM_OSC	IO_ADDRESS(INTEGRATOR_HDR_OSC)
#define CM_STAT IO_ADDRESS(INTEGRATOR_HDR_STAT)
#define CM_LOCK IO_ADDRESS(INTEGRATOR_HDR_LOCK)

static const struct icst525_params lclk_params = {
	.ref		= 24000,
	.vco_max	= 320000,
	.vd_min		= 8,
	.vd_max		= 132,
	.rd_min		= 24,
	.rd_max		= 24,
};

static const struct icst525_params cclk_params = {
	.ref		= 24000,
	.vco_max	= 320000,
	.vd_min		= 12,
	.vd_max		= 160,
	.rd_min		= 24,
	.rd_max		= 24,
};

/*
 * Validate the speed policy.
 */
static int integrator_verify_policy(struct cpufreq_policy *policy)
{
	struct icst525_vco vco;

	cpufreq_verify_within_limits(policy, 
				     policy->cpuinfo.min_freq, 
				     policy->cpuinfo.max_freq);

	vco = icst525_khz_to_vco(&cclk_params, policy->max);
	policy->max = icst525_khz(&cclk_params, vco);

	vco = icst525_khz_to_vco(&cclk_params, policy->min);
	policy->min = icst525_khz(&cclk_params, vco);

	cpufreq_verify_within_limits(policy, 
				     policy->cpuinfo.min_freq, 
				     policy->cpuinfo.max_freq);

	return 0;
}


static int integrator_set_target(struct cpufreq_policy *policy,
				 unsigned int target_freq,
				 unsigned int relation)
{
	cpumask_t cpus_allowed;
	int cpu = policy->cpu;
	struct icst525_vco vco;
	struct cpufreq_freqs freqs;
	u_int cm_osc;

	/*
	 * Save this threads cpus_allowed mask.
	 */
	cpus_allowed = current->cpus_allowed;

	/*
	 * Bind to the specified CPU.  When this call returns,
	 * we should be running on the right CPU.
	 */
	set_cpus_allowed(current, cpumask_of_cpu(cpu));
	BUG_ON(cpu != smp_processor_id());

	/* get current setting */
	cm_osc = __raw_readl(CM_OSC);

	if (machine_is_integrator()) {
		vco.s = (cm_osc >> 8) & 7;
	} else if (machine_is_cintegrator()) {
		vco.s = 1;
	}
	vco.v = cm_osc & 255;
	vco.r = 22;
	freqs.old = icst525_khz(&cclk_params, vco);

	/* icst525_khz_to_vco rounds down -- so we need the next
	 * larger freq in case of CPUFREQ_RELATION_L.
	 */
	if (relation == CPUFREQ_RELATION_L)
		target_freq += 999;
	if (target_freq > policy->max)
		target_freq = policy->max;
	vco = icst525_khz_to_vco(&cclk_params, target_freq);
	freqs.new = icst525_khz(&cclk_params, vco);

	freqs.cpu = policy->cpu;

	if (freqs.old == freqs.new) {
		set_cpus_allowed(current, cpus_allowed);
		return 0;
	}

	cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);

	cm_osc = __raw_readl(CM_OSC);

	if (machine_is_integrator()) {
		cm_osc &= 0xfffff800;
		cm_osc |= vco.s << 8;
	} else if (machine_is_cintegrator()) {
		cm_osc &= 0xffffff00;
	}
	cm_osc |= vco.v;

	__raw_writel(0xa05f, CM_LOCK);
	__raw_writel(cm_osc, CM_OSC);
	__raw_writel(0, CM_LOCK);

	/*
	 * Restore the CPUs allowed mask.
	 */
	set_cpus_allowed(current, cpus_allowed);

	cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);

	return 0;
}

static unsigned int integrator_get(unsigned int cpu)
{
	cpumask_t cpus_allowed;
	unsigned int current_freq;
	u_int cm_osc;
	struct icst525_vco vco;

	cpus_allowed = current->cpus_allowed;

	set_cpus_allowed(current, cpumask_of_cpu(cpu));
	BUG_ON(cpu != smp_processor_id());

	/* detect memory etc. */
	cm_osc = __raw_readl(CM_OSC);

	if (machine_is_integrator()) {
		vco.s = (cm_osc >> 8) & 7;
	} else if (machine_is_cintegrator()) {
		vco.s = 1;
	}
	vco.v = cm_osc & 255;
	vco.r = 22;

	current_freq = icst525_khz(&cclk_params, vco); /* current freq */

	set_cpus_allowed(current, cpus_allowed);

	return current_freq;
}

static int integrator_cpufreq_init(struct cpufreq_policy *policy)
{

	/* set default policy and cpuinfo */
	policy->cpuinfo.max_freq = 160000;
	policy->cpuinfo.min_freq = 12000;
	policy->cpuinfo.transition_latency = 1000000; /* 1 ms, assumed */
	policy->cur = policy->min = policy->max = integrator_get(policy->cpu);

	return 0;
}

static struct cpufreq_driver integrator_driver = {
	.verify		= integrator_verify_policy,
	.target		= integrator_set_target,
	.get		= integrator_get,
	.init		= integrator_cpufreq_init,
	.name		= "integrator",
};

static int __init integrator_cpu_init(void)
{
	return cpufreq_register_driver(&integrator_driver);
}

static void __exit integrator_cpu_exit(void)
{
	cpufreq_unregister_driver(&integrator_driver);
}

MODULE_AUTHOR ("Russell M. King");
MODULE_DESCRIPTION ("cpufreq driver for ARM Integrator CPUs");
MODULE_LICENSE ("GPL");

module_init(integrator_cpu_init);
module_exit(integrator_cpu_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/mach-integrator/cpu.c
	3	*
	4	* Copyright (C) 2001-2002 Deep Blue Solutions Ltd.
	5	*
1da177e4 LT	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	* CPU support functions
	11	*/
	12	#include <linux/module.h>
	13	#include <linux/types.h>
	14	#include <linux/kernel.h>
	15	#include <linux/cpufreq.h>
	16	#include <linux/slab.h>
	17	#include <linux/sched.h>
	18	#include <linux/smp.h>
	19	#include <linux/init.h>
fced80c7	20	#include <linux/io.h>
1da177e4	21
a09e64fb	22	#include <mach/hardware.h>
a285edcf	23	#include <mach/platform.h>
1da177e4 LT	24	#include <asm/mach-types.h>
	25	#include <asm/hardware/icst525.h>
	26
	27	static struct cpufreq_driver integrator_driver;
	28
b830b9b5 RK	29	#define CM_ID IO_ADDRESS(INTEGRATOR_HDR_ID)
	30	#define CM_OSC IO_ADDRESS(INTEGRATOR_HDR_OSC)
	31	#define CM_STAT IO_ADDRESS(INTEGRATOR_HDR_STAT)
	32	#define CM_LOCK IO_ADDRESS(INTEGRATOR_HDR_LOCK)
1da177e4 LT	33
	34	static const struct icst525_params lclk_params = {
	35	.ref = 24000,
	36	.vco_max = 320000,
	37	.vd_min = 8,
	38	.vd_max = 132,
	39	.rd_min = 24,
	40	.rd_max = 24,
	41	};
	42
	43	static const struct icst525_params cclk_params = {
	44	.ref = 24000,
	45	.vco_max = 320000,
	46	.vd_min = 12,
	47	.vd_max = 160,
	48	.rd_min = 24,
	49	.rd_max = 24,
	50	};
	51
	52	/*
	53	* Validate the speed policy.
	54	*/
	55	static int integrator_verify_policy(struct cpufreq_policy *policy)
	56	{
	57	struct icst525_vco vco;
	58
	59	cpufreq_verify_within_limits(policy,
	60	policy->cpuinfo.min_freq,
	61	policy->cpuinfo.max_freq);
	62
	63	vco = icst525_khz_to_vco(&cclk_params, policy->max);
	64	policy->max = icst525_khz(&cclk_params, vco);
	65
	66	vco = icst525_khz_to_vco(&cclk_params, policy->min);
	67	policy->min = icst525_khz(&cclk_params, vco);
	68
	69	cpufreq_verify_within_limits(policy,
	70	policy->cpuinfo.min_freq,
	71	policy->cpuinfo.max_freq);
	72
	73	return 0;
	74	}
	75
	76
	77	static int integrator_set_target(struct cpufreq_policy *policy,
	78	unsigned int target_freq,
	79	unsigned int relation)
	80	{
	81	cpumask_t cpus_allowed;
	82	int cpu = policy->cpu;
	83	struct icst525_vco vco;
	84	struct cpufreq_freqs freqs;
	85	u_int cm_osc;
	86
	87	/*
	88	* Save this threads cpus_allowed mask.
	89	*/
	90	cpus_allowed = current->cpus_allowed;
	91
	92	/*
	93	* Bind to the specified CPU. When this call returns,
	94	* we should be running on the right CPU.
	95	*/
	96	set_cpus_allowed(current, cpumask_of_cpu(cpu));
97	BUG_ON(cpu != smp_processor_id());
98
99	/* get current setting */
100	cm_osc = __raw_readl(CM_OSC);
101
102	if (machine_is_integrator()) {
103	vco.s = (cm_osc >> 8) & 7;
104	} else if (machine_is_cintegrator()) {
105	vco.s = 1;
106	}
107	vco.v = cm_osc & 255;
108	vco.r = 22;
109	freqs.old = icst525_khz(&cclk_params, vco);
110
111	/* icst525_khz_to_vco rounds down -- so we need the next
112	* larger freq in case of CPUFREQ_RELATION_L.
113	*/
114	if (relation == CPUFREQ_RELATION_L)
115	target_freq += 999;
116	if (target_freq > policy->max)
117	target_freq = policy->max;
118	vco = icst525_khz_to_vco(&cclk_params, target_freq);
119	freqs.new = icst525_khz(&cclk_params, vco);
120
121	freqs.cpu = policy->cpu;
122
123	if (freqs.old == freqs.new) {
124	set_cpus_allowed(current, cpus_allowed);
125	return 0;
126	}
127
128	cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
129
130	cm_osc = __raw_readl(CM_OSC);
131
132	if (machine_is_integrator()) {
133	cm_osc &= 0xfffff800;
134	cm_osc \|= vco.s << 8;
135	} else if (machine_is_cintegrator()) {
136	cm_osc &= 0xffffff00;
137	}
138	cm_osc \|= vco.v;
139
140	__raw_writel(0xa05f, CM_LOCK);
141	__raw_writel(cm_osc, CM_OSC);
142	__raw_writel(0, CM_LOCK);
143
144	/*
145	* Restore the CPUs allowed mask.
146	*/
147	set_cpus_allowed(current, cpus_allowed);
148
149	cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
150
151	return 0;
152	}
153
154	static unsigned int integrator_get(unsigned int cpu)
155	{
156	cpumask_t cpus_allowed;
157	unsigned int current_freq;
158	u_int cm_osc;
159	struct icst525_vco vco;
160
161	cpus_allowed = current->cpus_allowed;
162
163	set_cpus_allowed(current, cpumask_of_cpu(cpu));
164	BUG_ON(cpu != smp_processor_id());
165
166	/* detect memory etc. */
167	cm_osc = __raw_readl(CM_OSC);
168
169	if (machine_is_integrator()) {
170	vco.s = (cm_osc >> 8) & 7;
171	} else if (machine_is_cintegrator()) {
172	vco.s = 1;
173	}
174	vco.v = cm_osc & 255;
175	vco.r = 22;
176
177	current_freq = icst525_khz(&cclk_params, vco); /* current freq */
178
179	set_cpus_allowed(current, cpus_allowed);
180
181	return current_freq;
182	}
183
184	static int integrator_cpufreq_init(struct cpufreq_policy *policy)
185	{
186
187	/* set default policy and cpuinfo */
1da177e4 LT	188	policy->cpuinfo.max_freq = 160000;
	189	policy->cpuinfo.min_freq = 12000;
	190	policy->cpuinfo.transition_latency = 1000000; /* 1 ms, assumed */
	191	policy->cur = policy->min = policy->max = integrator_get(policy->cpu);
	192
	193	return 0;
	194	}
	195
	196	static struct cpufreq_driver integrator_driver = {
	197	.verify = integrator_verify_policy,
	198	.target = integrator_set_target,
	199	.get = integrator_get,
	200	.init = integrator_cpufreq_init,
	201	.name = "integrator",
	202	};
	203
	204	static int __init integrator_cpu_init(void)
	205	{
	206	return cpufreq_register_driver(&integrator_driver);
	207	}
	208
	209	static void __exit integrator_cpu_exit(void)
	210	{
	211	cpufreq_unregister_driver(&integrator_driver);
	212	}
	213
	214	MODULE_AUTHOR ("Russell M. King");
	215	MODULE_DESCRIPTION ("cpufreq driver for ARM Integrator CPUs");
	216	MODULE_LICENSE ("GPL");
	217
	218	module_init(integrator_cpu_init);
	219	module_exit(integrator_cpu_exit);