thermal.c 34.0 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 36 37 38
/*
 *  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>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
39 40
#include <linux/timer.h>
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
41 42 43 44 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 72
#include <linux/kmod.h>
#include <linux/seq_file.h>
#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_MODE_PASSIVE	0x01
#define ACPI_THERMAL_MODE_CRITICAL   	0xff
#define ACPI_THERMAL_PATH_POWEROFF	"/sbin/poweroff"

#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
73
ACPI_MODULE_NAME("thermal");
L
Linus Torvalds 已提交
74

75
MODULE_AUTHOR("Paul Diefenbaugh");
76
MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
L
Linus Torvalds 已提交
77 78 79 80 81 82
MODULE_LICENSE("GPL");

static int tzp;
module_param(tzp, int, 0);
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.\n");

L
Len Brown 已提交
83 84
static int acpi_thermal_add(struct acpi_device *device);
static int acpi_thermal_remove(struct acpi_device *device, int type);
85
static int acpi_thermal_resume(struct acpi_device *device);
L
Linus Torvalds 已提交
86 87 88 89
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 已提交
90 91 92
static ssize_t acpi_thermal_write_cooling_mode(struct file *,
					       const char __user *, size_t,
					       loff_t *);
L
Linus Torvalds 已提交
93
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
94 95
static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
					  size_t, loff_t *);
L
Linus Torvalds 已提交
96 97

static struct acpi_driver acpi_thermal_driver = {
L
Len Brown 已提交
98
	.name = "thermal",
L
Len Brown 已提交
99 100 101 102 103
	.class = ACPI_THERMAL_CLASS,
	.ids = ACPI_THERMAL_HID,
	.ops = {
		.add = acpi_thermal_add,
		.remove = acpi_thermal_remove,
104
		.resume = acpi_thermal_resume,
L
Len Brown 已提交
105
		},
L
Linus Torvalds 已提交
106 107 108
};

struct acpi_thermal_state {
L
Len Brown 已提交
109 110 111 112 113 114
	u8 critical:1;
	u8 hot:1;
	u8 passive:1;
	u8 active:1;
	u8 reserved:4;
	int active_index;
L
Linus Torvalds 已提交
115 116 117
};

struct acpi_thermal_state_flags {
L
Len Brown 已提交
118 119 120
	u8 valid:1;
	u8 enabled:1;
	u8 reserved:6;
L
Linus Torvalds 已提交
121 122 123 124
};

struct acpi_thermal_critical {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
125
	unsigned long temperature;
L
Linus Torvalds 已提交
126 127 128 129
};

struct acpi_thermal_hot {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
130
	unsigned long temperature;
L
Linus Torvalds 已提交
131 132 133 134
};

struct acpi_thermal_passive {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
135 136 137 138 139
	unsigned long temperature;
	unsigned long tc1;
	unsigned long tc2;
	unsigned long tsp;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
140 141 142 143
};

struct acpi_thermal_active {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
144 145
	unsigned long temperature;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
146 147 148 149
};

struct acpi_thermal_trips {
	struct acpi_thermal_critical critical;
L
Len Brown 已提交
150
	struct acpi_thermal_hot hot;
L
Linus Torvalds 已提交
151 152 153 154 155
	struct acpi_thermal_passive passive;
	struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
};

struct acpi_thermal_flags {
L
Len Brown 已提交
156 157 158
	u8 cooling_mode:1;	/* _SCP */
	u8 devices:1;		/* _TZD */
	u8 reserved:6;
L
Linus Torvalds 已提交
159 160 161
};

struct acpi_thermal {
162
	struct acpi_device * device;
L
Len Brown 已提交
163 164 165 166 167 168
	acpi_bus_id name;
	unsigned long temperature;
	unsigned long last_temperature;
	unsigned long polling_frequency;
	u8 cooling_mode;
	volatile u8 zombie;
L
Linus Torvalds 已提交
169 170 171
	struct acpi_thermal_flags flags;
	struct acpi_thermal_state state;
	struct acpi_thermal_trips trips;
L
Len Brown 已提交
172 173
	struct acpi_handle_list devices;
	struct timer_list timer;
L
Linus Torvalds 已提交
174 175
};

176
static const struct file_operations acpi_thermal_state_fops = {
L
Len Brown 已提交
177 178 179 180
	.open = acpi_thermal_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
181 182
};

183
static const struct file_operations acpi_thermal_temp_fops = {
L
Len Brown 已提交
184 185 186 187
	.open = acpi_thermal_temp_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
188 189
};

190
static const struct file_operations acpi_thermal_trip_fops = {
L
Len Brown 已提交
191 192 193 194
	.open = acpi_thermal_trip_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
195 196
};

