thermal.c 36.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/*
 *  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>
36
#include <linux/dmi.h>
L
Linus Torvalds 已提交
37 38 39
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
40 41
#include <linux/timer.h>
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
42 43
#include <linux/kmod.h>
#include <linux/seq_file.h>
44
#include <linux/reboot.h>
L
Linus Torvalds 已提交
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
#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
72
ACPI_MODULE_NAME("thermal");
L
Linus Torvalds 已提交
73

74
MODULE_AUTHOR("Paul Diefenbaugh");
75
MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
L
Linus Torvalds 已提交
76 77
MODULE_LICENSE("GPL");

78 79
static int act;
module_param(act, int, 0644);
80
MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
81

82 83 84 85
static int crt;
module_param(crt, int, 0644);
MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");

L
Linus Torvalds 已提交
86
static int tzp;
87
module_param(tzp, int, 0444);
88
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
L
Linus Torvalds 已提交
89

90 91
static int nocrt;
module_param(nocrt, int, 0);
92
MODULE_PARM_DESC(nocrt, "Set to disable action on ACPI thermal zone critical and hot trips.");
93

94 95
static int off;
module_param(off, int, 0);
96
MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
97

98 99
static int psv;
module_param(psv, int, 0644);
100
MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
101

L
Len Brown 已提交
102 103
static int acpi_thermal_add(struct acpi_device *device);
static int acpi_thermal_remove(struct acpi_device *device, int type);
104
static int acpi_thermal_resume(struct acpi_device *device);
L
Linus Torvalds 已提交
105 106 107 108
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);
L
Len Brown 已提交
109 110 111
static ssize_t acpi_thermal_write_cooling_mode(struct file *,
					       const char __user *, size_t,
					       loff_t *);
L
Linus Torvalds 已提交
112
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
113 114
static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
					  size_t, loff_t *);
L
Linus Torvalds 已提交
115

116 117 118 119 120 121
static const struct acpi_device_id  thermal_device_ids[] = {
	{ACPI_THERMAL_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, thermal_device_ids);

L
Linus Torvalds 已提交
122
static struct acpi_driver acpi_thermal_driver = {
L
Len Brown 已提交
123
	.name = "thermal",
L
Len Brown 已提交
124
	.class = ACPI_THERMAL_CLASS,
125
	.ids = thermal_device_ids,
L
Len Brown 已提交
126 127 128
	.ops = {
		.add = acpi_thermal_add,
		.remove = acpi_thermal_remove,
129
		.resume = acpi_thermal_resume,
L
Len Brown 已提交
130
		},
L
Linus Torvalds 已提交
131 132 133
};

struct acpi_thermal_state {
L
Len Brown 已提交
134 135 136 137 138 139
	u8 critical:1;
	u8 hot:1;
	u8 passive:1;
	u8 active:1;
	u8 reserved:4;
	int active_index;
L
Linus Torvalds 已提交
140 141 142
};

struct acpi_thermal_state_flags {
L
Len Brown 已提交
143 144 145
	u8 valid:1;
	u8 enabled:1;
	u8 reserved:6;
L
Linus Torvalds 已提交
146 147 148 149
};

struct acpi_thermal_critical {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
150
	unsigned long temperature;
L
Linus Torvalds 已提交
151 152 153 154
};

struct acpi_thermal_hot {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
155
	unsigned long temperature;
L
Linus Torvalds 已提交
156 157 158 159
};

struct acpi_thermal_passive {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
160 161 162 163 164
	unsigned long temperature;
	unsigned long tc1;
	unsigned long tc2;
	unsigned long tsp;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
165 166 167 168
};

struct acpi_thermal_active {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
169 170
	unsigned long temperature;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
171 172 173 174
};

struct acpi_thermal_trips {
	struct acpi_thermal_critical critical;
L
Len Brown 已提交
175
	struct acpi_thermal_hot hot;
L
Linus Torvalds 已提交
176 177 178 179 180
	struct acpi_thermal_passive passive;
	struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
};

struct acpi_thermal_flags {
L
Len Brown 已提交
181 182 183
	u8 cooling_mode:1;	/* _SCP */
	u8 devices:1;		/* _TZD */
	u8 reserved:6;
L
Linus Torvalds 已提交
184 185 186
};

struct acpi_thermal {
187
	struct acpi_device * device;
L
Len Brown 已提交
188 189 190 191 192
	acpi_bus_id name;
	unsigned long temperature;
	unsigned long last_temperature;
	unsigned long polling_frequency;
	volatile u8 zombie;
L
Linus Torvalds 已提交
193 194 195
	struct acpi_thermal_flags flags;
	struct acpi_thermal_state state;
	struct acpi_thermal_trips trips;
L
Len Brown 已提交
196 197
	struct acpi_handle_list devices;
	struct timer_list timer;
L
Linus Torvalds 已提交
198 199
};

200
static const struct file_operations acpi_thermal_state_fops = {
L
Len Brown 已提交
201 202 203 204
	.open = acpi_thermal_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
205 206
};

