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