2 * thermal.c - Generic Thermal Management Sysfs support.
4 * Copyright (C) 2008 Intel Corp
5 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
6 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
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.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 #include <linux/module.h>
27 #include <linux/device.h>
28 #include <linux/err.h>
29 #include <linux/slab.h>
30 #include <linux/kdev_t.h>
31 #include <linux/idr.h>
32 #include <linux/thermal.h>
33 #include <linux/spinlock.h>
34 #include <linux/reboot.h>
36 MODULE_AUTHOR("Zhang Rui");
37 MODULE_DESCRIPTION("Generic thermal management sysfs support");
38 MODULE_LICENSE("GPL");
40 #define PREFIX "Thermal: "
42 struct thermal_cooling_device_instance
{
44 char name
[THERMAL_NAME_LENGTH
];
45 struct thermal_zone_device
*tz
;
46 struct thermal_cooling_device
*cdev
;
48 char attr_name
[THERMAL_NAME_LENGTH
];
49 struct device_attribute attr
;
50 struct list_head node
;
53 static DEFINE_IDR(thermal_tz_idr
);
54 static DEFINE_IDR(thermal_cdev_idr
);
55 static DEFINE_MUTEX(thermal_idr_lock
);
57 static LIST_HEAD(thermal_tz_list
);
58 static LIST_HEAD(thermal_cdev_list
);
59 static DEFINE_MUTEX(thermal_list_lock
);
61 static int get_idr(struct idr
*idr
, struct mutex
*lock
, int *id
)
66 if (unlikely(idr_pre_get(idr
, GFP_KERNEL
) == 0))
71 err
= idr_get_new(idr
, NULL
, id
);
74 if (unlikely(err
== -EAGAIN
))
76 else if (unlikely(err
))
79 *id
= *id
& MAX_ID_MASK
;
83 static void release_idr(struct idr
*idr
, struct mutex
*lock
, int id
)
92 /* sys I/F for thermal zone */
94 #define to_thermal_zone(_dev) \
95 container_of(_dev, struct thermal_zone_device, device)
98 type_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
100 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
102 return sprintf(buf
, "%s\n", tz
->type
);
106 temp_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
108 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
112 if (!tz
->ops
->get_temp
)
115 ret
= tz
->ops
->get_temp(tz
, &temperature
);
120 return sprintf(buf
, "%ld\n", temperature
);
124 mode_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
126 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
127 enum thermal_device_mode mode
;
130 if (!tz
->ops
->get_mode
)
133 result
= tz
->ops
->get_mode(tz
, &mode
);
137 return sprintf(buf
, "%s\n", mode
== THERMAL_DEVICE_ENABLED
? "enabled"
142 mode_store(struct device
*dev
, struct device_attribute
*attr
,
143 const char *buf
, size_t count
)
145 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
148 if (!tz
->ops
->set_mode
)
151 if (!strncmp(buf
, "enabled", sizeof("enabled")))
152 result
= tz
->ops
->set_mode(tz
, THERMAL_DEVICE_ENABLED
);
153 else if (!strncmp(buf
, "disabled", sizeof("disabled")))
154 result
= tz
->ops
->set_mode(tz
, THERMAL_DEVICE_DISABLED
);
165 trip_point_type_show(struct device
*dev
, struct device_attribute
*attr
,
168 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
169 enum thermal_trip_type type
;
172 if (!tz
->ops
->get_trip_type
)
175 if (!sscanf(attr
->attr
.name
, "trip_point_%d_type", &trip
))
178 result
= tz
->ops
->get_trip_type(tz
, trip
, &type
);
183 case THERMAL_TRIP_CRITICAL
:
184 return sprintf(buf
, "critical\n");
185 case THERMAL_TRIP_HOT
:
186 return sprintf(buf
, "hot\n");
187 case THERMAL_TRIP_PASSIVE
:
188 return sprintf(buf
, "passive\n");
189 case THERMAL_TRIP_ACTIVE
:
190 return sprintf(buf
, "active\n");
192 return sprintf(buf
, "unknown\n");
197 trip_point_temp_show(struct device
*dev
, struct device_attribute
*attr
,
200 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
204 if (!tz
->ops
->get_trip_temp
)
207 if (!sscanf(attr
->attr
.name
, "trip_point_%d_temp", &trip
))
210 ret
= tz
->ops
->get_trip_temp(tz
, trip
, &temperature
);
215 return sprintf(buf
, "%ld\n", temperature
);
219 passive_store(struct device
*dev
, struct device_attribute
*attr
,
220 const char *buf
, size_t count
)
222 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
223 struct thermal_cooling_device
*cdev
= NULL
;
226 if (!sscanf(buf
, "%d\n", &state
))
229 /* sanity check: values below 1000 millicelcius don't make sense
230 * and can cause the system to go into a thermal heart attack
232 if (state
&& state
< 1000)
235 if (state
&& !tz
->forced_passive
) {
236 mutex_lock(&thermal_list_lock
);
237 list_for_each_entry(cdev
, &thermal_cdev_list
, node
) {
238 if (!strncmp("Processor", cdev
->type
,
239 sizeof("Processor")))
240 thermal_zone_bind_cooling_device(tz
,
244 mutex_unlock(&thermal_list_lock
);
245 if (!tz
->passive_delay
)
246 tz
->passive_delay
= 1000;
247 } else if (!state
&& tz
->forced_passive
) {
248 mutex_lock(&thermal_list_lock
);
249 list_for_each_entry(cdev
, &thermal_cdev_list
, node
) {
250 if (!strncmp("Processor", cdev
->type
,
251 sizeof("Processor")))
252 thermal_zone_unbind_cooling_device(tz
,
256 mutex_unlock(&thermal_list_lock
);
257 tz
->passive_delay
= 0;
263 tz
->forced_passive
= state
;
265 thermal_zone_device_update(tz
);
271 passive_show(struct device
*dev
, struct device_attribute
*attr
,
274 struct thermal_zone_device
*tz
= to_thermal_zone(dev
);
276 return sprintf(buf
, "%d\n", tz
->forced_passive
);
279 static DEVICE_ATTR(type
, 0444, type_show
, NULL
);
280 static DEVICE_ATTR(temp
, 0444, temp_show
, NULL
);
281 static DEVICE_ATTR(mode
, 0644, mode_show
, mode_store
);
282 static DEVICE_ATTR(passive
, S_IRUGO
| S_IWUSR
, passive_show
, \
285 static struct device_attribute trip_point_attrs
[] = {
286 __ATTR(trip_point_0_type
, 0444, trip_point_type_show
, NULL
),
287 __ATTR(trip_point_0_temp
, 0444, trip_point_temp_show
, NULL
),
288 __ATTR(trip_point_1_type
, 0444, trip_point_type_show
, NULL
),
289 __ATTR(trip_point_1_temp
, 0444, trip_point_temp_show
, NULL
),
290 __ATTR(trip_point_2_type
, 0444, trip_point_type_show
, NULL
),
291 __ATTR(trip_point_2_temp
, 0444, trip_point_temp_show
, NULL
),
292 __ATTR(trip_point_3_type
, 0444, trip_point_type_show
, NULL
),
293 __ATTR(trip_point_3_temp
, 0444, trip_point_temp_show
, NULL
),
294 __ATTR(trip_point_4_type
, 0444, trip_point_type_show
, NULL
),
295 __ATTR(trip_point_4_temp
, 0444, trip_point_temp_show
, NULL
),
296 __ATTR(trip_point_5_type
, 0444, trip_point_type_show
, NULL
),
297 __ATTR(trip_point_5_temp
, 0444, trip_point_temp_show
, NULL
),
298 __ATTR(trip_point_6_type
, 0444, trip_point_type_show
, NULL
),
299 __ATTR(trip_point_6_temp
, 0444, trip_point_temp_show
, NULL
),
300 __ATTR(trip_point_7_type
, 0444, trip_point_type_show
, NULL
),
301 __ATTR(trip_point_7_temp
, 0444, trip_point_temp_show
, NULL
),
302 __ATTR(trip_point_8_type
, 0444, trip_point_type_show
, NULL
),
303 __ATTR(trip_point_8_temp
, 0444, trip_point_temp_show
, NULL
),
304 __ATTR(trip_point_9_type
, 0444, trip_point_type_show
, NULL
),
305 __ATTR(trip_point_9_temp
, 0444, trip_point_temp_show
, NULL
),
306 __ATTR(trip_point_10_type
, 0444, trip_point_type_show
, NULL
),
307 __ATTR(trip_point_10_temp
, 0444, trip_point_temp_show
, NULL
),
308 __ATTR(trip_point_11_type
, 0444, trip_point_type_show
, NULL
),
309 __ATTR(trip_point_11_temp
, 0444, trip_point_temp_show
, NULL
),
312 #define TRIP_POINT_ATTR_ADD(_dev, _index, result) \
314 result = device_create_file(_dev, \
315 &trip_point_attrs[_index * 2]); \
318 result = device_create_file(_dev, \
319 &trip_point_attrs[_index * 2 + 1]); \
322 #define TRIP_POINT_ATTR_REMOVE(_dev, _index) \
324 device_remove_file(_dev, &trip_point_attrs[_index * 2]); \
325 device_remove_file(_dev, &trip_point_attrs[_index * 2 + 1]); \
328 /* sys I/F for cooling device */
329 #define to_cooling_device(_dev) \
330 container_of(_dev, struct thermal_cooling_device, device)
333 thermal_cooling_device_type_show(struct device
*dev
,
334 struct device_attribute
*attr
, char *buf
)
336 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
338 return sprintf(buf
, "%s\n", cdev
->type
);
342 thermal_cooling_device_max_state_show(struct device
*dev
,
343 struct device_attribute
*attr
, char *buf
)
345 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
349 ret
= cdev
->ops
->get_max_state(cdev
, &state
);
352 return sprintf(buf
, "%ld\n", state
);
356 thermal_cooling_device_cur_state_show(struct device
*dev
,
357 struct device_attribute
*attr
, char *buf
)
359 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
363 ret
= cdev
->ops
->get_cur_state(cdev
, &state
);
366 return sprintf(buf
, "%ld\n", state
);
370 thermal_cooling_device_cur_state_store(struct device
*dev
,
371 struct device_attribute
*attr
,
372 const char *buf
, size_t count
)
374 struct thermal_cooling_device
*cdev
= to_cooling_device(dev
);
378 if (!sscanf(buf
, "%ld\n", &state
))
384 result
= cdev
->ops
->set_cur_state(cdev
, state
);
390 static struct device_attribute dev_attr_cdev_type
=
391 __ATTR(type
, 0444, thermal_cooling_device_type_show
, NULL
);
392 static DEVICE_ATTR(max_state
, 0444,
393 thermal_cooling_device_max_state_show
, NULL
);
394 static DEVICE_ATTR(cur_state
, 0644,
395 thermal_cooling_device_cur_state_show
,
396 thermal_cooling_device_cur_state_store
);
399 thermal_cooling_device_trip_point_show(struct device
*dev
,
400 struct device_attribute
*attr
, char *buf
)
402 struct thermal_cooling_device_instance
*instance
;
405 container_of(attr
, struct thermal_cooling_device_instance
, attr
);
407 if (instance
->trip
== THERMAL_TRIPS_NONE
)
408 return sprintf(buf
, "-1\n");
410 return sprintf(buf
, "%d\n", instance
->trip
);
413 /* Device management */
415 #if defined(CONFIG_THERMAL_HWMON)
418 #include <linux/hwmon.h>
419 static LIST_HEAD(thermal_hwmon_list
);
422 name_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
424 struct thermal_hwmon_device
*hwmon
= dev_get_drvdata(dev
);
425 return sprintf(buf
, "%s\n", hwmon
->type
);
427 static DEVICE_ATTR(name
, 0444, name_show
, NULL
);
430 temp_input_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
434 struct thermal_hwmon_attr
*hwmon_attr
435 = container_of(attr
, struct thermal_hwmon_attr
, attr
);
436 struct thermal_zone_device
*tz
437 = container_of(hwmon_attr
, struct thermal_zone_device
,
440 ret
= tz
->ops
->get_temp(tz
, &temperature
);
445 return sprintf(buf
, "%ld\n", temperature
);
449 temp_crit_show(struct device
*dev
, struct device_attribute
*attr
,
452 struct thermal_hwmon_attr
*hwmon_attr
453 = container_of(attr
, struct thermal_hwmon_attr
, attr
);
454 struct thermal_zone_device
*tz
455 = container_of(hwmon_attr
, struct thermal_zone_device
,
460 ret
= tz
->ops
->get_trip_temp(tz
, 0, &temperature
);
464 return sprintf(buf
, "%ld\n", temperature
);
469 thermal_add_hwmon_sysfs(struct thermal_zone_device
*tz
)
471 struct thermal_hwmon_device
*hwmon
;
472 int new_hwmon_device
= 1;
475 mutex_lock(&thermal_list_lock
);
476 list_for_each_entry(hwmon
, &thermal_hwmon_list
, node
)
477 if (!strcmp(hwmon
->type
, tz
->type
)) {
478 new_hwmon_device
= 0;
479 mutex_unlock(&thermal_list_lock
);
480 goto register_sys_interface
;
482 mutex_unlock(&thermal_list_lock
);
484 hwmon
= kzalloc(sizeof(struct thermal_hwmon_device
), GFP_KERNEL
);
488 INIT_LIST_HEAD(&hwmon
->tz_list
);
489 strlcpy(hwmon
->type
, tz
->type
, THERMAL_NAME_LENGTH
);
490 hwmon
->device
= hwmon_device_register(NULL
);
491 if (IS_ERR(hwmon
->device
)) {
492 result
= PTR_ERR(hwmon
->device
);
495 dev_set_drvdata(hwmon
->device
, hwmon
);
496 result
= device_create_file(hwmon
->device
, &dev_attr_name
);
498 goto unregister_hwmon_device
;
500 register_sys_interface
:
504 snprintf(tz
->temp_input
.name
, THERMAL_NAME_LENGTH
,
505 "temp%d_input", hwmon
->count
);
506 tz
->temp_input
.attr
.attr
.name
= tz
->temp_input
.name
;
507 tz
->temp_input
.attr
.attr
.mode
= 0444;
508 tz
->temp_input
.attr
.show
= temp_input_show
;
509 result
= device_create_file(hwmon
->device
, &tz
->temp_input
.attr
);
511 goto unregister_hwmon_device
;
513 if (tz
->ops
->get_crit_temp
) {
514 unsigned long temperature
;
515 if (!tz
->ops
->get_crit_temp(tz
, &temperature
)) {
516 snprintf(tz
->temp_crit
.name
, THERMAL_NAME_LENGTH
,
517 "temp%d_crit", hwmon
->count
);
518 tz
->temp_crit
.attr
.attr
.name
= tz
->temp_crit
.name
;
519 tz
->temp_crit
.attr
.attr
.mode
= 0444;
520 tz
->temp_crit
.attr
.show
= temp_crit_show
;
521 result
= device_create_file(hwmon
->device
,
522 &tz
->temp_crit
.attr
);
524 goto unregister_hwmon_device
;
528 mutex_lock(&thermal_list_lock
);
529 if (new_hwmon_device
)
530 list_add_tail(&hwmon
->node
, &thermal_hwmon_list
);
531 list_add_tail(&tz
->hwmon_node
, &hwmon
->tz_list
);
532 mutex_unlock(&thermal_list_lock
);
536 unregister_hwmon_device
:
537 device_remove_file(hwmon
->device
, &tz
->temp_crit
.attr
);
538 device_remove_file(hwmon
->device
, &tz
->temp_input
.attr
);
539 if (new_hwmon_device
) {
540 device_remove_file(hwmon
->device
, &dev_attr_name
);
541 hwmon_device_unregister(hwmon
->device
);
544 if (new_hwmon_device
)
551 thermal_remove_hwmon_sysfs(struct thermal_zone_device
*tz
)
553 struct thermal_hwmon_device
*hwmon
= tz
->hwmon
;
556 device_remove_file(hwmon
->device
, &tz
->temp_input
.attr
);
557 device_remove_file(hwmon
->device
, &tz
->temp_crit
.attr
);
559 mutex_lock(&thermal_list_lock
);
560 list_del(&tz
->hwmon_node
);
561 if (!list_empty(&hwmon
->tz_list
)) {
562 mutex_unlock(&thermal_list_lock
);
565 list_del(&hwmon
->node
);
566 mutex_unlock(&thermal_list_lock
);
568 device_remove_file(hwmon
->device
, &dev_attr_name
);
569 hwmon_device_unregister(hwmon
->device
);
574 thermal_add_hwmon_sysfs(struct thermal_zone_device
*tz
)
580 thermal_remove_hwmon_sysfs(struct thermal_zone_device
*tz
)
585 static void thermal_zone_device_set_polling(struct thermal_zone_device
*tz
,
588 cancel_delayed_work(&(tz
->poll_queue
));
594 schedule_delayed_work(&(tz
->poll_queue
),
595 round_jiffies(msecs_to_jiffies(delay
)));
597 schedule_delayed_work(&(tz
->poll_queue
),
598 msecs_to_jiffies(delay
));
601 static void thermal_zone_device_passive(struct thermal_zone_device
*tz
,
602 int temp
, int trip_temp
, int trip
)
605 struct thermal_cooling_device_instance
*instance
;
606 struct thermal_cooling_device
*cdev
;
607 long state
, max_state
;
612 * Calculate the thermal trend (using the passive cooling equation)
613 * and modify the performance limit for all passive cooling devices
614 * accordingly. Note that we assume symmetry.
616 if (temp
>= trip_temp
) {
619 trend
= (tz
->tc1
* (temp
- tz
->last_temperature
)) +
620 (tz
->tc2
* (temp
- trip_temp
));
624 list_for_each_entry(instance
, &tz
->cooling_devices
,
626 if (instance
->trip
!= trip
)
628 cdev
= instance
->cdev
;
629 cdev
->ops
->get_cur_state(cdev
, &state
);
630 cdev
->ops
->get_max_state(cdev
, &max_state
);
631 if (state
++ < max_state
)
632 cdev
->ops
->set_cur_state(cdev
, state
);
634 } else if (trend
< 0) { /* Cooling off? */
635 list_for_each_entry(instance
, &tz
->cooling_devices
,
637 if (instance
->trip
!= trip
)
639 cdev
= instance
->cdev
;
640 cdev
->ops
->get_cur_state(cdev
, &state
);
641 cdev
->ops
->get_max_state(cdev
, &max_state
);
643 cdev
->ops
->set_cur_state(cdev
, --state
);
652 * Implement passive cooling hysteresis to slowly increase performance
653 * and avoid thrashing around the passive trip point. Note that we
656 list_for_each_entry(instance
, &tz
->cooling_devices
, node
) {
657 if (instance
->trip
!= trip
)
659 cdev
= instance
->cdev
;
660 cdev
->ops
->get_cur_state(cdev
, &state
);
661 cdev
->ops
->get_max_state(cdev
, &max_state
);
663 cdev
->ops
->set_cur_state(cdev
, --state
);
669 static void thermal_zone_device_check(struct work_struct
*work
)
671 struct thermal_zone_device
*tz
= container_of(work
, struct
674 thermal_zone_device_update(tz
);
678 * thermal_zone_bind_cooling_device - bind a cooling device to a thermal zone
679 * @tz: thermal zone device
680 * @trip: indicates which trip point the cooling devices is
681 * associated with in this thermal zone.
682 * @cdev: thermal cooling device
684 * This function is usually called in the thermal zone device .bind callback.
686 int thermal_zone_bind_cooling_device(struct thermal_zone_device
*tz
,
688 struct thermal_cooling_device
*cdev
)
690 struct thermal_cooling_device_instance
*dev
;
691 struct thermal_cooling_device_instance
*pos
;
692 struct thermal_zone_device
*pos1
;
693 struct thermal_cooling_device
*pos2
;
696 if (trip
>= tz
->trips
|| (trip
< 0 && trip
!= THERMAL_TRIPS_NONE
))
699 list_for_each_entry(pos1
, &thermal_tz_list
, node
) {
703 list_for_each_entry(pos2
, &thermal_cdev_list
, node
) {
708 if (tz
!= pos1
|| cdev
!= pos2
)
712 kzalloc(sizeof(struct thermal_cooling_device_instance
), GFP_KERNEL
);
718 result
= get_idr(&tz
->idr
, &tz
->lock
, &dev
->id
);
722 sprintf(dev
->name
, "cdev%d", dev
->id
);
724 sysfs_create_link(&tz
->device
.kobj
, &cdev
->device
.kobj
, dev
->name
);
728 sprintf(dev
->attr_name
, "cdev%d_trip_point", dev
->id
);
729 dev
->attr
.attr
.name
= dev
->attr_name
;
730 dev
->attr
.attr
.mode
= 0444;
731 dev
->attr
.show
= thermal_cooling_device_trip_point_show
;
732 result
= device_create_file(&tz
->device
, &dev
->attr
);
734 goto remove_symbol_link
;
736 mutex_lock(&tz
->lock
);
737 list_for_each_entry(pos
, &tz
->cooling_devices
, node
)
738 if (pos
->tz
== tz
&& pos
->trip
== trip
&& pos
->cdev
== cdev
) {
743 list_add_tail(&dev
->node
, &tz
->cooling_devices
);
744 mutex_unlock(&tz
->lock
);
749 device_remove_file(&tz
->device
, &dev
->attr
);
751 sysfs_remove_link(&tz
->device
.kobj
, dev
->name
);
753 release_idr(&tz
->idr
, &tz
->lock
, dev
->id
);
759 EXPORT_SYMBOL(thermal_zone_bind_cooling_device
);
762 * thermal_zone_unbind_cooling_device - unbind a cooling device from a thermal zone
763 * @tz: thermal zone device
764 * @trip: indicates which trip point the cooling devices is
765 * associated with in this thermal zone.
766 * @cdev: thermal cooling device
768 * This function is usually called in the thermal zone device .unbind callback.
770 int thermal_zone_unbind_cooling_device(struct thermal_zone_device
*tz
,
772 struct thermal_cooling_device
*cdev
)
774 struct thermal_cooling_device_instance
*pos
, *next
;
776 mutex_lock(&tz
->lock
);
777 list_for_each_entry_safe(pos
, next
, &tz
->cooling_devices
, node
) {
778 if (pos
->tz
== tz
&& pos
->trip
== trip
&& pos
->cdev
== cdev
) {
779 list_del(&pos
->node
);
780 mutex_unlock(&tz
->lock
);
784 mutex_unlock(&tz
->lock
);
789 device_remove_file(&tz
->device
, &pos
->attr
);
790 sysfs_remove_link(&tz
->device
.kobj
, pos
->name
);
791 release_idr(&tz
->idr
, &tz
->lock
, pos
->id
);
796 EXPORT_SYMBOL(thermal_zone_unbind_cooling_device
);
798 static void thermal_release(struct device
*dev
)
800 struct thermal_zone_device
*tz
;
801 struct thermal_cooling_device
*cdev
;
803 if (!strncmp(dev_name(dev
), "thermal_zone", sizeof "thermal_zone" - 1)) {
804 tz
= to_thermal_zone(dev
);
807 cdev
= to_cooling_device(dev
);
812 static struct class thermal_class
= {
814 .dev_release
= thermal_release
,
818 * thermal_cooling_device_register - register a new thermal cooling device
819 * @type: the thermal cooling device type.
820 * @devdata: device private data.
821 * @ops: standard thermal cooling devices callbacks.
823 struct thermal_cooling_device
*thermal_cooling_device_register(char *type
,
826 thermal_cooling_device_ops
829 struct thermal_cooling_device
*cdev
;
830 struct thermal_zone_device
*pos
;
833 if (strlen(type
) >= THERMAL_NAME_LENGTH
)
834 return ERR_PTR(-EINVAL
);
836 if (!ops
|| !ops
->get_max_state
|| !ops
->get_cur_state
||
838 return ERR_PTR(-EINVAL
);
840 cdev
= kzalloc(sizeof(struct thermal_cooling_device
), GFP_KERNEL
);
842 return ERR_PTR(-ENOMEM
);
844 result
= get_idr(&thermal_cdev_idr
, &thermal_idr_lock
, &cdev
->id
);
847 return ERR_PTR(result
);
850 strcpy(cdev
->type
, type
);
852 cdev
->device
.class = &thermal_class
;
853 cdev
->devdata
= devdata
;
854 dev_set_name(&cdev
->device
, "cooling_device%d", cdev
->id
);
855 result
= device_register(&cdev
->device
);
857 release_idr(&thermal_cdev_idr
, &thermal_idr_lock
, cdev
->id
);
859 return ERR_PTR(result
);
864 result
= device_create_file(&cdev
->device
, &dev_attr_cdev_type
);
869 result
= device_create_file(&cdev
->device
, &dev_attr_max_state
);
873 result
= device_create_file(&cdev
->device
, &dev_attr_cur_state
);
877 mutex_lock(&thermal_list_lock
);
878 list_add(&cdev
->node
, &thermal_cdev_list
);
879 list_for_each_entry(pos
, &thermal_tz_list
, node
) {
882 result
= pos
->ops
->bind(pos
, cdev
);
887 mutex_unlock(&thermal_list_lock
);
893 release_idr(&thermal_cdev_idr
, &thermal_idr_lock
, cdev
->id
);
894 device_unregister(&cdev
->device
);
895 return ERR_PTR(result
);
898 EXPORT_SYMBOL(thermal_cooling_device_register
);
901 * thermal_cooling_device_unregister - removes the registered thermal cooling device
902 * @cdev: the thermal cooling device to remove.
904 * thermal_cooling_device_unregister() must be called when the device is no
907 void thermal_cooling_device_unregister(struct
908 thermal_cooling_device
911 struct thermal_zone_device
*tz
;
912 struct thermal_cooling_device
*pos
= NULL
;
917 mutex_lock(&thermal_list_lock
);
918 list_for_each_entry(pos
, &thermal_cdev_list
, node
)
922 /* thermal cooling device not found */
923 mutex_unlock(&thermal_list_lock
);
926 list_del(&cdev
->node
);
927 list_for_each_entry(tz
, &thermal_tz_list
, node
) {
928 if (!tz
->ops
->unbind
)
930 tz
->ops
->unbind(tz
, cdev
);
932 mutex_unlock(&thermal_list_lock
);
934 device_remove_file(&cdev
->device
, &dev_attr_cdev_type
);
935 device_remove_file(&cdev
->device
, &dev_attr_max_state
);
936 device_remove_file(&cdev
->device
, &dev_attr_cur_state
);
938 release_idr(&thermal_cdev_idr
, &thermal_idr_lock
, cdev
->id
);
939 device_unregister(&cdev
->device
);
943 EXPORT_SYMBOL(thermal_cooling_device_unregister
);
946 * thermal_zone_device_update - force an update of a thermal zone's state
947 * @ttz: the thermal zone to update
950 void thermal_zone_device_update(struct thermal_zone_device
*tz
)
953 long temp
, trip_temp
;
954 enum thermal_trip_type trip_type
;
955 struct thermal_cooling_device_instance
*instance
;
956 struct thermal_cooling_device
*cdev
;
958 mutex_lock(&tz
->lock
);
960 if (tz
->ops
->get_temp(tz
, &temp
)) {
961 /* get_temp failed - retry it later */
962 printk(KERN_WARNING PREFIX
"failed to read out thermal zone "
967 for (count
= 0; count
< tz
->trips
; count
++) {
968 tz
->ops
->get_trip_type(tz
, count
, &trip_type
);
969 tz
->ops
->get_trip_temp(tz
, count
, &trip_temp
);
972 case THERMAL_TRIP_CRITICAL
:
973 if (temp
>= trip_temp
) {
975 ret
= tz
->ops
->notify(tz
, count
,
979 "Critical temperature reached (%ld C), shutting down.\n",
981 orderly_poweroff(true);
985 case THERMAL_TRIP_HOT
:
986 if (temp
>= trip_temp
)
988 tz
->ops
->notify(tz
, count
, trip_type
);
990 case THERMAL_TRIP_ACTIVE
:
991 list_for_each_entry(instance
, &tz
->cooling_devices
,
993 if (instance
->trip
!= count
)
996 cdev
= instance
->cdev
;
998 if (temp
>= trip_temp
)
999 cdev
->ops
->set_cur_state(cdev
, 1);
1001 cdev
->ops
->set_cur_state(cdev
, 0);
1004 case THERMAL_TRIP_PASSIVE
:
1005 if (temp
>= trip_temp
|| tz
->passive
)
1006 thermal_zone_device_passive(tz
, temp
,
1012 if (tz
->forced_passive
)
1013 thermal_zone_device_passive(tz
, temp
, tz
->forced_passive
,
1014 THERMAL_TRIPS_NONE
);
1016 tz
->last_temperature
= temp
;
1020 thermal_zone_device_set_polling(tz
, tz
->passive_delay
);
1021 else if (tz
->polling_delay
)
1022 thermal_zone_device_set_polling(tz
, tz
->polling_delay
);
1024 thermal_zone_device_set_polling(tz
, 0);
1025 mutex_unlock(&tz
->lock
);
1027 EXPORT_SYMBOL(thermal_zone_device_update
);
1030 * thermal_zone_device_register - register a new thermal zone device
1031 * @type: the thermal zone device type
1032 * @trips: the number of trip points the thermal zone support
1033 * @devdata: private device data
1034 * @ops: standard thermal zone device callbacks
1035 * @tc1: thermal coefficient 1 for passive calculations
1036 * @tc2: thermal coefficient 2 for passive calculations
1037 * @passive_delay: number of milliseconds to wait between polls when
1038 * performing passive cooling
1039 * @polling_delay: number of milliseconds to wait between polls when checking
1040 * whether trip points have been crossed (0 for interrupt
1043 * thermal_zone_device_unregister() must be called when the device is no
1044 * longer needed. The passive cooling formula uses tc1 and tc2 as described in
1045 * section 11.1.5.1 of the ACPI specification 3.0.
1047 struct thermal_zone_device
*thermal_zone_device_register(char *type
,
1049 void *devdata
, struct
1050 thermal_zone_device_ops
1056 struct thermal_zone_device
*tz
;
1057 struct thermal_cooling_device
*pos
;
1058 enum thermal_trip_type trip_type
;
1063 if (strlen(type
) >= THERMAL_NAME_LENGTH
)
1064 return ERR_PTR(-EINVAL
);
1066 if (trips
> THERMAL_MAX_TRIPS
|| trips
< 0)
1067 return ERR_PTR(-EINVAL
);
1069 if (!ops
|| !ops
->get_temp
)
1070 return ERR_PTR(-EINVAL
);
1072 tz
= kzalloc(sizeof(struct thermal_zone_device
), GFP_KERNEL
);
1074 return ERR_PTR(-ENOMEM
);
1076 INIT_LIST_HEAD(&tz
->cooling_devices
);
1078 mutex_init(&tz
->lock
);
1079 result
= get_idr(&thermal_tz_idr
, &thermal_idr_lock
, &tz
->id
);
1082 return ERR_PTR(result
);
1085 strcpy(tz
->type
, type
);
1087 tz
->device
.class = &thermal_class
;
1088 tz
->devdata
= devdata
;
1092 tz
->passive_delay
= passive_delay
;
1093 tz
->polling_delay
= polling_delay
;
1095 dev_set_name(&tz
->device
, "thermal_zone%d", tz
->id
);
1096 result
= device_register(&tz
->device
);
1098 release_idr(&thermal_tz_idr
, &thermal_idr_lock
, tz
->id
);
1100 return ERR_PTR(result
);
1105 result
= device_create_file(&tz
->device
, &dev_attr_type
);
1110 result
= device_create_file(&tz
->device
, &dev_attr_temp
);
1114 if (ops
->get_mode
) {
1115 result
= device_create_file(&tz
->device
, &dev_attr_mode
);
1120 for (count
= 0; count
< trips
; count
++) {
1121 TRIP_POINT_ATTR_ADD(&tz
->device
, count
, result
);
1124 tz
->ops
->get_trip_type(tz
, count
, &trip_type
);
1125 if (trip_type
== THERMAL_TRIP_PASSIVE
)
1130 result
= device_create_file(&tz
->device
,
1136 result
= thermal_add_hwmon_sysfs(tz
);
1140 mutex_lock(&thermal_list_lock
);
1141 list_add_tail(&tz
->node
, &thermal_tz_list
);
1143 list_for_each_entry(pos
, &thermal_cdev_list
, node
) {
1144 result
= ops
->bind(tz
, pos
);
1148 mutex_unlock(&thermal_list_lock
);
1150 INIT_DELAYED_WORK(&(tz
->poll_queue
), thermal_zone_device_check
);
1152 thermal_zone_device_update(tz
);
1158 release_idr(&thermal_tz_idr
, &thermal_idr_lock
, tz
->id
);
1159 device_unregister(&tz
->device
);
1160 return ERR_PTR(result
);
1163 EXPORT_SYMBOL(thermal_zone_device_register
);
1166 * thermal_device_unregister - removes the registered thermal zone device
1167 * @tz: the thermal zone device to remove
1169 void thermal_zone_device_unregister(struct thermal_zone_device
*tz
)
1171 struct thermal_cooling_device
*cdev
;
1172 struct thermal_zone_device
*pos
= NULL
;
1178 mutex_lock(&thermal_list_lock
);
1179 list_for_each_entry(pos
, &thermal_tz_list
, node
)
1183 /* thermal zone device not found */
1184 mutex_unlock(&thermal_list_lock
);
1187 list_del(&tz
->node
);
1188 if (tz
->ops
->unbind
)
1189 list_for_each_entry(cdev
, &thermal_cdev_list
, node
)
1190 tz
->ops
->unbind(tz
, cdev
);
1191 mutex_unlock(&thermal_list_lock
);
1193 thermal_zone_device_set_polling(tz
, 0);
1196 device_remove_file(&tz
->device
, &dev_attr_type
);
1197 device_remove_file(&tz
->device
, &dev_attr_temp
);
1198 if (tz
->ops
->get_mode
)
1199 device_remove_file(&tz
->device
, &dev_attr_mode
);
1201 for (count
= 0; count
< tz
->trips
; count
++)
1202 TRIP_POINT_ATTR_REMOVE(&tz
->device
, count
);
1204 thermal_remove_hwmon_sysfs(tz
);
1205 release_idr(&thermal_tz_idr
, &thermal_idr_lock
, tz
->id
);
1206 idr_destroy(&tz
->idr
);
1207 mutex_destroy(&tz
->lock
);
1208 device_unregister(&tz
->device
);
1212 EXPORT_SYMBOL(thermal_zone_device_unregister
);
1214 static int __init
thermal_init(void)
1218 result
= class_register(&thermal_class
);
1220 idr_destroy(&thermal_tz_idr
);
1221 idr_destroy(&thermal_cdev_idr
);
1222 mutex_destroy(&thermal_idr_lock
);
1223 mutex_destroy(&thermal_list_lock
);
1228 static void __exit
thermal_exit(void)
1230 class_unregister(&thermal_class
);
1231 idr_destroy(&thermal_tz_idr
);
1232 idr_destroy(&thermal_cdev_idr
);
1233 mutex_destroy(&thermal_idr_lock
);
1234 mutex_destroy(&thermal_list_lock
);
1237 subsys_initcall(thermal_init
);
1238 module_exit(thermal_exit
);