powernow-k7.c 17.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 *  AMD K7 Powernow driver.
Dave Jones's avatar
Dave Jones committed
3
 *  (C) 2003 Dave Jones on behalf of SuSE Labs.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8
 *  (C) 2003-2004 Dave Jones <davej@redhat.com>
 *
 *  Licensed under the terms of the GNU GPL License version 2.
 *  Based upon datasheets & sample CPUs kindly provided by AMD.
 *
9 10 11 12 13 14
 * Errata 5:
 *  CPU may fail to execute a FID/VID change in presence of interrupt.
 *  - We cli/sti on stepping A0 CPUs around the FID/VID transition.
 * Errata 15:
 *  CPU with half frequency multipliers may hang upon wakeup from disconnect.
 *  - We disable half multipliers if ACPI is used on A0 stepping CPUs.
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20 21 22 23 24
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/dmi.h>
25 26
#include <linux/timex.h>
#include <linux/io.h>
Linus Torvalds's avatar
Linus Torvalds committed
27

28
#include <asm/timer.h>		/* Needed for recalibrate_cpu_khz() */
Linus Torvalds's avatar
Linus Torvalds committed
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
#include <asm/msr.h>
#include <asm/system.h>

#ifdef CONFIG_X86_POWERNOW_K7_ACPI
#include <linux/acpi.h>
#include <acpi/processor.h>
#endif

#include "powernow-k7.h"

#define PFX "powernow: "


struct psb_s {
	u8 signature[10];
	u8 tableversion;
	u8 flags;
	u16 settlingtime;
	u8 reserved1;
	u8 numpst;
};

struct pst_s {
	u32 cpuid;
	u8 fsbspeed;
	u8 maxfid;
	u8 startvid;
	u8 numpstates;
};

#ifdef CONFIG_X86_POWERNOW_K7_ACPI
union powernow_acpi_control_t {
	struct {
		unsigned long fid:5,
63 64 65
			vid:5,
			sgtc:20,
			res1:2;
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69 70 71
	} bits;
	unsigned long val;
};
#endif

/* divide by 1000 to get VCore voltage in V. */
72
static const int mobile_vid_table[32] = {
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78 79
    2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
    1600, 1550, 1500, 1450, 1400, 1350, 1300, 0,
    1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
    1075, 1050, 1025, 1000, 975, 950, 925, 0,
};

/* divide by 10 to get FID. */
80
static const int fid_codes[32] = {
Linus Torvalds's avatar
Linus Torvalds committed
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
    110, 115, 120, 125, 50, 55, 60, 65,
    70, 75, 80, 85, 90, 95, 100, 105,
    30, 190, 40, 200, 130, 135, 140, 210,
    150, 225, 160, 165, 170, 180, -1, -1,
};

/* This parameter is used in order to force ACPI instead of legacy method for
 * configuration purpose.
 */

static int acpi_force;

static struct cpufreq_frequency_table *powernow_table;

static unsigned int can_scale_bus;
static unsigned int can_scale_vid;
97
static unsigned int minimum_speed = -1;
Linus Torvalds's avatar
Linus Torvalds committed
98 99 100 101 102 103 104 105 106 107 108 109
static unsigned int maximum_speed;
static unsigned int number_scales;
static unsigned int fsb;
static unsigned int latency;
static char have_a0;

static int check_fsb(unsigned int fsbspeed)
{
	int delta;
	unsigned int f = fsb / 1000;

	delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed;
110
	return delta < 5;
Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114
}

static int check_powernow(void)
{
115
	struct cpuinfo_x86 *c = &cpu_data(0);
Linus Torvalds's avatar
Linus Torvalds committed
116 117
	unsigned int maxei, eax, ebx, ecx, edx;

118
	if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 6)) {
Linus Torvalds's avatar
Linus Torvalds committed
119
#ifdef MODULE
120 121
		printk(KERN_INFO PFX "This module only works with "
				"AMD K7 CPUs\n");
Linus Torvalds's avatar
Linus Torvalds committed
122 123 124 125 126
#endif
		return 0;
	}

	/* Get maximum capabilities */
127
	maxei = cpuid_eax(0x80000000);
