powernow-k7.c 16.4 KB
Newer Older
1
/*
Dave Jones's avatar
Dave Jones committed
2
 *  AMD K7 Powernow driver.
3
 *  (C) 2003 Dave Jones <davej@codemonkey.org.uk> on behalf of SuSE Labs.
Dave Jones's avatar
Dave Jones committed
4
 *  (C) 2003-2004 Dave Jones <davej@redhat.com>
5 6 7 8 9 10 11 12 13 14
 *
 *  Licensed under the terms of the GNU GPL License version 2.
 *  Based upon datasheets & sample CPUs kindly provided by AMD.
 *
 * Errata 5: Processor 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: Processors with half frequency multipliers may hang upon wakeup from disconnect.
 * - 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 20 21 22
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/slab.h>
#include <linux/string.h>
23
#include <linux/dmi.h>
24 25 26 27

#include <asm/msr.h>
#include <asm/timex.h>
#include <asm/io.h>
28
#include <asm/system.h>
29

30
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
31 32 33 34
#include <linux/acpi.h>
#include <acpi/processor.h>
#endif

35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
#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;
};

57
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
58 59 60 61 62 63 64 65 66 67
union powernow_acpi_control_t {
	struct {
		unsigned long fid:5,
		vid:5,
		sgtc:20,
		res1:2;
	} bits;
	unsigned long val;
};
#endif
68

69
#ifdef CONFIG_CPU_FREQ_DEBUG
70
/* divide by 1000 to get VCore voltage in V. */
71 72 73 74
static int mobile_vid_table[32] = {
    2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
    1600, 1550, 1500, 1450, 1400, 1350, 1300, 0,
    1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
75
    1075, 1050, 1025, 1000, 975, 950, 925, 0,
76
};
77
#endif
78 79 80 81

/* divide by 10 to get FID. */
static int fid_codes[32] = {
    110, 115, 120, 125, 50, 55, 60, 65,
82
    70, 75, 80, 85, 90, 95, 100, 105,
83 84 85 86
    30, 190, 40, 200, 130, 135, 140, 210,
    150, 225, 160, 165, 170, 180, -1, -1,
};

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

91
static int acpi_force;
92

93 94 95 96 97 98 99 100 101 102 103
static struct cpufreq_frequency_table *powernow_table;

static unsigned int can_scale_bus;
static unsigned int can_scale_vid;
static unsigned int minimum_speed=-1;
static unsigned int maximum_speed;
static unsigned int number_scales;
static unsigned int fsb;
static unsigned int latency;
static char have_a0;

104
#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "powernow-k7", msg)
105

106 107 108 109 110 111 112 113
static int check_fsb(unsigned int fsbspeed)
{
	int delta;
	unsigned int f = fsb / 1000;

	delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed;
	return (delta < 5);
}
114 115 116 117 118 119

static int check_powernow(void)
{
	struct cpuinfo_x86 *c = cpu_data;
	unsigned int maxei, eax, ebx, ecx, edx;

120 121
	if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 !=6)) {
#ifdef MODULE
122
		printk (KERN_INFO PFX "This module only works with AMD K7 CPUs\n");
123
#endif
124 125 126 127 128 129
		return 0;
	}

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

136 137 138 139 140
	if ((c->x86_model == 6) && (c->x86_mask == 0)) {
		printk (KERN_INFO PFX "K7 660[A0] core detected, enabling errata workarounds\n");
		have_a0 = 1;
	}

141
	cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
142 143 144 145 146

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

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
	printk (KERN_INFO PFX "PowerNOW! Technology present. Can scale: ");

	if (edx & 1 << 1) {
		printk ("frequency");
		can_scale_bus=1;
	}

	if ((edx & (1 << 1 | 1 << 2)) == 0x6)
		printk (" and ");

	if (edx & 1 << 2) {
		printk ("voltage");
		can_scale_vid=1;
	}

	printk (".\n");
	return 1;
}


static int get_ranges (unsigned char *pst)
{
169 170
	unsigned int j;
	unsigned int speed;
171 172 173 174 175 176 177 178 179 180
	u8 fid, vid;

	powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table) * (number_scales + 1)), GFP_KERNEL);
	if (!powernow_table)
		return -ENOMEM;
	memset(powernow_table, 0, (sizeof(struct cpufreq_frequency_table) * (number_scales + 1)));

	for (j=0 ; j < number_scales; j++) {
		fid = *pst++;

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

184 185
		speed = powernow_table[j].frequency;

186
		if ((fid_codes[fid] % 10)==5) {
187
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
188 189 190 191 192 193 194 195 196 197 198 199
			if (have_a0 == 1)
				powernow_table[j].frequency = CPUFREQ_ENTRY_INVALID;
#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 */
200 201 202 203 204 205

		dprintk ("   FID: 0x%x (%d.%dx [%dMHz])  "
			 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10, 
			 fid_codes[fid] % 10, speed/1000, vid,	
			 mobile_vid_table[vid]/1000,
			 mobile_vid_table[vid]%1000);
206 207 208 209 210 211 212 213
	}
	powernow_table[number_scales].frequency = CPUFREQ_TABLE_END;
	powernow_table[number_scales].index = 0;

	return 0;
}