197
static const struct file_operations acpi_thermal_cooling_fops = {
L
Len Brown 已提交
198 199 200 201 202
	.open = acpi_thermal_cooling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_cooling_mode,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
203 204
};

205
static const struct file_operations acpi_thermal_polling_fops = {
L
Len Brown 已提交
206 207 208 209 210
	.open = acpi_thermal_polling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_polling,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
211 212 213 214 215 216
};

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

L
Len Brown 已提交
217
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
218
{
L
Len Brown 已提交
219
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
220 221 222


	if (!tz)
223
		return -EINVAL;
L
Linus Torvalds 已提交
224 225 226

	tz->last_temperature = tz->temperature;

L
Len Brown 已提交
227
	status =
228
	    acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
L
Linus Torvalds 已提交
229
	if (ACPI_FAILURE(status))
230
		return -ENODEV;
L
Linus Torvalds 已提交
231

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

235
	return 0;
L
Linus Torvalds 已提交
236 237
}

L
Len Brown 已提交
238
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
239
{
L
Len Brown 已提交
240
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
241 242 243


	if (!tz)
244
		return -EINVAL;
L
Linus Torvalds 已提交
245

L
Len Brown 已提交
246
	status =
247
	    acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
L
Len Brown 已提交
248
				  &tz->polling_frequency);
L
Linus Torvalds 已提交
249
	if (ACPI_FAILURE(status))
250
		return -ENODEV;
L
Linus Torvalds 已提交
251

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

255
	return 0;
L
Linus Torvalds 已提交
256 257
}

L
Len Brown 已提交
258
static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
L
Linus Torvalds 已提交
259 260 261
{

	if (!tz)
262
		return -EINVAL;
L
Linus Torvalds 已提交
263 264 265

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

L
Len Brown 已提交
266 267
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Polling frequency set to %lu seconds\n",
268
			  tz->polling_frequency/10));
L
Linus Torvalds 已提交
269

270
	return 0;
L
Linus Torvalds 已提交
271 272
}

L
Len Brown 已提交
273
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
L
Linus Torvalds 已提交
274
{
L
Len Brown 已提交
275 276 277 278
	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 已提交
279 280 281


	if (!tz)
282
		return -EINVAL;
L
Linus Torvalds 已提交
283

284
	status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
L
Linus Torvalds 已提交
285 286
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
287
		return -ENODEV;
L
Linus Torvalds 已提交
288 289 290 291 292 293
	}

	arg0.integer.value = mode;

	status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
	if (ACPI_FAILURE(status))
294
		return -ENODEV;
L
Linus Torvalds 已提交
295 296 297

	tz->cooling_mode = mode;

L
Len Brown 已提交
298 299
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling mode [%s]\n",
			  mode ? "passive" : "active"));
L
Linus Torvalds 已提交
300

301
	return 0;
L
Linus Torvalds 已提交
302 303
}

L
Len Brown 已提交
304
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
305
{
L
Len Brown 已提交
306 307
	acpi_status status = AE_OK;
	int i = 0;
L
Linus Torvalds 已提交
308 309 310


	if (!tz)
311
		return -EINVAL;
L
Linus Torvalds 已提交
312 313 314

	/* Critical Shutdown (required) */

315
	status = acpi_evaluate_integer(tz->device->handle, "_CRT", NULL,
L
Len Brown 已提交
316
				       &tz->trips.critical.temperature);
L
Linus Torvalds 已提交
317 318
	if (ACPI_FAILURE(status)) {
		tz->trips.critical.flags.valid = 0;
319
		ACPI_EXCEPTION((AE_INFO, status, "No critical threshold"));
320
		return -ENODEV;
L
Len Brown 已提交
321
	} else {
L
Linus Torvalds 已提交
322
		tz->trips.critical.flags.valid = 1;
L
Len Brown 已提交
323 324 325
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Found critical threshold [%lu]\n",
				  tz->trips.critical.temperature));
L
Linus Torvalds 已提交
326 327 328 329
	}

	/* Critical Sleep (optional) */

L
Len Brown 已提交
330
	status =
331
	    acpi_evaluate_integer(tz->device->handle, "_HOT", NULL,
L
Len Brown 已提交
332
				  &tz->trips.hot.temperature);
L
Linus Torvalds 已提交
333 334 335
	if (ACPI_FAILURE(status)) {
		tz->trips.hot.flags.valid = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No hot threshold\n"));
L
Len Brown 已提交
336
	} else {
L
Linus Torvalds 已提交
337
		tz->trips.hot.flags.valid = 1;
L
Len Brown 已提交
338 339
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found hot threshold [%lu]\n",
				  tz->trips.hot.temperature));
