2 * AMD K7 Powernow driver.
3 * (C) 2003 Dave Jones <davej@codemonkey.org.uk> on behalf of SuSE Labs.
4 * (C) 2003-2004 Dave Jones <davej@redhat.com>
6 * Licensed under the terms of the GNU GPL License version 2.
7 * Based upon datasheets & sample CPUs kindly provided by AMD.
9 * Errata 5: Processor may fail to execute a FID/VID change in presence of interrupt.
10 * - We cli/sti on stepping A0 CPUs around the FID/VID transition.
11 * Errata 15: Processors with half frequency multipliers may hang upon wakeup from disconnect.
12 * - We disable half multipliers if ACPI is used on A0 stepping CPUs.
15 #include <linux/config.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/init.h>
20 #include <linux/cpufreq.h>
21 #include <linux/slab.h>
22 #include <linux/string.h>
23 #include <linux/dmi.h>
26 #include <asm/timer.h>
27 #include <asm/timex.h>
29 #include <asm/system.h>
31 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
32 #include <linux/acpi.h>
33 #include <acpi/processor.h>
36 #include "powernow-k7.h"
38 #define PFX "powernow: "
58 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
59 union powernow_acpi_control_t
{
70 #ifdef CONFIG_CPU_FREQ_DEBUG
71 /* divide by 1000 to get VCore voltage in V. */
72 static int mobile_vid_table
[32] = {
73 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,
80 /* divide by 10 to get FID. */
81 static int fid_codes
[32] = {
82 110, 115, 120, 125, 50, 55, 60, 65,
83 70, 75, 80, 85, 90, 95, 100, 105,
84 30, 190, 40, 200, 130, 135, 140, 210,
85 150, 225, 160, 165, 170, 180, -1, -1,
88 /* This parameter is used in order to force ACPI instead of legacy method for
89 * configuration purpose.
92 static int acpi_force
;
94 static struct cpufreq_frequency_table
*powernow_table
;
96 static unsigned int can_scale_bus
;
97 static unsigned int can_scale_vid
;
98 static unsigned int minimum_speed
=-1;
99 static unsigned int maximum_speed
;
100 static unsigned int number_scales
;
101 static unsigned int fsb
;
102 static unsigned int latency
;
105 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "powernow-k7", msg)
107 static int check_fsb(unsigned int fsbspeed
)
110 unsigned int f
= fsb
/ 1000;
112 delta
= (fsbspeed
> f
) ? fsbspeed
- f
: f
- fsbspeed
;
116 static int check_powernow(void)
118 struct cpuinfo_x86
*c
= cpu_data
;
119 unsigned int maxei
, eax
, ebx
, ecx
, edx
;
121 if ((c
->x86_vendor
!= X86_VENDOR_AMD
) || (c
->x86
!=6)) {
123 printk (KERN_INFO PFX
"This module only works with AMD K7 CPUs\n");
128 /* Get maximum capabilities */
129 maxei
= cpuid_eax (0x80000000);
130 if (maxei
< 0x80000007) { /* Any powernow info ? */
132 printk (KERN_INFO PFX
"No powernow capabilities detected\n");
137 if ((c
->x86_model
== 6) && (c
->x86_mask
== 0)) {
138 printk (KERN_INFO PFX
"K7 660[A0] core detected, enabling errata workarounds\n");
142 cpuid(0x80000007, &eax
, &ebx
, &ecx
, &edx
);
144 /* Check we can actually do something before we say anything.*/
145 if (!(edx
& (1 << 1 | 1 << 2)))
148 printk (KERN_INFO PFX
"PowerNOW! Technology present. Can scale: ");
151 printk ("frequency");
155 if ((edx
& (1 << 1 | 1 << 2)) == 0x6)
168 static int get_ranges (unsigned char *pst
)
174 powernow_table
= kmalloc((sizeof(struct cpufreq_frequency_table
) * (number_scales
+ 1)), GFP_KERNEL
);
177 memset(powernow_table
, 0, (sizeof(struct cpufreq_frequency_table
) * (number_scales
+ 1)));
179 for (j
=0 ; j
< number_scales
; j
++) {
182 powernow_table
[j
].frequency
= (fsb
* fid_codes
[fid
]) / 10;
183 powernow_table
[j
].index
= fid
; /* lower 8 bits */
185 speed
= powernow_table
[j
].frequency
;
187 if ((fid_codes
[fid
] % 10)==5) {
188 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
190 powernow_table
[j
].frequency
= CPUFREQ_ENTRY_INVALID
;
194 if (speed
< minimum_speed
)
195 minimum_speed
= speed
;
196 if (speed
> maximum_speed
)
197 maximum_speed
= speed
;
200 powernow_table
[j
].index
|= (vid
<< 8); /* upper 8 bits */
202 dprintk (" FID: 0x%x (%d.%dx [%dMHz]) "
203 "VID: 0x%x (%d.%03dV)\n", fid
, fid_codes
[fid
] / 10,
204 fid_codes
[fid
] % 10, speed
/1000, vid
,
205 mobile_vid_table
[vid
]/1000,
206 mobile_vid_table
[vid
]%1000);
208 powernow_table
[number_scales
].frequency
= CPUFREQ_TABLE_END
;
209 powernow_table
[number_scales
].index
= 0;
215 static void change_FID(int fid
)
217 union msr_fidvidctl fidvidctl
;
219 rdmsrl (MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
220 if (fidvidctl
.bits
.FID
!= fid
) {
221 fidvidctl
.bits
.SGTC
= latency
;
222 fidvidctl
.bits
.FID
= fid
;
223 fidvidctl
.bits
.VIDC
= 0;
224 fidvidctl
.bits
.FIDC
= 1;
225 wrmsrl (MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
230 static void change_VID(int vid
)
232 union msr_fidvidctl fidvidctl
;
234 rdmsrl (MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
235 if (fidvidctl
.bits
.VID
!= vid
) {
236 fidvidctl
.bits
.SGTC
= latency
;
237 fidvidctl
.bits
.VID
= vid
;
238 fidvidctl
.bits
.FIDC
= 0;
239 fidvidctl
.bits
.VIDC
= 1;
240 wrmsrl (MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
245 static void change_speed (unsigned int index
)
248 struct cpufreq_freqs freqs
;
249 union msr_fidvidstatus fidvidstatus
;
252 /* fid are the lower 8 bits of the index we stored into
253 * the cpufreq frequency table in powernow_decode_bios,
254 * vid are the upper 8 bits.
257 fid
= powernow_table
[index
].index
& 0xFF;
258 vid
= (powernow_table
[index
].index
& 0xFF00) >> 8;
262 rdmsrl (MSR_K7_FID_VID_STATUS
, fidvidstatus
.val
);
263 cfid
= fidvidstatus
.bits
.CFID
;
264 freqs
.old
= fsb
* fid_codes
[cfid
] / 10;
266 freqs
.new = powernow_table
[index
].frequency
;
268 cpufreq_notify_transition(&freqs
, CPUFREQ_PRECHANGE
);
270 /* Now do the magic poking into the MSRs. */
272 if (have_a0
== 1) /* A0 errata 5 */
275 if (freqs
.old
> freqs
.new) {
276 /* Going down, so change FID first */
280 /* Going up, so change VID first */
289 cpufreq_notify_transition(&freqs
, CPUFREQ_POSTCHANGE
);
293 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
295 static struct acpi_processor_performance
*acpi_processor_perf
;
297 static int powernow_acpi_init(void)
301 union powernow_acpi_control_t pc
;
303 if (acpi_processor_perf
!= NULL
&& powernow_table
!= NULL
) {
308 acpi_processor_perf
= kmalloc(sizeof(struct acpi_processor_performance
),
311 if (!acpi_processor_perf
) {
316 memset(acpi_processor_perf
, 0, sizeof(struct acpi_processor_performance
));
318 if (acpi_processor_register_performance(acpi_processor_perf
, 0)) {
323 if (acpi_processor_perf
->control_register
.space_id
!= ACPI_ADR_SPACE_FIXED_HARDWARE
) {
328 if (acpi_processor_perf
->status_register
.space_id
!= ACPI_ADR_SPACE_FIXED_HARDWARE
) {
333 number_scales
= acpi_processor_perf
->state_count
;
335 if (number_scales
< 2) {
340 powernow_table
= kmalloc((number_scales
+ 1) * (sizeof(struct cpufreq_frequency_table
)), GFP_KERNEL
);
341 if (!powernow_table
) {
346 memset(powernow_table
, 0, ((number_scales
+ 1) * sizeof(struct cpufreq_frequency_table
)));
348 pc
.val
= (unsigned long) acpi_processor_perf
->states
[0].control
;
349 for (i
= 0; i
< number_scales
; i
++) {
353 pc
.val
= (unsigned long) acpi_processor_perf
->states
[i
].control
;
354 dprintk ("acpi: P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
356 (u32
) acpi_processor_perf
->states
[i
].core_frequency
,
357 (u32
) acpi_processor_perf
->states
[i
].power
,
358 (u32
) acpi_processor_perf
->states
[i
].transition_latency
,
359 (u32
) acpi_processor_perf
->states
[i
].control
,
365 powernow_table
[i
].frequency
= fsb
* fid_codes
[fid
] / 10;
366 powernow_table
[i
].index
= fid
; /* lower 8 bits */
367 powernow_table
[i
].index
|= (vid
<< 8); /* upper 8 bits */
369 speed
= powernow_table
[i
].frequency
;
371 if ((fid_codes
[fid
] % 10)==5) {
373 powernow_table
[i
].frequency
= CPUFREQ_ENTRY_INVALID
;
376 dprintk (" FID: 0x%x (%d.%dx [%dMHz]) "
377 "VID: 0x%x (%d.%03dV)\n", fid
, fid_codes
[fid
] / 10,
378 fid_codes
[fid
] % 10, speed
/1000, vid
,
379 mobile_vid_table
[vid
]/1000,
380 mobile_vid_table
[vid
]%1000);
382 if (latency
< pc
.bits
.sgtc
)
383 latency
= pc
.bits
.sgtc
;
385 if (speed
< minimum_speed
)
386 minimum_speed
= speed
;
387 if (speed
> maximum_speed
)
388 maximum_speed
= speed
;
391 powernow_table
[i
].frequency
= CPUFREQ_TABLE_END
;
392 powernow_table
[i
].index
= 0;
394 /* notify BIOS that we exist */
395 acpi_processor_notify_smm(THIS_MODULE
);
400 acpi_processor_unregister_performance(acpi_processor_perf
, 0);
402 kfree(acpi_processor_perf
);
404 printk(KERN_WARNING PFX
"ACPI perflib can not be used in this platform\n");
405 acpi_processor_perf
= NULL
;
409 static int powernow_acpi_init(void)
411 printk(KERN_INFO PFX
"no support for ACPI processor found."
412 " Please recompile your kernel with ACPI processor\n");
417 static int powernow_decode_bios (int maxfid
, int startvid
)
426 etuple
= cpuid_eax(0x80000001);
428 for (i
=0xC0000; i
< 0xffff0 ; i
+=16) {
432 if (memcmp(p
, "AMDK7PNOW!", 10) == 0){
433 dprintk ("Found PSB header at %p\n", p
);
434 psb
= (struct psb_s
*) p
;
435 dprintk ("Table version: 0x%x\n", psb
->tableversion
);
436 if (psb
->tableversion
!= 0x12) {
437 printk (KERN_INFO PFX
"Sorry, only v1.2 tables supported right now\n");
441 dprintk ("Flags: 0x%x\n", psb
->flags
);
442 if ((psb
->flags
& 1)==0) {
443 dprintk ("Mobile voltage regulator\n");
445 dprintk ("Desktop voltage regulator\n");
448 latency
= psb
->settlingtime
;
450 printk (KERN_INFO PFX
"BIOS set settling time to %d microseconds."
451 "Should be at least 100. Correcting.\n", latency
);
454 dprintk ("Settling Time: %d microseconds.\n", psb
->settlingtime
);
455 dprintk ("Has %d PST tables. (Only dumping ones relevant to this CPU).\n", psb
->numpst
);
457 p
+= sizeof (struct psb_s
);
459 pst
= (struct pst_s
*) p
;
461 for (i
= 0 ; i
<psb
->numpst
; i
++) {
462 pst
= (struct pst_s
*) p
;
463 number_scales
= pst
->numpstates
;
465 if ((etuple
== pst
->cpuid
) && check_fsb(pst
->fsbspeed
) &&
466 (maxfid
==pst
->maxfid
) && (startvid
==pst
->startvid
))
468 dprintk ("PST:%d (@%p)\n", i
, pst
);
469 dprintk (" cpuid: 0x%x fsb: %d maxFID: 0x%x startvid: 0x%x\n",
470 pst
->cpuid
, pst
->fsbspeed
, pst
->maxfid
, pst
->startvid
);
472 ret
= get_ranges ((char *) pst
+ sizeof (struct pst_s
));
476 p
= (char *) pst
+ sizeof (struct pst_s
);
477 for (j
=0 ; j
< number_scales
; j
++)
481 printk (KERN_INFO PFX
"No PST tables match this cpuid (0x%x)\n", etuple
);
482 printk (KERN_INFO PFX
"This is indicative of a broken BIOS.\n");
493 static int powernow_target (struct cpufreq_policy
*policy
,
494 unsigned int target_freq
,
495 unsigned int relation
)
497 unsigned int newstate
;
499 if (cpufreq_frequency_table_target(policy
, powernow_table
, target_freq
, relation
, &newstate
))
502 change_speed(newstate
);
508 static int powernow_verify (struct cpufreq_policy
*policy
)
510 return cpufreq_frequency_table_verify(policy
, powernow_table
);
514 * We use the fact that the bus frequency is somehow
515 * a multiple of 100000/3 khz, then we compute sgtc according
517 * That way, we match more how AMD thinks all of that work.
518 * We will then get the same kind of behaviour already tested under
519 * the "well-known" other OS.
521 static int __init
fixup_sgtc(void)
532 sgtc
= 100 * m
* latency
;
534 if (sgtc
> 0xfffff) {
535 printk(KERN_WARNING PFX
"SGTC too large %d\n", sgtc
);
541 static unsigned int powernow_get(unsigned int cpu
)
543 union msr_fidvidstatus fidvidstatus
;
548 rdmsrl (MSR_K7_FID_VID_STATUS
, fidvidstatus
.val
);
549 cfid
= fidvidstatus
.bits
.CFID
;
551 return (fsb
* fid_codes
[cfid
] / 10);
555 static int __init
acer_cpufreq_pst(struct dmi_system_id
*d
)
557 printk(KERN_WARNING
"%s laptop with broken PST tables in BIOS detected.\n", d
->ident
);
558 printk(KERN_WARNING
"You need to downgrade to 3A21 (09/09/2002), or try a newer BIOS than 3A71 (01/20/2003)\n");
559 printk(KERN_WARNING
"cpufreq scaling has been disabled as a result of this.\n");
564 * Some Athlon laptops have really fucked PST tables.
565 * A BIOS update is all that can save them.
566 * Mention this, and disable cpufreq.
568 static struct dmi_system_id __initdata powernow_dmi_table
[] = {
570 .callback
= acer_cpufreq_pst
,
571 .ident
= "Acer Aspire",
573 DMI_MATCH(DMI_SYS_VENDOR
, "Insyde Software"),
574 DMI_MATCH(DMI_BIOS_VERSION
, "3A71"),
580 static int __init
powernow_cpu_init (struct cpufreq_policy
*policy
)
582 union msr_fidvidstatus fidvidstatus
;
585 if (policy
->cpu
!= 0)
588 rdmsrl (MSR_K7_FID_VID_STATUS
, fidvidstatus
.val
);
590 /* recalibrate cpu_khz */
591 result
= recalibrate_cpu_khz();
595 fsb
= (10 * cpu_khz
) / fid_codes
[fidvidstatus
.bits
.CFID
];
597 printk(KERN_WARNING PFX
"can not determine bus frequency\n");
600 dprintk("FSB: %3dMHz\n", fsb
/1000);
602 if (dmi_check_system(powernow_dmi_table
) || acpi_force
) {
603 printk (KERN_INFO PFX
"PSB/PST known to be broken. Trying ACPI instead\n");
604 result
= powernow_acpi_init();
606 result
= powernow_decode_bios(fidvidstatus
.bits
.MFID
, fidvidstatus
.bits
.SVID
);
608 printk (KERN_INFO PFX
"Trying ACPI perflib\n");
612 result
= powernow_acpi_init();
614 printk (KERN_INFO PFX
"ACPI and legacy methods failed\n");
615 printk (KERN_INFO PFX
"See http://www.codemonkey.org.uk/projects/cpufreq/powernow-k7.shtml\n");
618 /* SGTC use the bus clock as timer */
619 latency
= fixup_sgtc();
620 printk(KERN_INFO PFX
"SGTC: %d\n", latency
);
627 printk (KERN_INFO PFX
"Minimum speed %d MHz. Maximum speed %d MHz.\n",
628 minimum_speed
/1000, maximum_speed
/1000);
630 policy
->governor
= CPUFREQ_DEFAULT_GOVERNOR
;
632 policy
->cpuinfo
.transition_latency
= cpufreq_scale(2000000UL, fsb
, latency
);
634 policy
->cur
= powernow_get(0);
636 cpufreq_frequency_table_get_attr(powernow_table
, policy
->cpu
);
638 return cpufreq_frequency_table_cpuinfo(policy
, powernow_table
);
641 static int powernow_cpu_exit (struct cpufreq_policy
*policy
) {
642 cpufreq_frequency_table_put_attr(policy
->cpu
);
644 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
645 if (acpi_processor_perf
) {
646 acpi_processor_unregister_performance(acpi_processor_perf
, 0);
647 kfree(acpi_processor_perf
);
651 kfree(powernow_table
);
655 static struct freq_attr
* powernow_table_attr
[] = {
656 &cpufreq_freq_attr_scaling_available_freqs
,
660 static struct cpufreq_driver powernow_driver
= {
661 .verify
= powernow_verify
,
662 .target
= powernow_target
,
664 .init
= powernow_cpu_init
,
665 .exit
= powernow_cpu_exit
,
666 .name
= "powernow-k7",
667 .owner
= THIS_MODULE
,
668 .attr
= powernow_table_attr
,
671 static int __init
powernow_init (void)
673 if (check_powernow()==0)
675 return cpufreq_register_driver(&powernow_driver
);
679 static void __exit
powernow_exit (void)
681 cpufreq_unregister_driver(&powernow_driver
);
684 module_param(acpi_force
, int, 0444);
685 MODULE_PARM_DESC(acpi_force
, "Force ACPI to be used.");
687 MODULE_AUTHOR ("Dave Jones <davej@codemonkey.org.uk>");
688 MODULE_DESCRIPTION ("Powernow driver for AMD K7 processors.");
689 MODULE_LICENSE ("GPL");
691 late_initcall(powernow_init
);
692 module_exit(powernow_exit
);