207
static const struct file_operations acpi_thermal_temp_fops = {
L
Len Brown 已提交
208 209 210 211
	.open = acpi_thermal_temp_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
212 213
};

214
static const struct file_operations acpi_thermal_trip_fops = {
L
Len Brown 已提交
215 216 217 218
	.open = acpi_thermal_trip_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
219 220
};

221
static const struct file_operations acpi_thermal_cooling_fops = {
L
Len Brown 已提交
222 223 224 225 226
	.open = acpi_thermal_cooling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_cooling_mode,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
227 228
};

229
static const struct file_operations acpi_thermal_polling_fops = {
L
Len Brown 已提交
230 231 232 233 234
	.open = acpi_thermal_polling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_polling,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
235 236 237 238 239 240
};

/* --------------------------------------------------------------------------
                             Thermal Zone Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
241
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
242
{
L
Len Brown 已提交
243
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
244 245 246


	if (!tz)
247
		return -EINVAL;
L
Linus Torvalds 已提交
248 249 250

	tz->last_temperature = tz->temperature;

L
Len Brown 已提交
251
	status =
252
	    acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
L
Linus Torvalds 已提交
253
	if (ACPI_FAILURE(status))
254
		return -ENODEV;
L
Linus Torvalds 已提交
255

L
Len Brown 已提交
256 257
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
			  tz->temperature));
L
Linus Torvalds 已提交
258

259
	return 0;
L
Linus Torvalds 已提交
260 261
}

L
Len Brown 已提交
262
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
263
{
L
Len Brown 已提交
264
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
265 266 267


	if (!tz)
268
		return -EINVAL;
L
Linus Torvalds 已提交
269

L
Len Brown 已提交
270
	status =
271
	    acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
L
Len Brown 已提交
272
				  &tz->polling_frequency);
L
Linus Torvalds 已提交
273
	if (ACPI_FAILURE(status))
274
		return -ENODEV;
L
Linus Torvalds 已提交
275

L
Len Brown 已提交
276 277
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
			  tz->polling_frequency));
L
Linus Torvalds 已提交
278

279
	return 0;
L
Linus Torvalds 已提交
280 281
}

L
Len Brown 已提交
282
static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
L
Linus Torvalds 已提交
283 284 285
{

	if (!tz)
286
		return -EINVAL;
L
Linus Torvalds 已提交
287 288 289

	tz->polling_frequency = seconds * 10;	/* Convert value to deci-seconds */

L
Len Brown 已提交
290 291
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Polling frequency set to %lu seconds\n",
292
			  tz->polling_frequency/10));
L
Linus Torvalds 已提交
293

294
	return 0;
L
Linus Torvalds 已提交
295 296
}

L
Len Brown 已提交
297
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
L
Linus Torvalds 已提交
298
{
L
Len Brown 已提交
299 300 301 302
	acpi_status status = AE_OK;
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &arg0 };
	acpi_handle handle = NULL;
L
Linus Torvalds 已提交
303 304 305


	if (!tz)
306
		return -EINVAL;
L
Linus Torvalds 已提交
307

308
	status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
L
Linus Torvalds 已提交
309 310
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
311
		return -ENODEV;
L
Linus Torvalds 已提交
312 313 314 315 316 317
	}

	arg0.integer.value = mode;

	status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
	if (ACPI_FAILURE(status))
318
		return -ENODEV;
L
Linus Torvalds 已提交
319

320
	return 0;
L
Linus Torvalds 已提交
321 322
}

L
Len Brown 已提交
323
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
324
{
L
Len Brown 已提交
325 326
	acpi_status status = AE_OK;
	int i = 0;
L
Linus Torvalds 已提交
327 328 329


	if (!tz)
330
		return -EINVAL;
L
Linus Torvalds 已提交
331 332 333

	/* Critical Shutdown (required) */

334
	status = acpi_evaluate_integer(tz->device->handle, "_CRT", NULL,
L
Len Brown 已提交
335
				       &tz->trips.critical.temperature);
L
Linus Torvalds 已提交
336 337
	if (ACPI_FAILURE(status)) {
		tz->trips.critical.flags.valid = 0;
338
		ACPI_EXCEPTION((AE_INFO, status, "No critical threshold"));
339
		return -ENODEV;
L
Len Brown 已提交
340
	} else {
L
Linus Torvalds 已提交
341
		tz->trips.critical.flags.valid = 1;
L
Len Brown 已提交
342 343 344
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Found critical threshold [%lu]\n",
				  tz->trips.critical.temperature));
L
Linus Torvalds 已提交
345 346
	}

347 348 349 350 351 352 353 354 355 356 357 358 359 360
	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;
		}
	}

L
Linus Torvalds 已提交
361 362
	/* Critical Sleep (optional) */

L
Len Brown 已提交
363
	status =
