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 */
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 
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 
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 
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 
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 
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 = &centaur->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 = &centaur->freq_table[0];
362 
363 	return 0;
364 }
365 
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 
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 
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