L
Linus Torvalds 已提交
340 341 342 343
	}

	/* Passive: Processors (optional) */

L
Len Brown 已提交
344
	status =
345
	    acpi_evaluate_integer(tz->device->handle, "_PSV", NULL,
L
Len Brown 已提交
346
				  &tz->trips.passive.temperature);
L
Linus Torvalds 已提交
347 348 349
	if (ACPI_FAILURE(status)) {
		tz->trips.passive.flags.valid = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No passive threshold\n"));
L
Len Brown 已提交
350
	} else {
L
Linus Torvalds 已提交
351 352
		tz->trips.passive.flags.valid = 1;

L
Len Brown 已提交
353
		status =
354
		    acpi_evaluate_integer(tz->device->handle, "_TC1", NULL,
L
Len Brown 已提交
355
					  &tz->trips.passive.tc1);
L
Linus Torvalds 已提交
356 357 358
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
359
		status =
360
		    acpi_evaluate_integer(tz->device->handle, "_TC2", NULL,
L
Len Brown 已提交
361
					  &tz->trips.passive.tc2);
L
Linus Torvalds 已提交
362 363 364
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
365
		status =
366
		    acpi_evaluate_integer(tz->device->handle, "_TSP", NULL,
L
Len Brown 已提交
367
					  &tz->trips.passive.tsp);
L
Linus Torvalds 已提交
368 369 370
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
371
		status =
372
		    acpi_evaluate_reference(tz->device->handle, "_PSL", NULL,
L
Len Brown 已提交
373
					    &tz->trips.passive.devices);
L
Linus Torvalds 已提交
374 375 376 377
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

		if (!tz->trips.passive.flags.valid)
378
			printk(KERN_WARNING PREFIX "Invalid passive threshold\n");
L
Linus Torvalds 已提交
379
		else
L
Len Brown 已提交
380 381 382
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Found passive threshold [%lu]\n",
					  tz->trips.passive.temperature));
L
Linus Torvalds 已提交
383 384 385 386
	}

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

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

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

L
Len Brown 已提交
391
		status =
392
		    acpi_evaluate_integer(tz->device->handle, name, NULL,
L
Len Brown 已提交
393
					  &tz->trips.active[i].temperature);
L
Linus Torvalds 已提交
394 395 396 397
		if (ACPI_FAILURE(status))
			break;

		name[2] = 'L';
L
Len Brown 已提交
398
		status =
399
		    acpi_evaluate_reference(tz->device->handle, name, NULL,
L
Len Brown 已提交
400
					    &tz->trips.active[i].devices);
L
Linus Torvalds 已提交
401 402
		if (ACPI_SUCCESS(status)) {
			tz->trips.active[i].flags.valid = 1;
L
Len Brown 已提交
403 404 405 406
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Found active threshold [%d]:[%lu]\n",
					  i, tz->trips.active[i].temperature));
		} else
407 408
			ACPI_EXCEPTION((AE_INFO, status,
					"Invalid active threshold [%d]", i));
L
Linus Torvalds 已提交
409 410
	}

411
	return 0;
L
Linus Torvalds 已提交
412 413
}

