2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
|
|
|
|
* Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* This driver fully implements the ACPI thermal policy as described in the
|
|
|
|
* ACPI 2.0 Specification.
|
|
|
|
*
|
|
|
|
* TBD: 1. Implement passive cooling hysteresis.
|
|
|
|
* 2. Enhance passive cooling (CPU) states/limit interface to support
|
|
|
|
* concepts of 'multiple limiters', upper/lower limits, etc.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
2007-08-11 22:13:02 -06:00
|
|
|
#include <linux/dmi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/init.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 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/types.h>
|
[PATCH] remove many unneeded #includes of sched.h
After Al Viro (finally) succeeded in removing the sched.h #include in module.h
recently, it makes sense again to remove other superfluous sched.h includes.
There are quite a lot of files which include it but don't actually need
anything defined in there. Presumably these includes were once needed for
macros that used to live in sched.h, but moved to other header files in the
course of cleaning it up.
To ease the pain, this time I did not fiddle with any header files and only
removed #includes from .c-files, which tend to cause less trouble.
Compile tested against 2.6.20-rc2 and 2.6.20-rc2-mm2 (with offsets) on alpha,
arm, i386, ia64, mips, powerpc, and x86_64 with allnoconfig, defconfig,
allmodconfig, and allyesconfig as well as a few randconfigs on x86_64 and all
configs in arch/arm/configs on arm. I also checked that no new warnings were
introduced by the patch (actually, some warnings are removed that were emitted
by unnecessarily included header files).
Signed-off-by: Tim Schmielau <tim@physik3.uni-rostock.de>
Acked-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-02-14 01:33:14 -07:00
|
|
|
#include <linux/jiffies.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/kmod.h>
|
2007-07-17 19:37:02 -06:00
|
|
|
#include <linux/reboot.h>
|
2009-03-02 18:47:17 -07:00
|
|
|
#include <linux/device.h>
|
2008-01-17 00:51:11 -07:00
|
|
|
#include <linux/thermal.h>
|
2013-12-02 17:49:16 -07:00
|
|
|
#include <linux/acpi.h>
|
2014-03-03 23:24:46 -07:00
|
|
|
#include <linux/workqueue.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-07-28 14:45:54 -06:00
|
|
|
#define PREFIX "ACPI: "
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#define ACPI_THERMAL_CLASS "thermal_zone"
|
|
|
|
#define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
|
|
|
|
#define ACPI_THERMAL_NOTIFY_TEMPERATURE 0x80
|
|
|
|
#define ACPI_THERMAL_NOTIFY_THRESHOLDS 0x81
|
|
|
|
#define ACPI_THERMAL_NOTIFY_DEVICES 0x82
|
|
|
|
#define ACPI_THERMAL_NOTIFY_CRITICAL 0xF0
|
|
|
|
#define ACPI_THERMAL_NOTIFY_HOT 0xF1
|
|
|
|
#define ACPI_THERMAL_MODE_ACTIVE 0x00
|
|
|
|
|
|
|
|
#define ACPI_THERMAL_MAX_ACTIVE 10
|
|
|
|
#define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
|
|
|
|
|
|
|
|
#define _COMPONENT ACPI_THERMAL_COMPONENT
|
2007-02-12 20:42:12 -07:00
|
|
|
ACPI_MODULE_NAME("thermal");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2004-09-16 09:07:00 -06:00
|
|
|
MODULE_AUTHOR("Paul Diefenbaugh");
|
2007-02-12 21:50:02 -07:00
|
|
|
MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2007-08-11 22:12:54 -06:00
|
|
|
static int act;
|
|
|
|
module_param(act, int, 0644);
|
2007-08-14 13:12:56 -06:00
|
|
|
MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
|
2007-08-11 22:12:54 -06:00
|
|
|
|
2007-08-14 13:49:32 -06:00
|
|
|
static int crt;
|
|
|
|
module_param(crt, int, 0644);
|
|
|
|
MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int tzp;
|
ACPI: thermal: expose "thermal.tzp=" to set global polling frequency
Thermal Zone Polling frequency (_TZP) is an optional ACPI object
recommending the rate that the OS should poll the associated thermal zone.
If _TZP is 0, no polling should be used.
If _TZP is non-zero, then the platform recommends that
the OS poll the thermal zone at the specified rate.
The minimum period is 30 seconds.
The maximum period is 5 minutes.
(note _TZP and thermal.tzp units are in deci-seconds,
so _TZP = 300 corresponds to 30 seconds)
If _TZP is not present, ACPI 3.0b recommends that the
thermal zone be polled at an "OS provided default frequency".
However, common industry practice is:
1. The BIOS never specifies any _TZP
2. High volume OS's from this century never poll any thermal zones
Ie. The OS depends on the platform's ability to
provoke thermal events when necessary, and
the "OS provided default frequency" is "never":-)
There is a proposal that ACPI 4.0 be updated to reflect
common industry practice -- ie. no _TZP, no polling.
The Linux kernel already follows this practice --
thermal zones are not polled unless _TZP is present and non-zero.
But thermal zone polling is useful as a workaround for systems
which have ACPI thermal control, but have an issue preventing
thermal events. Indeed, some Linux distributions still
set a non-zero thermal polling frequency for this reason.
But rather than ask the user to write a polling frequency
into all the /proc/acpi/thermal_zone/*/polling_frequency
files, here we simply document and expose the already
existing module parameter to do the same at system level,
to simplify debugging those broken platforms.
Note that thermal.tzp is a module-load time parameter only.
Signed-off-by: Len Brown <len.brown@intel.com>
2007-08-11 22:12:26 -06:00
|
|
|
module_param(tzp, int, 0444);
|
2007-08-14 13:12:56 -06:00
|
|
|
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-11 22:12:44 -06:00
|
|
|
static int nocrt;
|
|
|
|
module_param(nocrt, int, 0);
|
2007-08-20 16:46:50 -06:00
|
|
|
MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
|
2007-08-11 22:12:44 -06:00
|
|
|
|
2007-08-11 22:12:17 -06:00
|
|
|
static int off;
|
|
|
|
module_param(off, int, 0);
|
2007-08-14 13:12:56 -06:00
|
|
|
MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
|
2007-08-11 22:12:17 -06:00
|
|
|
|
2007-08-11 22:12:35 -06:00
|
|
|
static int psv;
|
|
|
|
module_param(psv, int, 0644);
|
2007-08-14 13:12:56 -06:00
|
|
|
MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
|
2007-08-11 22:12:35 -06:00
|
|
|
|
2014-03-03 23:24:46 -07:00
|
|
|
static struct workqueue_struct *acpi_thermal_pm_queue;
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_thermal_add(struct acpi_device *device);
|
2013-01-23 16:24:48 -07:00
|
|
|
static int acpi_thermal_remove(struct acpi_device *device);
|
2009-04-07 09:37:06 -06:00
|
|
|
static void acpi_thermal_notify(struct acpi_device *device, u32 event);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-23 06:44:41 -06:00
|
|
|
static const struct acpi_device_id thermal_device_ids[] = {
|
|
|
|
{ACPI_THERMAL_HID, 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
|
|
|
|
|
2012-08-09 15:00:02 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2014-03-03 23:24:46 -07:00
|
|
|
static int acpi_thermal_suspend(struct device *dev);
|
2012-06-27 15:26:18 -06:00
|
|
|
static int acpi_thermal_resume(struct device *dev);
|
2014-02-12 20:19:10 -07:00
|
|
|
#else
|
2014-03-03 23:24:46 -07:00
|
|
|
#define acpi_thermal_suspend NULL
|
2014-02-12 20:19:10 -07:00
|
|
|
#define acpi_thermal_resume NULL
|
2012-08-09 15:00:02 -06:00
|
|
|
#endif
|
2014-03-03 23:24:46 -07:00
|
|
|
static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, acpi_thermal_suspend, acpi_thermal_resume);
|
2012-06-27 15:26:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct acpi_driver acpi_thermal_driver = {
|
2007-02-12 21:33:40 -07:00
|
|
|
.name = "thermal",
|
2005-08-04 22:44:28 -06:00
|
|
|
.class = ACPI_THERMAL_CLASS,
|
2007-07-23 06:44:41 -06:00
|
|
|
.ids = thermal_device_ids,
|
2005-08-04 22:44:28 -06:00
|
|
|
.ops = {
|
|
|
|
.add = acpi_thermal_add,
|
|
|
|
.remove = acpi_thermal_remove,
|
2009-04-07 09:37:06 -06:00
|
|
|
.notify = acpi_thermal_notify,
|
2005-08-04 22:44:28 -06:00
|
|
|
},
|
2012-06-27 15:26:18 -06:00
|
|
|
.drv.pm = &acpi_thermal_pm,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_state {
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 critical:1;
|
|
|
|
u8 hot:1;
|
|
|
|
u8 passive:1;
|
|
|
|
u8 active:1;
|
|
|
|
u8 reserved:4;
|
|
|
|
int active_index;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_state_flags {
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 valid:1;
|
|
|
|
u8 enabled:1;
|
|
|
|
u8 reserved:6;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_critical {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-04 22:44:28 -06:00
|
|
|
unsigned long temperature;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_hot {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-04 22:44:28 -06:00
|
|
|
unsigned long temperature;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_passive {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-04 22:44:28 -06:00
|
|
|
unsigned long temperature;
|
|
|
|
unsigned long tc1;
|
|
|
|
unsigned long tc2;
|
|
|
|
unsigned long tsp;
|
|
|
|
struct acpi_handle_list devices;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_active {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-04 22:44:28 -06:00
|
|
|
unsigned long temperature;
|
|
|
|
struct acpi_handle_list devices;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_trips {
|
|
|
|
struct acpi_thermal_critical critical;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_thermal_hot hot;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_thermal_passive passive;
|
|
|
|
struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_flags {
|
2005-08-04 22:44:28 -06:00
|
|
|
u8 cooling_mode:1; /* _SCP */
|
|
|
|
u8 devices:1; /* _TZD */
|
|
|
|
u8 reserved:6;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal {
|
2006-05-19 14:54:40 -06:00
|
|
|
struct acpi_device * device;
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_bus_id name;
|
|
|
|
unsigned long temperature;
|
|
|
|
unsigned long last_temperature;
|
|
|
|
unsigned long polling_frequency;
|
|
|
|
volatile u8 zombie;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct acpi_thermal_flags flags;
|
|
|
|
struct acpi_thermal_state state;
|
|
|
|
struct acpi_thermal_trips trips;
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_handle_list devices;
|
2008-01-17 00:51:11 -07:00
|
|
|
struct thermal_zone_device *thermal_zone;
|
|
|
|
int tz_enabled;
|
2009-04-06 08:01:46 -06:00
|
|
|
int kelvin_offset;
|
2014-03-03 23:24:46 -07:00
|
|
|
struct work_struct thermal_check_work;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Thermal Zone Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status = AE_OK;
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!tz)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tz->last_temperature = tz->temperature;
|
|
|
|
|
2008-10-10 00:22:59 -06:00
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-10 00:22:59 -06:00
|
|
|
tz->temperature = tmp;
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
|
|
|
|
tz->temperature));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
acpi_status status = AE_OK;
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!tz)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-10 00:22:59 -06:00
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-10-10 00:22:59 -06:00
|
|
|
tz->polling_frequency = tmp;
|
2005-08-04 22:44:28 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
|
|
|
|
tz->polling_frequency));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (!tz)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-06-28 10:24:39 -06:00
|
|
|
if (!acpi_has_method(tz->device->handle, "_SCP")) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2013-06-28 10:24:39 -06:00
|
|
|
} else if (ACPI_FAILURE(acpi_execute_simple_method(tz->device->handle,
|
|
|
|
"_SCP", mode))) {
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2013-06-28 10:24:39 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
#define ACPI_TRIPS_CRITICAL 0x01
|
|
|
|
#define ACPI_TRIPS_HOT 0x02
|
|
|
|
#define ACPI_TRIPS_PASSIVE 0x04
|
|
|
|
#define ACPI_TRIPS_ACTIVE 0x08
|
|
|
|
#define ACPI_TRIPS_DEVICES 0x10
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
#define ACPI_TRIPS_REFRESH_THRESHOLDS (ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
|
|
|
|
#define ACPI_TRIPS_REFRESH_DEVICES ACPI_TRIPS_DEVICES
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
#define ACPI_TRIPS_INIT (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT | \
|
|
|
|
ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE | \
|
|
|
|
ACPI_TRIPS_DEVICES)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
/*
|
|
|
|
* This exception is thrown out in two cases:
|
|
|
|
* 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
|
|
|
|
* when re-evaluating the AML code.
|
|
|
|
* 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
|
|
|
|
* We need to re-bind the cooling devices of a thermal zone when this occurs.
|
|
|
|
*/
|
|
|
|
#define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str) \
|
|
|
|
do { \
|
|
|
|
if (flags != ACPI_TRIPS_INIT) \
|
|
|
|
ACPI_EXCEPTION((AE_INFO, AE_ERROR, \
|
|
|
|
"ACPI thermal trip point %s changed\n" \
|
2012-11-29 04:53:16 -07:00
|
|
|
"Please send acpidump to linux-acpi@vger.kernel.org", str)); \
|
2008-01-17 00:51:25 -07:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
|
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
2008-10-10 00:22:59 -06:00
|
|
|
unsigned long long tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
struct acpi_handle_list devices;
|
|
|
|
int valid = 0;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-02-20 03:44:27 -07:00
|
|
|
/* Critical Shutdown */
|
2008-01-17 00:51:25 -07:00
|
|
|
if (flag & ACPI_TRIPS_CRITICAL) {
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle,
|
2008-10-10 00:22:59 -06:00
|
|
|
"_CRT", NULL, &tmp);
|
|
|
|
tz->trips.critical.temperature = tmp;
|
2008-05-19 16:55:15 -06:00
|
|
|
/*
|
|
|
|
* Treat freezing temperatures as invalid as well; some
|
|
|
|
* BIOSes return really low values and cause reboots at startup.
|
2009-03-13 10:15:26 -06:00
|
|
|
* Below zero (Celsius) values clearly aren't right for sure..
|
2008-05-19 16:55:15 -06:00
|
|
|
* ... so lets discard those as invalid.
|
|
|
|
*/
|
2010-02-20 03:44:27 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
tz->trips.critical.flags.valid = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"No critical threshold\n"));
|
|
|
|
} else if (tmp <= 2732) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_warn(FW_BUG "Invalid critical threshold (%llu)\n",
|
|
|
|
tmp);
|
2007-08-14 13:49:32 -06:00
|
|
|
tz->trips.critical.flags.valid = 0;
|
2008-01-17 00:51:25 -07:00
|
|
|
} else {
|
|
|
|
tz->trips.critical.flags.valid = 1;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2010-02-20 03:44:27 -07:00
|
|
|
"Found critical threshold [%lu]\n",
|
|
|
|
tz->trips.critical.temperature));
|
2008-01-17 00:51:25 -07:00
|
|
|
}
|
|
|
|
if (tz->trips.critical.flags.valid == 1) {
|
|
|
|
if (crt == -1) {
|
|
|
|
tz->trips.critical.flags.valid = 0;
|
|
|
|
} else if (crt > 0) {
|
2015-10-01 15:45:31 -06:00
|
|
|
unsigned long crt_k = CELSIUS_TO_DECI_KELVIN(crt);
|
2008-01-17 00:51:25 -07:00
|
|
|
/*
|
2008-10-17 00:41:20 -06:00
|
|
|
* Allow override critical threshold
|
2008-01-17 00:51:25 -07:00
|
|
|
*/
|
2008-10-17 00:41:20 -06:00
|
|
|
if (crt_k > tz->trips.critical.temperature)
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_warn(PREFIX "Critical threshold %d C\n",
|
|
|
|
crt);
|
2008-10-17 00:41:20 -06:00
|
|
|
tz->trips.critical.temperature = crt_k;
|
2008-01-17 00:51:25 -07:00
|
|
|
}
|
2007-08-14 13:49:32 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Critical Sleep (optional) */
|
2008-01-17 00:51:25 -07:00
|
|
|
if (flag & ACPI_TRIPS_HOT) {
|
2007-08-11 22:12:35 -06:00
|
|
|
status = acpi_evaluate_integer(tz->device->handle,
|
2008-10-10 00:22:59 -06:00
|
|
|
"_HOT", NULL, &tmp);
|
2008-01-17 00:51:25 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
tz->trips.hot.flags.valid = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"No hot threshold\n"));
|
|
|
|
} else {
|
2008-10-10 00:22:59 -06:00
|
|
|
tz->trips.hot.temperature = tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
tz->trips.hot.flags.valid = 1;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Found hot threshold [%lu]\n",
|
2014-03-29 07:25:47 -06:00
|
|
|
tz->trips.hot.temperature));
|
2008-01-17 00:51:25 -07:00
|
|
|
}
|
2007-08-11 22:12:35 -06:00
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
/* Passive (optional) */
|
2009-01-16 10:53:42 -07:00
|
|
|
if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
|
|
|
|
(flag == ACPI_TRIPS_INIT)) {
|
2008-01-17 00:51:25 -07:00
|
|
|
valid = tz->trips.passive.flags.valid;
|
|
|
|
if (psv == -1) {
|
|
|
|
status = AE_SUPPORT;
|
|
|
|
} else if (psv > 0) {
|
2015-10-01 15:45:31 -06:00
|
|
|
tmp = CELSIUS_TO_DECI_KELVIN(psv);
|
2008-01-17 00:51:25 -07:00
|
|
|
status = AE_OK;
|
|
|
|
} else {
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle,
|
2008-10-10 00:22:59 -06:00
|
|
|
"_PSV", NULL, &tmp);
|
2008-01-17 00:51:25 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
2008-01-17 00:51:25 -07:00
|
|
|
else {
|
2008-10-10 00:22:59 -06:00
|
|
|
tz->trips.passive.temperature = tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
tz->trips.passive.flags.valid = 1;
|
|
|
|
if (flag == ACPI_TRIPS_INIT) {
|
|
|
|
status = acpi_evaluate_integer(
|
|
|
|
tz->device->handle, "_TC1",
|
2008-10-10 00:22:59 -06:00
|
|
|
NULL, &tmp);
|
2008-01-17 00:51:25 -07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
2008-10-10 00:22:59 -06:00
|
|
|
else
|
|
|
|
tz->trips.passive.tc1 = tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
status = acpi_evaluate_integer(
|
|
|
|
tz->device->handle, "_TC2",
|
2008-10-10 00:22:59 -06:00
|
|
|
NULL, &tmp);
|
2008-01-17 00:51:25 -07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
2008-10-10 00:22:59 -06:00
|
|
|
else
|
|
|
|
tz->trips.passive.tc2 = tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
status = acpi_evaluate_integer(
|
|
|
|
tz->device->handle, "_TSP",
|
2008-10-10 00:22:59 -06:00
|
|
|
NULL, &tmp);
|
2008-01-17 00:51:25 -07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
2008-10-10 00:22:59 -06:00
|
|
|
else
|
|
|
|
tz->trips.passive.tsp = tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
|
|
|
|
memset(&devices, 0, sizeof(struct acpi_handle_list));
|
|
|
|
status = acpi_evaluate_reference(tz->device->handle, "_PSL",
|
|
|
|
NULL, &devices);
|
2009-01-16 10:53:42 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_warn(PREFIX "Invalid passive threshold\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
tz->trips.passive.flags.valid = 0;
|
2009-01-16 10:53:42 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-01-17 00:51:25 -07:00
|
|
|
tz->trips.passive.flags.valid = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
if (memcmp(&tz->trips.passive.devices, &devices,
|
|
|
|
sizeof(struct acpi_handle_list))) {
|
|
|
|
memcpy(&tz->trips.passive.devices, &devices,
|
|
|
|
sizeof(struct acpi_handle_list));
|
|
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
|
|
|
|
if (valid != tz->trips.passive.flags.valid)
|
|
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
/* Active (optional) */
|
2005-08-04 22:44:28 -06:00
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
|
|
char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
|
2008-01-17 00:51:25 -07:00
|
|
|
valid = tz->trips.active[i].flags.valid;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-11 22:12:54 -06:00
|
|
|
if (act == -1)
|
2008-01-17 00:51:25 -07:00
|
|
|
break; /* disable all active trip points */
|
|
|
|
|
2009-01-16 10:53:42 -07:00
|
|
|
if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
|
|
|
|
tz->trips.active[i].flags.valid)) {
|
2008-01-17 00:51:25 -07:00
|
|
|
status = acpi_evaluate_integer(tz->device->handle,
|
2008-10-10 00:22:59 -06:00
|
|
|
name, NULL, &tmp);
|
2008-01-17 00:51:25 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
tz->trips.active[i].flags.valid = 0;
|
|
|
|
if (i == 0)
|
|
|
|
break;
|
|
|
|
if (act <= 0)
|
|
|
|
break;
|
|
|
|
if (i == 1)
|
|
|
|
tz->trips.active[0].temperature =
|
2015-10-01 15:45:31 -06:00
|
|
|
CELSIUS_TO_DECI_KELVIN(act);
|
2008-01-17 00:51:25 -07:00
|
|
|
else
|
|
|
|
/*
|
|
|
|
* Don't allow override higher than
|
|
|
|
* the next higher trip point
|
|
|
|
*/
|
|
|
|
tz->trips.active[i - 1].temperature =
|
|
|
|
(tz->trips.active[i - 2].temperature <
|
2015-10-01 15:45:31 -06:00
|
|
|
CELSIUS_TO_DECI_KELVIN(act) ?
|
2008-01-17 00:51:25 -07:00
|
|
|
tz->trips.active[i - 2].temperature :
|
2015-10-01 15:45:31 -06:00
|
|
|
CELSIUS_TO_DECI_KELVIN(act));
|
2007-08-11 22:12:54 -06:00
|
|
|
break;
|
2008-10-10 00:22:59 -06:00
|
|
|
} else {
|
|
|
|
tz->trips.active[i].temperature = tmp;
|
2008-01-17 00:51:25 -07:00
|
|
|
tz->trips.active[i].flags.valid = 1;
|
2008-10-10 00:22:59 -06:00
|
|
|
}
|
2007-08-11 22:12:54 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
name[2] = 'L';
|
2008-01-17 00:51:25 -07:00
|
|
|
if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
|
|
|
|
memset(&devices, 0, sizeof(struct acpi_handle_list));
|
|
|
|
status = acpi_evaluate_reference(tz->device->handle,
|
|
|
|
name, NULL, &devices);
|
2009-01-16 10:53:42 -07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_warn(PREFIX "Invalid active%d threshold\n",
|
|
|
|
i);
|
2008-01-17 00:51:25 -07:00
|
|
|
tz->trips.active[i].flags.valid = 0;
|
2009-01-16 10:53:42 -07:00
|
|
|
}
|
2008-01-17 00:51:25 -07:00
|
|
|
else
|
|
|
|
tz->trips.active[i].flags.valid = 1;
|
|
|
|
|
|
|
|
if (memcmp(&tz->trips.active[i].devices, &devices,
|
|
|
|
sizeof(struct acpi_handle_list))) {
|
|
|
|
memcpy(&tz->trips.active[i].devices, &devices,
|
|
|
|
sizeof(struct acpi_handle_list));
|
|
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
|
|
|
|
if (valid != tz->trips.active[i].flags.valid)
|
|
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
|
|
|
|
|
|
|
|
if (!tz->trips.active[i].flags.valid)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-08-27 02:29:31 -06:00
|
|
|
if ((flag & ACPI_TRIPS_DEVICES)
|
|
|
|
&& acpi_has_method(tz->device->handle, "_TZD")) {
|
|
|
|
memset(&devices, 0, sizeof(devices));
|
2008-01-17 00:51:25 -07:00
|
|
|
status = acpi_evaluate_reference(tz->device->handle, "_TZD",
|
|
|
|
NULL, &devices);
|
2013-08-27 02:29:31 -06:00
|
|
|
if (ACPI_SUCCESS(status)
|
|
|
|
&& memcmp(&tz->devices, &devices, sizeof(devices))) {
|
|
|
|
tz->devices = devices;
|
2008-01-17 00:51:25 -07:00
|
|
|
ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:25 -07:00
|
|
|
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-02-16 14:55:51 -07:00
|
|
|
int i, valid, ret = acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
valid = tz->trips.critical.flags.valid |
|
|
|
|
tz->trips.hot.flags.valid |
|
|
|
|
tz->trips.passive.flags.valid;
|
|
|
|
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
|
|
|
|
valid |= tz->trips.active[i].flags.valid;
|
|
|
|
|
|
|
|
if (!valid) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_warn(FW_BUG "No valid trip found\n");
|
2010-02-16 14:55:51 -07:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void acpi_thermal_check(void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-30 16:28:50 -06:00
|
|
|
struct acpi_thermal *tz = data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-09-25 10:29:50 -06:00
|
|
|
if (!tz->tz_enabled)
|
2013-01-15 15:57:16 -07:00
|
|
|
return;
|
2013-09-25 10:29:50 -06:00
|
|
|
|
2016-08-26 17:21:16 -06:00
|
|
|
thermal_zone_device_update(tz->thermal_zone,
|
|
|
|
THERMAL_EVENT_UNSPECIFIED);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:11 -07:00
|
|
|
/* sys I/F for generic thermal sysfs support */
|
2008-02-27 16:51:30 -07:00
|
|
|
|
2015-07-24 00:12:54 -06:00
|
|
|
static int thermal_get_temp(struct thermal_zone_device *thermal, int *temp)
|
2008-01-17 00:51:11 -07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
2008-04-10 02:20:23 -06:00
|
|
|
int result;
|
2008-01-17 00:51:11 -07:00
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-10 02:20:23 -06:00
|
|
|
result = acpi_thermal_get_temperature(tz);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2014-03-24 20:40:09 -06:00
|
|
|
*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(tz->temperature,
|
|
|
|
tz->kelvin_offset);
|
2008-11-27 10:48:13 -07:00
|
|
|
return 0;
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int thermal_get_mode(struct thermal_zone_device *thermal,
|
2008-11-27 10:48:13 -07:00
|
|
|
enum thermal_device_mode *mode)
|
2008-01-17 00:51:11 -07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-27 10:48:13 -07:00
|
|
|
*mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
|
|
|
|
THERMAL_DEVICE_DISABLED;
|
|
|
|
|
|
|
|
return 0;
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int thermal_set_mode(struct thermal_zone_device *thermal,
|
2008-11-27 10:48:13 -07:00
|
|
|
enum thermal_device_mode mode)
|
2008-01-17 00:51:11 -07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
int enable;
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* enable/disable thermal management from ACPI thermal driver
|
|
|
|
*/
|
2008-11-27 10:48:13 -07:00
|
|
|
if (mode == THERMAL_DEVICE_ENABLED)
|
2008-01-17 00:51:11 -07:00
|
|
|
enable = 1;
|
2013-09-25 10:29:50 -06:00
|
|
|
else if (mode == THERMAL_DEVICE_DISABLED) {
|
2008-01-17 00:51:11 -07:00
|
|
|
enable = 0;
|
2013-09-25 10:29:50 -06:00
|
|
|
pr_warn("thermal zone will be disabled\n");
|
|
|
|
} else
|
2008-01-17 00:51:11 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (enable != tz->tz_enabled) {
|
|
|
|
tz->tz_enabled = enable;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2012-07-24 20:11:00 -06:00
|
|
|
"%s kernel ACPI thermal control\n",
|
|
|
|
tz->tz_enabled ? "Enable" : "Disable"));
|
2008-01-17 00:51:11 -07:00
|
|
|
acpi_thermal_check(tz);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int thermal_get_trip_type(struct thermal_zone_device *thermal,
|
2008-11-27 10:48:13 -07:00
|
|
|
int trip, enum thermal_trip_type *type)
|
2008-01-17 00:51:11 -07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!tz || trip < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (tz->trips.critical.flags.valid) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
|
|
|
*type = THERMAL_TRIP_CRITICAL;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tz->trips.hot.flags.valid) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
|
|
|
*type = THERMAL_TRIP_HOT;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tz->trips.passive.flags.valid) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
|
|
|
*type = THERMAL_TRIP_PASSIVE;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
|
|
|
|
tz->trips.active[i].flags.valid; i++) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
|
|
|
*type = THERMAL_TRIP_ACTIVE;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
|
2015-07-24 00:12:54 -06:00
|
|
|
int trip, int *temp)
|
2008-01-17 00:51:11 -07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!tz || trip < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (tz->trips.critical.flags.valid) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
2014-03-24 20:40:09 -06:00
|
|
|
*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
|
2009-04-06 08:01:46 -06:00
|
|
|
tz->trips.critical.temperature,
|
|
|
|
tz->kelvin_offset);
|
2008-11-27 10:48:13 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tz->trips.hot.flags.valid) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
2014-03-24 20:40:09 -06:00
|
|
|
*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
|
2009-04-06 08:01:46 -06:00
|
|
|
tz->trips.hot.temperature,
|
|
|
|
tz->kelvin_offset);
|
2008-11-27 10:48:13 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tz->trips.passive.flags.valid) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
2014-03-24 20:40:09 -06:00
|
|
|
*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
|
2009-04-06 08:01:46 -06:00
|
|
|
tz->trips.passive.temperature,
|
|
|
|
tz->kelvin_offset);
|
2008-11-27 10:48:13 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
|
|
|
|
tz->trips.active[i].flags.valid; i++) {
|
2008-11-27 10:48:13 -07:00
|
|
|
if (!trip) {
|
2014-03-24 20:40:09 -06:00
|
|
|
*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
|
2009-04-06 08:01:46 -06:00
|
|
|
tz->trips.active[i].temperature,
|
|
|
|
tz->kelvin_offset);
|
2008-11-27 10:48:13 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
trip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-04-10 02:13:10 -06:00
|
|
|
static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
|
2015-07-24 00:12:54 -06:00
|
|
|
int *temperature)
|
|
|
|
{
|
2008-04-10 02:13:10 -06:00
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
|
|
|
|
if (tz->trips.critical.flags.valid) {
|
2014-03-24 20:40:09 -06:00
|
|
|
*temperature = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
|
2009-04-06 08:01:46 -06:00
|
|
|
tz->trips.critical.temperature,
|
|
|
|
tz->kelvin_offset);
|
2008-04-10 02:13:10 -06:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-06-26 19:54:33 -06:00
|
|
|
static int thermal_get_trend(struct thermal_zone_device *thermal,
|
|
|
|
int trip, enum thermal_trend *trend)
|
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
enum thermal_trip_type type;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (thermal_get_trip_type(thermal, trip, &type))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-06-26 20:05:39 -06:00
|
|
|
if (type == THERMAL_TRIP_ACTIVE) {
|
2015-07-24 00:12:54 -06:00
|
|
|
int trip_temp;
|
|
|
|
int temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
|
2014-03-24 20:40:09 -06:00
|
|
|
tz->temperature, tz->kelvin_offset);
|
2013-04-26 03:19:53 -06:00
|
|
|
if (thermal_get_trip_temp(thermal, trip, &trip_temp))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (temp > trip_temp) {
|
|
|
|
*trend = THERMAL_TREND_RAISING;
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
/* Fall back on default trend */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2012-06-26 20:05:39 -06:00
|
|
|
}
|
2012-06-26 19:54:33 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* tz->temperature has already been updated by generic thermal layer,
|
|
|
|
* before this callback being invoked
|
|
|
|
*/
|
|
|
|
i = (tz->trips.passive.tc1 * (tz->temperature - tz->last_temperature))
|
|
|
|
+ (tz->trips.passive.tc2
|
|
|
|
* (tz->temperature - tz->trips.passive.temperature));
|
|
|
|
|
|
|
|
if (i > 0)
|
|
|
|
*trend = THERMAL_TREND_RAISING;
|
|
|
|
else if (i < 0)
|
|
|
|
*trend = THERMAL_TREND_DROPPING;
|
|
|
|
else
|
|
|
|
*trend = THERMAL_TREND_STABLE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-12-03 10:55:32 -07:00
|
|
|
static int thermal_notify(struct thermal_zone_device *thermal, int trip,
|
|
|
|
enum thermal_trip_type trip_type)
|
|
|
|
{
|
|
|
|
u8 type = 0;
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
|
|
|
|
|
|
|
if (trip_type == THERMAL_TRIP_CRITICAL)
|
|
|
|
type = ACPI_THERMAL_NOTIFY_CRITICAL;
|
|
|
|
else if (trip_type == THERMAL_TRIP_HOT)
|
|
|
|
type = ACPI_THERMAL_NOTIFY_HOT;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
|
2009-03-02 18:47:17 -07:00
|
|
|
dev_name(&tz->device->dev), type, 1);
|
2008-12-03 10:55:32 -07:00
|
|
|
|
|
|
|
if (trip_type == THERMAL_TRIP_CRITICAL && nocrt)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:11 -07:00
|
|
|
static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
|
|
|
|
struct thermal_cooling_device *cdev,
|
2012-06-26 02:35:57 -06:00
|
|
|
bool bind)
|
2008-01-17 00:51:11 -07:00
|
|
|
{
|
|
|
|
struct acpi_device *device = cdev->devdata;
|
|
|
|
struct acpi_thermal *tz = thermal->devdata;
|
2008-01-17 00:51:18 -07:00
|
|
|
struct acpi_device *dev;
|
|
|
|
acpi_status status;
|
|
|
|
acpi_handle handle;
|
2008-01-17 00:51:11 -07:00
|
|
|
int i;
|
|
|
|
int j;
|
|
|
|
int trip = -1;
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
if (tz->trips.critical.flags.valid)
|
|
|
|
trip++;
|
|
|
|
|
|
|
|
if (tz->trips.hot.flags.valid)
|
|
|
|
trip++;
|
|
|
|
|
|
|
|
if (tz->trips.passive.flags.valid) {
|
|
|
|
trip++;
|
|
|
|
for (i = 0; i < tz->trips.passive.devices.count;
|
|
|
|
i++) {
|
2008-01-17 00:51:18 -07:00
|
|
|
handle = tz->trips.passive.devices.handles[i];
|
|
|
|
status = acpi_bus_get_device(handle, &dev);
|
2012-06-26 02:35:57 -06:00
|
|
|
if (ACPI_FAILURE(status) || dev != device)
|
|
|
|
continue;
|
|
|
|
if (bind)
|
|
|
|
result =
|
|
|
|
thermal_zone_bind_cooling_device
|
|
|
|
(thermal, trip, cdev,
|
2015-02-18 09:04:21 -07:00
|
|
|
THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
|
|
|
|
THERMAL_WEIGHT_DEFAULT);
|
2012-06-26 02:35:57 -06:00
|
|
|
else
|
|
|
|
result =
|
|
|
|
thermal_zone_unbind_cooling_device
|
|
|
|
(thermal, trip, cdev);
|
|
|
|
if (result)
|
|
|
|
goto failed;
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
|
|
if (!tz->trips.active[i].flags.valid)
|
|
|
|
break;
|
|
|
|
trip++;
|
|
|
|
for (j = 0;
|
|
|
|
j < tz->trips.active[i].devices.count;
|
|
|
|
j++) {
|
2008-01-17 00:51:18 -07:00
|
|
|
handle = tz->trips.active[i].devices.handles[j];
|
|
|
|
status = acpi_bus_get_device(handle, &dev);
|
2012-06-26 02:35:57 -06:00
|
|
|
if (ACPI_FAILURE(status) || dev != device)
|
|
|
|
continue;
|
|
|
|
if (bind)
|
|
|
|
result = thermal_zone_bind_cooling_device
|
|
|
|
(thermal, trip, cdev,
|
2015-02-18 09:04:21 -07:00
|
|
|
THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
|
|
|
|
THERMAL_WEIGHT_DEFAULT);
|
2012-06-26 02:35:57 -06:00
|
|
|
else
|
|
|
|
result = thermal_zone_unbind_cooling_device
|
|
|
|
(thermal, trip, cdev);
|
|
|
|
if (result)
|
|
|
|
goto failed;
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < tz->devices.count; i++) {
|
2008-01-17 00:51:18 -07:00
|
|
|
handle = tz->devices.handles[i];
|
|
|
|
status = acpi_bus_get_device(handle, &dev);
|
|
|
|
if (ACPI_SUCCESS(status) && (dev == device)) {
|
2012-06-26 02:35:57 -06:00
|
|
|
if (bind)
|
|
|
|
result = thermal_zone_bind_cooling_device
|
2013-08-14 07:00:39 -06:00
|
|
|
(thermal, THERMAL_TRIPS_NONE,
|
|
|
|
cdev, THERMAL_NO_LIMIT,
|
2015-02-18 09:04:21 -07:00
|
|
|
THERMAL_NO_LIMIT,
|
|
|
|
THERMAL_WEIGHT_DEFAULT);
|
2012-06-26 02:35:57 -06:00
|
|
|
else
|
|
|
|
result = thermal_zone_unbind_cooling_device
|
2013-08-14 07:00:39 -06:00
|
|
|
(thermal, THERMAL_TRIPS_NONE,
|
|
|
|
cdev);
|
2008-01-17 00:51:18 -07:00
|
|
|
if (result)
|
|
|
|
goto failed;
|
|
|
|
}
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
failed:
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
|
|
|
|
struct thermal_cooling_device *cdev)
|
|
|
|
{
|
2012-06-26 02:35:57 -06:00
|
|
|
return acpi_thermal_cooling_device_cb(thermal, cdev, true);
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
|
|
|
|
struct thermal_cooling_device *cdev)
|
|
|
|
{
|
2012-06-26 02:35:57 -06:00
|
|
|
return acpi_thermal_cooling_device_cb(thermal, cdev, false);
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
|
2014-01-07 09:24:55 -07:00
|
|
|
static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
|
2008-01-17 00:51:11 -07:00
|
|
|
.bind = acpi_thermal_bind_cooling_device,
|
|
|
|
.unbind = acpi_thermal_unbind_cooling_device,
|
|
|
|
.get_temp = thermal_get_temp,
|
|
|
|
.get_mode = thermal_get_mode,
|
|
|
|
.set_mode = thermal_set_mode,
|
|
|
|
.get_trip_type = thermal_get_trip_type,
|
|
|
|
.get_trip_temp = thermal_get_trip_temp,
|
2008-04-10 02:13:10 -06:00
|
|
|
.get_crit_temp = thermal_get_crit_temp,
|
2012-06-26 19:54:33 -06:00
|
|
|
.get_trend = thermal_get_trend,
|
2008-12-03 10:55:32 -07:00
|
|
|
.notify = thermal_notify,
|
2008-01-17 00:51:11 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
|
|
|
|
{
|
|
|
|
int trips = 0;
|
|
|
|
int result;
|
2008-01-17 00:51:21 -07:00
|
|
|
acpi_status status;
|
2008-01-17 00:51:11 -07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
if (tz->trips.critical.flags.valid)
|
|
|
|
trips++;
|
|
|
|
|
|
|
|
if (tz->trips.hot.flags.valid)
|
|
|
|
trips++;
|
|
|
|
|
|
|
|
if (tz->trips.passive.flags.valid)
|
|
|
|
trips++;
|
|
|
|
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
|
|
|
|
tz->trips.active[i].flags.valid; i++, trips++);
|
2008-12-03 10:55:32 -07:00
|
|
|
|
|
|
|
if (tz->trips.passive.flags.valid)
|
|
|
|
tz->thermal_zone =
|
2012-07-24 20:10:58 -06:00
|
|
|
thermal_zone_device_register("acpitz", trips, 0, tz,
|
2012-09-17 23:34:56 -06:00
|
|
|
&acpi_thermal_zone_ops, NULL,
|
2008-12-03 10:55:32 -07:00
|
|
|
tz->trips.passive.tsp*100,
|
|
|
|
tz->polling_frequency*100);
|
|
|
|
else
|
|
|
|
tz->thermal_zone =
|
2012-07-24 20:10:58 -06:00
|
|
|
thermal_zone_device_register("acpitz", trips, 0, tz,
|
2012-09-17 23:34:56 -06:00
|
|
|
&acpi_thermal_zone_ops, NULL,
|
|
|
|
0, tz->polling_frequency*100);
|
2008-04-08 18:41:52 -06:00
|
|
|
if (IS_ERR(tz->thermal_zone))
|
2008-01-17 00:51:11 -07:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
result = sysfs_create_link(&tz->device->dev.kobj,
|
|
|
|
&tz->thermal_zone->device.kobj, "thermal_zone");
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = sysfs_create_link(&tz->thermal_zone->device.kobj,
|
|
|
|
&tz->device->dev.kobj, "device");
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2014-05-20 06:59:22 -06:00
|
|
|
status = acpi_bus_attach_private_data(tz->device->handle,
|
|
|
|
tz->thermal_zone);
|
|
|
|
if (ACPI_FAILURE(status))
|
2008-01-17 00:51:21 -07:00
|
|
|
return -ENODEV;
|
|
|
|
|
2008-01-17 00:51:11 -07:00
|
|
|
tz->tz_enabled = 1;
|
|
|
|
|
2008-05-01 22:02:41 -06:00
|
|
|
dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
|
|
|
|
tz->thermal_zone->id);
|
2008-01-17 00:51:11 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
|
|
|
|
{
|
|
|
|
sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
|
|
|
|
sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
|
|
|
|
thermal_zone_device_unregister(tz->thermal_zone);
|
|
|
|
tz->thermal_zone = NULL;
|
2014-05-20 06:59:22 -06:00
|
|
|
acpi_bus_detach_private_data(tz->device->handle);
|
2008-01-17 00:51:11 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2009-04-07 09:37:06 -06:00
|
|
|
static void acpi_thermal_notify(struct acpi_device *device, u32 event)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-04-07 09:37:06 -06:00
|
|
|
struct acpi_thermal *tz = acpi_driver_data(device);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case ACPI_THERMAL_NOTIFY_TEMPERATURE:
|
|
|
|
acpi_thermal_check(tz);
|
|
|
|
break;
|
|
|
|
case ACPI_THERMAL_NOTIFY_THRESHOLDS:
|
2008-01-17 00:51:25 -07:00
|
|
|
acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_thermal_check(tz);
|
2007-08-22 11:24:31 -06:00
|
|
|
acpi_bus_generate_netlink_event(device->pnp.device_class,
|
ACPI: struct device - replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-10-29 18:18:59 -06:00
|
|
|
dev_name(&device->dev), event, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case ACPI_THERMAL_NOTIFY_DEVICES:
|
2008-01-17 00:51:25 -07:00
|
|
|
acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
|
|
|
|
acpi_thermal_check(tz);
|
2007-08-22 11:24:31 -06:00
|
|
|
acpi_bus_generate_netlink_event(device->pnp.device_class,
|
ACPI: struct device - replace bus_id with dev_name(), dev_set_name()
This patch is part of a larger patch series which will remove
the "char bus_id[20]" name string from struct device. The device
name is managed in the kobject anyway, and without any size
limitation, and just needlessly copied into "struct device".
To set and read the device name dev_name(dev) and dev_set_name(dev)
must be used. If your code uses static kobjects, which it shouldn't
do, "const char *init_name" can be used to statically provide the
name the registered device should have. At registration time, the
init_name field is cleared, to enforce the use of dev_name(dev) to
access the device name at a later time.
We need to get rid of all occurrences of bus_id in the entire tree
to be able to enable the new interface. Please apply this patch,
and possibly convert any remaining remaining occurrences of bus_id.
We want to submit a patch to -next, which will remove bus_id from
"struct device", to find the remaining pieces to convert, and finally
switch over to the new api, which will remove the 20 bytes array
and does no longer have a size limitation.
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-Off-By: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-10-29 18:18:59 -06:00
|
|
|
dev_name(&device->dev), event, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-04 22:44:28 -06:00
|
|
|
"Unsupported event [0x%x]\n", event));
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-27 12:42:11 -07:00
|
|
|
/*
|
|
|
|
* On some platforms, the AML code has dependency about
|
|
|
|
* the evaluating order of _TMP and _CRT/_HOT/_PSV/_ACx.
|
|
|
|
* 1. On HP Pavilion G4-1016tx, _TMP must be invoked after
|
|
|
|
* /_CRT/_HOT/_PSV/_ACx, or else system will be power off.
|
|
|
|
* 2. On HP Compaq 6715b/6715s, the return value of _PSV is 0
|
|
|
|
* if _TMP has never been evaluated.
|
|
|
|
*
|
|
|
|
* As this dependency is totally transparent to OS, evaluate
|
|
|
|
* all of them once, in the order of _CRT/_HOT/_PSV/_ACx,
|
|
|
|
* _TMP, before they are actually used.
|
|
|
|
*/
|
|
|
|
static void acpi_thermal_aml_dependency_fix(struct acpi_thermal *tz)
|
|
|
|
{
|
|
|
|
acpi_handle handle = tz->device->handle;
|
|
|
|
unsigned long long value;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
acpi_evaluate_integer(handle, "_CRT", NULL, &value);
|
|
|
|
acpi_evaluate_integer(handle, "_HOT", NULL, &value);
|
|
|
|
acpi_evaluate_integer(handle, "_PSV", NULL, &value);
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
|
|
char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_evaluate_integer(handle, name, NULL, &value);
|
|
|
|
if (status == AE_NOT_FOUND)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
acpi_evaluate_integer(handle, "_TMP", NULL, &value);
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_thermal_get_info(struct acpi_thermal *tz)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-27 12:42:11 -07:00
|
|
|
acpi_thermal_aml_dependency_fix(tz);
|
|
|
|
|
2012-02-01 08:26:54 -07:00
|
|
|
/* Get trip points [_CRT, _PSV, etc.] (required) */
|
|
|
|
result = acpi_thermal_get_trip_points(tz);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (result)
|
2006-06-26 22:41:40 -06:00
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-01 08:26:54 -07:00
|
|
|
/* Get temperature [_TMP] (required) */
|
|
|
|
result = acpi_thermal_get_temperature(tz);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (result)
|
2006-06-26 22:41:40 -06:00
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Set the cooling mode [_SCP] to active cooling (default) */
|
|
|
|
result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
|
2005-08-04 22:44:28 -06:00
|
|
|
if (!result)
|
2005-04-16 16:20:36 -06:00
|
|
|
tz->flags.cooling_mode = 1;
|
|
|
|
|
|
|
|
/* Get default polling frequency [_TZP] (optional) */
|
|
|
|
if (tzp)
|
|
|
|
tz->polling_frequency = tzp;
|
|
|
|
else
|
|
|
|
acpi_thermal_get_polling_frequency(tz);
|
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-04-06 08:01:46 -06:00
|
|
|
/*
|
|
|
|
* The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
|
|
|
|
* handles temperature values with a single decimal place. As a consequence,
|
|
|
|
* some implementations use an offset of 273.1 and others use an offset of
|
|
|
|
* 273.2. Try to find out which one is being used, to present the most
|
|
|
|
* accurate and visually appealing number.
|
|
|
|
*
|
|
|
|
* The heuristic below should work for all ACPI thermal zones which have a
|
|
|
|
* critical trip point with a value being a multiple of 0.5 degree Celsius.
|
|
|
|
*/
|
|
|
|
static void acpi_thermal_guess_offset(struct acpi_thermal *tz)
|
|
|
|
{
|
|
|
|
if (tz->trips.critical.flags.valid &&
|
|
|
|
(tz->trips.critical.temperature % 5) == 1)
|
|
|
|
tz->kelvin_offset = 2731;
|
|
|
|
else
|
|
|
|
tz->kelvin_offset = 2732;
|
|
|
|
}
|
|
|
|
|
2014-03-03 23:24:46 -07:00
|
|
|
static void acpi_thermal_check_fn(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = container_of(work, struct acpi_thermal,
|
|
|
|
thermal_check_work);
|
|
|
|
acpi_thermal_check(tz);
|
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int acpi_thermal_add(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
|
|
|
struct acpi_thermal *tz = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-12-19 13:56:11 -07:00
|
|
|
tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!tz)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-05-19 14:54:40 -06:00
|
|
|
tz->device = device;
|
2005-04-16 16:20:36 -06:00
|
|
|
strcpy(tz->name, device->pnp.bus_id);
|
|
|
|
strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
|
|
|
|
strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
|
2008-09-22 15:37:34 -06:00
|
|
|
device->driver_data = tz;
|
2008-01-17 00:51:11 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
result = acpi_thermal_get_info(tz);
|
|
|
|
if (result)
|
2008-01-17 00:51:11 -07:00
|
|
|
goto free_memory;
|
|
|
|
|
2009-04-06 08:01:46 -06:00
|
|
|
acpi_thermal_guess_offset(tz);
|
|
|
|
|
2008-01-17 00:51:11 -07:00
|
|
|
result = acpi_thermal_register_thermal_zone(tz);
|
|
|
|
if (result)
|
|
|
|
goto free_memory;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-03 23:24:46 -07:00
|
|
|
INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn);
|
|
|
|
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_info(PREFIX "%s [%s] (%ld C)\n", acpi_device_name(device),
|
2015-10-01 15:45:31 -06:00
|
|
|
acpi_device_bid(device), DECI_KELVIN_TO_CELSIUS(tz->temperature));
|
2008-01-17 00:51:11 -07:00
|
|
|
goto end;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:11 -07:00
|
|
|
free_memory:
|
|
|
|
kfree(tz);
|
|
|
|
end:
|
2006-06-26 22:41:40 -06:00
|
|
|
return result;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-01-23 16:24:48 -07:00
|
|
|
static int acpi_thermal_remove(struct acpi_device *device)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
struct acpi_thermal *tz = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-03 23:24:46 -07:00
|
|
|
flush_workqueue(acpi_thermal_pm_queue);
|
2006-09-30 16:28:50 -06:00
|
|
|
tz = acpi_driver_data(device);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-17 00:51:11 -07:00
|
|
|
acpi_thermal_unregister_thermal_zone(tz);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(tz);
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-08-09 15:00:02 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2014-03-03 23:24:46 -07:00
|
|
|
static int acpi_thermal_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
/* Make sure the previously queued thermal check work has been done */
|
|
|
|
flush_workqueue(acpi_thermal_pm_queue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-27 15:26:18 -06:00
|
|
|
static int acpi_thermal_resume(struct device *dev)
|
2006-05-08 06:32:00 -06:00
|
|
|
{
|
2012-06-27 15:26:18 -06:00
|
|
|
struct acpi_thermal *tz;
|
2007-02-16 00:23:07 -07:00
|
|
|
int i, j, power_state, result;
|
|
|
|
|
2012-06-27 15:26:18 -06:00
|
|
|
if (!dev)
|
2006-06-26 22:41:40 -06:00
|
|
|
return -EINVAL;
|
2006-05-08 06:32:00 -06:00
|
|
|
|
2012-06-27 15:26:18 -06:00
|
|
|
tz = acpi_driver_data(to_acpi_device(dev));
|
|
|
|
if (!tz)
|
|
|
|
return -EINVAL;
|
2006-05-08 06:32:00 -06:00
|
|
|
|
2006-07-10 05:44:26 -06:00
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
2007-02-16 00:23:07 -07:00
|
|
|
if (!(&tz->trips.active[i]))
|
|
|
|
break;
|
|
|
|
if (!tz->trips.active[i].flags.valid)
|
|
|
|
break;
|
|
|
|
tz->trips.active[i].flags.enabled = 1;
|
|
|
|
for (j = 0; j < tz->trips.active[i].devices.count; j++) {
|
2010-11-24 16:11:24 -07:00
|
|
|
result = acpi_bus_update_power(
|
|
|
|
tz->trips.active[i].devices.handles[j],
|
|
|
|
&power_state);
|
2007-02-16 00:23:07 -07:00
|
|
|
if (result || (power_state != ACPI_STATE_D0)) {
|
|
|
|
tz->trips.active[i].flags.enabled = 0;
|
|
|
|
break;
|
|
|
|
}
|
2006-07-10 05:44:26 -06:00
|
|
|
}
|
2007-02-16 00:23:07 -07:00
|
|
|
tz->state.active |= tz->trips.active[i].flags.enabled;
|
2006-07-10 05:44:26 -06:00
|
|
|
}
|
|
|
|
|
2014-03-03 23:24:46 -07:00
|
|
|
queue_work(acpi_thermal_pm_queue, &tz->thermal_check_work);
|
2006-05-08 06:32:00 -06:00
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
2012-08-09 15:00:02 -06:00
|
|
|
#endif
|
2006-05-08 06:32:00 -06:00
|
|
|
|
2007-10-03 13:15:40 -06:00
|
|
|
static int thermal_act(const struct dmi_system_id *d) {
|
2007-08-11 22:13:02 -06:00
|
|
|
|
|
|
|
if (act == 0) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_notice(PREFIX "%s detected: "
|
|
|
|
"disabling all active thermal trip points\n", d->ident);
|
2007-08-11 22:13:02 -06:00
|
|
|
act = -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-10-03 13:15:40 -06:00
|
|
|
static int thermal_nocrt(const struct dmi_system_id *d) {
|
2007-08-20 16:46:50 -06:00
|
|
|
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_notice(PREFIX "%s detected: "
|
|
|
|
"disabling all critical thermal trip point actions.\n", d->ident);
|
2007-08-20 16:46:50 -06:00
|
|
|
nocrt = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-10-03 13:15:40 -06:00
|
|
|
static int thermal_tzp(const struct dmi_system_id *d) {
|
2007-08-11 22:13:02 -06:00
|
|
|
|
|
|
|
if (tzp == 0) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_notice(PREFIX "%s detected: "
|
|
|
|
"enabling thermal zone polling\n", d->ident);
|
2007-08-11 22:13:02 -06:00
|
|
|
tzp = 300; /* 300 dS = 30 Seconds */
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-10-03 13:15:40 -06:00
|
|
|
static int thermal_psv(const struct dmi_system_id *d) {
|
2007-08-11 22:13:02 -06:00
|
|
|
|
|
|
|
if (psv == 0) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_notice(PREFIX "%s detected: "
|
|
|
|
"disabling all passive thermal trip points\n", d->ident);
|
2007-08-11 22:13:02 -06:00
|
|
|
psv = -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-14 03:59:30 -06:00
|
|
|
static const struct dmi_system_id thermal_dmi_table[] __initconst = {
|
2007-08-11 22:13:02 -06:00
|
|
|
/*
|
|
|
|
* Award BIOS on this AOpen makes thermal control almost worthless.
|
|
|
|
* http://bugzilla.kernel.org/show_bug.cgi?id=8842
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
.callback = thermal_act,
|
|
|
|
.ident = "AOpen i915GMm-HFS",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = thermal_psv,
|
|
|
|
.ident = "AOpen i915GMm-HFS",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = thermal_tzp,
|
|
|
|
.ident = "AOpen i915GMm-HFS",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
|
|
|
|
},
|
|
|
|
},
|
2007-08-20 16:46:50 -06:00
|
|
|
{
|
|
|
|
.callback = thermal_nocrt,
|
|
|
|
.ident = "Gigabyte GA-7ZX",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
|
|
|
|
},
|
|
|
|
},
|
2007-08-11 22:13:02 -06:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static int __init acpi_thermal_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-08-04 22:44:28 -06:00
|
|
|
int result = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-11 22:13:02 -06:00
|
|
|
dmi_check_system(thermal_dmi_table);
|
|
|
|
|
2007-08-11 22:12:17 -06:00
|
|
|
if (off) {
|
2013-09-13 09:15:46 -06:00
|
|
|
pr_notice(PREFIX "thermal control disabled\n");
|
2007-08-11 22:12:17 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2010-07-14 20:46:44 -06:00
|
|
|
|
2016-06-06 21:15:40 -06:00
|
|
|
acpi_thermal_pm_queue = alloc_workqueue("acpi_thermal_pm",
|
|
|
|
WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
|
2014-03-03 23:24:46 -07:00
|
|
|
if (!acpi_thermal_pm_queue)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
result = acpi_bus_register_driver(&acpi_thermal_driver);
|
2014-03-03 23:24:46 -07:00
|
|
|
if (result < 0) {
|
|
|
|
destroy_workqueue(acpi_thermal_pm_queue);
|
2006-06-26 22:41:40 -06:00
|
|
|
return -ENODEV;
|
2014-03-03 23:24:46 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-08-04 22:44:28 -06:00
|
|
|
static void __exit acpi_thermal_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
acpi_bus_unregister_driver(&acpi_thermal_driver);
|
2014-05-26 06:34:07 -06:00
|
|
|
destroy_workqueue(acpi_thermal_pm_queue);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-06-26 22:41:40 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(acpi_thermal_init);
|
|
|
|
module_exit(acpi_thermal_exit);
|