1 /* 2 * AMD K7 Powernow driver. 3 * (C) 2003 Dave Jones on behalf of SuSE Labs. 4 * (C) 2003-2004 Dave Jones <davej@redhat.com> 5 * 6 * Licensed under the terms of the GNU GPL License version 2. 7 * Based upon datasheets & sample CPUs kindly provided by AMD. 8 * 9 * Errata 5: 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. 12 * Errata 15: 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. 15 */ 16 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> 26 #include <linux/io.h> 27 28 #include <asm/timer.h> /* Needed for recalibrate_cpu_khz() */ 29 #include <asm/msr.h> 30 #include <asm/cpu_device_id.h> 31 32 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 33 #include <linux/acpi.h> 34 #include <acpi/processor.h> 35 #endif 36 37 #include "powernow-k7.h" 38 39 #define PFX "powernow: " 40 41 42 struct psb_s { 43 u8 signature[10]; 44 u8 tableversion; 45 u8 flags; 46 u16 settlingtime; 47 u8 reserved1; 48 u8 numpst; 49 }; 50 51 struct pst_s { 52 u32 cpuid; 53 u8 fsbspeed; 54 u8 maxfid; 55 u8 startvid; 56 u8 numpstates; 57 }; 58 59 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 60 union powernow_acpi_control_t { 61 struct { 62 unsigned long fid:5, 63 vid:5, 64 sgtc:20, 65 res1:2; 66 } bits; 67 unsigned long val; 68 }; 69 #endif 70 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, 77 }; 78 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, 85 }; 86 87 /* This parameter is used in order to force ACPI instead of legacy method for 88 * configuration purpose. 89 */ 90 91 static int acpi_force; 92 93 static struct cpufreq_frequency_table *powernow_table; 94 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; 102 static char have_a0; 103 104 static int check_fsb(unsigned int fsbspeed) 105 { 106 int delta; 107 unsigned int f = fsb / 1000; 108 109 delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed; 110 return delta < 5; 111 } 112 113 static const struct x86_cpu_id powernow_k7_cpuids[] = { 114 { X86_VENDOR_AMD, 6, }, 115 {} 116 }; 117 MODULE_DEVICE_TABLE(x86cpu, powernow_k7_cpuids); 118 119 static int check_powernow(void) 120 { 121 struct cpuinfo_x86 *c = &cpu_data(0); 122 unsigned int maxei, eax, ebx, ecx, edx; 123 124 if (!x86_match_cpu(powernow_k7_cpuids)) 125 return 0; 126 127 /* Get maximum capabilities */ 128 maxei = cpuid_eax(0x80000000); 129 if (maxei < 0x80000007) { /* Any powernow info ? */ 130 #ifdef MODULE 131 printk(KERN_INFO PFX "No powernow capabilities detected\n"); 132 #endif 133 return 0; 134 } 135 136 if ((c->x86_model == 6) && (c->x86_mask == 0)) { 137 printk(KERN_INFO PFX "K7 660[A0] core detected, " 138 "enabling errata workarounds\n"); 139 have_a0 = 1; 140 } 141 142 cpuid(0x80000007, &eax, &ebx, &ecx, &edx); 143 144 /* Check we can actually do something before we say anything.*/ 145 if (!(edx & (1 << 1 | 1 << 2))) 146 return 0; 147 148 printk(KERN_INFO PFX "PowerNOW! Technology present. Can scale: "); 149 150 if (edx & 1 << 1) { 151 printk("frequency"); 152 can_scale_bus = 1; 153 } 154 155 if ((edx & (1 << 1 | 1 << 2)) == 0x6) 156 printk(" and "); 157 158 if (edx & 1 << 2) { 159 printk("voltage"); 160 can_scale_vid = 1; 161 } 162 163 printk(".\n"); 164 return 1; 165 } 166 167 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 168 static void invalidate_entry(unsigned int entry) 169 { 170 powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID; 171 } 172 #endif 173 174 static int get_ranges(unsigned char *pst) 175 { 176 unsigned int j; 177 unsigned int speed; 178 u8 fid, vid; 179 180 powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) * 181 (number_scales + 1)), GFP_KERNEL); 182 if (!powernow_table) 183 return -ENOMEM; 184 185 for (j = 0 ; j < number_scales; j++) { 186 fid = *pst++; 187 188 powernow_table[j].frequency = (fsb * fid_codes[fid]) / 10; 189 powernow_table[j].driver_data = fid; /* lower 8 bits */ 190 191 speed = powernow_table[j].frequency; 192 193 if ((fid_codes[fid] % 10) == 5) { 194 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 195 if (have_a0 == 1) 196 invalidate_entry(j); 197 #endif 198 } 199 200 if (speed < minimum_speed) 201 minimum_speed = speed; 202 if (speed > maximum_speed) 203 maximum_speed = speed; 204 205 vid = *pst++; 206 powernow_table[j].driver_data |= (vid << 8); /* upper 8 bits */ 207 208 pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) " 209 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10, 210 fid_codes[fid] % 10, speed/1000, vid, 211 mobile_vid_table[vid]/1000, 212 mobile_vid_table[vid]%1000); 213 } 214 powernow_table[number_scales].frequency = CPUFREQ_TABLE_END; 215 powernow_table[number_scales].driver_data = 0; 216 217 return 0; 218 } 219 220 221 static void change_FID(int fid) 222 { 223 union msr_fidvidctl fidvidctl; 224 225 rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val); 226 if (fidvidctl.bits.FID != fid) { 227 fidvidctl.bits.SGTC = latency; 228 fidvidctl.bits.FID = fid; 229 fidvidctl.bits.VIDC = 0; 230 fidvidctl.bits.FIDC = 1; 231 wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val); 232 } 233 } 234 235 236 static void change_VID(int vid) 237 { 238 union msr_fidvidctl fidvidctl; 239 240 rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val); 241 if (fidvidctl.bits.VID != vid) { 242 fidvidctl.bits.SGTC = latency; 243 fidvidctl.bits.VID = vid; 244 fidvidctl.bits.FIDC = 0; 245 fidvidctl.bits.VIDC = 1; 246 wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val); 247 } 248 } 249 250 251 static void change_speed(struct cpufreq_policy *policy, unsigned int index) 252 { 253 u8 fid, vid; 254 struct cpufreq_freqs freqs; 255 union msr_fidvidstatus fidvidstatus; 256 int cfid; 257 258 /* fid are the lower 8 bits of the index we stored into 259 * the cpufreq frequency table in powernow_decode_bios, 260 * vid are the upper 8 bits. 261 */ 262 263 fid = powernow_table[index].driver_data & 0xFF; 264 vid = (powernow_table[index].driver_data & 0xFF00) >> 8; 265 266 rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val); 267 cfid = fidvidstatus.bits.CFID; 268 freqs.old = fsb * fid_codes[cfid] / 10; 269 270 freqs.new = powernow_table[index].frequency; 271 272 cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE); 273 274 /* Now do the magic poking into the MSRs. */ 275 276 if (have_a0 == 1) /* A0 errata 5 */ 277 local_irq_disable(); 278 279 if (freqs.old > freqs.new) { 280 /* Going down, so change FID first */ 281 change_FID(fid); 282 change_VID(vid); 283 } else { 284 /* Going up, so change VID first */ 285 change_VID(vid); 286 change_FID(fid); 287 } 288 289 290 if (have_a0 == 1) 291 local_irq_enable(); 292 293 cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE); 294 } 295 296 297 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 298 299 static struct acpi_processor_performance *acpi_processor_perf; 300 301 static int powernow_acpi_init(void) 302 { 303 int i; 304 int retval = 0; 305 union powernow_acpi_control_t pc; 306 307 if (acpi_processor_perf != NULL && powernow_table != NULL) { 308 retval = -EINVAL; 309 goto err0; 310 } 311 312 acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance), 313 GFP_KERNEL); 314 if (!acpi_processor_perf) { 315 retval = -ENOMEM; 316 goto err0; 317 } 318 319 if (!zalloc_cpumask_var(&acpi_processor_perf->shared_cpu_map, 320 GFP_KERNEL)) { 321 retval = -ENOMEM; 322 goto err05; 323 } 324 325 if (acpi_processor_register_performance(acpi_processor_perf, 0)) { 326 retval = -EIO; 327 goto err1; 328 } 329 330 if (acpi_processor_perf->control_register.space_id != 331 ACPI_ADR_SPACE_FIXED_HARDWARE) { 332 retval = -ENODEV; 333 goto err2; 334 } 335 336 if (acpi_processor_perf->status_register.space_id != 337 ACPI_ADR_SPACE_FIXED_HARDWARE) { 338 retval = -ENODEV; 339 goto err2; 340 } 341 342 number_scales = acpi_processor_perf->state_count; 343 344 if (number_scales < 2) { 345 retval = -ENODEV; 346 goto err2; 347 } 348 349 powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) * 350 (number_scales + 1)), GFP_KERNEL); 351 if (!powernow_table) { 352 retval = -ENOMEM; 353 goto err2; 354 } 355 356 pc.val = (unsigned long) acpi_processor_perf->states[0].control; 357 for (i = 0; i < number_scales; i++) { 358 u8 fid, vid; 359 struct acpi_processor_px *state = 360 &acpi_processor_perf->states[i]; 361 unsigned int speed, speed_mhz; 362 363 pc.val = (unsigned long) state->control; 364 pr_debug("acpi: P%d: %d MHz %d mW %d uS control %08x SGTC %d\n", 365 i, 366 (u32) state->core_frequency, 367 (u32) state->power, 368 (u32) state->transition_latency, 369 (u32) state->control, 370 pc.bits.sgtc); 371 372 vid = pc.bits.vid; 373 fid = pc.bits.fid; 374 375 powernow_table[i].frequency = fsb * fid_codes[fid] / 10; 376 powernow_table[i].driver_data = fid; /* lower 8 bits */ 377 powernow_table[i].driver_data |= (vid << 8); /* upper 8 bits */ 378 379 speed = powernow_table[i].frequency; 380 speed_mhz = speed / 1000; 381 382 /* processor_perflib will multiply the MHz value by 1000 to 383 * get a KHz value (e.g. 1266000). However, powernow-k7 works 384 * with true KHz values (e.g. 1266768). To ensure that all 385 * powernow frequencies are available, we must ensure that 386 * ACPI doesn't restrict them, so we round up the MHz value 387 * to ensure that perflib's computed KHz value is greater than 388 * or equal to powernow's KHz value. 389 */ 390 if (speed % 1000 > 0) 391 speed_mhz++; 392 393 if ((fid_codes[fid] % 10) == 5) { 394 if (have_a0 == 1) 395 invalidate_entry(i); 396 } 397 398 pr_debug(" FID: 0x%x (%d.%dx [%dMHz]) " 399 "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10, 400 fid_codes[fid] % 10, speed_mhz, vid, 401 mobile_vid_table[vid]/1000, 402 mobile_vid_table[vid]%1000); 403 404 if (state->core_frequency != speed_mhz) { 405 state->core_frequency = speed_mhz; 406 pr_debug(" Corrected ACPI frequency to %d\n", 407 speed_mhz); 408 } 409 410 if (latency < pc.bits.sgtc) 411 latency = pc.bits.sgtc; 412 413 if (speed < minimum_speed) 414 minimum_speed = speed; 415 if (speed > maximum_speed) 416 maximum_speed = speed; 417 } 418 419 powernow_table[i].frequency = CPUFREQ_TABLE_END; 420 powernow_table[i].driver_data = 0; 421 422 /* notify BIOS that we exist */ 423 acpi_processor_notify_smm(THIS_MODULE); 424 425 return 0; 426 427 err2: 428 acpi_processor_unregister_performance(acpi_processor_perf, 0); 429 err1: 430 free_cpumask_var(acpi_processor_perf->shared_cpu_map); 431 err05: 432 kfree(acpi_processor_perf); 433 err0: 434 printk(KERN_WARNING PFX "ACPI perflib can not be used on " 435 "this platform\n"); 436 acpi_processor_perf = NULL; 437 return retval; 438 } 439 #else 440 static int powernow_acpi_init(void) 441 { 442 printk(KERN_INFO PFX "no support for ACPI processor found." 443 " Please recompile your kernel with ACPI processor\n"); 444 return -EINVAL; 445 } 446 #endif 447 448 static void print_pst_entry(struct pst_s *pst, unsigned int j) 449 { 450 pr_debug("PST:%d (@%p)\n", j, pst); 451 pr_debug(" cpuid: 0x%x fsb: %d maxFID: 0x%x startvid: 0x%x\n", 452 pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid); 453 } 454 455 static int powernow_decode_bios(int maxfid, int startvid) 456 { 457 struct psb_s *psb; 458 struct pst_s *pst; 459 unsigned int i, j; 460 unsigned char *p; 461 unsigned int etuple; 462 unsigned int ret; 463 464 etuple = cpuid_eax(0x80000001); 465 466 for (i = 0xC0000; i < 0xffff0 ; i += 16) { 467 468 p = phys_to_virt(i); 469 470 if (memcmp(p, "AMDK7PNOW!", 10) == 0) { 471 pr_debug("Found PSB header at %p\n", p); 472 psb = (struct psb_s *) p; 473 pr_debug("Table version: 0x%x\n", psb->tableversion); 474 if (psb->tableversion != 0x12) { 475 printk(KERN_INFO PFX "Sorry, only v1.2 tables" 476 " supported right now\n"); 477 return -ENODEV; 478 } 479 480 pr_debug("Flags: 0x%x\n", psb->flags); 481 if ((psb->flags & 1) == 0) 482 pr_debug("Mobile voltage regulator\n"); 483 else 484 pr_debug("Desktop voltage regulator\n"); 485 486 latency = psb->settlingtime; 487 if (latency < 100) { 488 printk(KERN_INFO PFX "BIOS set settling time " 489 "to %d microseconds. " 490 "Should be at least 100. " 491 "Correcting.\n", latency); 492 latency = 100; 493 } 494 pr_debug("Settling Time: %d microseconds.\n", 495 psb->settlingtime); 496 pr_debug("Has %d PST tables. (Only dumping ones " 497 "relevant to this CPU).\n", 498 psb->numpst); 499 500 p += sizeof(struct psb_s); 501 502 pst = (struct pst_s *) p; 503 504 for (j = 0; j < psb->numpst; j++) { 505 pst = (struct pst_s *) p; 506 number_scales = pst->numpstates; 507 508 if ((etuple == pst->cpuid) && 509 check_fsb(pst->fsbspeed) && 510 (maxfid == pst->maxfid) && 511 (startvid == pst->startvid)) { 512 print_pst_entry(pst, j); 513 p = (char *)pst + sizeof(struct pst_s); 514 ret = get_ranges(p); 515 return ret; 516 } else { 517 unsigned int k; 518 p = (char *)pst + sizeof(struct pst_s); 519 for (k = 0; k < number_scales; k++) 520 p += 2; 521 } 522 } 523 printk(KERN_INFO PFX "No PST tables match this cpuid " 524 "(0x%x)\n", etuple); 525 printk(KERN_INFO PFX "This is indicative of a broken " 526 "BIOS.\n"); 527 528 return -EINVAL; 529 } 530 p++; 531 } 532 533 return -ENODEV; 534 } 535 536 537 static int powernow_target(struct cpufreq_policy *policy, 538 unsigned int target_freq, 539 unsigned int relation) 540 { 541 unsigned int newstate; 542 543 if (cpufreq_frequency_table_target(policy, powernow_table, target_freq, 544 relation, &newstate)) 545 return -EINVAL; 546 547 change_speed(policy, newstate); 548 549 return 0; 550 } 551 552 553 static int powernow_verify(struct cpufreq_policy *policy) 554 { 555 return cpufreq_frequency_table_verify(policy, powernow_table); 556 } 557 558 /* 559 * We use the fact that the bus frequency is somehow 560 * a multiple of 100000/3 khz, then we compute sgtc according 561 * to this multiple. 562 * That way, we match more how AMD thinks all of that work. 563 * We will then get the same kind of behaviour already tested under 564 * the "well-known" other OS. 565 */ 566 static int fixup_sgtc(void) 567 { 568 unsigned int sgtc; 569 unsigned int m; 570 571 m = fsb / 3333; 572 if ((m % 10) >= 5) 573 m += 5; 574 575 m /= 10; 576 577 sgtc = 100 * m * latency; 578 sgtc = sgtc / 3; 579 if (sgtc > 0xfffff) { 580 printk(KERN_WARNING PFX "SGTC too large %d\n", sgtc); 581 sgtc = 0xfffff; 582 } 583 return sgtc; 584 } 585 586 static unsigned int powernow_get(unsigned int cpu) 587 { 588 union msr_fidvidstatus fidvidstatus; 589 unsigned int cfid; 590 591 if (cpu) 592 return 0; 593 rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val); 594 cfid = fidvidstatus.bits.CFID; 595 596 return fsb * fid_codes[cfid] / 10; 597 } 598 599 600 static int acer_cpufreq_pst(const struct dmi_system_id *d) 601 { 602 printk(KERN_WARNING PFX 603 "%s laptop with broken PST tables in BIOS detected.\n", 604 d->ident); 605 printk(KERN_WARNING PFX 606 "You need to downgrade to 3A21 (09/09/2002), or try a newer " 607 "BIOS than 3A71 (01/20/2003)\n"); 608 printk(KERN_WARNING PFX 609 "cpufreq scaling has been disabled as a result of this.\n"); 610 return 0; 611 } 612 613 /* 614 * Some Athlon laptops have really fucked PST tables. 615 * A BIOS update is all that can save them. 616 * Mention this, and disable cpufreq. 617 */ 618 static struct dmi_system_id powernow_dmi_table[] = { 619 { 620 .callback = acer_cpufreq_pst, 621 .ident = "Acer Aspire", 622 .matches = { 623 DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"), 624 DMI_MATCH(DMI_BIOS_VERSION, "3A71"), 625 }, 626 }, 627 { } 628 }; 629 630 static int powernow_cpu_init(struct cpufreq_policy *policy) 631 { 632 union msr_fidvidstatus fidvidstatus; 633 int result; 634 635 if (policy->cpu != 0) 636 return -ENODEV; 637 638 rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val); 639 640 recalibrate_cpu_khz(); 641 642 fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.CFID]; 643 if (!fsb) { 644 printk(KERN_WARNING PFX "can not determine bus frequency\n"); 645 return -EINVAL; 646 } 647 pr_debug("FSB: %3dMHz\n", fsb/1000); 648 649 if (dmi_check_system(powernow_dmi_table) || acpi_force) { 650 printk(KERN_INFO PFX "PSB/PST known to be broken. " 651 "Trying ACPI instead\n"); 652 result = powernow_acpi_init(); 653 } else { 654 result = powernow_decode_bios(fidvidstatus.bits.MFID, 655 fidvidstatus.bits.SVID); 656 if (result) { 657 printk(KERN_INFO PFX "Trying ACPI perflib\n"); 658 maximum_speed = 0; 659 minimum_speed = -1; 660 latency = 0; 661 result = powernow_acpi_init(); 662 if (result) { 663 printk(KERN_INFO PFX 664 "ACPI and legacy methods failed\n"); 665 } 666 } else { 667 /* SGTC use the bus clock as timer */ 668 latency = fixup_sgtc(); 669 printk(KERN_INFO PFX "SGTC: %d\n", latency); 670 } 671 } 672 673 if (result) 674 return result; 675 676 printk(KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n", 677 minimum_speed/1000, maximum_speed/1000); 678 679 policy->cpuinfo.transition_latency = 680 cpufreq_scale(2000000UL, fsb, latency); 681 682 policy->cur = powernow_get(0); 683 684 cpufreq_frequency_table_get_attr(powernow_table, policy->cpu); 685 686 return cpufreq_frequency_table_cpuinfo(policy, powernow_table); 687 } 688 689 static int powernow_cpu_exit(struct cpufreq_policy *policy) 690 { 691 cpufreq_frequency_table_put_attr(policy->cpu); 692 693 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 694 if (acpi_processor_perf) { 695 acpi_processor_unregister_performance(acpi_processor_perf, 0); 696 free_cpumask_var(acpi_processor_perf->shared_cpu_map); 697 kfree(acpi_processor_perf); 698 } 699 #endif 700 701 kfree(powernow_table); 702 return 0; 703 } 704 705 static struct freq_attr *powernow_table_attr[] = { 706 &cpufreq_freq_attr_scaling_available_freqs, 707 NULL, 708 }; 709 710 static struct cpufreq_driver powernow_driver = { 711 .verify = powernow_verify, 712 .target = powernow_target, 713 .get = powernow_get, 714 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 715 .bios_limit = acpi_processor_get_bios_limit, 716 #endif 717 .init = powernow_cpu_init, 718 .exit = powernow_cpu_exit, 719 .name = "powernow-k7", 720 .owner = THIS_MODULE, 721 .attr = powernow_table_attr, 722 }; 723 724 static int __init powernow_init(void) 725 { 726 if (check_powernow() == 0) 727 return -ENODEV; 728 return cpufreq_register_driver(&powernow_driver); 729 } 730 731 732 static void __exit powernow_exit(void) 733 { 734 cpufreq_unregister_driver(&powernow_driver); 735 } 736 737 module_param(acpi_force, int, 0444); 738 MODULE_PARM_DESC(acpi_force, "Force ACPI to be used."); 739 740 MODULE_AUTHOR("Dave Jones <davej@redhat.com>"); 741 MODULE_DESCRIPTION("Powernow driver for AMD K7 processors."); 742 MODULE_LICENSE("GPL"); 743 744 late_initcall(powernow_init); 745 module_exit(powernow_exit); 746 747