xref: /linux/drivers/cpufreq/powernow-k6.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  This file was based upon code in Powertweak Linux (http://powertweak.sf.net)
4  *  (C) 2000-2003  Dave Jones, Arjan van de Ven, Janne Pänkälä,
5  *                 Dominik Brodowski.
6  *
7  *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
8  */
9 
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/cpufreq.h>
16 #include <linux/ioport.h>
17 #include <linux/timex.h>
18 #include <linux/io.h>
19 
20 #include <asm/cpu_device_id.h>
21 #include <asm/msr.h>
22 
23 #define POWERNOW_IOPORT 0xfff0          /* it doesn't matter where, as long
24 					   as it is unused */
25 
26 static unsigned int                     busfreq;   /* FSB, in 10 kHz */
27 static unsigned int                     max_multiplier;
28 
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");
37 
38 /* Clock ratio multiplied by 10 - see table 27 in AMD#23446 */
39 static struct cpufreq_frequency_table clock_ratio[] = {
40 	{0, 60,  /* 110 -> 6.0x */ 0},
41 	{0, 55,  /* 011 -> 5.5x */ 0},
42 	{0, 50,  /* 001 -> 5.0x */ 0},
43 	{0, 45,  /* 000 -> 4.5x */ 0},
44 	{0, 40,  /* 010 -> 4.0x */ 0},
45 	{0, 35,  /* 111 -> 3.5x */ 0},
46 	{0, 30,  /* 101 -> 3.0x */ 0},
47 	{0, 20,  /* 100 -> 2.0x */ 0},
48 	{0, 0, CPUFREQ_TABLE_END}
49 };
50 
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 
54 static const struct {
55 	unsigned freq;
56 	unsigned mult;
57 } usual_frequency_table[] = {
58 	{ 350000, 35 },	// 100   * 3.5
59 	{ 400000, 40 },	// 100   * 4
60 	{ 450000, 45 }, // 100   * 4.5
61 	{ 475000, 50 }, //  95   * 5
62 	{ 500000, 50 }, // 100   * 5
63 	{ 506250, 45 }, // 112.5 * 4.5
64 	{ 533500, 55 }, //  97   * 5.5
65 	{ 550000, 55 }, // 100   * 5.5
66 	{ 562500, 50 }, // 112.5 * 5
67 	{ 570000, 60 }, //  95   * 6
68 	{ 600000, 60 }, // 100   * 6
69 	{ 618750, 55 }, // 112.5 * 5.5
70 	{ 660000, 55 }, // 120   * 5.5
71 	{ 675000, 60 }, // 112.5 * 6
72 	{ 720000, 60 }, // 120   * 6
73 };
74 
75 #define FREQ_RANGE		3000
76 
77 /**
78  * powernow_k6_get_cpu_multiplier - returns the current FSB multiplier
79  *
80  * Returns the current setting of the frequency multiplier. Core clock
81  * speed is frequency of the Front-Side Bus multiplied with this value.
82  */
powernow_k6_get_cpu_multiplier(void)83 static int powernow_k6_get_cpu_multiplier(void)
84 {
85 	unsigned long invalue = 0;
86 	u32 msrval;
87 
88 	local_irq_disable();
89 
90 	msrval = POWERNOW_IOPORT + 0x1;
91 	wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */
92 	invalue = inl(POWERNOW_IOPORT + 0x8);
93 	msrval = POWERNOW_IOPORT + 0x0;
94 	wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */
95 
96 	local_irq_enable();
97 
98 	return clock_ratio[register_to_index[(invalue >> 5)&7]].driver_data;
99 }
100 
powernow_k6_set_cpu_multiplier(unsigned int best_i)101 static void powernow_k6_set_cpu_multiplier(unsigned int best_i)
102 {
103 	unsigned long outvalue, invalue;
104 	unsigned long msrval;
105 	unsigned long cr0;
106 
107 	/* we now need to transform best_i to the BVC format, see AMD#23446 */
108 
109 	/*
110 	 * The processor doesn't respond to inquiry cycles while changing the
111 	 * frequency, so we must disable cache.
112 	 */
113 	local_irq_disable();
114 	cr0 = read_cr0();
115 	write_cr0(cr0 | X86_CR0_CD);
116 	wbinvd();
117 
118 	outvalue = (1<<12) | (1<<10) | (1<<9) | (index_to_register[best_i]<<5);
119 
120 	msrval = POWERNOW_IOPORT + 0x1;
121 	wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */
122 	invalue = inl(POWERNOW_IOPORT + 0x8);
123 	invalue = invalue & 0x1f;
124 	outvalue = outvalue | invalue;
125 	outl(outvalue, (POWERNOW_IOPORT + 0x8));
126 	msrval = POWERNOW_IOPORT + 0x0;
127 	wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */
128 
129 	write_cr0(cr0);
130 	local_irq_enable();
131 }
132 
133 /**
134  * powernow_k6_target - set the PowerNow! multiplier
135  * @best_i: clock_ratio[best_i] is the target multiplier
136  *
137  *   Tries to change the PowerNow! multiplier
138  */
powernow_k6_target(struct cpufreq_policy * policy,unsigned int best_i)139 static int powernow_k6_target(struct cpufreq_policy *policy,
140 		unsigned int best_i)
141 {
142 
143 	if (clock_ratio[best_i].driver_data > max_multiplier) {
144 		pr_err("invalid target frequency\n");
145 		return -EINVAL;
146 	}
147 
148 	powernow_k6_set_cpu_multiplier(best_i);
149 
150 	return 0;
151 }
152 
powernow_k6_cpu_init(struct cpufreq_policy * policy)153 static int powernow_k6_cpu_init(struct cpufreq_policy *policy)
154 {
155 	struct cpufreq_frequency_table *pos;
156 	unsigned int i, f;
157 	unsigned khz;
158 
159 	if (policy->cpu != 0)
160 		return -ENODEV;
161 
162 	max_multiplier = 0;
163 	khz = cpu_khz;
164 	for (i = 0; i < ARRAY_SIZE(usual_frequency_table); i++) {
165 		if (khz >= usual_frequency_table[i].freq - FREQ_RANGE &&
166 		    khz <= usual_frequency_table[i].freq + FREQ_RANGE) {
167 			khz = usual_frequency_table[i].freq;
168 			max_multiplier = usual_frequency_table[i].mult;
169 			break;
170 		}
171 	}
172 	if (param_max_multiplier) {
173 		cpufreq_for_each_entry(pos, clock_ratio)
174 			if (pos->driver_data == param_max_multiplier) {
175 				max_multiplier = param_max_multiplier;
176 				goto have_max_multiplier;
177 			}
178 		pr_err("invalid max_multiplier parameter, valid parameters 20, 30, 35, 40, 45, 50, 55, 60\n");
179 		return -EINVAL;
180 	}
181 
182 	if (!max_multiplier) {
183 		pr_warn("unknown frequency %u, cannot determine current multiplier\n",
184 			khz);
185 		pr_warn("use module parameters max_multiplier and bus_frequency\n");
186 		return -EOPNOTSUPP;
187 	}
188 
189 have_max_multiplier:
190 	param_max_multiplier = max_multiplier;
191 
192 	if (param_busfreq) {
193 		if (param_busfreq >= 50000 && param_busfreq <= 150000) {
194 			busfreq = param_busfreq / 10;
195 			goto have_busfreq;
196 		}
197 		pr_err("invalid bus_frequency parameter, allowed range 50000 - 150000 kHz\n");
198 		return -EINVAL;
199 	}
200 
201 	busfreq = khz / max_multiplier;
202 have_busfreq:
203 	param_busfreq = busfreq * 10;
204 
205 	/* table init */
206 	cpufreq_for_each_entry(pos, clock_ratio) {
207 		f = pos->driver_data;
208 		if (f > max_multiplier)
209 			pos->frequency = CPUFREQ_ENTRY_INVALID;
210 		else
211 			pos->frequency = busfreq * f;
212 	}
213 
214 	/* cpuinfo and default policy values */
215 	policy->cpuinfo.transition_latency = 500000;
216 	policy->freq_table = clock_ratio;
217 
218 	return 0;
219 }
220 
221 
powernow_k6_cpu_exit(struct cpufreq_policy * policy)222 static void powernow_k6_cpu_exit(struct cpufreq_policy *policy)
223 {
224 	unsigned int i;
225 
226 	for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
227 		if (clock_ratio[i].driver_data == max_multiplier) {
228 			struct cpufreq_freqs freqs;
229 
230 			freqs.old = policy->cur;
231 			freqs.new = clock_ratio[i].frequency;
232 			freqs.flags = 0;
233 
234 			cpufreq_freq_transition_begin(policy, &freqs);
235 			powernow_k6_target(policy, i);
236 			cpufreq_freq_transition_end(policy, &freqs, 0);
237 			return;
238 		}
239 	}
240 }
241 
powernow_k6_get(unsigned int cpu)242 static unsigned int powernow_k6_get(unsigned int cpu)
243 {
244 	unsigned int ret;
245 	ret = (busfreq * powernow_k6_get_cpu_multiplier());
246 	return ret;
247 }
248 
249 static struct cpufreq_driver powernow_k6_driver = {
250 	.verify		= cpufreq_generic_frequency_table_verify,
251 	.target_index	= powernow_k6_target,
252 	.init		= powernow_k6_cpu_init,
253 	.exit		= powernow_k6_cpu_exit,
254 	.get		= powernow_k6_get,
255 	.name		= "powernow-k6",
256 	.attr		= cpufreq_generic_attr,
257 };
258 
259 static const struct x86_cpu_id powernow_k6_ids[] = {
260 	X86_MATCH_VENDOR_FAM_MODEL(AMD, 5, 12, NULL),
261 	X86_MATCH_VENDOR_FAM_MODEL(AMD, 5, 13, NULL),
262 	{}
263 };
264 MODULE_DEVICE_TABLE(x86cpu, powernow_k6_ids);
265 
266 /**
267  * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver
268  *
269  *   Initializes the K6 PowerNow! support. Returns -ENODEV on unsupported
270  * devices, -EINVAL or -ENOMEM on problems during initiatization, and zero
271  * on success.
272  */
powernow_k6_init(void)273 static int __init powernow_k6_init(void)
274 {
275 	if (!x86_match_cpu(powernow_k6_ids))
276 		return -ENODEV;
277 
278 	if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) {
279 		pr_info("PowerNow IOPORT region already used\n");
280 		return -EIO;
281 	}
282 
283 	if (cpufreq_register_driver(&powernow_k6_driver)) {
284 		release_region(POWERNOW_IOPORT, 16);
285 		return -EINVAL;
286 	}
287 
288 	return 0;
289 }
290 
291 
292 /**
293  * powernow_k6_exit - unregisters AMD K6-2+/3+ PowerNow! support
294  *
295  *   Unregisters AMD K6-2+ / K6-3+ PowerNow! support.
296  */
powernow_k6_exit(void)297 static void __exit powernow_k6_exit(void)
298 {
299 	cpufreq_unregister_driver(&powernow_k6_driver);
300 	release_region(POWERNOW_IOPORT, 16);
301 }
302 
303 
304 MODULE_AUTHOR("Arjan van de Ven, Dave Jones, "
305 		"Dominik Brodowski <linux@brodo.de>");
306 MODULE_DESCRIPTION("PowerNow! driver for AMD K6-2+ / K6-3+ processors.");
307 MODULE_LICENSE("GPL");
308 
309 module_init(powernow_k6_init);
310 module_exit(powernow_k6_exit);
311