Linus Torvalds's avatar
Linus Torvalds committed
128 129
	if (maxei < 0x80000007) {	/* Any powernow info ? */
#ifdef MODULE
130
		printk(KERN_INFO PFX "No powernow capabilities detected\n");
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134 135
#endif
		return 0;
	}

	if ((c->x86_model == 6) && (c->x86_mask == 0)) {
136 137
		printk(KERN_INFO PFX "K7 660[A0] core detected, "
				"enabling errata workarounds\n");
Linus Torvalds's avatar
Linus Torvalds committed
138 139 140 141 142 143 144 145 146
		have_a0 = 1;
	}

	cpuid(0x80000007, &eax, &ebx, &ecx, &edx);

	/* Check we can actually do something before we say anything.*/
	if (!(edx & (1 << 1 | 1 << 2)))
		return 0;

147
	printk(KERN_INFO PFX "PowerNOW! Technology present. Can scale: ");
Linus Torvalds's avatar
Linus Torvalds committed
148 149

	if (edx & 1 << 1) {
150 151
		printk("frequency");
		can_scale_bus = 1;
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154
	}

	if ((edx & (1 << 1 | 1 << 2)) == 0x6)
155
		printk(" and ");
Linus Torvalds's avatar
Linus Torvalds committed
156 157

	if (edx & 1 << 2) {
158 159
		printk("voltage");
		can_scale_vid = 1;
Linus Torvalds's avatar
Linus Torvalds committed
160 161
	}

162
	printk(".\n");
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165
	return 1;
}

166
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
167 168 169 170
static void invalidate_entry(unsigned int entry)
{
	powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
}
171
#endif
Linus Torvalds's avatar
Linus Torvalds committed
172

173
static int get_ranges(unsigned char *pst)
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176 177 178
{
	unsigned int j;
	unsigned int speed;
	u8 fid, vid;

179 180
	powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
				(number_scales + 1)), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
181 182 183
	if (!powernow_table)
		return -ENOMEM;

184
	for (j = 0 ; j < number_scales; j++) {
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188 189 190 191
		fid = *pst++;

		powernow_table[j].frequency = (fsb * fid_codes[fid]) / 10;
		powernow_table[j].index = fid; /* lower 8 bits */

		speed = powernow_table[j].frequency;

192
		if ((fid_codes[fid] % 10) == 5) {
Linus Torvalds's avatar
Linus Torvalds committed
193 194
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
			if (have_a0 == 1)
195
				invalidate_entry(j);
Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199 200 201 202 203 204 205 206
#endif
		}

		if (speed < minimum_speed)
			minimum_speed = speed;
		if (speed > maximum_speed)
			maximum_speed = speed;

		vid = *pst++;
		powernow_table[j].index |= (vid << 8); /* upper 8 bits */

207
		pr_debug("   FID: 0x%x (%d.%dx [%dMHz])  "
208 209
			 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
			 fid_codes[fid] % 10, speed/1000, vid,
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213 214 215 216 217 218 219 220 221 222 223
			 mobile_vid_table[vid]/1000,
			 mobile_vid_table[vid]%1000);
	}
	powernow_table[number_scales].frequency = CPUFREQ_TABLE_END;
	powernow_table[number_scales].index = 0;

	return 0;
}


static void change_FID(int fid)
{
	union msr_fidvidctl fidvidctl;

224
	rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229
	if (fidvidctl.bits.FID != fid) {
		fidvidctl.bits.SGTC = latency;
		fidvidctl.bits.FID = fid;
		fidvidctl.bits.VIDC = 0;
		fidvidctl.bits.FIDC = 1;
230
		wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234 235 236 237 238
	}
}


static void change_VID(int vid)
{
	union msr_fidvidctl fidvidctl;

239
	rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242 243 244
	if (fidvidctl.bits.VID != vid) {
		fidvidctl.bits.SGTC = latency;
		fidvidctl.bits.VID = vid;
		fidvidctl.bits.FIDC = 0;
		fidvidctl.bits.VIDC = 1;
245
		wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
Linus Torvalds's avatar
Linus Torvalds committed
246 247 248 249
	}
}


250
static void change_speed(unsigned int index)
Linus Torvalds's avatar
Linus Torvalds committed
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
{
	u8 fid, vid;
	struct cpufreq_freqs freqs;
	union msr_fidvidstatus fidvidstatus;
	int cfid;

	/* fid are the lower 8 bits of the index we stored into
	 * the cpufreq frequency table in powernow_decode_bios,
	 * vid are the upper 8 bits.
	 */

	fid = powernow_table[index].index & 0xFF;
	vid = (powernow_table[index].index & 0xFF00) >> 8;

	freqs.cpu = 0;

267
	rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
Linus Torvalds's avatar
Linus Torvalds committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
	cfid = fidvidstatus.bits.CFID;
	freqs.old = fsb * fid_codes[cfid] / 10;

	freqs.new = powernow_table[index].frequency;

	cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);

	/* Now do the magic poking into the MSRs.  */

	if (have_a0 == 1)	/* A0 errata 5 */
		local_irq_disable();

	if (freqs.old > freqs.new) {
		/* Going down, so change FID first */
		change_FID(fid);
		change_VID(vid);
	} else {
		/* Going up, so change VID first */
		change_VID(vid);
		change_FID(fid);
	}


	if (have_a0 == 1)
		local_irq_enable();

	cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
}