L
Len Brown 已提交
414
static int acpi_thermal_get_devices(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
415
{
L
Len Brown 已提交
416
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
417 418 419


	if (!tz)
420
		return -EINVAL;
L
Linus Torvalds 已提交
421

L
Len Brown 已提交
422
	status =
423
	    acpi_evaluate_reference(tz->device->handle, "_TZD", NULL, &tz->devices);
L
Linus Torvalds 已提交
424
	if (ACPI_FAILURE(status))
425
		return -ENODEV;
L
Linus Torvalds 已提交
426

427
	return 0;
L
Linus Torvalds 已提交
428 429
}

L
Len Brown 已提交
430
static int acpi_thermal_call_usermode(char *path)
L
Linus Torvalds 已提交
431
{
L
Len Brown 已提交
432 433
	char *argv[2] = { NULL, NULL };
	char *envp[3] = { NULL, NULL, NULL };
L
Linus Torvalds 已提交
434 435 436


	if (!path)
437
		return -EINVAL;
L
Linus Torvalds 已提交
438 439 440 441 442 443

	argv[0] = path;

	/* minimal command environment */
	envp[0] = "HOME=/";
	envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
L
Len Brown 已提交
444

L
Linus Torvalds 已提交
445 446
	call_usermodehelper(argv[0], argv, envp, 0);

447
	return 0;
L
Linus Torvalds 已提交
448 449
}

L
Len Brown 已提交
450
static int acpi_thermal_critical(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
451 452
{
	if (!tz || !tz->trips.critical.flags.valid)
453
		return -EINVAL;
L
Linus Torvalds 已提交
454 455

	if (tz->temperature >= tz->trips.critical.temperature) {
456
		printk(KERN_WARNING PREFIX "Critical trip point\n");
L
Linus Torvalds 已提交
457
		tz->trips.critical.flags.enabled = 1;
L
Len Brown 已提交
458
	} else if (tz->trips.critical.flags.enabled)
L
Linus Torvalds 已提交
459 460
		tz->trips.critical.flags.enabled = 0;

L
Len Brown 已提交
461 462 463
	printk(KERN_EMERG
	       "Critical temperature reached (%ld C), shutting down.\n",
	       KELVIN_TO_CELSIUS(tz->temperature));
464
	acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
L
Len Brown 已提交
465
				tz->trips.critical.flags.enabled);
L
Linus Torvalds 已提交
466 467 468

	acpi_thermal_call_usermode(ACPI_THERMAL_PATH_POWEROFF);

469
	return 0;
L
Linus Torvalds 已提交
470 471
}

L
Len Brown 已提交
472
static int acpi_thermal_hot(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
473 474
{
	if (!tz || !tz->trips.hot.flags.valid)
475
		return -EINVAL;
L
Linus Torvalds 已提交
476 477

	if (tz->temperature >= tz->trips.hot.temperature) {
478
		printk(KERN_WARNING PREFIX "Hot trip point\n");
L
Linus Torvalds 已提交
479
		tz->trips.hot.flags.enabled = 1;
L
Len Brown 已提交
480
	} else if (tz->trips.hot.flags.enabled)
L
Linus Torvalds 已提交
481 482
		tz->trips.hot.flags.enabled = 0;

483
	acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
L
Len Brown 已提交
484
				tz->trips.hot.flags.enabled);
L
Linus Torvalds 已提交
485 486 487

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

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

491
static void acpi_thermal_passive(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
492
{
493
	int result = 1;
L
Linus Torvalds 已提交
494
	struct acpi_thermal_passive *passive = NULL;
L
Len Brown 已提交
495 496
	int trend = 0;
	int i = 0;
L
Linus Torvalds 已提交
497 498 499


	if (!tz || !tz->trips.passive.flags.valid)
500
		return;
L
Linus Torvalds 已提交
501 502 503 504 505 506 507 508 509 510 511

	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 已提交
512 513 514 515 516 517 518 519
		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));
520
		passive->flags.enabled = 1;
L
Linus Torvalds 已提交
521 522
		/* Heating up? */
		if (trend > 0)
L
Len Brown 已提交
523 524 525 526 527
			for (i = 0; i < passive->devices.count; i++)
				acpi_processor_set_thermal_limit(passive->
								 devices.
								 handles[i],
								 ACPI_PROCESSOR_LIMIT_INCREMENT);
L
Linus Torvalds 已提交
528
		/* Cooling off? */
529
		else if (trend < 0) {
L
Len Brown 已提交
530
			for (i = 0; i < passive->devices.count; i++)
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
				/*
				 * 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 已提交
555 556 557 558 559 560 561 562 563
	}

	/*
	 * Below Trip?
	 * -----------
	 * Implement passive cooling hysteresis to slowly increase performance
	 * and avoid thrashing around the passive trip point.  Note that we
	 * assume symmetry.
	 */
564 565 566 567 568 569 570 571 572 573 574
	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 已提交
575 576 577
	}
}

578
static void acpi_thermal_active(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
579
{
L
Len Brown 已提交
580
	int result = 0;
L
Linus Torvalds 已提交
581
	struct acpi_thermal_active *active = NULL;
L
Len Brown 已提交
582 583 584
	int i = 0;
	int j = 0;
	unsigned long maxtemp = 0;
L
Linus Torvalds 已提交
585 586 587


	if (!tz)
588
		return;
L
Linus Torvalds 已提交
589

L
Len Brown 已提交
590
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
L
Linus Torvalds 已提交
591 592 593 594
		active = &(tz->trips.active[i]);
		if (!active || !active->flags.valid)
			break;
		if (tz->temperature >= active->temperature) {
595 596 597 598 599 600
			/*
			 * Above Threshold?
			 * ----------------
			 * If not already enabled, turn ON all cooling devices
			 * associated with this active threshold.
			 */
L
Linus Torvalds 已提交
601
			if (active->temperature > maxtemp)
602 603 604 605
				tz->state.active_index = i;
			maxtemp = active->temperature;
			if (active->flags.enabled)
				continue;
L
Linus Torvalds 已提交
606
			for (j = 0; j < active->devices.count; j++) {
L
Len Brown 已提交
607 608 609
				result =
				    acpi_bus_set_power(active->devices.
						       handles[j],
610
						       ACPI_STATE_D0);
L
Linus Torvalds 已提交
611
				if (result) {
612 613
					printk(KERN_WARNING PREFIX
						      "Unable to turn cooling device [%p] 'on'\n",
614
						      active->devices.
615
						      handles[j]);
L
Linus Torvalds 已提交
616 617
					continue;
				}
618
				active->flags.enabled = 1;
L
Len Brown 已提交
619
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
620
						  "Cooling device [%p] now 'on'\n",
L
Len Brown 已提交
621
						  active->devices.handles[j]));
L
Linus Torvalds 已提交
622
			}
623 624 625 626 627 628 629 630 631 632 633 634 635 636
			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) {
637 638 639
				printk(KERN_WARNING PREFIX
					      "Unable to turn cooling device [%p] 'off'\n",
					      active->devices.handles[j]);
640 641 642 643 644 645
				continue;
			}
			active->flags.enabled = 0;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Cooling device [%p] now 'off'\n",
					  active->devices.handles[j]));
