powernow-k6.c

  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
 26static unsigned int                     busfreq;   /* FSB, in 10 kHz */
 27static unsigned int                     max_multiplier;
 28
 29static unsigned int			param_busfreq = 0;
 30static unsigned int			param_max_multiplier = 0;
 31
 32module_param_named(max_multiplier, param_max_multiplier, uint, S_IRUGO);
 33MODULE_PARM_DESC(max_multiplier, "Maximum multiplier (allowed values: 20 30 35 40 45 50 55 60)");
 34
 35module_param_named(bus_frequency, param_busfreq, uint, S_IRUGO);
 36MODULE_PARM_DESC(bus_frequency, "Bus frequency in kHz");
 37
 38/* Clock ratio multiplied by 10 - see table 27 in AMD#23446 */
 39static 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
 51static const u8 index_to_register[8] = { 6, 3, 1, 0, 2, 7, 5, 4 };
 52static const u8 register_to_index[8] = { 3, 2, 4, 1, 7, 6, 0, 5 };
 53
 54static 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 */
 83static 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
101static 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 */
139static 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
153static 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
189have_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;
202have_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
222static 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
242static 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
249static 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};
257
258static const struct x86_cpu_id powernow_k6_ids[] = {
259	X86_MATCH_VENDOR_FAM_MODEL(AMD, 5, 12, NULL),
260	X86_MATCH_VENDOR_FAM_MODEL(AMD, 5, 13, NULL),
261	{}
262};
263MODULE_DEVICE_TABLE(x86cpu, powernow_k6_ids);
264
265/**
266 * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver
267 *
268 *   Initializes the K6 PowerNow! support. Returns -ENODEV on unsupported
269 * devices, -EINVAL or -ENOMEM on problems during initiatization, and zero
270 * on success.
271 */
272static int __init powernow_k6_init(void)
273{
274	if (!x86_match_cpu(powernow_k6_ids))
275		return -ENODEV;
276
277	if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) {
278		pr_info("PowerNow IOPORT region already used\n");
279		return -EIO;
280	}
281
282	if (cpufreq_register_driver(&powernow_k6_driver)) {
283		release_region(POWERNOW_IOPORT, 16);
284		return -EINVAL;
285	}
286
287	return 0;
288}
289
290
291/**
292 * powernow_k6_exit - unregisters AMD K6-2+/3+ PowerNow! support
293 *
294 *   Unregisters AMD K6-2+ / K6-3+ PowerNow! support.
295 */
296static void __exit powernow_k6_exit(void)
297{
298	cpufreq_unregister_driver(&powernow_k6_driver);
299	release_region(POWERNOW_IOPORT, 16);
300}
301
302
303MODULE_AUTHOR("Arjan van de Ven, Dave Jones, "
304		"Dominik Brodowski <linux@brodo.de>");
305MODULE_DESCRIPTION("PowerNow! driver for AMD K6-2+ / K6-3+ processors.");
306MODULE_LICENSE("GPL");
307
308module_init(powernow_k6_init);
309module_exit(powernow_k6_exit);