#ifdef CONFIG_X86_POWERNOW_K7_ACPI

static struct acpi_processor_performance *acpi_processor_perf;

static int powernow_acpi_init(void)
{
	int i;
	int retval = 0;
	union powernow_acpi_control_t pc;

	if (acpi_processor_perf != NULL && powernow_table != NULL) {
		retval = -EINVAL;
		goto err0;
	}

313
	acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance),
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316 317 318 319
				      GFP_KERNEL);
	if (!acpi_processor_perf) {
		retval = -ENOMEM;
		goto err0;
	}

320
	if (!zalloc_cpumask_var(&acpi_processor_perf->shared_cpu_map,
321 322 323 324 325
								GFP_KERNEL)) {
		retval = -ENOMEM;
		goto err05;
	}

Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329 330
	if (acpi_processor_register_performance(acpi_processor_perf, 0)) {
		retval = -EIO;
		goto err1;
	}

331 332
	if (acpi_processor_perf->control_register.space_id !=
			ACPI_ADR_SPACE_FIXED_HARDWARE) {
Linus Torvalds's avatar
Linus Torvalds committed
333 334 335 336
		retval = -ENODEV;
		goto err2;
	}

337 338
	if (acpi_processor_perf->status_register.space_id !=
			ACPI_ADR_SPACE_FIXED_HARDWARE) {
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343 344 345 346 347 348 349
		retval = -ENODEV;
		goto err2;
	}

	number_scales = acpi_processor_perf->state_count;

	if (number_scales < 2) {
		retval = -ENODEV;
		goto err2;
	}

350 351
	powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
				(number_scales + 1)), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
352 353 354 355 356 357 358 359
	if (!powernow_table) {
		retval = -ENOMEM;
		goto err2;
	}

	pc.val = (unsigned long) acpi_processor_perf->states[0].control;
	for (i = 0; i < number_scales; i++) {
		u8 fid, vid;
360 361 362
		struct acpi_processor_px *state =
			&acpi_processor_perf->states[i];
		unsigned int speed, speed_mhz;
Linus Torvalds's avatar
Linus Torvalds committed
363

364
		pc.val = (unsigned long) state->control;
365
		pr_debug("acpi:  P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
366
			 i,
367 368 369 370
			 (u32) state->core_frequency,
			 (u32) state->power,
			 (u32) state->transition_latency,
			 (u32) state->control,
Linus Torvalds's avatar
Linus Torvalds committed
371 372 373 374 375 376 377 378 379 380
			 pc.bits.sgtc);

		vid = pc.bits.vid;
		fid = pc.bits.fid;

		powernow_table[i].frequency = fsb * fid_codes[fid] / 10;
		powernow_table[i].index = fid; /* lower 8 bits */
		powernow_table[i].index |= (vid << 8); /* upper 8 bits */

		speed = powernow_table[i].frequency;
381 382 383 384 385 386 387 388 389 390 391 392
		speed_mhz = speed / 1000;

		/* processor_perflib will multiply the MHz value by 1000 to
		 * get a KHz value (e.g. 1266000). However, powernow-k7 works
		 * with true KHz values (e.g. 1266768). To ensure that all
		 * powernow frequencies are available, we must ensure that
		 * ACPI doesn't restrict them, so we round up the MHz value
		 * to ensure that perflib's computed KHz value is greater than
		 * or equal to powernow's KHz value.
		 */
		if (speed % 1000 > 0)
			speed_mhz++;
Linus Torvalds's avatar
Linus Torvalds committed
393

394
		if ((fid_codes[fid] % 10) == 5) {
Linus Torvalds's avatar
Linus Torvalds committed
395
			if (have_a0 == 1)
396
				invalidate_entry(i);
Linus Torvalds's avatar
Linus Torvalds committed
397 398
		}

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,
Linus Torvalds's avatar
Linus Torvalds committed
402 403 404
			 mobile_vid_table[vid]/1000,
			 mobile_vid_table[vid]%1000);

