blob: 53888dacbe585608b0af69d8a8fbe6df8612c54a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * AMD K7 Powernow driver.
Dave Jonesf4432c52008-10-20 13:31:45 -04003 * (C) 2003 Dave Jones on behalf of SuSE Labs.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * (C) 2003-2004 Dave Jones <davej@redhat.com>
5 *
6 * Licensed under the terms of the GNU GPL License version 2.
7 * Based upon datasheets & sample CPUs kindly provided by AMD.
8 *
Dave Jonesb9e76382009-01-18 00:32:26 -05009 * Errata 5:
10 * CPU may fail to execute a FID/VID change in presence of interrupt.
11 * - We cli/sti on stepping A0 CPUs around the FID/VID transition.
12 * Errata 15:
13 * CPU with half frequency multipliers may hang upon wakeup from disconnect.
14 * - We disable half multipliers if ACPI is used on A0 stepping CPUs.
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/moduleparam.h>
20#include <linux/init.h>
21#include <linux/cpufreq.h>
22#include <linux/slab.h>
23#include <linux/string.h>
24#include <linux/dmi.h>
Dave Jonesb9e76382009-01-18 00:32:26 -050025#include <linux/timex.h>
26#include <linux/io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Dave Jonesb9e76382009-01-18 00:32:26 -050028#include <asm/timer.h> /* Needed for recalibrate_cpu_khz() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <asm/msr.h>
Andi Kleenfa8031a2012-01-26 00:09:12 +010030#include <asm/cpu_device_id.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#ifdef CONFIG_X86_POWERNOW_K7_ACPI
33#include <linux/acpi.h>
34#include <acpi/processor.h>
35#endif
36
37#include "powernow-k7.h"
38
39#define PFX "powernow: "
40
41
42struct psb_s {
43 u8 signature[10];
44 u8 tableversion;
45 u8 flags;
46 u16 settlingtime;
47 u8 reserved1;
48 u8 numpst;
49};
50
51struct pst_s {
52 u32 cpuid;
53 u8 fsbspeed;
54 u8 maxfid;
55 u8 startvid;
56 u8 numpstates;
57};
58
59#ifdef CONFIG_X86_POWERNOW_K7_ACPI
60union powernow_acpi_control_t {
61 struct {
62 unsigned long fid:5,
Dave Jonesb9e76382009-01-18 00:32:26 -050063 vid:5,
64 sgtc:20,
65 res1:2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 } bits;
67 unsigned long val;
68};
69#endif
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/* divide by 1000 to get VCore voltage in V. */
Dave Jonesbd5ab262007-02-22 19:11:16 -050072static const int mobile_vid_table[32] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
74 1600, 1550, 1500, 1450, 1400, 1350, 1300, 0,
75 1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
76 1075, 1050, 1025, 1000, 975, 950, 925, 0,
77};
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79/* divide by 10 to get FID. */
Dave Jonesbd5ab262007-02-22 19:11:16 -050080static const int fid_codes[32] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 110, 115, 120, 125, 50, 55, 60, 65,
82 70, 75, 80, 85, 90, 95, 100, 105,
83 30, 190, 40, 200, 130, 135, 140, 210,
84 150, 225, 160, 165, 170, 180, -1, -1,
85};
86
87/* This parameter is used in order to force ACPI instead of legacy method for
88 * configuration purpose.
89 */
90
91static int acpi_force;
92
93static struct cpufreq_frequency_table *powernow_table;
94
95static unsigned int can_scale_bus;
96static unsigned int can_scale_vid;
Dave Jonesfff78ad2009-01-17 22:28:42 -050097static unsigned int minimum_speed = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098static unsigned int maximum_speed;
99static unsigned int number_scales;
100static unsigned int fsb;
101static unsigned int latency;
102static char have_a0;
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104static int check_fsb(unsigned int fsbspeed)
105{
106 int delta;
107 unsigned int f = fsb / 1000;
108
109 delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed;
Dave Jonesb9e76382009-01-18 00:32:26 -0500110 return delta < 5;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112
Andi Kleenfa8031a2012-01-26 00:09:12 +0100113static const struct x86_cpu_id powernow_k7_cpuids[] = {
Ben Hutchings30bcfff2012-02-11 22:58:14 +0000114 { X86_VENDOR_AMD, 6, },
Andi Kleenfa8031a2012-01-26 00:09:12 +0100115 {}
116};
117MODULE_DEVICE_TABLE(x86cpu, powernow_k7_cpuids);
118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119static int check_powernow(void)
120{
Mike Travis92cb7612007-10-19 20:35:04 +0200121 struct cpuinfo_x86 *c = &cpu_data(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 unsigned int maxei, eax, ebx, ecx, edx;
123
Andi Kleenfa8031a2012-01-26 00:09:12 +0100124 if (!x86_match_cpu(powernow_k7_cpuids))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
127 /* Get maximum capabilities */
Dave Jonesb9e76382009-01-18 00:32:26 -0500128 maxei = cpuid_eax(0x80000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 if (maxei < 0x80000007) { /* Any powernow info ? */
130#ifdef MODULE
Dave Jonesb9e76382009-01-18 00:32:26 -0500131 printk(KERN_INFO PFX "No powernow capabilities detected\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132#endif
133 return 0;
134 }
135
136 if ((c->x86_model == 6) && (c->x86_mask == 0)) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500137 printk(KERN_INFO PFX "K7 660[A0] core detected, "
138 "enabling errata workarounds\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 have_a0 = 1;
140 }
141
142 cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
143
144 /* Check we can actually do something before we say anything.*/
145 if (!(edx & (1 << 1 | 1 << 2)))
146 return 0;
147
Dave Jonesb9e76382009-01-18 00:32:26 -0500148 printk(KERN_INFO PFX "PowerNOW! Technology present. Can scale: ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
150 if (edx & 1 << 1) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500151 printk("frequency");
152 can_scale_bus = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
154
155 if ((edx & (1 << 1 | 1 << 2)) == 0x6)
Dave Jonesb9e76382009-01-18 00:32:26 -0500156 printk(" and ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 if (edx & 1 << 2) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500159 printk("voltage");
160 can_scale_vid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 }
162
Dave Jonesb9e76382009-01-18 00:32:26 -0500163 printk(".\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 return 1;
165}
166
Dave Jonesd38e73e2009-04-23 13:36:12 -0400167#ifdef CONFIG_X86_POWERNOW_K7_ACPI
Dave Jonesb9e76382009-01-18 00:32:26 -0500168static void invalidate_entry(unsigned int entry)
169{
170 powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
171}
Dave Jonesd38e73e2009-04-23 13:36:12 -0400172#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Dave Jonesb9e76382009-01-18 00:32:26 -0500174static int get_ranges(unsigned char *pst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
176 unsigned int j;
177 unsigned int speed;
178 u8 fid, vid;
179
Dave Jonesb9e76382009-01-18 00:32:26 -0500180 powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
181 (number_scales + 1)), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 if (!powernow_table)
183 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Dave Jonesb9e76382009-01-18 00:32:26 -0500185 for (j = 0 ; j < number_scales; j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 fid = *pst++;
187
188 powernow_table[j].frequency = (fsb * fid_codes[fid]) / 10;
189 powernow_table[j].index = fid; /* lower 8 bits */
190
191 speed = powernow_table[j].frequency;
192
Dave Jonesb9e76382009-01-18 00:32:26 -0500193 if ((fid_codes[fid] % 10) == 5) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194#ifdef CONFIG_X86_POWERNOW_K7_ACPI
195 if (have_a0 == 1)
Dave Jonesb9e76382009-01-18 00:32:26 -0500196 invalidate_entry(j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197#endif
198 }
199
200 if (speed < minimum_speed)
201 minimum_speed = speed;
202 if (speed > maximum_speed)
203 maximum_speed = speed;
204
205 vid = *pst++;
206 powernow_table[j].index |= (vid << 8); /* upper 8 bits */
207
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200208 pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
Dave Jones32ee8c32006-02-28 00:43:23 -0500209 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
210 fid_codes[fid] % 10, speed/1000, vid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 mobile_vid_table[vid]/1000,
212 mobile_vid_table[vid]%1000);
213 }
214 powernow_table[number_scales].frequency = CPUFREQ_TABLE_END;
215 powernow_table[number_scales].index = 0;
216
217 return 0;
218}
219
220
221static void change_FID(int fid)
222{
223 union msr_fidvidctl fidvidctl;
224
Dave Jonesb9e76382009-01-18 00:32:26 -0500225 rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 if (fidvidctl.bits.FID != fid) {
227 fidvidctl.bits.SGTC = latency;
228 fidvidctl.bits.FID = fid;
229 fidvidctl.bits.VIDC = 0;
230 fidvidctl.bits.FIDC = 1;
Dave Jonesb9e76382009-01-18 00:32:26 -0500231 wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 }
233}
234
235
236static void change_VID(int vid)
237{
238 union msr_fidvidctl fidvidctl;
239
Dave Jonesb9e76382009-01-18 00:32:26 -0500240 rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 if (fidvidctl.bits.VID != vid) {
242 fidvidctl.bits.SGTC = latency;
243 fidvidctl.bits.VID = vid;
244 fidvidctl.bits.FIDC = 0;
245 fidvidctl.bits.VIDC = 1;
Dave Jonesb9e76382009-01-18 00:32:26 -0500246 wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 }
248}
249
250
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530251static void change_speed(struct cpufreq_policy *policy, unsigned int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 u8 fid, vid;
254 struct cpufreq_freqs freqs;
255 union msr_fidvidstatus fidvidstatus;
256 int cfid;
257
258 /* fid are the lower 8 bits of the index we stored into
259 * the cpufreq frequency table in powernow_decode_bios,
260 * vid are the upper 8 bits.
261 */
262
263 fid = powernow_table[index].index & 0xFF;
264 vid = (powernow_table[index].index & 0xFF00) >> 8;
265
Dave Jonesb9e76382009-01-18 00:32:26 -0500266 rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 cfid = fidvidstatus.bits.CFID;
268 freqs.old = fsb * fid_codes[cfid] / 10;
269
270 freqs.new = powernow_table[index].frequency;
271
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530272 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 /* Now do the magic poking into the MSRs. */
275
276 if (have_a0 == 1) /* A0 errata 5 */
277 local_irq_disable();
278
279 if (freqs.old > freqs.new) {
280 /* Going down, so change FID first */
281 change_FID(fid);
282 change_VID(vid);
283 } else {
284 /* Going up, so change VID first */
285 change_VID(vid);
286 change_FID(fid);
287 }
288
289
290 if (have_a0 == 1)
291 local_irq_enable();
292
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530293 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294}
295
296
297#ifdef CONFIG_X86_POWERNOW_K7_ACPI
298
299static struct acpi_processor_performance *acpi_processor_perf;
300
301static int powernow_acpi_init(void)
302{
303 int i;
304 int retval = 0;
305 union powernow_acpi_control_t pc;
306
307 if (acpi_processor_perf != NULL && powernow_table != NULL) {
308 retval = -EINVAL;
309 goto err0;
310 }
311
Dave Jonesbfdc7082005-10-20 15:16:15 -0700312 acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 if (!acpi_processor_perf) {
315 retval = -ENOMEM;
316 goto err0;
317 }
318
Yinghai Lueaa95842009-06-06 14:51:36 -0700319 if (!zalloc_cpumask_var(&acpi_processor_perf->shared_cpu_map,
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800320 GFP_KERNEL)) {
321 retval = -ENOMEM;
322 goto err05;
323 }
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 if (acpi_processor_register_performance(acpi_processor_perf, 0)) {
326 retval = -EIO;
327 goto err1;
328 }
329
Dave Jonesb9e76382009-01-18 00:32:26 -0500330 if (acpi_processor_perf->control_register.space_id !=
331 ACPI_ADR_SPACE_FIXED_HARDWARE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 retval = -ENODEV;
333 goto err2;
334 }
335
Dave Jonesb9e76382009-01-18 00:32:26 -0500336 if (acpi_processor_perf->status_register.space_id !=
337 ACPI_ADR_SPACE_FIXED_HARDWARE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 retval = -ENODEV;
339 goto err2;
340 }
341
342 number_scales = acpi_processor_perf->state_count;
343
344 if (number_scales < 2) {
345 retval = -ENODEV;
346 goto err2;
347 }
348
Dave Jonesb9e76382009-01-18 00:32:26 -0500349 powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
350 (number_scales + 1)), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 if (!powernow_table) {
352 retval = -ENOMEM;
353 goto err2;
354 }
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 pc.val = (unsigned long) acpi_processor_perf->states[0].control;
357 for (i = 0; i < number_scales; i++) {
358 u8 fid, vid;
Daniel Drakedc2585e2007-05-02 23:19:05 +0100359 struct acpi_processor_px *state =
360 &acpi_processor_perf->states[i];
361 unsigned int speed, speed_mhz;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Daniel Drakedc2585e2007-05-02 23:19:05 +0100363 pc.val = (unsigned long) state->control;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200364 pr_debug("acpi: P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 i,
Daniel Drakedc2585e2007-05-02 23:19:05 +0100366 (u32) state->core_frequency,
367 (u32) state->power,
368 (u32) state->transition_latency,
369 (u32) state->control,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 pc.bits.sgtc);
371
372 vid = pc.bits.vid;
373 fid = pc.bits.fid;
374
375 powernow_table[i].frequency = fsb * fid_codes[fid] / 10;
376 powernow_table[i].index = fid; /* lower 8 bits */
377 powernow_table[i].index |= (vid << 8); /* upper 8 bits */
378
379 speed = powernow_table[i].frequency;
Daniel Drakedc2585e2007-05-02 23:19:05 +0100380 speed_mhz = speed / 1000;
381
382 /* processor_perflib will multiply the MHz value by 1000 to
383 * get a KHz value (e.g. 1266000). However, powernow-k7 works
384 * with true KHz values (e.g. 1266768). To ensure that all
385 * powernow frequencies are available, we must ensure that
386 * ACPI doesn't restrict them, so we round up the MHz value
387 * to ensure that perflib's computed KHz value is greater than
388 * or equal to powernow's KHz value.
389 */
390 if (speed % 1000 > 0)
391 speed_mhz++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Dave Jonesb9e76382009-01-18 00:32:26 -0500393 if ((fid_codes[fid] % 10) == 5) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 if (have_a0 == 1)
Dave Jonesb9e76382009-01-18 00:32:26 -0500395 invalidate_entry(i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
397
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200398 pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
Dave Jones32ee8c32006-02-28 00:43:23 -0500399 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
Daniel Drakedc2585e2007-05-02 23:19:05 +0100400 fid_codes[fid] % 10, speed_mhz, vid,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 mobile_vid_table[vid]/1000,
402 mobile_vid_table[vid]%1000);
403
Daniel Drakedc2585e2007-05-02 23:19:05 +0100404 if (state->core_frequency != speed_mhz) {
405 state->core_frequency = speed_mhz;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200406 pr_debug(" Corrected ACPI frequency to %d\n",
Daniel Drakedc2585e2007-05-02 23:19:05 +0100407 speed_mhz);
408 }
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 if (latency < pc.bits.sgtc)
411 latency = pc.bits.sgtc;
412
413 if (speed < minimum_speed)
414 minimum_speed = speed;
415 if (speed > maximum_speed)
416 maximum_speed = speed;
417 }
418
419 powernow_table[i].frequency = CPUFREQ_TABLE_END;
420 powernow_table[i].index = 0;
421
422 /* notify BIOS that we exist */
423 acpi_processor_notify_smm(THIS_MODULE);
424
425 return 0;
426
427err2:
428 acpi_processor_unregister_performance(acpi_processor_perf, 0);
429err1:
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800430 free_cpumask_var(acpi_processor_perf->shared_cpu_map);
431err05:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 kfree(acpi_processor_perf);
433err0:
Dave Jonesb9e76382009-01-18 00:32:26 -0500434 printk(KERN_WARNING PFX "ACPI perflib can not be used on "
435 "this platform\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 acpi_processor_perf = NULL;
437 return retval;
438}
439#else
440static int powernow_acpi_init(void)
441{
442 printk(KERN_INFO PFX "no support for ACPI processor found."
443 " Please recompile your kernel with ACPI processor\n");
444 return -EINVAL;
445}
446#endif
447
Dave Jonesb9e76382009-01-18 00:32:26 -0500448static void print_pst_entry(struct pst_s *pst, unsigned int j)
449{
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200450 pr_debug("PST:%d (@%p)\n", j, pst);
451 pr_debug(" cpuid: 0x%x fsb: %d maxFID: 0x%x startvid: 0x%x\n",
Dave Jonesb9e76382009-01-18 00:32:26 -0500452 pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid);
453}
454
455static int powernow_decode_bios(int maxfid, int startvid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
457 struct psb_s *psb;
458 struct pst_s *pst;
459 unsigned int i, j;
460 unsigned char *p;
461 unsigned int etuple;
462 unsigned int ret;
463
464 etuple = cpuid_eax(0x80000001);
465
Dave Jonesb9e76382009-01-18 00:32:26 -0500466 for (i = 0xC0000; i < 0xffff0 ; i += 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468 p = phys_to_virt(i);
469
Dave Jonesb9e76382009-01-18 00:32:26 -0500470 if (memcmp(p, "AMDK7PNOW!", 10) == 0) {
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200471 pr_debug("Found PSB header at %p\n", p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 psb = (struct psb_s *) p;
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200473 pr_debug("Table version: 0x%x\n", psb->tableversion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (psb->tableversion != 0x12) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500475 printk(KERN_INFO PFX "Sorry, only v1.2 tables"
476 " supported right now\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 return -ENODEV;
478 }
479
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200480 pr_debug("Flags: 0x%x\n", psb->flags);
Dave Jonesb9e76382009-01-18 00:32:26 -0500481 if ((psb->flags & 1) == 0)
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200482 pr_debug("Mobile voltage regulator\n");
Dave Jonesb9e76382009-01-18 00:32:26 -0500483 else
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200484 pr_debug("Desktop voltage regulator\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 latency = psb->settlingtime;
487 if (latency < 100) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500488 printk(KERN_INFO PFX "BIOS set settling time "
489 "to %d microseconds. "
490 "Should be at least 100. "
491 "Correcting.\n", latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 latency = 100;
493 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200494 pr_debug("Settling Time: %d microseconds.\n",
Dave Jonesb9e76382009-01-18 00:32:26 -0500495 psb->settlingtime);
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200496 pr_debug("Has %d PST tables. (Only dumping ones "
Dave Jonesb9e76382009-01-18 00:32:26 -0500497 "relevant to this CPU).\n",
498 psb->numpst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Dave Jonesb9e76382009-01-18 00:32:26 -0500500 p += sizeof(struct psb_s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502 pst = (struct pst_s *) p;
503
Dave Jonesb9e76382009-01-18 00:32:26 -0500504 for (j = 0; j < psb->numpst; j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 pst = (struct pst_s *) p;
506 number_scales = pst->numpstates;
507
Dave Jonesb9e76382009-01-18 00:32:26 -0500508 if ((etuple == pst->cpuid) &&
509 check_fsb(pst->fsbspeed) &&
510 (maxfid == pst->maxfid) &&
511 (startvid == pst->startvid)) {
512 print_pst_entry(pst, j);
513 p = (char *)pst + sizeof(struct pst_s);
514 ret = get_ranges(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 } else {
Dave Jones8cbe0162006-05-30 17:26:08 -0400517 unsigned int k;
Dave Jonesb9e76382009-01-18 00:32:26 -0500518 p = (char *)pst + sizeof(struct pst_s);
519 for (k = 0; k < number_scales; k++)
520 p += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522 }
Dave Jonesb9e76382009-01-18 00:32:26 -0500523 printk(KERN_INFO PFX "No PST tables match this cpuid "
524 "(0x%x)\n", etuple);
525 printk(KERN_INFO PFX "This is indicative of a broken "
526 "BIOS.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 return -EINVAL;
529 }
530 p++;
531 }
532
533 return -ENODEV;
534}
535
536
Dave Jonesb9e76382009-01-18 00:32:26 -0500537static int powernow_target(struct cpufreq_policy *policy,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 unsigned int target_freq,
539 unsigned int relation)
540{
541 unsigned int newstate;
542
Dave Jonesb9e76382009-01-18 00:32:26 -0500543 if (cpufreq_frequency_table_target(policy, powernow_table, target_freq,
544 relation, &newstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 return -EINVAL;
546
Viresh Kumarb43a7ff2013-03-24 11:56:43 +0530547 change_speed(policy, newstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
549 return 0;
550}
551
552
Dave Jonesb9e76382009-01-18 00:32:26 -0500553static int powernow_verify(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554{
555 return cpufreq_frequency_table_verify(policy, powernow_table);
556}
557
558/*
559 * We use the fact that the bus frequency is somehow
560 * a multiple of 100000/3 khz, then we compute sgtc according
561 * to this multiple.
562 * That way, we match more how AMD thinks all of that work.
563 * We will then get the same kind of behaviour already tested under
564 * the "well-known" other OS.
565 */
Holger Freyther307069c2010-07-19 03:29:16 +0800566static int __cpuinit fixup_sgtc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567{
568 unsigned int sgtc;
569 unsigned int m;
570
571 m = fsb / 3333;
572 if ((m % 10) >= 5)
573 m += 5;
574
575 m /= 10;
576
577 sgtc = 100 * m * latency;
578 sgtc = sgtc / 3;
579 if (sgtc > 0xfffff) {
580 printk(KERN_WARNING PFX "SGTC too large %d\n", sgtc);
581 sgtc = 0xfffff;
582 }
583 return sgtc;
584}
585
586static unsigned int powernow_get(unsigned int cpu)
587{
588 union msr_fidvidstatus fidvidstatus;
589 unsigned int cfid;
590
591 if (cpu)
592 return 0;
Dave Jonesb9e76382009-01-18 00:32:26 -0500593 rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 cfid = fidvidstatus.bits.CFID;
595
Dave Jonesb9e76382009-01-18 00:32:26 -0500596 return fsb * fid_codes[cfid] / 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597}
598
599
Holger Freyther307069c2010-07-19 03:29:16 +0800600static int __cpuinit acer_cpufreq_pst(const struct dmi_system_id *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Dave Jonesb9e76382009-01-18 00:32:26 -0500602 printk(KERN_WARNING PFX
603 "%s laptop with broken PST tables in BIOS detected.\n",
604 d->ident);
605 printk(KERN_WARNING PFX
606 "You need to downgrade to 3A21 (09/09/2002), or try a newer "
607 "BIOS than 3A71 (01/20/2003)\n");
608 printk(KERN_WARNING PFX
609 "cpufreq scaling has been disabled as a result of this.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 return 0;
611}
612
613/*
614 * Some Athlon laptops have really fucked PST tables.
615 * A BIOS update is all that can save them.
616 * Mention this, and disable cpufreq.
617 */
Holger Freyther307069c2010-07-19 03:29:16 +0800618static struct dmi_system_id __cpuinitdata powernow_dmi_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 {
620 .callback = acer_cpufreq_pst,
621 .ident = "Acer Aspire",
622 .matches = {
623 DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"),
624 DMI_MATCH(DMI_BIOS_VERSION, "3A71"),
625 },
626 },
627 { }
628};
629
Holger Freyther307069c2010-07-19 03:29:16 +0800630static int __cpuinit powernow_cpu_init(struct cpufreq_policy *policy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
632 union msr_fidvidstatus fidvidstatus;
633 int result;
634
635 if (policy->cpu != 0)
636 return -ENODEV;
637
Dave Jonesb9e76382009-01-18 00:32:26 -0500638 rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Dave Jones436fe7b2006-06-05 14:03:50 -0400640 recalibrate_cpu_khz();
Dave Jones91350ed2005-05-31 19:03:45 -0700641
642 fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.CFID];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (!fsb) {
644 printk(KERN_WARNING PFX "can not determine bus frequency\n");
645 return -EINVAL;
646 }
Dominik Brodowski2d06d8c2011-03-27 15:04:46 +0200647 pr_debug("FSB: %3dMHz\n", fsb/1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649 if (dmi_check_system(powernow_dmi_table) || acpi_force) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500650 printk(KERN_INFO PFX "PSB/PST known to be broken. "
651 "Trying ACPI instead\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 result = powernow_acpi_init();
653 } else {
Dave Jonesb9e76382009-01-18 00:32:26 -0500654 result = powernow_decode_bios(fidvidstatus.bits.MFID,
655 fidvidstatus.bits.SVID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 if (result) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500657 printk(KERN_INFO PFX "Trying ACPI perflib\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 maximum_speed = 0;
659 minimum_speed = -1;
660 latency = 0;
661 result = powernow_acpi_init();
662 if (result) {
Dave Jonesb9e76382009-01-18 00:32:26 -0500663 printk(KERN_INFO PFX
664 "ACPI and legacy methods failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 }
666 } else {
667 /* SGTC use the bus clock as timer */
668 latency = fixup_sgtc();
669 printk(KERN_INFO PFX "SGTC: %d\n", latency);
670 }
671 }
672
673 if (result)
674 return result;
675
Dave Jonesb9e76382009-01-18 00:32:26 -0500676 printk(KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 minimum_speed/1000, maximum_speed/1000);
678
Dave Jonesb9e76382009-01-18 00:32:26 -0500679 policy->cpuinfo.transition_latency =
680 cpufreq_scale(2000000UL, fsb, latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
682 policy->cur = powernow_get(0);
683
684 cpufreq_frequency_table_get_attr(powernow_table, policy->cpu);
685
686 return cpufreq_frequency_table_cpuinfo(policy, powernow_table);
687}
688
Dave Jonesb9e76382009-01-18 00:32:26 -0500689static int powernow_cpu_exit(struct cpufreq_policy *policy)
690{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 cpufreq_frequency_table_put_attr(policy->cpu);
692
693#ifdef CONFIG_X86_POWERNOW_K7_ACPI
694 if (acpi_processor_perf) {
695 acpi_processor_unregister_performance(acpi_processor_perf, 0);
Rusty Russell2fdf66b2008-12-31 18:08:47 -0800696 free_cpumask_var(acpi_processor_perf->shared_cpu_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 kfree(acpi_processor_perf);
698 }
699#endif
700
Jesper Juhl4ae66732005-06-25 14:58:48 -0700701 kfree(powernow_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 return 0;
703}
704
Dave Jonesb9e76382009-01-18 00:32:26 -0500705static struct freq_attr *powernow_table_attr[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 &cpufreq_freq_attr_scaling_available_freqs,
707 NULL,
708};
709
Linus Torvalds221dee22007-02-26 14:55:48 -0800710static struct cpufreq_driver powernow_driver = {
Thomas Renningere2f74f32009-11-19 12:31:01 +0100711 .verify = powernow_verify,
712 .target = powernow_target,
713 .get = powernow_get,
714#ifdef CONFIG_X86_POWERNOW_K7_ACPI
715 .bios_limit = acpi_processor_get_bios_limit,
716#endif
717 .init = powernow_cpu_init,
718 .exit = powernow_cpu_exit,
719 .name = "powernow-k7",
720 .owner = THIS_MODULE,
721 .attr = powernow_table_attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722};
723
Dave Jonesb9e76382009-01-18 00:32:26 -0500724static int __init powernow_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
Dave Jonesb9e76382009-01-18 00:32:26 -0500726 if (check_powernow() == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return -ENODEV;
728 return cpufreq_register_driver(&powernow_driver);
729}
730
731
Dave Jonesb9e76382009-01-18 00:32:26 -0500732static void __exit powernow_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733{
734 cpufreq_unregister_driver(&powernow_driver);
735}
736
737module_param(acpi_force, int, 0444);
738MODULE_PARM_DESC(acpi_force, "Force ACPI to be used.");
739
Dave Jonesb9e76382009-01-18 00:32:26 -0500740MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
741MODULE_DESCRIPTION("Powernow driver for AMD K7 processors.");
742MODULE_LICENSE("GPL");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744late_initcall(powernow_init);
745module_exit(powernow_exit);
746