364
	    acpi_evaluate_integer(tz->device->handle, "_HOT", NULL,
L
Len Brown 已提交
365
				  &tz->trips.hot.temperature);
L
Linus Torvalds 已提交
366 367 368
	if (ACPI_FAILURE(status)) {
		tz->trips.hot.flags.valid = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No hot threshold\n"));
L
Len Brown 已提交
369
	} else {
L
Linus Torvalds 已提交
370
		tz->trips.hot.flags.valid = 1;
L
Len Brown 已提交
371 372
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found hot threshold [%lu]\n",
				  tz->trips.hot.temperature));
L
Linus Torvalds 已提交
373 374 375 376
	}

	/* Passive: Processors (optional) */

377 378 379 380 381 382 383 384 385 386
	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);
	}

L
Linus Torvalds 已提交
387 388 389
	if (ACPI_FAILURE(status)) {
		tz->trips.passive.flags.valid = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No passive threshold\n"));
L
Len Brown 已提交
390
	} else {
L
Linus Torvalds 已提交
391 392
		tz->trips.passive.flags.valid = 1;

L
Len Brown 已提交
393
		status =
394
		    acpi_evaluate_integer(tz->device->handle, "_TC1", NULL,
L
Len Brown 已提交
395
					  &tz->trips.passive.tc1);
L
Linus Torvalds 已提交
396 397 398
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
399
		status =
400
		    acpi_evaluate_integer(tz->device->handle, "_TC2", NULL,
L
Len Brown 已提交
401
					  &tz->trips.passive.tc2);
L
Linus Torvalds 已提交
402 403 404
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
405
		status =
406
		    acpi_evaluate_integer(tz->device->handle, "_TSP", NULL,
L
Len Brown 已提交
407
					  &tz->trips.passive.tsp);
L
Linus Torvalds 已提交
408 409 410
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
411
		status =
412
		    acpi_evaluate_reference(tz->device->handle, "_PSL", NULL,
L
Len Brown 已提交
413
					    &tz->trips.passive.devices);
L
Linus Torvalds 已提交
414 415 416 417
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

		if (!tz->trips.passive.flags.valid)
418
			printk(KERN_WARNING PREFIX "Invalid passive threshold\n");
L
Linus Torvalds 已提交
419
		else
L
Len Brown 已提交
420 421 422
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Found passive threshold [%lu]\n",
					  tz->trips.passive.temperature));
L
Linus Torvalds 已提交
423 424 425 426
	}

	/* Active: Fans, etc. (optional) */

L
Len Brown 已提交
427
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
L
Linus Torvalds 已提交
428

L
Len Brown 已提交
429
		char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
L
Linus Torvalds 已提交
430

431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
		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));
			}
L
Linus Torvalds 已提交
456
			break;
457
		}
L
Linus Torvalds 已提交
458 459

		name[2] = 'L';
L
Len Brown 已提交
460
		status =
461
		    acpi_evaluate_reference(tz->device->handle, name, NULL,
L
Len Brown 已提交
462
					    &tz->trips.active[i].devices);
L
Linus Torvalds 已提交
463 464
		if (ACPI_SUCCESS(status)) {
			tz->trips.active[i].flags.valid = 1;
L
Len Brown 已提交
465 466 467 468
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Found active threshold [%d]:[%lu]\n",
					  i, tz->trips.active[i].temperature));
		} else
469 470
			ACPI_EXCEPTION((AE_INFO, status,
					"Invalid active threshold [%d]", i));
L
Linus Torvalds 已提交
471 472
	}

473
	return 0;
L
Linus Torvalds 已提交
474 475
}