405 406
		if (state->core_frequency != speed_mhz) {
			state->core_frequency = speed_mhz;
407
			pr_debug("   Corrected ACPI frequency to %d\n",
408 409 410
				speed_mhz);
		}

Linus Torvalds's avatar
Linus Torvalds committed
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
		if (latency < pc.bits.sgtc)
			latency = pc.bits.sgtc;

		if (speed < minimum_speed)
			minimum_speed = speed;
		if (speed > maximum_speed)
			maximum_speed = speed;
	}

	powernow_table[i].frequency = CPUFREQ_TABLE_END;
	powernow_table[i].index = 0;

	/* notify BIOS that we exist */
	acpi_processor_notify_smm(THIS_MODULE);

	return 0;

err2:
	acpi_processor_unregister_performance(acpi_processor_perf, 0);
err1:
431 432
	free_cpumask_var(acpi_processor_perf->shared_cpu_map);
err05:
Linus Torvalds's avatar
Linus Torvalds committed
433 434
	kfree(acpi_processor_perf);
err0:
435 436
	printk(KERN_WARNING PFX "ACPI perflib can not be used on "
			"this platform\n");
Linus Torvalds's avatar
Linus Torvalds committed
437 438 439 440 441 442 443 444 445 446 447 448
	acpi_processor_perf = NULL;
	return retval;
}
#else
static int powernow_acpi_init(void)
{
	printk(KERN_INFO PFX "no support for ACPI processor found."
	       "  Please recompile your kernel with ACPI processor\n");
	return -EINVAL;
}
#endif

449 450
static void print_pst_entry(struct pst_s *pst, unsigned int j)
{
451 452
	pr_debug("PST:%d (@%p)\n", j, pst);
	pr_debug(" cpuid: 0x%x  fsb: %d  maxFID: 0x%x  startvid: 0x%x\n",
453 454 455 456
		pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid);
}

static int powernow_decode_bios(int maxfid, int startvid)
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459 460 461 462 463 464 465 466
{
	struct psb_s *psb;
	struct pst_s *pst;
	unsigned int i, j;
	unsigned char *p;
	unsigned int etuple;
	unsigned int ret;

	etuple = cpuid_eax(0x80000001);

467
	for (i = 0xC0000; i < 0xffff0 ; i += 16) {
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470

		p = phys_to_virt(i);

471
		if (memcmp(p, "AMDK7PNOW!",  10) == 0) {
472
			pr_debug("Found PSB header at %p\n", p);
Linus Torvalds's avatar
Linus Torvalds committed
473
			psb = (struct psb_s *) p;
474
			pr_debug("Table version: 0x%x\n", psb->tableversion);
Linus Torvalds's avatar
Linus Torvalds committed
475
			if (psb->tableversion != 0x12) {
476 477
				printk(KERN_INFO PFX "Sorry, only v1.2 tables"
						" supported right now\n");
Linus Torvalds's avatar
Linus Torvalds committed
478 479 480
				return -ENODEV;
			}

481
			pr_debug("Flags: 0x%x\n", psb->flags);
482
			if ((psb->flags & 1) == 0)
483
				pr_debug("Mobile voltage regulator\n");
484
			else
485
				pr_debug("Desktop voltage regulator\n");
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488

			latency = psb->settlingtime;
			if (latency < 100) {
489 490 491 492
				printk(KERN_INFO PFX "BIOS set settling time "
						"to %d microseconds. "
						"Should be at least 100. "
						"Correcting.\n", latency);
Linus Torvalds's avatar
Linus Torvalds committed
493 494
				latency = 100;
			}
495
			pr_debug("Settling Time: %d microseconds.\n",
496
					psb->settlingtime);
497
			pr_debug("Has %d PST tables. (Only dumping ones "
498 499
					"relevant to this CPU).\n",
					psb->numpst);
Linus Torvalds's avatar
Linus Torvalds committed
500

501
			p += sizeof(struct psb_s);
Linus Torvalds's avatar
Linus Torvalds committed
502 503 504

			pst = (struct pst_s *) p;

505
			for (j = 0; j < psb->numpst; j++) {
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508
				pst = (struct pst_s *) p;
				number_scales = pst->numpstates;

509 510 511 512 513 514 515
				if ((etuple == pst->cpuid) &&
				    check_fsb(pst->fsbspeed) &&
				    (maxfid == pst->maxfid) &&
				    (startvid == pst->startvid)) {
					print_pst_entry(pst, j);
					p = (char *)pst + sizeof(struct pst_s);
					ret = get_ranges(p);
Linus Torvalds's avatar
Linus Torvalds committed
516 517
					return ret;
				} else {
518
					unsigned int k;
519 520 521
					p = (char *)pst + sizeof(struct pst_s);
					for (k = 0; k < number_scales; k++)
						p += 2;
Linus Torvalds's avatar
Linus Torvalds committed
522 523
				}
			}
524 525 526 527
			printk(KERN_INFO PFX "No PST tables match this cpuid "
					"(0x%x)\n", etuple);
			printk(KERN_INFO PFX "This is indicative of a broken "
					"BIOS.\n");
Linus Torvalds's avatar
Linus Torvalds committed
528 529 530 531 532 533 534 535 536 537

			return -EINVAL;
		}
		p++;
	}

	return -ENODEV;
}


