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 int 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 			break;
238 		}
239 	}
240 	return 0;
241 }
242 
powernow_k6_get(unsigned int cpu)243 static unsigned int powernow_k6_get(unsigned int cpu)
244 {
245 	unsigned int ret;
246 	ret = (busfreq * powernow_k6_get_cpu_multiplier());
247 	return ret;
248 }
249 
250 static struct cpufreq_driver powernow_k6_driver = {
251 	.verify		= cpufreq_generic_frequency_table_verify,
252 	.target_index	= powernow_k6_target,
253 	.init		= powernow_k6_cpu_init,
254 	.exit		= powernow_k6_cpu_exit,
255 	.get		= powernow_k6_get,
256 	.name		= "powernow-k6",
257 	.attr		= cpufreq_generic_attr,
258 };
259 
260 static const struct x86_cpu_id powernow_k6_ids[] = {
261 	X86_MATCH_VENDOR_FAM_MODEL(AMD, 5, 12, NULL),
262 	X86_MATCH_VENDOR_FAM_MODEL(AMD, 5, 13, NULL),
263 	{}
264 };
265 MODULE_DEVICE_TABLE(x86cpu, powernow_k6_ids);
266 
267 /**
268  * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver
269  *
270  *   Initializes the K6 PowerNow! support. Returns -ENODEV on unsupported
271  * devices, -EINVAL or -ENOMEM on problems during initiatization, and zero
272  * on success.
273  */
powernow_k6_init(void)274 static int __init powernow_k6_init(void)
275 {
276 	if (!x86_match_cpu(powernow_k6_ids))
277 		return -ENODEV;
278 
279 	if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) {
280 		pr_info("PowerNow IOPORT region already used\n");
281 		return -EIO;
282 	}
283 
284 	if (cpufreq_register_driver(&powernow_k6_driver)) {
285 		release_region(POWERNOW_IOPORT, 16);
286 		return -EINVAL;
287 	}
288 
289 	return 0;
290 }
291 
292 
293 /**
294  * powernow_k6_exit - unregisters AMD K6-2+/3+ PowerNow! support
295  *
296  *   Unregisters AMD K6-2+ / K6-3+ PowerNow! support.
297  */
powernow_k6_exit(void)298 static void __exit powernow_k6_exit(void)
299 {
300 	cpufreq_unregister_driver(&powernow_k6_driver);
301 	release_region(POWERNOW_IOPORT, 16);
302 }
303 
304 
305 MODULE_AUTHOR("Arjan van de Ven, Dave Jones, "
306 		"Dominik Brodowski <linux@brodo.de>");
307 MODULE_DESCRIPTION("PowerNow! driver for AMD K6-2+ / K6-3+ processors.");
308 MODULE_LICENSE("GPL");
309 
310 module_init(powernow_k6_init);
311 module_exit(powernow_k6_exit);
312