1/*
2 *  This file was based upon code in Powertweak Linux (http://powertweak.sf.net)
3 *  (C) 2000-2003  Dave Jones, Arjan van de Ven, Janne Pänkälä,
4 *                 Dominik Brodowski.
5 *
6 *  Licensed under the terms of the GNU GPL License version 2.
7 *
8 *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
9 */
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/timex.h>
17#include <linux/io.h>
18
19#include <asm/cpu_device_id.h>
20#include <asm/msr.h>
21
22#define POWERNOW_IOPORT 0xfff0          /* it doesn't matter where, as long
23					   as it is unused */
24
25#define PFX "powernow-k6: "
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		printk(KERN_ERR PFX "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		printk(KERN_ERR "powernow-k6: 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		printk(KERN_WARNING "powernow-k6: unknown frequency %u, cannot determine current multiplier\n", khz);
184		printk(KERN_WARNING "powernow-k6: use module parameters max_multiplier and bus_frequency\n");
185		return -EOPNOTSUPP;
186	}
187
188have_max_multiplier:
189	param_max_multiplier = max_multiplier;
190
191	if (param_busfreq) {
192		if (param_busfreq >= 50000 && param_busfreq <= 150000) {
193			busfreq = param_busfreq / 10;
194			goto have_busfreq;
195		}
196		printk(KERN_ERR "powernow-k6: invalid bus_frequency parameter, allowed range 50000 - 150000 kHz\n");
197		return -EINVAL;
198	}
199
200	busfreq = khz / max_multiplier;
201have_busfreq:
202	param_busfreq = busfreq * 10;
203
204	/* table init */
205	cpufreq_for_each_entry(pos, clock_ratio) {
206		f = pos->driver_data;
207		if (f > max_multiplier)
208			pos->frequency = CPUFREQ_ENTRY_INVALID;
209		else
210			pos->frequency = busfreq * f;
211	}
212
213	/* cpuinfo and default policy values */
214	policy->cpuinfo.transition_latency = 500000;
215
216	return cpufreq_table_validate_and_show(policy, clock_ratio);
217}
218
219
220static int powernow_k6_cpu_exit(struct cpufreq_policy *policy)
221{
222	unsigned int i;
223
224	for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
225		if (clock_ratio[i].driver_data == max_multiplier) {
226			struct cpufreq_freqs freqs;
227
228			freqs.old = policy->cur;
229			freqs.new = clock_ratio[i].frequency;
230			freqs.flags = 0;
231
232			cpufreq_freq_transition_begin(policy, &freqs);
233			powernow_k6_target(policy, i);
234			cpufreq_freq_transition_end(policy, &freqs, 0);
235			break;
236		}
237	}
238	return 0;
239}
240
241static unsigned int powernow_k6_get(unsigned int cpu)
242{
243	unsigned int ret;
244	ret = (busfreq * powernow_k6_get_cpu_multiplier());
245	return ret;
246}
247
248static struct cpufreq_driver powernow_k6_driver = {
249	.verify		= cpufreq_generic_frequency_table_verify,
250	.target_index	= powernow_k6_target,
251	.init		= powernow_k6_cpu_init,
252	.exit		= powernow_k6_cpu_exit,
253	.get		= powernow_k6_get,
254	.name		= "powernow-k6",
255	.attr		= cpufreq_generic_attr,
256};
257
258static const struct x86_cpu_id powernow_k6_ids[] = {
259	{ X86_VENDOR_AMD, 5, 12 },
260	{ X86_VENDOR_AMD, 5, 13 },
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		printk(KERN_INFO PFX "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);
310