2 * AMD K7 Powernow driver.
3 * (C) 2003 Dave Jones 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.
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.
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.
17 #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>
25 #include <linux/timex.h>
28 #include <asm/timer.h> /* Needed for recalibrate_cpu_khz() */
30 #include <asm/system.h>
31 #include <asm/cpu_device_id.h>
33 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
34 #include <linux/acpi.h>
35 #include <acpi/processor.h>
38 #include "powernow-k7.h"
40 #define PFX "powernow: "
60 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
61 union powernow_acpi_control_t
{
72 /* divide by 1000 to get VCore voltage in V. */
73 static const int mobile_vid_table
[32] = {
74 2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
75 1600, 1550, 1500, 1450, 1400, 1350, 1300, 0,
76 1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
77 1075, 1050, 1025, 1000, 975, 950, 925, 0,
80 /* divide by 10 to get FID. */
81 static const 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 static int check_fsb(unsigned int fsbspeed
)
108 unsigned int f
= fsb
/ 1000;
110 delta
= (fsbspeed
> f
) ? fsbspeed
- f
: f
- fsbspeed
;
114 static const struct x86_cpu_id powernow_k7_cpuids
[] = {
115 { X86_VENDOR_AMD
, 7, },
118 MODULE_DEVICE_TABLE(x86cpu
, powernow_k7_cpuids
);
120 static int check_powernow(void)
122 struct cpuinfo_x86
*c
= &cpu_data(0);
123 unsigned int maxei
, eax
, ebx
, ecx
, edx
;
125 if (!x86_match_cpu(powernow_k7_cpuids
))
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, "
139 "enabling errata workarounds\n");
143 cpuid(0x80000007, &eax
, &ebx
, &ecx
, &edx
);
145 /* Check we can actually do something before we say anything.*/
146 if (!(edx
& (1 << 1 | 1 << 2)))
149 printk(KERN_INFO PFX
"PowerNOW! Technology present. Can scale: ");
156 if ((edx
& (1 << 1 | 1 << 2)) == 0x6)
168 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
169 static void invalidate_entry(unsigned int entry
)
171 powernow_table
[entry
].frequency
= CPUFREQ_ENTRY_INVALID
;
175 static int get_ranges(unsigned char *pst
)
181 powernow_table
= kzalloc((sizeof(struct cpufreq_frequency_table
) *
182 (number_scales
+ 1)), GFP_KERNEL
);
186 for (j
= 0 ; j
< number_scales
; j
++) {
189 powernow_table
[j
].frequency
= (fsb
* fid_codes
[fid
]) / 10;
190 powernow_table
[j
].index
= fid
; /* lower 8 bits */
192 speed
= powernow_table
[j
].frequency
;
194 if ((fid_codes
[fid
] % 10) == 5) {
195 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
201 if (speed
< minimum_speed
)
202 minimum_speed
= speed
;
203 if (speed
> maximum_speed
)
204 maximum_speed
= speed
;
207 powernow_table
[j
].index
|= (vid
<< 8); /* upper 8 bits */
209 pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
210 "VID: 0x%x (%d.%03dV)\n", fid
, fid_codes
[fid
] / 10,
211 fid_codes
[fid
] % 10, speed
/1000, vid
,
212 mobile_vid_table
[vid
]/1000,
213 mobile_vid_table
[vid
]%1000);
215 powernow_table
[number_scales
].frequency
= CPUFREQ_TABLE_END
;
216 powernow_table
[number_scales
].index
= 0;
222 static void change_FID(int fid
)
224 union msr_fidvidctl fidvidctl
;
226 rdmsrl(MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
227 if (fidvidctl
.bits
.FID
!= fid
) {
228 fidvidctl
.bits
.SGTC
= latency
;
229 fidvidctl
.bits
.FID
= fid
;
230 fidvidctl
.bits
.VIDC
= 0;
231 fidvidctl
.bits
.FIDC
= 1;
232 wrmsrl(MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
237 static void change_VID(int vid
)
239 union msr_fidvidctl fidvidctl
;
241 rdmsrl(MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
242 if (fidvidctl
.bits
.VID
!= vid
) {
243 fidvidctl
.bits
.SGTC
= latency
;
244 fidvidctl
.bits
.VID
= vid
;
245 fidvidctl
.bits
.FIDC
= 0;
246 fidvidctl
.bits
.VIDC
= 1;
247 wrmsrl(MSR_K7_FID_VID_CTL
, fidvidctl
.val
);
252 static void change_speed(unsigned int index
)
255 struct cpufreq_freqs freqs
;
256 union msr_fidvidstatus fidvidstatus
;
259 /* fid are the lower 8 bits of the index we stored into
260 * the cpufreq frequency table in powernow_decode_bios,
261 * vid are the upper 8 bits.
264 fid
= powernow_table
[index
].index
& 0xFF;
265 vid
= (powernow_table
[index
].index
& 0xFF00) >> 8;
269 rdmsrl(MSR_K7_FID_VID_STATUS
, fidvidstatus
.val
);
270 cfid
= fidvidstatus
.bits
.CFID
;
271 freqs
.old
= fsb
* fid_codes
[cfid
] / 10;
273 freqs
.new = powernow_table
[index
].frequency
;
275 cpufreq_notify_transition(&freqs
, CPUFREQ_PRECHANGE
);
277 /* Now do the magic poking into the MSRs. */
279 if (have_a0
== 1) /* A0 errata 5 */
282 if (freqs
.old
> freqs
.new) {
283 /* Going down, so change FID first */
287 /* Going up, so change VID first */
296 cpufreq_notify_transition(&freqs
, CPUFREQ_POSTCHANGE
);
300 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
302 static struct acpi_processor_performance
*acpi_processor_perf
;
304 static int powernow_acpi_init(void)
308 union powernow_acpi_control_t pc
;
310 if (acpi_processor_perf
!= NULL
&& powernow_table
!= NULL
) {
315 acpi_processor_perf
= kzalloc(sizeof(struct acpi_processor_performance
),
317 if (!acpi_processor_perf
) {
322 if (!zalloc_cpumask_var(&acpi_processor_perf
->shared_cpu_map
,
328 if (acpi_processor_register_performance(acpi_processor_perf
, 0)) {
333 if (acpi_processor_perf
->control_register
.space_id
!=
334 ACPI_ADR_SPACE_FIXED_HARDWARE
) {
339 if (acpi_processor_perf
->status_register
.space_id
!=
340 ACPI_ADR_SPACE_FIXED_HARDWARE
) {
345 number_scales
= acpi_processor_perf
->state_count
;
347 if (number_scales
< 2) {
352 powernow_table
= kzalloc((sizeof(struct cpufreq_frequency_table
) *
353 (number_scales
+ 1)), GFP_KERNEL
);
354 if (!powernow_table
) {
359 pc
.val
= (unsigned long) acpi_processor_perf
->states
[0].control
;
360 for (i
= 0; i
< number_scales
; i
++) {
362 struct acpi_processor_px
*state
=
363 &acpi_processor_perf
->states
[i
];
364 unsigned int speed
, speed_mhz
;
366 pc
.val
= (unsigned long) state
->control
;
367 pr_debug("acpi: P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
369 (u32
) state
->core_frequency
,
371 (u32
) state
->transition_latency
,
372 (u32
) state
->control
,
378 powernow_table
[i
].frequency
= fsb
* fid_codes
[fid
] / 10;
379 powernow_table
[i
].index
= fid
; /* lower 8 bits */
380 powernow_table
[i
].index
|= (vid
<< 8); /* upper 8 bits */
382 speed
= powernow_table
[i
].frequency
;
383 speed_mhz
= speed
/ 1000;
385 /* processor_perflib will multiply the MHz value by 1000 to
386 * get a KHz value (e.g. 1266000). However, powernow-k7 works
387 * with true KHz values (e.g. 1266768). To ensure that all
388 * powernow frequencies are available, we must ensure that
389 * ACPI doesn't restrict them, so we round up the MHz value
390 * to ensure that perflib's computed KHz value is greater than
391 * or equal to powernow's KHz value.
393 if (speed
% 1000 > 0)
396 if ((fid_codes
[fid
] % 10) == 5) {
401 pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
402 "VID: 0x%x (%d.%03dV)\n", fid
, fid_codes
[fid
] / 10,
403 fid_codes
[fid
] % 10, speed_mhz
, vid
,
404 mobile_vid_table
[vid
]/1000,
405 mobile_vid_table
[vid
]%1000);
407 if (state
->core_frequency
!= speed_mhz
) {
408 state
->core_frequency
= speed_mhz
;
409 pr_debug(" Corrected ACPI frequency to %d\n",
413 if (latency
< pc
.bits
.sgtc
)
414 latency
= pc
.bits
.sgtc
;
416 if (speed
< minimum_speed
)
417 minimum_speed
= speed
;
418 if (speed
> maximum_speed
)
419 maximum_speed
= speed
;
422 powernow_table
[i
].frequency
= CPUFREQ_TABLE_END
;
423 powernow_table
[i
].index
= 0;
425 /* notify BIOS that we exist */
426 acpi_processor_notify_smm(THIS_MODULE
);
431 acpi_processor_unregister_performance(acpi_processor_perf
, 0);
433 free_cpumask_var(acpi_processor_perf
->shared_cpu_map
);
435 kfree(acpi_processor_perf
);
437 printk(KERN_WARNING PFX
"ACPI perflib can not be used on "
439 acpi_processor_perf
= NULL
;
443 static int powernow_acpi_init(void)
445 printk(KERN_INFO PFX
"no support for ACPI processor found."
446 " Please recompile your kernel with ACPI processor\n");
451 static void print_pst_entry(struct pst_s
*pst
, unsigned int j
)
453 pr_debug("PST:%d (@%p)\n", j
, pst
);
454 pr_debug(" cpuid: 0x%x fsb: %d maxFID: 0x%x startvid: 0x%x\n",
455 pst
->cpuid
, pst
->fsbspeed
, pst
->maxfid
, pst
->startvid
);
458 static int powernow_decode_bios(int maxfid
, int startvid
)
467 etuple
= cpuid_eax(0x80000001);
469 for (i
= 0xC0000; i
< 0xffff0 ; i
+= 16) {
473 if (memcmp(p
, "AMDK7PNOW!", 10) == 0) {
474 pr_debug("Found PSB header at %p\n", p
);
475 psb
= (struct psb_s
*) p
;
476 pr_debug("Table version: 0x%x\n", psb
->tableversion
);
477 if (psb
->tableversion
!= 0x12) {
478 printk(KERN_INFO PFX
"Sorry, only v1.2 tables"
479 " supported right now\n");
483 pr_debug("Flags: 0x%x\n", psb
->flags
);
484 if ((psb
->flags
& 1) == 0)
485 pr_debug("Mobile voltage regulator\n");
487 pr_debug("Desktop voltage regulator\n");
489 latency
= psb
->settlingtime
;
491 printk(KERN_INFO PFX
"BIOS set settling time "
492 "to %d microseconds. "
493 "Should be at least 100. "
494 "Correcting.\n", latency
);
497 pr_debug("Settling Time: %d microseconds.\n",
499 pr_debug("Has %d PST tables. (Only dumping ones "
500 "relevant to this CPU).\n",
503 p
+= sizeof(struct psb_s
);
505 pst
= (struct pst_s
*) p
;
507 for (j
= 0; j
< psb
->numpst
; j
++) {
508 pst
= (struct pst_s
*) p
;
509 number_scales
= pst
->numpstates
;
511 if ((etuple
== pst
->cpuid
) &&
512 check_fsb(pst
->fsbspeed
) &&
513 (maxfid
== pst
->maxfid
) &&
514 (startvid
== pst
->startvid
)) {
515 print_pst_entry(pst
, j
);
516 p
= (char *)pst
+ sizeof(struct pst_s
);
521 p
= (char *)pst
+ sizeof(struct pst_s
);
522 for (k
= 0; k
< number_scales
; k
++)
526 printk(KERN_INFO PFX
"No PST tables match this cpuid "
528 printk(KERN_INFO PFX
"This is indicative of a broken "
540 static int powernow_target(struct cpufreq_policy
*policy
,
541 unsigned int target_freq
,
542 unsigned int relation
)
544 unsigned int newstate
;
546 if (cpufreq_frequency_table_target(policy
, powernow_table
, target_freq
,
547 relation
, &newstate
))
550 change_speed(newstate
);
556 static int powernow_verify(struct cpufreq_policy
*policy
)
558 return cpufreq_frequency_table_verify(policy
, powernow_table
);
562 * We use the fact that the bus frequency is somehow
563 * a multiple of 100000/3 khz, then we compute sgtc according
565 * That way, we match more how AMD thinks all of that work.
566 * We will then get the same kind of behaviour already tested under
567 * the "well-known" other OS.
569 static int __cpuinit
fixup_sgtc(void)
580 sgtc
= 100 * m
* latency
;
582 if (sgtc
> 0xfffff) {
583 printk(KERN_WARNING PFX
"SGTC too large %d\n", sgtc
);
589 static unsigned int powernow_get(unsigned int cpu
)
591 union msr_fidvidstatus fidvidstatus
;
596 rdmsrl(MSR_K7_FID_VID_STATUS
, fidvidstatus
.val
);
597 cfid
= fidvidstatus
.bits
.CFID
;
599 return fsb
* fid_codes
[cfid
] / 10;
603 static int __cpuinit
acer_cpufreq_pst(const struct dmi_system_id
*d
)
605 printk(KERN_WARNING PFX
606 "%s laptop with broken PST tables in BIOS detected.\n",
608 printk(KERN_WARNING PFX
609 "You need to downgrade to 3A21 (09/09/2002), or try a newer "
610 "BIOS than 3A71 (01/20/2003)\n");
611 printk(KERN_WARNING PFX
612 "cpufreq scaling has been disabled as a result of this.\n");
617 * Some Athlon laptops have really fucked PST tables.
618 * A BIOS update is all that can save them.
619 * Mention this, and disable cpufreq.
621 static struct dmi_system_id __cpuinitdata powernow_dmi_table
[] = {
623 .callback
= acer_cpufreq_pst
,
624 .ident
= "Acer Aspire",
626 DMI_MATCH(DMI_SYS_VENDOR
, "Insyde Software"),
627 DMI_MATCH(DMI_BIOS_VERSION
, "3A71"),
633 static int __cpuinit
powernow_cpu_init(struct cpufreq_policy
*policy
)
635 union msr_fidvidstatus fidvidstatus
;
638 if (policy
->cpu
!= 0)
641 rdmsrl(MSR_K7_FID_VID_STATUS
, fidvidstatus
.val
);
643 recalibrate_cpu_khz();
645 fsb
= (10 * cpu_khz
) / fid_codes
[fidvidstatus
.bits
.CFID
];
647 printk(KERN_WARNING PFX
"can not determine bus frequency\n");
650 pr_debug("FSB: %3dMHz\n", fsb
/1000);
652 if (dmi_check_system(powernow_dmi_table
) || acpi_force
) {
653 printk(KERN_INFO PFX
"PSB/PST known to be broken. "
654 "Trying ACPI instead\n");
655 result
= powernow_acpi_init();
657 result
= powernow_decode_bios(fidvidstatus
.bits
.MFID
,
658 fidvidstatus
.bits
.SVID
);
660 printk(KERN_INFO PFX
"Trying ACPI perflib\n");
664 result
= powernow_acpi_init();
667 "ACPI and legacy methods failed\n");
670 /* SGTC use the bus clock as timer */
671 latency
= fixup_sgtc();
672 printk(KERN_INFO PFX
"SGTC: %d\n", latency
);
679 printk(KERN_INFO PFX
"Minimum speed %d MHz. Maximum speed %d MHz.\n",
680 minimum_speed
/1000, maximum_speed
/1000);
682 policy
->cpuinfo
.transition_latency
=
683 cpufreq_scale(2000000UL, fsb
, latency
);
685 policy
->cur
= powernow_get(0);
687 cpufreq_frequency_table_get_attr(powernow_table
, policy
->cpu
);
689 return cpufreq_frequency_table_cpuinfo(policy
, powernow_table
);
692 static int powernow_cpu_exit(struct cpufreq_policy
*policy
)
694 cpufreq_frequency_table_put_attr(policy
->cpu
);
696 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
697 if (acpi_processor_perf
) {
698 acpi_processor_unregister_performance(acpi_processor_perf
, 0);
699 free_cpumask_var(acpi_processor_perf
->shared_cpu_map
);
700 kfree(acpi_processor_perf
);
704 kfree(powernow_table
);
708 static struct freq_attr
*powernow_table_attr
[] = {
709 &cpufreq_freq_attr_scaling_available_freqs
,
713 static struct cpufreq_driver powernow_driver
= {
714 .verify
= powernow_verify
,
715 .target
= powernow_target
,
717 #ifdef CONFIG_X86_POWERNOW_K7_ACPI
718 .bios_limit
= acpi_processor_get_bios_limit
,
720 .init
= powernow_cpu_init
,
721 .exit
= powernow_cpu_exit
,
722 .name
= "powernow-k7",
723 .owner
= THIS_MODULE
,
724 .attr
= powernow_table_attr
,
727 static int __init
powernow_init(void)
729 if (check_powernow() == 0)
731 return cpufreq_register_driver(&powernow_driver
);
735 static void __exit
powernow_exit(void)
737 cpufreq_unregister_driver(&powernow_driver
);
740 module_param(acpi_force
, int, 0444);
741 MODULE_PARM_DESC(acpi_force
, "Force ACPI to be used.");
743 MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
744 MODULE_DESCRIPTION("Powernow driver for AMD K7 processors.");
745 MODULE_LICENSE("GPL");
747 late_initcall(powernow_init
);
748 module_exit(powernow_exit
);