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