1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * processor_throttling.c - Throttling submodule of the ACPI processor driver 4 * 5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * Copyright (C) 2004 Dominik Brodowski <linux@brodo.de> 8 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 9 * - Added processor hotplug support 10 */ 11 12#include <linux/kernel.h> 13#include <linux/module.h> 14#include <linux/slab.h> 15#include <linux/init.h> 16#include <linux/sched.h> 17#include <linux/cpufreq.h> 18#include <linux/acpi.h> 19#include <acpi/processor.h> 20#include <asm/io.h> 21#include <linux/uaccess.h> 22 23#define PREFIX "ACPI: " 24 25#define ACPI_PROCESSOR_CLASS "processor" 26#define _COMPONENT ACPI_PROCESSOR_COMPONENT 27ACPI_MODULE_NAME("processor_throttling"); 28 29/* ignore_tpc: 30 * 0 -> acpi processor driver doesn't ignore _TPC values 31 * 1 -> acpi processor driver ignores _TPC values 32 */ 33static int ignore_tpc; 34module_param(ignore_tpc, int, 0644); 35MODULE_PARM_DESC(ignore_tpc, "Disable broken BIOS _TPC throttling support"); 36 37struct throttling_tstate { 38 unsigned int cpu; /* cpu nr */ 39 int target_state; /* target T-state */ 40}; 41 42struct acpi_processor_throttling_arg { 43 struct acpi_processor *pr; 44 int target_state; 45 bool force; 46}; 47 48#define THROTTLING_PRECHANGE (1) 49#define THROTTLING_POSTCHANGE (2) 50 51static int acpi_processor_get_throttling(struct acpi_processor *pr); 52static int __acpi_processor_set_throttling(struct acpi_processor *pr, 53 int state, bool force, bool direct); 54 55static int acpi_processor_update_tsd_coord(void) 56{ 57 int count, count_target; 58 int retval = 0; 59 unsigned int i, j; 60 cpumask_var_t covered_cpus; 61 struct acpi_processor *pr, *match_pr; 62 struct acpi_tsd_package *pdomain, *match_pdomain; 63 struct acpi_processor_throttling *pthrottling, *match_pthrottling; 64 65 if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL)) 66 return -ENOMEM; 67 68 /* 69 * Now that we have _TSD data from all CPUs, lets setup T-state 70 * coordination between all CPUs. 71 */ 72 for_each_possible_cpu(i) { 73 pr = per_cpu(processors, i); 74 if (!pr) 75 continue; 76 77 /* Basic validity check for domain info */ 78 pthrottling = &(pr->throttling); 79 80 /* 81 * If tsd package for one cpu is invalid, the coordination 82 * among all CPUs is thought as invalid. 83 * Maybe it is ugly. 84 */ 85 if (!pthrottling->tsd_valid_flag) { 86 retval = -EINVAL; 87 break; 88 } 89 } 90 if (retval) 91 goto err_ret; 92 93 for_each_possible_cpu(i) { 94 pr = per_cpu(processors, i); 95 if (!pr) 96 continue; 97 98 if (cpumask_test_cpu(i, covered_cpus)) 99 continue; 100 pthrottling = &pr->throttling; 101 102 pdomain = &(pthrottling->domain_info); 103 cpumask_set_cpu(i, pthrottling->shared_cpu_map); 104 cpumask_set_cpu(i, covered_cpus); 105 /* 106 * If the number of processor in the TSD domain is 1, it is 107 * unnecessary to parse the coordination for this CPU. 108 */ 109 if (pdomain->num_processors <= 1) 110 continue; 111 112 /* Validate the Domain info */ 113 count_target = pdomain->num_processors; 114 count = 1; 115 116 for_each_possible_cpu(j) { 117 if (i == j) 118 continue; 119 120 match_pr = per_cpu(processors, j); 121 if (!match_pr) 122 continue; 123 124 match_pthrottling = &(match_pr->throttling); 125 match_pdomain = &(match_pthrottling->domain_info); 126 if (match_pdomain->domain != pdomain->domain) 127 continue; 128 129 /* Here i and j are in the same domain. 130 * If two TSD packages have the same domain, they 131 * should have the same num_porcessors and 132 * coordination type. Otherwise it will be regarded 133 * as illegal. 134 */ 135 if (match_pdomain->num_processors != count_target) { 136 retval = -EINVAL; 137 goto err_ret; 138 } 139 140 if (pdomain->coord_type != match_pdomain->coord_type) { 141 retval = -EINVAL; 142 goto err_ret; 143 } 144 145 cpumask_set_cpu(j, covered_cpus); 146 cpumask_set_cpu(j, pthrottling->shared_cpu_map); 147 count++; 148 } 149 for_each_possible_cpu(j) { 150 if (i == j) 151 continue; 152 153 match_pr = per_cpu(processors, j); 154 if (!match_pr) 155 continue; 156 157 match_pthrottling = &(match_pr->throttling); 158 match_pdomain = &(match_pthrottling->domain_info); 159 if (match_pdomain->domain != pdomain->domain) 160 continue; 161 162 /* 163 * If some CPUS have the same domain, they 164 * will have the same shared_cpu_map. 165 */ 166 cpumask_copy(match_pthrottling->shared_cpu_map, 167 pthrottling->shared_cpu_map); 168 } 169 } 170 171err_ret: 172 free_cpumask_var(covered_cpus); 173 174 for_each_possible_cpu(i) { 175 pr = per_cpu(processors, i); 176 if (!pr) 177 continue; 178 179 /* 180 * Assume no coordination on any error parsing domain info. 181 * The coordination type will be forced as SW_ALL. 182 */ 183 if (retval) { 184 pthrottling = &(pr->throttling); 185 cpumask_clear(pthrottling->shared_cpu_map); 186 cpumask_set_cpu(i, pthrottling->shared_cpu_map); 187 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL; 188 } 189 } 190 191 return retval; 192} 193 194/* 195 * Update the T-state coordination after the _TSD 196 * data for all cpus is obtained. 197 */ 198void acpi_processor_throttling_init(void) 199{ 200 if (acpi_processor_update_tsd_coord()) { 201 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 202 "Assume no T-state coordination\n")); 203 } 204 205 return; 206} 207 208static int acpi_processor_throttling_notifier(unsigned long event, void *data) 209{ 210 struct throttling_tstate *p_tstate = data; 211 struct acpi_processor *pr; 212 unsigned int cpu ; 213 int target_state; 214 struct acpi_processor_limit *p_limit; 215 struct acpi_processor_throttling *p_throttling; 216 217 cpu = p_tstate->cpu; 218 pr = per_cpu(processors, cpu); 219 if (!pr) { 220 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Invalid pr pointer\n")); 221 return 0; 222 } 223 if (!pr->flags.throttling) { 224 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Throttling control is " 225 "unsupported on CPU %d\n", cpu)); 226 return 0; 227 } 228 target_state = p_tstate->target_state; 229 p_throttling = &(pr->throttling); 230 switch (event) { 231 case THROTTLING_PRECHANGE: 232 /* 233 * Prechange event is used to choose one proper t-state, 234 * which meets the limits of thermal, user and _TPC. 235 */ 236 p_limit = &pr->limit; 237 if (p_limit->thermal.tx > target_state) 238 target_state = p_limit->thermal.tx; 239 if (p_limit->user.tx > target_state) 240 target_state = p_limit->user.tx; 241 if (pr->throttling_platform_limit > target_state) 242 target_state = pr->throttling_platform_limit; 243 if (target_state >= p_throttling->state_count) { 244 printk(KERN_WARNING 245 "Exceed the limit of T-state \n"); 246 target_state = p_throttling->state_count - 1; 247 } 248 p_tstate->target_state = target_state; 249 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PreChange Event:" 250 "target T-state of CPU %d is T%d\n", 251 cpu, target_state)); 252 break; 253 case THROTTLING_POSTCHANGE: 254 /* 255 * Postchange event is only used to update the 256 * T-state flag of acpi_processor_throttling. 257 */ 258 p_throttling->state = target_state; 259 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PostChange Event:" 260 "CPU %d is switched to T%d\n", 261 cpu, target_state)); 262 break; 263 default: 264 printk(KERN_WARNING 265 "Unsupported Throttling notifier event\n"); 266 break; 267 } 268 269 return 0; 270} 271 272/* 273 * _TPC - Throttling Present Capabilities 274 */ 275static int acpi_processor_get_platform_limit(struct acpi_processor *pr) 276{ 277 acpi_status status = 0; 278 unsigned long long tpc = 0; 279 280 if (!pr) 281 return -EINVAL; 282 283 if (ignore_tpc) 284 goto end; 285 286 status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc); 287 if (ACPI_FAILURE(status)) { 288 if (status != AE_NOT_FOUND) { 289 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC")); 290 } 291 return -ENODEV; 292 } 293 294end: 295 pr->throttling_platform_limit = (int)tpc; 296 return 0; 297} 298 299int acpi_processor_tstate_has_changed(struct acpi_processor *pr) 300{ 301 int result = 0; 302 int throttling_limit; 303 int current_state; 304 struct acpi_processor_limit *limit; 305 int target_state; 306 307 if (ignore_tpc) 308 return 0; 309 310 result = acpi_processor_get_platform_limit(pr); 311 if (result) { 312 /* Throttling Limit is unsupported */ 313 return result; 314 } 315 316 throttling_limit = pr->throttling_platform_limit; 317 if (throttling_limit >= pr->throttling.state_count) { 318 /* Uncorrect Throttling Limit */ 319 return -EINVAL; 320 } 321 322 current_state = pr->throttling.state; 323 if (current_state > throttling_limit) { 324 /* 325 * The current state can meet the requirement of 326 * _TPC limit. But it is reasonable that OSPM changes 327 * t-states from high to low for better performance. 328 * Of course the limit condition of thermal 329 * and user should be considered. 330 */ 331 limit = &pr->limit; 332 target_state = throttling_limit; 333 if (limit->thermal.tx > target_state) 334 target_state = limit->thermal.tx; 335 if (limit->user.tx > target_state) 336 target_state = limit->user.tx; 337 } else if (current_state == throttling_limit) { 338 /* 339 * Unnecessary to change the throttling state 340 */ 341 return 0; 342 } else { 343 /* 344 * If the current state is lower than the limit of _TPC, it 345 * will be forced to switch to the throttling state defined 346 * by throttling_platfor_limit. 347 * Because the previous state meets with the limit condition 348 * of thermal and user, it is unnecessary to check it again. 349 */ 350 target_state = throttling_limit; 351 } 352 return acpi_processor_set_throttling(pr, target_state, false); 353} 354 355/* 356 * This function is used to reevaluate whether the T-state is valid 357 * after one CPU is onlined/offlined. 358 * It is noted that it won't reevaluate the following properties for 359 * the T-state. 360 * 1. Control method. 361 * 2. the number of supported T-state 362 * 3. TSD domain 363 */ 364void acpi_processor_reevaluate_tstate(struct acpi_processor *pr, 365 bool is_dead) 366{ 367 int result = 0; 368 369 if (is_dead) { 370 /* When one CPU is offline, the T-state throttling 371 * will be invalidated. 372 */ 373 pr->flags.throttling = 0; 374 return; 375 } 376 /* the following is to recheck whether the T-state is valid for 377 * the online CPU 378 */ 379 if (!pr->throttling.state_count) { 380 /* If the number of T-state is invalid, it is 381 * invalidated. 382 */ 383 pr->flags.throttling = 0; 384 return; 385 } 386 pr->flags.throttling = 1; 387 388 /* Disable throttling (if enabled). We'll let subsequent 389 * policy (e.g.thermal) decide to lower performance if it 390 * so chooses, but for now we'll crank up the speed. 391 */ 392 393 result = acpi_processor_get_throttling(pr); 394 if (result) 395 goto end; 396 397 if (pr->throttling.state) { 398 result = acpi_processor_set_throttling(pr, 0, false); 399 if (result) 400 goto end; 401 } 402 403end: 404 if (result) 405 pr->flags.throttling = 0; 406} 407/* 408 * _PTC - Processor Throttling Control (and status) register location 409 */ 410static int acpi_processor_get_throttling_control(struct acpi_processor *pr) 411{ 412 int result = 0; 413 acpi_status status = 0; 414 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 415 union acpi_object *ptc = NULL; 416 union acpi_object obj = { 0 }; 417 struct acpi_processor_throttling *throttling; 418 419 status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer); 420 if (ACPI_FAILURE(status)) { 421 if (status != AE_NOT_FOUND) { 422 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC")); 423 } 424 return -ENODEV; 425 } 426 427 ptc = (union acpi_object *)buffer.pointer; 428 if (!ptc || (ptc->type != ACPI_TYPE_PACKAGE) 429 || (ptc->package.count != 2)) { 430 printk(KERN_ERR PREFIX "Invalid _PTC data\n"); 431 result = -EFAULT; 432 goto end; 433 } 434 435 /* 436 * control_register 437 */ 438 439 obj = ptc->package.elements[0]; 440 441 if ((obj.type != ACPI_TYPE_BUFFER) 442 || (obj.buffer.length < sizeof(struct acpi_ptc_register)) 443 || (obj.buffer.pointer == NULL)) { 444 printk(KERN_ERR PREFIX 445 "Invalid _PTC data (control_register)\n"); 446 result = -EFAULT; 447 goto end; 448 } 449 memcpy(&pr->throttling.control_register, obj.buffer.pointer, 450 sizeof(struct acpi_ptc_register)); 451 452 /* 453 * status_register 454 */ 455 456 obj = ptc->package.elements[1]; 457 458 if ((obj.type != ACPI_TYPE_BUFFER) 459 || (obj.buffer.length < sizeof(struct acpi_ptc_register)) 460 || (obj.buffer.pointer == NULL)) { 461 printk(KERN_ERR PREFIX "Invalid _PTC data (status_register)\n"); 462 result = -EFAULT; 463 goto end; 464 } 465 466 memcpy(&pr->throttling.status_register, obj.buffer.pointer, 467 sizeof(struct acpi_ptc_register)); 468 469 throttling = &pr->throttling; 470 471 if ((throttling->control_register.bit_width + 472 throttling->control_register.bit_offset) > 32) { 473 printk(KERN_ERR PREFIX "Invalid _PTC control register\n"); 474 result = -EFAULT; 475 goto end; 476 } 477 478 if ((throttling->status_register.bit_width + 479 throttling->status_register.bit_offset) > 32) { 480 printk(KERN_ERR PREFIX "Invalid _PTC status register\n"); 481 result = -EFAULT; 482 goto end; 483 } 484 485 end: 486 kfree(buffer.pointer); 487 488 return result; 489} 490 491/* 492 * _TSS - Throttling Supported States 493 */ 494static int acpi_processor_get_throttling_states(struct acpi_processor *pr) 495{ 496 int result = 0; 497 acpi_status status = AE_OK; 498 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 499 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" }; 500 struct acpi_buffer state = { 0, NULL }; 501 union acpi_object *tss = NULL; 502 int i; 503 504 status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer); 505 if (ACPI_FAILURE(status)) { 506 if (status != AE_NOT_FOUND) { 507 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS")); 508 } 509 return -ENODEV; 510 } 511 512 tss = buffer.pointer; 513 if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) { 514 printk(KERN_ERR PREFIX "Invalid _TSS data\n"); 515 result = -EFAULT; 516 goto end; 517 } 518 519 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n", 520 tss->package.count)); 521 522 pr->throttling.state_count = tss->package.count; 523 pr->throttling.states_tss = 524 kmalloc_array(tss->package.count, 525 sizeof(struct acpi_processor_tx_tss), 526 GFP_KERNEL); 527 if (!pr->throttling.states_tss) { 528 result = -ENOMEM; 529 goto end; 530 } 531 532 for (i = 0; i < pr->throttling.state_count; i++) { 533 534 struct acpi_processor_tx_tss *tx = 535 (struct acpi_processor_tx_tss *)&(pr->throttling. 536 states_tss[i]); 537 538 state.length = sizeof(struct acpi_processor_tx_tss); 539 state.pointer = tx; 540 541 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i)); 542 543 status = acpi_extract_package(&(tss->package.elements[i]), 544 &format, &state); 545 if (ACPI_FAILURE(status)) { 546 ACPI_EXCEPTION((AE_INFO, status, "Invalid _TSS data")); 547 result = -EFAULT; 548 kfree(pr->throttling.states_tss); 549 goto end; 550 } 551 552 if (!tx->freqpercentage) { 553 printk(KERN_ERR PREFIX 554 "Invalid _TSS data: freq is zero\n"); 555 result = -EFAULT; 556 kfree(pr->throttling.states_tss); 557 goto end; 558 } 559 } 560 561 end: 562 kfree(buffer.pointer); 563 564 return result; 565} 566 567/* 568 * _TSD - T-State Dependencies 569 */ 570static int acpi_processor_get_tsd(struct acpi_processor *pr) 571{ 572 int result = 0; 573 acpi_status status = AE_OK; 574 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 575 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" }; 576 struct acpi_buffer state = { 0, NULL }; 577 union acpi_object *tsd = NULL; 578 struct acpi_tsd_package *pdomain; 579 struct acpi_processor_throttling *pthrottling; 580 581 pthrottling = &pr->throttling; 582 pthrottling->tsd_valid_flag = 0; 583 584 status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer); 585 if (ACPI_FAILURE(status)) { 586 if (status != AE_NOT_FOUND) { 587 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSD")); 588 } 589 return -ENODEV; 590 } 591 592 tsd = buffer.pointer; 593 if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) { 594 printk(KERN_ERR PREFIX "Invalid _TSD data\n"); 595 result = -EFAULT; 596 goto end; 597 } 598 599 if (tsd->package.count != 1) { 600 printk(KERN_ERR PREFIX "Invalid _TSD data\n"); 601 result = -EFAULT; 602 goto end; 603 } 604 605 pdomain = &(pr->throttling.domain_info); 606 607 state.length = sizeof(struct acpi_tsd_package); 608 state.pointer = pdomain; 609 610 status = acpi_extract_package(&(tsd->package.elements[0]), 611 &format, &state); 612 if (ACPI_FAILURE(status)) { 613 printk(KERN_ERR PREFIX "Invalid _TSD data\n"); 614 result = -EFAULT; 615 goto end; 616 } 617 618 if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) { 619 printk(KERN_ERR PREFIX "Unknown _TSD:num_entries\n"); 620 result = -EFAULT; 621 goto end; 622 } 623 624 if (pdomain->revision != ACPI_TSD_REV0_REVISION) { 625 printk(KERN_ERR PREFIX "Unknown _TSD:revision\n"); 626 result = -EFAULT; 627 goto end; 628 } 629 630 pthrottling = &pr->throttling; 631 pthrottling->tsd_valid_flag = 1; 632 pthrottling->shared_type = pdomain->coord_type; 633 cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map); 634 /* 635 * If the coordination type is not defined in ACPI spec, 636 * the tsd_valid_flag will be clear and coordination type 637 * will be forecd as DOMAIN_COORD_TYPE_SW_ALL. 638 */ 639 if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL && 640 pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY && 641 pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) { 642 pthrottling->tsd_valid_flag = 0; 643 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL; 644 } 645 646 end: 647 kfree(buffer.pointer); 648 return result; 649} 650 651/* -------------------------------------------------------------------------- 652 Throttling Control 653 -------------------------------------------------------------------------- */ 654static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr) 655{ 656 int state = 0; 657 u32 value = 0; 658 u32 duty_mask = 0; 659 u32 duty_value = 0; 660 661 if (!pr) 662 return -EINVAL; 663 664 if (!pr->flags.throttling) 665 return -ENODEV; 666 667 /* 668 * We don't care about error returns - we just try to mark 669 * these reserved so that nobody else is confused into thinking 670 * that this region might be unused.. 671 * 672 * (In particular, allocating the IO range for Cardbus) 673 */ 674 request_region(pr->throttling.address, 6, "ACPI CPU throttle"); 675 676 pr->throttling.state = 0; 677 678 duty_mask = pr->throttling.state_count - 1; 679 680 duty_mask <<= pr->throttling.duty_offset; 681 682 local_irq_disable(); 683 684 value = inl(pr->throttling.address); 685 686 /* 687 * Compute the current throttling state when throttling is enabled 688 * (bit 4 is on). 689 */ 690 if (value & 0x10) { 691 duty_value = value & duty_mask; 692 duty_value >>= pr->throttling.duty_offset; 693 694 if (duty_value) 695 state = pr->throttling.state_count - duty_value; 696 } 697 698 pr->throttling.state = state; 699 700 local_irq_enable(); 701 702 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 703 "Throttling state is T%d (%d%% throttling applied)\n", 704 state, pr->throttling.states[state].performance)); 705 706 return 0; 707} 708 709#ifdef CONFIG_X86 710static int acpi_throttling_rdmsr(u64 *value) 711{ 712 u64 msr_high, msr_low; 713 u64 msr = 0; 714 int ret = -1; 715 716 if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) || 717 !this_cpu_has(X86_FEATURE_ACPI)) { 718 printk(KERN_ERR PREFIX 719 "HARDWARE addr space,NOT supported yet\n"); 720 } else { 721 msr_low = 0; 722 msr_high = 0; 723 rdmsr_safe(MSR_IA32_THERM_CONTROL, 724 (u32 *)&msr_low , (u32 *) &msr_high); 725 msr = (msr_high << 32) | msr_low; 726 *value = (u64) msr; 727 ret = 0; 728 } 729 return ret; 730} 731 732static int acpi_throttling_wrmsr(u64 value) 733{ 734 int ret = -1; 735 u64 msr; 736 737 if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) || 738 !this_cpu_has(X86_FEATURE_ACPI)) { 739 printk(KERN_ERR PREFIX 740 "HARDWARE addr space,NOT supported yet\n"); 741 } else { 742 msr = value; 743 wrmsr_safe(MSR_IA32_THERM_CONTROL, 744 msr & 0xffffffff, msr >> 32); 745 ret = 0; 746 } 747 return ret; 748} 749#else 750static int acpi_throttling_rdmsr(u64 *value) 751{ 752 printk(KERN_ERR PREFIX 753 "HARDWARE addr space,NOT supported yet\n"); 754 return -1; 755} 756 757static int acpi_throttling_wrmsr(u64 value) 758{ 759 printk(KERN_ERR PREFIX 760 "HARDWARE addr space,NOT supported yet\n"); 761 return -1; 762} 763#endif 764 765static int acpi_read_throttling_status(struct acpi_processor *pr, 766 u64 *value) 767{ 768 u32 bit_width, bit_offset; 769 u32 ptc_value; 770 u64 ptc_mask; 771 struct acpi_processor_throttling *throttling; 772 int ret = -1; 773 774 throttling = &pr->throttling; 775 switch (throttling->status_register.space_id) { 776 case ACPI_ADR_SPACE_SYSTEM_IO: 777 bit_width = throttling->status_register.bit_width; 778 bit_offset = throttling->status_register.bit_offset; 779 780 acpi_os_read_port((acpi_io_address) throttling->status_register. 781 address, &ptc_value, 782 (u32) (bit_width + bit_offset)); 783 ptc_mask = (1 << bit_width) - 1; 784 *value = (u64) ((ptc_value >> bit_offset) & ptc_mask); 785 ret = 0; 786 break; 787 case ACPI_ADR_SPACE_FIXED_HARDWARE: 788 ret = acpi_throttling_rdmsr(value); 789 break; 790 default: 791 printk(KERN_ERR PREFIX "Unknown addr space %d\n", 792 (u32) (throttling->status_register.space_id)); 793 } 794 return ret; 795} 796 797static int acpi_write_throttling_state(struct acpi_processor *pr, 798 u64 value) 799{ 800 u32 bit_width, bit_offset; 801 u64 ptc_value; 802 u64 ptc_mask; 803 struct acpi_processor_throttling *throttling; 804 int ret = -1; 805 806 throttling = &pr->throttling; 807 switch (throttling->control_register.space_id) { 808 case ACPI_ADR_SPACE_SYSTEM_IO: 809 bit_width = throttling->control_register.bit_width; 810 bit_offset = throttling->control_register.bit_offset; 811 ptc_mask = (1 << bit_width) - 1; 812 ptc_value = value & ptc_mask; 813 814 acpi_os_write_port((acpi_io_address) throttling-> 815 control_register.address, 816 (u32) (ptc_value << bit_offset), 817 (u32) (bit_width + bit_offset)); 818 ret = 0; 819 break; 820 case ACPI_ADR_SPACE_FIXED_HARDWARE: 821 ret = acpi_throttling_wrmsr(value); 822 break; 823 default: 824 printk(KERN_ERR PREFIX "Unknown addr space %d\n", 825 (u32) (throttling->control_register.space_id)); 826 } 827 return ret; 828} 829 830static int acpi_get_throttling_state(struct acpi_processor *pr, 831 u64 value) 832{ 833 int i; 834 835 for (i = 0; i < pr->throttling.state_count; i++) { 836 struct acpi_processor_tx_tss *tx = 837 (struct acpi_processor_tx_tss *)&(pr->throttling. 838 states_tss[i]); 839 if (tx->control == value) 840 return i; 841 } 842 return -1; 843} 844 845static int acpi_get_throttling_value(struct acpi_processor *pr, 846 int state, u64 *value) 847{ 848 int ret = -1; 849 850 if (state >= 0 && state <= pr->throttling.state_count) { 851 struct acpi_processor_tx_tss *tx = 852 (struct acpi_processor_tx_tss *)&(pr->throttling. 853 states_tss[state]); 854 *value = tx->control; 855 ret = 0; 856 } 857 return ret; 858} 859 860static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr) 861{ 862 int state = 0; 863 int ret; 864 u64 value; 865 866 if (!pr) 867 return -EINVAL; 868 869 if (!pr->flags.throttling) 870 return -ENODEV; 871 872 pr->throttling.state = 0; 873 874 value = 0; 875 ret = acpi_read_throttling_status(pr, &value); 876 if (ret >= 0) { 877 state = acpi_get_throttling_state(pr, value); 878 if (state == -1) { 879 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 880 "Invalid throttling state, reset\n")); 881 state = 0; 882 ret = __acpi_processor_set_throttling(pr, state, true, 883 true); 884 if (ret) 885 return ret; 886 } 887 pr->throttling.state = state; 888 } 889 890 return 0; 891} 892 893static long __acpi_processor_get_throttling(void *data) 894{ 895 struct acpi_processor *pr = data; 896 897 return pr->throttling.acpi_processor_get_throttling(pr); 898} 899 900static int acpi_processor_get_throttling(struct acpi_processor *pr) 901{ 902 if (!pr) 903 return -EINVAL; 904 905 if (!pr->flags.throttling) 906 return -ENODEV; 907 908 /* 909 * This is either called from the CPU hotplug callback of 910 * processor_driver or via the ACPI probe function. In the latter 911 * case the CPU is not guaranteed to be online. Both call sites are 912 * protected against CPU hotplug. 913 */ 914 if (!cpu_online(pr->id)) 915 return -ENODEV; 916 917 return call_on_cpu(pr->id, __acpi_processor_get_throttling, pr, false); 918} 919 920static int acpi_processor_get_fadt_info(struct acpi_processor *pr) 921{ 922 int i, step; 923 924 if (!pr->throttling.address) { 925 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n")); 926 return -EINVAL; 927 } else if (!pr->throttling.duty_width) { 928 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n")); 929 return -EINVAL; 930 } 931 /* TBD: Support duty_cycle values that span bit 4. */ 932 else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) { 933 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n"); 934 return -EINVAL; 935 } 936 937 pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width; 938 939 /* 940 * Compute state values. Note that throttling displays a linear power 941 * performance relationship (at 50% performance the CPU will consume 942 * 50% power). Values are in 1/10th of a percent to preserve accuracy. 943 */ 944 945 step = (1000 / pr->throttling.state_count); 946 947 for (i = 0; i < pr->throttling.state_count; i++) { 948 pr->throttling.states[i].performance = 1000 - step * i; 949 pr->throttling.states[i].power = 1000 - step * i; 950 } 951 return 0; 952} 953 954static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr, 955 int state, bool force) 956{ 957 u32 value = 0; 958 u32 duty_mask = 0; 959 u32 duty_value = 0; 960 961 if (!pr) 962 return -EINVAL; 963 964 if ((state < 0) || (state > (pr->throttling.state_count - 1))) 965 return -EINVAL; 966 967 if (!pr->flags.throttling) 968 return -ENODEV; 969 970 if (!force && (state == pr->throttling.state)) 971 return 0; 972 973 if (state < pr->throttling_platform_limit) 974 return -EPERM; 975 /* 976 * Calculate the duty_value and duty_mask. 977 */ 978 if (state) { 979 duty_value = pr->throttling.state_count - state; 980 981 duty_value <<= pr->throttling.duty_offset; 982 983 /* Used to clear all duty_value bits */ 984 duty_mask = pr->throttling.state_count - 1; 985 986 duty_mask <<= acpi_gbl_FADT.duty_offset; 987 duty_mask = ~duty_mask; 988 } 989 990 local_irq_disable(); 991 992 /* 993 * Disable throttling by writing a 0 to bit 4. Note that we must 994 * turn it off before you can change the duty_value. 995 */ 996 value = inl(pr->throttling.address); 997 if (value & 0x10) { 998 value &= 0xFFFFFFEF; 999 outl(value, pr->throttling.address); 1000 } 1001 1002 /* 1003 * Write the new duty_value and then enable throttling. Note 1004 * that a state value of 0 leaves throttling disabled. 1005 */ 1006 if (state) { 1007 value &= duty_mask; 1008 value |= duty_value; 1009 outl(value, pr->throttling.address); 1010 1011 value |= 0x00000010; 1012 outl(value, pr->throttling.address); 1013 } 1014 1015 pr->throttling.state = state; 1016 1017 local_irq_enable(); 1018 1019 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1020 "Throttling state set to T%d (%d%%)\n", state, 1021 (pr->throttling.states[state].performance ? pr-> 1022 throttling.states[state].performance / 10 : 0))); 1023 1024 return 0; 1025} 1026 1027static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr, 1028 int state, bool force) 1029{ 1030 int ret; 1031 u64 value; 1032 1033 if (!pr) 1034 return -EINVAL; 1035 1036 if ((state < 0) || (state > (pr->throttling.state_count - 1))) 1037 return -EINVAL; 1038 1039 if (!pr->flags.throttling) 1040 return -ENODEV; 1041 1042 if (!force && (state == pr->throttling.state)) 1043 return 0; 1044 1045 if (state < pr->throttling_platform_limit) 1046 return -EPERM; 1047 1048 value = 0; 1049 ret = acpi_get_throttling_value(pr, state, &value); 1050 if (ret >= 0) { 1051 acpi_write_throttling_state(pr, value); 1052 pr->throttling.state = state; 1053 } 1054 1055 return 0; 1056} 1057 1058static long acpi_processor_throttling_fn(void *data) 1059{ 1060 struct acpi_processor_throttling_arg *arg = data; 1061 struct acpi_processor *pr = arg->pr; 1062 1063 return pr->throttling.acpi_processor_set_throttling(pr, 1064 arg->target_state, arg->force); 1065} 1066 1067static int __acpi_processor_set_throttling(struct acpi_processor *pr, 1068 int state, bool force, bool direct) 1069{ 1070 int ret = 0; 1071 unsigned int i; 1072 struct acpi_processor *match_pr; 1073 struct acpi_processor_throttling *p_throttling; 1074 struct acpi_processor_throttling_arg arg; 1075 struct throttling_tstate t_state; 1076 1077 if (!pr) 1078 return -EINVAL; 1079 1080 if (!pr->flags.throttling) 1081 return -ENODEV; 1082 1083 if ((state < 0) || (state > (pr->throttling.state_count - 1))) 1084 return -EINVAL; 1085 1086 if (cpu_is_offline(pr->id)) { 1087 /* 1088 * the cpu pointed by pr->id is offline. Unnecessary to change 1089 * the throttling state any more. 1090 */ 1091 return -ENODEV; 1092 } 1093 1094 t_state.target_state = state; 1095 p_throttling = &(pr->throttling); 1096 1097 /* 1098 * The throttling notifier will be called for every 1099 * affected cpu in order to get one proper T-state. 1100 * The notifier event is THROTTLING_PRECHANGE. 1101 */ 1102 for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) { 1103 t_state.cpu = i; 1104 acpi_processor_throttling_notifier(THROTTLING_PRECHANGE, 1105 &t_state); 1106 } 1107 /* 1108 * The function of acpi_processor_set_throttling will be called 1109 * to switch T-state. If the coordination type is SW_ALL or HW_ALL, 1110 * it is necessary to call it for every affected cpu. Otherwise 1111 * it can be called only for the cpu pointed by pr. 1112 */ 1113 if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) { 1114 arg.pr = pr; 1115 arg.target_state = state; 1116 arg.force = force; 1117 ret = call_on_cpu(pr->id, acpi_processor_throttling_fn, &arg, 1118 direct); 1119 } else { 1120 /* 1121 * When the T-state coordination is SW_ALL or HW_ALL, 1122 * it is necessary to set T-state for every affected 1123 * cpus. 1124 */ 1125 for_each_cpu_and(i, cpu_online_mask, 1126 p_throttling->shared_cpu_map) { 1127 match_pr = per_cpu(processors, i); 1128 /* 1129 * If the pointer is invalid, we will report the 1130 * error message and continue. 1131 */ 1132 if (!match_pr) { 1133 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1134 "Invalid Pointer for CPU %d\n", i)); 1135 continue; 1136 } 1137 /* 1138 * If the throttling control is unsupported on CPU i, 1139 * we will report the error message and continue. 1140 */ 1141 if (!match_pr->flags.throttling) { 1142 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1143 "Throttling Control is unsupported " 1144 "on CPU %d\n", i)); 1145 continue; 1146 } 1147 1148 arg.pr = match_pr; 1149 arg.target_state = state; 1150 arg.force = force; 1151 ret = call_on_cpu(pr->id, acpi_processor_throttling_fn, 1152 &arg, direct); 1153 } 1154 } 1155 /* 1156 * After the set_throttling is called, the 1157 * throttling notifier is called for every 1158 * affected cpu to update the T-states. 1159 * The notifier event is THROTTLING_POSTCHANGE 1160 */ 1161 for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) { 1162 t_state.cpu = i; 1163 acpi_processor_throttling_notifier(THROTTLING_POSTCHANGE, 1164 &t_state); 1165 } 1166 1167 return ret; 1168} 1169 1170int acpi_processor_set_throttling(struct acpi_processor *pr, int state, 1171 bool force) 1172{ 1173 return __acpi_processor_set_throttling(pr, state, force, false); 1174} 1175 1176int acpi_processor_get_throttling_info(struct acpi_processor *pr) 1177{ 1178 int result = 0; 1179 struct acpi_processor_throttling *pthrottling; 1180 1181 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1182 "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n", 1183 pr->throttling.address, 1184 pr->throttling.duty_offset, 1185 pr->throttling.duty_width)); 1186 1187 /* 1188 * Evaluate _PTC, _TSS and _TPC 1189 * They must all be present or none of them can be used. 1190 */ 1191 if (acpi_processor_get_throttling_control(pr) || 1192 acpi_processor_get_throttling_states(pr) || 1193 acpi_processor_get_platform_limit(pr)) 1194 { 1195 pr->throttling.acpi_processor_get_throttling = 1196 &acpi_processor_get_throttling_fadt; 1197 pr->throttling.acpi_processor_set_throttling = 1198 &acpi_processor_set_throttling_fadt; 1199 if (acpi_processor_get_fadt_info(pr)) 1200 return 0; 1201 } else { 1202 pr->throttling.acpi_processor_get_throttling = 1203 &acpi_processor_get_throttling_ptc; 1204 pr->throttling.acpi_processor_set_throttling = 1205 &acpi_processor_set_throttling_ptc; 1206 } 1207 1208 /* 1209 * If TSD package for one CPU can't be parsed successfully, it means 1210 * that this CPU will have no coordination with other CPUs. 1211 */ 1212 if (acpi_processor_get_tsd(pr)) { 1213 pthrottling = &pr->throttling; 1214 pthrottling->tsd_valid_flag = 0; 1215 cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map); 1216 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL; 1217 } 1218 1219 /* 1220 * PIIX4 Errata: We don't support throttling on the original PIIX4. 1221 * This shouldn't be an issue as few (if any) mobile systems ever 1222 * used this part. 1223 */ 1224 if (errata.piix4.throttle) { 1225 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1226 "Throttling not supported on PIIX4 A- or B-step\n")); 1227 return 0; 1228 } 1229 1230 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n", 1231 pr->throttling.state_count)); 1232 1233 pr->flags.throttling = 1; 1234 1235 /* 1236 * Disable throttling (if enabled). We'll let subsequent policy (e.g. 1237 * thermal) decide to lower performance if it so chooses, but for now 1238 * we'll crank up the speed. 1239 */ 1240 1241 result = acpi_processor_get_throttling(pr); 1242 if (result) 1243 goto end; 1244 1245 if (pr->throttling.state) { 1246 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1247 "Disabling throttling (was T%d)\n", 1248 pr->throttling.state)); 1249 result = acpi_processor_set_throttling(pr, 0, false); 1250 if (result) 1251 goto end; 1252 } 1253 1254 end: 1255 if (result) 1256 pr->flags.throttling = 0; 1257 1258 return result; 1259} 1260 1261