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