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>
32
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
33
#include <linux/acpi.h>
34
#include <acpi/processor.h>
37
#include "powernow-k7.h"
39
#define PFX "powernow: "
59
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
60
union powernow_acpi_control_t {
71
/* divide by 1000 to get VCore voltage in V. */
72
static const 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,
79
/* divide by 10 to get FID. */
80
static const int fid_codes[32] = {
81
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,
87
/* This parameter is used in order to force ACPI instead of legacy method for
88
* configuration purpose.
91
static int acpi_force;
93
static struct cpufreq_frequency_table *powernow_table;
95
static unsigned int can_scale_bus;
96
static unsigned int can_scale_vid;
97
static unsigned int minimum_speed = -1;
98
static unsigned int maximum_speed;
99
static unsigned int number_scales;
100
static unsigned int fsb;
101
static unsigned int latency;
104
static int check_fsb(unsigned int fsbspeed)
107
unsigned int f = fsb / 1000;
109
delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed;
113
static int check_powernow(void)
115
struct cpuinfo_x86 *c = &cpu_data(0);
116
unsigned int maxei, eax, ebx, ecx, edx;
118
if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 6)) {
120
printk(KERN_INFO PFX "This module only works with "
126
/* Get maximum capabilities */
127
maxei = cpuid_eax(0x80000000);
128
if (maxei < 0x80000007) { /* Any powernow info ? */
130
printk(KERN_INFO PFX "No powernow capabilities detected\n");
135
if ((c->x86_model == 6) && (c->x86_mask == 0)) {
136
printk(KERN_INFO PFX "K7 660[A0] core detected, "
137
"enabling errata workarounds\n");
141
cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
143
/* Check we can actually do something before we say anything.*/
144
if (!(edx & (1 << 1 | 1 << 2)))
147
printk(KERN_INFO PFX "PowerNOW! Technology present. Can scale: ");
154
if ((edx & (1 << 1 | 1 << 2)) == 0x6)
166
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
167
static void invalidate_entry(unsigned int entry)
169
powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
173
static int get_ranges(unsigned char *pst)
179
powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
180
(number_scales + 1)), GFP_KERNEL);
184
for (j = 0 ; j < number_scales; j++) {
187
powernow_table[j].frequency = (fsb * fid_codes[fid]) / 10;
188
powernow_table[j].index = fid; /* lower 8 bits */
190
speed = powernow_table[j].frequency;
192
if ((fid_codes[fid] % 10) == 5) {
193
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
199
if (speed < minimum_speed)
200
minimum_speed = speed;
201
if (speed > maximum_speed)
202
maximum_speed = speed;
205
powernow_table[j].index |= (vid << 8); /* upper 8 bits */
207
pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
208
"VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
209
fid_codes[fid] % 10, speed/1000, vid,
210
mobile_vid_table[vid]/1000,
211
mobile_vid_table[vid]%1000);
213
powernow_table[number_scales].frequency = CPUFREQ_TABLE_END;
214
powernow_table[number_scales].index = 0;
220
static void change_FID(int fid)
222
union msr_fidvidctl fidvidctl;
224
rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
225
if (fidvidctl.bits.FID != fid) {
226
fidvidctl.bits.SGTC = latency;
227
fidvidctl.bits.FID = fid;
228
fidvidctl.bits.VIDC = 0;
229
fidvidctl.bits.FIDC = 1;
230
wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
235
static void change_VID(int vid)
237
union msr_fidvidctl fidvidctl;
239
rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
240
if (fidvidctl.bits.VID != vid) {
241
fidvidctl.bits.SGTC = latency;
242
fidvidctl.bits.VID = vid;
243
fidvidctl.bits.FIDC = 0;
244
fidvidctl.bits.VIDC = 1;
245
wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
250
static void change_speed(unsigned int index)
253
struct cpufreq_freqs freqs;
254
union msr_fidvidstatus fidvidstatus;
257
/* fid are the lower 8 bits of the index we stored into
258
* the cpufreq frequency table in powernow_decode_bios,
259
* vid are the upper 8 bits.
262
fid = powernow_table[index].index & 0xFF;
263
vid = (powernow_table[index].index & 0xFF00) >> 8;
267
rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
268
cfid = fidvidstatus.bits.CFID;
269
freqs.old = fsb * fid_codes[cfid] / 10;
271
freqs.new = powernow_table[index].frequency;
273
cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
275
/* Now do the magic poking into the MSRs. */
277
if (have_a0 == 1) /* A0 errata 5 */
280
if (freqs.old > freqs.new) {
281
/* Going down, so change FID first */
285
/* Going up, so change VID first */
294
cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
298
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
300
static struct acpi_processor_performance *acpi_processor_perf;
302
static int powernow_acpi_init(void)
306
union powernow_acpi_control_t pc;
308
if (acpi_processor_perf != NULL && powernow_table != NULL) {
313
acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance),
315
if (!acpi_processor_perf) {
320
if (!zalloc_cpumask_var(&acpi_processor_perf->shared_cpu_map,
326
if (acpi_processor_register_performance(acpi_processor_perf, 0)) {
331
if (acpi_processor_perf->control_register.space_id !=
332
ACPI_ADR_SPACE_FIXED_HARDWARE) {
337
if (acpi_processor_perf->status_register.space_id !=
338
ACPI_ADR_SPACE_FIXED_HARDWARE) {
343
number_scales = acpi_processor_perf->state_count;
345
if (number_scales < 2) {
350
powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
351
(number_scales + 1)), GFP_KERNEL);
352
if (!powernow_table) {
357
pc.val = (unsigned long) acpi_processor_perf->states[0].control;
358
for (i = 0; i < number_scales; i++) {
360
struct acpi_processor_px *state =
361
&acpi_processor_perf->states[i];
362
unsigned int speed, speed_mhz;
364
pc.val = (unsigned long) state->control;
365
pr_debug("acpi: P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
367
(u32) state->core_frequency,
369
(u32) state->transition_latency,
370
(u32) state->control,
376
powernow_table[i].frequency = fsb * fid_codes[fid] / 10;
377
powernow_table[i].index = fid; /* lower 8 bits */
378
powernow_table[i].index |= (vid << 8); /* upper 8 bits */
380
speed = powernow_table[i].frequency;
381
speed_mhz = speed / 1000;
383
/* processor_perflib will multiply the MHz value by 1000 to
384
* get a KHz value (e.g. 1266000). However, powernow-k7 works
385
* with true KHz values (e.g. 1266768). To ensure that all
386
* powernow frequencies are available, we must ensure that
387
* ACPI doesn't restrict them, so we round up the MHz value
388
* to ensure that perflib's computed KHz value is greater than
389
* or equal to powernow's KHz value.
391
if (speed % 1000 > 0)
394
if ((fid_codes[fid] % 10) == 5) {
399
pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) "
400
"VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
401
fid_codes[fid] % 10, speed_mhz, vid,
402
mobile_vid_table[vid]/1000,
403
mobile_vid_table[vid]%1000);
405
if (state->core_frequency != speed_mhz) {
406
state->core_frequency = speed_mhz;
407
pr_debug(" Corrected ACPI frequency to %d\n",
411
if (latency < pc.bits.sgtc)
412
latency = pc.bits.sgtc;
414
if (speed < minimum_speed)
415
minimum_speed = speed;
416
if (speed > maximum_speed)
417
maximum_speed = speed;
420
powernow_table[i].frequency = CPUFREQ_TABLE_END;
421
powernow_table[i].index = 0;
423
/* notify BIOS that we exist */
424
acpi_processor_notify_smm(THIS_MODULE);
429
acpi_processor_unregister_performance(acpi_processor_perf, 0);
431
free_cpumask_var(acpi_processor_perf->shared_cpu_map);
433
kfree(acpi_processor_perf);
435
printk(KERN_WARNING PFX "ACPI perflib can not be used on "
437
acpi_processor_perf = NULL;
441
static int powernow_acpi_init(void)
443
printk(KERN_INFO PFX "no support for ACPI processor found."
444
" Please recompile your kernel with ACPI processor\n");
449
static void print_pst_entry(struct pst_s *pst, unsigned int j)
451
pr_debug("PST:%d (@%p)\n", j, pst);
452
pr_debug(" cpuid: 0x%x fsb: %d maxFID: 0x%x startvid: 0x%x\n",
453
pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid);
456
static int powernow_decode_bios(int maxfid, int startvid)
465
etuple = cpuid_eax(0x80000001);
467
for (i = 0xC0000; i < 0xffff0 ; i += 16) {
471
if (memcmp(p, "AMDK7PNOW!", 10) == 0) {
472
pr_debug("Found PSB header at %p\n", p);
473
psb = (struct psb_s *) p;
474
pr_debug("Table version: 0x%x\n", psb->tableversion);
475
if (psb->tableversion != 0x12) {
476
printk(KERN_INFO PFX "Sorry, only v1.2 tables"
477
" supported right now\n");
481
pr_debug("Flags: 0x%x\n", psb->flags);
482
if ((psb->flags & 1) == 0)
483
pr_debug("Mobile voltage regulator\n");
485
pr_debug("Desktop voltage regulator\n");
487
latency = psb->settlingtime;
489
printk(KERN_INFO PFX "BIOS set settling time "
490
"to %d microseconds. "
491
"Should be at least 100. "
492
"Correcting.\n", latency);
495
pr_debug("Settling Time: %d microseconds.\n",
497
pr_debug("Has %d PST tables. (Only dumping ones "
498
"relevant to this CPU).\n",
501
p += sizeof(struct psb_s);
503
pst = (struct pst_s *) p;
505
for (j = 0; j < psb->numpst; j++) {
506
pst = (struct pst_s *) p;
507
number_scales = pst->numpstates;
509
if ((etuple == pst->cpuid) &&
510
check_fsb(pst->fsbspeed) &&
511
(maxfid == pst->maxfid) &&
512
(startvid == pst->startvid)) {
513
print_pst_entry(pst, j);
514
p = (char *)pst + sizeof(struct pst_s);
519
p = (char *)pst + sizeof(struct pst_s);
520
for (k = 0; k < number_scales; k++)
524
printk(KERN_INFO PFX "No PST tables match this cpuid "
526
printk(KERN_INFO PFX "This is indicative of a broken "
538
static int powernow_target(struct cpufreq_policy *policy,
539
unsigned int target_freq,
540
unsigned int relation)
542
unsigned int newstate;
544
if (cpufreq_frequency_table_target(policy, powernow_table, target_freq,
545
relation, &newstate))
548
change_speed(newstate);
554
static int powernow_verify(struct cpufreq_policy *policy)
556
return cpufreq_frequency_table_verify(policy, powernow_table);
560
* We use the fact that the bus frequency is somehow
561
* a multiple of 100000/3 khz, then we compute sgtc according
563
* That way, we match more how AMD thinks all of that work.
564
* We will then get the same kind of behaviour already tested under
565
* the "well-known" other OS.
567
static int __cpuinit fixup_sgtc(void)
578
sgtc = 100 * m * latency;
580
if (sgtc > 0xfffff) {
581
printk(KERN_WARNING PFX "SGTC too large %d\n", sgtc);
587
static unsigned int powernow_get(unsigned int cpu)
589
union msr_fidvidstatus fidvidstatus;
594
rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
595
cfid = fidvidstatus.bits.CFID;
597
return fsb * fid_codes[cfid] / 10;
601
static int __cpuinit acer_cpufreq_pst(const struct dmi_system_id *d)
603
printk(KERN_WARNING PFX
604
"%s laptop with broken PST tables in BIOS detected.\n",
606
printk(KERN_WARNING PFX
607
"You need to downgrade to 3A21 (09/09/2002), or try a newer "
608
"BIOS than 3A71 (01/20/2003)\n");
609
printk(KERN_WARNING PFX
610
"cpufreq scaling has been disabled as a result of this.\n");
615
* Some Athlon laptops have really fucked PST tables.
616
* A BIOS update is all that can save them.
617
* Mention this, and disable cpufreq.
619
static struct dmi_system_id __cpuinitdata powernow_dmi_table[] = {
621
.callback = acer_cpufreq_pst,
622
.ident = "Acer Aspire",
624
DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"),
625
DMI_MATCH(DMI_BIOS_VERSION, "3A71"),
631
static int __cpuinit powernow_cpu_init(struct cpufreq_policy *policy)
633
union msr_fidvidstatus fidvidstatus;
636
if (policy->cpu != 0)
639
rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
641
recalibrate_cpu_khz();
643
fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.CFID];
645
printk(KERN_WARNING PFX "can not determine bus frequency\n");
648
pr_debug("FSB: %3dMHz\n", fsb/1000);
650
if (dmi_check_system(powernow_dmi_table) || acpi_force) {
651
printk(KERN_INFO PFX "PSB/PST known to be broken. "
652
"Trying ACPI instead\n");
653
result = powernow_acpi_init();
655
result = powernow_decode_bios(fidvidstatus.bits.MFID,
656
fidvidstatus.bits.SVID);
658
printk(KERN_INFO PFX "Trying ACPI perflib\n");
662
result = powernow_acpi_init();
665
"ACPI and legacy methods failed\n");
668
/* SGTC use the bus clock as timer */
669
latency = fixup_sgtc();
670
printk(KERN_INFO PFX "SGTC: %d\n", latency);
677
printk(KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n",
678
minimum_speed/1000, maximum_speed/1000);
680
policy->cpuinfo.transition_latency =
681
cpufreq_scale(2000000UL, fsb, latency);
683
policy->cur = powernow_get(0);
685
cpufreq_frequency_table_get_attr(powernow_table, policy->cpu);
687
return cpufreq_frequency_table_cpuinfo(policy, powernow_table);
690
static int powernow_cpu_exit(struct cpufreq_policy *policy)
692
cpufreq_frequency_table_put_attr(policy->cpu);
694
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
695
if (acpi_processor_perf) {
696
acpi_processor_unregister_performance(acpi_processor_perf, 0);
697
free_cpumask_var(acpi_processor_perf->shared_cpu_map);
698
kfree(acpi_processor_perf);
702
kfree(powernow_table);
706
static struct freq_attr *powernow_table_attr[] = {
707
&cpufreq_freq_attr_scaling_available_freqs,
711
static struct cpufreq_driver powernow_driver = {
712
.verify = powernow_verify,
713
.target = powernow_target,
715
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
716
.bios_limit = acpi_processor_get_bios_limit,
718
.init = powernow_cpu_init,
719
.exit = powernow_cpu_exit,
720
.name = "powernow-k7",
721
.owner = THIS_MODULE,
722
.attr = powernow_table_attr,
725
static int __init powernow_init(void)
727
if (check_powernow() == 0)
729
return cpufreq_register_driver(&powernow_driver);
733
static void __exit powernow_exit(void)
735
cpufreq_unregister_driver(&powernow_driver);
738
module_param(acpi_force, int, 0444);
739
MODULE_PARM_DESC(acpi_force, "Force ACPI to be used.");
741
MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
742
MODULE_DESCRIPTION("Powernow driver for AMD K7 processors.");
743
MODULE_LICENSE("GPL");
745
late_initcall(powernow_init);
746
module_exit(powernow_exit);