1 // SPDX-License-Identifier: GPL-2.0
3 * thermal.c - Generic Thermal Management Sysfs support.
5 * Copyright (C) 2008 Intel Corp
6 * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
7 * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/module.h>
13 #include <linux/device.h>
14 #include <linux/err.h>
15 #include <linux/slab.h>
16 #include <linux/kdev_t.h>
17 #include <linux/idr.h>
18 #include <linux/thermal.h>
19 #include <linux/reboot.h>
20 #include <linux/string.h>
22 #include <net/netlink.h>
23 #include <net/genetlink.h>
24 #include <linux/suspend.h>
26 #define CREATE_TRACE_POINTS
27 #include <trace/events/thermal.h>
29 #include "thermal_core.h"
30 #include "thermal_hwmon.h"
32 MODULE_AUTHOR("Zhang Rui");
33 MODULE_DESCRIPTION("Generic thermal management sysfs support");
34 MODULE_LICENSE("GPL v2");
36 static DEFINE_IDA(thermal_tz_ida
);
37 static DEFINE_IDA(thermal_cdev_ida
);
39 static LIST_HEAD(thermal_tz_list
);
40 static LIST_HEAD(thermal_cdev_list
);
41 static LIST_HEAD(thermal_governor_list
);
43 static DEFINE_MUTEX(thermal_list_lock
);
44 static DEFINE_MUTEX(thermal_governor_lock
);
45 static DEFINE_MUTEX(poweroff_lock
);
47 static atomic_t in_suspend
;
48 static bool power_off_triggered
;
50 static struct thermal_governor
*def_governor
;
53 * Governor section: set of functions to handle thermal governors
55 * Functions to help in the life cycle of thermal governors within
56 * the thermal core and by the thermal governor code.
59 static struct thermal_governor
*__find_governor(const char *name
)
61 struct thermal_governor
*pos
;
63 if (!name
|| !name
[0])
66 list_for_each_entry(pos
, &thermal_governor_list
, governor_list
)
67 if (!strncasecmp(name
, pos
->name
, THERMAL_NAME_LENGTH
))
74 * bind_previous_governor() - bind the previous governor of the thermal zone
75 * @tz: a valid pointer to a struct thermal_zone_device
76 * @failed_gov_name: the name of the governor that failed to register
78 * Register the previous governor of the thermal zone after a new
79 * governor has failed to be bound.
81 static void bind_previous_governor(struct thermal_zone_device
*tz
,
82 const char *failed_gov_name
)
84 if (tz
->governor
&& tz
->governor
->bind_to_tz
) {
85 if (tz
->governor
->bind_to_tz(tz
)) {
87 "governor %s failed to bind and the previous one (%s) failed to bind again, thermal zone %s has no governor\n",
88 failed_gov_name
, tz
->governor
->name
, tz
->type
);
95 * thermal_set_governor() - Switch to another governor
96 * @tz: a valid pointer to a struct thermal_zone_device
97 * @new_gov: pointer to the new governor
99 * Change the governor of thermal zone @tz.
101 * Return: 0 on success, an error if the new governor's bind_to_tz() failed.
103 static int thermal_set_governor(struct thermal_zone_device
*tz
,
104 struct thermal_governor
*new_gov
)
108 if (tz
->governor
&& tz
->governor
->unbind_from_tz
)
109 tz
->governor
->unbind_from_tz(tz
);
111 if (new_gov
&& new_gov
->bind_to_tz
) {
112 ret
= new_gov
->bind_to_tz(tz
);
114 bind_previous_governor(tz
, new_gov
->name
);
120 tz
->governor
= new_gov
;
125 int thermal_register_governor(struct thermal_governor
*governor
)
129 struct thermal_zone_device
*pos
;
134 mutex_lock(&thermal_governor_lock
);
137 if (!__find_governor(governor
->name
)) {
141 list_add(&governor
->governor_list
, &thermal_governor_list
);
142 match_default
= !strncmp(governor
->name
,
143 DEFAULT_THERMAL_GOVERNOR
,
144 THERMAL_NAME_LENGTH
);
146 if (!def_governor
&& match_default
)
147 def_governor
= governor
;
150 mutex_lock(&thermal_list_lock
);
152 list_for_each_entry(pos
, &thermal_tz_list
, node
) {
154 * only thermal zones with specified tz->tzp->governor_name
155 * may run with tz->govenor unset
160 name
= pos
->tzp
->governor_name
;
162 if (!strncasecmp(name
, governor
->name
, THERMAL_NAME_LENGTH
)) {
165 ret
= thermal_set_governor(pos
, governor
);
167 dev_err(&pos
->device
,
168 "Failed to set governor %s for thermal zone %s: %d\n",
169 governor
->name
, pos
->type
, ret
);
173 mutex_unlock(&thermal_list_lock
);
174 mutex_unlock(&thermal_governor_lock
);
179 void thermal_unregister_governor(struct thermal_governor
*governor
)
181 struct thermal_zone_device
*pos
;
186 mutex_lock(&thermal_governor_lock
);
188 if (!__find_governor(governor
->name
))
191 mutex_lock(&thermal_list_lock
);
193 list_for_each_entry(pos
, &thermal_tz_list
, node
) {
194 if (!strncasecmp(pos
->governor
->name
, governor
->name
,
195 THERMAL_NAME_LENGTH
))
196 thermal_set_governor(pos
, NULL
);
199 mutex_unlock(&thermal_list_lock
);
200 list_del(&governor
->governor_list
);
202 mutex_unlock(&thermal_governor_lock
);
205 int thermal_zone_device_set_policy(struct thermal_zone_device
*tz
,
208 struct thermal_governor
*gov
;
211 mutex_lock(&thermal_governor_lock
);
212 mutex_lock(&tz
->lock
);
214 gov
= __find_governor(strim(policy
));
218 ret
= thermal_set_governor(tz
, gov
);
221 mutex_unlock(&tz
->lock
);
222 mutex_unlock(&thermal_governor_lock
);
227 int thermal_build_list_of_policies(char *buf
)
229 struct thermal_governor
*pos
;
231 ssize_t size
= PAGE_SIZE
;
233 mutex_lock(&thermal_governor_lock
);
235 list_for_each_entry(pos
, &thermal_governor_list
, governor_list
) {
236 size
= PAGE_SIZE
- count
;
237 count
+= scnprintf(buf
+ count
, size
, "%s ", pos
->name
);
239 count
+= scnprintf(buf
+ count
, size
, "\n");
241 mutex_unlock(&thermal_governor_lock
);
246 static int __init
thermal_register_governors(void)
250 result
= thermal_gov_step_wise_register();
254 result
= thermal_gov_fair_share_register();
258 result
= thermal_gov_bang_bang_register();
262 result
= thermal_gov_user_space_register();
266 return thermal_gov_power_allocator_register();
269 static void thermal_unregister_governors(void)
271 thermal_gov_step_wise_unregister();
272 thermal_gov_fair_share_unregister();
273 thermal_gov_bang_bang_unregister();
274 thermal_gov_user_space_unregister();
275 thermal_gov_power_allocator_unregister();
279 * Zone update section: main control loop applied to each zone while monitoring
281 * in polling mode. The monitoring is done using a workqueue.
282 * Same update may be done on a zone by calling thermal_zone_device_update().
285 * - Non-critical trips will invoke the governor responsible for that zone;
286 * - Hot trips will produce a notification to userspace;
287 * - Critical trip point will cause a system shutdown.
289 static void thermal_zone_device_set_polling(struct thermal_zone_device
*tz
,
293 mod_delayed_work(system_freezable_power_efficient_wq
,
295 round_jiffies(msecs_to_jiffies(delay
)));
297 mod_delayed_work(system_freezable_power_efficient_wq
,
299 msecs_to_jiffies(delay
));
301 cancel_delayed_work(&tz
->poll_queue
);
304 static void monitor_thermal_zone(struct thermal_zone_device
*tz
)
306 mutex_lock(&tz
->lock
);
309 thermal_zone_device_set_polling(tz
, tz
->passive_delay
);
310 else if (tz
->polling_delay
)
311 thermal_zone_device_set_polling(tz
, tz
->polling_delay
);
313 thermal_zone_device_set_polling(tz
, 0);
315 mutex_unlock(&tz
->lock
);
318 static void handle_non_critical_trips(struct thermal_zone_device
*tz
,
320 enum thermal_trip_type trip_type
)
322 tz
->governor
? tz
->governor
->throttle(tz
, trip
) :
323 def_governor
->throttle(tz
, trip
);
327 * thermal_emergency_poweroff_func - emergency poweroff work after a known delay
328 * @work: work_struct associated with the emergency poweroff function
330 * This function is called in very critical situations to force
331 * a kernel poweroff after a configurable timeout value.
333 static void thermal_emergency_poweroff_func(struct work_struct
*work
)
336 * We have reached here after the emergency thermal shutdown
337 * Waiting period has expired. This means orderly_poweroff has
338 * not been able to shut off the system for some reason.
339 * Try to shut down the system immediately using kernel_power_off
342 WARN(1, "Attempting kernel_power_off: Temperature too high\n");
346 * Worst of the worst case trigger emergency restart
348 WARN(1, "Attempting emergency_restart: Temperature too high\n");
352 static DECLARE_DELAYED_WORK(thermal_emergency_poweroff_work
,
353 thermal_emergency_poweroff_func
);
356 * thermal_emergency_poweroff - Trigger an emergency system poweroff
358 * This may be called from any critical situation to trigger a system shutdown
359 * after a known period of time. By default this is not scheduled.
361 static void thermal_emergency_poweroff(void)
363 int poweroff_delay_ms
= CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS
;
365 * poweroff_delay_ms must be a carefully profiled positive value.
366 * Its a must for thermal_emergency_poweroff_work to be scheduled
368 if (poweroff_delay_ms
<= 0)
370 schedule_delayed_work(&thermal_emergency_poweroff_work
,
371 msecs_to_jiffies(poweroff_delay_ms
));
374 static void handle_critical_trips(struct thermal_zone_device
*tz
,
375 int trip
, enum thermal_trip_type trip_type
)
379 tz
->ops
->get_trip_temp(tz
, trip
, &trip_temp
);
381 /* If we have not crossed the trip_temp, we do not care. */
382 if (trip_temp
<= 0 || tz
->temperature
< trip_temp
)
385 trace_thermal_zone_trip(tz
, trip
, trip_type
);
388 tz
->ops
->notify(tz
, trip
, trip_type
);
390 if (trip_type
== THERMAL_TRIP_CRITICAL
) {
391 dev_emerg(&tz
->device
,
392 "critical temperature reached (%d C), shutting down\n",
393 tz
->temperature
/ 1000);
394 mutex_lock(&poweroff_lock
);
395 if (!power_off_triggered
) {
397 * Queue a backup emergency shutdown in the event of
398 * orderly_poweroff failure
400 thermal_emergency_poweroff();
401 orderly_poweroff(true);
402 power_off_triggered
= true;
404 mutex_unlock(&poweroff_lock
);
408 static void handle_thermal_trip(struct thermal_zone_device
*tz
, int trip
)
410 enum thermal_trip_type type
;
412 /* Ignore disabled trip points */
413 if (test_bit(trip
, &tz
->trips_disabled
))
416 tz
->ops
->get_trip_type(tz
, trip
, &type
);
418 if (type
== THERMAL_TRIP_CRITICAL
|| type
== THERMAL_TRIP_HOT
)
419 handle_critical_trips(tz
, trip
, type
);
421 handle_non_critical_trips(tz
, trip
, type
);
423 * Alright, we handled this trip successfully.
424 * So, start monitoring again.
426 monitor_thermal_zone(tz
);
429 static void update_temperature(struct thermal_zone_device
*tz
)
433 ret
= thermal_zone_get_temp(tz
, &temp
);
436 dev_warn(&tz
->device
,
437 "failed to read out thermal zone (%d)\n",
442 mutex_lock(&tz
->lock
);
443 tz
->last_temperature
= tz
->temperature
;
444 tz
->temperature
= temp
;
445 mutex_unlock(&tz
->lock
);
447 trace_thermal_temperature(tz
);
448 if (tz
->last_temperature
== THERMAL_TEMP_INVALID
)
449 dev_dbg(&tz
->device
, "last_temperature N/A, current_temperature=%d\n",
452 dev_dbg(&tz
->device
, "last_temperature=%d, current_temperature=%d\n",
453 tz
->last_temperature
, tz
->temperature
);
456 static void thermal_zone_device_reset(struct thermal_zone_device
*tz
)
458 struct thermal_instance
*pos
;
460 tz
->temperature
= THERMAL_TEMP_INVALID
;
462 list_for_each_entry(pos
, &tz
->thermal_instances
, tz_node
)
463 pos
->initialized
= false;
466 void thermal_zone_device_update(struct thermal_zone_device
*tz
,
467 enum thermal_notify_event event
)
471 if (atomic_read(&in_suspend
))
474 if (!tz
->ops
->get_temp
)
477 update_temperature(tz
);
479 thermal_zone_set_trips(tz
);
481 tz
->notify_event
= event
;
483 for (count
= 0; count
< tz
->trips
; count
++)
484 handle_thermal_trip(tz
, count
);
486 EXPORT_SYMBOL_GPL(thermal_zone_device_update
);
489 * thermal_notify_framework - Sensor drivers use this API to notify framework
490 * @tz: thermal zone device
491 * @trip: indicates which trip point has been crossed
493 * This function handles the trip events from sensor drivers. It starts
494 * throttling the cooling devices according to the policy configured.
495 * For CRITICAL and HOT trip points, this notifies the respective drivers,
496 * and does actual throttling for other trip points i.e ACTIVE and PASSIVE.
497 * The throttling policy is based on the configured platform data; if no
498 * platform data is provided, this uses the step_wise throttling policy.
500 void thermal_notify_framework(struct thermal_zone_device
*tz
, int trip
)
502 handle_thermal_trip(tz
, trip
);
504 EXPORT_SYMBOL_GPL(thermal_notify_framework
);
506 static void thermal_zone_device_check(struct work_struct
*work
)
508 struct thermal_zone_device
*tz
= container_of(work
, struct
511 thermal_zone_device_update(tz
, THERMAL_EVENT_UNSPECIFIED
);
515 * Power actor section: interface to power actors to estimate power
517 * Set of functions used to interact to cooling devices that know
518 * how to estimate their devices power consumption.
522 * power_actor_get_max_power() - get the maximum power that a cdev can consume
523 * @cdev: pointer to &thermal_cooling_device
524 * @tz: a valid thermal zone device pointer
525 * @max_power: pointer in which to store the maximum power
527 * Calculate the maximum power consumption in milliwats that the
528 * cooling device can currently consume and store it in @max_power.
530 * Return: 0 on success, -EINVAL if @cdev doesn't support the
531 * power_actor API or -E* on other error.
533 int power_actor_get_max_power(struct thermal_cooling_device
*cdev
,
534 struct thermal_zone_device
*tz
, u32
*max_power
)
536 if (!cdev_is_power_actor(cdev
))
539 return cdev
->ops
->state2power(cdev
, tz
, 0, max_power
);
543 * power_actor_get_min_power() - get the mainimum power that a cdev can consume
544 * @cdev: pointer to &thermal_cooling_device
545 * @tz: a valid thermal zone device pointer
546 * @min_power: pointer in which to store the minimum power
548 * Calculate the minimum power consumption in milliwatts that the
549 * cooling device can currently consume and store it in @min_power.
551 * Return: 0 on success, -EINVAL if @cdev doesn't support the
552 * power_actor API or -E* on other error.
554 int power_actor_get_min_power(struct thermal_cooling_device
*cdev
,
555 struct thermal_zone_device
*tz
, u32
*min_power
)
557 unsigned long max_state
;
560 if (!cdev_is_power_actor(cdev
))
563 ret
= cdev
->ops
->get_max_state(cdev
, &max_state
);
567 return cdev
->ops
->state2power(cdev
, tz
, max_state
, min_power
);
571 * power_actor_set_power() - limit the maximum power a cooling device consumes
572 * @cdev: pointer to &thermal_cooling_device
573 * @instance: thermal instance to update
574 * @power: the power in milliwatts
576 * Set the cooling device to consume at most @power milliwatts. The limit is
577 * expected to be a cap at the maximum power consumption.
579 * Return: 0 on success, -EINVAL if the cooling device does not
580 * implement the power actor API or -E* for other failures.
582 int power_actor_set_power(struct thermal_cooling_device
*cdev
,
583 struct thermal_instance
*instance
, u32 power
)
588 if (!cdev_is_power_actor(cdev
))
591 ret
= cdev
->ops
->power2state(cdev
, instance
->tz
, power
, &state
);
595 instance
->target
= state
;
596 mutex_lock(&cdev
->lock
);
597 cdev
->updated
= false;
598 mutex_unlock(&cdev
->lock
);
599 thermal_cdev_update(cdev
);
604 void thermal_zone_device_rebind_exception(struct thermal_zone_device
*tz
,
605 const char *cdev_type
, size_t size
)
607 struct thermal_cooling_device
*cdev
= NULL
;
609 mutex_lock(&thermal_list_lock
);
610 list_for_each_entry(cdev
, &thermal_cdev_list
, node
) {
611 /* skip non matching cdevs */
612 if (strncmp(cdev_type
, cdev
->type
, size
))
615 /* re binding the exception matching the type pattern */
616 thermal_zone_bind_cooling_device(tz
, THERMAL_TRIPS_NONE
, cdev
,
619 THERMAL_WEIGHT_DEFAULT
);
621 mutex_unlock(&thermal_list_lock
);
624 void thermal_zone_device_unbind_exception(struct thermal_zone_device
*tz
,
625 const char *cdev_type
, size_t size
)
627 struct thermal_cooling_device
*cdev
= NULL
;
629 mutex_lock(&thermal_list_lock
);
630 list_for_each_entry(cdev
, &thermal_cdev_list
, node
) {
631 /* skip non matching cdevs */
632 if (strncmp(cdev_type
, cdev
->type
, size
))
634 /* unbinding the exception matching the type pattern */
635 thermal_zone_unbind_cooling_device(tz
, THERMAL_TRIPS_NONE
,
638 mutex_unlock(&thermal_list_lock
);
642 * Device management section: cooling devices, zones devices, and binding
644 * Set of functions provided by the thermal core for:
645 * - cooling devices lifecycle: registration, unregistration,
646 * binding, and unbinding.
647 * - thermal zone devices lifecycle: registration, unregistration,
648 * binding, and unbinding.
652 * thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone
653 * @tz: pointer to struct thermal_zone_device
654 * @trip: indicates which trip point the cooling devices is
655 * associated with in this thermal zone.
656 * @cdev: pointer to struct thermal_cooling_device
657 * @upper: the Maximum cooling state for this trip point.
658 * THERMAL_NO_LIMIT means no upper limit,
659 * and the cooling device can be in max_state.
660 * @lower: the Minimum cooling state can be used for this trip point.
661 * THERMAL_NO_LIMIT means no lower limit,
662 * and the cooling device can be in cooling state 0.
663 * @weight: The weight of the cooling device to be bound to the
664 * thermal zone. Use THERMAL_WEIGHT_DEFAULT for the
667 * This interface function bind a thermal cooling device to the certain trip
668 * point of a thermal zone device.
669 * This function is usually called in the thermal zone device .bind callback.
671 * Return: 0 on success, the proper error value otherwise.
673 int thermal_zone_bind_cooling_device(struct thermal_zone_device
*tz
,
675 struct thermal_cooling_device
*cdev
,
676 unsigned long upper
, unsigned long lower
,
679 struct thermal_instance
*dev
;
680 struct thermal_instance
*pos
;
681 struct thermal_zone_device
*pos1
;
682 struct thermal_cooling_device
*pos2
;
683 unsigned long max_state
;
686 if (trip
>= tz
->trips
|| (trip
< 0 && trip
!= THERMAL_TRIPS_NONE
))
689 list_for_each_entry(pos1
, &thermal_tz_list
, node
) {
693 list_for_each_entry(pos2
, &thermal_cdev_list
, node
) {
698 if (tz
!= pos1
|| cdev
!= pos2
)
701 ret
= cdev
->ops
->get_max_state(cdev
, &max_state
);
705 /* lower default 0, upper default max_state */
706 lower
= lower
== THERMAL_NO_LIMIT
? 0 : lower
;
707 upper
= upper
== THERMAL_NO_LIMIT
? max_state
: upper
;
709 if (lower
> upper
|| upper
> max_state
)
712 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
720 dev
->target
= THERMAL_NO_TARGET
;
721 dev
->weight
= weight
;
723 result
= ida_simple_get(&tz
->ida
, 0, 0, GFP_KERNEL
);
728 sprintf(dev
->name
, "cdev%d", dev
->id
);
730 sysfs_create_link(&tz
->device
.kobj
, &cdev
->device
.kobj
, dev
->name
);
734 sprintf(dev
->attr_name
, "cdev%d_trip_point", dev
->id
);
735 sysfs_attr_init(&dev
->attr
.attr
);
736 dev
->attr
.attr
.name
= dev
->attr_name
;
737 dev
->attr
.attr
.mode
= 0444;
738 dev
->attr
.show
= trip_point_show
;
739 result
= device_create_file(&tz
->device
, &dev
->attr
);
741 goto remove_symbol_link
;
743 sprintf(dev
->weight_attr_name
, "cdev%d_weight", dev
->id
);
744 sysfs_attr_init(&dev
->weight_attr
.attr
);
745 dev
->weight_attr
.attr
.name
= dev
->weight_attr_name
;
746 dev
->weight_attr
.attr
.mode
= S_IWUSR
| S_IRUGO
;
747 dev
->weight_attr
.show
= weight_show
;
748 dev
->weight_attr
.store
= weight_store
;
749 result
= device_create_file(&tz
->device
, &dev
->weight_attr
);
751 goto remove_trip_file
;
753 mutex_lock(&tz
->lock
);
754 mutex_lock(&cdev
->lock
);
755 list_for_each_entry(pos
, &tz
->thermal_instances
, tz_node
)
756 if (pos
->tz
== tz
&& pos
->trip
== trip
&& pos
->cdev
== cdev
) {
761 list_add_tail(&dev
->tz_node
, &tz
->thermal_instances
);
762 list_add_tail(&dev
->cdev_node
, &cdev
->thermal_instances
);
763 atomic_set(&tz
->need_update
, 1);
765 mutex_unlock(&cdev
->lock
);
766 mutex_unlock(&tz
->lock
);
771 device_remove_file(&tz
->device
, &dev
->weight_attr
);
773 device_remove_file(&tz
->device
, &dev
->attr
);
775 sysfs_remove_link(&tz
->device
.kobj
, dev
->name
);
777 ida_simple_remove(&tz
->ida
, dev
->id
);
782 EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device
);
785 * thermal_zone_unbind_cooling_device() - unbind a cooling device from a
787 * @tz: pointer to a struct thermal_zone_device.
788 * @trip: indicates which trip point the cooling devices is
789 * associated with in this thermal zone.
790 * @cdev: pointer to a struct thermal_cooling_device.
792 * This interface function unbind a thermal cooling device from the certain
793 * trip point of a thermal zone device.
794 * This function is usually called in the thermal zone device .unbind callback.
796 * Return: 0 on success, the proper error value otherwise.
798 int thermal_zone_unbind_cooling_device(struct thermal_zone_device
*tz
,
800 struct thermal_cooling_device
*cdev
)
802 struct thermal_instance
*pos
, *next
;
804 mutex_lock(&tz
->lock
);
805 mutex_lock(&cdev
->lock
);
806 list_for_each_entry_safe(pos
, next
, &tz
->thermal_instances
, tz_node
) {
807 if (pos
->tz
== tz
&& pos
->trip
== trip
&& pos
->cdev
== cdev
) {
808 list_del(&pos
->tz_node
);
809 list_del(&pos
->cdev_node
);
810 mutex_unlock(&cdev
->lock
);
811 mutex_unlock(&tz
->lock
);
815 mutex_unlock(&cdev
->lock
);
816 mutex_unlock(&tz
->lock
);
821 device_remove_file(&tz
->device
, &pos
->weight_attr
);
822 device_remove_file(&tz
->device
, &pos
->attr
);
823 sysfs_remove_link(&tz
->device
.kobj
, pos
->name
);
824 ida_simple_remove(&tz
->ida
, pos
->id
);
828 EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device
);
830 static void thermal_release(struct device
*dev
)
832 struct thermal_zone_device
*tz
;
833 struct thermal_cooling_device
*cdev
;
835 if (!strncmp(dev_name(dev
), "thermal_zone",
836 sizeof("thermal_zone") - 1)) {
837 tz
= to_thermal_zone(dev
);
838 thermal_zone_destroy_device_groups(tz
);
840 } else if (!strncmp(dev_name(dev
), "cooling_device",
841 sizeof("cooling_device") - 1)) {
842 cdev
= to_cooling_device(dev
);
847 static struct class thermal_class
= {
849 .dev_release
= thermal_release
,
853 void print_bind_err_msg(struct thermal_zone_device
*tz
,
854 struct thermal_cooling_device
*cdev
, int ret
)
856 dev_err(&tz
->device
, "binding zone %s with cdev %s failed:%d\n",
857 tz
->type
, cdev
->type
, ret
);
860 static void __bind(struct thermal_zone_device
*tz
, int mask
,
861 struct thermal_cooling_device
*cdev
,
862 unsigned long *limits
,
867 for (i
= 0; i
< tz
->trips
; i
++) {
868 if (mask
& (1 << i
)) {
869 unsigned long upper
, lower
;
871 upper
= THERMAL_NO_LIMIT
;
872 lower
= THERMAL_NO_LIMIT
;
874 lower
= limits
[i
* 2];
875 upper
= limits
[i
* 2 + 1];
877 ret
= thermal_zone_bind_cooling_device(tz
, i
, cdev
,
881 print_bind_err_msg(tz
, cdev
, ret
);
886 static void bind_cdev(struct thermal_cooling_device
*cdev
)
889 const struct thermal_zone_params
*tzp
;
890 struct thermal_zone_device
*pos
= NULL
;
892 mutex_lock(&thermal_list_lock
);
894 list_for_each_entry(pos
, &thermal_tz_list
, node
) {
895 if (!pos
->tzp
&& !pos
->ops
->bind
)
898 if (pos
->ops
->bind
) {
899 ret
= pos
->ops
->bind(pos
, cdev
);
901 print_bind_err_msg(pos
, cdev
, ret
);
906 if (!tzp
|| !tzp
->tbp
)
909 for (i
= 0; i
< tzp
->num_tbps
; i
++) {
910 if (tzp
->tbp
[i
].cdev
|| !tzp
->tbp
[i
].match
)
912 if (tzp
->tbp
[i
].match(pos
, cdev
))
914 tzp
->tbp
[i
].cdev
= cdev
;
915 __bind(pos
, tzp
->tbp
[i
].trip_mask
, cdev
,
916 tzp
->tbp
[i
].binding_limits
,
921 mutex_unlock(&thermal_list_lock
);
925 * __thermal_cooling_device_register() - register a new thermal cooling device
926 * @np: a pointer to a device tree node.
927 * @type: the thermal cooling device type.
928 * @devdata: device private data.
929 * @ops: standard thermal cooling devices callbacks.
931 * This interface function adds a new thermal cooling device (fan/processor/...)
932 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
933 * to all the thermal zone devices registered at the same time.
934 * It also gives the opportunity to link the cooling device to a device tree
935 * node, so that it can be bound to a thermal zone created out of device tree.
937 * Return: a pointer to the created struct thermal_cooling_device or an
938 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
940 static struct thermal_cooling_device
*
941 __thermal_cooling_device_register(struct device_node
*np
,
942 char *type
, void *devdata
,
943 const struct thermal_cooling_device_ops
*ops
)
945 struct thermal_cooling_device
*cdev
;
946 struct thermal_zone_device
*pos
= NULL
;
949 if (type
&& strlen(type
) >= THERMAL_NAME_LENGTH
)
950 return ERR_PTR(-EINVAL
);
952 if (!ops
|| !ops
->get_max_state
|| !ops
->get_cur_state
||
954 return ERR_PTR(-EINVAL
);
956 cdev
= kzalloc(sizeof(*cdev
), GFP_KERNEL
);
958 return ERR_PTR(-ENOMEM
);
960 result
= ida_simple_get(&thermal_cdev_ida
, 0, 0, GFP_KERNEL
);
963 return ERR_PTR(result
);
967 strlcpy(cdev
->type
, type
? : "", sizeof(cdev
->type
));
968 mutex_init(&cdev
->lock
);
969 INIT_LIST_HEAD(&cdev
->thermal_instances
);
972 cdev
->updated
= false;
973 cdev
->device
.class = &thermal_class
;
974 cdev
->devdata
= devdata
;
975 thermal_cooling_device_setup_sysfs(cdev
);
976 dev_set_name(&cdev
->device
, "cooling_device%d", cdev
->id
);
977 result
= device_register(&cdev
->device
);
979 ida_simple_remove(&thermal_cdev_ida
, cdev
->id
);
981 return ERR_PTR(result
);
984 /* Add 'this' new cdev to the global cdev list */
985 mutex_lock(&thermal_list_lock
);
986 list_add(&cdev
->node
, &thermal_cdev_list
);
987 mutex_unlock(&thermal_list_lock
);
989 /* Update binding information for 'this' new cdev */
992 mutex_lock(&thermal_list_lock
);
993 list_for_each_entry(pos
, &thermal_tz_list
, node
)
994 if (atomic_cmpxchg(&pos
->need_update
, 1, 0))
995 thermal_zone_device_update(pos
,
996 THERMAL_EVENT_UNSPECIFIED
);
997 mutex_unlock(&thermal_list_lock
);
1003 * thermal_cooling_device_register() - register a new thermal cooling device
1004 * @type: the thermal cooling device type.
1005 * @devdata: device private data.
1006 * @ops: standard thermal cooling devices callbacks.
1008 * This interface function adds a new thermal cooling device (fan/processor/...)
1009 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1010 * to all the thermal zone devices registered at the same time.
1012 * Return: a pointer to the created struct thermal_cooling_device or an
1013 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1015 struct thermal_cooling_device
*
1016 thermal_cooling_device_register(char *type
, void *devdata
,
1017 const struct thermal_cooling_device_ops
*ops
)
1019 return __thermal_cooling_device_register(NULL
, type
, devdata
, ops
);
1021 EXPORT_SYMBOL_GPL(thermal_cooling_device_register
);
1024 * thermal_of_cooling_device_register() - register an OF thermal cooling device
1025 * @np: a pointer to a device tree node.
1026 * @type: the thermal cooling device type.
1027 * @devdata: device private data.
1028 * @ops: standard thermal cooling devices callbacks.
1030 * This function will register a cooling device with device tree node reference.
1031 * This interface function adds a new thermal cooling device (fan/processor/...)
1032 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1033 * to all the thermal zone devices registered at the same time.
1035 * Return: a pointer to the created struct thermal_cooling_device or an
1036 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1038 struct thermal_cooling_device
*
1039 thermal_of_cooling_device_register(struct device_node
*np
,
1040 char *type
, void *devdata
,
1041 const struct thermal_cooling_device_ops
*ops
)
1043 return __thermal_cooling_device_register(np
, type
, devdata
, ops
);
1045 EXPORT_SYMBOL_GPL(thermal_of_cooling_device_register
);
1047 static void __unbind(struct thermal_zone_device
*tz
, int mask
,
1048 struct thermal_cooling_device
*cdev
)
1052 for (i
= 0; i
< tz
->trips
; i
++)
1053 if (mask
& (1 << i
))
1054 thermal_zone_unbind_cooling_device(tz
, i
, cdev
);
1058 * thermal_cooling_device_unregister - removes a thermal cooling device
1059 * @cdev: the thermal cooling device to remove.
1061 * thermal_cooling_device_unregister() must be called when a registered
1062 * thermal cooling device is no longer needed.
1064 void thermal_cooling_device_unregister(struct thermal_cooling_device
*cdev
)
1067 const struct thermal_zone_params
*tzp
;
1068 struct thermal_zone_device
*tz
;
1069 struct thermal_cooling_device
*pos
= NULL
;
1074 mutex_lock(&thermal_list_lock
);
1075 list_for_each_entry(pos
, &thermal_cdev_list
, node
)
1079 /* thermal cooling device not found */
1080 mutex_unlock(&thermal_list_lock
);
1083 list_del(&cdev
->node
);
1085 /* Unbind all thermal zones associated with 'this' cdev */
1086 list_for_each_entry(tz
, &thermal_tz_list
, node
) {
1087 if (tz
->ops
->unbind
) {
1088 tz
->ops
->unbind(tz
, cdev
);
1092 if (!tz
->tzp
|| !tz
->tzp
->tbp
)
1096 for (i
= 0; i
< tzp
->num_tbps
; i
++) {
1097 if (tzp
->tbp
[i
].cdev
== cdev
) {
1098 __unbind(tz
, tzp
->tbp
[i
].trip_mask
, cdev
);
1099 tzp
->tbp
[i
].cdev
= NULL
;
1104 mutex_unlock(&thermal_list_lock
);
1106 ida_simple_remove(&thermal_cdev_ida
, cdev
->id
);
1107 device_del(&cdev
->device
);
1108 thermal_cooling_device_destroy_sysfs(cdev
);
1109 put_device(&cdev
->device
);
1111 EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister
);
1113 static void bind_tz(struct thermal_zone_device
*tz
)
1116 struct thermal_cooling_device
*pos
= NULL
;
1117 const struct thermal_zone_params
*tzp
= tz
->tzp
;
1119 if (!tzp
&& !tz
->ops
->bind
)
1122 mutex_lock(&thermal_list_lock
);
1124 /* If there is ops->bind, try to use ops->bind */
1125 if (tz
->ops
->bind
) {
1126 list_for_each_entry(pos
, &thermal_cdev_list
, node
) {
1127 ret
= tz
->ops
->bind(tz
, pos
);
1129 print_bind_err_msg(tz
, pos
, ret
);
1134 if (!tzp
|| !tzp
->tbp
)
1137 list_for_each_entry(pos
, &thermal_cdev_list
, node
) {
1138 for (i
= 0; i
< tzp
->num_tbps
; i
++) {
1139 if (tzp
->tbp
[i
].cdev
|| !tzp
->tbp
[i
].match
)
1141 if (tzp
->tbp
[i
].match(tz
, pos
))
1143 tzp
->tbp
[i
].cdev
= pos
;
1144 __bind(tz
, tzp
->tbp
[i
].trip_mask
, pos
,
1145 tzp
->tbp
[i
].binding_limits
,
1146 tzp
->tbp
[i
].weight
);
1150 mutex_unlock(&thermal_list_lock
);
1154 * thermal_zone_device_register() - register a new thermal zone device
1155 * @type: the thermal zone device type
1156 * @trips: the number of trip points the thermal zone support
1157 * @mask: a bit string indicating the writeablility of trip points
1158 * @devdata: private device data
1159 * @ops: standard thermal zone device callbacks
1160 * @tzp: thermal zone platform parameters
1161 * @passive_delay: number of milliseconds to wait between polls when
1162 * performing passive cooling
1163 * @polling_delay: number of milliseconds to wait between polls when checking
1164 * whether trip points have been crossed (0 for interrupt
1167 * This interface function adds a new thermal zone device (sensor) to
1168 * /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the
1169 * thermal cooling devices registered at the same time.
1170 * thermal_zone_device_unregister() must be called when the device is no
1171 * longer needed. The passive cooling depends on the .get_trend() return value.
1173 * Return: a pointer to the created struct thermal_zone_device or an
1174 * in case of error, an ERR_PTR. Caller must check return value with
1175 * IS_ERR*() helpers.
1177 struct thermal_zone_device
*
1178 thermal_zone_device_register(const char *type
, int trips
, int mask
,
1179 void *devdata
, struct thermal_zone_device_ops
*ops
,
1180 struct thermal_zone_params
*tzp
, int passive_delay
,
1183 struct thermal_zone_device
*tz
;
1184 enum thermal_trip_type trip_type
;
1188 struct thermal_governor
*governor
;
1190 if (!type
|| strlen(type
) == 0)
1191 return ERR_PTR(-EINVAL
);
1193 if (type
&& strlen(type
) >= THERMAL_NAME_LENGTH
)
1194 return ERR_PTR(-EINVAL
);
1196 if (trips
> THERMAL_MAX_TRIPS
|| trips
< 0 || mask
>> trips
)
1197 return ERR_PTR(-EINVAL
);
1200 return ERR_PTR(-EINVAL
);
1202 if (trips
> 0 && (!ops
->get_trip_type
|| !ops
->get_trip_temp
))
1203 return ERR_PTR(-EINVAL
);
1205 tz
= kzalloc(sizeof(*tz
), GFP_KERNEL
);
1207 return ERR_PTR(-ENOMEM
);
1209 INIT_LIST_HEAD(&tz
->thermal_instances
);
1211 mutex_init(&tz
->lock
);
1212 result
= ida_simple_get(&thermal_tz_ida
, 0, 0, GFP_KERNEL
);
1217 strlcpy(tz
->type
, type
, sizeof(tz
->type
));
1220 tz
->device
.class = &thermal_class
;
1221 tz
->devdata
= devdata
;
1223 tz
->passive_delay
= passive_delay
;
1224 tz
->polling_delay
= polling_delay
;
1227 /* Add nodes that are always present via .groups */
1228 result
= thermal_zone_create_device_groups(tz
, mask
);
1232 /* A new thermal zone needs to be updated anyway. */
1233 atomic_set(&tz
->need_update
, 1);
1235 dev_set_name(&tz
->device
, "thermal_zone%d", tz
->id
);
1236 result
= device_register(&tz
->device
);
1238 goto remove_device_groups
;
1240 for (count
= 0; count
< trips
; count
++) {
1241 if (tz
->ops
->get_trip_type(tz
, count
, &trip_type
))
1242 set_bit(count
, &tz
->trips_disabled
);
1243 if (tz
->ops
->get_trip_temp(tz
, count
, &trip_temp
))
1244 set_bit(count
, &tz
->trips_disabled
);
1245 /* Check for bogus trip points */
1247 set_bit(count
, &tz
->trips_disabled
);
1250 /* Update 'this' zone's governor information */
1251 mutex_lock(&thermal_governor_lock
);
1254 governor
= __find_governor(tz
->tzp
->governor_name
);
1256 governor
= def_governor
;
1258 result
= thermal_set_governor(tz
, governor
);
1260 mutex_unlock(&thermal_governor_lock
);
1264 mutex_unlock(&thermal_governor_lock
);
1266 if (!tz
->tzp
|| !tz
->tzp
->no_hwmon
) {
1267 result
= thermal_add_hwmon_sysfs(tz
);
1272 mutex_lock(&thermal_list_lock
);
1273 list_add_tail(&tz
->node
, &thermal_tz_list
);
1274 mutex_unlock(&thermal_list_lock
);
1276 /* Bind cooling devices for this zone */
1279 INIT_DELAYED_WORK(&tz
->poll_queue
, thermal_zone_device_check
);
1281 thermal_zone_device_reset(tz
);
1282 /* Update the new thermal zone and mark it as already updated. */
1283 if (atomic_cmpxchg(&tz
->need_update
, 1, 0))
1284 thermal_zone_device_update(tz
, THERMAL_EVENT_UNSPECIFIED
);
1289 ida_simple_remove(&thermal_tz_ida
, tz
->id
);
1290 device_unregister(&tz
->device
);
1291 return ERR_PTR(result
);
1293 remove_device_groups
:
1294 thermal_zone_destroy_device_groups(tz
);
1296 ida_simple_remove(&thermal_tz_ida
, tz
->id
);
1299 return ERR_PTR(result
);
1301 EXPORT_SYMBOL_GPL(thermal_zone_device_register
);
1304 * thermal_device_unregister - removes the registered thermal zone device
1305 * @tz: the thermal zone device to remove
1307 void thermal_zone_device_unregister(struct thermal_zone_device
*tz
)
1310 const struct thermal_zone_params
*tzp
;
1311 struct thermal_cooling_device
*cdev
;
1312 struct thermal_zone_device
*pos
= NULL
;
1319 mutex_lock(&thermal_list_lock
);
1320 list_for_each_entry(pos
, &thermal_tz_list
, node
)
1324 /* thermal zone device not found */
1325 mutex_unlock(&thermal_list_lock
);
1328 list_del(&tz
->node
);
1330 /* Unbind all cdevs associated with 'this' thermal zone */
1331 list_for_each_entry(cdev
, &thermal_cdev_list
, node
) {
1332 if (tz
->ops
->unbind
) {
1333 tz
->ops
->unbind(tz
, cdev
);
1337 if (!tzp
|| !tzp
->tbp
)
1340 for (i
= 0; i
< tzp
->num_tbps
; i
++) {
1341 if (tzp
->tbp
[i
].cdev
== cdev
) {
1342 __unbind(tz
, tzp
->tbp
[i
].trip_mask
, cdev
);
1343 tzp
->tbp
[i
].cdev
= NULL
;
1348 mutex_unlock(&thermal_list_lock
);
1350 thermal_zone_device_set_polling(tz
, 0);
1352 thermal_set_governor(tz
, NULL
);
1354 thermal_remove_hwmon_sysfs(tz
);
1355 ida_simple_remove(&thermal_tz_ida
, tz
->id
);
1356 ida_destroy(&tz
->ida
);
1357 mutex_destroy(&tz
->lock
);
1358 device_unregister(&tz
->device
);
1360 EXPORT_SYMBOL_GPL(thermal_zone_device_unregister
);
1363 * thermal_zone_get_zone_by_name() - search for a zone and returns its ref
1364 * @name: thermal zone name to fetch the temperature
1366 * When only one zone is found with the passed name, returns a reference to it.
1368 * Return: On success returns a reference to an unique thermal zone with
1369 * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid
1370 * paramenters, -ENODEV for not found and -EEXIST for multiple matches).
1372 struct thermal_zone_device
*thermal_zone_get_zone_by_name(const char *name
)
1374 struct thermal_zone_device
*pos
= NULL
, *ref
= ERR_PTR(-EINVAL
);
1375 unsigned int found
= 0;
1380 mutex_lock(&thermal_list_lock
);
1381 list_for_each_entry(pos
, &thermal_tz_list
, node
)
1382 if (!strncasecmp(name
, pos
->type
, THERMAL_NAME_LENGTH
)) {
1386 mutex_unlock(&thermal_list_lock
);
1388 /* nothing has been found, thus an error code for it */
1390 ref
= ERR_PTR(-ENODEV
);
1392 /* Success only when an unique zone is found */
1393 ref
= ERR_PTR(-EEXIST
);
1398 EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name
);
1401 static const struct genl_multicast_group thermal_event_mcgrps
[] = {
1402 { .name
= THERMAL_GENL_MCAST_GROUP_NAME
, },
1405 static struct genl_family thermal_event_genl_family __ro_after_init
= {
1406 .module
= THIS_MODULE
,
1407 .name
= THERMAL_GENL_FAMILY_NAME
,
1408 .version
= THERMAL_GENL_VERSION
,
1409 .maxattr
= THERMAL_GENL_ATTR_MAX
,
1410 .mcgrps
= thermal_event_mcgrps
,
1411 .n_mcgrps
= ARRAY_SIZE(thermal_event_mcgrps
),
1414 int thermal_generate_netlink_event(struct thermal_zone_device
*tz
,
1417 struct sk_buff
*skb
;
1418 struct nlattr
*attr
;
1419 struct thermal_genl_event
*thermal_event
;
1423 static unsigned int thermal_event_seqnum
;
1428 /* allocate memory */
1429 size
= nla_total_size(sizeof(struct thermal_genl_event
)) +
1432 skb
= genlmsg_new(size
, GFP_ATOMIC
);
1436 /* add the genetlink message header */
1437 msg_header
= genlmsg_put(skb
, 0, thermal_event_seqnum
++,
1438 &thermal_event_genl_family
, 0,
1439 THERMAL_GENL_CMD_EVENT
);
1446 attr
= nla_reserve(skb
, THERMAL_GENL_ATTR_EVENT
,
1447 sizeof(struct thermal_genl_event
));
1454 thermal_event
= nla_data(attr
);
1455 if (!thermal_event
) {
1460 memset(thermal_event
, 0, sizeof(struct thermal_genl_event
));
1462 thermal_event
->orig
= tz
->id
;
1463 thermal_event
->event
= event
;
1465 /* send multicast genetlink message */
1466 genlmsg_end(skb
, msg_header
);
1468 result
= genlmsg_multicast(&thermal_event_genl_family
, skb
, 0,
1471 dev_err(&tz
->device
, "Failed to send netlink event:%d", result
);
1475 EXPORT_SYMBOL_GPL(thermal_generate_netlink_event
);
1477 static int __init
genetlink_init(void)
1479 return genl_register_family(&thermal_event_genl_family
);
1482 static void genetlink_exit(void)
1484 genl_unregister_family(&thermal_event_genl_family
);
1486 #else /* !CONFIG_NET */
1487 static inline int genetlink_init(void) { return 0; }
1488 static inline void genetlink_exit(void) {}
1489 #endif /* !CONFIG_NET */
1491 static int thermal_pm_notify(struct notifier_block
*nb
,
1492 unsigned long mode
, void *_unused
)
1494 struct thermal_zone_device
*tz
;
1497 case PM_HIBERNATION_PREPARE
:
1498 case PM_RESTORE_PREPARE
:
1499 case PM_SUSPEND_PREPARE
:
1500 atomic_set(&in_suspend
, 1);
1502 case PM_POST_HIBERNATION
:
1503 case PM_POST_RESTORE
:
1504 case PM_POST_SUSPEND
:
1505 atomic_set(&in_suspend
, 0);
1506 list_for_each_entry(tz
, &thermal_tz_list
, node
) {
1507 thermal_zone_device_reset(tz
);
1508 thermal_zone_device_update(tz
,
1509 THERMAL_EVENT_UNSPECIFIED
);
1518 static struct notifier_block thermal_pm_nb
= {
1519 .notifier_call
= thermal_pm_notify
,
1522 static int __init
thermal_init(void)
1526 mutex_init(&poweroff_lock
);
1527 result
= thermal_register_governors();
1531 result
= class_register(&thermal_class
);
1533 goto unregister_governors
;
1535 result
= genetlink_init();
1537 goto unregister_class
;
1539 result
= of_parse_thermal_zones();
1543 result
= register_pm_notifier(&thermal_pm_nb
);
1545 pr_warn("Thermal: Can not register suspend notifier, return %d\n",
1553 class_unregister(&thermal_class
);
1554 unregister_governors
:
1555 thermal_unregister_governors();
1557 ida_destroy(&thermal_tz_ida
);
1558 ida_destroy(&thermal_cdev_ida
);
1559 mutex_destroy(&thermal_list_lock
);
1560 mutex_destroy(&thermal_governor_lock
);
1561 mutex_destroy(&poweroff_lock
);
1565 static void __exit
thermal_exit(void)
1567 unregister_pm_notifier(&thermal_pm_nb
);
1568 of_thermal_destroy_zones();
1570 class_unregister(&thermal_class
);
1571 thermal_unregister_governors();
1572 ida_destroy(&thermal_tz_ida
);
1573 ida_destroy(&thermal_cdev_ida
);
1574 mutex_destroy(&thermal_list_lock
);
1575 mutex_destroy(&thermal_governor_lock
);
1578 fs_initcall(thermal_init
);
1579 module_exit(thermal_exit
);