1 /*
2 * Based on documentation provided by Dave Jones. Thanks!
3 *
4 * Licensed under the terms of the GNU GPL License version 2.
5 *
6 * BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
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
36 struct 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
44 static struct eps_cpu_data *eps_cpu[NR_CPUS];
45
46 /* Module parameters */
47 static int freq_failsafe_off;
48 static int voltage_failsafe_off;
49 static int set_max_voltage;
50
51 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
52 static int ignore_acpi_limit;
53
54 static struct acpi_processor_performance *eps_acpi_cpu_perf;
55
56 /* Minimum necessary to get acpi_processor_get_bios_limit() working */
eps_acpi_init(void)57 static 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
eps_acpi_exit(struct cpufreq_policy * policy)80 static 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
eps_get(unsigned int cpu)92 static 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 /* Return current frequency */
104 rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
105 return centaur->fsb * ((lo >> 8) & 0xff);
106 }
107
eps_set_state(struct eps_cpu_data * centaur,struct cpufreq_policy * policy,u32 dest_state)108 static 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 /* Wait while CPU is busy */
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 /* Set new multiplier and voltage */
127 wrmsr(MSR_IA32_PERF_CTL, dest_state & 0xffff, 0);
128 /* Wait until transition end */
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 /* Print voltage and multiplier */
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
eps_target(struct cpufreq_policy * policy,unsigned int index)154 static 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 /* Make frequency transition */
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
eps_cpu_init(struct cpufreq_policy * policy)173 static 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 /* Check brand */
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 /* Enable Enhanced PowerSaver */
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 /* Can be locked at 0 */
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 /* Print voltage and multiplier */
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 /* Print limits */
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 /* Sanity checks */
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 /* Check for systems using underclocked CPU */
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 /* Calc FSB speed */
286 fsb = cpu_khz / current_multiplier;
287
288 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
289 /* Check for ACPI processor speed limit */
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 /* Check if max_multiplier is in BIOS limits */
297 if (limit && max_multiplier * fsb > limit) {
298 pr_info("Aborting\n");
299 return -EINVAL;
300 }
301 }
302 }
303 #endif
304
305 /* Allow user to set lower maximum voltage then that reported
306 * by processor */
307 if (brand == EPS_BRAND_C7M && set_max_voltage) {
308 u32 v;
309
310 /* Change mV to something hardware can use */
311 v = (set_max_voltage - 700) / 16;
312 /* Check if voltage is within limits */
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 /* Calc number of p-states supported */
320 if (brand == EPS_BRAND_C7M)
321 states = max_multiplier - min_multiplier + 1;
322 else
323 states = 2;
324
325 /* Allocate private data and frequency table for current cpu */
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 /* Copy basic values */
334 centaur->fsb = fsb;
335 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
336 centaur->bios_limit = limit;
337 #endif
338
339 /* Fill frequency and MSR value table */
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; /* 844mV -> 700mV in ns */
361 policy->freq_table = ¢aur->freq_table[0];
362
363 return 0;
364 }
365
eps_cpu_exit(struct cpufreq_policy * policy)366 static int eps_cpu_exit(struct cpufreq_policy *policy)
367 {
368 unsigned int cpu = policy->cpu;
369
370 /* Bye */
371 kfree(eps_cpu[cpu]);
372 eps_cpu[cpu] = NULL;
373 return 0;
374 }
375
376 static 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 /* This driver will work only on Centaur C7 processors with
388 * Enhanced SpeedStep/PowerSaver registers */
389 static const struct x86_cpu_id eps_cpu_id[] = {
390 { X86_VENDOR_CENTAUR, 6, X86_MODEL_ANY, X86_FEATURE_EST },
391 {}
392 };
393 MODULE_DEVICE_TABLE(x86cpu, eps_cpu_id);
394
eps_init(void)395 static 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
eps_exit(void)404 static void __exit eps_exit(void)
405 {
406 cpufreq_unregister_driver(&eps_driver);
407 }
408
409 /* Allow user to overclock his machine or to change frequency to higher after
410 * unloading module */
411 module_param(freq_failsafe_off, int, 0644);
412 MODULE_PARM_DESC(freq_failsafe_off, "Disable current vs max frequency check");
413 module_param(voltage_failsafe_off, int, 0644);
414 MODULE_PARM_DESC(voltage_failsafe_off, "Disable current vs max voltage check");
415 #if IS_ENABLED(CONFIG_ACPI_PROCESSOR)
416 module_param(ignore_acpi_limit, int, 0644);
417 MODULE_PARM_DESC(ignore_acpi_limit, "Don't check ACPI's processor speed limit");
418 #endif
419 module_param(set_max_voltage, int, 0644);
420 MODULE_PARM_DESC(set_max_voltage, "Set maximum CPU voltage (mV) C7-M only");
421
422 MODULE_AUTHOR("Rafal Bilski <rafalbilski@interia.pl>");
423 MODULE_DESCRIPTION("Enhanced PowerSaver driver for VIA C7 CPU's.");
424 MODULE_LICENSE("GPL");
425
426 module_init(eps_init);
427 module_exit(eps_exit);
428