L
Len Brown 已提交
476
static int acpi_thermal_get_devices(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
477
{
L
Len Brown 已提交
478
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
479 480 481


	if (!tz)
482
		return -EINVAL;
L
Linus Torvalds 已提交
483

L
Len Brown 已提交
484
	status =
485
	    acpi_evaluate_reference(tz->device->handle, "_TZD", NULL, &tz->devices);
L
Linus Torvalds 已提交
486
	if (ACPI_FAILURE(status))
487
		return -ENODEV;
L
Linus Torvalds 已提交
488

489
	return 0;
L
Linus Torvalds 已提交
490 491
}

L
Len Brown 已提交
492
static int acpi_thermal_critical(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
493
{
494
	if (!tz || !tz->trips.critical.flags.valid || nocrt)
495
		return -EINVAL;
L
Linus Torvalds 已提交
496 497

	if (tz->temperature >= tz->trips.critical.temperature) {
498
		printk(KERN_WARNING PREFIX "Critical trip point\n");
L
Linus Torvalds 已提交
499
		tz->trips.critical.flags.enabled = 1;
L
Len Brown 已提交
500
	} else if (tz->trips.critical.flags.enabled)
L
Linus Torvalds 已提交
501 502
		tz->trips.critical.flags.enabled = 0;

L
Len Brown 已提交
503 504 505
	printk(KERN_EMERG
	       "Critical temperature reached (%ld C), shutting down.\n",
	       KELVIN_TO_CELSIUS(tz->temperature));
506
	acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
L
Len Brown 已提交
507
				tz->trips.critical.flags.enabled);
L
Linus Torvalds 已提交
508

509
	orderly_poweroff(true);
L
Linus Torvalds 已提交
510

511
	return 0;
L
Linus Torvalds 已提交
512 513
}

L
Len Brown 已提交
514
static int acpi_thermal_hot(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
515
{
516
	if (!tz || !tz->trips.hot.flags.valid || nocrt)
517
		return -EINVAL;
L
Linus Torvalds 已提交
518 519

	if (tz->temperature >= tz->trips.hot.temperature) {
520
		printk(KERN_WARNING PREFIX "Hot trip point\n");
L
Linus Torvalds 已提交
521
		tz->trips.hot.flags.enabled = 1;
L
Len Brown 已提交
522
	} else if (tz->trips.hot.flags.enabled)
L
Linus Torvalds 已提交
523 524
		tz->trips.hot.flags.enabled = 0;

525
	acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
L
Len Brown 已提交
526
				tz->trips.hot.flags.enabled);
L
Linus Torvalds 已提交
527 528 529

	/* TBD: Call user-mode "sleep(S4)" function */

530
	return 0;
L
Linus Torvalds 已提交
531 532
}

533
static void acpi_thermal_passive(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
534
{
535
	int result = 1;
L
Linus Torvalds 已提交
536
	struct acpi_thermal_passive *passive = NULL;
L
Len Brown 已提交
537 538
	int trend = 0;
	int i = 0;
L
Linus Torvalds 已提交
539 540 541


	if (!tz || !tz->trips.passive.flags.valid)
542
		return;
L
Linus Torvalds 已提交
543 544 545 546 547 548 549 550 551 552 553

	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) {
L
Len Brown 已提交
554 555 556 557 558 559 560 561
		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));
562
		passive->flags.enabled = 1;
L
Linus Torvalds 已提交
563 564
		/* Heating up? */
		if (trend > 0)
L
Len Brown 已提交
565 566 567 568 569
			for (i = 0; i < passive->devices.count; i++)
				acpi_processor_set_thermal_limit(passive->
								 devices.
								 handles[i],
								 ACPI_PROCESSOR_LIMIT_INCREMENT);
L
Linus Torvalds 已提交
570
		/* Cooling off? */
571
		else if (trend < 0) {
L
Len Brown 已提交
572
			for (i = 0; i < passive->devices.count; i++)
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
				/*
				 * 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;
L
Linus Torvalds 已提交
597 598 599 600 601 602 603 604 605
	}

	/*
	 * Below Trip?
	 * -----------
	 * Implement passive cooling hysteresis to slowly increase performance
	 * and avoid thrashing around the passive trip point.  Note that we
	 * assume symmetry.
	 */
606 607 608 609 610 611 612 613 614 615 616
	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"));
L
Linus Torvalds 已提交
617 618 619
	}
}

620
static void acpi_thermal_active(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
621
{
L
Len Brown 已提交
622
	int result = 0;
L
Linus Torvalds 已提交
623
	struct acpi_thermal_active *active = NULL;
L
Len Brown 已提交
624 625 626
	int i = 0;
	int j = 0;
	unsigned long maxtemp = 0;
L
Linus Torvalds 已提交
627 628 629


	if (!tz)
630
		return;
L
Linus Torvalds 已提交
631

L
Len Brown 已提交
632
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
L
Linus Torvalds 已提交
633 634 635 636
		active = &(tz->trips.active[i]);
		if (!active || !active->flags.valid)
			break;
		if (tz->temperature >= active->temperature) {
637 638 639 640 641 642
			/*
			 * Above Threshold?
			 * ----------------
			 * If not already enabled, turn ON all cooling devices
			 * associated with this active threshold.
			 */
L
Linus Torvalds 已提交
643
			if (active->temperature > maxtemp)
644 645 646 647
				tz->state.active_index = i;
			maxtemp = active->temperature;
			if (active->flags.enabled)
				continue;
L
Linus Torvalds 已提交
648
			for (j = 0; j < active->devices.count; j++) {
L
Len Brown 已提交
649 650 651
				result =
				    acpi_bus_set_power(active->devices.
						       handles[j],
652
						       ACPI_STATE_D0);
L
Linus Torvalds 已提交
653
				if (result) {
654 655
					printk(KERN_WARNING PREFIX
						      "Unable to turn cooling device [%p] 'on'\n",
656
						      active->devices.
657
						      handles[j]);
L
Linus Torvalds 已提交
658 659
					continue;
				}
660
				active->flags.enabled = 1;
L
Len Brown 已提交
661
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
662
						  "Cooling device [%p] now 'on'\n",
L
Len Brown 已提交
663
						  active->devices.handles[j]));
L
Linus Torvalds 已提交
664
			}
665 666 667 668 669 670 671 672 673 674 675 676 677 678
			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) {
679 680 681
				printk(KERN_WARNING PREFIX
					      "Unable to turn cooling device [%p] 'off'\n",
					      active->devices.handles[j]);
682 683 684 685 686 687
				continue;
			}
			active->flags.enabled = 0;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Cooling device [%p] now 'off'\n",
					  active->devices.handles[j]));
