drivers/cpufreq/powernow-k7.c

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