2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* processor_perflib.c - ACPI Processor P-States Library ($Revision: 71 $)
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or (at
|
|
|
|
* your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/cpufreq.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 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-10-24 09:22:04 +00:00
|
|
|
#ifdef CONFIG_X86
|
2008-09-01 12:27:04 +00:00
|
|
|
#include <asm/cpufeature.h>
|
2008-10-24 09:22:04 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <acpi/acpi_bus.h>
|
2008-11-07 23:57:45 +00:00
|
|
|
#include <acpi/acpi_drivers.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <acpi/processor.h>
|
|
|
|
|
2009-07-28 20:45:54 +00:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define ACPI_PROCESSOR_CLASS "processor"
|
|
|
|
#define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
|
|
|
|
#define _COMPONENT ACPI_PROCESSOR_COMPONENT
|
2007-02-13 03:42:12 +00:00
|
|
|
ACPI_MODULE_NAME("processor_perflib");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
static DEFINE_MUTEX(performance_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* _PPC support is implemented as a CPUfreq policy notifier:
|
|
|
|
* This means each time a CPUfreq driver registered also with
|
|
|
|
* the ACPI core is asked to change the speed policy, the maximum
|
|
|
|
* value is adjusted so that it is within the platform limit.
|
|
|
|
*
|
|
|
|
* Also, when a new platform limit value is detected, the CPUfreq
|
|
|
|
* policy is adjusted accordingly.
|
|
|
|
*/
|
|
|
|
|
2008-07-30 05:32:58 +00:00
|
|
|
/* ignore_ppc:
|
|
|
|
* -1 -> cpufreq low level drivers not initialized -> _PSS, etc. not called yet
|
|
|
|
* ignore _PPC
|
|
|
|
* 0 -> cpufreq low level drivers initialized -> consider _PPC values
|
|
|
|
* 1 -> ignore _PPC totally -> forced by user through boot param
|
|
|
|
*/
|
2008-08-12 15:48:27 +00:00
|
|
|
static int ignore_ppc = -1;
|
2008-08-16 00:11:28 +00:00
|
|
|
module_param(ignore_ppc, int, 0644);
|
2007-05-19 02:59:28 +00:00
|
|
|
MODULE_PARM_DESC(ignore_ppc, "If the frequency of your machine gets wrongly" \
|
|
|
|
"limited by BIOS, this should help");
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define PPC_REGISTERED 1
|
|
|
|
#define PPC_IN_USE 2
|
|
|
|
|
2008-07-30 05:32:58 +00:00
|
|
|
static int acpi_processor_ppc_status;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int acpi_processor_ppc_notifier(struct notifier_block *nb,
|
2005-08-05 04:44:28 +00:00
|
|
|
unsigned long event, void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct cpufreq_policy *policy = data;
|
|
|
|
struct acpi_processor *pr;
|
|
|
|
unsigned int ppc = 0;
|
|
|
|
|
2008-07-30 05:32:58 +00:00
|
|
|
if (event == CPUFREQ_START && ignore_ppc <= 0) {
|
|
|
|
ignore_ppc = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-05-19 02:59:28 +00:00
|
|
|
if (ignore_ppc)
|
|
|
|
return 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (event != CPUFREQ_INCOMPATIBLE)
|
2008-07-30 05:32:59 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
mutex_lock(&performance_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-09 23:22:23 +00:00
|
|
|
pr = per_cpu(processors, policy->cpu);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pr || !pr->performance)
|
|
|
|
goto out;
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
ppc = (unsigned int)pr->performance_platform_limit;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-11-23 01:42:01 +00:00
|
|
|
if (ppc >= pr->performance->state_count)
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
cpufreq_verify_within_limits(policy, 0,
|
2005-08-05 04:44:28 +00:00
|
|
|
pr->performance->states[ppc].
|
|
|
|
core_frequency * 1000);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
out:
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block acpi_ppc_notifier_block = {
|
|
|
|
.notifier_call = acpi_processor_ppc_notifier,
|
|
|
|
};
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_status status = 0;
|
2008-10-10 06:22:59 +00:00
|
|
|
unsigned long long ppc = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (!pr)
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* _PPC indicates the maximum state currently supported by the platform
|
|
|
|
* (e.g. 0 = states 0..n; 1 = states 1..n; etc.
|
|
|
|
*/
|
|
|
|
status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc);
|
|
|
|
|
|
|
|
if (status != AE_NOT_FOUND)
|
|
|
|
acpi_processor_ppc_status |= PPC_IN_USE;
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
|
2006-06-27 03:58:43 +00:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PPC"));
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-03-27 13:04:46 +00:00
|
|
|
pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
|
2007-10-31 14:41:42 +00:00
|
|
|
(int)ppc, ppc ? "" : "not");
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
pr->performance_platform_limit = (int)ppc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-10-16 01:20:41 +00:00
|
|
|
#define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
|
|
|
|
/*
|
|
|
|
* acpi_processor_ppc_ost: Notify firmware the _PPC evaluation status
|
|
|
|
* @handle: ACPI processor handle
|
|
|
|
* @status: the status code of _PPC evaluation
|
|
|
|
* 0: success. OSPM is now using the performance state specificed.
|
|
|
|
* 1: failure. OSPM has not changed the number of P-states in use
|
|
|
|
*/
|
|
|
|
static void acpi_processor_ppc_ost(acpi_handle handle, int status)
|
|
|
|
{
|
|
|
|
union acpi_object params[2] = {
|
|
|
|
{.type = ACPI_TYPE_INTEGER,},
|
|
|
|
{.type = ACPI_TYPE_INTEGER,},
|
|
|
|
};
|
|
|
|
struct acpi_object_list arg_list = {2, params};
|
|
|
|
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(handle, "_OST")) {
|
|
|
|
params[0].integer.value = ACPI_PROCESSOR_NOTIFY_PERFORMANCE;
|
|
|
|
params[1].integer.value = status;
|
|
|
|
acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
|
|
|
|
}
|
2009-10-16 01:20:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_processor_ppc_has_changed(struct acpi_processor *pr, int event_flag)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-19 02:59:28 +00:00
|
|
|
int ret;
|
|
|
|
|
2009-10-16 01:20:41 +00:00
|
|
|
if (ignore_ppc) {
|
|
|
|
/*
|
|
|
|
* Only when it is notification event, the _OST object
|
|
|
|
* will be evaluated. Otherwise it is skipped.
|
|
|
|
*/
|
|
|
|
if (event_flag)
|
|
|
|
acpi_processor_ppc_ost(pr->handle, 1);
|
2007-05-19 02:59:28 +00:00
|
|
|
return 0;
|
2009-10-16 01:20:41 +00:00
|
|
|
}
|
2007-05-19 02:59:28 +00:00
|
|
|
|
|
|
|
ret = acpi_processor_get_platform_limit(pr);
|
2009-10-16 01:20:41 +00:00
|
|
|
/*
|
|
|
|
* Only when it is notification event, the _OST object
|
|
|
|
* will be evaluated. Otherwise it is skipped.
|
|
|
|
*/
|
|
|
|
if (event_flag) {
|
|
|
|
if (ret < 0)
|
|
|
|
acpi_processor_ppc_ost(pr->handle, 1);
|
|
|
|
else
|
|
|
|
acpi_processor_ppc_ost(pr->handle, 0);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return (ret);
|
|
|
|
else
|
|
|
|
return cpufreq_update_policy(pr->id);
|
|
|
|
}
|
|
|
|
|
2009-11-19 11:31:01 +00:00
|
|
|
int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
|
|
|
|
{
|
|
|
|
struct acpi_processor *pr;
|
|
|
|
|
|
|
|
pr = per_cpu(processors, cpu);
|
|
|
|
if (!pr || !pr->performance || !pr->performance->state_count)
|
|
|
|
return -ENODEV;
|
|
|
|
*limit = pr->performance->states[pr->performance_platform_limit].
|
|
|
|
core_frequency * 1000;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_processor_get_bios_limit);
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
void acpi_processor_ppc_init(void)
|
|
|
|
{
|
|
|
|
if (!cpufreq_register_notifier
|
|
|
|
(&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER))
|
2005-04-16 22:20:36 +00:00
|
|
|
acpi_processor_ppc_status |= PPC_REGISTERED;
|
|
|
|
else
|
2005-08-05 04:44:28 +00:00
|
|
|
printk(KERN_DEBUG
|
|
|
|
"Warning: Processor Platform Limit not supported.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
void acpi_processor_ppc_exit(void)
|
|
|
|
{
|
2005-04-16 22:20:36 +00:00
|
|
|
if (acpi_processor_ppc_status & PPC_REGISTERED)
|
2005-08-05 04:44:28 +00:00
|
|
|
cpufreq_unregister_notifier(&acpi_ppc_notifier_block,
|
|
|
|
CPUFREQ_POLICY_NOTIFIER);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
acpi_processor_ppc_status &= ~PPC_REGISTERED;
|
|
|
|
}
|
|
|
|
|
2012-01-25 23:09:08 +00:00
|
|
|
/*
|
|
|
|
* Do a quick check if the systems looks like it should use ACPI
|
|
|
|
* cpufreq. We look at a _PCT method being available, but don't
|
|
|
|
* do a whole lot of sanity checks.
|
|
|
|
*/
|
|
|
|
void acpi_processor_load_module(struct acpi_processor *pr)
|
|
|
|
{
|
|
|
|
static int requested;
|
|
|
|
acpi_status status = 0;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
|
|
|
|
if (!arch_has_acpi_pdc() || requested)
|
|
|
|
return;
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
|
|
|
|
if (!ACPI_FAILURE(status)) {
|
|
|
|
printk(KERN_INFO PREFIX "Requesting acpi_cpufreq\n");
|
|
|
|
request_module_nowait("acpi_cpufreq");
|
|
|
|
requested = 1;
|
|
|
|
}
|
|
|
|
kfree(buffer.pointer);
|
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_processor_get_performance_control(struct acpi_processor *pr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = 0;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *pct = NULL;
|
|
|
|
union acpi_object obj = { 0 };
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
|
2005-08-05 04:44:28 +00:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-06-27 03:58:43 +00:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PCT"));
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
pct = (union acpi_object *)buffer.pointer;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
|
2005-08-05 04:44:28 +00:00
|
|
|
|| (pct->package.count != 2)) {
|
2006-06-27 03:41:38 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PCT data\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* control_register
|
|
|
|
*/
|
|
|
|
|
|
|
|
obj = pct->package.elements[0];
|
|
|
|
|
|
|
|
if ((obj.type != ACPI_TYPE_BUFFER)
|
2005-08-05 04:44:28 +00:00
|
|
|
|| (obj.buffer.length < sizeof(struct acpi_pct_register))
|
|
|
|
|| (obj.buffer.pointer == NULL)) {
|
2006-06-27 03:41:38 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PCT data (control_register)\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
2005-08-05 04:44:28 +00:00
|
|
|
memcpy(&pr->performance->control_register, obj.buffer.pointer,
|
|
|
|
sizeof(struct acpi_pct_register));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* status_register
|
|
|
|
*/
|
|
|
|
|
|
|
|
obj = pct->package.elements[1];
|
|
|
|
|
|
|
|
if ((obj.type != ACPI_TYPE_BUFFER)
|
2005-08-05 04:44:28 +00:00
|
|
|
|| (obj.buffer.length < sizeof(struct acpi_pct_register))
|
|
|
|
|| (obj.buffer.pointer == NULL)) {
|
2006-06-27 03:41:38 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PCT data (status_register)\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
memcpy(&pr->performance->status_register, obj.buffer.pointer,
|
|
|
|
sizeof(struct acpi_pct_register));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
end:
|
2006-06-30 07:19:10 +00:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return result;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-09-04 08:28:06 +00:00
|
|
|
#ifdef CONFIG_X86
|
|
|
|
/*
|
|
|
|
* Some AMDs have 50MHz frequency multiples, but only provide 100MHz rounding
|
|
|
|
* in their ACPI data. Calculate the real values and fix up the _PSS data.
|
|
|
|
*/
|
|
|
|
static void amd_fixup_frequency(struct acpi_processor_px *px, int i)
|
|
|
|
{
|
|
|
|
u32 hi, lo, fid, did;
|
|
|
|
int index = px->control & 0x00000007;
|
|
|
|
|
|
|
|
if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((boot_cpu_data.x86 == 0x10 && boot_cpu_data.x86_model < 10)
|
|
|
|
|| boot_cpu_data.x86 == 0x11) {
|
|
|
|
rdmsr(MSR_AMD_PSTATE_DEF_BASE + index, lo, hi);
|
2013-01-22 12:37:21 +00:00
|
|
|
/*
|
|
|
|
* MSR C001_0064+:
|
|
|
|
* Bit 63: PstateEn. Read-write. If set, the P-state is valid.
|
|
|
|
*/
|
|
|
|
if (!(hi & BIT(31)))
|
|
|
|
return;
|
|
|
|
|
2012-09-04 08:28:06 +00:00
|
|
|
fid = lo & 0x3f;
|
|
|
|
did = (lo >> 6) & 7;
|
|
|
|
if (boot_cpu_data.x86 == 0x10)
|
|
|
|
px->core_frequency = (100 * (fid + 0x10)) >> did;
|
|
|
|
else
|
|
|
|
px->core_frequency = (100 * (fid + 8)) >> did;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void amd_fixup_frequency(struct acpi_processor_px *px, int i) {};
|
|
|
|
#endif
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
static int acpi_processor_get_performance_states(struct acpi_processor *pr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
struct acpi_buffer format = { sizeof("NNNNNN"), "NNNNNN" };
|
|
|
|
struct acpi_buffer state = { 0, NULL };
|
|
|
|
union acpi_object *pss = NULL;
|
|
|
|
int i;
|
2012-05-04 16:53:44 +00:00
|
|
|
int last_invalid = -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
|
2005-08-05 04:44:28 +00:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-06-27 03:58:43 +00:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PSS"));
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-09-30 22:28:50 +00:00
|
|
|
pss = buffer.pointer;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
|
2006-06-27 03:41:38 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PSS data\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n",
|
2005-08-05 04:44:28 +00:00
|
|
|
pss->package.count));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pr->performance->state_count = pss->package.count;
|
2005-08-05 04:44:28 +00:00
|
|
|
pr->performance->states =
|
|
|
|
kmalloc(sizeof(struct acpi_processor_px) * pss->package.count,
|
|
|
|
GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pr->performance->states) {
|
|
|
|
result = -ENOMEM;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < pr->performance->state_count; i++) {
|
|
|
|
|
|
|
|
struct acpi_processor_px *px = &(pr->performance->states[i]);
|
|
|
|
|
|
|
|
state.length = sizeof(struct acpi_processor_px);
|
|
|
|
state.pointer = px;
|
|
|
|
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
|
|
|
|
|
|
|
|
status = acpi_extract_package(&(pss->package.elements[i]),
|
2005-08-05 04:44:28 +00:00
|
|
|
&format, &state);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-06-27 03:58:43 +00:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "Invalid _PSS data"));
|
2005-04-16 22:20:36 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
kfree(pr->performance->states);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2012-09-04 08:28:06 +00:00
|
|
|
amd_fixup_frequency(px, i);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 04:44:28 +00:00
|
|
|
"State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
|
|
|
|
i,
|
|
|
|
(u32) px->core_frequency,
|
|
|
|
(u32) px->power,
|
|
|
|
(u32) px->transition_latency,
|
|
|
|
(u32) px->bus_master_latency,
|
|
|
|
(u32) px->control, (u32) px->status));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
ACPI: sanity check _PSS frequency to prevent cpufreq crash
When BIOS SETUP is changed to disable EIST, some BIOS
hand the OS an un-initialized _PSS:
Name (_PSS, Package (0x06)
{
Package (0x06)
{
0x80000000, // frequency [MHz]
0x80000000, // power [mW]
0x80000000, // latency [us]
0x80000000, // BM latency [us]
0x80000000, // control
0x80000000 // status
},
...
These are outrageous values for frequency,
power and latency, raising the question where to draw
the line between legal and illegal. We tend to survive
garbage in the power and latency fields, but we can BUG_ON
when garbage is in the frequency field.
Cpufreq multiplies the frequency by 1000 and stores it in a u32 KHz.
So disregard a _PSS with a frequency so large
that it can't be represented by cpufreq.
https://bugzilla.redhat.com/show_bug.cgi?id=500311
Signed-off-by: Len Brown <len.brown@intel.com>
2009-05-26 19:11:06 +00:00
|
|
|
/*
|
|
|
|
* Check that ACPI's u64 MHz will be valid as u32 KHz in cpufreq
|
|
|
|
*/
|
|
|
|
if (!px->core_frequency ||
|
|
|
|
((u32)(px->core_frequency * 1000) !=
|
|
|
|
(px->core_frequency * 1000))) {
|
|
|
|
printk(KERN_ERR FW_BUG PREFIX
|
2012-05-04 16:53:44 +00:00
|
|
|
"Invalid BIOS _PSS frequency found for processor %d: 0x%llx MHz\n",
|
|
|
|
pr->id, px->core_frequency);
|
|
|
|
if (last_invalid == -1)
|
|
|
|
last_invalid = i;
|
|
|
|
} else {
|
|
|
|
if (last_invalid != -1) {
|
|
|
|
/*
|
|
|
|
* Copy this valid entry over last_invalid entry
|
|
|
|
*/
|
|
|
|
memcpy(&(pr->performance->states[last_invalid]),
|
|
|
|
px, sizeof(struct acpi_processor_px));
|
|
|
|
++last_invalid;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-04 16:53:44 +00:00
|
|
|
if (last_invalid == 0) {
|
|
|
|
printk(KERN_ERR FW_BUG PREFIX
|
|
|
|
"No valid BIOS _PSS frequency found for processor %d\n", pr->id);
|
|
|
|
result = -EFAULT;
|
|
|
|
kfree(pr->performance->states);
|
|
|
|
pr->performance->states = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (last_invalid > 0)
|
|
|
|
pr->performance->state_count = last_invalid;
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
end:
|
2006-06-30 07:19:10 +00:00
|
|
|
kfree(buffer.pointer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return result;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-03-05 18:42:54 +00:00
|
|
|
int acpi_processor_get_performance_info(struct acpi_processor *pr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-08-05 04:44:28 +00:00
|
|
|
int result = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!pr || !pr->performance || !pr->handle)
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-06-28 16:24:38 +00:00
|
|
|
if (!acpi_has_method(pr->handle, "_PCT")) {
|
2005-04-16 22:20:36 +00:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 04:44:28 +00:00
|
|
|
"ACPI-based processor performance control unavailable\n"));
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
result = acpi_processor_get_performance_control(pr);
|
|
|
|
if (result)
|
2008-09-01 12:27:04 +00:00
|
|
|
goto update_bios;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
result = acpi_processor_get_performance_states(pr);
|
|
|
|
if (result)
|
2008-09-01 12:27:04 +00:00
|
|
|
goto update_bios;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-02-18 18:28:20 +00:00
|
|
|
/* We need to call _PPC once when cpufreq starts */
|
|
|
|
if (ignore_ppc != 1)
|
|
|
|
result = acpi_processor_get_platform_limit(pr);
|
|
|
|
|
|
|
|
return result;
|
2008-09-01 12:27:04 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Having _PPC but missing frequencies (_PSS, _PCT) is a very good hint that
|
|
|
|
* the BIOS is older than the CPU and does not know its frequencies
|
|
|
|
*/
|
|
|
|
update_bios:
|
2008-10-24 09:22:04 +00:00
|
|
|
#ifdef CONFIG_X86
|
2013-06-28 16:24:38 +00:00
|
|
|
if (acpi_has_method(pr->handle, "_PPC")) {
|
2008-09-01 12:27:04 +00:00
|
|
|
if(boot_cpu_has(X86_FEATURE_EST))
|
|
|
|
printk(KERN_WARNING FW_BUG "BIOS needs update for CPU "
|
|
|
|
"frequency support\n");
|
|
|
|
}
|
2008-10-24 09:22:04 +00:00
|
|
|
#endif
|
2008-09-01 12:27:04 +00:00
|
|
|
return result;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-03-05 18:42:54 +00:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_processor_get_performance_info);
|
2005-08-05 04:44:28 +00:00
|
|
|
int acpi_processor_notify_smm(struct module *calling_module)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
static int is_done = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (!(acpi_processor_ppc_status & PPC_REGISTERED))
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EBUSY;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!try_module_get(calling_module))
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-07 16:49:45 +00:00
|
|
|
/* is_done is set to negative if an error occurred,
|
|
|
|
* and to postitive if _no_ error occurred, but SMM
|
2005-04-16 22:20:36 +00:00
|
|
|
* was already notified. This avoids double notification
|
|
|
|
* which might lead to unexpected results...
|
|
|
|
*/
|
|
|
|
if (is_done > 0) {
|
|
|
|
module_put(calling_module);
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-08-05 04:44:28 +00:00
|
|
|
} else if (is_done < 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
module_put(calling_module);
|
2006-06-27 04:41:40 +00:00
|
|
|
return is_done;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
is_done = -EIO;
|
|
|
|
|
2007-02-02 16:48:19 +00:00
|
|
|
/* Can't write pstate_control to smi_command if either value is zero */
|
2007-02-02 16:48:22 +00:00
|
|
|
if ((!acpi_gbl_FADT.smi_command) || (!acpi_gbl_FADT.pstate_control)) {
|
2007-02-02 16:48:19 +00:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No SMI port or pstate_control\n"));
|
2005-04-16 22:20:36 +00:00
|
|
|
module_put(calling_module);
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2007-02-02 16:48:19 +00:00
|
|
|
"Writing pstate_control [0x%x] to smi_command [0x%x]\n",
|
2007-02-02 16:48:22 +00:00
|
|
|
acpi_gbl_FADT.pstate_control, acpi_gbl_FADT.smi_command));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-02 16:48:22 +00:00
|
|
|
status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
|
|
|
|
(u32) acpi_gbl_FADT.pstate_control, 8);
|
2005-08-05 04:44:28 +00:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-06-27 03:58:43 +00:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
2007-02-02 16:48:19 +00:00
|
|
|
"Failed to write pstate_control [0x%x] to "
|
2007-02-02 16:48:22 +00:00
|
|
|
"smi_command [0x%x]", acpi_gbl_FADT.pstate_control,
|
|
|
|
acpi_gbl_FADT.smi_command));
|
2005-04-16 22:20:36 +00:00
|
|
|
module_put(calling_module);
|
2006-06-27 04:41:40 +00:00
|
|
|
return status;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Success. If there's no _PPC, we need to fear nothing, so
|
|
|
|
* we can allow the cpufreq driver to be rmmod'ed. */
|
|
|
|
is_done = 1;
|
|
|
|
|
|
|
|
if (!(acpi_processor_ppc_status & PPC_IN_USE))
|
|
|
|
module_put(calling_module);
|
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
EXPORT_SYMBOL(acpi_processor_notify_smm);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-12-14 20:05:00 +00:00
|
|
|
static int acpi_processor_get_psd(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 *psd = NULL;
|
|
|
|
struct acpi_psd_package *pdomain;
|
|
|
|
|
|
|
|
status = acpi_evaluate_object(pr->handle, "_PSD", NULL, &buffer);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2006-05-11 04:28:12 +00:00
|
|
|
return -ENODEV;
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
|
|
|
|
2006-09-30 22:28:50 +00:00
|
|
|
psd = buffer.pointer;
|
2005-12-14 20:05:00 +00:00
|
|
|
if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) {
|
2008-09-28 06:51:56 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PSD data\n");
|
2005-12-14 20:05:00 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (psd->package.count != 1) {
|
2008-09-28 06:51:56 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PSD data\n");
|
2005-12-14 20:05:00 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
pdomain = &(pr->performance->domain_info);
|
|
|
|
|
|
|
|
state.length = sizeof(struct acpi_psd_package);
|
|
|
|
state.pointer = pdomain;
|
|
|
|
|
|
|
|
status = acpi_extract_package(&(psd->package.elements[0]),
|
|
|
|
&format, &state);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2008-09-28 06:51:56 +00:00
|
|
|
printk(KERN_ERR PREFIX "Invalid _PSD data\n");
|
2005-12-14 20:05:00 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES) {
|
2008-09-28 06:51:56 +00:00
|
|
|
printk(KERN_ERR PREFIX "Unknown _PSD:num_entries\n");
|
2005-12-14 20:05:00 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pdomain->revision != ACPI_PSD_REV0_REVISION) {
|
2008-09-28 06:51:56 +00:00
|
|
|
printk(KERN_ERR PREFIX "Unknown _PSD:revision\n");
|
2005-12-14 20:05:00 +00:00
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2009-03-24 12:41:59 +00:00
|
|
|
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) {
|
|
|
|
printk(KERN_ERR PREFIX "Invalid _PSD:coord_type\n");
|
|
|
|
result = -EFAULT;
|
|
|
|
goto end;
|
|
|
|
}
|
2005-12-14 20:05:00 +00:00
|
|
|
end:
|
2006-06-30 07:19:10 +00:00
|
|
|
kfree(buffer.pointer);
|
2006-05-11 04:28:12 +00:00
|
|
|
return result;
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int acpi_processor_preregister_performance(
|
2010-02-02 05:39:15 +00:00
|
|
|
struct acpi_processor_performance __percpu *performance)
|
2005-12-14 20:05:00 +00:00
|
|
|
{
|
2013-06-25 02:06:45 +00:00
|
|
|
int count_target;
|
2005-12-14 20:05:00 +00:00
|
|
|
int retval = 0;
|
|
|
|
unsigned int i, j;
|
2009-01-01 02:08:47 +00:00
|
|
|
cpumask_var_t covered_cpus;
|
2005-12-14 20:05:00 +00:00
|
|
|
struct acpi_processor *pr;
|
|
|
|
struct acpi_psd_package *pdomain;
|
|
|
|
struct acpi_processor *match_pr;
|
|
|
|
struct acpi_psd_package *match_pdomain;
|
|
|
|
|
2009-06-15 06:58:26 +00:00
|
|
|
if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
|
2009-01-01 02:08:47 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-06-16 02:19:31 +00:00
|
|
|
mutex_lock(&performance_mutex);
|
2005-12-14 20:05:00 +00:00
|
|
|
|
2009-03-24 12:41:59 +00:00
|
|
|
/*
|
|
|
|
* Check if another driver has already registered, and abort before
|
|
|
|
* changing pr->performance if it has. Check input data as well.
|
|
|
|
*/
|
2006-04-27 09:25:00 +00:00
|
|
|
for_each_possible_cpu(i) {
|
2008-06-09 23:22:23 +00:00
|
|
|
pr = per_cpu(processors, i);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (!pr) {
|
|
|
|
/* Look only at processors in ACPI namespace */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pr->performance) {
|
|
|
|
retval = -EBUSY;
|
2009-03-24 12:41:59 +00:00
|
|
|
goto err_out;
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
|
|
|
|
2009-02-20 07:29:08 +00:00
|
|
|
if (!performance || !per_cpu_ptr(performance, i)) {
|
2005-12-14 20:05:00 +00:00
|
|
|
retval = -EINVAL;
|
2009-03-24 12:41:59 +00:00
|
|
|
goto err_out;
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
2009-03-24 12:41:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Call _PSD for all CPUs */
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
pr = per_cpu(processors, i);
|
|
|
|
if (!pr)
|
|
|
|
continue;
|
2005-12-14 20:05:00 +00:00
|
|
|
|
2009-02-20 07:29:08 +00:00
|
|
|
pr->performance = per_cpu_ptr(performance, i);
|
2009-01-01 02:08:47 +00:00
|
|
|
cpumask_set_cpu(i, pr->performance->shared_cpu_map);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (acpi_processor_get_psd(pr)) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (retval)
|
|
|
|
goto err_ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that we have _PSD data from all CPUs, lets setup P-state
|
|
|
|
* domain info.
|
|
|
|
*/
|
2006-04-27 09:25:00 +00:00
|
|
|
for_each_possible_cpu(i) {
|
2008-06-09 23:22:23 +00:00
|
|
|
pr = per_cpu(processors, i);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (!pr)
|
|
|
|
continue;
|
|
|
|
|
2009-01-01 02:08:47 +00:00
|
|
|
if (cpumask_test_cpu(i, covered_cpus))
|
2005-12-14 20:05:00 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
pdomain = &(pr->performance->domain_info);
|
2009-01-01 02:08:47 +00:00
|
|
|
cpumask_set_cpu(i, pr->performance->shared_cpu_map);
|
|
|
|
cpumask_set_cpu(i, covered_cpus);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (pdomain->num_processors <= 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Validate the Domain info */
|
|
|
|
count_target = pdomain->num_processors;
|
2006-06-26 04:34:43 +00:00
|
|
|
if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
|
2005-12-14 20:05:00 +00:00
|
|
|
pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
|
2006-06-26 04:34:43 +00:00
|
|
|
else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
|
|
|
|
pr->performance->shared_type = CPUFREQ_SHARED_TYPE_HW;
|
|
|
|
else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
|
2005-12-14 20:05:00 +00:00
|
|
|
pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ANY;
|
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
for_each_possible_cpu(j) {
|
2005-12-14 20:05:00 +00:00
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
|
2008-06-09 23:22:23 +00:00
|
|
|
match_pr = per_cpu(processors, j);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (!match_pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
match_pdomain = &(match_pr->performance->domain_info);
|
|
|
|
if (match_pdomain->domain != pdomain->domain)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Here i and j are in the same domain */
|
|
|
|
|
|
|
|
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 02:08:47 +00:00
|
|
|
cpumask_set_cpu(j, covered_cpus);
|
|
|
|
cpumask_set_cpu(j, pr->performance->shared_cpu_map);
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
for_each_possible_cpu(j) {
|
2005-12-14 20:05:00 +00:00
|
|
|
if (i == j)
|
|
|
|
continue;
|
|
|
|
|
2008-06-09 23:22:23 +00:00
|
|
|
match_pr = per_cpu(processors, j);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (!match_pr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
match_pdomain = &(match_pr->performance->domain_info);
|
|
|
|
if (match_pdomain->domain != pdomain->domain)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
match_pr->performance->shared_type =
|
|
|
|
pr->performance->shared_type;
|
2009-01-01 02:08:47 +00:00
|
|
|
cpumask_copy(match_pr->performance->shared_cpu_map,
|
|
|
|
pr->performance->shared_cpu_map);
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err_ret:
|
2006-04-27 09:25:00 +00:00
|
|
|
for_each_possible_cpu(i) {
|
2008-06-09 23:22:23 +00:00
|
|
|
pr = per_cpu(processors, i);
|
2005-12-14 20:05:00 +00:00
|
|
|
if (!pr || !pr->performance)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Assume no coordination on any error parsing domain info */
|
|
|
|
if (retval) {
|
2009-01-01 02:08:47 +00:00
|
|
|
cpumask_clear(pr->performance->shared_cpu_map);
|
|
|
|
cpumask_set_cpu(i, pr->performance->shared_cpu_map);
|
2005-12-14 20:05:00 +00:00
|
|
|
pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
|
|
|
|
}
|
|
|
|
pr->performance = NULL; /* Will be set for real in register */
|
|
|
|
}
|
|
|
|
|
2009-03-24 12:41:59 +00:00
|
|
|
err_out:
|
2006-06-16 02:19:31 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2009-01-01 02:08:47 +00:00
|
|
|
free_cpumask_var(covered_cpus);
|
2006-05-11 04:28:12 +00:00
|
|
|
return retval;
|
2005-12-14 20:05:00 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(acpi_processor_preregister_performance);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_processor_register_performance(struct acpi_processor_performance
|
|
|
|
*performance, unsigned int cpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct acpi_processor *pr;
|
|
|
|
|
|
|
|
if (!(acpi_processor_ppc_status & PPC_REGISTERED))
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_lock(&performance_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-09 23:22:23 +00:00
|
|
|
pr = per_cpu(processors, cpu);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pr) {
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2006-06-27 04:41:40 +00:00
|
|
|
return -ENODEV;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (pr->performance) {
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EBUSY;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-06-10 16:54:13 +00:00
|
|
|
WARN_ON(!performance);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
pr->performance = performance;
|
|
|
|
|
|
|
|
if (acpi_processor_get_performance_info(pr)) {
|
|
|
|
pr->performance = NULL;
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2006-06-27 04:41:40 +00:00
|
|
|
return -EIO;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2006-06-27 04:41:40 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2005-08-05 04:44:28 +00:00
|
|
|
EXPORT_SYMBOL(acpi_processor_register_performance);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
void
|
2005-08-05 04:44:28 +00:00
|
|
|
acpi_processor_unregister_performance(struct acpi_processor_performance
|
|
|
|
*performance, unsigned int cpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct acpi_processor *pr;
|
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_lock(&performance_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-09 23:22:23 +00:00
|
|
|
pr = per_cpu(processors, cpu);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!pr) {
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2006-06-27 04:41:40 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-06-10 16:54:13 +00:00
|
|
|
if (pr->performance)
|
|
|
|
kfree(pr->performance->states);
|
2005-04-16 22:20:36 +00:00
|
|
|
pr->performance = NULL;
|
|
|
|
|
2006-04-27 09:25:00 +00:00
|
|
|
mutex_unlock(&performance_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-06-27 04:41:40 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2005-08-05 04:44:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
EXPORT_SYMBOL(acpi_processor_unregister_performance);
|