L
Linus Torvalds 已提交
688 689 690 691
		}
	}
}

L
Len Brown 已提交
692
static void acpi_thermal_check(void *context);
L
Linus Torvalds 已提交
693

L
Len Brown 已提交
694
static void acpi_thermal_run(unsigned long data)
L
Linus Torvalds 已提交
695 696 697
{
	struct acpi_thermal *tz = (struct acpi_thermal *)data;
	if (!tz->zombie)
698
		acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
L
Linus Torvalds 已提交
699 700
}

L
Len Brown 已提交
701
static void acpi_thermal_check(void *data)
L
Linus Torvalds 已提交
702
{
L
Len Brown 已提交
703
	int result = 0;
704
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
705 706
	unsigned long sleep_time = 0;
	int i = 0;
L
Linus Torvalds 已提交
707 708 709 710
	struct acpi_thermal_state state;


	if (!tz) {
711
		printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
712
		return;
L
Linus Torvalds 已提交
713 714 715 716 717 718
	}

	state = tz->state;

	result = acpi_thermal_get_temperature(tz);
	if (result)
719
		return;
L
Len Brown 已提交
720

L
Linus Torvalds 已提交
721
	memset(&tz->state, 0, sizeof(tz->state));
L
Len Brown 已提交
722

L
Linus Torvalds 已提交
723 724 725 726 727 728 729 730 731
	/*
	 * 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)
L
Len Brown 已提交
732 733
		state.critical |=
		    (tz->temperature >= tz->trips.critical.temperature);
L
Linus Torvalds 已提交
734 735 736
	if (tz->trips.hot.flags.valid)
		state.hot |= (tz->temperature >= tz->trips.hot.temperature);
	if (tz->trips.passive.flags.valid)
L
Len Brown 已提交
737 738 739
		state.passive |=
		    (tz->temperature >= tz->trips.passive.temperature);
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
L
Linus Torvalds 已提交
740
		if (tz->trips.active[i].flags.valid)
L
Len Brown 已提交
741 742 743
			state.active |=
			    (tz->temperature >=
			     tz->trips.active[i].temperature);
L
Linus Torvalds 已提交
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

	/*
	 * 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.
	 */
766 767 768 769
	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;
L
Len Brown 已提交
770
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
771
		tz->state.active |= tz->trips.active[i].flags.enabled;
L
Linus Torvalds 已提交
772 773 774 775 776 777 778 779 780 781 782 783 784 785 786

	/*
	 * 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).
	 */
	if (tz->state.passive)
		sleep_time = tz->trips.passive.tsp * 100;
	else if (tz->polling_frequency > 0)
		sleep_time = tz->polling_frequency * 100;

L
Len Brown 已提交
787 788
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
			  tz->name, tz->temperature, sleep_time));
L
Linus Torvalds 已提交
789 790 791 792 793 794 795 796

	/*
	 * Schedule Next Poll
	 * ------------------
	 */
	if (!sleep_time) {
		if (timer_pending(&(tz->timer)))
			del_timer(&(tz->timer));
L
Len Brown 已提交
797
	} else {
L
Linus Torvalds 已提交
798
		if (timer_pending(&(tz->timer)))
799 800
			mod_timer(&(tz->timer),
					jiffies + (HZ * sleep_time) / 1000);
L
Linus Torvalds 已提交
801
		else {
L
Len Brown 已提交
802
			tz->timer.data = (unsigned long)tz;
L
Linus Torvalds 已提交
803 804 805 806 807 808
			tz->timer.function = acpi_thermal_run;
			tz->timer.expires = jiffies + (HZ * sleep_time) / 1000;
			add_timer(&(tz->timer));
		}
	}

809
	return;
L
Linus Torvalds 已提交
810 811 812 813 814 815
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
816
static struct proc_dir_entry *acpi_thermal_dir;
L
Linus Torvalds 已提交
817 818 819

static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
{
820
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
821 822 823 824 825 826 827


	if (!tz)
		goto end;

	seq_puts(seq, "state:                   ");

L
Len Brown 已提交
828 829
	if (!tz->state.critical && !tz->state.hot && !tz->state.passive
	    && !tz->state.active)
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837 838 839 840 841 842
		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");
	}

L
Len Brown 已提交
843
      end:
844
	return 0;