538
static int powernow_target(struct cpufreq_policy *policy,
Linus Torvalds's avatar
Linus Torvalds committed
539 540 541 542 543
			    unsigned int target_freq,
			    unsigned int relation)
{
	unsigned int newstate;

544 545
	if (cpufreq_frequency_table_target(policy, powernow_table, target_freq,
				relation, &newstate))
Linus Torvalds's avatar
Linus Torvalds committed
546 547 548 549 550 551 552 553
		return -EINVAL;

	change_speed(newstate);

	return 0;
}


554
static int powernow_verify(struct cpufreq_policy *policy)
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557 558 559 560 561 562 563 564 565 566
{
	return cpufreq_frequency_table_verify(policy, powernow_table);
}

/*
 * We use the fact that the bus frequency is somehow
 * a multiple of 100000/3 khz, then we compute sgtc according
 * to this multiple.
 * That way, we match more how AMD thinks all of that work.
 * We will then get the same kind of behaviour already tested under
 * the "well-known" other OS.
 */
567
static int __cpuinit fixup_sgtc(void)
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
{
	unsigned int sgtc;
	unsigned int m;

	m = fsb / 3333;
	if ((m % 10) >= 5)
		m += 5;

	m /= 10;

	sgtc = 100 * m * latency;
	sgtc = sgtc / 3;
	if (sgtc > 0xfffff) {
		printk(KERN_WARNING PFX "SGTC too large %d\n", sgtc);
		sgtc = 0xfffff;
	}
	return sgtc;
}

static unsigned int powernow_get(unsigned int cpu)
{
	union msr_fidvidstatus fidvidstatus;
	unsigned int cfid;

	if (cpu)
		return 0;
594
	rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
Linus Torvalds's avatar
Linus Torvalds committed
595 596
	cfid = fidvidstatus.bits.CFID;

597
	return fsb * fid_codes[cfid] / 10;
Linus Torvalds's avatar
Linus Torvalds committed
598 599 600
}


601
static int __cpuinit acer_cpufreq_pst(const struct dmi_system_id *d)
Linus Torvalds's avatar
Linus Torvalds committed
602
{
603 604 605 606 607 608 609 610
	printk(KERN_WARNING PFX
		"%s laptop with broken PST tables in BIOS detected.\n",
		d->ident);
	printk(KERN_WARNING PFX
		"You need to downgrade to 3A21 (09/09/2002), or try a newer "
		"BIOS than 3A71 (01/20/2003)\n");
	printk(KERN_WARNING PFX
		"cpufreq scaling has been disabled as a result of this.\n");
Linus Torvalds's avatar
Linus Torvalds committed
611 612 613 614 615 616 617 618
	return 0;
}

/*
 * Some Athlon laptops have really fucked PST tables.
 * A BIOS update is all that can save them.
 * Mention this, and disable cpufreq.
 */
619
static struct dmi_system_id __cpuinitdata powernow_dmi_table[] = {
Linus Torvalds's avatar
Linus Torvalds committed
620 621 622 623 624 625 626 627 628 629 630
	{
		.callback = acer_cpufreq_pst,
		.ident = "Acer Aspire",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"),
			DMI_MATCH(DMI_BIOS_VERSION, "3A71"),
		},
	},
	{ }
};

631
static int __cpuinit powernow_cpu_init(struct cpufreq_policy *policy)
Linus Torvalds's avatar
Linus Torvalds committed
632 633 634 635 636 637 638
{
	union msr_fidvidstatus fidvidstatus;
	int result;

	if (policy->cpu != 0)
		return -ENODEV;

639
	rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
Linus Torvalds's avatar
Linus Torvalds committed
640

641
	recalibrate_cpu_khz();
642 643

	fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.CFID];
