]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * This file was based upon code in Powertweak Linux (http://powertweak.sf.net) | |
96de0e25 | 3 | * (C) 2000-2003 Dave Jones, Arjan van de Ven, Janne Pänkälä, Dominik Brodowski. |
1da177e4 LT |
4 | * |
5 | * Licensed under the terms of the GNU GPL License version 2. | |
6 | * | |
7 | * BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous* | |
8 | */ | |
9 | ||
10 | #include <linux/kernel.h> | |
32ee8c3e | 11 | #include <linux/module.h> |
1da177e4 LT |
12 | #include <linux/init.h> |
13 | #include <linux/cpufreq.h> | |
14 | #include <linux/ioport.h> | |
15 | #include <linux/slab.h> | |
16 | ||
17 | #include <asm/msr.h> | |
8d2d2051 PC |
18 | #include <linux/timex.h> |
19 | #include <linux/io.h> | |
1da177e4 | 20 | |
8d2d2051 PC |
21 | #define POWERNOW_IOPORT 0xfff0 /* it doesn't matter where, as long |
22 | as it is unused */ | |
1da177e4 LT |
23 | |
24 | static unsigned int busfreq; /* FSB, in 10 kHz */ | |
25 | static unsigned int max_multiplier; | |
26 | ||
27 | ||
28 | /* Clock ratio multiplied by 10 - see table 27 in AMD#23446 */ | |
29 | static struct cpufreq_frequency_table clock_ratio[] = { | |
30 | {45, /* 000 -> 4.5x */ 0}, | |
31 | {50, /* 001 -> 5.0x */ 0}, | |
32 | {40, /* 010 -> 4.0x */ 0}, | |
33 | {55, /* 011 -> 5.5x */ 0}, | |
34 | {20, /* 100 -> 2.0x */ 0}, | |
35 | {30, /* 101 -> 3.0x */ 0}, | |
36 | {60, /* 110 -> 6.0x */ 0}, | |
37 | {35, /* 111 -> 3.5x */ 0}, | |
38 | {0, CPUFREQ_TABLE_END} | |
39 | }; | |
40 | ||
41 | ||
42 | /** | |
43 | * powernow_k6_get_cpu_multiplier - returns the current FSB multiplier | |
44 | * | |
45 | * Returns the current setting of the frequency multiplier. Core clock | |
46 | * speed is frequency of the Front-Side Bus multiplied with this value. | |
47 | */ | |
48 | static int powernow_k6_get_cpu_multiplier(void) | |
49 | { | |
50 | u64 invalue = 0; | |
51 | u32 msrval; | |
32ee8c3e | 52 | |
1da177e4 LT |
53 | msrval = POWERNOW_IOPORT + 0x1; |
54 | wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */ | |
8d2d2051 | 55 | invalue = inl(POWERNOW_IOPORT + 0x8); |
1da177e4 LT |
56 | msrval = POWERNOW_IOPORT + 0x0; |
57 | wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */ | |
58 | ||
59 | return clock_ratio[(invalue >> 5)&7].index; | |
60 | } | |
61 | ||
62 | ||
63 | /** | |
64 | * powernow_k6_set_state - set the PowerNow! multiplier | |
65 | * @best_i: clock_ratio[best_i] is the target multiplier | |
66 | * | |
67 | * Tries to change the PowerNow! multiplier | |
68 | */ | |
8d2d2051 | 69 | static void powernow_k6_set_state(unsigned int best_i) |
1da177e4 | 70 | { |
8d2d2051 | 71 | unsigned long outvalue = 0, invalue = 0; |
1da177e4 LT |
72 | unsigned long msrval; |
73 | struct cpufreq_freqs freqs; | |
74 | ||
75 | if (clock_ratio[best_i].index > max_multiplier) { | |
76 | printk(KERN_ERR "cpufreq: invalid target frequency\n"); | |
77 | return; | |
78 | } | |
79 | ||
80 | freqs.old = busfreq * powernow_k6_get_cpu_multiplier(); | |
81 | freqs.new = busfreq * clock_ratio[best_i].index; | |
82 | freqs.cpu = 0; /* powernow-k6.c is UP only driver */ | |
32ee8c3e | 83 | |
1da177e4 LT |
84 | cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); |
85 | ||
86 | /* we now need to transform best_i to the BVC format, see AMD#23446 */ | |
87 | ||
88 | outvalue = (1<<12) | (1<<10) | (1<<9) | (best_i<<5); | |
89 | ||
90 | msrval = POWERNOW_IOPORT + 0x1; | |
91 | wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */ | |
8d2d2051 | 92 | invalue = inl(POWERNOW_IOPORT + 0x8); |
1da177e4 LT |
93 | invalue = invalue & 0xf; |
94 | outvalue = outvalue | invalue; | |
8d2d2051 | 95 | outl(outvalue , (POWERNOW_IOPORT + 0x8)); |
1da177e4 LT |
96 | msrval = POWERNOW_IOPORT + 0x0; |
97 | wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */ | |
98 | ||
99 | cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); | |
100 | ||
101 | return; | |
102 | } | |
103 | ||
104 | ||
105 | /** | |
106 | * powernow_k6_verify - verifies a new CPUfreq policy | |
107 | * @policy: new policy | |
108 | * | |
109 | * Policy must be within lowest and highest possible CPU Frequency, | |
110 | * and at least one possible state must be within min and max. | |
111 | */ | |
112 | static int powernow_k6_verify(struct cpufreq_policy *policy) | |
113 | { | |
114 | return cpufreq_frequency_table_verify(policy, &clock_ratio[0]); | |
115 | } | |
116 | ||
117 | ||
118 | /** | |
119 | * powernow_k6_setpolicy - sets a new CPUFreq policy | |
120 | * @policy: new policy | |
121 | * @target_freq: the target frequency | |
122 | * @relation: how that frequency relates to achieved frequency (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H) | |
123 | * | |
124 | * sets a new CPUFreq policy | |
125 | */ | |
8d2d2051 | 126 | static int powernow_k6_target(struct cpufreq_policy *policy, |
1da177e4 LT |
127 | unsigned int target_freq, |
128 | unsigned int relation) | |
129 | { | |
130 | unsigned int newstate = 0; | |
131 | ||
132 | if (cpufreq_frequency_table_target(policy, &clock_ratio[0], target_freq, relation, &newstate)) | |
133 | return -EINVAL; | |
134 | ||
135 | powernow_k6_set_state(newstate); | |
136 | ||
137 | return 0; | |
138 | } | |
139 | ||
140 | ||
141 | static int powernow_k6_cpu_init(struct cpufreq_policy *policy) | |
142 | { | |
143 | unsigned int i; | |
144 | int result; | |
145 | ||
146 | if (policy->cpu != 0) | |
147 | return -ENODEV; | |
148 | ||
149 | /* get frequencies */ | |
150 | max_multiplier = powernow_k6_get_cpu_multiplier(); | |
151 | busfreq = cpu_khz / max_multiplier; | |
152 | ||
153 | /* table init */ | |
8d2d2051 | 154 | for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) { |
1da177e4 LT |
155 | if (clock_ratio[i].index > max_multiplier) |
156 | clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID; | |
157 | else | |
158 | clock_ratio[i].frequency = busfreq * clock_ratio[i].index; | |
159 | } | |
160 | ||
161 | /* cpuinfo and default policy values */ | |
1da177e4 LT |
162 | policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; |
163 | policy->cur = busfreq * max_multiplier; | |
164 | ||
165 | result = cpufreq_frequency_table_cpuinfo(policy, clock_ratio); | |
166 | if (result) | |
8d2d2051 | 167 | return result; |
1da177e4 LT |
168 | |
169 | cpufreq_frequency_table_get_attr(clock_ratio, policy->cpu); | |
170 | ||
171 | return 0; | |
172 | } | |
173 | ||
174 | ||
175 | static int powernow_k6_cpu_exit(struct cpufreq_policy *policy) | |
176 | { | |
177 | unsigned int i; | |
8d2d2051 PC |
178 | for (i = 0; i < 8; i++) { |
179 | if (i == max_multiplier) | |
1da177e4 LT |
180 | powernow_k6_set_state(i); |
181 | } | |
182 | cpufreq_frequency_table_put_attr(policy->cpu); | |
32ee8c3e | 183 | return 0; |
1da177e4 LT |
184 | } |
185 | ||
186 | static unsigned int powernow_k6_get(unsigned int cpu) | |
187 | { | |
188 | return busfreq * powernow_k6_get_cpu_multiplier(); | |
189 | } | |
190 | ||
8d2d2051 | 191 | static struct freq_attr *powernow_k6_attr[] = { |
1da177e4 LT |
192 | &cpufreq_freq_attr_scaling_available_freqs, |
193 | NULL, | |
194 | }; | |
195 | ||
221dee28 | 196 | static struct cpufreq_driver powernow_k6_driver = { |
32ee8c3e DJ |
197 | .verify = powernow_k6_verify, |
198 | .target = powernow_k6_target, | |
1da177e4 LT |
199 | .init = powernow_k6_cpu_init, |
200 | .exit = powernow_k6_cpu_exit, | |
201 | .get = powernow_k6_get, | |
202 | .name = "powernow-k6", | |
203 | .owner = THIS_MODULE, | |
204 | .attr = powernow_k6_attr, | |
205 | }; | |
206 | ||
207 | ||
208 | /** | |
209 | * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver | |
210 | * | |
211 | * Initializes the K6 PowerNow! support. Returns -ENODEV on unsupported | |
212 | * devices, -EINVAL or -ENOMEM on problems during initiatization, and zero | |
213 | * on success. | |
214 | */ | |
215 | static int __init powernow_k6_init(void) | |
32ee8c3e | 216 | { |
92cb7612 | 217 | struct cpuinfo_x86 *c = &cpu_data(0); |
1da177e4 LT |
218 | |
219 | if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 5) || | |
220 | ((c->x86_model != 12) && (c->x86_model != 13))) | |
221 | return -ENODEV; | |
222 | ||
223 | if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) { | |
224 | printk("cpufreq: PowerNow IOPORT region already used.\n"); | |
225 | return -EIO; | |
226 | } | |
227 | ||
228 | if (cpufreq_register_driver(&powernow_k6_driver)) { | |
8d2d2051 | 229 | release_region(POWERNOW_IOPORT, 16); |
1da177e4 LT |
230 | return -EINVAL; |
231 | } | |
232 | ||
233 | return 0; | |
234 | } | |
235 | ||
236 | ||
237 | /** | |
238 | * powernow_k6_exit - unregisters AMD K6-2+/3+ PowerNow! support | |
239 | * | |
240 | * Unregisters AMD K6-2+ / K6-3+ PowerNow! support. | |
241 | */ | |
242 | static void __exit powernow_k6_exit(void) | |
243 | { | |
244 | cpufreq_unregister_driver(&powernow_k6_driver); | |
8d2d2051 | 245 | release_region(POWERNOW_IOPORT, 16); |
1da177e4 LT |
246 | } |
247 | ||
248 | ||
f4432c5c | 249 | MODULE_AUTHOR("Arjan van de Ven, Dave Jones <davej@redhat.com>, Dominik Brodowski <linux@brodo.de>"); |
8d2d2051 PC |
250 | MODULE_DESCRIPTION("PowerNow! driver for AMD K6-2+ / K6-3+ processors."); |
251 | MODULE_LICENSE("GPL"); | |
1da177e4 LT |
252 | |
253 | module_init(powernow_k6_init); | |
254 | module_exit(powernow_k6_exit); |