L
Linus Torvalds 已提交
845 846 847 848 849 850 851 852 853
}

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)
{
L
Len Brown 已提交
854
	int result = 0;
855
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
856 857 858 859 860 861 862 863 864


	if (!tz)
		goto end;

	result = acpi_thermal_get_temperature(tz);
	if (result)
		goto end;

L
Len Brown 已提交
865 866
	seq_printf(seq, "temperature:             %ld C\n",
		   KELVIN_TO_CELSIUS(tz->temperature));
L
Linus Torvalds 已提交
867

L
Len Brown 已提交
868
      end:
869
	return 0;
L
Linus Torvalds 已提交
870 871 872 873 874 875 876 877 878
}

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)
{
879
	struct acpi_thermal *tz = seq->private;
880
	struct acpi_device *device;
881 882
	acpi_status status;

L
Len Brown 已提交
883 884
	int i = 0;
	int j = 0;
L
Linus Torvalds 已提交
885 886 887 888 889 890


	if (!tz)
		goto end;

	if (tz->trips.critical.flags.valid)
891 892 893
		seq_printf(seq, "critical (S5):           %ld C%s",
			   KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
			   nocrt ? " <disabled>\n" : "\n");
L
Linus Torvalds 已提交
894 895

	if (tz->trips.hot.flags.valid)
896 897 898
		seq_printf(seq, "hot (S4):                %ld C%s",
			   KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
			   nocrt ? " <disabled>\n" : "\n");
L
Linus Torvalds 已提交
899 900

	if (tz->trips.passive.flags.valid) {
L
Len Brown 已提交
901 902 903 904 905 906
		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++) {
907 908 909 910
			status = acpi_bus_get_device(tz->trips.passive.devices.
						     handles[j], &device);
			seq_printf(seq, "%4.4s ", status ? "" :
				   acpi_device_bid(device));
L
Linus Torvalds 已提交
911 912 913 914 915 916 917 918
		}
		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=",
L
Len Brown 已提交
919 920
			   i,
			   KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
921
		for (j = 0; j < tz->trips.active[i].devices.count; j++){
922 923 924 925 926
			status = acpi_bus_get_device(tz->trips.active[i].
						     devices.handles[j],
						     &device);
			seq_printf(seq, "%4.4s ", status ? "" :
				   acpi_device_bid(device));
927
		}
L
Linus Torvalds 已提交
928 929 930
		seq_puts(seq, "\n");
	}

L
Len Brown 已提交
931
      end:
932
	return 0;
L
Linus Torvalds 已提交
933 934 935 936 937 938 939 940 941
}

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)
{
942
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
943 944 945 946 947


	if (!tz)
		goto end;

948
	if (!tz->flags.cooling_mode)
L
Linus Torvalds 已提交
949 950
		seq_puts(seq, "<setting not supported>\n");
	else
951
		seq_puts(seq, "0 - Active; 1 - Passive\n");
L
Linus Torvalds 已提交
952

L
Len Brown 已提交
953
      end:
954
	return 0;
L
Linus Torvalds 已提交
955 956 957 958 959
}

static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_cooling_seq_show,
L
Len Brown 已提交
960
			   PDE(inode)->data);
L
Linus Torvalds 已提交
961 962 963
}

static ssize_t
L
Len Brown 已提交
964 965 966
acpi_thermal_write_cooling_mode(struct file *file,
				const char __user * buffer,
				size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
967
{
968 969
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
970 971
	int result = 0;
	char mode_string[12] = { '\0' };
L
Linus Torvalds 已提交
972 973 974


	if (!tz || (count > sizeof(mode_string) - 1))
975
		return -EINVAL;
L
Linus Torvalds 已提交
976 977

	if (!tz->flags.cooling_mode)
978
		return -ENODEV;
L
Linus Torvalds 已提交
979 980

	if (copy_from_user(mode_string, buffer, count))
981
		return -EFAULT;
L
Len Brown 已提交
982

L
Linus Torvalds 已提交
983
	mode_string[count] = '\0';
L
Len Brown 已提交
984 985 986 987

	result = acpi_thermal_set_cooling_mode(tz,
					       simple_strtoul(mode_string, NULL,
							      0));
L
Linus Torvalds 已提交
988
	if (result)
989
		return result;
L
Linus Torvalds 已提交
990 991 992

	acpi_thermal_check(tz);

993
	return count;
L
Linus Torvalds 已提交
994 995 996 997
}

static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
{
998
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009


	if (!tz)
		goto end;

	if (!tz->polling_frequency) {
		seq_puts(seq, "<polling disabled>\n");
		goto end;
	}

	seq_printf(seq, "polling frequency:       %lu seconds\n",
L
Len Brown 已提交
1010
		   (tz->polling_frequency / 10));
L
Linus Torvalds 已提交
1011

L
Len Brown 已提交
1012
      end:
1013
	return 0;
L
Linus Torvalds 已提交
1014 1015 1016 1017 1018
}

static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_polling_seq_show,
L
Len Brown 已提交
1019
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1020 1021 1022
}

