Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * This file was based upon code in Powertweak Linux (http://powertweak.sf.net) | |
14a6650f DJ |
3 | * (C) 2000-2003 Dave Jones, Arjan van de Ven, Janne Pänkälä, |
4 | * Dominik Brodowski. | |
1da177e4 LT |
5 | * |
6 | * Licensed under the terms of the GNU GPL License version 2. | |
7 | * | |
8 | * BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous* | |
9 | */ | |
10 | ||
11 | #include <linux/kernel.h> | |
32ee8c3e | 12 | #include <linux/module.h> |
1da177e4 LT |
13 | #include <linux/init.h> |
14 | #include <linux/cpufreq.h> | |
15 | #include <linux/ioport.h> | |
8d2d2051 PC |
16 | #include <linux/timex.h> |
17 | #include <linux/io.h> | |
1da177e4 | 18 | |
fa8031ae | 19 | #include <asm/cpu_device_id.h> |
14a6650f DJ |
20 | #include <asm/msr.h> |
21 | ||
8d2d2051 PC |
22 | #define POWERNOW_IOPORT 0xfff0 /* it doesn't matter where, as long |
23 | as it is unused */ | |
1da177e4 | 24 | |
14a6650f | 25 | #define PFX "powernow-k6: " |
1da177e4 LT |
26 | static unsigned int busfreq; /* FSB, in 10 kHz */ |
27 | static unsigned int max_multiplier; | |
28 | ||
59b61f4d MP |
29 | static unsigned int param_busfreq = 0; |
30 | static unsigned int param_max_multiplier = 0; | |
31 | ||
32 | module_param_named(max_multiplier, param_max_multiplier, uint, S_IRUGO); | |
33 | MODULE_PARM_DESC(max_multiplier, "Maximum multiplier (allowed values: 20 30 35 40 45 50 55 60)"); | |
34 | ||
35 | module_param_named(bus_frequency, param_busfreq, uint, S_IRUGO); | |
36 | MODULE_PARM_DESC(bus_frequency, "Bus frequency in kHz"); | |
1da177e4 LT |
37 | |
38 | /* Clock ratio multiplied by 10 - see table 27 in AMD#23446 */ | |
39 | static struct cpufreq_frequency_table clock_ratio[] = { | |
45deaa3b MP |
40 | {60, /* 110 -> 6.0x */ 0}, |
41 | {55, /* 011 -> 5.5x */ 0}, | |
1da177e4 | 42 | {50, /* 001 -> 5.0x */ 0}, |
45deaa3b | 43 | {45, /* 000 -> 4.5x */ 0}, |
1da177e4 | 44 | {40, /* 010 -> 4.0x */ 0}, |
1da177e4 | 45 | {35, /* 111 -> 3.5x */ 0}, |
45deaa3b MP |
46 | {30, /* 101 -> 3.0x */ 0}, |
47 | {20, /* 100 -> 2.0x */ 0}, | |
1da177e4 LT |
48 | {0, CPUFREQ_TABLE_END} |
49 | }; | |
50 | ||
45deaa3b MP |
51 | static const u8 index_to_register[8] = { 6, 3, 1, 0, 2, 7, 5, 4 }; |
52 | static const u8 register_to_index[8] = { 3, 2, 4, 1, 7, 6, 0, 5 }; | |
53 | ||
59b61f4d MP |
54 | static const struct { |
55 | unsigned freq; | |
56 | unsigned mult; | |
57 | } usual_frequency_table[] = { | |
58 | { 400000, 40 }, // 100 * 4 | |
59 | { 450000, 45 }, // 100 * 4.5 | |
60 | { 475000, 50 }, // 95 * 5 | |
61 | { 500000, 50 }, // 100 * 5 | |
62 | { 506250, 45 }, // 112.5 * 4.5 | |
63 | { 533500, 55 }, // 97 * 5.5 | |
64 | { 550000, 55 }, // 100 * 5.5 | |
65 | { 562500, 50 }, // 112.5 * 5 | |
66 | { 570000, 60 }, // 95 * 6 | |
67 | { 600000, 60 }, // 100 * 6 | |
68 | { 618750, 55 }, // 112.5 * 5.5 | |
69 | { 660000, 55 }, // 120 * 5.5 | |
70 | { 675000, 60 }, // 112.5 * 6 | |
71 | { 720000, 60 }, // 120 * 6 | |
72 | }; | |
73 | ||
74 | #define FREQ_RANGE 3000 | |
1da177e4 LT |
75 | |
76 | /** | |
77 | * powernow_k6_get_cpu_multiplier - returns the current FSB multiplier | |
78 | * | |
cfc83ee6 | 79 | * Returns the current setting of the frequency multiplier. Core clock |
1da177e4 LT |
80 | * speed is frequency of the Front-Side Bus multiplied with this value. |
81 | */ | |
82 | static int powernow_k6_get_cpu_multiplier(void) | |
83 | { | |
cfc83ee6 | 84 | unsigned long invalue = 0; |
14a6650f | 85 | u32 msrval; |
32ee8c3e | 86 | |
cfc83ee6 MP |
87 | local_irq_disable(); |
88 | ||
1da177e4 LT |
89 | msrval = POWERNOW_IOPORT + 0x1; |
90 | wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */ | |
8d2d2051 | 91 | invalue = inl(POWERNOW_IOPORT + 0x8); |
1da177e4 LT |
92 | msrval = POWERNOW_IOPORT + 0x0; |
93 | wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */ | |
94 | ||
cfc83ee6 MP |
95 | local_irq_enable(); |
96 | ||
45deaa3b | 97 | return clock_ratio[register_to_index[(invalue >> 5)&7]].index; |
1da177e4 LT |
98 | } |
99 | ||
cfc83ee6 MP |
100 | static void powernow_k6_set_cpu_multiplier(unsigned int best_i) |
101 | { | |
102 | unsigned long outvalue, invalue; | |
103 | unsigned long msrval; | |
104 | unsigned long cr0; | |
105 | ||
106 | /* we now need to transform best_i to the BVC format, see AMD#23446 */ | |
107 | ||
108 | /* | |
109 | * The processor doesn't respond to inquiry cycles while changing the | |
110 | * frequency, so we must disable cache. | |
111 | */ | |
112 | local_irq_disable(); | |
113 | cr0 = read_cr0(); | |
114 | write_cr0(cr0 | X86_CR0_CD); | |
115 | wbinvd(); | |
116 | ||
45deaa3b | 117 | outvalue = (1<<12) | (1<<10) | (1<<9) | (index_to_register[best_i]<<5); |
cfc83ee6 MP |
118 | |
119 | msrval = POWERNOW_IOPORT + 0x1; | |
120 | wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */ | |
121 | invalue = inl(POWERNOW_IOPORT + 0x8); | |
122 | invalue = invalue & 0x1f; | |
123 | outvalue = outvalue | invalue; | |
124 | outl(outvalue, (POWERNOW_IOPORT + 0x8)); | |
125 | msrval = POWERNOW_IOPORT + 0x0; | |
126 | wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */ | |
127 | ||
128 | write_cr0(cr0); | |
129 | local_irq_enable(); | |
130 | } | |
1da177e4 LT |
131 | |
132 | /** | |
133 | * powernow_k6_set_state - set the PowerNow! multiplier | |
134 | * @best_i: clock_ratio[best_i] is the target multiplier | |
135 | * | |
136 | * Tries to change the PowerNow! multiplier | |
137 | */ | |
b43a7ffb VK |
138 | static void powernow_k6_set_state(struct cpufreq_policy *policy, |
139 | unsigned int best_i) | |
1da177e4 | 140 | { |
14a6650f | 141 | struct cpufreq_freqs freqs; |
1da177e4 LT |
142 | |
143 | if (clock_ratio[best_i].index > max_multiplier) { | |
14a6650f | 144 | printk(KERN_ERR PFX "invalid target frequency\n"); |
1da177e4 LT |
145 | return; |
146 | } | |
147 | ||
148 | freqs.old = busfreq * powernow_k6_get_cpu_multiplier(); | |
149 | freqs.new = busfreq * clock_ratio[best_i].index; | |
32ee8c3e | 150 | |
b43a7ffb | 151 | cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE); |
1da177e4 | 152 | |
cfc83ee6 | 153 | powernow_k6_set_cpu_multiplier(best_i); |
1da177e4 | 154 | |
b43a7ffb | 155 | cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE); |
1da177e4 LT |
156 | |
157 | return; | |
158 | } | |
159 | ||
160 | ||
161 | /** | |
162 | * powernow_k6_verify - verifies a new CPUfreq policy | |
163 | * @policy: new policy | |
164 | * | |
165 | * Policy must be within lowest and highest possible CPU Frequency, | |
166 | * and at least one possible state must be within min and max. | |
167 | */ | |
168 | static int powernow_k6_verify(struct cpufreq_policy *policy) | |
169 | { | |
170 | return cpufreq_frequency_table_verify(policy, &clock_ratio[0]); | |
171 | } | |
172 | ||
173 | ||
174 | /** | |
175 | * powernow_k6_setpolicy - sets a new CPUFreq policy | |
176 | * @policy: new policy | |
177 | * @target_freq: the target frequency | |
14a6650f DJ |
178 | * @relation: how that frequency relates to achieved frequency |
179 | * (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H) | |
1da177e4 LT |
180 | * |
181 | * sets a new CPUFreq policy | |
182 | */ | |
8d2d2051 | 183 | static int powernow_k6_target(struct cpufreq_policy *policy, |
1da177e4 LT |
184 | unsigned int target_freq, |
185 | unsigned int relation) | |
186 | { | |
14a6650f | 187 | unsigned int newstate = 0; |
1da177e4 | 188 | |
14a6650f DJ |
189 | if (cpufreq_frequency_table_target(policy, &clock_ratio[0], |
190 | target_freq, relation, &newstate)) | |
1da177e4 LT |
191 | return -EINVAL; |
192 | ||
b43a7ffb | 193 | powernow_k6_set_state(policy, newstate); |
1da177e4 LT |
194 | |
195 | return 0; | |
196 | } | |
197 | ||
1da177e4 LT |
198 | static int powernow_k6_cpu_init(struct cpufreq_policy *policy) |
199 | { | |
14a6650f | 200 | unsigned int i, f; |
1da177e4 | 201 | int result; |
59b61f4d | 202 | unsigned khz; |
1da177e4 LT |
203 | |
204 | if (policy->cpu != 0) | |
205 | return -ENODEV; | |
206 | ||
59b61f4d MP |
207 | max_multiplier = 0; |
208 | khz = cpu_khz; | |
209 | for (i = 0; i < ARRAY_SIZE(usual_frequency_table); i++) { | |
210 | if (khz >= usual_frequency_table[i].freq - FREQ_RANGE && | |
211 | khz <= usual_frequency_table[i].freq + FREQ_RANGE) { | |
212 | khz = usual_frequency_table[i].freq; | |
213 | max_multiplier = usual_frequency_table[i].mult; | |
214 | break; | |
215 | } | |
216 | } | |
217 | if (param_max_multiplier) { | |
218 | for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) { | |
219 | if (clock_ratio[i].index == param_max_multiplier) { | |
220 | max_multiplier = param_max_multiplier; | |
221 | goto have_max_multiplier; | |
222 | } | |
223 | } | |
224 | printk(KERN_ERR "powernow-k6: invalid max_multiplier parameter, valid parameters 20, 30, 35, 40, 45, 50, 55, 60\n"); | |
225 | return -EINVAL; | |
226 | } | |
227 | ||
228 | if (!max_multiplier) { | |
229 | printk(KERN_WARNING "powernow-k6: unknown frequency %u, cannot determine current multiplier\n", khz); | |
230 | printk(KERN_WARNING "powernow-k6: use module parameters max_multiplier and bus_frequency\n"); | |
231 | return -EOPNOTSUPP; | |
232 | } | |
233 | ||
234 | have_max_multiplier: | |
235 | param_max_multiplier = max_multiplier; | |
236 | ||
237 | if (param_busfreq) { | |
238 | if (param_busfreq >= 50000 && param_busfreq <= 150000) { | |
239 | busfreq = param_busfreq / 10; | |
240 | goto have_busfreq; | |
241 | } | |
242 | printk(KERN_ERR "powernow-k6: invalid bus_frequency parameter, allowed range 50000 - 150000 kHz\n"); | |
243 | return -EINVAL; | |
244 | } | |
245 | ||
246 | busfreq = khz / max_multiplier; | |
247 | have_busfreq: | |
248 | param_busfreq = busfreq * 10; | |
1da177e4 LT |
249 | |
250 | /* table init */ | |
8d2d2051 | 251 | for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) { |
14a6650f DJ |
252 | f = clock_ratio[i].index; |
253 | if (f > max_multiplier) | |
1da177e4 LT |
254 | clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID; |
255 | else | |
14a6650f | 256 | clock_ratio[i].frequency = busfreq * f; |
1da177e4 LT |
257 | } |
258 | ||
259 | /* cpuinfo and default policy values */ | |
cfc83ee6 | 260 | policy->cpuinfo.transition_latency = 500000; |
1da177e4 LT |
261 | policy->cur = busfreq * max_multiplier; |
262 | ||
263 | result = cpufreq_frequency_table_cpuinfo(policy, clock_ratio); | |
264 | if (result) | |
8d2d2051 | 265 | return result; |
1da177e4 LT |
266 | |
267 | cpufreq_frequency_table_get_attr(clock_ratio, policy->cpu); | |
268 | ||
269 | return 0; | |
270 | } | |
271 | ||
272 | ||
273 | static int powernow_k6_cpu_exit(struct cpufreq_policy *policy) | |
274 | { | |
275 | unsigned int i; | |
8d2d2051 PC |
276 | for (i = 0; i < 8; i++) { |
277 | if (i == max_multiplier) | |
b43a7ffb | 278 | powernow_k6_set_state(policy, i); |
1da177e4 LT |
279 | } |
280 | cpufreq_frequency_table_put_attr(policy->cpu); | |
32ee8c3e | 281 | return 0; |
1da177e4 LT |
282 | } |
283 | ||
284 | static unsigned int powernow_k6_get(unsigned int cpu) | |
285 | { | |
14a6650f DJ |
286 | unsigned int ret; |
287 | ret = (busfreq * powernow_k6_get_cpu_multiplier()); | |
288 | return ret; | |
1da177e4 LT |
289 | } |
290 | ||
8d2d2051 | 291 | static struct freq_attr *powernow_k6_attr[] = { |
1da177e4 LT |
292 | &cpufreq_freq_attr_scaling_available_freqs, |
293 | NULL, | |
294 | }; | |
295 | ||
221dee28 | 296 | static struct cpufreq_driver powernow_k6_driver = { |
32ee8c3e DJ |
297 | .verify = powernow_k6_verify, |
298 | .target = powernow_k6_target, | |
1da177e4 LT |
299 | .init = powernow_k6_cpu_init, |
300 | .exit = powernow_k6_cpu_exit, | |
301 | .get = powernow_k6_get, | |
302 | .name = "powernow-k6", | |
303 | .owner = THIS_MODULE, | |
304 | .attr = powernow_k6_attr, | |
305 | }; | |
306 | ||
fa8031ae AK |
307 | static const struct x86_cpu_id powernow_k6_ids[] = { |
308 | { X86_VENDOR_AMD, 5, 12 }, | |
309 | { X86_VENDOR_AMD, 5, 13 }, | |
310 | {} | |
311 | }; | |
b4d2d231 | 312 | MODULE_DEVICE_TABLE(x86cpu, powernow_k6_ids); |
1da177e4 LT |
313 | |
314 | /** | |
315 | * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver | |
316 | * | |
317 | * Initializes the K6 PowerNow! support. Returns -ENODEV on unsupported | |
318 | * devices, -EINVAL or -ENOMEM on problems during initiatization, and zero | |
319 | * on success. | |
320 | */ | |
321 | static int __init powernow_k6_init(void) | |
32ee8c3e | 322 | { |
fa8031ae | 323 | if (!x86_match_cpu(powernow_k6_ids)) |
1da177e4 LT |
324 | return -ENODEV; |
325 | ||
326 | if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) { | |
14a6650f | 327 | printk(KERN_INFO PFX "PowerNow IOPORT region already used.\n"); |
1da177e4 LT |
328 | return -EIO; |
329 | } | |
330 | ||
331 | if (cpufreq_register_driver(&powernow_k6_driver)) { | |
8d2d2051 | 332 | release_region(POWERNOW_IOPORT, 16); |
1da177e4 LT |
333 | return -EINVAL; |
334 | } | |
335 | ||
336 | return 0; | |
337 | } | |
338 | ||
339 | ||
340 | /** | |
341 | * powernow_k6_exit - unregisters AMD K6-2+/3+ PowerNow! support | |
342 | * | |
343 | * Unregisters AMD K6-2+ / K6-3+ PowerNow! support. | |
344 | */ | |
345 | static void __exit powernow_k6_exit(void) | |
346 | { | |
347 | cpufreq_unregister_driver(&powernow_k6_driver); | |
8d2d2051 | 348 | release_region(POWERNOW_IOPORT, 16); |
1da177e4 LT |
349 | } |
350 | ||
351 | ||
14a6650f DJ |
352 | MODULE_AUTHOR("Arjan van de Ven, Dave Jones <davej@redhat.com>, " |
353 | "Dominik Brodowski <linux@brodo.de>"); | |
8d2d2051 PC |
354 | MODULE_DESCRIPTION("PowerNow! driver for AMD K6-2+ / K6-3+ processors."); |
355 | MODULE_LICENSE("GPL"); | |
1da177e4 LT |
356 | |
357 | module_init(powernow_k6_init); | |
358 | module_exit(powernow_k6_exit); |