L
Linus Torvalds 已提交
646 647 648 649
		}
	}
}

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

L
Len Brown 已提交
652
static void acpi_thermal_run(unsigned long data)
L
Linus Torvalds 已提交
653 654 655
{
	struct acpi_thermal *tz = (struct acpi_thermal *)data;
	if (!tz->zombie)
656
		acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
L
Linus Torvalds 已提交
657 658
}

L
Len Brown 已提交
659
static void acpi_thermal_check(void *data)
L
Linus Torvalds 已提交
660
{
L
Len Brown 已提交
661
	int result = 0;
662
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
663 664
	unsigned long sleep_time = 0;
	int i = 0;
L
Linus Torvalds 已提交
665 666 667 668
	struct acpi_thermal_state state;


	if (!tz) {
669
		printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
670
		return;
L
Linus Torvalds 已提交
671 672 673 674 675 676
	}

	state = tz->state;

	result = acpi_thermal_get_temperature(tz);
	if (result)
677
		return;
L
Len Brown 已提交
678

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

L
Linus Torvalds 已提交
681 682 683 684 685 686 687 688 689
	/*
	 * 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 已提交
690 691
		state.critical |=
		    (tz->temperature >= tz->trips.critical.temperature);
L
Linus Torvalds 已提交
692 693 694
	if (tz->trips.hot.flags.valid)
		state.hot |= (tz->temperature >= tz->trips.hot.temperature);
	if (tz->trips.passive.flags.valid)
L
Len Brown 已提交
695 696 697
		state.passive |=
		    (tz->temperature >= tz->trips.passive.temperature);
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
L
Linus Torvalds 已提交
698
		if (tz->trips.active[i].flags.valid)
L
Len Brown 已提交
699 700 701
			state.active |=
			    (tz->temperature >=
			     tz->trips.active[i].temperature);
L
Linus Torvalds 已提交
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723

	/*
	 * 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.
	 */
724 725 726 727
	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 已提交
728
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
729
		tz->state.active |= tz->trips.active[i].flags.enabled;
L
Linus Torvalds 已提交
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744

	/*
	 * 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 已提交
745 746
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
			  tz->name, tz->temperature, sleep_time));
L
Linus Torvalds 已提交
747 748 749 750 751 752 753 754

	/*
	 * Schedule Next Poll
	 * ------------------
	 */
	if (!sleep_time) {
		if (timer_pending(&(tz->timer)))
			del_timer(&(tz->timer));
L
Len Brown 已提交
755
	} else {
L
Linus Torvalds 已提交
756
		if (timer_pending(&(tz->timer)))
757 758
			mod_timer(&(tz->timer),
					jiffies + (HZ * sleep_time) / 1000);
L
Linus Torvalds 已提交
759
		else {
L
Len Brown 已提交
760
			tz->timer.data = (unsigned long)tz;
L
Linus Torvalds 已提交
761 762 763 764 765 766
			tz->timer.function = acpi_thermal_run;
			tz->timer.expires = jiffies + (HZ * sleep_time) / 1000;
			add_timer(&(tz->timer));
		}
	}

767
	return;
L
Linus Torvalds 已提交
768 769 770 771 772 773
}

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

L
Len Brown 已提交
774
static struct proc_dir_entry *acpi_thermal_dir;
L
Linus Torvalds 已提交
775 776 777

static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
{
778
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
779 780 781 782 783 784 785


	if (!tz)
		goto end;

	seq_puts(seq, "state:                   ");

L
Len Brown 已提交
786 787
	if (!tz->state.critical && !tz->state.hot && !tz->state.passive
	    && !tz->state.active)
L
Linus Torvalds 已提交
788 789 790 791 792 793 794 795 796 797 798 799 800
		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 已提交
801
      end:
802
	return 0;
L
Linus Torvalds 已提交
803 804 805 806 807 808 809 810 811
}

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 已提交
812
	int result = 0;