static ssize_t
L
Len Brown 已提交
1023 1024 1025
acpi_thermal_write_polling(struct file *file,
			   const char __user * buffer,
			   size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
1026
{
1027 1028
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
1029 1030 1031
	int result = 0;
	char polling_string[12] = { '\0' };
	int seconds = 0;
L
Linus Torvalds 已提交
1032 1033 1034


	if (!tz || (count > sizeof(polling_string) - 1))
1035
		return -EINVAL;
L
Len Brown 已提交
1036

L
Linus Torvalds 已提交
1037
	if (copy_from_user(polling_string, buffer, count))
1038
		return -EFAULT;
L
Len Brown 已提交
1039

L
Linus Torvalds 已提交
1040 1041 1042
	polling_string[count] = '\0';

	seconds = simple_strtoul(polling_string, NULL, 0);
L
Len Brown 已提交
1043

L
Linus Torvalds 已提交
1044 1045
	result = acpi_thermal_set_polling(tz, seconds);
	if (result)
1046
		return result;
L
Linus Torvalds 已提交
1047 1048 1049

	acpi_thermal_check(tz);

1050
	return count;
L
Linus Torvalds 已提交
1051 1052
}

L
Len Brown 已提交
1053
static int acpi_thermal_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1054
{
L
Len Brown 已提交
1055
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
1056 1057 1058 1059


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
1060
						     acpi_thermal_dir);
L
Linus Torvalds 已提交
1061
		if (!acpi_device_dir(device))
1062
			return -ENODEV;
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067
		acpi_device_dir(device)->owner = THIS_MODULE;
	}

	/* 'state' [R] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
L
Len Brown 已提交
1068
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1069
	if (!entry)
1070
		return -ENODEV;
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075 1076 1077 1078
	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,
L
Len Brown 已提交
1079
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1080
	if (!entry)
1081
		return -ENODEV;
L
Linus Torvalds 已提交
1082 1083 1084 1085 1086 1087 1088 1089
	else {
		entry->proc_fops = &acpi_thermal_temp_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'trip_points' [R/W] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
L
Len Brown 已提交
1090 1091
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1092
	if (!entry)
1093
		return -ENODEV;
L
Linus Torvalds 已提交
1094 1095 1096 1097 1098 1099 1100 1101
	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,
L
Len Brown 已提交
1102 1103
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1104
	if (!entry)
1105
		return -ENODEV;
L
Linus Torvalds 已提交
1106 1107 1108 1109 1110 1111 1112 1113
	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,
L
Len Brown 已提交
1114 1115
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1116
	if (!entry)
1117
		return -ENODEV;
L
Linus Torvalds 已提交
1118 1119 1120 1121 1122 1123
	else {
		entry->proc_fops = &acpi_thermal_polling_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

1124
	return 0;
L
Linus Torvalds 已提交
1125 1126
}

L
Len Brown 已提交
1127
static int acpi_thermal_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
{

	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;
	}

1145
	return 0;
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151
}

/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
1152
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1153
{
1154
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
1155
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
1156 1157 1158


	if (!tz)
1159
		return;
L
Linus Torvalds 已提交
1160

1161
	device = tz->device;
L
Linus Torvalds 已提交
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178

	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);
		acpi_bus_generate_event(device, event, 0);
		break;
	case ACPI_THERMAL_NOTIFY_DEVICES:
		if (tz->flags.devices)
			acpi_thermal_get_devices(tz);
		acpi_bus_generate_event(device, event, 0);
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1179
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1180 1181 1182
		break;
	}

1183
	return;
L
Linus Torvalds 已提交
1184 1185
}

L
Len Brown 已提交
1186
static int acpi_thermal_get_info(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
1187
{
L
Len Brown 已提交
1188
	int result = 0;
L
Linus Torvalds 已提交
1189 1190 1191


	if (!tz)
1192
		return -EINVAL;
L
Linus Torvalds 已提交
1193 1194 1195 1196

	/* Get temperature [_TMP] (required) */
	result = acpi_thermal_get_temperature(tz);
	if (result)
1197
		return result;
L
Linus Torvalds 已提交
1198 1199 1200 1201

	/* Get trip points [_CRT, _PSV, etc.] (required) */
	result = acpi_thermal_get_trip_points(tz);
	if (result)
1202
		return result;
L
Linus Torvalds 已提交
1203 1204 1205

	/* Set the cooling mode [_SCP] to active cooling (default) */
	result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
L
Len Brown 已提交
1206
	if (!result)
L
Linus Torvalds 已提交
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
		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;

1220
	return 0;
L
Linus Torvalds 已提交
1221 1222
}

