Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * thermal.c - Generic Thermal Management Sysfs support.
4 *
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>
8 */
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12#include <linux/device.h>
13#include <linux/err.h>
14#include <linux/export.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>
21#include <linux/of.h>
22#include <linux/suspend.h>
23
24#define CREATE_TRACE_POINTS
25#include "thermal_trace.h"
26
27#include "thermal_core.h"
28#include "thermal_hwmon.h"
29
30static DEFINE_IDA(thermal_tz_ida);
31static DEFINE_IDA(thermal_cdev_ida);
32
33static LIST_HEAD(thermal_tz_list);
34static LIST_HEAD(thermal_cdev_list);
35static LIST_HEAD(thermal_governor_list);
36
37static DEFINE_MUTEX(thermal_list_lock);
38static DEFINE_MUTEX(thermal_governor_lock);
39
40static struct thermal_governor *def_governor;
41
42/*
43 * Governor section: set of functions to handle thermal governors
44 *
45 * Functions to help in the life cycle of thermal governors within
46 * the thermal core and by the thermal governor code.
47 */
48
49static struct thermal_governor *__find_governor(const char *name)
50{
51 struct thermal_governor *pos;
52
53 if (!name || !name[0])
54 return def_governor;
55
56 list_for_each_entry(pos, &thermal_governor_list, governor_list)
57 if (!strncasecmp(name, pos->name, THERMAL_NAME_LENGTH))
58 return pos;
59
60 return NULL;
61}
62
63/**
64 * bind_previous_governor() - bind the previous governor of the thermal zone
65 * @tz: a valid pointer to a struct thermal_zone_device
66 * @failed_gov_name: the name of the governor that failed to register
67 *
68 * Register the previous governor of the thermal zone after a new
69 * governor has failed to be bound.
70 */
71static void bind_previous_governor(struct thermal_zone_device *tz,
72 const char *failed_gov_name)
73{
74 if (tz->governor && tz->governor->bind_to_tz) {
75 if (tz->governor->bind_to_tz(tz)) {
76 dev_err(&tz->device,
77 "governor %s failed to bind and the previous one (%s) failed to bind again, thermal zone %s has no governor\n",
78 failed_gov_name, tz->governor->name, tz->type);
79 tz->governor = NULL;
80 }
81 }
82}
83
84/**
85 * thermal_set_governor() - Switch to another governor
86 * @tz: a valid pointer to a struct thermal_zone_device
87 * @new_gov: pointer to the new governor
88 *
89 * Change the governor of thermal zone @tz.
90 *
91 * Return: 0 on success, an error if the new governor's bind_to_tz() failed.
92 */
93static int thermal_set_governor(struct thermal_zone_device *tz,
94 struct thermal_governor *new_gov)
95{
96 int ret = 0;
97
98 if (tz->governor && tz->governor->unbind_from_tz)
99 tz->governor->unbind_from_tz(tz);
100
101 if (new_gov && new_gov->bind_to_tz) {
102 ret = new_gov->bind_to_tz(tz);
103 if (ret) {
104 bind_previous_governor(tz, new_gov->name);
105
106 return ret;
107 }
108 }
109
110 tz->governor = new_gov;
111
112 return ret;
113}
114
115int thermal_register_governor(struct thermal_governor *governor)
116{
117 int err;
118 const char *name;
119 struct thermal_zone_device *pos;
120
121 if (!governor)
122 return -EINVAL;
123
124 mutex_lock(&thermal_governor_lock);
125
126 err = -EBUSY;
127 if (!__find_governor(governor->name)) {
128 bool match_default;
129
130 err = 0;
131 list_add(&governor->governor_list, &thermal_governor_list);
132 match_default = !strncmp(governor->name,
133 DEFAULT_THERMAL_GOVERNOR,
134 THERMAL_NAME_LENGTH);
135
136 if (!def_governor && match_default)
137 def_governor = governor;
138 }
139
140 mutex_lock(&thermal_list_lock);
141
142 list_for_each_entry(pos, &thermal_tz_list, node) {
143 /*
144 * only thermal zones with specified tz->tzp->governor_name
145 * may run with tz->govenor unset
146 */
147 if (pos->governor)
148 continue;
149
150 name = pos->tzp->governor_name;
151
152 if (!strncasecmp(name, governor->name, THERMAL_NAME_LENGTH)) {
153 int ret;
154
155 ret = thermal_set_governor(pos, governor);
156 if (ret)
157 dev_err(&pos->device,
158 "Failed to set governor %s for thermal zone %s: %d\n",
159 governor->name, pos->type, ret);
160 }
161 }
162
163 mutex_unlock(&thermal_list_lock);
164 mutex_unlock(&thermal_governor_lock);
165
166 return err;
167}
168
169void thermal_unregister_governor(struct thermal_governor *governor)
170{
171 struct thermal_zone_device *pos;
172
173 if (!governor)
174 return;
175
176 mutex_lock(&thermal_governor_lock);
177
178 if (!__find_governor(governor->name))
179 goto exit;
180
181 mutex_lock(&thermal_list_lock);
182
183 list_for_each_entry(pos, &thermal_tz_list, node) {
184 if (!strncasecmp(pos->governor->name, governor->name,
185 THERMAL_NAME_LENGTH))
186 thermal_set_governor(pos, NULL);
187 }
188
189 mutex_unlock(&thermal_list_lock);
190 list_del(&governor->governor_list);
191exit:
192 mutex_unlock(&thermal_governor_lock);
193}
194
195int thermal_zone_device_set_policy(struct thermal_zone_device *tz,
196 char *policy)
197{
198 struct thermal_governor *gov;
199 int ret = -EINVAL;
200
201 mutex_lock(&thermal_governor_lock);
202 mutex_lock(&tz->lock);
203
204 gov = __find_governor(strim(policy));
205 if (!gov)
206 goto exit;
207
208 ret = thermal_set_governor(tz, gov);
209
210exit:
211 mutex_unlock(&tz->lock);
212 mutex_unlock(&thermal_governor_lock);
213
214 thermal_notify_tz_gov_change(tz, policy);
215
216 return ret;
217}
218
219int thermal_build_list_of_policies(char *buf)
220{
221 struct thermal_governor *pos;
222 ssize_t count = 0;
223
224 mutex_lock(&thermal_governor_lock);
225
226 list_for_each_entry(pos, &thermal_governor_list, governor_list) {
227 count += sysfs_emit_at(buf, count, "%s ", pos->name);
228 }
229 count += sysfs_emit_at(buf, count, "\n");
230
231 mutex_unlock(&thermal_governor_lock);
232
233 return count;
234}
235
236static void __init thermal_unregister_governors(void)
237{
238 struct thermal_governor **governor;
239
240 for_each_governor_table(governor)
241 thermal_unregister_governor(*governor);
242}
243
244static int __init thermal_register_governors(void)
245{
246 int ret = 0;
247 struct thermal_governor **governor;
248
249 for_each_governor_table(governor) {
250 ret = thermal_register_governor(*governor);
251 if (ret) {
252 pr_err("Failed to register governor: '%s'",
253 (*governor)->name);
254 break;
255 }
256
257 pr_info("Registered thermal governor '%s'",
258 (*governor)->name);
259 }
260
261 if (ret) {
262 struct thermal_governor **gov;
263
264 for_each_governor_table(gov) {
265 if (gov == governor)
266 break;
267 thermal_unregister_governor(*gov);
268 }
269 }
270
271 return ret;
272}
273
274/*
275 * Zone update section: main control loop applied to each zone while monitoring
276 *
277 * in polling mode. The monitoring is done using a workqueue.
278 * Same update may be done on a zone by calling thermal_zone_device_update().
279 *
280 * An update means:
281 * - Non-critical trips will invoke the governor responsible for that zone;
282 * - Hot trips will produce a notification to userspace;
283 * - Critical trip point will cause a system shutdown.
284 */
285static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
286 unsigned long delay)
287{
288 if (delay)
289 mod_delayed_work(system_freezable_power_efficient_wq,
290 &tz->poll_queue, delay);
291 else
292 cancel_delayed_work(&tz->poll_queue);
293}
294
295static void monitor_thermal_zone(struct thermal_zone_device *tz)
296{
297 if (tz->mode != THERMAL_DEVICE_ENABLED)
298 thermal_zone_device_set_polling(tz, 0);
299 else if (tz->passive)
300 thermal_zone_device_set_polling(tz, tz->passive_delay_jiffies);
301 else if (tz->polling_delay_jiffies)
302 thermal_zone_device_set_polling(tz, tz->polling_delay_jiffies);
303}
304
305static void handle_non_critical_trips(struct thermal_zone_device *tz,
306 const struct thermal_trip *trip)
307{
308 tz->governor ? tz->governor->throttle(tz, trip) :
309 def_governor->throttle(tz, trip);
310}
311
312void thermal_governor_update_tz(struct thermal_zone_device *tz,
313 enum thermal_notify_event reason)
314{
315 if (!tz->governor || !tz->governor->update_tz)
316 return;
317
318 tz->governor->update_tz(tz, reason);
319}
320
321static void thermal_zone_device_halt(struct thermal_zone_device *tz, bool shutdown)
322{
323 /*
324 * poweroff_delay_ms must be a carefully profiled positive value.
325 * Its a must for forced_emergency_poweroff_work to be scheduled.
326 */
327 int poweroff_delay_ms = CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS;
328 const char *msg = "Temperature too high";
329
330 dev_emerg(&tz->device, "%s: critical temperature reached\n", tz->type);
331
332 if (shutdown)
333 hw_protection_shutdown(msg, poweroff_delay_ms);
334 else
335 hw_protection_reboot(msg, poweroff_delay_ms);
336}
337
338void thermal_zone_device_critical(struct thermal_zone_device *tz)
339{
340 thermal_zone_device_halt(tz, true);
341}
342EXPORT_SYMBOL(thermal_zone_device_critical);
343
344void thermal_zone_device_critical_reboot(struct thermal_zone_device *tz)
345{
346 thermal_zone_device_halt(tz, false);
347}
348
349static void handle_critical_trips(struct thermal_zone_device *tz,
350 const struct thermal_trip *trip)
351{
352 /* If we have not crossed the trip_temp, we do not care. */
353 if (trip->temperature <= 0 || tz->temperature < trip->temperature)
354 return;
355
356 trace_thermal_zone_trip(tz, thermal_zone_trip_id(tz, trip), trip->type);
357
358 if (trip->type == THERMAL_TRIP_CRITICAL)
359 tz->ops->critical(tz);
360 else if (tz->ops->hot)
361 tz->ops->hot(tz);
362}
363
364static void handle_thermal_trip(struct thermal_zone_device *tz,
365 struct thermal_trip *trip)
366{
367 if (trip->temperature == THERMAL_TEMP_INVALID)
368 return;
369
370 if (tz->last_temperature == THERMAL_TEMP_INVALID) {
371 /* Initialization. */
372 trip->threshold = trip->temperature;
373 if (tz->temperature >= trip->threshold)
374 trip->threshold -= trip->hysteresis;
375 } else if (tz->last_temperature < trip->threshold) {
376 /*
377 * The trip threshold is equal to the trip temperature, unless
378 * the latter has changed in the meantime. In either case,
379 * the trip is crossed if the current zone temperature is at
380 * least equal to its temperature, but otherwise ensure that
381 * the threshold and the trip temperature will be equal.
382 */
383 if (tz->temperature >= trip->temperature) {
384 thermal_notify_tz_trip_up(tz, trip);
385 thermal_debug_tz_trip_up(tz, trip);
386 trip->threshold = trip->temperature - trip->hysteresis;
387 } else {
388 trip->threshold = trip->temperature;
389 }
390 } else {
391 /*
392 * The previous zone temperature was above or equal to the trip
393 * threshold, which would be equal to the "low temperature" of
394 * the trip (its temperature minus its hysteresis), unless the
395 * trip temperature or hysteresis had changed. In either case,
396 * the trip is crossed if the current zone temperature is below
397 * the low temperature of the trip, but otherwise ensure that
398 * the trip threshold will be equal to the low temperature of
399 * the trip.
400 */
401 if (tz->temperature < trip->temperature - trip->hysteresis) {
402 thermal_notify_tz_trip_down(tz, trip);
403 thermal_debug_tz_trip_down(tz, trip);
404 trip->threshold = trip->temperature;
405 } else {
406 trip->threshold = trip->temperature - trip->hysteresis;
407 }
408 }
409
410 if (trip->type == THERMAL_TRIP_CRITICAL || trip->type == THERMAL_TRIP_HOT)
411 handle_critical_trips(tz, trip);
412 else
413 handle_non_critical_trips(tz, trip);
414}
415
416static void update_temperature(struct thermal_zone_device *tz)
417{
418 int temp, ret;
419
420 ret = __thermal_zone_get_temp(tz, &temp);
421 if (ret) {
422 if (ret != -EAGAIN)
423 dev_warn(&tz->device,
424 "failed to read out thermal zone (%d)\n",
425 ret);
426 return;
427 }
428
429 tz->last_temperature = tz->temperature;
430 tz->temperature = temp;
431
432 trace_thermal_temperature(tz);
433
434 thermal_genl_sampling_temp(tz->id, temp);
435 thermal_debug_update_temp(tz);
436}
437
438static void thermal_zone_device_check(struct work_struct *work)
439{
440 struct thermal_zone_device *tz = container_of(work, struct
441 thermal_zone_device,
442 poll_queue.work);
443 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
444}
445
446static void thermal_zone_device_init(struct thermal_zone_device *tz)
447{
448 struct thermal_instance *pos;
449
450 INIT_DELAYED_WORK(&tz->poll_queue, thermal_zone_device_check);
451
452 tz->temperature = THERMAL_TEMP_INVALID;
453 tz->prev_low_trip = -INT_MAX;
454 tz->prev_high_trip = INT_MAX;
455 list_for_each_entry(pos, &tz->thermal_instances, tz_node)
456 pos->initialized = false;
457}
458
459void __thermal_zone_device_update(struct thermal_zone_device *tz,
460 enum thermal_notify_event event)
461{
462 struct thermal_trip *trip;
463
464 if (tz->suspended)
465 return;
466
467 if (!thermal_zone_device_is_enabled(tz))
468 return;
469
470 update_temperature(tz);
471
472 __thermal_zone_set_trips(tz);
473
474 tz->notify_event = event;
475
476 for_each_trip(tz, trip)
477 handle_thermal_trip(tz, trip);
478
479 monitor_thermal_zone(tz);
480}
481
482static int thermal_zone_device_set_mode(struct thermal_zone_device *tz,
483 enum thermal_device_mode mode)
484{
485 int ret = 0;
486
487 mutex_lock(&tz->lock);
488
489 /* do nothing if mode isn't changing */
490 if (mode == tz->mode) {
491 mutex_unlock(&tz->lock);
492
493 return ret;
494 }
495
496 if (tz->ops->change_mode)
497 ret = tz->ops->change_mode(tz, mode);
498
499 if (!ret)
500 tz->mode = mode;
501
502 __thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
503
504 mutex_unlock(&tz->lock);
505
506 if (mode == THERMAL_DEVICE_ENABLED)
507 thermal_notify_tz_enable(tz);
508 else
509 thermal_notify_tz_disable(tz);
510
511 return ret;
512}
513
514int thermal_zone_device_enable(struct thermal_zone_device *tz)
515{
516 return thermal_zone_device_set_mode(tz, THERMAL_DEVICE_ENABLED);
517}
518EXPORT_SYMBOL_GPL(thermal_zone_device_enable);
519
520int thermal_zone_device_disable(struct thermal_zone_device *tz)
521{
522 return thermal_zone_device_set_mode(tz, THERMAL_DEVICE_DISABLED);
523}
524EXPORT_SYMBOL_GPL(thermal_zone_device_disable);
525
526int thermal_zone_device_is_enabled(struct thermal_zone_device *tz)
527{
528 lockdep_assert_held(&tz->lock);
529
530 return tz->mode == THERMAL_DEVICE_ENABLED;
531}
532
533static bool thermal_zone_is_present(struct thermal_zone_device *tz)
534{
535 return !list_empty(&tz->node);
536}
537
538void thermal_zone_device_update(struct thermal_zone_device *tz,
539 enum thermal_notify_event event)
540{
541 mutex_lock(&tz->lock);
542 if (thermal_zone_is_present(tz))
543 __thermal_zone_device_update(tz, event);
544 mutex_unlock(&tz->lock);
545}
546EXPORT_SYMBOL_GPL(thermal_zone_device_update);
547
548int for_each_thermal_governor(int (*cb)(struct thermal_governor *, void *),
549 void *data)
550{
551 struct thermal_governor *gov;
552 int ret = 0;
553
554 mutex_lock(&thermal_governor_lock);
555 list_for_each_entry(gov, &thermal_governor_list, governor_list) {
556 ret = cb(gov, data);
557 if (ret)
558 break;
559 }
560 mutex_unlock(&thermal_governor_lock);
561
562 return ret;
563}
564
565int for_each_thermal_cooling_device(int (*cb)(struct thermal_cooling_device *,
566 void *), void *data)
567{
568 struct thermal_cooling_device *cdev;
569 int ret = 0;
570
571 mutex_lock(&thermal_list_lock);
572 list_for_each_entry(cdev, &thermal_cdev_list, node) {
573 ret = cb(cdev, data);
574 if (ret)
575 break;
576 }
577 mutex_unlock(&thermal_list_lock);
578
579 return ret;
580}
581
582int for_each_thermal_zone(int (*cb)(struct thermal_zone_device *, void *),
583 void *data)
584{
585 struct thermal_zone_device *tz;
586 int ret = 0;
587
588 mutex_lock(&thermal_list_lock);
589 list_for_each_entry(tz, &thermal_tz_list, node) {
590 ret = cb(tz, data);
591 if (ret)
592 break;
593 }
594 mutex_unlock(&thermal_list_lock);
595
596 return ret;
597}
598
599struct thermal_zone_device *thermal_zone_get_by_id(int id)
600{
601 struct thermal_zone_device *tz, *match = NULL;
602
603 mutex_lock(&thermal_list_lock);
604 list_for_each_entry(tz, &thermal_tz_list, node) {
605 if (tz->id == id) {
606 match = tz;
607 break;
608 }
609 }
610 mutex_unlock(&thermal_list_lock);
611
612 return match;
613}
614
615/*
616 * Device management section: cooling devices, zones devices, and binding
617 *
618 * Set of functions provided by the thermal core for:
619 * - cooling devices lifecycle: registration, unregistration,
620 * binding, and unbinding.
621 * - thermal zone devices lifecycle: registration, unregistration,
622 * binding, and unbinding.
623 */
624
625/**
626 * thermal_bind_cdev_to_trip - bind a cooling device to a thermal zone
627 * @tz: pointer to struct thermal_zone_device
628 * @trip: trip point the cooling devices is associated with in this zone.
629 * @cdev: pointer to struct thermal_cooling_device
630 * @upper: the Maximum cooling state for this trip point.
631 * THERMAL_NO_LIMIT means no upper limit,
632 * and the cooling device can be in max_state.
633 * @lower: the Minimum cooling state can be used for this trip point.
634 * THERMAL_NO_LIMIT means no lower limit,
635 * and the cooling device can be in cooling state 0.
636 * @weight: The weight of the cooling device to be bound to the
637 * thermal zone. Use THERMAL_WEIGHT_DEFAULT for the
638 * default value
639 *
640 * This interface function bind a thermal cooling device to the certain trip
641 * point of a thermal zone device.
642 * This function is usually called in the thermal zone device .bind callback.
643 *
644 * Return: 0 on success, the proper error value otherwise.
645 */
646int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,
647 const struct thermal_trip *trip,
648 struct thermal_cooling_device *cdev,
649 unsigned long upper, unsigned long lower,
650 unsigned int weight)
651{
652 struct thermal_instance *dev;
653 struct thermal_instance *pos;
654 struct thermal_zone_device *pos1;
655 struct thermal_cooling_device *pos2;
656 bool upper_no_limit;
657 int result;
658
659 list_for_each_entry(pos1, &thermal_tz_list, node) {
660 if (pos1 == tz)
661 break;
662 }
663 list_for_each_entry(pos2, &thermal_cdev_list, node) {
664 if (pos2 == cdev)
665 break;
666 }
667
668 if (tz != pos1 || cdev != pos2)
669 return -EINVAL;
670
671 /* lower default 0, upper default max_state */
672 lower = lower == THERMAL_NO_LIMIT ? 0 : lower;
673
674 if (upper == THERMAL_NO_LIMIT) {
675 upper = cdev->max_state;
676 upper_no_limit = true;
677 } else {
678 upper_no_limit = false;
679 }
680
681 if (lower > upper || upper > cdev->max_state)
682 return -EINVAL;
683
684 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
685 if (!dev)
686 return -ENOMEM;
687 dev->tz = tz;
688 dev->cdev = cdev;
689 dev->trip = trip;
690 dev->upper = upper;
691 dev->upper_no_limit = upper_no_limit;
692 dev->lower = lower;
693 dev->target = THERMAL_NO_TARGET;
694 dev->weight = weight;
695
696 result = ida_alloc(&tz->ida, GFP_KERNEL);
697 if (result < 0)
698 goto free_mem;
699
700 dev->id = result;
701 sprintf(dev->name, "cdev%d", dev->id);
702 result =
703 sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);
704 if (result)
705 goto release_ida;
706
707 snprintf(dev->attr_name, sizeof(dev->attr_name), "cdev%d_trip_point",
708 dev->id);
709 sysfs_attr_init(&dev->attr.attr);
710 dev->attr.attr.name = dev->attr_name;
711 dev->attr.attr.mode = 0444;
712 dev->attr.show = trip_point_show;
713 result = device_create_file(&tz->device, &dev->attr);
714 if (result)
715 goto remove_symbol_link;
716
717 snprintf(dev->weight_attr_name, sizeof(dev->weight_attr_name),
718 "cdev%d_weight", dev->id);
719 sysfs_attr_init(&dev->weight_attr.attr);
720 dev->weight_attr.attr.name = dev->weight_attr_name;
721 dev->weight_attr.attr.mode = S_IWUSR | S_IRUGO;
722 dev->weight_attr.show = weight_show;
723 dev->weight_attr.store = weight_store;
724 result = device_create_file(&tz->device, &dev->weight_attr);
725 if (result)
726 goto remove_trip_file;
727
728 mutex_lock(&tz->lock);
729 mutex_lock(&cdev->lock);
730 list_for_each_entry(pos, &tz->thermal_instances, tz_node)
731 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
732 result = -EEXIST;
733 break;
734 }
735 if (!result) {
736 list_add_tail(&dev->tz_node, &tz->thermal_instances);
737 list_add_tail(&dev->cdev_node, &cdev->thermal_instances);
738 atomic_set(&tz->need_update, 1);
739
740 thermal_governor_update_tz(tz, THERMAL_TZ_BIND_CDEV);
741 }
742 mutex_unlock(&cdev->lock);
743 mutex_unlock(&tz->lock);
744
745 if (!result)
746 return 0;
747
748 device_remove_file(&tz->device, &dev->weight_attr);
749remove_trip_file:
750 device_remove_file(&tz->device, &dev->attr);
751remove_symbol_link:
752 sysfs_remove_link(&tz->device.kobj, dev->name);
753release_ida:
754 ida_free(&tz->ida, dev->id);
755free_mem:
756 kfree(dev);
757 return result;
758}
759EXPORT_SYMBOL_GPL(thermal_bind_cdev_to_trip);
760
761int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
762 int trip_index,
763 struct thermal_cooling_device *cdev,
764 unsigned long upper, unsigned long lower,
765 unsigned int weight)
766{
767 if (trip_index < 0 || trip_index >= tz->num_trips)
768 return -EINVAL;
769
770 return thermal_bind_cdev_to_trip(tz, &tz->trips[trip_index], cdev,
771 upper, lower, weight);
772}
773EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device);
774
775/**
776 * thermal_unbind_cdev_from_trip - unbind a cooling device from a thermal zone.
777 * @tz: pointer to a struct thermal_zone_device.
778 * @trip: trip point the cooling devices is associated with in this zone.
779 * @cdev: pointer to a struct thermal_cooling_device.
780 *
781 * This interface function unbind a thermal cooling device from the certain
782 * trip point of a thermal zone device.
783 * This function is usually called in the thermal zone device .unbind callback.
784 *
785 * Return: 0 on success, the proper error value otherwise.
786 */
787int thermal_unbind_cdev_from_trip(struct thermal_zone_device *tz,
788 const struct thermal_trip *trip,
789 struct thermal_cooling_device *cdev)
790{
791 struct thermal_instance *pos, *next;
792
793 mutex_lock(&tz->lock);
794 mutex_lock(&cdev->lock);
795 list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) {
796 if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
797 list_del(&pos->tz_node);
798 list_del(&pos->cdev_node);
799
800 thermal_governor_update_tz(tz, THERMAL_TZ_UNBIND_CDEV);
801
802 mutex_unlock(&cdev->lock);
803 mutex_unlock(&tz->lock);
804 goto unbind;
805 }
806 }
807 mutex_unlock(&cdev->lock);
808 mutex_unlock(&tz->lock);
809
810 return -ENODEV;
811
812unbind:
813 device_remove_file(&tz->device, &pos->weight_attr);
814 device_remove_file(&tz->device, &pos->attr);
815 sysfs_remove_link(&tz->device.kobj, pos->name);
816 ida_free(&tz->ida, pos->id);
817 kfree(pos);
818 return 0;
819}
820EXPORT_SYMBOL_GPL(thermal_unbind_cdev_from_trip);
821
822int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
823 int trip_index,
824 struct thermal_cooling_device *cdev)
825{
826 if (trip_index < 0 || trip_index >= tz->num_trips)
827 return -EINVAL;
828
829 return thermal_unbind_cdev_from_trip(tz, &tz->trips[trip_index], cdev);
830}
831EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device);
832
833static void thermal_release(struct device *dev)
834{
835 struct thermal_zone_device *tz;
836 struct thermal_cooling_device *cdev;
837
838 if (!strncmp(dev_name(dev), "thermal_zone",
839 sizeof("thermal_zone") - 1)) {
840 tz = to_thermal_zone(dev);
841 thermal_zone_destroy_device_groups(tz);
842 mutex_destroy(&tz->lock);
843 complete(&tz->removal);
844 } else if (!strncmp(dev_name(dev), "cooling_device",
845 sizeof("cooling_device") - 1)) {
846 cdev = to_cooling_device(dev);
847 thermal_cooling_device_destroy_sysfs(cdev);
848 kfree_const(cdev->type);
849 ida_free(&thermal_cdev_ida, cdev->id);
850 kfree(cdev);
851 }
852}
853
854static struct class *thermal_class;
855
856static inline
857void print_bind_err_msg(struct thermal_zone_device *tz,
858 struct thermal_cooling_device *cdev, int ret)
859{
860 dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n",
861 tz->type, cdev->type, ret);
862}
863
864static void bind_cdev(struct thermal_cooling_device *cdev)
865{
866 int ret;
867 struct thermal_zone_device *pos = NULL;
868
869 list_for_each_entry(pos, &thermal_tz_list, node) {
870 if (pos->ops->bind) {
871 ret = pos->ops->bind(pos, cdev);
872 if (ret)
873 print_bind_err_msg(pos, cdev, ret);
874 }
875 }
876}
877
878/**
879 * __thermal_cooling_device_register() - register a new thermal cooling device
880 * @np: a pointer to a device tree node.
881 * @type: the thermal cooling device type.
882 * @devdata: device private data.
883 * @ops: standard thermal cooling devices callbacks.
884 *
885 * This interface function adds a new thermal cooling device (fan/processor/...)
886 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
887 * to all the thermal zone devices registered at the same time.
888 * It also gives the opportunity to link the cooling device to a device tree
889 * node, so that it can be bound to a thermal zone created out of device tree.
890 *
891 * Return: a pointer to the created struct thermal_cooling_device or an
892 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
893 */
894static struct thermal_cooling_device *
895__thermal_cooling_device_register(struct device_node *np,
896 const char *type, void *devdata,
897 const struct thermal_cooling_device_ops *ops)
898{
899 struct thermal_cooling_device *cdev;
900 struct thermal_zone_device *pos = NULL;
901 int id, ret;
902
903 if (!ops || !ops->get_max_state || !ops->get_cur_state ||
904 !ops->set_cur_state)
905 return ERR_PTR(-EINVAL);
906
907 if (!thermal_class)
908 return ERR_PTR(-ENODEV);
909
910 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
911 if (!cdev)
912 return ERR_PTR(-ENOMEM);
913
914 ret = ida_alloc(&thermal_cdev_ida, GFP_KERNEL);
915 if (ret < 0)
916 goto out_kfree_cdev;
917 cdev->id = ret;
918 id = ret;
919
920 cdev->type = kstrdup_const(type ? type : "", GFP_KERNEL);
921 if (!cdev->type) {
922 ret = -ENOMEM;
923 goto out_ida_remove;
924 }
925
926 mutex_init(&cdev->lock);
927 INIT_LIST_HEAD(&cdev->thermal_instances);
928 cdev->np = np;
929 cdev->ops = ops;
930 cdev->updated = false;
931 cdev->device.class = thermal_class;
932 cdev->devdata = devdata;
933
934 ret = cdev->ops->get_max_state(cdev, &cdev->max_state);
935 if (ret)
936 goto out_cdev_type;
937
938 thermal_cooling_device_setup_sysfs(cdev);
939
940 ret = dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
941 if (ret)
942 goto out_cooling_dev;
943
944 ret = device_register(&cdev->device);
945 if (ret) {
946 /* thermal_release() handles rest of the cleanup */
947 put_device(&cdev->device);
948 return ERR_PTR(ret);
949 }
950
951 /* Add 'this' new cdev to the global cdev list */
952 mutex_lock(&thermal_list_lock);
953
954 list_add(&cdev->node, &thermal_cdev_list);
955
956 /* Update binding information for 'this' new cdev */
957 bind_cdev(cdev);
958
959 list_for_each_entry(pos, &thermal_tz_list, node)
960 if (atomic_cmpxchg(&pos->need_update, 1, 0))
961 thermal_zone_device_update(pos,
962 THERMAL_EVENT_UNSPECIFIED);
963
964 mutex_unlock(&thermal_list_lock);
965
966 thermal_debug_cdev_add(cdev);
967
968 return cdev;
969
970out_cooling_dev:
971 thermal_cooling_device_destroy_sysfs(cdev);
972out_cdev_type:
973 kfree_const(cdev->type);
974out_ida_remove:
975 ida_free(&thermal_cdev_ida, id);
976out_kfree_cdev:
977 kfree(cdev);
978 return ERR_PTR(ret);
979}
980
981/**
982 * thermal_cooling_device_register() - register a new thermal cooling device
983 * @type: the thermal cooling device type.
984 * @devdata: device private data.
985 * @ops: standard thermal cooling devices callbacks.
986 *
987 * This interface function adds a new thermal cooling device (fan/processor/...)
988 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
989 * to all the thermal zone devices registered at the same time.
990 *
991 * Return: a pointer to the created struct thermal_cooling_device or an
992 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
993 */
994struct thermal_cooling_device *
995thermal_cooling_device_register(const char *type, void *devdata,
996 const struct thermal_cooling_device_ops *ops)
997{
998 return __thermal_cooling_device_register(NULL, type, devdata, ops);
999}
1000EXPORT_SYMBOL_GPL(thermal_cooling_device_register);
1001
1002/**
1003 * thermal_of_cooling_device_register() - register an OF thermal cooling device
1004 * @np: a pointer to a device tree node.
1005 * @type: the thermal cooling device type.
1006 * @devdata: device private data.
1007 * @ops: standard thermal cooling devices callbacks.
1008 *
1009 * This function will register a cooling device with device tree node reference.
1010 * This interface function adds a new thermal cooling device (fan/processor/...)
1011 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1012 * to all the thermal zone devices registered at the same time.
1013 *
1014 * Return: a pointer to the created struct thermal_cooling_device or an
1015 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1016 */
1017struct thermal_cooling_device *
1018thermal_of_cooling_device_register(struct device_node *np,
1019 const char *type, void *devdata,
1020 const struct thermal_cooling_device_ops *ops)
1021{
1022 return __thermal_cooling_device_register(np, type, devdata, ops);
1023}
1024EXPORT_SYMBOL_GPL(thermal_of_cooling_device_register);
1025
1026static void thermal_cooling_device_release(struct device *dev, void *res)
1027{
1028 thermal_cooling_device_unregister(
1029 *(struct thermal_cooling_device **)res);
1030}
1031
1032/**
1033 * devm_thermal_of_cooling_device_register() - register an OF thermal cooling
1034 * device
1035 * @dev: a valid struct device pointer of a sensor device.
1036 * @np: a pointer to a device tree node.
1037 * @type: the thermal cooling device type.
1038 * @devdata: device private data.
1039 * @ops: standard thermal cooling devices callbacks.
1040 *
1041 * This function will register a cooling device with device tree node reference.
1042 * This interface function adds a new thermal cooling device (fan/processor/...)
1043 * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1044 * to all the thermal zone devices registered at the same time.
1045 *
1046 * Return: a pointer to the created struct thermal_cooling_device or an
1047 * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1048 */
1049struct thermal_cooling_device *
1050devm_thermal_of_cooling_device_register(struct device *dev,
1051 struct device_node *np,
1052 char *type, void *devdata,
1053 const struct thermal_cooling_device_ops *ops)
1054{
1055 struct thermal_cooling_device **ptr, *tcd;
1056
1057 ptr = devres_alloc(thermal_cooling_device_release, sizeof(*ptr),
1058 GFP_KERNEL);
1059 if (!ptr)
1060 return ERR_PTR(-ENOMEM);
1061
1062 tcd = __thermal_cooling_device_register(np, type, devdata, ops);
1063 if (IS_ERR(tcd)) {
1064 devres_free(ptr);
1065 return tcd;
1066 }
1067
1068 *ptr = tcd;
1069 devres_add(dev, ptr);
1070
1071 return tcd;
1072}
1073EXPORT_SYMBOL_GPL(devm_thermal_of_cooling_device_register);
1074
1075static bool thermal_cooling_device_present(struct thermal_cooling_device *cdev)
1076{
1077 struct thermal_cooling_device *pos = NULL;
1078
1079 list_for_each_entry(pos, &thermal_cdev_list, node) {
1080 if (pos == cdev)
1081 return true;
1082 }
1083
1084 return false;
1085}
1086
1087/**
1088 * thermal_cooling_device_update - Update a cooling device object
1089 * @cdev: Target cooling device.
1090 *
1091 * Update @cdev to reflect a change of the underlying hardware or platform.
1092 *
1093 * Must be called when the maximum cooling state of @cdev becomes invalid and so
1094 * its .get_max_state() callback needs to be run to produce the new maximum
1095 * cooling state value.
1096 */
1097void thermal_cooling_device_update(struct thermal_cooling_device *cdev)
1098{
1099 struct thermal_instance *ti;
1100 unsigned long state;
1101
1102 if (IS_ERR_OR_NULL(cdev))
1103 return;
1104
1105 /*
1106 * Hold thermal_list_lock throughout the update to prevent the device
1107 * from going away while being updated.
1108 */
1109 mutex_lock(&thermal_list_lock);
1110
1111 if (!thermal_cooling_device_present(cdev))
1112 goto unlock_list;
1113
1114 /*
1115 * Update under the cdev lock to prevent the state from being set beyond
1116 * the new limit concurrently.
1117 */
1118 mutex_lock(&cdev->lock);
1119
1120 if (cdev->ops->get_max_state(cdev, &cdev->max_state))
1121 goto unlock;
1122
1123 thermal_cooling_device_stats_reinit(cdev);
1124
1125 list_for_each_entry(ti, &cdev->thermal_instances, cdev_node) {
1126 if (ti->upper == cdev->max_state)
1127 continue;
1128
1129 if (ti->upper < cdev->max_state) {
1130 if (ti->upper_no_limit)
1131 ti->upper = cdev->max_state;
1132
1133 continue;
1134 }
1135
1136 ti->upper = cdev->max_state;
1137 if (ti->lower > ti->upper)
1138 ti->lower = ti->upper;
1139
1140 if (ti->target == THERMAL_NO_TARGET)
1141 continue;
1142
1143 if (ti->target > ti->upper)
1144 ti->target = ti->upper;
1145 }
1146
1147 if (cdev->ops->get_cur_state(cdev, &state) || state > cdev->max_state)
1148 goto unlock;
1149
1150 thermal_cooling_device_stats_update(cdev, state);
1151
1152unlock:
1153 mutex_unlock(&cdev->lock);
1154
1155unlock_list:
1156 mutex_unlock(&thermal_list_lock);
1157}
1158EXPORT_SYMBOL_GPL(thermal_cooling_device_update);
1159
1160/**
1161 * thermal_cooling_device_unregister - removes a thermal cooling device
1162 * @cdev: the thermal cooling device to remove.
1163 *
1164 * thermal_cooling_device_unregister() must be called when a registered
1165 * thermal cooling device is no longer needed.
1166 */
1167void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev)
1168{
1169 struct thermal_zone_device *tz;
1170
1171 if (!cdev)
1172 return;
1173
1174 thermal_debug_cdev_remove(cdev);
1175
1176 mutex_lock(&thermal_list_lock);
1177
1178 if (!thermal_cooling_device_present(cdev)) {
1179 mutex_unlock(&thermal_list_lock);
1180 return;
1181 }
1182
1183 list_del(&cdev->node);
1184
1185 /* Unbind all thermal zones associated with 'this' cdev */
1186 list_for_each_entry(tz, &thermal_tz_list, node) {
1187 if (tz->ops->unbind)
1188 tz->ops->unbind(tz, cdev);
1189 }
1190
1191 mutex_unlock(&thermal_list_lock);
1192
1193 device_unregister(&cdev->device);
1194}
1195EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister);
1196
1197static void bind_tz(struct thermal_zone_device *tz)
1198{
1199 int ret;
1200 struct thermal_cooling_device *pos = NULL;
1201
1202 if (!tz->ops->bind)
1203 return;
1204
1205 mutex_lock(&thermal_list_lock);
1206
1207 list_for_each_entry(pos, &thermal_cdev_list, node) {
1208 ret = tz->ops->bind(tz, pos);
1209 if (ret)
1210 print_bind_err_msg(tz, pos, ret);
1211 }
1212
1213 mutex_unlock(&thermal_list_lock);
1214}
1215
1216static void thermal_set_delay_jiffies(unsigned long *delay_jiffies, int delay_ms)
1217{
1218 *delay_jiffies = msecs_to_jiffies(delay_ms);
1219 if (delay_ms > 1000)
1220 *delay_jiffies = round_jiffies(*delay_jiffies);
1221}
1222
1223int thermal_zone_get_crit_temp(struct thermal_zone_device *tz, int *temp)
1224{
1225 int i, ret = -EINVAL;
1226
1227 if (tz->ops->get_crit_temp)
1228 return tz->ops->get_crit_temp(tz, temp);
1229
1230 if (!tz->trips)
1231 return -EINVAL;
1232
1233 mutex_lock(&tz->lock);
1234
1235 for (i = 0; i < tz->num_trips; i++) {
1236 if (tz->trips[i].type == THERMAL_TRIP_CRITICAL) {
1237 *temp = tz->trips[i].temperature;
1238 ret = 0;
1239 break;
1240 }
1241 }
1242
1243 mutex_unlock(&tz->lock);
1244
1245 return ret;
1246}
1247EXPORT_SYMBOL_GPL(thermal_zone_get_crit_temp);
1248
1249/**
1250 * thermal_zone_device_register_with_trips() - register a new thermal zone device
1251 * @type: the thermal zone device type
1252 * @trips: a pointer to an array of thermal trips
1253 * @num_trips: the number of trip points the thermal zone support
1254 * @mask: a bit string indicating the writeablility of trip points
1255 * @devdata: private device data
1256 * @ops: standard thermal zone device callbacks
1257 * @tzp: thermal zone platform parameters
1258 * @passive_delay: number of milliseconds to wait between polls when
1259 * performing passive cooling
1260 * @polling_delay: number of milliseconds to wait between polls when checking
1261 * whether trip points have been crossed (0 for interrupt
1262 * driven systems)
1263 *
1264 * This interface function adds a new thermal zone device (sensor) to
1265 * /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the
1266 * thermal cooling devices registered at the same time.
1267 * thermal_zone_device_unregister() must be called when the device is no
1268 * longer needed. The passive cooling depends on the .get_trend() return value.
1269 *
1270 * Return: a pointer to the created struct thermal_zone_device or an
1271 * in case of error, an ERR_PTR. Caller must check return value with
1272 * IS_ERR*() helpers.
1273 */
1274struct thermal_zone_device *
1275thermal_zone_device_register_with_trips(const char *type, struct thermal_trip *trips, int num_trips, int mask,
1276 void *devdata, struct thermal_zone_device_ops *ops,
1277 const struct thermal_zone_params *tzp, int passive_delay,
1278 int polling_delay)
1279{
1280 struct thermal_zone_device *tz;
1281 int id;
1282 int result;
1283 struct thermal_governor *governor;
1284
1285 if (!type || strlen(type) == 0) {
1286 pr_err("No thermal zone type defined\n");
1287 return ERR_PTR(-EINVAL);
1288 }
1289
1290 if (strlen(type) >= THERMAL_NAME_LENGTH) {
1291 pr_err("Thermal zone name (%s) too long, should be under %d chars\n",
1292 type, THERMAL_NAME_LENGTH);
1293 return ERR_PTR(-EINVAL);
1294 }
1295
1296 /*
1297 * Max trip count can't exceed 31 as the "mask >> num_trips" condition.
1298 * For example, shifting by 32 will result in compiler warning:
1299 * warning: right shift count >= width of type [-Wshift-count- overflow]
1300 *
1301 * Also "mask >> num_trips" will always be true with 32 bit shift.
1302 * E.g. mask = 0x80000000 for trip id 31 to be RW. Then
1303 * mask >> 32 = 0x80000000
1304 * This will result in failure for the below condition.
1305 *
1306 * Check will be true when the bit 31 of the mask is set.
1307 * 32 bit shift will cause overflow of 4 byte integer.
1308 */
1309 if (num_trips > (BITS_PER_TYPE(int) - 1) || num_trips < 0 || mask >> num_trips) {
1310 pr_err("Incorrect number of thermal trips\n");
1311 return ERR_PTR(-EINVAL);
1312 }
1313
1314 if (!ops || !ops->get_temp) {
1315 pr_err("Thermal zone device ops not defined\n");
1316 return ERR_PTR(-EINVAL);
1317 }
1318
1319 if (num_trips > 0 && !trips)
1320 return ERR_PTR(-EINVAL);
1321
1322 if (!thermal_class)
1323 return ERR_PTR(-ENODEV);
1324
1325 tz = kzalloc(sizeof(*tz), GFP_KERNEL);
1326 if (!tz)
1327 return ERR_PTR(-ENOMEM);
1328
1329 if (tzp) {
1330 tz->tzp = kmemdup(tzp, sizeof(*tzp), GFP_KERNEL);
1331 if (!tz->tzp) {
1332 result = -ENOMEM;
1333 goto free_tz;
1334 }
1335 }
1336
1337 INIT_LIST_HEAD(&tz->thermal_instances);
1338 INIT_LIST_HEAD(&tz->node);
1339 ida_init(&tz->ida);
1340 mutex_init(&tz->lock);
1341 init_completion(&tz->removal);
1342 id = ida_alloc(&thermal_tz_ida, GFP_KERNEL);
1343 if (id < 0) {
1344 result = id;
1345 goto free_tzp;
1346 }
1347
1348 tz->id = id;
1349 strscpy(tz->type, type, sizeof(tz->type));
1350
1351 if (!ops->critical)
1352 ops->critical = thermal_zone_device_critical;
1353
1354 tz->ops = ops;
1355 tz->device.class = thermal_class;
1356 tz->devdata = devdata;
1357 tz->trips = trips;
1358 tz->num_trips = num_trips;
1359
1360 thermal_set_delay_jiffies(&tz->passive_delay_jiffies, passive_delay);
1361 thermal_set_delay_jiffies(&tz->polling_delay_jiffies, polling_delay);
1362
1363 /* sys I/F */
1364 /* Add nodes that are always present via .groups */
1365 result = thermal_zone_create_device_groups(tz, mask);
1366 if (result)
1367 goto remove_id;
1368
1369 /* A new thermal zone needs to be updated anyway. */
1370 atomic_set(&tz->need_update, 1);
1371
1372 result = dev_set_name(&tz->device, "thermal_zone%d", tz->id);
1373 if (result) {
1374 thermal_zone_destroy_device_groups(tz);
1375 goto remove_id;
1376 }
1377 result = device_register(&tz->device);
1378 if (result)
1379 goto release_device;
1380
1381 /* Update 'this' zone's governor information */
1382 mutex_lock(&thermal_governor_lock);
1383
1384 if (tz->tzp)
1385 governor = __find_governor(tz->tzp->governor_name);
1386 else
1387 governor = def_governor;
1388
1389 result = thermal_set_governor(tz, governor);
1390 if (result) {
1391 mutex_unlock(&thermal_governor_lock);
1392 goto unregister;
1393 }
1394
1395 mutex_unlock(&thermal_governor_lock);
1396
1397 if (!tz->tzp || !tz->tzp->no_hwmon) {
1398 result = thermal_add_hwmon_sysfs(tz);
1399 if (result)
1400 goto unregister;
1401 }
1402
1403 mutex_lock(&thermal_list_lock);
1404 mutex_lock(&tz->lock);
1405 list_add_tail(&tz->node, &thermal_tz_list);
1406 mutex_unlock(&tz->lock);
1407 mutex_unlock(&thermal_list_lock);
1408
1409 /* Bind cooling devices for this zone */
1410 bind_tz(tz);
1411
1412 thermal_zone_device_init(tz);
1413 /* Update the new thermal zone and mark it as already updated. */
1414 if (atomic_cmpxchg(&tz->need_update, 1, 0))
1415 thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
1416
1417 thermal_notify_tz_create(tz);
1418
1419 thermal_debug_tz_add(tz);
1420
1421 return tz;
1422
1423unregister:
1424 device_del(&tz->device);
1425release_device:
1426 put_device(&tz->device);
1427remove_id:
1428 ida_free(&thermal_tz_ida, id);
1429free_tzp:
1430 kfree(tz->tzp);
1431free_tz:
1432 kfree(tz);
1433 return ERR_PTR(result);
1434}
1435EXPORT_SYMBOL_GPL(thermal_zone_device_register_with_trips);
1436
1437struct thermal_zone_device *thermal_tripless_zone_device_register(
1438 const char *type,
1439 void *devdata,
1440 struct thermal_zone_device_ops *ops,
1441 const struct thermal_zone_params *tzp)
1442{
1443 return thermal_zone_device_register_with_trips(type, NULL, 0, 0, devdata,
1444 ops, tzp, 0, 0);
1445}
1446EXPORT_SYMBOL_GPL(thermal_tripless_zone_device_register);
1447
1448void *thermal_zone_device_priv(struct thermal_zone_device *tzd)
1449{
1450 return tzd->devdata;
1451}
1452EXPORT_SYMBOL_GPL(thermal_zone_device_priv);
1453
1454const char *thermal_zone_device_type(struct thermal_zone_device *tzd)
1455{
1456 return tzd->type;
1457}
1458EXPORT_SYMBOL_GPL(thermal_zone_device_type);
1459
1460int thermal_zone_device_id(struct thermal_zone_device *tzd)
1461{
1462 return tzd->id;
1463}
1464EXPORT_SYMBOL_GPL(thermal_zone_device_id);
1465
1466struct device *thermal_zone_device(struct thermal_zone_device *tzd)
1467{
1468 return &tzd->device;
1469}
1470EXPORT_SYMBOL_GPL(thermal_zone_device);
1471
1472/**
1473 * thermal_zone_device_unregister - removes the registered thermal zone device
1474 * @tz: the thermal zone device to remove
1475 */
1476void thermal_zone_device_unregister(struct thermal_zone_device *tz)
1477{
1478 struct thermal_cooling_device *cdev;
1479 struct thermal_zone_device *pos = NULL;
1480
1481 if (!tz)
1482 return;
1483
1484 thermal_debug_tz_remove(tz);
1485
1486 mutex_lock(&thermal_list_lock);
1487 list_for_each_entry(pos, &thermal_tz_list, node)
1488 if (pos == tz)
1489 break;
1490 if (pos != tz) {
1491 /* thermal zone device not found */
1492 mutex_unlock(&thermal_list_lock);
1493 return;
1494 }
1495
1496 mutex_lock(&tz->lock);
1497 list_del(&tz->node);
1498 mutex_unlock(&tz->lock);
1499
1500 /* Unbind all cdevs associated with 'this' thermal zone */
1501 list_for_each_entry(cdev, &thermal_cdev_list, node)
1502 if (tz->ops->unbind)
1503 tz->ops->unbind(tz, cdev);
1504
1505 mutex_unlock(&thermal_list_lock);
1506
1507 cancel_delayed_work_sync(&tz->poll_queue);
1508
1509 thermal_set_governor(tz, NULL);
1510
1511 thermal_remove_hwmon_sysfs(tz);
1512 ida_free(&thermal_tz_ida, tz->id);
1513 ida_destroy(&tz->ida);
1514
1515 device_del(&tz->device);
1516
1517 kfree(tz->tzp);
1518
1519 put_device(&tz->device);
1520
1521 thermal_notify_tz_delete(tz);
1522
1523 wait_for_completion(&tz->removal);
1524 kfree(tz);
1525}
1526EXPORT_SYMBOL_GPL(thermal_zone_device_unregister);
1527
1528/**
1529 * thermal_zone_get_zone_by_name() - search for a zone and returns its ref
1530 * @name: thermal zone name to fetch the temperature
1531 *
1532 * When only one zone is found with the passed name, returns a reference to it.
1533 *
1534 * Return: On success returns a reference to an unique thermal zone with
1535 * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid
1536 * paramenters, -ENODEV for not found and -EEXIST for multiple matches).
1537 */
1538struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name)
1539{
1540 struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL);
1541 unsigned int found = 0;
1542
1543 if (!name)
1544 goto exit;
1545
1546 mutex_lock(&thermal_list_lock);
1547 list_for_each_entry(pos, &thermal_tz_list, node)
1548 if (!strncasecmp(name, pos->type, THERMAL_NAME_LENGTH)) {
1549 found++;
1550 ref = pos;
1551 }
1552 mutex_unlock(&thermal_list_lock);
1553
1554 /* nothing has been found, thus an error code for it */
1555 if (found == 0)
1556 ref = ERR_PTR(-ENODEV);
1557 else if (found > 1)
1558 /* Success only when an unique zone is found */
1559 ref = ERR_PTR(-EEXIST);
1560
1561exit:
1562 return ref;
1563}
1564EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name);
1565
1566static void thermal_zone_device_resume(struct work_struct *work)
1567{
1568 struct thermal_zone_device *tz;
1569
1570 tz = container_of(work, struct thermal_zone_device, poll_queue.work);
1571
1572 mutex_lock(&tz->lock);
1573
1574 tz->suspended = false;
1575
1576 thermal_zone_device_init(tz);
1577 __thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
1578
1579 mutex_unlock(&tz->lock);
1580}
1581
1582static int thermal_pm_notify(struct notifier_block *nb,
1583 unsigned long mode, void *_unused)
1584{
1585 struct thermal_zone_device *tz;
1586
1587 switch (mode) {
1588 case PM_HIBERNATION_PREPARE:
1589 case PM_RESTORE_PREPARE:
1590 case PM_SUSPEND_PREPARE:
1591 mutex_lock(&thermal_list_lock);
1592
1593 list_for_each_entry(tz, &thermal_tz_list, node) {
1594 mutex_lock(&tz->lock);
1595
1596 tz->suspended = true;
1597
1598 mutex_unlock(&tz->lock);
1599 }
1600
1601 mutex_unlock(&thermal_list_lock);
1602 break;
1603 case PM_POST_HIBERNATION:
1604 case PM_POST_RESTORE:
1605 case PM_POST_SUSPEND:
1606 mutex_lock(&thermal_list_lock);
1607
1608 list_for_each_entry(tz, &thermal_tz_list, node) {
1609 mutex_lock(&tz->lock);
1610
1611 cancel_delayed_work(&tz->poll_queue);
1612
1613 /*
1614 * Replace the work function with the resume one, which
1615 * will restore the original work function and schedule
1616 * the polling work if needed.
1617 */
1618 INIT_DELAYED_WORK(&tz->poll_queue,
1619 thermal_zone_device_resume);
1620 /* Queue up the work without a delay. */
1621 mod_delayed_work(system_freezable_power_efficient_wq,
1622 &tz->poll_queue, 0);
1623
1624 mutex_unlock(&tz->lock);
1625 }
1626
1627 mutex_unlock(&thermal_list_lock);
1628 break;
1629 default:
1630 break;
1631 }
1632 return 0;
1633}
1634
1635static struct notifier_block thermal_pm_nb = {
1636 .notifier_call = thermal_pm_notify,
1637};
1638
1639static int __init thermal_init(void)
1640{
1641 int result;
1642
1643 thermal_debug_init();
1644
1645 result = thermal_netlink_init();
1646 if (result)
1647 goto error;
1648
1649 result = thermal_register_governors();
1650 if (result)
1651 goto unregister_netlink;
1652
1653 thermal_class = kzalloc(sizeof(*thermal_class), GFP_KERNEL);
1654 if (!thermal_class) {
1655 result = -ENOMEM;
1656 goto unregister_governors;
1657 }
1658
1659 thermal_class->name = "thermal";
1660 thermal_class->dev_release = thermal_release;
1661
1662 result = class_register(thermal_class);
1663 if (result) {
1664 kfree(thermal_class);
1665 thermal_class = NULL;
1666 goto unregister_governors;
1667 }
1668
1669 result = register_pm_notifier(&thermal_pm_nb);
1670 if (result)
1671 pr_warn("Thermal: Can not register suspend notifier, return %d\n",
1672 result);
1673
1674 return 0;
1675
1676unregister_governors:
1677 thermal_unregister_governors();
1678unregister_netlink:
1679 thermal_netlink_exit();
1680error:
1681 mutex_destroy(&thermal_list_lock);
1682 mutex_destroy(&thermal_governor_lock);
1683 return result;
1684}
1685postcore_initcall(thermal_init);