1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * AMD K7 Powernow driver. 4 * (C) 2003 Dave Jones on behalf of SuSE Labs. 5 * 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 17 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/init.h> 22 #include <linux/cpufreq.h> 23 #include <linux/slab.h> 24 #include <linux/string.h> 25 #include <linux/dmi.h> 26 #include <linux/timex.h> 27 #include <linux/io.h> 28 29 #include <asm/timer.h> /* Needed for recalibrate_cpu_khz() */ 30 #include <asm/msr.h> 31 #include <asm/cpu_device_id.h> 32 #include <asm/cpuid/api.h> 33 34 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 35 #include <linux/acpi.h> 36 #include <acpi/processor.h> 37 #endif 38 39 #include "powernow-k7.h" 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_MATCH_VENDOR_FAM(AMD, 6, NULL), 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("No powernow capabilities detected\n"); 131 #endif 132 return 0; 133 } 134 135 if ((c->x86_model == 6) && (c->x86_stepping == 0)) { 136 pr_info("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("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 rdmsrq(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 wrmsrq(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 rdmsrq(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 wrmsrq(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 rdmsrq(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_obj(*acpi_processor_perf); 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("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("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("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("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("No PST tables match this cpuid (0x%x)\n", 514 etuple); 515 pr_info("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("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 rdmsrq(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("%s laptop with broken PST tables in BIOS detected\n", 571 d->ident); 572 pr_warn("You need to downgrade to 3A21 (09/09/2002), or try a newer BIOS than 3A71 (01/20/2003)\n"); 573 pr_warn("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 const 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 rdmsrq(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("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("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("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("ACPI and legacy methods failed\n"); 627 } 628 } else { 629 /* SGTC use the bus clock as timer */ 630 latency = fixup_sgtc(); 631 pr_info("SGTC: %d\n", latency); 632 } 633 } 634 635 if (result) 636 return result; 637 638 pr_info("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 policy->freq_table = powernow_table; 644 645 return 0; 646 } 647 648 static void powernow_cpu_exit(struct cpufreq_policy *policy) 649 { 650 #ifdef CONFIG_X86_POWERNOW_K7_ACPI 651 if (acpi_processor_perf) { 652 acpi_processor_unregister_performance(0); 653 free_cpumask_var(acpi_processor_perf->shared_cpu_map); 654 kfree(acpi_processor_perf); 655 } 656 #endif 657 658 kfree(powernow_table); 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 }; 672 673 static int __init powernow_init(void) 674 { 675 if (check_powernow() == 0) 676 return -ENODEV; 677 return cpufreq_register_driver(&powernow_driver); 678 } 679 680 681 static void __exit powernow_exit(void) 682 { 683 cpufreq_unregister_driver(&powernow_driver); 684 } 685 686 module_param(acpi_force, int, 0444); 687 MODULE_PARM_DESC(acpi_force, "Force ACPI to be used."); 688 689 MODULE_AUTHOR("Dave Jones"); 690 MODULE_DESCRIPTION("Powernow driver for AMD K7 processors."); 691 MODULE_LICENSE("GPL"); 692 693 late_initcall(powernow_init); 694 module_exit(powernow_exit); 695 696