1
2
3
4
5
6
7
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/cpufreq.h>
15#include <linux/ioport.h>
16#include <linux/slab.h>
17#include <linux/timex.h>
18#include <linux/io.h>
19#include <linux/delay.h>
20
21#include <asm/cpu_device_id.h>
22#include <asm/msr.h>
23#include <asm/tsc.h>
24
25#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
26#include <linux/acpi.h>
27#include <acpi/processor.h>
28#endif
29
30#define EPS_BRAND_C7M 0
31#define EPS_BRAND_C7 1
32#define EPS_BRAND_EDEN 2
33#define EPS_BRAND_C3 3
34#define EPS_BRAND_C7D 4
35
36struct eps_cpu_data {
37 u32 fsb;
38#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
39 u32 bios_limit;
40#endif
41 struct cpufreq_frequency_table freq_table[];
42};
43
44static struct eps_cpu_data *eps_cpu[NR_CPUS];
45
46
47static int freq_failsafe_off;
48static int voltage_failsafe_off;
49static int set_max_voltage;
50
51#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
52static int ignore_acpi_limit;
53
54static struct acpi_processor_performance *eps_acpi_cpu_perf;
55
56
57static int eps_acpi_init(void)
58{
59 eps_acpi_cpu_perf = kzalloc(sizeof(*eps_acpi_cpu_perf),
60 GFP_KERNEL);
61 if (!eps_acpi_cpu_perf)
62 return -ENOMEM;
63
64 if (!zalloc_cpumask_var(&eps_acpi_cpu_perf->shared_cpu_map,
65 GFP_KERNEL)) {
66 kfree(eps_acpi_cpu_perf);
67 eps_acpi_cpu_perf = NULL;
68 return -ENOMEM;
69 }
70
71 if (acpi_processor_register_performance(eps_acpi_cpu_perf, 0)) {
72 free_cpumask_var(eps_acpi_cpu_perf->shared_cpu_map);
73 kfree(eps_acpi_cpu_perf);
74 eps_acpi_cpu_perf = NULL;
75 return -EIO;
76 }
77 return 0;
78}
79
80static int eps_acpi_exit(struct cpufreq_policy *policy)
81{
82 if (eps_acpi_cpu_perf) {
83 acpi_processor_unregister_performance(0);
84 free_cpumask_var(eps_acpi_cpu_perf->shared_cpu_map);
85 kfree(eps_acpi_cpu_perf);
86 eps_acpi_cpu_perf = NULL;
87 }
88 return 0;
89}
90#endif
91
92static unsigned int eps_get(unsigned int cpu)
93{
94 struct eps_cpu_data *centaur;
95 u32 lo, hi;
96
97 if (cpu)
98 return 0;
99 centaur = eps_cpu[cpu];
100 if (centaur == NULL)
101 return 0;
102
103
104 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
105 return centaur->fsb * ((lo >> 8) & 0xff);
106}
107
108static int eps_set_state(struct eps_cpu_data *centaur,
109 struct cpufreq_policy *policy,
110 u32 dest_state)
111{
112 u32 lo, hi;
113 int i;
114
115
116 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
117 i = 0;
118 while (lo & ((1 << 16) | (1 << 17))) {
119 udelay(16);
120 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
121 i++;
122 if (unlikely(i > 64)) {
123 return -ENODEV;
124 }
125 }
126
127 wrmsr(MSR_IA32_PERF_CTL, dest_state & 0xffff, 0);
128
129 i = 0;
130 do {
131 udelay(16);
132 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
133 i++;
134 if (unlikely(i > 64)) {
135 return -ENODEV;
136 }
137 } while (lo & ((1 << 16) | (1 << 17)));
138
139#ifdef DEBUG
140 {
141 u8 current_multiplier, current_voltage;
142
143
144 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
145 current_voltage = lo & 0xff;
146 pr_info("Current voltage = %dmV\n", current_voltage * 16 + 700);
147 current_multiplier = (lo >> 8) & 0xff;
148 pr_info("Current multiplier = %d\n", current_multiplier);
149 }
150#endif
151 return 0;
152}
153
154static int eps_target(struct cpufreq_policy *policy, unsigned int index)
155{
156 struct eps_cpu_data *centaur;
157 unsigned int cpu = policy->cpu;
158 unsigned int dest_state;
159 int ret;
160
161 if (unlikely(eps_cpu[cpu] == NULL))
162 return -ENODEV;
163 centaur = eps_cpu[cpu];
164
165
166 dest_state = centaur->freq_table[index].driver_data & 0xffff;
167 ret = eps_set_state(centaur, policy, dest_state);
168 if (ret)
169 pr_err("Timeout!\n");
170 return ret;
171}
172
173static int eps_cpu_init(struct cpufreq_policy *policy)
174{
175 unsigned int i;
176 u32 lo, hi;
177 u64 val;
178 u8 current_multiplier, current_voltage;
179 u8 max_multiplier, max_voltage;
180 u8 min_multiplier, min_voltage;
181 u8 brand = 0;
182 u32 fsb;
183 struct eps_cpu_data *centaur;
184 struct cpuinfo_x86 *c = &cpu_data(0);
185 struct cpufreq_frequency_table *f_table;
186 int k, step, voltage;
187 int states;
188#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
189 unsigned int limit;
190#endif
191
192 if (policy->cpu != 0)
193 return -ENODEV;
194
195
196 pr_info("Detected VIA ");
197
198 switch (c->x86_model) {
199 case 10:
200 rdmsr(0x1153, lo, hi);
201 brand = (((lo >> 2) ^ lo) >> 18) & 3;
202 pr_cont("Model A ");
203 break;
204 case 13:
205 rdmsr(0x1154, lo, hi);
206 brand = (((lo >> 4) ^ (lo >> 2))) & 0x000000ff;
207 pr_cont("Model D ");
208 break;
209 }
210
211 switch (brand) {
212 case EPS_BRAND_C7M:
213 pr_cont("C7-M\n");
214 break;
215 case EPS_BRAND_C7:
216 pr_cont("C7\n");
217 break;
218 case EPS_BRAND_EDEN:
219 pr_cont("Eden\n");
220 break;
221 case EPS_BRAND_C7D:
222 pr_cont("C7-D\n");
223 break;
224 case EPS_BRAND_C3:
225 pr_cont("C3\n");
226 return -ENODEV;
227 break;
228 }
229
230 rdmsrl(MSR_IA32_MISC_ENABLE, val);
231 if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
232 val |= MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP;
233 wrmsrl(MSR_IA32_MISC_ENABLE, val);
234
235 rdmsrl(MSR_IA32_MISC_ENABLE, val);
236 if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
237 pr_info("Can't enable Enhanced PowerSaver\n");
238 return -ENODEV;
239 }
240 }
241
242
243 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
244 current_voltage = lo & 0xff;
245 pr_info("Current voltage = %dmV\n", current_voltage * 16 + 700);
246 current_multiplier = (lo >> 8) & 0xff;
247 pr_info("Current multiplier = %d\n", current_multiplier);
248
249
250 max_voltage = hi & 0xff;
251 pr_info("Highest voltage = %dmV\n", max_voltage * 16 + 700);
252 max_multiplier = (hi >> 8) & 0xff;
253 pr_info("Highest multiplier = %d\n", max_multiplier);
254 min_voltage = (hi >> 16) & 0xff;
255 pr_info("Lowest voltage = %dmV\n", min_voltage * 16 + 700);
256 min_multiplier = (hi >> 24) & 0xff;
257 pr_info("Lowest multiplier = %d\n", min_multiplier);
258
259
260 if (current_multiplier == 0 || max_multiplier == 0
261 || min_multiplier == 0)
262 return -EINVAL;
263 if (current_multiplier > max_multiplier
264 || max_multiplier <= min_multiplier)
265 return -EINVAL;
266 if (current_voltage > 0x1f || max_voltage > 0x1f)
267 return -EINVAL;
268 if (max_voltage < min_voltage
269 || current_voltage < min_voltage
270 || current_voltage > max_voltage)
271 return -EINVAL;
272
273
274 if (!freq_failsafe_off && max_multiplier != current_multiplier) {
275 pr_info("Your processor is running at different frequency then its maximum. Aborting.\n");
276 pr_info("You can use freq_failsafe_off option to disable this check.\n");
277 return -EINVAL;
278 }
279 if (!voltage_failsafe_off && max_voltage != current_voltage) {
280 pr_info("Your processor is running at different voltage then its maximum. Aborting.\n");
281 pr_info("You can use voltage_failsafe_off option to disable this check.\n");
282 return -EINVAL;
283 }
284
285
286 fsb = cpu_khz / current_multiplier;
287
288#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
289
290 if (!ignore_acpi_limit && !eps_acpi_init()) {
291 if (!acpi_processor_get_bios_limit(policy->cpu, &limit)) {
292 pr_info("ACPI limit %u.%uGHz\n",
293 limit/1000000,
294 (limit%1000000)/10000);
295 eps_acpi_exit(policy);
296
297 if (limit && max_multiplier * fsb > limit) {
298 pr_info("Aborting\n");
299 return -EINVAL;
300 }
301 }
302 }
303#endif
304
305
306
307 if (brand == EPS_BRAND_C7M && set_max_voltage) {
308 u32 v;
309
310
311 v = (set_max_voltage - 700) / 16;
312
313 if (v >= min_voltage && v <= max_voltage) {
314 pr_info("Setting %dmV as maximum\n", v * 16 + 700);
315 max_voltage = v;
316 }
317 }
318
319
320 if (brand == EPS_BRAND_C7M)
321 states = max_multiplier - min_multiplier + 1;
322 else
323 states = 2;
324
325
326 centaur = kzalloc(sizeof(*centaur)
327 + (states + 1) * sizeof(struct cpufreq_frequency_table),
328 GFP_KERNEL);
329 if (!centaur)
330 return -ENOMEM;
331 eps_cpu[0] = centaur;
332
333
334 centaur->fsb = fsb;
335#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
336 centaur->bios_limit = limit;
337#endif
338
339
340 f_table = ¢aur->freq_table[0];
341 if (brand != EPS_BRAND_C7M) {
342 f_table[0].frequency = fsb * min_multiplier;
343 f_table[0].driver_data = (min_multiplier << 8) | min_voltage;
344 f_table[1].frequency = fsb * max_multiplier;
345 f_table[1].driver_data = (max_multiplier << 8) | max_voltage;
346 f_table[2].frequency = CPUFREQ_TABLE_END;
347 } else {
348 k = 0;
349 step = ((max_voltage - min_voltage) * 256)
350 / (max_multiplier - min_multiplier);
351 for (i = min_multiplier; i <= max_multiplier; i++) {
352 voltage = (k * step) / 256 + min_voltage;
353 f_table[k].frequency = fsb * i;
354 f_table[k].driver_data = (i << 8) | voltage;
355 k++;
356 }
357 f_table[k].frequency = CPUFREQ_TABLE_END;
358 }
359
360 policy->cpuinfo.transition_latency = 140000;
361 policy->freq_table = ¢aur->freq_table[0];
362
363 return 0;
364}
365
366static int eps_cpu_exit(struct cpufreq_policy *policy)
367{
368 unsigned int cpu = policy->cpu;
369
370
371 kfree(eps_cpu[cpu]);
372 eps_cpu[cpu] = NULL;
373 return 0;
374}
375
376static struct cpufreq_driver eps_driver = {
377 .verify = cpufreq_generic_frequency_table_verify,
378 .target_index = eps_target,
379 .init = eps_cpu_init,
380 .exit = eps_cpu_exit,
381 .get = eps_get,
382 .name = "e_powersaver",
383 .attr = cpufreq_generic_attr,
384};
385
386
387
388
389static const struct x86_cpu_id eps_cpu_id[] = {
390 { X86_VENDOR_CENTAUR, 6, X86_MODEL_ANY, X86_FEATURE_EST },
391 {}
392};
393MODULE_DEVICE_TABLE(x86cpu, eps_cpu_id);
394
395static int __init eps_init(void)
396{
397 if (!x86_match_cpu(eps_cpu_id) || boot_cpu_data.x86_model < 10)
398 return -ENODEV;
399 if (cpufreq_register_driver(&eps_driver))
400 return -EINVAL;
401 return 0;
402}
403
404static void __exit eps_exit(void)
405{
406 cpufreq_unregister_driver(&eps_driver);
407}
408
409
410
411module_param(freq_failsafe_off, int, 0644);
412MODULE_PARM_DESC(freq_failsafe_off, "Disable current vs max frequency check");
413module_param(voltage_failsafe_off, int, 0644);
414MODULE_PARM_DESC(voltage_failsafe_off, "Disable current vs max voltage check");
415#if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
416module_param(ignore_acpi_limit, int, 0644);
417MODULE_PARM_DESC(ignore_acpi_limit, "Don't check ACPI's processor speed limit");
418#endif
419module_param(set_max_voltage, int, 0644);
420MODULE_PARM_DESC(set_max_voltage, "Set maximum CPU voltage (mV) C7-M only");
421
422MODULE_AUTHOR("Rafal Bilski <rafalbilski@interia.pl>");
423MODULE_DESCRIPTION("Enhanced PowerSaver driver for VIA C7 CPU's.");
424MODULE_LICENSE("GPL");
425
426module_init(eps_init);
427module_exit(eps_exit);
428
