2005-04-17 05:20:36 +07: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.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
*
|
|
|
|
* 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-12 11:13:02 +07:00
|
|
|
#include <linux/dmi.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/proc_fs.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 15:33:14 +07:00
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/jiffies.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/kmod.h>
|
|
|
|
#include <linux/seq_file.h>
|
2007-07-18 08:37:02 +07:00
|
|
|
#include <linux/reboot.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
|
|
|
|
#define ACPI_THERMAL_COMPONENT 0x04000000
|
|
|
|
#define ACPI_THERMAL_CLASS "thermal_zone"
|
|
|
|
#define ACPI_THERMAL_DEVICE_NAME "Thermal Zone"
|
|
|
|
#define ACPI_THERMAL_FILE_STATE "state"
|
|
|
|
#define ACPI_THERMAL_FILE_TEMPERATURE "temperature"
|
|
|
|
#define ACPI_THERMAL_FILE_TRIP_POINTS "trip_points"
|
|
|
|
#define ACPI_THERMAL_FILE_COOLING_MODE "cooling_mode"
|
|
|
|
#define ACPI_THERMAL_FILE_POLLING_FREQ "polling_frequency"
|
|
|
|
#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 KELVIN_TO_CELSIUS(t) (long)(((long)t-2732>=0) ? ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
|
|
|
|
#define CELSIUS_TO_KELVIN(t) ((t+273)*10)
|
|
|
|
|
|
|
|
#define _COMPONENT ACPI_THERMAL_COMPONENT
|
2007-02-13 10:42:12 +07:00
|
|
|
ACPI_MODULE_NAME("thermal");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2004-09-16 22:07:00 +07:00
|
|
|
MODULE_AUTHOR("Paul Diefenbaugh");
|
2007-02-13 11:50:02 +07:00
|
|
|
MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
|
2005-04-17 05:20:36 +07:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2007-08-12 11:12:54 +07:00
|
|
|
static int act;
|
|
|
|
module_param(act, int, 0644);
|
2007-08-15 02:12:56 +07:00
|
|
|
MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
|
2007-08-12 11:12:54 +07:00
|
|
|
|
2007-08-15 02:49:32 +07:00
|
|
|
static int crt;
|
|
|
|
module_param(crt, int, 0644);
|
|
|
|
MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
|
|
|
|
|
2005-04-17 05:20:36 +07: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-12 11:12:26 +07:00
|
|
|
module_param(tzp, int, 0444);
|
2007-08-15 02:12:56 +07:00
|
|
|
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-12 11:12:44 +07:00
|
|
|
static int nocrt;
|
|
|
|
module_param(nocrt, int, 0);
|
2007-08-21 05:46:50 +07:00
|
|
|
MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
|
2007-08-12 11:12:44 +07:00
|
|
|
|
2007-08-12 11:12:17 +07:00
|
|
|
static int off;
|
|
|
|
module_param(off, int, 0);
|
2007-08-15 02:12:56 +07:00
|
|
|
MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
|
2007-08-12 11:12:17 +07:00
|
|
|
|
2007-08-12 11:12:35 +07:00
|
|
|
static int psv;
|
|
|
|
module_param(psv, int, 0644);
|
2007-08-15 02:12:56 +07:00
|
|
|
MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
|
2007-08-12 11:12:35 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_add(struct acpi_device *device);
|
|
|
|
static int acpi_thermal_remove(struct acpi_device *device, int type);
|
2006-12-07 19:56:27 +07:00
|
|
|
static int acpi_thermal_resume(struct acpi_device *device);
|
2005-04-17 05:20:36 +07:00
|
|
|
static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
|
|
|
|
static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
|
|
|
|
static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
|
|
|
|
static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
|
2005-08-05 11:44:28 +07:00
|
|
|
static ssize_t acpi_thermal_write_cooling_mode(struct file *,
|
|
|
|
const char __user *, size_t,
|
|
|
|
loff_t *);
|
2005-04-17 05:20:36 +07:00
|
|
|
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
|
2005-08-05 11:44:28 +07:00
|
|
|
static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
|
|
|
|
size_t, loff_t *);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-23 19:44:41 +07:00
|
|
|
static const struct acpi_device_id thermal_device_ids[] = {
|
|
|
|
{ACPI_THERMAL_HID, 0},
|
|
|
|
{"", 0},
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static struct acpi_driver acpi_thermal_driver = {
|
2007-02-13 11:33:40 +07:00
|
|
|
.name = "thermal",
|
2005-08-05 11:44:28 +07:00
|
|
|
.class = ACPI_THERMAL_CLASS,
|
2007-07-23 19:44:41 +07:00
|
|
|
.ids = thermal_device_ids,
|
2005-08-05 11:44:28 +07:00
|
|
|
.ops = {
|
|
|
|
.add = acpi_thermal_add,
|
|
|
|
.remove = acpi_thermal_remove,
|
2006-05-08 19:32:00 +07:00
|
|
|
.resume = acpi_thermal_resume,
|
2005-08-05 11:44:28 +07:00
|
|
|
},
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_state {
|
2005-08-05 11:44:28 +07:00
|
|
|
u8 critical:1;
|
|
|
|
u8 hot:1;
|
|
|
|
u8 passive:1;
|
|
|
|
u8 active:1;
|
|
|
|
u8 reserved:4;
|
|
|
|
int active_index;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_state_flags {
|
2005-08-05 11:44:28 +07:00
|
|
|
u8 valid:1;
|
|
|
|
u8 enabled:1;
|
|
|
|
u8 reserved:6;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_critical {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long temperature;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_hot {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long temperature;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_passive {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long temperature;
|
|
|
|
unsigned long tc1;
|
|
|
|
unsigned long tc2;
|
|
|
|
unsigned long tsp;
|
|
|
|
struct acpi_handle_list devices;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_active {
|
|
|
|
struct acpi_thermal_state_flags flags;
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long temperature;
|
|
|
|
struct acpi_handle_list devices;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_trips {
|
|
|
|
struct acpi_thermal_critical critical;
|
2005-08-05 11:44:28 +07:00
|
|
|
struct acpi_thermal_hot hot;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct acpi_thermal_passive passive;
|
|
|
|
struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal_flags {
|
2005-08-05 11:44:28 +07:00
|
|
|
u8 cooling_mode:1; /* _SCP */
|
|
|
|
u8 devices:1; /* _TZD */
|
|
|
|
u8 reserved:6;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct acpi_thermal {
|
2006-05-20 03:54:40 +07:00
|
|
|
struct acpi_device * device;
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_bus_id name;
|
|
|
|
unsigned long temperature;
|
|
|
|
unsigned long last_temperature;
|
|
|
|
unsigned long polling_frequency;
|
|
|
|
volatile u8 zombie;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct acpi_thermal_flags flags;
|
|
|
|
struct acpi_thermal_state state;
|
|
|
|
struct acpi_thermal_trips trips;
|
2005-08-05 11:44:28 +07:00
|
|
|
struct acpi_handle_list devices;
|
|
|
|
struct timer_list timer;
|
2007-09-01 03:11:59 +07:00
|
|
|
struct mutex lock;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2006-07-05 00:06:00 +07:00
|
|
|
static const struct file_operations acpi_thermal_state_fops = {
|
2005-08-05 11:44:28 +07:00
|
|
|
.open = acpi_thermal_state_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2006-07-05 00:06:00 +07:00
|
|
|
static const struct file_operations acpi_thermal_temp_fops = {
|
2005-08-05 11:44:28 +07:00
|
|
|
.open = acpi_thermal_temp_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2006-07-05 00:06:00 +07:00
|
|
|
static const struct file_operations acpi_thermal_trip_fops = {
|
2005-08-05 11:44:28 +07:00
|
|
|
.open = acpi_thermal_trip_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2006-07-05 00:06:00 +07:00
|
|
|
static const struct file_operations acpi_thermal_cooling_fops = {
|
2005-08-05 11:44:28 +07:00
|
|
|
.open = acpi_thermal_cooling_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.write = acpi_thermal_write_cooling_mode,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2006-07-05 00:06:00 +07:00
|
|
|
static const struct file_operations acpi_thermal_polling_fops = {
|
2005-08-05 11:44:28 +07:00
|
|
|
.open = acpi_thermal_polling_open_fs,
|
|
|
|
.read = seq_read,
|
|
|
|
.write = acpi_thermal_write_polling,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Thermal Zone Management
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
tz->last_temperature = tz->temperature;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
|
|
|
|
tz->temperature));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->polling_frequency);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
|
|
|
|
tz->polling_frequency));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
tz->polling_frequency = seconds * 10; /* Convert value to deci-seconds */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Polling frequency set to %lu seconds\n",
|
2007-02-16 13:24:43 +07:00
|
|
|
tz->polling_frequency/10));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
union acpi_object arg0 = { ACPI_TYPE_INTEGER };
|
|
|
|
struct acpi_object_list arg_list = { 1, &arg0 };
|
|
|
|
acpi_handle handle = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-05-20 03:54:48 +07:00
|
|
|
status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
arg0.integer.value = mode;
|
|
|
|
|
|
|
|
status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
|
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
int i = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Critical Shutdown (required) */
|
|
|
|
|
2006-05-20 03:54:48 +07:00
|
|
|
status = acpi_evaluate_integer(tz->device->handle, "_CRT", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.critical.temperature);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
tz->trips.critical.flags.valid = 0;
|
2006-06-27 10:58:43 +07:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status, "No critical threshold"));
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-08-05 11:44:28 +07:00
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.critical.flags.valid = 1;
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Found critical threshold [%lu]\n",
|
|
|
|
tz->trips.critical.temperature));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-08-15 02:49:32 +07:00
|
|
|
if (tz->trips.critical.flags.valid == 1) {
|
|
|
|
if (crt == -1) {
|
|
|
|
tz->trips.critical.flags.valid = 0;
|
|
|
|
} else if (crt > 0) {
|
|
|
|
unsigned long crt_k = CELSIUS_TO_KELVIN(crt);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allow override to lower critical threshold
|
|
|
|
*/
|
|
|
|
if (crt_k < tz->trips.critical.temperature)
|
|
|
|
tz->trips.critical.temperature = crt_k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Critical Sleep (optional) */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_integer(tz->device->handle, "_HOT", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.hot.temperature);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
tz->trips.hot.flags.valid = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No hot threshold\n"));
|
2005-08-05 11:44:28 +07:00
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.hot.flags.valid = 1;
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found hot threshold [%lu]\n",
|
|
|
|
tz->trips.hot.temperature));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Passive: Processors (optional) */
|
|
|
|
|
2007-08-12 11:12:35 +07:00
|
|
|
if (psv == -1) {
|
|
|
|
status = AE_SUPPORT;
|
|
|
|
} else if (psv > 0) {
|
|
|
|
tz->trips.passive.temperature = CELSIUS_TO_KELVIN(psv);
|
|
|
|
status = AE_OK;
|
|
|
|
} else {
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle,
|
|
|
|
"_PSV", NULL, &tz->trips.passive.temperature);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No passive threshold\n"));
|
2005-08-05 11:44:28 +07:00
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.passive.flags.valid = 1;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_integer(tz->device->handle, "_TC1", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.passive.tc1);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_integer(tz->device->handle, "_TC2", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.passive.tc2);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_integer(tz->device->handle, "_TSP", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.passive.tsp);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_reference(tz->device->handle, "_PSL", NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.passive.devices);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
tz->trips.passive.flags.valid = 0;
|
|
|
|
|
|
|
|
if (!tz->trips.passive.flags.valid)
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX "Invalid passive threshold\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Found passive threshold [%lu]\n",
|
|
|
|
tz->trips.passive.temperature));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Active: Fans, etc. (optional) */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-12 11:12:54 +07:00
|
|
|
if (act == -1)
|
|
|
|
break; /* disable all active trip points */
|
|
|
|
|
|
|
|
status = acpi_evaluate_integer(tz->device->handle,
|
|
|
|
name, NULL, &tz->trips.active[i].temperature);
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
if (i == 0) /* no active trip points */
|
|
|
|
break;
|
|
|
|
if (act <= 0) /* no override requested */
|
|
|
|
break;
|
|
|
|
if (i == 1) { /* 1 trip point */
|
|
|
|
tz->trips.active[0].temperature =
|
|
|
|
CELSIUS_TO_KELVIN(act);
|
|
|
|
} else { /* multiple trips */
|
|
|
|
/*
|
|
|
|
* Don't allow override higher than
|
|
|
|
* the next higher trip point
|
|
|
|
*/
|
|
|
|
tz->trips.active[i - 1].temperature =
|
|
|
|
(tz->trips.active[i - 2].temperature <
|
|
|
|
CELSIUS_TO_KELVIN(act) ?
|
|
|
|
tz->trips.active[i - 2].temperature :
|
|
|
|
CELSIUS_TO_KELVIN(act));
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2007-08-12 11:12:54 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
name[2] = 'L';
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_reference(tz->device->handle, name, NULL,
|
2005-08-05 11:44:28 +07:00
|
|
|
&tz->trips.active[i].devices);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
tz->trips.active[i].flags.valid = 1;
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Found active threshold [%d]:[%lu]\n",
|
|
|
|
i, tz->trips.active[i].temperature));
|
|
|
|
} else
|
2006-06-27 10:58:43 +07:00
|
|
|
ACPI_EXCEPTION((AE_INFO, status,
|
|
|
|
"Invalid active threshold [%d]", i));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_get_devices(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
status =
|
2006-05-20 03:54:48 +07:00
|
|
|
acpi_evaluate_reference(tz->device->handle, "_TZD", NULL, &tz->devices);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_critical(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-08-12 11:12:44 +07:00
|
|
|
if (!tz || !tz->trips.critical.flags.valid || nocrt)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (tz->temperature >= tz->trips.critical.temperature) {
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX "Critical trip point\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.critical.flags.enabled = 1;
|
2005-08-05 11:44:28 +07:00
|
|
|
} else if (tz->trips.critical.flags.enabled)
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.critical.flags.enabled = 0;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
printk(KERN_EMERG
|
|
|
|
"Critical temperature reached (%ld C), shutting down.\n",
|
|
|
|
KELVIN_TO_CELSIUS(tz->temperature));
|
2007-08-24 02:20:26 +07:00
|
|
|
acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
|
2005-08-05 11:44:28 +07:00
|
|
|
tz->trips.critical.flags.enabled);
|
2007-08-23 00:24:31 +07:00
|
|
|
acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
|
|
|
|
tz->device->dev.bus_id,
|
|
|
|
ACPI_THERMAL_NOTIFY_CRITICAL,
|
|
|
|
tz->trips.critical.flags.enabled);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-18 08:37:02 +07:00
|
|
|
orderly_poweroff(true);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_hot(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-08-12 11:12:44 +07:00
|
|
|
if (!tz || !tz->trips.hot.flags.valid || nocrt)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (tz->temperature >= tz->trips.hot.temperature) {
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX "Hot trip point\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.hot.flags.enabled = 1;
|
2005-08-05 11:44:28 +07:00
|
|
|
} else if (tz->trips.hot.flags.enabled)
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.hot.flags.enabled = 0;
|
|
|
|
|
2007-08-24 02:20:26 +07:00
|
|
|
acpi_bus_generate_proc_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
|
2005-08-05 11:44:28 +07:00
|
|
|
tz->trips.hot.flags.enabled);
|
2007-08-23 00:24:31 +07:00
|
|
|
acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
|
|
|
|
tz->device->dev.bus_id,
|
|
|
|
ACPI_THERMAL_NOTIFY_HOT,
|
|
|
|
tz->trips.hot.flags.enabled);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* TBD: Call user-mode "sleep(S4)" function */
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2004-09-16 22:07:00 +07:00
|
|
|
static void acpi_thermal_passive(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2004-09-16 22:07:00 +07:00
|
|
|
int result = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct acpi_thermal_passive *passive = NULL;
|
2005-08-05 11:44:28 +07:00
|
|
|
int trend = 0;
|
|
|
|
int i = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz || !tz->trips.passive.flags.valid)
|
2004-09-16 22:07:00 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
passive = &(tz->trips.passive);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Above Trip?
|
|
|
|
* -----------
|
|
|
|
* Calculate the thermal trend (using the passive cooling equation)
|
|
|
|
* and modify the performance limit for all passive cooling devices
|
|
|
|
* accordingly. Note that we assume symmetry.
|
|
|
|
*/
|
|
|
|
if (tz->temperature >= passive->temperature) {
|
2005-08-05 11:44:28 +07:00
|
|
|
trend =
|
|
|
|
(passive->tc1 * (tz->temperature - tz->last_temperature)) +
|
|
|
|
(passive->tc2 * (tz->temperature - passive->temperature));
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"trend[%d]=(tc1[%lu]*(tmp[%lu]-last[%lu]))+(tc2[%lu]*(tmp[%lu]-psv[%lu]))\n",
|
|
|
|
trend, passive->tc1, tz->temperature,
|
|
|
|
tz->last_temperature, passive->tc2,
|
|
|
|
tz->temperature, passive->temperature));
|
2004-09-16 22:07:00 +07:00
|
|
|
passive->flags.enabled = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Heating up? */
|
|
|
|
if (trend > 0)
|
2005-08-05 11:44:28 +07:00
|
|
|
for (i = 0; i < passive->devices.count; i++)
|
|
|
|
acpi_processor_set_thermal_limit(passive->
|
|
|
|
devices.
|
|
|
|
handles[i],
|
|
|
|
ACPI_PROCESSOR_LIMIT_INCREMENT);
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Cooling off? */
|
2004-09-16 22:07:00 +07:00
|
|
|
else if (trend < 0) {
|
2005-08-05 11:44:28 +07:00
|
|
|
for (i = 0; i < passive->devices.count; i++)
|
2004-09-16 22:07:00 +07:00
|
|
|
/*
|
|
|
|
* assume that we are on highest
|
|
|
|
* freq/lowest thrott and can leave
|
|
|
|
* passive mode, even in error case
|
|
|
|
*/
|
|
|
|
if (!acpi_processor_set_thermal_limit
|
|
|
|
(passive->devices.handles[i],
|
|
|
|
ACPI_PROCESSOR_LIMIT_DECREMENT))
|
|
|
|
result = 0;
|
|
|
|
/*
|
|
|
|
* Leave cooling mode, even if the temp might
|
|
|
|
* higher than trip point This is because some
|
|
|
|
* machines might have long thermal polling
|
|
|
|
* frequencies (tsp) defined. We will fall back
|
|
|
|
* into passive mode in next cycle (probably quicker)
|
|
|
|
*/
|
|
|
|
if (result) {
|
|
|
|
passive->flags.enabled = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Disabling passive cooling, still above threshold,"
|
|
|
|
" but we are cooling down\n"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Below Trip?
|
|
|
|
* -----------
|
|
|
|
* Implement passive cooling hysteresis to slowly increase performance
|
|
|
|
* and avoid thrashing around the passive trip point. Note that we
|
|
|
|
* assume symmetry.
|
|
|
|
*/
|
2004-09-16 22:07:00 +07:00
|
|
|
if (!passive->flags.enabled)
|
|
|
|
return;
|
|
|
|
for (i = 0; i < passive->devices.count; i++)
|
|
|
|
if (!acpi_processor_set_thermal_limit
|
|
|
|
(passive->devices.handles[i],
|
|
|
|
ACPI_PROCESSOR_LIMIT_DECREMENT))
|
|
|
|
result = 0;
|
|
|
|
if (result) {
|
|
|
|
passive->flags.enabled = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Disabling passive cooling (zone is cool)\n"));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-16 22:07:00 +07:00
|
|
|
static void acpi_thermal_active(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct acpi_thermal_active *active = NULL;
|
2005-08-05 11:44:28 +07:00
|
|
|
int i = 0;
|
|
|
|
int j = 0;
|
|
|
|
unsigned long maxtemp = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2004-09-16 22:07:00 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
2005-04-17 05:20:36 +07:00
|
|
|
active = &(tz->trips.active[i]);
|
|
|
|
if (!active || !active->flags.valid)
|
|
|
|
break;
|
|
|
|
if (tz->temperature >= active->temperature) {
|
2004-09-16 22:07:00 +07:00
|
|
|
/*
|
|
|
|
* Above Threshold?
|
|
|
|
* ----------------
|
|
|
|
* If not already enabled, turn ON all cooling devices
|
|
|
|
* associated with this active threshold.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
if (active->temperature > maxtemp)
|
2004-09-16 22:07:00 +07:00
|
|
|
tz->state.active_index = i;
|
|
|
|
maxtemp = active->temperature;
|
|
|
|
if (active->flags.enabled)
|
|
|
|
continue;
|
2005-04-17 05:20:36 +07:00
|
|
|
for (j = 0; j < active->devices.count; j++) {
|
2005-08-05 11:44:28 +07:00
|
|
|
result =
|
|
|
|
acpi_bus_set_power(active->devices.
|
|
|
|
handles[j],
|
2004-09-16 22:07:00 +07:00
|
|
|
ACPI_STATE_D0);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (result) {
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX
|
|
|
|
"Unable to turn cooling device [%p] 'on'\n",
|
2006-06-27 10:58:43 +07:00
|
|
|
active->devices.
|
2006-06-27 10:04:31 +07:00
|
|
|
handles[j]);
|
2005-04-17 05:20:36 +07:00
|
|
|
continue;
|
|
|
|
}
|
2004-09-16 22:07:00 +07:00
|
|
|
active->flags.enabled = 1;
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2004-09-16 22:07:00 +07:00
|
|
|
"Cooling device [%p] now 'on'\n",
|
2005-08-05 11:44:28 +07:00
|
|
|
active->devices.handles[j]));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2004-09-16 22:07:00 +07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!active->flags.enabled)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* Below Threshold?
|
|
|
|
* ----------------
|
|
|
|
* Turn OFF all cooling devices associated with this
|
|
|
|
* threshold.
|
|
|
|
*/
|
|
|
|
for (j = 0; j < active->devices.count; j++) {
|
|
|
|
result = acpi_bus_set_power(active->devices.handles[j],
|
|
|
|
ACPI_STATE_D3);
|
|
|
|
if (result) {
|
2006-06-27 10:04:31 +07:00
|
|
|
printk(KERN_WARNING PREFIX
|
|
|
|
"Unable to turn cooling device [%p] 'off'\n",
|
|
|
|
active->devices.handles[j]);
|
2004-09-16 22:07:00 +07:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
active->flags.enabled = 0;
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
|
|
|
"Cooling device [%p] now 'off'\n",
|
|
|
|
active->devices.handles[j]));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static void acpi_thermal_check(void *context);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static void acpi_thermal_run(unsigned long data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = (struct acpi_thermal *)data;
|
|
|
|
if (!tz->zombie)
|
2006-05-05 14:23:00 +07:00
|
|
|
acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static void acpi_thermal_check(void *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = data;
|
2005-08-05 11:44:28 +07:00
|
|
|
unsigned long sleep_time = 0;
|
2007-09-04 23:49:22 +07:00
|
|
|
unsigned long timeout_jiffies = 0;
|
2005-08-05 11:44:28 +07:00
|
|
|
int i = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct acpi_thermal_state state;
|
|
|
|
|
|
|
|
|
|
|
|
if (!tz) {
|
2006-06-27 10:41:38 +07:00
|
|
|
printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-09-01 03:11:59 +07:00
|
|
|
/* Check if someone else is already running */
|
|
|
|
if (!mutex_trylock(&tz->lock))
|
|
|
|
return;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
state = tz->state;
|
|
|
|
|
|
|
|
result = acpi_thermal_get_temperature(tz);
|
|
|
|
if (result)
|
2007-09-01 03:11:59 +07:00
|
|
|
goto unlock;
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
memset(&tz->state, 0, sizeof(tz->state));
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Check Trip Points
|
|
|
|
* -----------------
|
|
|
|
* Compare the current temperature to the trip point values to see
|
|
|
|
* if we've entered one of the thermal policy states. Note that
|
|
|
|
* this function determines when a state is entered, but the
|
|
|
|
* individual policy decides when it is exited (e.g. hysteresis).
|
|
|
|
*/
|
|
|
|
if (tz->trips.critical.flags.valid)
|
2005-08-05 11:44:28 +07:00
|
|
|
state.critical |=
|
|
|
|
(tz->temperature >= tz->trips.critical.temperature);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (tz->trips.hot.flags.valid)
|
|
|
|
state.hot |= (tz->temperature >= tz->trips.hot.temperature);
|
|
|
|
if (tz->trips.passive.flags.valid)
|
2005-08-05 11:44:28 +07:00
|
|
|
state.passive |=
|
|
|
|
(tz->temperature >= tz->trips.passive.temperature);
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
|
2005-04-17 05:20:36 +07:00
|
|
|
if (tz->trips.active[i].flags.valid)
|
2005-08-05 11:44:28 +07:00
|
|
|
state.active |=
|
|
|
|
(tz->temperature >=
|
|
|
|
tz->trips.active[i].temperature);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Invoke Policy
|
|
|
|
* -------------
|
|
|
|
* Separated from the above check to allow individual policy to
|
|
|
|
* determine when to exit a given state.
|
|
|
|
*/
|
|
|
|
if (state.critical)
|
|
|
|
acpi_thermal_critical(tz);
|
|
|
|
if (state.hot)
|
|
|
|
acpi_thermal_hot(tz);
|
|
|
|
if (state.passive)
|
|
|
|
acpi_thermal_passive(tz);
|
|
|
|
if (state.active)
|
|
|
|
acpi_thermal_active(tz);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate State
|
|
|
|
* ---------------
|
|
|
|
* Again, separated from the above two to allow independent policy
|
|
|
|
* decisions.
|
|
|
|
*/
|
2004-09-16 22:07:00 +07:00
|
|
|
tz->state.critical = tz->trips.critical.flags.enabled;
|
|
|
|
tz->state.hot = tz->trips.hot.flags.enabled;
|
|
|
|
tz->state.passive = tz->trips.passive.flags.enabled;
|
|
|
|
tz->state.active = 0;
|
2005-08-05 11:44:28 +07:00
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
|
2004-09-16 22:07:00 +07:00
|
|
|
tz->state.active |= tz->trips.active[i].flags.enabled;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate Sleep Time
|
|
|
|
* --------------------
|
|
|
|
* If we're in the passive state, use _TSP's value. Otherwise
|
|
|
|
* use the default polling frequency (e.g. _TZP). If no polling
|
|
|
|
* frequency is specified then we'll wait forever (at least until
|
|
|
|
* a thermal event occurs). Note that _TSP and _TZD values are
|
|
|
|
* given in 1/10th seconds (we must covert to milliseconds).
|
|
|
|
*/
|
2007-09-04 23:49:22 +07:00
|
|
|
if (tz->state.passive) {
|
2005-04-17 05:20:36 +07:00
|
|
|
sleep_time = tz->trips.passive.tsp * 100;
|
2007-09-04 23:49:22 +07:00
|
|
|
timeout_jiffies = jiffies + (HZ * sleep_time) / 1000;
|
|
|
|
} else if (tz->polling_frequency > 0) {
|
2005-04-17 05:20:36 +07:00
|
|
|
sleep_time = tz->polling_frequency * 100;
|
2007-09-04 23:49:22 +07:00
|
|
|
timeout_jiffies = round_jiffies(jiffies + (HZ * sleep_time) / 1000);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
|
|
|
|
tz->name, tz->temperature, sleep_time));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Schedule Next Poll
|
|
|
|
* ------------------
|
|
|
|
*/
|
|
|
|
if (!sleep_time) {
|
|
|
|
if (timer_pending(&(tz->timer)))
|
|
|
|
del_timer(&(tz->timer));
|
2005-08-05 11:44:28 +07:00
|
|
|
} else {
|
2005-04-17 05:20:36 +07:00
|
|
|
if (timer_pending(&(tz->timer)))
|
2007-09-04 23:49:22 +07:00
|
|
|
mod_timer(&(tz->timer), timeout_jiffies);
|
2005-04-17 05:20:36 +07:00
|
|
|
else {
|
2005-08-05 11:44:28 +07:00
|
|
|
tz->timer.data = (unsigned long)tz;
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->timer.function = acpi_thermal_run;
|
2007-09-04 23:49:22 +07:00
|
|
|
tz->timer.expires = timeout_jiffies;
|
2005-04-17 05:20:36 +07:00
|
|
|
add_timer(&(tz->timer));
|
|
|
|
}
|
|
|
|
}
|
2007-09-01 03:11:59 +07:00
|
|
|
unlock:
|
|
|
|
mutex_unlock(&tz->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
FS Interface (/proc)
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static struct proc_dir_entry *acpi_thermal_dir;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = seq->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
seq_puts(seq, "state: ");
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
if (!tz->state.critical && !tz->state.hot && !tz->state.passive
|
|
|
|
&& !tz->state.active)
|
2005-04-17 05:20:36 +07:00
|
|
|
seq_puts(seq, "ok\n");
|
|
|
|
else {
|
|
|
|
if (tz->state.critical)
|
|
|
|
seq_puts(seq, "critical ");
|
|
|
|
if (tz->state.hot)
|
|
|
|
seq_puts(seq, "hot ");
|
|
|
|
if (tz->state.passive)
|
|
|
|
seq_puts(seq, "passive ");
|
|
|
|
if (tz->state.active)
|
|
|
|
seq_printf(seq, "active[%d]", tz->state.active_index);
|
|
|
|
seq_puts(seq, "\n");
|
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
end:
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = seq->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
result = acpi_thermal_get_temperature(tz);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
seq_printf(seq, "temperature: %ld C\n",
|
|
|
|
KELVIN_TO_CELSIUS(tz->temperature));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
end:
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = seq->private;
|
2006-11-20 05:01:40 +07:00
|
|
|
struct acpi_device *device;
|
2007-06-18 11:40:51 +07:00
|
|
|
acpi_status status;
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
int i = 0;
|
|
|
|
int j = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (tz->trips.critical.flags.valid)
|
2007-08-12 11:12:44 +07:00
|
|
|
seq_printf(seq, "critical (S5): %ld C%s",
|
|
|
|
KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
|
|
|
|
nocrt ? " <disabled>\n" : "\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (tz->trips.hot.flags.valid)
|
2007-08-12 11:12:44 +07:00
|
|
|
seq_printf(seq, "hot (S4): %ld C%s",
|
|
|
|
KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
|
|
|
|
nocrt ? " <disabled>\n" : "\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (tz->trips.passive.flags.valid) {
|
2005-08-05 11:44:28 +07:00
|
|
|
seq_printf(seq,
|
|
|
|
"passive: %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
|
|
|
|
KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
|
|
|
|
tz->trips.passive.tc1, tz->trips.passive.tc2,
|
|
|
|
tz->trips.passive.tsp);
|
|
|
|
for (j = 0; j < tz->trips.passive.devices.count; j++) {
|
2007-06-18 11:40:51 +07:00
|
|
|
status = acpi_bus_get_device(tz->trips.passive.devices.
|
|
|
|
handles[j], &device);
|
|
|
|
seq_printf(seq, "%4.4s ", status ? "" :
|
|
|
|
acpi_device_bid(device));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
seq_puts(seq, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
|
|
|
if (!(tz->trips.active[i].flags.valid))
|
|
|
|
break;
|
|
|
|
seq_printf(seq, "active[%d]: %ld C: devices=",
|
2005-08-05 11:44:28 +07:00
|
|
|
i,
|
|
|
|
KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
|
2006-11-20 05:01:40 +07:00
|
|
|
for (j = 0; j < tz->trips.active[i].devices.count; j++){
|
2007-06-18 11:40:51 +07:00
|
|
|
status = acpi_bus_get_device(tz->trips.active[i].
|
|
|
|
devices.handles[j],
|
|
|
|
&device);
|
|
|
|
seq_printf(seq, "%4.4s ", status ? "" :
|
|
|
|
acpi_device_bid(device));
|
2006-11-20 05:01:40 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
seq_puts(seq, "\n");
|
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
end:
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = seq->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
goto end;
|
|
|
|
|
2007-05-01 10:27:43 +07:00
|
|
|
if (!tz->flags.cooling_mode)
|
2005-04-17 05:20:36 +07:00
|
|
|
seq_puts(seq, "<setting not supported>\n");
|
|
|
|
else
|
2007-05-01 10:27:43 +07:00
|
|
|
seq_puts(seq, "0 - Active; 1 - Passive\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
end:
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, acpi_thermal_cooling_seq_show,
|
2005-08-05 11:44:28 +07:00
|
|
|
PDE(inode)->data);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_thermal_write_cooling_mode(struct file *file,
|
|
|
|
const char __user * buffer,
|
|
|
|
size_t count, loff_t * ppos)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct acpi_thermal *tz = m->private;
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
|
|
|
char mode_string[12] = { '\0' };
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz || (count > sizeof(mode_string) - 1))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (!tz->flags.cooling_mode)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (copy_from_user(mode_string, buffer, count))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EFAULT;
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
mode_string[count] = '\0';
|
2005-08-05 11:44:28 +07:00
|
|
|
|
|
|
|
result = acpi_thermal_set_cooling_mode(tz,
|
|
|
|
simple_strtoul(mode_string, NULL,
|
|
|
|
0));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (result)
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
acpi_thermal_check(tz);
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return count;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
|
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = seq->private;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
if (!tz->polling_frequency) {
|
|
|
|
seq_puts(seq, "<polling disabled>\n");
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_printf(seq, "polling frequency: %lu seconds\n",
|
2005-08-05 11:44:28 +07:00
|
|
|
(tz->polling_frequency / 10));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
end:
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return single_open(file, acpi_thermal_polling_seq_show,
|
2005-08-05 11:44:28 +07:00
|
|
|
PDE(inode)->data);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_thermal_write_polling(struct file *file,
|
|
|
|
const char __user * buffer,
|
|
|
|
size_t count, loff_t * ppos)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
struct acpi_thermal *tz = m->private;
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
|
|
|
char polling_string[12] = { '\0' };
|
|
|
|
int seconds = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz || (count > sizeof(polling_string) - 1))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (copy_from_user(polling_string, buffer, count))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EFAULT;
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
polling_string[count] = '\0';
|
|
|
|
|
|
|
|
seconds = simple_strtoul(polling_string, NULL, 0);
|
2005-08-05 11:44:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
result = acpi_thermal_set_polling(tz, seconds);
|
|
|
|
if (result)
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
acpi_thermal_check(tz);
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return count;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_add_fs(struct acpi_device *device)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
struct proc_dir_entry *entry = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!acpi_device_dir(device)) {
|
|
|
|
acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_thermal_dir);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!acpi_device_dir(device))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
acpi_device_dir(device)->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 'state' [R] */
|
|
|
|
entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
|
2005-08-05 11:44:28 +07:00
|
|
|
S_IRUGO, acpi_device_dir(device));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!entry)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
else {
|
|
|
|
entry->proc_fops = &acpi_thermal_state_fops;
|
|
|
|
entry->data = acpi_driver_data(device);
|
|
|
|
entry->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 'temperature' [R] */
|
|
|
|
entry = create_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
|
2005-08-05 11:44:28 +07:00
|
|
|
S_IRUGO, acpi_device_dir(device));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!entry)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
else {
|
|
|
|
entry->proc_fops = &acpi_thermal_temp_fops;
|
|
|
|
entry->data = acpi_driver_data(device);
|
|
|
|
entry->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
2007-08-24 16:45:50 +07:00
|
|
|
/* 'trip_points' [R] */
|
2005-04-17 05:20:36 +07:00
|
|
|
entry = create_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
|
2007-08-24 16:45:50 +07:00
|
|
|
S_IRUGO,
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_device_dir(device));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!entry)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
else {
|
|
|
|
entry->proc_fops = &acpi_thermal_trip_fops;
|
|
|
|
entry->data = acpi_driver_data(device);
|
|
|
|
entry->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 'cooling_mode' [R/W] */
|
|
|
|
entry = create_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
|
2005-08-05 11:44:28 +07:00
|
|
|
S_IFREG | S_IRUGO | S_IWUSR,
|
|
|
|
acpi_device_dir(device));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!entry)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
else {
|
|
|
|
entry->proc_fops = &acpi_thermal_cooling_fops;
|
|
|
|
entry->data = acpi_driver_data(device);
|
|
|
|
entry->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 'polling_frequency' [R/W] */
|
|
|
|
entry = create_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
|
2005-08-05 11:44:28 +07:00
|
|
|
S_IFREG | S_IRUGO | S_IWUSR,
|
|
|
|
acpi_device_dir(device));
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!entry)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
else {
|
|
|
|
entry->proc_fops = &acpi_thermal_polling_fops;
|
|
|
|
entry->data = acpi_driver_data(device);
|
|
|
|
entry->owner = THIS_MODULE;
|
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_remove_fs(struct acpi_device *device)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
|
|
|
|
if (acpi_device_dir(device)) {
|
|
|
|
remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
|
|
|
|
acpi_device_dir(device));
|
|
|
|
remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
|
|
|
|
acpi_device_dir(device));
|
|
|
|
remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
|
|
|
|
acpi_device_dir(device));
|
|
|
|
remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
|
|
|
|
acpi_device_dir(device));
|
|
|
|
remove_proc_entry(ACPI_THERMAL_FILE_STATE,
|
|
|
|
acpi_device_dir(device));
|
|
|
|
remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
|
|
|
|
acpi_device_dir(device) = NULL;
|
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------
|
|
|
|
Driver Interface
|
|
|
|
-------------------------------------------------------------------------- */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2006-10-01 05:28:50 +07:00
|
|
|
struct acpi_thermal *tz = data;
|
2005-08-05 11:44:28 +07:00
|
|
|
struct acpi_device *device = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-05-20 03:54:40 +07:00
|
|
|
device = tz->device;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case ACPI_THERMAL_NOTIFY_TEMPERATURE:
|
|
|
|
acpi_thermal_check(tz);
|
|
|
|
break;
|
|
|
|
case ACPI_THERMAL_NOTIFY_THRESHOLDS:
|
|
|
|
acpi_thermal_get_trip_points(tz);
|
|
|
|
acpi_thermal_check(tz);
|
2007-08-24 02:20:26 +07:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-23 00:24:31 +07:00
|
|
|
acpi_bus_generate_netlink_event(device->pnp.device_class,
|
|
|
|
device->dev.bus_id, event, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case ACPI_THERMAL_NOTIFY_DEVICES:
|
|
|
|
if (tz->flags.devices)
|
|
|
|
acpi_thermal_get_devices(tz);
|
2007-08-24 02:20:26 +07:00
|
|
|
acpi_bus_generate_proc_event(device, event, 0);
|
2007-08-23 00:24:31 +07:00
|
|
|
acpi_bus_generate_netlink_event(device->pnp.device_class,
|
|
|
|
device->dev.bus_id, event, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
|
2005-08-05 11:44:28 +07:00
|
|
|
"Unsupported event [0x%x]\n", event));
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_get_info(struct acpi_thermal *tz)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Get temperature [_TMP] (required) */
|
|
|
|
result = acpi_thermal_get_temperature(tz);
|
|
|
|
if (result)
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Get trip points [_CRT, _PSV, etc.] (required) */
|
|
|
|
result = acpi_thermal_get_trip_points(tz);
|
|
|
|
if (result)
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Set the cooling mode [_SCP] to active cooling (default) */
|
|
|
|
result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
|
2005-08-05 11:44:28 +07:00
|
|
|
if (!result)
|
2005-04-17 05:20:36 +07: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);
|
|
|
|
|
|
|
|
/* Get devices in this thermal zone [_TZD] (optional) */
|
|
|
|
result = acpi_thermal_get_devices(tz);
|
|
|
|
if (!result)
|
|
|
|
tz->flags.devices = 1;
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_add(struct acpi_device *device)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
struct acpi_thermal *tz = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!device)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-20 03:56:11 +07:00
|
|
|
tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!tz)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENOMEM;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-05-20 03:54:40 +07:00
|
|
|
tz->device = device;
|
2005-04-17 05:20:36 +07: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);
|
|
|
|
acpi_driver_data(device) = tz;
|
2007-09-01 03:11:59 +07:00
|
|
|
mutex_init(&tz->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
result = acpi_thermal_get_info(tz);
|
|
|
|
if (result)
|
|
|
|
goto end;
|
|
|
|
|
|
|
|
result = acpi_thermal_add_fs(device);
|
|
|
|
if (result)
|
2006-04-27 16:25:00 +07:00
|
|
|
goto end;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
init_timer(&tz->timer);
|
|
|
|
|
|
|
|
acpi_thermal_check(tz);
|
|
|
|
|
2006-05-20 03:54:48 +07:00
|
|
|
status = acpi_install_notify_handler(device->handle,
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_thermal_notify, tz);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
result = -ENODEV;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_device_name(device), acpi_device_bid(device),
|
|
|
|
KELVIN_TO_CELSIUS(tz->temperature));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
end:
|
2005-04-17 05:20:36 +07:00
|
|
|
if (result) {
|
|
|
|
acpi_thermal_remove_fs(device);
|
|
|
|
kfree(tz);
|
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return result;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int acpi_thermal_remove(struct acpi_device *device, int type)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
acpi_status status = AE_OK;
|
|
|
|
struct acpi_thermal *tz = NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-10-01 05:28:50 +07:00
|
|
|
tz = acpi_driver_data(device);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* avoid timer adding new defer task */
|
|
|
|
tz->zombie = 1;
|
|
|
|
/* wait for running timer (on other CPUs) finish */
|
|
|
|
del_timer_sync(&(tz->timer));
|
|
|
|
/* synchronize deferred task */
|
|
|
|
acpi_os_wait_events_complete(NULL);
|
|
|
|
/* deferred task may reinsert timer */
|
|
|
|
del_timer_sync(&(tz->timer));
|
|
|
|
|
2006-05-20 03:54:48 +07:00
|
|
|
status = acpi_remove_notify_handler(device->handle,
|
2005-08-05 11:44:28 +07:00
|
|
|
ACPI_DEVICE_NOTIFY,
|
|
|
|
acpi_thermal_notify);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Terminate policy */
|
2005-08-05 11:44:28 +07:00
|
|
|
if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.passive.flags.enabled = 0;
|
|
|
|
acpi_thermal_passive(tz);
|
|
|
|
}
|
|
|
|
if (tz->trips.active[0].flags.valid
|
2005-08-05 11:44:28 +07:00
|
|
|
&& tz->trips.active[0].flags.enabled) {
|
2005-04-17 05:20:36 +07:00
|
|
|
tz->trips.active[0].flags.enabled = 0;
|
|
|
|
acpi_thermal_active(tz);
|
|
|
|
}
|
|
|
|
|
|
|
|
acpi_thermal_remove_fs(device);
|
2007-09-01 03:11:59 +07:00
|
|
|
mutex_destroy(&tz->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(tz);
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-12-07 19:56:27 +07:00
|
|
|
static int acpi_thermal_resume(struct acpi_device *device)
|
2006-05-08 19:32:00 +07:00
|
|
|
{
|
|
|
|
struct acpi_thermal *tz = NULL;
|
2007-02-16 14:23:07 +07:00
|
|
|
int i, j, power_state, result;
|
|
|
|
|
2006-05-08 19:32:00 +07:00
|
|
|
|
|
|
|
if (!device || !acpi_driver_data(device))
|
2006-06-27 11:41:40 +07:00
|
|
|
return -EINVAL;
|
2006-05-08 19:32:00 +07:00
|
|
|
|
2006-10-01 05:28:50 +07:00
|
|
|
tz = acpi_driver_data(device);
|
2006-05-08 19:32:00 +07:00
|
|
|
|
2006-07-10 18:44:26 +07:00
|
|
|
for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
|
2007-02-16 14: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++) {
|
|
|
|
result = acpi_bus_get_power(tz->trips.active[i].devices.
|
|
|
|
handles[j], &power_state);
|
|
|
|
if (result || (power_state != ACPI_STATE_D0)) {
|
|
|
|
tz->trips.active[i].flags.enabled = 0;
|
|
|
|
break;
|
|
|
|
}
|
2006-07-10 18:44:26 +07:00
|
|
|
}
|
2007-02-16 14:23:07 +07:00
|
|
|
tz->state.active |= tz->trips.active[i].flags.enabled;
|
2006-07-10 18:44:26 +07:00
|
|
|
}
|
|
|
|
|
2007-02-16 14:23:07 +07:00
|
|
|
acpi_thermal_check(tz);
|
2006-05-08 19:32:00 +07:00
|
|
|
|
|
|
|
return AE_OK;
|
|
|
|
}
|
|
|
|
|
2007-08-12 11:13:02 +07:00
|
|
|
#ifdef CONFIG_DMI
|
2007-10-04 02:15:40 +07:00
|
|
|
static int thermal_act(const struct dmi_system_id *d) {
|
2007-08-12 11:13:02 +07:00
|
|
|
|
|
|
|
if (act == 0) {
|
|
|
|
printk(KERN_NOTICE "ACPI: %s detected: "
|
|
|
|
"disabling all active thermal trip points\n", d->ident);
|
|
|
|
act = -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-10-04 02:15:40 +07:00
|
|
|
static int thermal_nocrt(const struct dmi_system_id *d) {
|
2007-08-21 05:46:50 +07:00
|
|
|
|
|
|
|
printk(KERN_NOTICE "ACPI: %s detected: "
|
|
|
|
"disabling all critical thermal trip point actions.\n", d->ident);
|
|
|
|
nocrt = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-10-04 02:15:40 +07:00
|
|
|
static int thermal_tzp(const struct dmi_system_id *d) {
|
2007-08-12 11:13:02 +07:00
|
|
|
|
|
|
|
if (tzp == 0) {
|
|
|
|
printk(KERN_NOTICE "ACPI: %s detected: "
|
|
|
|
"enabling thermal zone polling\n", d->ident);
|
|
|
|
tzp = 300; /* 300 dS = 30 Seconds */
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-10-04 02:15:40 +07:00
|
|
|
static int thermal_psv(const struct dmi_system_id *d) {
|
2007-08-12 11:13:02 +07:00
|
|
|
|
|
|
|
if (psv == 0) {
|
|
|
|
printk(KERN_NOTICE "ACPI: %s detected: "
|
|
|
|
"disabling all passive thermal trip points\n", d->ident);
|
|
|
|
psv = -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dmi_system_id thermal_dmi_table[] __initdata = {
|
|
|
|
/*
|
|
|
|
* 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-21 05:46:50 +07: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-12 11:13:02 +07:00
|
|
|
{}
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_DMI */
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static int __init acpi_thermal_init(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-08-05 11:44:28 +07:00
|
|
|
int result = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-08-12 11:13:02 +07:00
|
|
|
dmi_check_system(thermal_dmi_table);
|
|
|
|
|
2007-08-12 11:12:17 +07:00
|
|
|
if (off) {
|
|
|
|
printk(KERN_NOTICE "ACPI: thermal control disabled\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
|
|
|
|
if (!acpi_thermal_dir)
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
acpi_thermal_dir->owner = THIS_MODULE;
|
|
|
|
|
|
|
|
result = acpi_bus_register_driver(&acpi_thermal_driver);
|
|
|
|
if (result < 0) {
|
|
|
|
remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
|
2006-06-27 11:41:40 +07:00
|
|
|
return -ENODEV;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2005-08-05 11:44:28 +07:00
|
|
|
static void __exit acpi_thermal_exit(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
|
|
|
|
acpi_bus_unregister_driver(&acpi_thermal_driver);
|
|
|
|
|
|
|
|
remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
|
|
|
|
|
2006-06-27 11:41:40 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(acpi_thermal_init);
|
|
|
|
module_exit(acpi_thermal_exit);
|