Linus Torvalds's avatar
Linus Torvalds committed
644 645 646 647
	if (!fsb) {
		printk(KERN_WARNING PFX "can not determine bus frequency\n");
		return -EINVAL;
	}
648
	pr_debug("FSB: %3dMHz\n", fsb/1000);
Linus Torvalds's avatar
Linus Torvalds committed
649 650

	if (dmi_check_system(powernow_dmi_table) || acpi_force) {
651 652
		printk(KERN_INFO PFX "PSB/PST known to be broken.  "
				"Trying ACPI instead\n");
Linus Torvalds's avatar
Linus Torvalds committed
653 654
		result = powernow_acpi_init();
	} else {
655 656
		result = powernow_decode_bios(fidvidstatus.bits.MFID,
				fidvidstatus.bits.SVID);
Linus Torvalds's avatar
Linus Torvalds committed
657
		if (result) {
658
			printk(KERN_INFO PFX "Trying ACPI perflib\n");
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661 662 663
			maximum_speed = 0;
			minimum_speed = -1;
			latency = 0;
			result = powernow_acpi_init();
			if (result) {
664 665
				printk(KERN_INFO PFX
					"ACPI and legacy methods failed\n");
Linus Torvalds's avatar
Linus Torvalds committed
666 667 668 669 670 671 672 673 674 675 676
			}
		} else {
			/* SGTC use the bus clock as timer */
			latency = fixup_sgtc();
			printk(KERN_INFO PFX "SGTC: %d\n", latency);
		}
	}

	if (result)
		return result;

677
	printk(KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n",
Linus Torvalds's avatar
Linus Torvalds committed
678 679
				minimum_speed/1000, maximum_speed/1000);

680 681
	policy->cpuinfo.transition_latency =
		cpufreq_scale(2000000UL, fsb, latency);
Linus Torvalds's avatar
Linus Torvalds committed
682 683 684 685 686 687 688 689

	policy->cur = powernow_get(0);

	cpufreq_frequency_table_get_attr(powernow_table, policy->cpu);

	return cpufreq_frequency_table_cpuinfo(policy, powernow_table);
}

690 691
static int powernow_cpu_exit(struct cpufreq_policy *policy)
{
Linus Torvalds's avatar
Linus Torvalds committed
692 693 694 695 696
	cpufreq_frequency_table_put_attr(policy->cpu);

#ifdef CONFIG_X86_POWERNOW_K7_ACPI
	if (acpi_processor_perf) {
		acpi_processor_unregister_performance(acpi_processor_perf, 0);
697
		free_cpumask_var(acpi_processor_perf->shared_cpu_map);
Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701
		kfree(acpi_processor_perf);
	}
#endif

702
	kfree(powernow_table);
Linus Torvalds's avatar
Linus Torvalds committed
703 704 705
	return 0;
}

706
static struct freq_attr *powernow_table_attr[] = {
Linus Torvalds's avatar
Linus Torvalds committed
707 708 709 710
	&cpufreq_freq_attr_scaling_available_freqs,
	NULL,
};

711
static struct cpufreq_driver powernow_driver = {
712 713 714 715 716 717 718 719 720 721 722
	.verify		= powernow_verify,
	.target		= powernow_target,
	.get		= powernow_get,
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
	.bios_limit	= acpi_processor_get_bios_limit,
#endif
	.init		= powernow_cpu_init,
	.exit		= powernow_cpu_exit,
	.name		= "powernow-k7",
	.owner		= THIS_MODULE,
	.attr		= powernow_table_attr,
Linus Torvalds's avatar
Linus Torvalds committed
723 724
};

725
static int __init powernow_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
726
{
727
	if (check_powernow() == 0)
Linus Torvalds's avatar
Linus Torvalds committed
728 729 730 731 732
		return -ENODEV;
	return cpufreq_register_driver(&powernow_driver);
}


733
static void __exit powernow_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
734 735 736 737 738 739 740
{
	cpufreq_unregister_driver(&powernow_driver);
}

module_param(acpi_force,  int, 0444);
MODULE_PARM_DESC(acpi_force, "Force ACPI to be used.");

741 742 743
MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
MODULE_DESCRIPTION("Powernow driver for AMD K7 processors.");
MODULE_LICENSE("GPL");
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746 747

late_initcall(powernow_init);
module_exit(powernow_exit);