L
Len Brown 已提交
1223
static int acpi_thermal_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1224
{
L
Len Brown 已提交
1225 1226 1227
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1228 1229 1230


	if (!device)
1231
		return -EINVAL;
L
Linus Torvalds 已提交
1232

1233
	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
L
Linus Torvalds 已提交
1234
	if (!tz)
1235
		return -ENOMEM;
L
Linus Torvalds 已提交
1236

1237
	tz->device = device;
L
Linus Torvalds 已提交
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
	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;

	result = acpi_thermal_get_info(tz);
	if (result)
		goto end;

	result = acpi_thermal_add_fs(device);
	if (result)
1249
		goto end;
L
Linus Torvalds 已提交
1250 1251 1252 1253 1254

	init_timer(&tz->timer);

	acpi_thermal_check(tz);

1255
	status = acpi_install_notify_handler(device->handle,
L
Len Brown 已提交
1256 1257
					     ACPI_DEVICE_NOTIFY,
					     acpi_thermal_notify, tz);
L
Linus Torvalds 已提交
1258 1259 1260 1261 1262 1263
	if (ACPI_FAILURE(status)) {
		result = -ENODEV;
		goto end;
	}

	printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
L
Len Brown 已提交
1264 1265
	       acpi_device_name(device), acpi_device_bid(device),
	       KELVIN_TO_CELSIUS(tz->temperature));
L
Linus Torvalds 已提交
1266

L
Len Brown 已提交
1267
      end:
L
Linus Torvalds 已提交
1268 1269 1270 1271 1272
	if (result) {
		acpi_thermal_remove_fs(device);
		kfree(tz);
	}

1273
	return result;
L
Linus Torvalds 已提交
1274 1275
}

L
Len Brown 已提交
1276
static int acpi_thermal_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
1277
{
L
Len Brown 已提交
1278 1279
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1280 1281 1282


	if (!device || !acpi_driver_data(device))
1283
		return -EINVAL;
L
Linus Torvalds 已提交
1284

1285
	tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295

	/* 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));

1296
	status = acpi_remove_notify_handler(device->handle,
L
Len Brown 已提交
1297 1298
					    ACPI_DEVICE_NOTIFY,
					    acpi_thermal_notify);
L
Linus Torvalds 已提交
1299 1300

	/* Terminate policy */
L
Len Brown 已提交
1301
	if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
L
Linus Torvalds 已提交
1302 1303 1304 1305
		tz->trips.passive.flags.enabled = 0;
		acpi_thermal_passive(tz);
	}
	if (tz->trips.active[0].flags.valid
L
Len Brown 已提交
1306
	    && tz->trips.active[0].flags.enabled) {
L
Linus Torvalds 已提交
1307 1308 1309 1310 1311 1312 1313
		tz->trips.active[0].flags.enabled = 0;
		acpi_thermal_active(tz);
	}

	acpi_thermal_remove_fs(device);

	kfree(tz);
1314
	return 0;
L
Linus Torvalds 已提交
1315 1316
}

1317
static int acpi_thermal_resume(struct acpi_device *device)
1318 1319
{
	struct acpi_thermal *tz = NULL;
1320 1321
	int i, j, power_state, result;

1322 1323

	if (!device || !acpi_driver_data(device))
1324
		return -EINVAL;
1325

1326
	tz = acpi_driver_data(device);
1327

1328
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
		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;
			}
1341
		}
1342
		tz->state.active |= tz->trips.active[i].flags.enabled;
1343 1344
	}

1345
	acpi_thermal_check(tz);
1346 1347 1348 1349

	return AE_OK;
}

1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
#ifdef CONFIG_DMI
static int thermal_act(struct dmi_system_id *d) {

	if (act == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"disabling all active thermal trip points\n", d->ident);
		act = -1;
	}
	return 0;
}
static int thermal_tzp(struct dmi_system_id *d) {

	if (tzp == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"enabling thermal zone polling\n", d->ident);
		tzp = 300;	/* 300 dS = 30 Seconds */
	}
	return 0;
}
static int thermal_psv(struct dmi_system_id *d) {

	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"),
		},
	},
	{}
};
#endif /* CONFIG_DMI */

L
Len Brown 已提交
1412
static int __init acpi_thermal_init(void)
L
Linus Torvalds 已提交
1413
{
L
Len Brown 已提交
1414
	int result = 0;
L
Linus Torvalds 已提交
1415

1416 1417
	dmi_check_system(thermal_dmi_table);

1418 1419 1420 1421
	if (off) {
		printk(KERN_NOTICE "ACPI: thermal control disabled\n");
		return -ENODEV;
	}
L
Linus Torvalds 已提交
1422 1423
	acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
	if (!acpi_thermal_dir)
1424
		return -ENODEV;
L
Linus Torvalds 已提交
1425 1426 1427 1428 1429
	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);
1430
		return -ENODEV;
L
Linus Torvalds 已提交
1431 1432
	}

1433
	return 0;
L
Linus Torvalds 已提交
1434 1435
}

L
Len Brown 已提交
1436
static void __exit acpi_thermal_exit(void)
L
Linus Torvalds 已提交
1437 1438 1439 1440 1441 1442
{

	acpi_bus_unregister_driver(&acpi_thermal_driver);

	remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);

1443
	return;
L
Linus Torvalds 已提交
1444 1445 1446 1447
}

module_init(acpi_thermal_init);
module_exit(acpi_thermal_exit);