214 215 216 217
static void change_FID(int fid)
{
	union msr_fidvidctl fidvidctl;

218
	rdmsrl (MSR_K7_FID_VID_CTL, fidvidctl.val);
219 220 221
	if (fidvidctl.bits.FID != fid) {
		fidvidctl.bits.SGTC = latency;
		fidvidctl.bits.FID = fid;
222
		fidvidctl.bits.VIDC = 0;
223 224 225 226 227 228 229 230 231 232
		fidvidctl.bits.FIDC = 1;
		wrmsrl (MSR_K7_FID_VID_CTL, fidvidctl.val);
	}
}


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

233
	rdmsrl (MSR_K7_FID_VID_CTL, fidvidctl.val);
234
	if (fidvidctl.bits.VID != vid) {
235
		fidvidctl.bits.SGTC = latency;
236
		fidvidctl.bits.VID = vid;
237
		fidvidctl.bits.FIDC = 0;
238 239 240 241 242 243
		fidvidctl.bits.VIDC = 1;
		wrmsrl (MSR_K7_FID_VID_CTL, fidvidctl.val);
	}
}


244 245 246 247 248
static void change_speed (unsigned int index)
{
	u8 fid, vid;
	struct cpufreq_freqs freqs;
	union msr_fidvidstatus fidvidstatus;
249
	int cfid;
250 251 252 253 254 255 256 257 258 259 260 261

	/* 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;

	rdmsrl (MSR_K7_FID_VID_STATUS, fidvidstatus.val);
262
	cfid = fidvidstatus.bits.CFID;
263 264
	freqs.old = fsb * fid_codes[cfid] / 10;

265 266 267 268 269 270
	freqs.new = powernow_table[index].frequency;

	cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);

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

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

274 275 276 277 278 279
	if (freqs.old > freqs.new) {
		/* Going down, so change FID first */
		change_FID(fid);
		change_VID(vid);
	} else {
		/* Going up, so change VID first */
Bruno Ducrot's avatar
Bruno Ducrot committed
280 281
		change_VID(vid);
		change_FID(fid);
282
	}
283

284 285

	if (have_a0 == 1)
286
		local_irq_enable();
287 288 289 290 291

	cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
}


292
#ifdef CONFIG_X86_POWERNOW_K7_ACPI
293