813
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
814 815 816 817 818 819 820 821 822


	if (!tz)
		goto end;

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

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

L
Len Brown 已提交
826
      end:
827
	return 0;
L
Linus Torvalds 已提交
828 829 830 831 832 833 834 835 836
}

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)
{
837
	struct acpi_thermal *tz = seq->private;
L
Len Brown 已提交
838 839
	int i = 0;
	int j = 0;
L
Linus Torvalds 已提交
840 841 842 843 844 845 846


	if (!tz)
		goto end;

	if (tz->trips.critical.flags.valid)
		seq_printf(seq, "critical (S5):           %ld C\n",
L
Len Brown 已提交
847
			   KELVIN_TO_CELSIUS(tz->trips.critical.temperature));
L
Linus Torvalds 已提交
848 849 850

	if (tz->trips.hot.flags.valid)
		seq_printf(seq, "hot (S4):                %ld C\n",
L
Len Brown 已提交
851
			   KELVIN_TO_CELSIUS(tz->trips.hot.temperature));
L
Linus Torvalds 已提交
852 853

	if (tz->trips.passive.flags.valid) {
L
Len Brown 已提交
854 855 856 857 858 859 860 861 862
		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++) {

			seq_printf(seq, "0x%p ",
				   tz->trips.passive.devices.handles[j]);
L
Linus Torvalds 已提交
863 864 865 866 867 868 869 870
		}
		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 已提交
871 872 873
			   i,
			   KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
		for (j = 0; j < tz->trips.active[i].devices.count; j++)
L
Linus Torvalds 已提交
874
			seq_printf(seq, "0x%p ",
L
Len Brown 已提交
875
				   tz->trips.active[i].devices.handles[j]);
L
Linus Torvalds 已提交
876 877 878
		seq_puts(seq, "\n");
	}

L
Len Brown 已提交
879
      end:
880
	return 0;
L
Linus Torvalds 已提交
881 882 883 884 885 886 887 888 889
}

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)
{
890
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
891 892 893 894 895 896 897 898 899


	if (!tz)
		goto end;

	if (!tz->flags.cooling_mode) {
		seq_puts(seq, "<setting not supported>\n");
	}

L
Len Brown 已提交
900
	if (tz->cooling_mode == ACPI_THERMAL_MODE_CRITICAL)
L
Linus Torvalds 已提交
901 902 903
		seq_printf(seq, "cooling mode:	critical\n");
	else
		seq_printf(seq, "cooling mode:	%s\n",
L
Len Brown 已提交
904
			   tz->cooling_mode ? "passive" : "active");
L
Linus Torvalds 已提交
905

L
Len Brown 已提交
906
      end:
907
	return 0;
L
Linus Torvalds 已提交
908 909 910 911 912
}

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 已提交
913
			   PDE(inode)->data);
L
Linus Torvalds 已提交
914 915 916
}

static ssize_t
L
Len Brown 已提交
917 918 919
acpi_thermal_write_cooling_mode(struct file *file,
				const char __user * buffer,
				size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
920
{
921 922
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
923 924
	int result = 0;
	char mode_string[12] = { '\0' };
L
Linus Torvalds 已提交
925 926 927


	if (!tz || (count > sizeof(mode_string) - 1))
928
		return -EINVAL;
L
Linus Torvalds 已提交
929 930

	if (!tz->flags.cooling_mode)
931
		return -ENODEV;
L
Linus Torvalds 已提交
932 933

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

L
Linus Torvalds 已提交
936
	mode_string[count] = '\0';
L
Len Brown 已提交
937 938 939 940

	result = acpi_thermal_set_cooling_mode(tz,
					       simple_strtoul(mode_string, NULL,
							      0));
L
Linus Torvalds 已提交
941
	if (result)
942
		return result;
L
Linus Torvalds 已提交
943 944 945

	acpi_thermal_check(tz);

946
	return count;
L
Linus Torvalds 已提交
947 948 949 950
}

static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
{
951
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
952 953 954 955 956 957 958 959 960 961 962


	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 已提交
963
		   (tz->polling_frequency / 10));
L
Linus Torvalds 已提交
964

L
Len Brown 已提交
965
      end:
966
	return 0;
L
Linus Torvalds 已提交
967 968 969 970 971
}

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 已提交
972
			   PDE(inode)->data);
L
Linus Torvalds 已提交
973 974 975
}

