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