1/*
2 *  acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $)
3 *
4 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 *  This program is free software; you can redistribute it and/or modify
10 *  it under the terms of the GNU General Public License as published by
11 *  the Free Software Foundation; either version 2 of the License, or (at
12 *  your option) any later version.
13 *
14 *  This program is distributed in the hope that it will be useful, but
15 *  WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 *  General Public License for more details.
18 *
19 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
20 *
21 *  This driver fully implements the ACPI thermal policy as described in the
22 *  ACPI 2.0 Specification.
23 *
24 *  TBD: 1. Implement passive cooling hysteresis.
25 *       2. Enhance passive cooling (CPU) states/limit interface to support
26 *          concepts of 'multiple limiters', upper/lower limits, etc.
27 *
28 */
29
30#include <linux/kernel.h>
31#include <linux/module.h>
32#include <linux/dmi.h>
33#include <linux/init.h>
34#include <linux/slab.h>
35#include <linux/types.h>
36#include <linux/jiffies.h>
37#include <linux/kmod.h>
38#include <linux/reboot.h>
39#include <linux/device.h>
40#include <linux/thermal.h>
41#include <linux/acpi.h>
42#include <linux/workqueue.h>
43#include <asm/uaccess.h>
44
45#define PREFIX "ACPI: "
46
47#define ACPI_THERMAL_CLASS		"thermal_zone"
48#define ACPI_THERMAL_DEVICE_NAME	"Thermal Zone"
49#define ACPI_THERMAL_NOTIFY_TEMPERATURE	0x80
50#define ACPI_THERMAL_NOTIFY_THRESHOLDS	0x81
51#define ACPI_THERMAL_NOTIFY_DEVICES	0x82
52#define ACPI_THERMAL_NOTIFY_CRITICAL	0xF0
53#define ACPI_THERMAL_NOTIFY_HOT		0xF1
54#define ACPI_THERMAL_MODE_ACTIVE	0x00
55
56#define ACPI_THERMAL_MAX_ACTIVE	10
57#define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65
58
59#define _COMPONENT		ACPI_THERMAL_COMPONENT
60ACPI_MODULE_NAME("thermal");
61
62MODULE_AUTHOR("Paul Diefenbaugh");
63MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
64MODULE_LICENSE("GPL");
65
66static int act;
67module_param(act, int, 0644);
68MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
69
70static int crt;
71module_param(crt, int, 0644);
72MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");
73
74static int tzp;
75module_param(tzp, int, 0444);
76MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
77
78static int nocrt;
79module_param(nocrt, int, 0);
80MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
81
82static int off;
83module_param(off, int, 0);
84MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
85
86static int psv;
87module_param(psv, int, 0644);
88MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
89
90static struct workqueue_struct *acpi_thermal_pm_queue;
91
92static int acpi_thermal_add(struct acpi_device *device);
93static int acpi_thermal_remove(struct acpi_device *device);
94static void acpi_thermal_notify(struct acpi_device *device, u32 event);
95
96static const struct acpi_device_id  thermal_device_ids[] = {
97	{ACPI_THERMAL_HID, 0},
98	{"", 0},
99};
100MODULE_DEVICE_TABLE(acpi, thermal_device_ids);
101
102#ifdef CONFIG_PM_SLEEP
103static int acpi_thermal_suspend(struct device *dev);
104static int acpi_thermal_resume(struct device *dev);
105#else
106#define acpi_thermal_suspend NULL
107#define acpi_thermal_resume NULL
108#endif
109static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, acpi_thermal_suspend, acpi_thermal_resume);
110
111static struct acpi_driver acpi_thermal_driver = {
112	.name = "thermal",
113	.class = ACPI_THERMAL_CLASS,
114	.ids = thermal_device_ids,
115	.ops = {
116		.add = acpi_thermal_add,
117		.remove = acpi_thermal_remove,
118		.notify = acpi_thermal_notify,
119		},
120	.drv.pm = &acpi_thermal_pm,
121};
122
123struct acpi_thermal_state {
124	u8 critical:1;
125	u8 hot:1;
126	u8 passive:1;
127	u8 active:1;
128	u8 reserved:4;
129	int active_index;
130};
131
132struct acpi_thermal_state_flags {
133	u8 valid:1;
134	u8 enabled:1;
135	u8 reserved:6;
136};
137
138struct acpi_thermal_critical {
139	struct acpi_thermal_state_flags flags;
140	unsigned long temperature;
141};
142
143struct acpi_thermal_hot {
144	struct acpi_thermal_state_flags flags;
145	unsigned long temperature;
146};
147
148struct acpi_thermal_passive {
149	struct acpi_thermal_state_flags flags;
150	unsigned long temperature;
151	unsigned long tc1;
152	unsigned long tc2;
153	unsigned long tsp;
154	struct acpi_handle_list devices;
155};
156
157struct acpi_thermal_active {
158	struct acpi_thermal_state_flags flags;
159	unsigned long temperature;
160	struct acpi_handle_list devices;
161};
162
163struct acpi_thermal_trips {
164	struct acpi_thermal_critical critical;
165	struct acpi_thermal_hot hot;
166	struct acpi_thermal_passive passive;
167	struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
168};
169
170struct acpi_thermal_flags {
171	u8 cooling_mode:1;	/* _SCP */
172	u8 devices:1;		/* _TZD */
173	u8 reserved:6;
174};
175
176struct acpi_thermal {
177	struct acpi_device * device;
178	acpi_bus_id name;
179	unsigned long temperature;
180	unsigned long last_temperature;
181	unsigned long polling_frequency;
182	volatile u8 zombie;
183	struct acpi_thermal_flags flags;
184	struct acpi_thermal_state state;
185	struct acpi_thermal_trips trips;
186	struct acpi_handle_list devices;
187	struct thermal_zone_device *thermal_zone;
188	int tz_enabled;
189	int kelvin_offset;
190	struct work_struct thermal_check_work;
191};
192
193/* --------------------------------------------------------------------------
194                             Thermal Zone Management
195   -------------------------------------------------------------------------- */
196
197static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
198{
199	acpi_status status = AE_OK;
200	unsigned long long tmp;
201
202	if (!tz)
203		return -EINVAL;
204
205	tz->last_temperature = tz->temperature;
206
207	status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
208	if (ACPI_FAILURE(status))
209		return -ENODEV;
210
211	tz->temperature = tmp;
212	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
213			  tz->temperature));
214
215	return 0;
216}
217
218static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
219{
220	acpi_status status = AE_OK;
221	unsigned long long tmp;
222
223	if (!tz)
224		return -EINVAL;
225
226	status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
227	if (ACPI_FAILURE(status))
228		return -ENODEV;
229
230	tz->polling_frequency = tmp;
231	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
232			  tz->polling_frequency));
233
234	return 0;
235}
236
237static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
238{
239	if (!tz)
240		return -EINVAL;
241
242	if (!acpi_has_method(tz->device->handle, "_SCP")) {
243		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
244		return -ENODEV;
245	} else if (ACPI_FAILURE(acpi_execute_simple_method(tz->device->handle,
246							   "_SCP", mode))) {
247		return -ENODEV;
248	}
249
250	return 0;
251}
252
253#define ACPI_TRIPS_CRITICAL	0x01
254#define ACPI_TRIPS_HOT		0x02
255#define ACPI_TRIPS_PASSIVE	0x04
256#define ACPI_TRIPS_ACTIVE	0x08
257#define ACPI_TRIPS_DEVICES	0x10
258
259#define ACPI_TRIPS_REFRESH_THRESHOLDS	(ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
260#define ACPI_TRIPS_REFRESH_DEVICES	ACPI_TRIPS_DEVICES
261
262#define ACPI_TRIPS_INIT      (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT |	\
263			      ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE |	\
264			      ACPI_TRIPS_DEVICES)
265
266/*
267 * This exception is thrown out in two cases:
268 * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
269 *   when re-evaluating the AML code.
270 * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
271 *   We need to re-bind the cooling devices of a thermal zone when this occurs.
272 */
273#define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str)	\
274do {	\
275	if (flags != ACPI_TRIPS_INIT)	\
276		ACPI_EXCEPTION((AE_INFO, AE_ERROR,	\
277		"ACPI thermal trip point %s changed\n"	\
278		"Please send acpidump to linux-acpi@vger.kernel.org", str)); \
279} while (0)
280
281static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
282{
283	acpi_status status = AE_OK;
284	unsigned long long tmp;
285	struct acpi_handle_list devices;
286	int valid = 0;
287	int i;
288
289	/* Critical Shutdown */
290	if (flag & ACPI_TRIPS_CRITICAL) {
291		status = acpi_evaluate_integer(tz->device->handle,
292				"_CRT", NULL, &tmp);
293		tz->trips.critical.temperature = tmp;
294		/*
295		 * Treat freezing temperatures as invalid as well; some
296		 * BIOSes return really low values and cause reboots at startup.
297		 * Below zero (Celsius) values clearly aren't right for sure..
298		 * ... so lets discard those as invalid.
299		 */
300		if (ACPI_FAILURE(status)) {
301			tz->trips.critical.flags.valid = 0;
302			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
303					  "No critical threshold\n"));
304		} else if (tmp <= 2732) {
305			pr_warn(FW_BUG "Invalid critical threshold (%llu)\n",
306				tmp);
307			tz->trips.critical.flags.valid = 0;
308		} else {
309			tz->trips.critical.flags.valid = 1;
310			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
311					  "Found critical threshold [%lu]\n",
312					  tz->trips.critical.temperature));
313		}
314		if (tz->trips.critical.flags.valid == 1) {
315			if (crt == -1) {
316				tz->trips.critical.flags.valid = 0;
317			} else if (crt > 0) {
318				unsigned long crt_k = CELSIUS_TO_DECI_KELVIN(crt);
319				/*
320				 * Allow override critical threshold
321				 */
322				if (crt_k > tz->trips.critical.temperature)
323					pr_warn(PREFIX "Critical threshold %d C\n",
324						crt);
325				tz->trips.critical.temperature = crt_k;
326			}
327		}
328	}
329
330	/* Critical Sleep (optional) */
331	if (flag & ACPI_TRIPS_HOT) {
332		status = acpi_evaluate_integer(tz->device->handle,
333				"_HOT", NULL, &tmp);
334		if (ACPI_FAILURE(status)) {
335			tz->trips.hot.flags.valid = 0;
336			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
337					"No hot threshold\n"));
338		} else {
339			tz->trips.hot.temperature = tmp;
340			tz->trips.hot.flags.valid = 1;
341			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
342					"Found hot threshold [%lu]\n",
343					tz->trips.hot.temperature));
344		}
345	}
346
347	/* Passive (optional) */
348	if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
349		(flag == ACPI_TRIPS_INIT)) {
350		valid = tz->trips.passive.flags.valid;
351		if (psv == -1) {
352			status = AE_SUPPORT;
353		} else if (psv > 0) {
354			tmp = CELSIUS_TO_DECI_KELVIN(psv);
355			status = AE_OK;
356		} else {
357			status = acpi_evaluate_integer(tz->device->handle,
358				"_PSV", NULL, &tmp);
359		}
360
361		if (ACPI_FAILURE(status))
362			tz->trips.passive.flags.valid = 0;
363		else {
364			tz->trips.passive.temperature = tmp;
365			tz->trips.passive.flags.valid = 1;
366			if (flag == ACPI_TRIPS_INIT) {
367				status = acpi_evaluate_integer(
368						tz->device->handle, "_TC1",
369						NULL, &tmp);
370				if (ACPI_FAILURE(status))
371					tz->trips.passive.flags.valid = 0;
372				else
373					tz->trips.passive.tc1 = tmp;
374				status = acpi_evaluate_integer(
375						tz->device->handle, "_TC2",
376						NULL, &tmp);
377				if (ACPI_FAILURE(status))
378					tz->trips.passive.flags.valid = 0;
379				else
380					tz->trips.passive.tc2 = tmp;
381				status = acpi_evaluate_integer(
382						tz->device->handle, "_TSP",
383						NULL, &tmp);
384				if (ACPI_FAILURE(status))
385					tz->trips.passive.flags.valid = 0;
386				else
387					tz->trips.passive.tsp = tmp;
388			}
389		}
390	}
391	if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
392		memset(&devices, 0, sizeof(struct acpi_handle_list));
393		status = acpi_evaluate_reference(tz->device->handle, "_PSL",
394							NULL, &devices);
395		if (ACPI_FAILURE(status)) {
396			pr_warn(PREFIX "Invalid passive threshold\n");
397			tz->trips.passive.flags.valid = 0;
398		}
399		else
400			tz->trips.passive.flags.valid = 1;
401
402		if (memcmp(&tz->trips.passive.devices, &devices,
403				sizeof(struct acpi_handle_list))) {
404			memcpy(&tz->trips.passive.devices, &devices,
405				sizeof(struct acpi_handle_list));
406			ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
407		}
408	}
409	if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
410		if (valid != tz->trips.passive.flags.valid)
411				ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
412	}
413
414	/* Active (optional) */
415	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
416		char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
417		valid = tz->trips.active[i].flags.valid;
418
419		if (act == -1)
420			break; /* disable all active trip points */
421
422		if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
423			tz->trips.active[i].flags.valid)) {
424			status = acpi_evaluate_integer(tz->device->handle,
425							name, NULL, &tmp);
426			if (ACPI_FAILURE(status)) {
427				tz->trips.active[i].flags.valid = 0;
428				if (i == 0)
429					break;
430				if (act <= 0)
431					break;
432				if (i == 1)
433					tz->trips.active[0].temperature =
434						CELSIUS_TO_DECI_KELVIN(act);
435				else
436					/*
437					 * Don't allow override higher than
438					 * the next higher trip point
439					 */
440					tz->trips.active[i - 1].temperature =
441						(tz->trips.active[i - 2].temperature <
442						CELSIUS_TO_DECI_KELVIN(act) ?
443						tz->trips.active[i - 2].temperature :
444						CELSIUS_TO_DECI_KELVIN(act));
445				break;
446			} else {
447				tz->trips.active[i].temperature = tmp;
448				tz->trips.active[i].flags.valid = 1;
449			}
450		}
451
452		name[2] = 'L';
453		if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
454			memset(&devices, 0, sizeof(struct acpi_handle_list));
455			status = acpi_evaluate_reference(tz->device->handle,
456						name, NULL, &devices);
457			if (ACPI_FAILURE(status)) {
458				pr_warn(PREFIX "Invalid active%d threshold\n",
459					i);
460				tz->trips.active[i].flags.valid = 0;
461			}
462			else
463				tz->trips.active[i].flags.valid = 1;
464
465			if (memcmp(&tz->trips.active[i].devices, &devices,
466					sizeof(struct acpi_handle_list))) {
467				memcpy(&tz->trips.active[i].devices, &devices,
468					sizeof(struct acpi_handle_list));
469				ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
470			}
471		}
472		if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
473			if (valid != tz->trips.active[i].flags.valid)
474				ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
475
476		if (!tz->trips.active[i].flags.valid)
477			break;
478	}
479
480	if ((flag & ACPI_TRIPS_DEVICES)
481	    && acpi_has_method(tz->device->handle, "_TZD")) {
482		memset(&devices, 0, sizeof(devices));
483		status = acpi_evaluate_reference(tz->device->handle, "_TZD",
484						NULL, &devices);
485		if (ACPI_SUCCESS(status)
486		    && memcmp(&tz->devices, &devices, sizeof(devices))) {
487			tz->devices = devices;
488			ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
489		}
490	}
491
492	return 0;
493}
494
495static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
496{
497	int i, valid, ret = acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
498
499	if (ret)
500		return ret;
501
502	valid = tz->trips.critical.flags.valid |
503		tz->trips.hot.flags.valid |
504		tz->trips.passive.flags.valid;
505
506	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
507		valid |= tz->trips.active[i].flags.valid;
508
509	if (!valid) {
510		pr_warn(FW_BUG "No valid trip found\n");
511		return -ENODEV;
512	}
513	return 0;
514}
515
516static void acpi_thermal_check(void *data)
517{
518	struct acpi_thermal *tz = data;
519
520	if (!tz->tz_enabled)
521		return;
522
523	thermal_zone_device_update(tz->thermal_zone);
524}
525
526/* sys I/F for generic thermal sysfs support */
527
528static int thermal_get_temp(struct thermal_zone_device *thermal, int *temp)
529{
530	struct acpi_thermal *tz = thermal->devdata;
531	int result;
532
533	if (!tz)
534		return -EINVAL;
535
536	result = acpi_thermal_get_temperature(tz);
537	if (result)
538		return result;
539
540	*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(tz->temperature,
541							tz->kelvin_offset);
542	return 0;
543}
544
545static int thermal_get_mode(struct thermal_zone_device *thermal,
546				enum thermal_device_mode *mode)
547{
548	struct acpi_thermal *tz = thermal->devdata;
549
550	if (!tz)
551		return -EINVAL;
552
553	*mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
554		THERMAL_DEVICE_DISABLED;
555
556	return 0;
557}
558
559static int thermal_set_mode(struct thermal_zone_device *thermal,
560				enum thermal_device_mode mode)
561{
562	struct acpi_thermal *tz = thermal->devdata;
563	int enable;
564
565	if (!tz)
566		return -EINVAL;
567
568	/*
569	 * enable/disable thermal management from ACPI thermal driver
570	 */
571	if (mode == THERMAL_DEVICE_ENABLED)
572		enable = 1;
573	else if (mode == THERMAL_DEVICE_DISABLED) {
574		enable = 0;
575		pr_warn("thermal zone will be disabled\n");
576	} else
577		return -EINVAL;
578
579	if (enable != tz->tz_enabled) {
580		tz->tz_enabled = enable;
581		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
582			"%s kernel ACPI thermal control\n",
583			tz->tz_enabled ? "Enable" : "Disable"));
584		acpi_thermal_check(tz);
585	}
586	return 0;
587}
588
589static int thermal_get_trip_type(struct thermal_zone_device *thermal,
590				 int trip, enum thermal_trip_type *type)
591{
592	struct acpi_thermal *tz = thermal->devdata;
593	int i;
594
595	if (!tz || trip < 0)
596		return -EINVAL;
597
598	if (tz->trips.critical.flags.valid) {
599		if (!trip) {
600			*type = THERMAL_TRIP_CRITICAL;
601			return 0;
602		}
603		trip--;
604	}
605
606	if (tz->trips.hot.flags.valid) {
607		if (!trip) {
608			*type = THERMAL_TRIP_HOT;
609			return 0;
610		}
611		trip--;
612	}
613
614	if (tz->trips.passive.flags.valid) {
615		if (!trip) {
616			*type = THERMAL_TRIP_PASSIVE;
617			return 0;
618		}
619		trip--;
620	}
621
622	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
623		tz->trips.active[i].flags.valid; i++) {
624		if (!trip) {
625			*type = THERMAL_TRIP_ACTIVE;
626			return 0;
627		}
628		trip--;
629	}
630
631	return -EINVAL;
632}
633
634static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
635				 int trip, int *temp)
636{
637	struct acpi_thermal *tz = thermal->devdata;
638	int i;
639
640	if (!tz || trip < 0)
641		return -EINVAL;
642
643	if (tz->trips.critical.flags.valid) {
644		if (!trip) {
645			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
646				tz->trips.critical.temperature,
647				tz->kelvin_offset);
648			return 0;
649		}
650		trip--;
651	}
652
653	if (tz->trips.hot.flags.valid) {
654		if (!trip) {
655			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
656				tz->trips.hot.temperature,
657				tz->kelvin_offset);
658			return 0;
659		}
660		trip--;
661	}
662
663	if (tz->trips.passive.flags.valid) {
664		if (!trip) {
665			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
666				tz->trips.passive.temperature,
667				tz->kelvin_offset);
668			return 0;
669		}
670		trip--;
671	}
672
673	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
674		tz->trips.active[i].flags.valid; i++) {
675		if (!trip) {
676			*temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
677				tz->trips.active[i].temperature,
678				tz->kelvin_offset);
679			return 0;
680		}
681		trip--;
682	}
683
684	return -EINVAL;
685}
686
687static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
688				int *temperature)
689{
690	struct acpi_thermal *tz = thermal->devdata;
691
692	if (tz->trips.critical.flags.valid) {
693		*temperature = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
694				tz->trips.critical.temperature,
695				tz->kelvin_offset);
696		return 0;
697	} else
698		return -EINVAL;
699}
700
701static int thermal_get_trend(struct thermal_zone_device *thermal,
702				int trip, enum thermal_trend *trend)
703{
704	struct acpi_thermal *tz = thermal->devdata;
705	enum thermal_trip_type type;
706	int i;
707
708	if (thermal_get_trip_type(thermal, trip, &type))
709		return -EINVAL;
710
711	if (type == THERMAL_TRIP_ACTIVE) {
712		int trip_temp;
713		int temp = DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(
714					tz->temperature, tz->kelvin_offset);
715		if (thermal_get_trip_temp(thermal, trip, &trip_temp))
716			return -EINVAL;
717
718		if (temp > trip_temp) {
719			*trend = THERMAL_TREND_RAISING;
720			return 0;
721		} else {
722			/* Fall back on default trend */
723			return -EINVAL;
724		}
725	}
726
727	/*
728	 * tz->temperature has already been updated by generic thermal layer,
729	 * before this callback being invoked
730	 */
731	i = (tz->trips.passive.tc1 * (tz->temperature - tz->last_temperature))
732		+ (tz->trips.passive.tc2
733		* (tz->temperature - tz->trips.passive.temperature));
734
735	if (i > 0)
736		*trend = THERMAL_TREND_RAISING;
737	else if (i < 0)
738		*trend = THERMAL_TREND_DROPPING;
739	else
740		*trend = THERMAL_TREND_STABLE;
741	return 0;
742}
743
744
745static int thermal_notify(struct thermal_zone_device *thermal, int trip,
746			   enum thermal_trip_type trip_type)
747{
748	u8 type = 0;
749	struct acpi_thermal *tz = thermal->devdata;
750
751	if (trip_type == THERMAL_TRIP_CRITICAL)
752		type = ACPI_THERMAL_NOTIFY_CRITICAL;
753	else if (trip_type == THERMAL_TRIP_HOT)
754		type = ACPI_THERMAL_NOTIFY_HOT;
755	else
756		return 0;
757
758	acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
759					dev_name(&tz->device->dev), type, 1);
760
761	if (trip_type == THERMAL_TRIP_CRITICAL && nocrt)
762		return 1;
763
764	return 0;
765}
766
767static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
768					struct thermal_cooling_device *cdev,
769					bool bind)
770{
771	struct acpi_device *device = cdev->devdata;
772	struct acpi_thermal *tz = thermal->devdata;
773	struct acpi_device *dev;
774	acpi_status status;
775	acpi_handle handle;
776	int i;
777	int j;
778	int trip = -1;
779	int result = 0;
780
781	if (tz->trips.critical.flags.valid)
782		trip++;
783
784	if (tz->trips.hot.flags.valid)
785		trip++;
786
787	if (tz->trips.passive.flags.valid) {
788		trip++;
789		for (i = 0; i < tz->trips.passive.devices.count;
790		    i++) {
791			handle = tz->trips.passive.devices.handles[i];
792			status = acpi_bus_get_device(handle, &dev);
793			if (ACPI_FAILURE(status) || dev != device)
794				continue;
795			if (bind)
796				result =
797					thermal_zone_bind_cooling_device
798					(thermal, trip, cdev,
799					 THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
800					 THERMAL_WEIGHT_DEFAULT);
801			else
802				result =
803					thermal_zone_unbind_cooling_device
804					(thermal, trip, cdev);
805			if (result)
806				goto failed;
807		}
808	}
809
810	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
811		if (!tz->trips.active[i].flags.valid)
812			break;
813		trip++;
814		for (j = 0;
815		    j < tz->trips.active[i].devices.count;
816		    j++) {
817			handle = tz->trips.active[i].devices.handles[j];
818			status = acpi_bus_get_device(handle, &dev);
819			if (ACPI_FAILURE(status) || dev != device)
820				continue;
821			if (bind)
822				result = thermal_zone_bind_cooling_device
823					(thermal, trip, cdev,
824					 THERMAL_NO_LIMIT, THERMAL_NO_LIMIT,
825					 THERMAL_WEIGHT_DEFAULT);
826			else
827				result = thermal_zone_unbind_cooling_device
828					(thermal, trip, cdev);
829			if (result)
830				goto failed;
831		}
832	}
833
834	for (i = 0; i < tz->devices.count; i++) {
835		handle = tz->devices.handles[i];
836		status = acpi_bus_get_device(handle, &dev);
837		if (ACPI_SUCCESS(status) && (dev == device)) {
838			if (bind)
839				result = thermal_zone_bind_cooling_device
840						(thermal, THERMAL_TRIPS_NONE,
841						 cdev, THERMAL_NO_LIMIT,
842						 THERMAL_NO_LIMIT,
843						 THERMAL_WEIGHT_DEFAULT);
844			else
845				result = thermal_zone_unbind_cooling_device
846						(thermal, THERMAL_TRIPS_NONE,
847						 cdev);
848			if (result)
849				goto failed;
850		}
851	}
852
853failed:
854	return result;
855}
856
857static int
858acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
859					struct thermal_cooling_device *cdev)
860{
861	return acpi_thermal_cooling_device_cb(thermal, cdev, true);
862}
863
864static int
865acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
866					struct thermal_cooling_device *cdev)
867{
868	return acpi_thermal_cooling_device_cb(thermal, cdev, false);
869}
870
871static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
872	.bind = acpi_thermal_bind_cooling_device,
873	.unbind	= acpi_thermal_unbind_cooling_device,
874	.get_temp = thermal_get_temp,
875	.get_mode = thermal_get_mode,
876	.set_mode = thermal_set_mode,
877	.get_trip_type = thermal_get_trip_type,
878	.get_trip_temp = thermal_get_trip_temp,
879	.get_crit_temp = thermal_get_crit_temp,
880	.get_trend = thermal_get_trend,
881	.notify = thermal_notify,
882};
883
884static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
885{
886	int trips = 0;
887	int result;
888	acpi_status status;
889	int i;
890
891	if (tz->trips.critical.flags.valid)
892		trips++;
893
894	if (tz->trips.hot.flags.valid)
895		trips++;
896
897	if (tz->trips.passive.flags.valid)
898		trips++;
899
900	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
901			tz->trips.active[i].flags.valid; i++, trips++);
902
903	if (tz->trips.passive.flags.valid)
904		tz->thermal_zone =
905			thermal_zone_device_register("acpitz", trips, 0, tz,
906						&acpi_thermal_zone_ops, NULL,
907						     tz->trips.passive.tsp*100,
908						     tz->polling_frequency*100);
909	else
910		tz->thermal_zone =
911			thermal_zone_device_register("acpitz", trips, 0, tz,
912						&acpi_thermal_zone_ops, NULL,
913						0, tz->polling_frequency*100);
914	if (IS_ERR(tz->thermal_zone))
915		return -ENODEV;
916
917	result = sysfs_create_link(&tz->device->dev.kobj,
918				   &tz->thermal_zone->device.kobj, "thermal_zone");
919	if (result)
920		return result;
921
922	result = sysfs_create_link(&tz->thermal_zone->device.kobj,
923				   &tz->device->dev.kobj, "device");
924	if (result)
925		return result;
926
927	status =  acpi_bus_attach_private_data(tz->device->handle,
928					       tz->thermal_zone);
929	if (ACPI_FAILURE(status))
930		return -ENODEV;
931
932	tz->tz_enabled = 1;
933
934	dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
935		 tz->thermal_zone->id);
936	return 0;
937}
938
939static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
940{
941	sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
942	sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
943	thermal_zone_device_unregister(tz->thermal_zone);
944	tz->thermal_zone = NULL;
945	acpi_bus_detach_private_data(tz->device->handle);
946}
947
948
949/* --------------------------------------------------------------------------
950                                 Driver Interface
951   -------------------------------------------------------------------------- */
952
953static void acpi_thermal_notify(struct acpi_device *device, u32 event)
954{
955	struct acpi_thermal *tz = acpi_driver_data(device);
956
957
958	if (!tz)
959		return;
960
961	switch (event) {
962	case ACPI_THERMAL_NOTIFY_TEMPERATURE:
963		acpi_thermal_check(tz);
964		break;
965	case ACPI_THERMAL_NOTIFY_THRESHOLDS:
966		acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
967		acpi_thermal_check(tz);
968		acpi_bus_generate_netlink_event(device->pnp.device_class,
969						  dev_name(&device->dev), event, 0);
970		break;
971	case ACPI_THERMAL_NOTIFY_DEVICES:
972		acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
973		acpi_thermal_check(tz);
974		acpi_bus_generate_netlink_event(device->pnp.device_class,
975						  dev_name(&device->dev), event, 0);
976		break;
977	default:
978		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
979				  "Unsupported event [0x%x]\n", event));
980		break;
981	}
982}
983
984/*
985 * On some platforms, the AML code has dependency about
986 * the evaluating order of _TMP and _CRT/_HOT/_PSV/_ACx.
987 * 1. On HP Pavilion G4-1016tx, _TMP must be invoked after
988 *    /_CRT/_HOT/_PSV/_ACx, or else system will be power off.
989 * 2. On HP Compaq 6715b/6715s, the return value of _PSV is 0
990 *    if _TMP has never been evaluated.
991 *
992 * As this dependency is totally transparent to OS, evaluate
993 * all of them once, in the order of _CRT/_HOT/_PSV/_ACx,
994 * _TMP, before they are actually used.
995 */
996static void acpi_thermal_aml_dependency_fix(struct acpi_thermal *tz)
997{
998	acpi_handle handle = tz->device->handle;
999	unsigned long long value;
1000	int i;
1001
1002	acpi_evaluate_integer(handle, "_CRT", NULL, &value);
1003	acpi_evaluate_integer(handle, "_HOT", NULL, &value);
1004	acpi_evaluate_integer(handle, "_PSV", NULL, &value);
1005	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1006		char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
1007		acpi_status status;
1008
1009		status = acpi_evaluate_integer(handle, name, NULL, &value);
1010		if (status == AE_NOT_FOUND)
1011			break;
1012	}
1013	acpi_evaluate_integer(handle, "_TMP", NULL, &value);
1014}
1015
1016static int acpi_thermal_get_info(struct acpi_thermal *tz)
1017{
1018	int result = 0;
1019
1020
1021	if (!tz)
1022		return -EINVAL;
1023
1024	acpi_thermal_aml_dependency_fix(tz);
1025
1026	/* Get trip points [_CRT, _PSV, etc.] (required) */
1027	result = acpi_thermal_get_trip_points(tz);
1028	if (result)
1029		return result;
1030
1031	/* Get temperature [_TMP] (required) */
1032	result = acpi_thermal_get_temperature(tz);
1033	if (result)
1034		return result;
1035
1036	/* Set the cooling mode [_SCP] to active cooling (default) */
1037	result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
1038	if (!result)
1039		tz->flags.cooling_mode = 1;
1040
1041	/* Get default polling frequency [_TZP] (optional) */
1042	if (tzp)
1043		tz->polling_frequency = tzp;
1044	else
1045		acpi_thermal_get_polling_frequency(tz);
1046
1047	return 0;
1048}
1049
1050/*
1051 * The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
1052 * handles temperature values with a single decimal place. As a consequence,
1053 * some implementations use an offset of 273.1 and others use an offset of
1054 * 273.2. Try to find out which one is being used, to present the most
1055 * accurate and visually appealing number.
1056 *
1057 * The heuristic below should work for all ACPI thermal zones which have a
1058 * critical trip point with a value being a multiple of 0.5 degree Celsius.
1059 */
1060static void acpi_thermal_guess_offset(struct acpi_thermal *tz)
1061{
1062	if (tz->trips.critical.flags.valid &&
1063	    (tz->trips.critical.temperature % 5) == 1)
1064		tz->kelvin_offset = 2731;
1065	else
1066		tz->kelvin_offset = 2732;
1067}
1068
1069static void acpi_thermal_check_fn(struct work_struct *work)
1070{
1071	struct acpi_thermal *tz = container_of(work, struct acpi_thermal,
1072					       thermal_check_work);
1073	acpi_thermal_check(tz);
1074}
1075
1076static int acpi_thermal_add(struct acpi_device *device)
1077{
1078	int result = 0;
1079	struct acpi_thermal *tz = NULL;
1080
1081
1082	if (!device)
1083		return -EINVAL;
1084
1085	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
1086	if (!tz)
1087		return -ENOMEM;
1088
1089	tz->device = device;
1090	strcpy(tz->name, device->pnp.bus_id);
1091	strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
1092	strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1093	device->driver_data = tz;
1094
1095	result = acpi_thermal_get_info(tz);
1096	if (result)
1097		goto free_memory;
1098
1099	acpi_thermal_guess_offset(tz);
1100
1101	result = acpi_thermal_register_thermal_zone(tz);
1102	if (result)
1103		goto free_memory;
1104
1105	INIT_WORK(&tz->thermal_check_work, acpi_thermal_check_fn);
1106
1107	pr_info(PREFIX "%s [%s] (%ld C)\n", acpi_device_name(device),
1108		acpi_device_bid(device), DECI_KELVIN_TO_CELSIUS(tz->temperature));
1109	goto end;
1110
1111free_memory:
1112	kfree(tz);
1113end:
1114	return result;
1115}
1116
1117static int acpi_thermal_remove(struct acpi_device *device)
1118{
1119	struct acpi_thermal *tz = NULL;
1120
1121	if (!device || !acpi_driver_data(device))
1122		return -EINVAL;
1123
1124	flush_workqueue(acpi_thermal_pm_queue);
1125	tz = acpi_driver_data(device);
1126
1127	acpi_thermal_unregister_thermal_zone(tz);
1128	kfree(tz);
1129	return 0;
1130}
1131
1132#ifdef CONFIG_PM_SLEEP
1133static int acpi_thermal_suspend(struct device *dev)
1134{
1135	/* Make sure the previously queued thermal check work has been done */
1136	flush_workqueue(acpi_thermal_pm_queue);
1137	return 0;
1138}
1139
1140static int acpi_thermal_resume(struct device *dev)
1141{
1142	struct acpi_thermal *tz;
1143	int i, j, power_state, result;
1144
1145	if (!dev)
1146		return -EINVAL;
1147
1148	tz = acpi_driver_data(to_acpi_device(dev));
1149	if (!tz)
1150		return -EINVAL;
1151
1152	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1153		if (!(&tz->trips.active[i]))
1154			break;
1155		if (!tz->trips.active[i].flags.valid)
1156			break;
1157		tz->trips.active[i].flags.enabled = 1;
1158		for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1159			result = acpi_bus_update_power(
1160					tz->trips.active[i].devices.handles[j],
1161					&power_state);
1162			if (result || (power_state != ACPI_STATE_D0)) {
1163				tz->trips.active[i].flags.enabled = 0;
1164				break;
1165			}
1166		}
1167		tz->state.active |= tz->trips.active[i].flags.enabled;
1168	}
1169
1170	queue_work(acpi_thermal_pm_queue, &tz->thermal_check_work);
1171
1172	return AE_OK;
1173}
1174#endif
1175
1176static int thermal_act(const struct dmi_system_id *d) {
1177
1178	if (act == 0) {
1179		pr_notice(PREFIX "%s detected: "
1180			  "disabling all active thermal trip points\n", d->ident);
1181		act = -1;
1182	}
1183	return 0;
1184}
1185static int thermal_nocrt(const struct dmi_system_id *d) {
1186
1187	pr_notice(PREFIX "%s detected: "
1188		  "disabling all critical thermal trip point actions.\n", d->ident);
1189	nocrt = 1;
1190	return 0;
1191}
1192static int thermal_tzp(const struct dmi_system_id *d) {
1193
1194	if (tzp == 0) {
1195		pr_notice(PREFIX "%s detected: "
1196			  "enabling thermal zone polling\n", d->ident);
1197		tzp = 300;	/* 300 dS = 30 Seconds */
1198	}
1199	return 0;
1200}
1201static int thermal_psv(const struct dmi_system_id *d) {
1202
1203	if (psv == 0) {
1204		pr_notice(PREFIX "%s detected: "
1205			  "disabling all passive thermal trip points\n", d->ident);
1206		psv = -1;
1207	}
1208	return 0;
1209}
1210
1211static struct dmi_system_id thermal_dmi_table[] __initdata = {
1212	/*
1213	 * Award BIOS on this AOpen makes thermal control almost worthless.
1214	 * http://bugzilla.kernel.org/show_bug.cgi?id=8842
1215	 */
1216	{
1217	 .callback = thermal_act,
1218	 .ident = "AOpen i915GMm-HFS",
1219	 .matches = {
1220		DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1221		DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1222		},
1223	},
1224	{
1225	 .callback = thermal_psv,
1226	 .ident = "AOpen i915GMm-HFS",
1227	 .matches = {
1228		DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1229		DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1230		},
1231	},
1232	{
1233	 .callback = thermal_tzp,
1234	 .ident = "AOpen i915GMm-HFS",
1235	 .matches = {
1236		DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
1237		DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
1238		},
1239	},
1240	{
1241	 .callback = thermal_nocrt,
1242	 .ident = "Gigabyte GA-7ZX",
1243	 .matches = {
1244		DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
1245		DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
1246		},
1247	},
1248	{}
1249};
1250
1251static int __init acpi_thermal_init(void)
1252{
1253	int result = 0;
1254
1255	dmi_check_system(thermal_dmi_table);
1256
1257	if (off) {
1258		pr_notice(PREFIX "thermal control disabled\n");
1259		return -ENODEV;
1260	}
1261
1262	acpi_thermal_pm_queue = create_workqueue("acpi_thermal_pm");
1263	if (!acpi_thermal_pm_queue)
1264		return -ENODEV;
1265
1266	result = acpi_bus_register_driver(&acpi_thermal_driver);
1267	if (result < 0) {
1268		destroy_workqueue(acpi_thermal_pm_queue);
1269		return -ENODEV;
1270	}
1271
1272	return 0;
1273}
1274
1275static void __exit acpi_thermal_exit(void)
1276{
1277	acpi_bus_unregister_driver(&acpi_thermal_driver);
1278	destroy_workqueue(acpi_thermal_pm_queue);
1279
1280	return;
1281}
1282
1283module_init(acpi_thermal_init);
1284module_exit(acpi_thermal_exit);
1285