2019-05-27 14:55:06 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* processor_throttling.c - Throttling submodule of the ACPI processor driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
|
|
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
* Copyright (C) 2004 Dominik Brodowski <linux@brodo.de>
|
|
|
|
* Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
|
|
|
|
* - Added processor hotplug support
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/init.h>
|
2007-11-29 16:22:43 +08:00
|
|
|
#include <linux/sched.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/cpufreq.h>
|
2013-12-03 08:49:16 +08:00
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <acpi/processor.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/io.h>
|
2016-12-25 03:46:01 +08:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-29 04:45:54 +08:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define _COMPONENT ACPI_PROCESSOR_COMPONENT
|
2007-02-13 11:42:12 +08:00
|
|
|
ACPI_MODULE_NAME("processor_throttling");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-05-11 09:35:57 +08:00
|
|
|
/* ignore_tpc:
|
|
|
|
* 0 -> acpi processor driver doesn't ignore _TPC values
|
|
|
|
* 1 -> acpi processor driver ignores _TPC values
|
|
|
|
*/
|
|
|
|
static int ignore_tpc;
|
|
|
|
module_param(ignore_tpc, int, 0644);
|
|
|
|
MODULE_PARM_DESC(ignore_tpc, "Disable broken BIOS _TPC throttling support");
|
|
|
|
|
2008-01-28 13:54:46 +08:00
|
|
|
struct throttling_tstate {
|
|
|
|
unsigned int cpu; /* cpu nr */
|
|
|
|
int target_state; /* target T-state */
|
|
|
|
};
|
|
|
|
|
2014-02-26 21:03:05 +08:00
|
|
|
struct acpi_processor_throttling_arg {
|
|
|
|
struct acpi_processor *pr;
|
|
|
|
int target_state;
|
|
|
|
bool force;
|
|
|
|
};
|
|
|
|
|
2008-01-28 13:54:46 +08:00
|
|
|
#define THROTTLING_PRECHANGE (1)
|
|
|
|
#define THROTTLING_POSTCHANGE (2)
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
static int acpi_processor_get_throttling(struct acpi_processor *pr);
|
2017-04-13 04:07:34 +08:00
|
|
|
static int __acpi_processor_set_throttling(struct acpi_processor *pr,
|
|
|
|
int state, bool force, bool direct);
|
2007-05-26 22:49:58 +08:00
|
|
|
|
2008-01-28 13:53:42 +08:00
|
|
|
static int acpi_processor_update_tsd_coord(void)
|
|
|
|
{
|
|
|
|
int count, count_target;
|
|
|
|
int retval = 0;
|
|
|
|
unsigned int i, j;
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_var_t covered_cpus;
|
2008-01-28 13:53:42 +08:00
|
|
|
struct acpi_processor *pr, *match_pr;
|
|
|
|
struct acpi_tsd_package *pdomain, *match_pdomain;
|
|
|
|
struct acpi_processor_throttling *pthrottling, *match_pthrottling;
|
|
|
|
|
2009-06-15 14:58:26 +08:00
|
|
|
if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
|
2009-01-01 10:08:47 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-01-28 13:53:42 +08:00
|
|
|
/*
|
|
|
|
* Now that we have _TSD data from all CPUs, lets setup T-state
|
2008-01-28 13:55:56 +08:00
|
|
|
* coordination between all CPUs.
|
2008-01-28 13:53:42 +08:00
|
|
|
*/
|
|
|
|
for_each_possible_cpu(i) {
|
2008-06-10 07:22:23 +08:00
|
|
|
pr = per_cpu(processors, i);
|
2008-01-28 13:53:42 +08:00
|
|
|
if (!pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Basic validity check for domain info */
|
|
|
|
pthrottling = &(pr->throttling);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If tsd package for one cpu is invalid, the coordination
|
|
|
|
* among all CPUs is thought as invalid.
|
|
|
|
* Maybe it is ugly.
|
|
|
|
*/
|
|
|
|
if (!pthrottling->tsd_valid_flag) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
goto err_ret;
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
2008-06-10 07:22:23 +08:00
|
|
|
pr = per_cpu(processors, i);
|
2008-01-28 13:53:42 +08:00
|
|
|
if (!pr)
|
|
|
|
continue;
|
|
|
|
|
2009-01-01 10:08:47 +08:00
|
|
|
if (cpumask_test_cpu(i, covered_cpus))
|
2008-01-28 13:53:42 +08:00
|
|
|
continue;
|
|
|
|
pthrottling = &pr->throttling;
|
|
|
|
|
|
|
|
pdomain = &(pthrottling->domain_info);
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_set_cpu(i, pthrottling->shared_cpu_map);
|
|
|
|
cpumask_set_cpu(i, covered_cpus);
|
2008-01-28 13:53:42 +08:00
|
|
|
/*
|
|
|
|
* If the number of processor in the TSD domain is 1, it is
|
|
|
|
* unnecessary to parse the coordination for this CPU.
|
|
|
|
*/
|
|
|
|
if (pdomain->num_processors <= 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Validate the Domain info */
|
|
|
|
count_target = pdomain->num_processors;
|
|
|
|
count = 1;
|
|
|
|
|
|
|
|
for_each_possible_cpu(j) {
|
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
|
2008-06-10 07:22:23 +08:00
|
|
|
match_pr = per_cpu(processors, j);
|
2008-01-28 13:53:42 +08:00
|
|
|
if (!match_pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
match_pthrottling = &(match_pr->throttling);
|
|
|
|
match_pdomain = &(match_pthrottling->domain_info);
|
|
|
|
if (match_pdomain->domain != pdomain->domain)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Here i and j are in the same domain.
|
|
|
|
* If two TSD packages have the same domain, they
|
|
|
|
* should have the same num_porcessors and
|
|
|
|
* coordination type. Otherwise it will be regarded
|
|
|
|
* as illegal.
|
|
|
|
*/
|
|
|
|
if (match_pdomain->num_processors != count_target) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto err_ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdomain->coord_type != match_pdomain->coord_type) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto err_ret;
|
|
|
|
}
|
|
|
|
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_set_cpu(j, covered_cpus);
|
|
|
|
cpumask_set_cpu(j, pthrottling->shared_cpu_map);
|
2008-01-28 13:53:42 +08:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
for_each_possible_cpu(j) {
|
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
|
2008-06-10 07:22:23 +08:00
|
|
|
match_pr = per_cpu(processors, j);
|
2008-01-28 13:53:42 +08:00
|
|
|
if (!match_pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
match_pthrottling = &(match_pr->throttling);
|
|
|
|
match_pdomain = &(match_pthrottling->domain_info);
|
|
|
|
if (match_pdomain->domain != pdomain->domain)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If some CPUS have the same domain, they
|
|
|
|
* will have the same shared_cpu_map.
|
|
|
|
*/
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_copy(match_pthrottling->shared_cpu_map,
|
|
|
|
pthrottling->shared_cpu_map);
|
2008-01-28 13:53:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err_ret:
|
2009-01-01 10:08:47 +08:00
|
|
|
free_cpumask_var(covered_cpus);
|
|
|
|
|
2008-01-28 13:53:42 +08:00
|
|
|
for_each_possible_cpu(i) {
|
2008-06-10 07:22:23 +08:00
|
|
|
pr = per_cpu(processors, i);
|
2008-01-28 13:53:42 +08:00
|
|
|
if (!pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Assume no coordination on any error parsing domain info.
|
|
|
|
* The coordination type will be forced as SW_ALL.
|
|
|
|
*/
|
|
|
|
if (retval) {
|
|
|
|
pthrottling = &(pr->throttling);
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_clear(pthrottling->shared_cpu_map);
|
|
|
|
cpumask_set_cpu(i, pthrottling->shared_cpu_map);
|
2008-01-28 13:53:42 +08:00
|
|
|
pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the T-state coordination after the _TSD
|
|
|
|
* data for all cpus is obtained.
|
|
|
|
*/
|
|
|
|
void acpi_processor_throttling_init(void)
|
|
|
|
{
|
2013-03-11 17:17:05 +08:00
|
|
|
if (acpi_processor_update_tsd_coord()) {
|
2008-01-28 13:53:42 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Assume no T-state coordination\n"));
|
2013-03-11 17:17:05 +08:00
|
|
|
}
|
2008-01-28 13:53:42 +08:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-01-28 13:54:46 +08:00
|
|
|
static int acpi_processor_throttling_notifier(unsigned long event, void *data)
|
|
|
|
{
|
|
|
|
struct throttling_tstate *p_tstate = data;
|
|
|
|
struct acpi_processor *pr;
|
|
|
|
unsigned int cpu ;
|
|
|
|
int target_state;
|
|
|
|
struct acpi_processor_limit *p_limit;
|
|
|
|
struct acpi_processor_throttling *p_throttling;
|
|
|
|
|
|
|
|
cpu = p_tstate->cpu;
|
2008-06-10 07:22:23 +08:00
|
|
|
pr = per_cpu(processors, cpu);
|
2008-01-28 13:54:46 +08:00
|
|
|
if (!pr) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Invalid pr pointer\n"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (!pr->flags.throttling) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Throttling control is "
|
|
|
|
"unsupported on CPU %d\n", cpu));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
target_state = p_tstate->target_state;
|
|
|
|
p_throttling = &(pr->throttling);
|
|
|
|
switch (event) {
|
|
|
|
case THROTTLING_PRECHANGE:
|
|
|
|
/*
|
|
|
|
* Prechange event is used to choose one proper t-state,
|
|
|
|
* which meets the limits of thermal, user and _TPC.
|
|
|
|
*/
|
|
|
|
p_limit = &pr->limit;
|
|
|
|
if (p_limit->thermal.tx > target_state)
|
|
|
|
target_state = p_limit->thermal.tx;
|
|
|
|
if (p_limit->user.tx > target_state)
|
|
|
|
target_state = p_limit->user.tx;
|
|
|
|
if (pr->throttling_platform_limit > target_state)
|
|
|
|
target_state = pr->throttling_platform_limit;
|
|
|
|
if (target_state >= p_throttling->state_count) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"Exceed the limit of T-state \n");
|
|
|
|
target_state = p_throttling->state_count - 1;
|
|
|
|
}
|
|
|
|
p_tstate->target_state = target_state;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PreChange Event:"
|
|
|
|
"target T-state of CPU %d is T%d\n",
|
|
|
|
cpu, target_state));
|
|
|
|
break;
|
|
|
|
case THROTTLING_POSTCHANGE:
|
|
|
|
/*
|
|
|
|
* Postchange event is only used to update the
|
|
|
|
* T-state flag of acpi_processor_throttling.
|
|
|
|
*/
|
|
|
|
p_throttling->state = target_state;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PostChange Event:"
|
|
|
|
"CPU %d is switched to T%d\n",
|
|
|
|
cpu, target_state));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"Unsupported Throttling notifier event\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-25 12:57:46 +08:00
|
|
|
/*
|
|
|
|
* _TPC - Throttling Present Capabilities
|
|
|
|
*/
|
2007-05-26 22:49:58 +08:00
|
|
|
static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
|
|
|
|
{
|
|
|
|
acpi_status status = 0;
|
2008-10-10 14:22:59 +08:00
|
|
|
unsigned long long tpc = 0;
|
2007-05-26 22:49:58 +08:00
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
if (!pr)
|
2007-05-26 22:49:58 +08:00
|
|
|
return -EINVAL;
|
2009-05-11 09:35:57 +08:00
|
|
|
|
|
|
|
if (ignore_tpc)
|
|
|
|
goto end;
|
|
|
|
|
2007-05-26 22:49:58 +08:00
|
|
|
status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc);
|
2007-07-25 12:57:46 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
if (status != AE_NOT_FOUND) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC"));
|
|
|
|
}
|
2007-05-26 22:49:58 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2009-05-11 09:35:57 +08:00
|
|
|
|
|
|
|
end:
|
2007-05-26 22:49:58 +08:00
|
|
|
pr->throttling_platform_limit = (int)tpc;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
|
|
|
|
{
|
2007-11-15 16:59:30 +08:00
|
|
|
int result = 0;
|
|
|
|
int throttling_limit;
|
|
|
|
int current_state;
|
|
|
|
struct acpi_processor_limit *limit;
|
|
|
|
int target_state;
|
|
|
|
|
2009-05-11 09:35:57 +08:00
|
|
|
if (ignore_tpc)
|
|
|
|
return 0;
|
|
|
|
|
2007-11-15 16:59:30 +08:00
|
|
|
result = acpi_processor_get_platform_limit(pr);
|
|
|
|
if (result) {
|
|
|
|
/* Throttling Limit is unsupported */
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
throttling_limit = pr->throttling_platform_limit;
|
|
|
|
if (throttling_limit >= pr->throttling.state_count) {
|
|
|
|
/* Uncorrect Throttling Limit */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
current_state = pr->throttling.state;
|
|
|
|
if (current_state > throttling_limit) {
|
|
|
|
/*
|
|
|
|
* The current state can meet the requirement of
|
|
|
|
* _TPC limit. But it is reasonable that OSPM changes
|
|
|
|
* t-states from high to low for better performance.
|
|
|
|
* Of course the limit condition of thermal
|
|
|
|
* and user should be considered.
|
|
|
|
*/
|
|
|
|
limit = &pr->limit;
|
|
|
|
target_state = throttling_limit;
|
|
|
|
if (limit->thermal.tx > target_state)
|
|
|
|
target_state = limit->thermal.tx;
|
|
|
|
if (limit->user.tx > target_state)
|
|
|
|
target_state = limit->user.tx;
|
|
|
|
} else if (current_state == throttling_limit) {
|
|
|
|
/*
|
|
|
|
* Unnecessary to change the throttling state
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If the current state is lower than the limit of _TPC, it
|
|
|
|
* will be forced to switch to the throttling state defined
|
|
|
|
* by throttling_platfor_limit.
|
|
|
|
* Because the previous state meets with the limit condition
|
|
|
|
* of thermal and user, it is unnecessary to check it again.
|
|
|
|
*/
|
|
|
|
target_state = throttling_limit;
|
|
|
|
}
|
2009-08-27 05:29:29 +08:00
|
|
|
return acpi_processor_set_throttling(pr, target_state, false);
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
2011-01-10 16:35:45 +08:00
|
|
|
/*
|
|
|
|
* This function is used to reevaluate whether the T-state is valid
|
|
|
|
* after one CPU is onlined/offlined.
|
|
|
|
* It is noted that it won't reevaluate the following properties for
|
|
|
|
* the T-state.
|
|
|
|
* 1. Control method.
|
|
|
|
* 2. the number of supported T-state
|
|
|
|
* 3. TSD domain
|
|
|
|
*/
|
|
|
|
void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
|
2016-09-07 01:04:47 +08:00
|
|
|
bool is_dead)
|
2011-01-10 16:35:45 +08:00
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
2016-09-07 01:04:47 +08:00
|
|
|
if (is_dead) {
|
2011-01-10 16:35:45 +08:00
|
|
|
/* When one CPU is offline, the T-state throttling
|
|
|
|
* will be invalidated.
|
|
|
|
*/
|
|
|
|
pr->flags.throttling = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* the following is to recheck whether the T-state is valid for
|
|
|
|
* the online CPU
|
|
|
|
*/
|
|
|
|
if (!pr->throttling.state_count) {
|
|
|
|
/* If the number of T-state is invalid, it is
|
|
|
|
* invalidated.
|
|
|
|
*/
|
|
|
|
pr->flags.throttling = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pr->flags.throttling = 1;
|
|
|
|
|
|
|
|
/* Disable throttling (if enabled). We'll let subsequent
|
|
|
|
* policy (e.g.thermal) decide to lower performance if it
|
|
|
|
* so chooses, but for now we'll crank up the speed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
result = acpi_processor_get_throttling(pr);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (pr->throttling.state) {
|
|
|
|
result = acpi_processor_set_throttling(pr, 0, false);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
|
|
|
if (result)
|
|
|
|
pr->flags.throttling = 0;
|
|
|
|
}
|
2007-07-25 12:57:46 +08:00
|
|
|
/*
|
|
|
|
* _PTC - Processor Throttling Control (and status) register location
|
|
|
|
*/
|
2007-05-26 22:49:58 +08:00
|
|
|
static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
acpi_status status = 0;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *ptc = NULL;
|
|
|
|
union acpi_object obj = { 0 };
|
2007-11-15 17:05:05 +08:00
|
|
|
struct acpi_processor_throttling *throttling;
|
2007-05-26 22:49:58 +08:00
|
|
|
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2007-07-25 12:57:46 +08:00
|
|
|
if (status != AE_NOT_FOUND) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC"));
|
|
|
|
}
|
2007-05-26 22:49:58 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
ptc = (union acpi_object *)buffer.pointer;
|
|
|
|
if (!ptc || (ptc->type != ACPI_TYPE_PACKAGE)
|
|
|
|
|| (ptc->package.count != 2)) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid _PTC data\n");
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* control_register
|
|
|
|
*/
|
|
|
|
|
|
|
|
obj = ptc->package.elements[0];
|
|
|
|
|
|
|
|
if ((obj.type != ACPI_TYPE_BUFFER)
|
|
|
|
|| (obj.buffer.length < sizeof(struct acpi_ptc_register))
|
|
|
|
|| (obj.buffer.pointer == NULL)) {
|
2007-06-02 12:15:25 +08:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"Invalid _PTC data (control_register)\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
memcpy(&pr->throttling.control_register, obj.buffer.pointer,
|
|
|
|
sizeof(struct acpi_ptc_register));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* status_register
|
|
|
|
*/
|
|
|
|
|
|
|
|
obj = ptc->package.elements[1];
|
|
|
|
|
|
|
|
if ((obj.type != ACPI_TYPE_BUFFER)
|
|
|
|
|| (obj.buffer.length < sizeof(struct acpi_ptc_register))
|
|
|
|
|| (obj.buffer.pointer == NULL)) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid _PTC data (status_register)\n");
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(&pr->throttling.status_register, obj.buffer.pointer,
|
2007-06-02 12:15:25 +08:00
|
|
|
sizeof(struct acpi_ptc_register));
|
2007-05-26 22:49:58 +08:00
|
|
|
|
2007-11-15 17:05:05 +08:00
|
|
|
throttling = &pr->throttling;
|
|
|
|
|
|
|
|
if ((throttling->control_register.bit_width +
|
|
|
|
throttling->control_register.bit_offset) > 32) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid _PTC control register\n");
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((throttling->status_register.bit_width +
|
|
|
|
throttling->status_register.bit_offset) > 32) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid _PTC status register\n");
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
end:
|
2007-05-26 22:49:58 +08:00
|
|
|
kfree(buffer.pointer);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2007-07-25 12:57:46 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* _TSS - Throttling Supported States
|
|
|
|
*/
|
2007-05-26 22:49:58 +08:00
|
|
|
static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
|
|
|
|
struct acpi_buffer state = { 0, NULL };
|
|
|
|
union acpi_object *tss = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2007-07-25 12:57:46 +08:00
|
|
|
if (status != AE_NOT_FOUND) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS"));
|
|
|
|
}
|
2007-05-26 22:49:58 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
tss = buffer.pointer;
|
|
|
|
if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid _TSS data\n");
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
|
|
|
|
tss->package.count));
|
|
|
|
|
|
|
|
pr->throttling.state_count = tss->package.count;
|
|
|
|
pr->throttling.states_tss =
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 04:55:00 +08:00
|
|
|
kmalloc_array(tss->package.count,
|
|
|
|
sizeof(struct acpi_processor_tx_tss),
|
|
|
|
GFP_KERNEL);
|
2007-05-26 22:49:58 +08:00
|
|
|
if (!pr->throttling.states_tss) {
|
|
|
|
result = -ENOMEM;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < pr->throttling.state_count; i++) {
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
struct acpi_processor_tx_tss *tx =
|
|
|
|
(struct acpi_processor_tx_tss *)&(pr->throttling.
|
|
|
|
states_tss[i]);
|
2007-05-26 22:49:58 +08:00
|
|
|
|
|
|
|
state.length = sizeof(struct acpi_processor_tx_tss);
|
|
|
|
state.pointer = tx;
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
|
|
|
|
|
|
|
|
status = acpi_extract_package(&(tss->package.elements[i]),
|
|
|
|
&format, &state);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Invalid _TSS data"));
|
|
|
|
result = -EFAULT;
|
|
|
|
kfree(pr->throttling.states_tss);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tx->freqpercentage) {
|
|
|
|
printk(KERN_ERR PREFIX
|
2007-06-02 12:15:25 +08:00
|
|
|
"Invalid _TSS data: freq is zero\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
kfree(pr->throttling.states_tss);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
|
|
|
kfree(buffer.pointer);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2007-07-25 12:57:46 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* _TSD - T-State Dependencies
|
|
|
|
*/
|
2007-06-02 12:15:25 +08:00
|
|
|
static int acpi_processor_get_tsd(struct acpi_processor *pr)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
2007-06-02 12:15:25 +08:00
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
|
|
|
|
struct acpi_buffer state = { 0, NULL };
|
|
|
|
union acpi_object *tsd = NULL;
|
2007-05-26 22:49:58 +08:00
|
|
|
struct acpi_tsd_package *pdomain;
|
2008-01-28 13:53:42 +08:00
|
|
|
struct acpi_processor_throttling *pthrottling;
|
|
|
|
|
|
|
|
pthrottling = &pr->throttling;
|
|
|
|
pthrottling->tsd_valid_flag = 0;
|
2007-05-26 22:49:58 +08:00
|
|
|
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2007-07-25 12:57:46 +08:00
|
|
|
if (status != AE_NOT_FOUND) {
|
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSD"));
|
|
|
|
}
|
2007-05-26 22:49:58 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
tsd = buffer.pointer;
|
|
|
|
if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) {
|
2008-09-28 14:51:56 +08:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _TSD data\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tsd->package.count != 1) {
|
2008-09-28 14:51:56 +08:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _TSD data\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
pdomain = &(pr->throttling.domain_info);
|
|
|
|
|
|
|
|
state.length = sizeof(struct acpi_tsd_package);
|
|
|
|
state.pointer = pdomain;
|
|
|
|
|
|
|
|
status = acpi_extract_package(&(tsd->package.elements[0]),
|
2007-06-02 12:15:25 +08:00
|
|
|
&format, &state);
|
2007-05-26 22:49:58 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2008-09-28 14:51:56 +08:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _TSD data\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) {
|
2008-09-28 14:51:56 +08:00
|
|
|
printk(KERN_ERR PREFIX "Unknown _TSD:num_entries\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdomain->revision != ACPI_TSD_REV0_REVISION) {
|
2008-09-28 14:51:56 +08:00
|
|
|
printk(KERN_ERR PREFIX "Unknown _TSD:revision\n");
|
2007-05-26 22:49:58 +08:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2008-01-28 13:53:42 +08:00
|
|
|
pthrottling = &pr->throttling;
|
|
|
|
pthrottling->tsd_valid_flag = 1;
|
|
|
|
pthrottling->shared_type = pdomain->coord_type;
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
|
2008-01-28 13:53:42 +08:00
|
|
|
/*
|
|
|
|
* If the coordination type is not defined in ACPI spec,
|
|
|
|
* the tsd_valid_flag will be clear and coordination type
|
|
|
|
* will be forecd as DOMAIN_COORD_TYPE_SW_ALL.
|
|
|
|
*/
|
|
|
|
if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
|
|
|
|
pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
|
|
|
|
pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
|
|
|
|
pthrottling->tsd_valid_flag = 0;
|
|
|
|
pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
|
|
|
|
}
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
end:
|
2007-05-26 22:49:58 +08:00
|
|
|
kfree(buffer.pointer);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Throttling Control
|
|
|
|
-------------------------------------------------------------------------- */
|
2007-05-26 22:49:58 +08:00
|
|
|
static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
int state = 0;
|
|
|
|
u32 value = 0;
|
|
|
|
u32 duty_mask = 0;
|
|
|
|
u32 duty_value = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!pr)
|
2006-06-27 12:41:40 +08:00
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!pr->flags.throttling)
|
2006-06-27 12:41:40 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-06-02 07:57:50 +08:00
|
|
|
/*
|
|
|
|
* We don't care about error returns - we just try to mark
|
|
|
|
* these reserved so that nobody else is confused into thinking
|
|
|
|
* that this region might be unused..
|
|
|
|
*
|
|
|
|
* (In particular, allocating the IO range for Cardbus)
|
|
|
|
*/
|
|
|
|
request_region(pr->throttling.address, 6, "ACPI CPU throttle");
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
pr->throttling.state = 0;
|
|
|
|
|
|
|
|
duty_mask = pr->throttling.state_count - 1;
|
|
|
|
|
|
|
|
duty_mask <<= pr->throttling.duty_offset;
|
|
|
|
|
|
|
|
local_irq_disable();
|
|
|
|
|
|
|
|
value = inl(pr->throttling.address);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute the current throttling state when throttling is enabled
|
|
|
|
* (bit 4 is on).
|
|
|
|
*/
|
|
|
|
if (value & 0x10) {
|
|
|
|
duty_value = value & duty_mask;
|
|
|
|
duty_value >>= pr->throttling.duty_offset;
|
|
|
|
|
|
|
|
if (duty_value)
|
2005-08-05 12:44:28 +08:00
|
|
|
state = pr->throttling.state_count - duty_value;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
pr->throttling.state = state;
|
|
|
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 12:44:28 +08:00
|
|
|
"Throttling state is T%d (%d%% throttling applied)\n",
|
|
|
|
state, pr->throttling.states[state].performance));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-27 12:41:40 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-11-15 17:06:36 +08:00
|
|
|
#ifdef CONFIG_X86
|
2011-03-12 19:51:12 +08:00
|
|
|
static int acpi_throttling_rdmsr(u64 *value)
|
2007-11-15 17:06:36 +08:00
|
|
|
{
|
|
|
|
u64 msr_high, msr_low;
|
|
|
|
u64 msr = 0;
|
|
|
|
int ret = -1;
|
|
|
|
|
2011-03-12 19:51:12 +08:00
|
|
|
if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
|
|
|
|
!this_cpu_has(X86_FEATURE_ACPI)) {
|
2007-11-15 17:06:36 +08:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"HARDWARE addr space,NOT supported yet\n");
|
|
|
|
} else {
|
|
|
|
msr_low = 0;
|
|
|
|
msr_high = 0;
|
2007-11-29 16:22:43 +08:00
|
|
|
rdmsr_safe(MSR_IA32_THERM_CONTROL,
|
2007-11-15 17:06:36 +08:00
|
|
|
(u32 *)&msr_low , (u32 *) &msr_high);
|
|
|
|
msr = (msr_high << 32) | msr_low;
|
2010-01-28 10:53:19 +08:00
|
|
|
*value = (u64) msr;
|
2007-11-15 17:06:36 +08:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-03-12 19:51:12 +08:00
|
|
|
static int acpi_throttling_wrmsr(u64 value)
|
2007-11-15 17:06:36 +08:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
u64 msr;
|
|
|
|
|
2011-03-12 19:51:12 +08:00
|
|
|
if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
|
|
|
|
!this_cpu_has(X86_FEATURE_ACPI)) {
|
2007-11-15 17:06:36 +08:00
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"HARDWARE addr space,NOT supported yet\n");
|
|
|
|
} else {
|
|
|
|
msr = value;
|
2007-11-29 16:22:43 +08:00
|
|
|
wrmsr_safe(MSR_IA32_THERM_CONTROL,
|
2007-11-15 17:06:36 +08:00
|
|
|
msr & 0xffffffff, msr >> 32);
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#else
|
2011-03-12 19:51:12 +08:00
|
|
|
static int acpi_throttling_rdmsr(u64 *value)
|
2007-11-15 17:06:36 +08:00
|
|
|
{
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"HARDWARE addr space,NOT supported yet\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-03-12 19:51:12 +08:00
|
|
|
static int acpi_throttling_wrmsr(u64 value)
|
2007-11-15 17:06:36 +08:00
|
|
|
{
|
|
|
|
printk(KERN_ERR PREFIX
|
|
|
|
"HARDWARE addr space,NOT supported yet\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
static int acpi_read_throttling_status(struct acpi_processor *pr,
|
2010-01-28 10:53:19 +08:00
|
|
|
u64 *value)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
2007-11-15 17:05:05 +08:00
|
|
|
u32 bit_width, bit_offset;
|
2012-03-07 19:57:36 +08:00
|
|
|
u32 ptc_value;
|
2007-11-15 17:05:05 +08:00
|
|
|
u64 ptc_mask;
|
2007-11-15 17:03:46 +08:00
|
|
|
struct acpi_processor_throttling *throttling;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
throttling = &pr->throttling;
|
2007-05-26 22:49:58 +08:00
|
|
|
switch (throttling->status_register.space_id) {
|
|
|
|
case ACPI_ADR_SPACE_SYSTEM_IO:
|
2007-11-15 17:05:05 +08:00
|
|
|
bit_width = throttling->status_register.bit_width;
|
|
|
|
bit_offset = throttling->status_register.bit_offset;
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
acpi_os_read_port((acpi_io_address) throttling->status_register.
|
2012-03-07 19:57:36 +08:00
|
|
|
address, &ptc_value,
|
2007-11-15 17:05:05 +08:00
|
|
|
(u32) (bit_width + bit_offset));
|
|
|
|
ptc_mask = (1 << bit_width) - 1;
|
2010-01-28 10:53:19 +08:00
|
|
|
*value = (u64) ((ptc_value >> bit_offset) & ptc_mask);
|
2007-11-15 17:03:46 +08:00
|
|
|
ret = 0;
|
2007-05-26 22:49:58 +08:00
|
|
|
break;
|
|
|
|
case ACPI_ADR_SPACE_FIXED_HARDWARE:
|
2011-03-12 19:51:12 +08:00
|
|
|
ret = acpi_throttling_rdmsr(value);
|
2007-05-26 22:49:58 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR PREFIX "Unknown addr space %d\n",
|
2007-06-02 12:15:25 +08:00
|
|
|
(u32) (throttling->status_register.space_id));
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
2007-11-15 17:03:46 +08:00
|
|
|
return ret;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
static int acpi_write_throttling_state(struct acpi_processor *pr,
|
2010-01-28 10:53:19 +08:00
|
|
|
u64 value)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
2007-11-15 17:05:05 +08:00
|
|
|
u32 bit_width, bit_offset;
|
2007-11-15 17:03:46 +08:00
|
|
|
u64 ptc_value;
|
2007-11-15 17:05:05 +08:00
|
|
|
u64 ptc_mask;
|
2007-11-15 17:03:46 +08:00
|
|
|
struct acpi_processor_throttling *throttling;
|
2007-05-26 22:49:58 +08:00
|
|
|
int ret = -1;
|
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
throttling = &pr->throttling;
|
2007-05-26 22:49:58 +08:00
|
|
|
switch (throttling->control_register.space_id) {
|
|
|
|
case ACPI_ADR_SPACE_SYSTEM_IO:
|
2007-11-15 17:05:05 +08:00
|
|
|
bit_width = throttling->control_register.bit_width;
|
|
|
|
bit_offset = throttling->control_register.bit_offset;
|
|
|
|
ptc_mask = (1 << bit_width) - 1;
|
|
|
|
ptc_value = value & ptc_mask;
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
acpi_os_write_port((acpi_io_address) throttling->
|
2007-11-15 17:05:05 +08:00
|
|
|
control_register.address,
|
|
|
|
(u32) (ptc_value << bit_offset),
|
|
|
|
(u32) (bit_width + bit_offset));
|
2007-05-26 22:49:58 +08:00
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
case ACPI_ADR_SPACE_FIXED_HARDWARE:
|
2011-03-12 19:51:12 +08:00
|
|
|
ret = acpi_throttling_wrmsr(value);
|
2007-05-26 22:49:58 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR PREFIX "Unknown addr space %d\n",
|
2007-06-02 12:15:25 +08:00
|
|
|
(u32) (throttling->control_register.space_id));
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
static int acpi_get_throttling_state(struct acpi_processor *pr,
|
2010-01-28 10:53:19 +08:00
|
|
|
u64 value)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < pr->throttling.state_count; i++) {
|
2007-06-02 12:15:25 +08:00
|
|
|
struct acpi_processor_tx_tss *tx =
|
|
|
|
(struct acpi_processor_tx_tss *)&(pr->throttling.
|
|
|
|
states_tss[i]);
|
|
|
|
if (tx->control == value)
|
2009-03-16 11:36:38 +08:00
|
|
|
return i;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
2009-03-16 11:36:38 +08:00
|
|
|
return -1;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
static int acpi_get_throttling_value(struct acpi_processor *pr,
|
2010-01-28 10:53:19 +08:00
|
|
|
int state, u64 *value)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
2007-11-15 17:03:46 +08:00
|
|
|
int ret = -1;
|
|
|
|
|
2007-06-02 12:15:25 +08:00
|
|
|
if (state >= 0 && state <= pr->throttling.state_count) {
|
|
|
|
struct acpi_processor_tx_tss *tx =
|
|
|
|
(struct acpi_processor_tx_tss *)&(pr->throttling.
|
|
|
|
states_tss[state]);
|
2007-11-15 17:03:46 +08:00
|
|
|
*value = tx->control;
|
|
|
|
ret = 0;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
2007-11-15 17:03:46 +08:00
|
|
|
return ret;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr)
|
|
|
|
{
|
|
|
|
int state = 0;
|
2007-11-15 17:03:46 +08:00
|
|
|
int ret;
|
2010-01-28 10:53:19 +08:00
|
|
|
u64 value;
|
2007-05-26 22:49:58 +08:00
|
|
|
|
|
|
|
if (!pr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!pr->flags.throttling)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
pr->throttling.state = 0;
|
2007-11-29 16:22:43 +08:00
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
value = 0;
|
|
|
|
ret = acpi_read_throttling_status(pr, &value);
|
|
|
|
if (ret >= 0) {
|
2007-06-02 12:15:25 +08:00
|
|
|
state = acpi_get_throttling_state(pr, value);
|
2009-05-11 09:36:01 +08:00
|
|
|
if (state == -1) {
|
2009-08-27 05:29:30 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Invalid throttling state, reset\n"));
|
2009-05-11 09:36:01 +08:00
|
|
|
state = 0;
|
2017-04-13 04:07:34 +08:00
|
|
|
ret = __acpi_processor_set_throttling(pr, state, true,
|
|
|
|
true);
|
2009-05-11 09:36:01 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2007-05-26 22:49:58 +08:00
|
|
|
pr->throttling.state = state;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-04-13 04:07:34 +08:00
|
|
|
static long __acpi_processor_get_throttling(void *data)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
2017-04-13 04:07:34 +08:00
|
|
|
struct acpi_processor *pr = data;
|
|
|
|
|
|
|
|
return pr->throttling.acpi_processor_get_throttling(pr);
|
|
|
|
}
|
2007-11-29 16:22:43 +08:00
|
|
|
|
2017-04-13 04:07:34 +08:00
|
|
|
static int acpi_processor_get_throttling(struct acpi_processor *pr)
|
|
|
|
{
|
2008-01-28 13:53:30 +08:00
|
|
|
if (!pr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!pr->flags.throttling)
|
|
|
|
return -ENODEV;
|
2009-01-01 10:08:47 +08:00
|
|
|
|
2007-11-29 16:22:43 +08:00
|
|
|
/*
|
2017-04-13 04:07:34 +08:00
|
|
|
* This is either called from the CPU hotplug callback of
|
|
|
|
* processor_driver or via the ACPI probe function. In the latter
|
|
|
|
* case the CPU is not guaranteed to be online. Both call sites are
|
|
|
|
* protected against CPU hotplug.
|
2007-11-29 16:22:43 +08:00
|
|
|
*/
|
2017-04-13 04:07:34 +08:00
|
|
|
if (!cpu_online(pr->id))
|
2011-01-10 16:35:44 +08:00
|
|
|
return -ENODEV;
|
2007-11-29 16:22:43 +08:00
|
|
|
|
2017-05-24 16:15:42 +08:00
|
|
|
return call_on_cpu(pr->id, __acpi_processor_get_throttling, pr, false);
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
2007-11-15 17:02:03 +08:00
|
|
|
static int acpi_processor_get_fadt_info(struct acpi_processor *pr)
|
|
|
|
{
|
|
|
|
int i, step;
|
|
|
|
|
|
|
|
if (!pr->throttling.address) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (!pr->throttling.duty_width) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
/* TBD: Support duty_cycle values that span bit 4. */
|
|
|
|
else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
|
|
|
|
printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute state values. Note that throttling displays a linear power
|
|
|
|
* performance relationship (at 50% performance the CPU will consume
|
|
|
|
* 50% power). Values are in 1/10th of a percent to preserve accuracy.
|
|
|
|
*/
|
|
|
|
|
|
|
|
step = (1000 / pr->throttling.state_count);
|
|
|
|
|
|
|
|
for (i = 0; i < pr->throttling.state_count; i++) {
|
|
|
|
pr->throttling.states[i].performance = 1000 - step * i;
|
|
|
|
pr->throttling.states[i].power = 1000 - step * i;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-03 12:53:12 +08:00
|
|
|
static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr,
|
2009-08-27 05:29:29 +08:00
|
|
|
int state, bool force)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
u32 value = 0;
|
|
|
|
u32 duty_mask = 0;
|
|
|
|
u32 duty_value = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!pr)
|
2006-06-27 12:41:40 +08:00
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if ((state < 0) || (state > (pr->throttling.state_count - 1)))
|
2006-06-27 12:41:40 +08:00
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!pr->flags.throttling)
|
2006-06-27 12:41:40 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-08-27 05:29:29 +08:00
|
|
|
if (!force && (state == pr->throttling.state))
|
2006-06-27 12:41:40 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-05-26 22:49:58 +08:00
|
|
|
if (state < pr->throttling_platform_limit)
|
|
|
|
return -EPERM;
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Calculate the duty_value and duty_mask.
|
|
|
|
*/
|
|
|
|
if (state) {
|
|
|
|
duty_value = pr->throttling.state_count - state;
|
|
|
|
|
|
|
|
duty_value <<= pr->throttling.duty_offset;
|
|
|
|
|
|
|
|
/* Used to clear all duty_value bits */
|
|
|
|
duty_mask = pr->throttling.state_count - 1;
|
|
|
|
|
2007-02-03 00:48:22 +08:00
|
|
|
duty_mask <<= acpi_gbl_FADT.duty_offset;
|
2005-04-17 06:20:36 +08:00
|
|
|
duty_mask = ~duty_mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
local_irq_disable();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable throttling by writing a 0 to bit 4. Note that we must
|
|
|
|
* turn it off before you can change the duty_value.
|
|
|
|
*/
|
|
|
|
value = inl(pr->throttling.address);
|
|
|
|
if (value & 0x10) {
|
|
|
|
value &= 0xFFFFFFEF;
|
|
|
|
outl(value, pr->throttling.address);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write the new duty_value and then enable throttling. Note
|
|
|
|
* that a state value of 0 leaves throttling disabled.
|
|
|
|
*/
|
|
|
|
if (state) {
|
|
|
|
value &= duty_mask;
|
|
|
|
value |= duty_value;
|
|
|
|
outl(value, pr->throttling.address);
|
|
|
|
|
|
|
|
value |= 0x00000010;
|
|
|
|
outl(value, pr->throttling.address);
|
|
|
|
}
|
|
|
|
|
|
|
|
pr->throttling.state = state;
|
|
|
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 12:44:28 +08:00
|
|
|
"Throttling state set to T%d (%d%%)\n", state,
|
|
|
|
(pr->throttling.states[state].performance ? pr->
|
|
|
|
throttling.states[state].performance / 10 : 0)));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-27 12:41:40 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-07-03 12:53:12 +08:00
|
|
|
static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr,
|
2009-08-27 05:29:29 +08:00
|
|
|
int state, bool force)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
2007-11-15 17:03:46 +08:00
|
|
|
int ret;
|
2010-01-28 10:53:19 +08:00
|
|
|
u64 value;
|
2007-05-26 22:49:58 +08:00
|
|
|
|
|
|
|
if (!pr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if ((state < 0) || (state > (pr->throttling.state_count - 1)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!pr->flags.throttling)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2009-08-27 05:29:29 +08:00
|
|
|
if (!force && (state == pr->throttling.state))
|
2007-05-26 22:49:58 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (state < pr->throttling_platform_limit)
|
|
|
|
return -EPERM;
|
|
|
|
|
2007-11-15 17:03:46 +08:00
|
|
|
value = 0;
|
|
|
|
ret = acpi_get_throttling_value(pr, state, &value);
|
|
|
|
if (ret >= 0) {
|
|
|
|
acpi_write_throttling_state(pr, value);
|
2007-05-26 22:49:58 +08:00
|
|
|
pr->throttling.state = state;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-26 21:03:05 +08:00
|
|
|
static long acpi_processor_throttling_fn(void *data)
|
|
|
|
{
|
|
|
|
struct acpi_processor_throttling_arg *arg = data;
|
|
|
|
struct acpi_processor *pr = arg->pr;
|
|
|
|
|
|
|
|
return pr->throttling.acpi_processor_set_throttling(pr,
|
|
|
|
arg->target_state, arg->force);
|
|
|
|
}
|
|
|
|
|
2017-04-13 04:07:34 +08:00
|
|
|
static int __acpi_processor_set_throttling(struct acpi_processor *pr,
|
|
|
|
int state, bool force, bool direct)
|
2007-05-26 22:49:58 +08:00
|
|
|
{
|
2008-02-02 16:56:18 +08:00
|
|
|
int ret = 0;
|
2008-01-28 13:55:56 +08:00
|
|
|
unsigned int i;
|
|
|
|
struct acpi_processor *match_pr;
|
|
|
|
struct acpi_processor_throttling *p_throttling;
|
2014-02-26 21:03:05 +08:00
|
|
|
struct acpi_processor_throttling_arg arg;
|
2008-01-28 13:55:56 +08:00
|
|
|
struct throttling_tstate t_state;
|
2008-01-28 13:53:30 +08:00
|
|
|
|
|
|
|
if (!pr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!pr->flags.throttling)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if ((state < 0) || (state > (pr->throttling.state_count - 1)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-01-10 16:35:44 +08:00
|
|
|
if (cpu_is_offline(pr->id)) {
|
|
|
|
/*
|
|
|
|
* the cpu pointed by pr->id is offline. Unnecessary to change
|
|
|
|
* the throttling state any more.
|
|
|
|
*/
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2008-01-28 13:55:56 +08:00
|
|
|
t_state.target_state = state;
|
|
|
|
p_throttling = &(pr->throttling);
|
2014-02-26 21:03:05 +08:00
|
|
|
|
2007-11-29 16:22:43 +08:00
|
|
|
/*
|
2008-01-28 13:55:56 +08:00
|
|
|
* The throttling notifier will be called for every
|
|
|
|
* affected cpu in order to get one proper T-state.
|
|
|
|
* The notifier event is THROTTLING_PRECHANGE.
|
2007-11-29 16:22:43 +08:00
|
|
|
*/
|
2014-02-26 21:03:05 +08:00
|
|
|
for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
|
2008-01-28 13:55:56 +08:00
|
|
|
t_state.cpu = i;
|
|
|
|
acpi_processor_throttling_notifier(THROTTLING_PRECHANGE,
|
|
|
|
&t_state);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The function of acpi_processor_set_throttling will be called
|
|
|
|
* to switch T-state. If the coordination type is SW_ALL or HW_ALL,
|
|
|
|
* it is necessary to call it for every affected cpu. Otherwise
|
|
|
|
* it can be called only for the cpu pointed by pr.
|
|
|
|
*/
|
|
|
|
if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
|
2014-02-26 21:03:05 +08:00
|
|
|
arg.pr = pr;
|
|
|
|
arg.target_state = state;
|
|
|
|
arg.force = force;
|
2017-04-13 04:07:34 +08:00
|
|
|
ret = call_on_cpu(pr->id, acpi_processor_throttling_fn, &arg,
|
|
|
|
direct);
|
2008-01-28 13:55:56 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* When the T-state coordination is SW_ALL or HW_ALL,
|
|
|
|
* it is necessary to set T-state for every affected
|
|
|
|
* cpus.
|
|
|
|
*/
|
2014-02-26 21:03:05 +08:00
|
|
|
for_each_cpu_and(i, cpu_online_mask,
|
|
|
|
p_throttling->shared_cpu_map) {
|
2008-06-10 07:22:23 +08:00
|
|
|
match_pr = per_cpu(processors, i);
|
2008-01-28 13:55:56 +08:00
|
|
|
/*
|
|
|
|
* If the pointer is invalid, we will report the
|
|
|
|
* error message and continue.
|
|
|
|
*/
|
|
|
|
if (!match_pr) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Invalid Pointer for CPU %d\n", i));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If the throttling control is unsupported on CPU i,
|
|
|
|
* we will report the error message and continue.
|
|
|
|
*/
|
|
|
|
if (!match_pr->flags.throttling) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2011-03-31 09:57:33 +08:00
|
|
|
"Throttling Control is unsupported "
|
2008-01-28 13:55:56 +08:00
|
|
|
"on CPU %d\n", i));
|
|
|
|
continue;
|
|
|
|
}
|
2014-02-26 21:03:05 +08:00
|
|
|
|
|
|
|
arg.pr = match_pr;
|
|
|
|
arg.target_state = state;
|
|
|
|
arg.force = force;
|
2017-04-13 04:07:34 +08:00
|
|
|
ret = call_on_cpu(pr->id, acpi_processor_throttling_fn,
|
|
|
|
&arg, direct);
|
2008-01-28 13:55:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* After the set_throttling is called, the
|
|
|
|
* throttling notifier is called for every
|
|
|
|
* affected cpu to update the T-states.
|
|
|
|
* The notifier event is THROTTLING_POSTCHANGE
|
|
|
|
*/
|
2014-02-26 21:03:05 +08:00
|
|
|
for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
|
2008-01-28 13:55:56 +08:00
|
|
|
t_state.cpu = i;
|
|
|
|
acpi_processor_throttling_notifier(THROTTLING_POSTCHANGE,
|
|
|
|
&t_state);
|
|
|
|
}
|
2014-02-26 21:03:05 +08:00
|
|
|
|
2007-11-29 16:22:43 +08:00
|
|
|
return ret;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
|
|
|
|
2017-04-13 04:07:34 +08:00
|
|
|
int acpi_processor_set_throttling(struct acpi_processor *pr, int state,
|
|
|
|
bool force)
|
|
|
|
{
|
|
|
|
return __acpi_processor_set_throttling(pr, state, force, false);
|
|
|
|
}
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
int acpi_processor_get_throttling_info(struct acpi_processor *pr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-08-05 12:44:28 +08:00
|
|
|
int result = 0;
|
2008-01-28 13:53:42 +08:00
|
|
|
struct acpi_processor_throttling *pthrottling;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 12:44:28 +08:00
|
|
|
"pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
|
|
|
|
pr->throttling.address,
|
|
|
|
pr->throttling.duty_offset,
|
|
|
|
pr->throttling.duty_width));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-07-25 12:57:46 +08:00
|
|
|
/*
|
|
|
|
* Evaluate _PTC, _TSS and _TPC
|
|
|
|
* They must all be present or none of them can be used.
|
|
|
|
*/
|
|
|
|
if (acpi_processor_get_throttling_control(pr) ||
|
|
|
|
acpi_processor_get_throttling_states(pr) ||
|
|
|
|
acpi_processor_get_platform_limit(pr))
|
|
|
|
{
|
2007-06-02 12:15:25 +08:00
|
|
|
pr->throttling.acpi_processor_get_throttling =
|
|
|
|
&acpi_processor_get_throttling_fadt;
|
|
|
|
pr->throttling.acpi_processor_set_throttling =
|
|
|
|
&acpi_processor_set_throttling_fadt;
|
2008-01-15 13:47:47 +08:00
|
|
|
if (acpi_processor_get_fadt_info(pr))
|
|
|
|
return 0;
|
2007-05-26 22:49:58 +08:00
|
|
|
} else {
|
2007-06-02 12:15:25 +08:00
|
|
|
pr->throttling.acpi_processor_get_throttling =
|
|
|
|
&acpi_processor_get_throttling_ptc;
|
|
|
|
pr->throttling.acpi_processor_set_throttling =
|
|
|
|
&acpi_processor_set_throttling_ptc;
|
2007-05-26 22:49:58 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-28 13:53:42 +08:00
|
|
|
/*
|
|
|
|
* If TSD package for one CPU can't be parsed successfully, it means
|
|
|
|
* that this CPU will have no coordination with other CPUs.
|
|
|
|
*/
|
|
|
|
if (acpi_processor_get_tsd(pr)) {
|
|
|
|
pthrottling = &pr->throttling;
|
|
|
|
pthrottling->tsd_valid_flag = 0;
|
2009-01-01 10:08:47 +08:00
|
|
|
cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
|
2008-01-28 13:53:42 +08:00
|
|
|
pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
|
|
|
|
}
|
2007-07-25 12:57:46 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* PIIX4 Errata: We don't support throttling on the original PIIX4.
|
|
|
|
* This shouldn't be an issue as few (if any) mobile systems ever
|
|
|
|
* used this part.
|
|
|
|
*/
|
|
|
|
if (errata.piix4.throttle) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 12:44:28 +08:00
|
|
|
"Throttling not supported on PIIX4 A- or B-step\n"));
|
2006-06-27 12:41:40 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
|
2005-08-05 12:44:28 +08:00
|
|
|
pr->throttling.state_count));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
pr->flags.throttling = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable throttling (if enabled). We'll let subsequent policy (e.g.
|
|
|
|
* thermal) decide to lower performance if it so chooses, but for now
|
|
|
|
* we'll crank up the speed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
result = acpi_processor_get_throttling(pr);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (pr->throttling.state) {
|
2005-08-05 12:44:28 +08:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Disabling throttling (was T%d)\n",
|
|
|
|
pr->throttling.state));
|
2009-08-27 05:29:29 +08:00
|
|
|
result = acpi_processor_set_throttling(pr, 0, false);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2005-08-05 12:44:28 +08:00
|
|
|
end:
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result)
|
|
|
|
pr->flags.throttling = 0;
|
|
|
|
|
2006-06-27 12:41:40 +08:00
|
|
|
return result;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|