294
static struct acpi_processor_performance *acpi_processor_perf;
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352

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;
	}

	acpi_processor_perf = kmalloc(sizeof(struct acpi_processor_performance),
				      GFP_KERNEL);

	if (!acpi_processor_perf) {
		retval = -ENOMEM;
		goto err0;
	}

	memset(acpi_processor_perf, 0, sizeof(struct acpi_processor_performance));

	if (acpi_processor_register_performance(acpi_processor_perf, 0)) {
		retval = -EIO;
		goto err1;
	}

	if (acpi_processor_perf->control_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) {
		retval = -ENODEV;
		goto err2;
	}

	if (acpi_processor_perf->status_register.space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) {
		retval = -ENODEV;
		goto err2;
	}

	number_scales = acpi_processor_perf->state_count;

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

	powernow_table = kmalloc((number_scales + 1) * (sizeof(struct cpufreq_frequency_table)), GFP_KERNEL);
	if (!powernow_table) {
		retval = -ENOMEM;
		goto err2;
	}

	memset(powernow_table, 0, ((number_scales + 1) * sizeof(struct cpufreq_frequency_table)));

	pc.val = (unsigned long) acpi_processor_perf->states[0].control;
	for (i = 0; i < number_scales; i++) {
		u8 fid, vid;
		unsigned int speed;

		pc.val = (unsigned long) acpi_processor_perf->states[i].control;
353
		dprintk ("acpi:  P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
354 355 356 357 358 359 360 361 362 363
			 i,
			 (u32) acpi_processor_perf->states[i].core_frequency,
			 (u32) acpi_processor_perf->states[i].power,
			 (u32) acpi_processor_perf->states[i].transition_latency,
			 (u32) acpi_processor_perf->states[i].control,
			 pc.bits.sgtc);

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

364
		powernow_table[i].frequency = fsb * fid_codes[fid] / 10;
365 366 367 368 369 370 371 372 373 374
		powernow_table[i].index = fid; /* lower 8 bits */
		powernow_table[i].index |= (vid << 8); /* upper 8 bits */

		speed = powernow_table[i].frequency;

		if ((fid_codes[fid] % 10)==5) {
			if (have_a0 == 1)
				powernow_table[i].frequency = CPUFREQ_ENTRY_INVALID;
		}

375 376 377 378 379
		dprintk ("   FID: 0x%x (%d.%dx [%dMHz])  "
			 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10, 
			 fid_codes[fid] % 10, speed/1000, vid,	
			 mobile_vid_table[vid]/1000,
			 mobile_vid_table[vid]%1000);
380 381 382 383 384 385 386 387 388 389 390 391 392

		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;

Len Brown's avatar
Len Brown committed
393 394 395
	/* notify BIOS that we exist */
	acpi_processor_notify_smm(THIS_MODULE);

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
	return 0;

err2:
	acpi_processor_unregister_performance(acpi_processor_perf, 0);
err1:
	kfree(acpi_processor_perf);
err0:
	printk(KERN_WARNING PFX "ACPI perflib can not be used in this platform\n");
	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

416
static int powernow_decode_bios (int maxfid, int startvid)
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
{
	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);

	for (i=0xC0000; i < 0xffff0 ; i+=16) {

		p = phys_to_virt(i);

		if (memcmp(p, "AMDK7PNOW!",  10) == 0){
432
			dprintk ("Found PSB header at %p\n", p);
433
			psb = (struct psb_s *) p;
434
			dprintk ("Table version: 0x%x\n", psb->tableversion);
435 436 437 438 439
			if (psb->tableversion != 0x12) {
				printk (KERN_INFO PFX "Sorry, only v1.2 tables supported right now\n");
				return -ENODEV;
			}

440
			dprintk ("Flags: 0x%x\n", psb->flags);
441
			if ((psb->flags & 1)==0) {
442
				dprintk ("Mobile voltage regulator\n");
443
			} else {
444
				dprintk ("Desktop voltage regulator\n");
445 446 447
			}

			latency = psb->settlingtime;
448
			if (latency < 100) {
449
				printk (KERN_INFO PFX "BIOS set settling time to %d microseconds."
450 451
						"Should be at least 100. Correcting.\n", latency);
				latency = 100;
452
			}
453 454
			dprintk ("Settling Time: %d microseconds.\n", psb->settlingtime);
			dprintk ("Has %d PST tables. (Only dumping ones relevant to this CPU).\n", psb->numpst);
455 456 457 458 459 460 461 462 463

			p += sizeof (struct psb_s);

			pst = (struct pst_s *) p;

			for (i = 0 ; i <psb->numpst; i++) {
				pst = (struct pst_s *) p;
				number_scales = pst->numpstates;

464 465
				if ((etuple == pst->cpuid) && check_fsb(pst->fsbspeed) &&
				    (maxfid==pst->maxfid) && (startvid==pst->startvid))
466
				{
467 468 469
					dprintk ("PST:%d (@%p)\n", i, pst);
					dprintk (" cpuid: 0x%x  fsb: %d  maxFID: 0x%x  startvid: 0x%x\n", 
						 pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid);
470 471 472 473 474 475 476 477 478 479

					ret = get_ranges ((char *) pst + sizeof (struct pst_s));
					return ret;

				} else {
					p = (char *) pst + sizeof (struct pst_s);
					for (j=0 ; j < number_scales; j++)
						p+=2;
				}
			}
480
			printk (KERN_INFO PFX "No PST tables match this cpuid (0x%x)\n", etuple);
481
			printk (KERN_INFO PFX "This is indicative of a broken BIOS.\n");
482

483
			return -EINVAL;
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
		}
		p++;
	}

	return -ENODEV;
}


static int powernow_target (struct cpufreq_policy *policy,
			    unsigned int target_freq,
			    unsigned int relation)
{
	unsigned int newstate;

	if (cpufreq_frequency_table_target(policy, powernow_table, target_freq, relation, &newstate))
		return -EINVAL;

	change_speed(newstate);

	return 0;
}


static int powernow_verify (struct cpufreq_policy *policy)
{
	return cpufreq_frequency_table_verify(policy, powernow_table);
}

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
/*
 * 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.
 */
static int __init fixup_sgtc(void)
{
	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;
}
539

540 541 542 543 544 545 546 547 548 549 550 551 552 553
static unsigned int powernow_get(unsigned int cpu)
{
	union msr_fidvidstatus fidvidstatus;
	unsigned int cfid;

	if (cpu)
		return 0;
	rdmsrl (MSR_K7_FID_VID_STATUS, fidvidstatus.val);
	cfid = fidvidstatus.bits.CFID;

	return (fsb * fid_codes[cfid] / 10);
}


