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