static ssize_t
L
Len Brown 已提交
976 977 978
acpi_thermal_write_polling(struct file *file,
			   const char __user * buffer,
			   size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
979
{
980 981
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
982 983 984
	int result = 0;
	char polling_string[12] = { '\0' };
	int seconds = 0;
L
Linus Torvalds 已提交
985 986 987


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

L
Linus Torvalds 已提交
990
	if (copy_from_user(polling_string, buffer, count))
991
		return -EFAULT;
L
Len Brown 已提交
992

L
Linus Torvalds 已提交
993 994 995
	polling_string[count] = '\0';

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

L
Linus Torvalds 已提交
997 998
	result = acpi_thermal_set_polling(tz, seconds);
	if (result)
999
		return result;
L
Linus Torvalds 已提交
1000 1001 1002

	acpi_thermal_check(tz);

1003
	return count;
L
Linus Torvalds 已提交
1004 1005
}

L
Len Brown 已提交
1006
static int acpi_thermal_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1007
{
L
Len Brown 已提交
1008
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
1009 1010 1011 1012


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
1013
						     acpi_thermal_dir);
L
Linus Torvalds 已提交
1014
		if (!acpi_device_dir(device))
1015
			return -ENODEV;
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020
		acpi_device_dir(device)->owner = THIS_MODULE;
	}

	/* 'state' [R] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
L
Len Brown 已提交
1021
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1022
	if (!entry)
1023
		return -ENODEV;
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029 1030 1031
	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 已提交
1032
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1033
	if (!entry)
1034
		return -ENODEV;
L
Linus Torvalds 已提交
1035 1036 1037 1038 1039 1040 1041 1042
	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 已提交
1043 1044
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1045
	if (!entry)
1046
		return -ENODEV;
L
Linus Torvalds 已提交
1047 1048 1049 1050 1051 1052 1053 1054
	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 已提交
1055 1056
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1057
	if (!entry)
1058
		return -ENODEV;
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064 1065 1066
	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 已提交
1067 1068
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1069
	if (!entry)
1070
		return -ENODEV;
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075 1076
	else {
		entry->proc_fops = &acpi_thermal_polling_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

1077
	return 0;
L
Linus Torvalds 已提交
1078 1079
}

L
Len Brown 已提交
1080
static int acpi_thermal_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
{

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

1098
	return 0;
L
Linus Torvalds 已提交
1099 1100 1101 1102 1103 1104
}

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

L
Len Brown 已提交
1105
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1106
{
1107
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
1108
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
1109 1110 1111


	if (!tz)
1112
		return;
L
Linus Torvalds 已提交
1113

1114
	device = tz->device;
L
Linus Torvalds 已提交
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131

	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 已提交
1132
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1133 1134 1135
		break;
	}

1136
	return;
L
Linus Torvalds 已提交
1137 1138
}

L
Len Brown 已提交
1139
static int acpi_thermal_get_info(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
1140
{
L
Len Brown 已提交
1141
	int result = 0;
L
Linus Torvalds 已提交
1142 1143 1144


	if (!tz)
1145
		return -EINVAL;
L
Linus Torvalds 已提交
1146 1147 1148 1149

	/* Get temperature [_TMP] (required) */
	result = acpi_thermal_get_temperature(tz);
	if (result)
1150
		return result;
L
Linus Torvalds 已提交
1151 1152 1153 1154

	/* Get trip points [_CRT, _PSV, etc.] (required) */
	result = acpi_thermal_get_trip_points(tz);
	if (result)
1155
		return result;
L
Linus Torvalds 已提交
1156 1157 1158

	/* Set the cooling mode [_SCP] to active cooling (default) */
	result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
L
Len Brown 已提交
1159
	if (!result)
L
Linus Torvalds 已提交
1160
		tz->flags.cooling_mode = 1;
L
Len Brown 已提交
1161
	else {
L
Linus Torvalds 已提交
1162
		/* Oh,we have not _SCP method.
L
Len Brown 已提交
1163
		   Generally show cooling_mode by _ACx, _PSV,spec 12.2 */
L
Linus Torvalds 已提交
1164
		tz->flags.cooling_mode = 0;
L
Len Brown 已提交
1165 1166 1167 1168
		if (tz->trips.active[0].flags.valid
		    && tz->trips.passive.flags.valid) {
			if (tz->trips.passive.temperature >
			    tz->trips.active[0].temperature)
L
Linus Torvalds 已提交
1169
				tz->cooling_mode = ACPI_THERMAL_MODE_ACTIVE;
L
Len Brown 已提交
1170
			else
L
Linus Torvalds 已提交
1171
				tz->cooling_mode = ACPI_THERMAL_MODE_PASSIVE;
L
Len Brown 已提交
1172 1173
		} else if (!tz->trips.active[0].flags.valid
			   && tz->trips.passive.flags.valid) {
L
Linus Torvalds 已提交
1174
			tz->cooling_mode = ACPI_THERMAL_MODE_PASSIVE;
L
Len Brown 已提交
1175 1176
		} else if (tz->trips.active[0].flags.valid
			   && !tz->trips.passive.flags.valid) {
L
Linus Torvalds 已提交
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
			tz->cooling_mode = ACPI_THERMAL_MODE_ACTIVE;
		} else {
			/* _ACx and _PSV are optional, but _CRT is required */
			tz->cooling_mode = ACPI_THERMAL_MODE_CRITICAL;
		}
	}

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