554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
static int __init acer_cpufreq_pst(struct dmi_system_id *d)
{
	printk(KERN_WARNING "%s laptop with broken PST tables in BIOS detected.\n", d->ident);
	printk(KERN_WARNING "You need to downgrade to 3A21 (09/09/2002), or try a newer BIOS than 3A71 (01/20/2003)\n");
	printk(KERN_WARNING "cpufreq scaling has been disabled as a result of this.\n");
	return 0;
}

/*
 * Some Athlon laptops have really fucked PST tables.
 * A BIOS update is all that can save them.
 * Mention this, and disable cpufreq.
 */
static struct dmi_system_id __initdata powernow_dmi_table[] = {
	{
		.callback = acer_cpufreq_pst,
		.ident = "Acer Aspire",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"),
			DMI_MATCH(DMI_BIOS_VERSION, "3A71"),
		},
	},
	{ }
};

579 580 581 582 583 584 585 586 587 588
static int __init powernow_cpu_init (struct cpufreq_policy *policy)
{
	union msr_fidvidstatus fidvidstatus;
	int result;

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

	rdmsrl (MSR_K7_FID_VID_STATUS, fidvidstatus.val);

589
	/* A K7 with powernow technology is set to max frequency by BIOS */
590
	fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.MFID];
591 592 593 594
	if (!fsb) {
		printk(KERN_WARNING PFX "can not determine bus frequency\n");
		return -EINVAL;
	}
595
	dprintk("FSB: %3d.%03d MHz\n", fsb/1000, fsb%1000);
596

597
	if (dmi_check_system(powernow_dmi_table) || acpi_force) {
598 599 600 601 602
		printk (KERN_INFO PFX "PSB/PST known to be broken.  Trying ACPI instead\n");
		result = powernow_acpi_init();
	} else {
		result = powernow_decode_bios(fidvidstatus.bits.MFID, fidvidstatus.bits.SVID);
		if (result) {
603
			printk (KERN_INFO PFX "Trying ACPI perflib\n");
604 605 606
			maximum_speed = 0;
			minimum_speed = -1;
			latency = 0;
607
			result = powernow_acpi_init();
608 609 610 611
			if (result) {
				printk (KERN_INFO PFX "ACPI and legacy methods failed\n");
				printk (KERN_INFO PFX "See http://www.codemonkey.org.uk/projects/cpufreq/powernow-k7.shtml\n");
			}
612 613 614 615 616 617 618
		} else {
			/* SGTC use the bus clock as timer */
			latency = fixup_sgtc();
			printk(KERN_INFO PFX "SGTC: %d\n", latency);
		}
	}

619 620 621 622
	if (result)
		return result;

	printk (KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n",
623
				minimum_speed/1000, maximum_speed/1000);
624

625
	policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
626

627
	policy->cpuinfo.transition_latency = cpufreq_scale(2000000UL, fsb, latency);
628

629
	policy->cur = powernow_get(0);
630

631 632
	cpufreq_frequency_table_get_attr(powernow_table, policy->cpu);

633 634 635
	return cpufreq_frequency_table_cpuinfo(policy, powernow_table);
}

636 637
static int powernow_cpu_exit (struct cpufreq_policy *policy) {
	cpufreq_frequency_table_put_attr(policy->cpu);
638 639 640 641 642 643 644 645 646 647 648

#ifdef CONFIG_X86_POWERNOW_K7_ACPI
	if (acpi_processor_perf) {
		acpi_processor_unregister_performance(acpi_processor_perf, 0);
		kfree(acpi_processor_perf);
	}
#endif

	if (powernow_table)
		kfree(powernow_table);

649 650 651 652 653 654 655 656
	return 0;
}

static struct freq_attr* powernow_table_attr[] = {
	&cpufreq_freq_attr_scaling_available_freqs,
	NULL,
};

657
static struct cpufreq_driver powernow_driver = {
658 659 660 661 662 663 664 665
	.verify	= powernow_verify,
	.target	= powernow_target,
	.get	= powernow_get,
	.init	= powernow_cpu_init,
	.exit	= powernow_cpu_exit,
	.name	= "powernow-k7",
	.owner	= THIS_MODULE,
	.attr	= powernow_table_attr,
666 667
};

668 669 670 671 672 673 674 675 676 677 678 679 680
static int __init powernow_init (void)
{
	if (check_powernow()==0)
		return -ENODEV;
	return cpufreq_register_driver(&powernow_driver);
}


static void __exit powernow_exit (void)
{
	cpufreq_unregister_driver(&powernow_driver);
}

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

684
MODULE_AUTHOR ("Dave Jones <davej@codemonkey.org.uk>");
685 686 687
MODULE_DESCRIPTION ("Powernow driver for AMD K7 processors.");
MODULE_LICENSE ("GPL");

688
late_initcall(powernow_init);
689 690
module_exit(powernow_exit);