Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cpu.c
Go to the documentation of this file.
1 /*
2  * linux/arch/arm/mach-integrator/cpu.c
3  *
4  * Copyright (C) 2001-2002 Deep Blue Solutions Ltd.
5  *
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/sched.h>
17 #include <linux/smp.h>
18 #include <linux/init.h>
19 #include <linux/io.h>
20 
21 #include <mach/hardware.h>
22 #include <mach/platform.h>
23 #include <asm/mach-types.h>
24 #include <asm/hardware/icst.h>
25 
26 static struct cpufreq_driver integrator_driver;
27 
28 #define CM_ID __io_address(INTEGRATOR_HDR_ID)
29 #define CM_OSC __io_address(INTEGRATOR_HDR_OSC)
30 #define CM_STAT __io_address(INTEGRATOR_HDR_STAT)
31 #define CM_LOCK __io_address(INTEGRATOR_HDR_LOCK)
32 
33 static const struct icst_params lclk_params = {
34  .ref = 24000000,
35  .vco_max = ICST525_VCO_MAX_5V,
36  .vco_min = ICST525_VCO_MIN,
37  .vd_min = 8,
38  .vd_max = 132,
39  .rd_min = 24,
40  .rd_max = 24,
41  .s2div = icst525_s2div,
42  .idx2s = icst525_idx2s,
43 };
44 
45 static const struct icst_params cclk_params = {
46  .ref = 24000000,
47  .vco_max = ICST525_VCO_MAX_5V,
48  .vco_min = ICST525_VCO_MIN,
49  .vd_min = 12,
50  .vd_max = 160,
51  .rd_min = 24,
52  .rd_max = 24,
53  .s2div = icst525_s2div,
54  .idx2s = icst525_idx2s,
55 };
56 
57 /*
58  * Validate the speed policy.
59  */
60 static int integrator_verify_policy(struct cpufreq_policy *policy)
61 {
62  struct icst_vco vco;
63 
64  cpufreq_verify_within_limits(policy,
65  policy->cpuinfo.min_freq,
66  policy->cpuinfo.max_freq);
67 
68  vco = icst_hz_to_vco(&cclk_params, policy->max * 1000);
69  policy->max = icst_hz(&cclk_params, vco) / 1000;
70 
71  vco = icst_hz_to_vco(&cclk_params, policy->min * 1000);
72  policy->min = icst_hz(&cclk_params, vco) / 1000;
73 
74  cpufreq_verify_within_limits(policy,
75  policy->cpuinfo.min_freq,
76  policy->cpuinfo.max_freq);
77 
78  return 0;
79 }
80 
81 
82 static int integrator_set_target(struct cpufreq_policy *policy,
83  unsigned int target_freq,
84  unsigned int relation)
85 {
86  cpumask_t cpus_allowed;
87  int cpu = policy->cpu;
88  struct icst_vco vco;
89  struct cpufreq_freqs freqs;
90  u_int cm_osc;
91 
92  /*
93  * Save this threads cpus_allowed mask.
94  */
95  cpus_allowed = current->cpus_allowed;
96 
97  /*
98  * Bind to the specified CPU. When this call returns,
99  * we should be running on the right CPU.
100  */
101  set_cpus_allowed(current, cpumask_of_cpu(cpu));
102  BUG_ON(cpu != smp_processor_id());
103 
104  /* get current setting */
105  cm_osc = __raw_readl(CM_OSC);
106 
107  if (machine_is_integrator()) {
108  vco.s = (cm_osc >> 8) & 7;
109  } else if (machine_is_cintegrator()) {
110  vco.s = 1;
111  }
112  vco.v = cm_osc & 255;
113  vco.r = 22;
114  freqs.old = icst_hz(&cclk_params, vco) / 1000;
115 
116  /* icst_hz_to_vco rounds down -- so we need the next
117  * larger freq in case of CPUFREQ_RELATION_L.
118  */
119  if (relation == CPUFREQ_RELATION_L)
120  target_freq += 999;
121  if (target_freq > policy->max)
122  target_freq = policy->max;
123  vco = icst_hz_to_vco(&cclk_params, target_freq * 1000);
124  freqs.new = icst_hz(&cclk_params, vco) / 1000;
125 
126  freqs.cpu = policy->cpu;
127 
128  if (freqs.old == freqs.new) {
129  set_cpus_allowed(current, cpus_allowed);
130  return 0;
131  }
132 
134 
135  cm_osc = __raw_readl(CM_OSC);
136 
137  if (machine_is_integrator()) {
138  cm_osc &= 0xfffff800;
139  cm_osc |= vco.s << 8;
140  } else if (machine_is_cintegrator()) {
141  cm_osc &= 0xffffff00;
142  }
143  cm_osc |= vco.v;
144 
145  __raw_writel(0xa05f, CM_LOCK);
146  __raw_writel(cm_osc, CM_OSC);
147  __raw_writel(0, CM_LOCK);
148 
149  /*
150  * Restore the CPUs allowed mask.
151  */
152  set_cpus_allowed(current, cpus_allowed);
153 
155 
156  return 0;
157 }
158 
159 static unsigned int integrator_get(unsigned int cpu)
160 {
161  cpumask_t cpus_allowed;
162  unsigned int current_freq;
163  u_int cm_osc;
164  struct icst_vco vco;
165 
166  cpus_allowed = current->cpus_allowed;
167 
168  set_cpus_allowed(current, cpumask_of_cpu(cpu));
169  BUG_ON(cpu != smp_processor_id());
170 
171  /* detect memory etc. */
172  cm_osc = __raw_readl(CM_OSC);
173 
174  if (machine_is_integrator()) {
175  vco.s = (cm_osc >> 8) & 7;
176  } else {
177  vco.s = 1;
178  }
179  vco.v = cm_osc & 255;
180  vco.r = 22;
181 
182  current_freq = icst_hz(&cclk_params, vco) / 1000; /* current freq */
183 
184  set_cpus_allowed(current, cpus_allowed);
185 
186  return current_freq;
187 }
188 
189 static int integrator_cpufreq_init(struct cpufreq_policy *policy)
190 {
191 
192  /* set default policy and cpuinfo */
193  policy->cpuinfo.max_freq = 160000;
194  policy->cpuinfo.min_freq = 12000;
195  policy->cpuinfo.transition_latency = 1000000; /* 1 ms, assumed */
196  policy->cur = policy->min = policy->max = integrator_get(policy->cpu);
197 
198  return 0;
199 }
200 
201 static struct cpufreq_driver integrator_driver = {
202  .verify = integrator_verify_policy,
203  .target = integrator_set_target,
204  .get = integrator_get,
205  .init = integrator_cpufreq_init,
206  .name = "integrator",
207 };
208 
209 static int __init integrator_cpu_init(void)
210 {
211  return cpufreq_register_driver(&integrator_driver);
212 }
213 
214 static void __exit integrator_cpu_exit(void)
215 {
216  cpufreq_unregister_driver(&integrator_driver);
217 }
218 
219 MODULE_AUTHOR ("Russell M. King");
220 MODULE_DESCRIPTION ("cpufreq driver for ARM Integrator CPUs");
221 MODULE_LICENSE ("GPL");
222 
223 module_init(integrator_cpu_init);
224 module_exit(integrator_cpu_exit);