1195
	return 0;
L
Linus Torvalds 已提交
1196 1197
}

L
Len Brown 已提交
1198
static int acpi_thermal_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1199
{
L
Len Brown 已提交
1200 1201 1202
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1203 1204 1205


	if (!device)
1206
		return -EINVAL;
L
Linus Torvalds 已提交
1207

1208
	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
L
Linus Torvalds 已提交
1209
	if (!tz)
1210
		return -ENOMEM;
L
Linus Torvalds 已提交
1211

1212
	tz->device = device;
L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
	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)
1224
		goto end;
L
Linus Torvalds 已提交
1225 1226 1227 1228 1229

	init_timer(&tz->timer);

	acpi_thermal_check(tz);

1230
	status = acpi_install_notify_handler(device->handle,
L
Len Brown 已提交
1231 1232
					     ACPI_DEVICE_NOTIFY,
					     acpi_thermal_notify, tz);
L
Linus Torvalds 已提交
1233 1234 1235 1236 1237 1238
	if (ACPI_FAILURE(status)) {
		result = -ENODEV;
		goto end;
	}

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

L
Len Brown 已提交
1242
      end:
L
Linus Torvalds 已提交
1243 1244 1245 1246 1247
	if (result) {
		acpi_thermal_remove_fs(device);
		kfree(tz);
	}

1248
	return result;
L
Linus Torvalds 已提交
1249 1250
}

L
Len Brown 已提交
1251
static int acpi_thermal_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
1252
{
L
Len Brown 已提交
1253 1254
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1255 1256 1257


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

1260
	tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270

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

1271
	status = acpi_remove_notify_handler(device->handle,
L
Len Brown 已提交
1272 1273
					    ACPI_DEVICE_NOTIFY,
					    acpi_thermal_notify);
L
Linus Torvalds 已提交
1274 1275

	/* Terminate policy */
L
Len Brown 已提交
1276
	if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
L
Linus Torvalds 已提交
1277 1278 1279 1280
		tz->trips.passive.flags.enabled = 0;
		acpi_thermal_passive(tz);
	}
	if (tz->trips.active[0].flags.valid
L
Len Brown 已提交
1281
	    && tz->trips.active[0].flags.enabled) {
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288
		tz->trips.active[0].flags.enabled = 0;
		acpi_thermal_active(tz);
	}

	acpi_thermal_remove_fs(device);

	kfree(tz);
1289
	return 0;
L
Linus Torvalds 已提交
1290 1291
}

1292
static int acpi_thermal_resume(struct acpi_device *device)
1293 1294
{
	struct acpi_thermal *tz = NULL;
1295 1296
	int i, j, power_state, result;

1297 1298

	if (!device || !acpi_driver_data(device))
1299
		return -EINVAL;
1300

1301
	tz = acpi_driver_data(device);
1302

1303
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
		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;
			}
1316
		}
1317
		tz->state.active |= tz->trips.active[i].flags.enabled;
1318 1319
	}

1320
	acpi_thermal_check(tz);
1321 1322 1323 1324

	return AE_OK;
}

L
Len Brown 已提交
1325
static int __init acpi_thermal_init(void)
L
Linus Torvalds 已提交
1326
{
L
Len Brown 已提交
1327
	int result = 0;
L
Linus Torvalds 已提交
1328 1329 1330 1331


	acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
	if (!acpi_thermal_dir)
1332
		return -ENODEV;
L
Linus Torvalds 已提交
1333 1334 1335 1336 1337
	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);
1338
		return -ENODEV;
L
Linus Torvalds 已提交
1339 1340
	}

1341
	return 0;
L
Linus Torvalds 已提交
1342 1343
}

L
Len Brown 已提交
1344
static void __exit acpi_thermal_exit(void)
L
Linus Torvalds 已提交
1345 1346 1347 1348 1349 1350
{

	acpi_bus_unregister_driver(&acpi_thermal_driver);

	remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);

1351
	return;
L
Linus Torvalds 已提交
1352 1353 1354 1355
}

module_init(acpi_thermal_init);
module_exit(acpi_thermal_exit);