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  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; version 2 of the License.
13  *
14  *  This program is distributed in the hope that it will be useful, but
15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  *  General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License along
20  *  with this program; if not, write to the Free Software Foundation, Inc.,
21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
22  *
23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
24  */
25 
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 
28 #include <linux/module.h>
29 #include <linux/device.h>
30 #include <linux/err.h>
31 #include <linux/slab.h>
32 #include <linux/kdev_t.h>
33 #include <linux/idr.h>
34 #include <linux/thermal.h>
35 #include <linux/reboot.h>
36 #include <linux/string.h>
37 #include <linux/of.h>
38 #include <net/netlink.h>
39 #include <net/genetlink.h>
40 #include <linux/suspend.h>
41 
42 #define CREATE_TRACE_POINTS
43 #include <trace/events/thermal.h>
44 
45 #include "thermal_core.h"
46 #include "thermal_hwmon.h"
47 
48 MODULE_AUTHOR("Zhang Rui");
49 MODULE_DESCRIPTION("Generic thermal management sysfs support");
50 MODULE_LICENSE("GPL v2");
51 
52 static DEFINE_IDR(thermal_tz_idr);
53 static DEFINE_IDR(thermal_cdev_idr);
54 static DEFINE_MUTEX(thermal_idr_lock);
55 
56 static LIST_HEAD(thermal_tz_list);
57 static LIST_HEAD(thermal_cdev_list);
58 static LIST_HEAD(thermal_governor_list);
59 
60 static DEFINE_MUTEX(thermal_list_lock);
61 static DEFINE_MUTEX(thermal_governor_lock);
62 
63 static atomic_t in_suspend;
64 
65 static struct thermal_governor *def_governor;
66 
67 static struct thermal_governor *__find_governor(const char *name)
68 {
69 	struct thermal_governor *pos;
70 
71 	if (!name || !name[0])
72 		return def_governor;
73 
74 	list_for_each_entry(pos, &thermal_governor_list, governor_list)
75 		if (!strncasecmp(name, pos->name, THERMAL_NAME_LENGTH))
76 			return pos;
77 
78 	return NULL;
79 }
80 
81 /**
82  * bind_previous_governor() - bind the previous governor of the thermal zone
83  * @tz:		a valid pointer to a struct thermal_zone_device
84  * @failed_gov_name:	the name of the governor that failed to register
85  *
86  * Register the previous governor of the thermal zone after a new
87  * governor has failed to be bound.
88  */
89 static void bind_previous_governor(struct thermal_zone_device *tz,
90 				   const char *failed_gov_name)
91 {
92 	if (tz->governor && tz->governor->bind_to_tz) {
93 		if (tz->governor->bind_to_tz(tz)) {
94 			dev_err(&tz->device,
95 				"governor %s failed to bind and the previous one (%s) failed to bind again, thermal zone %s has no governor\n",
96 				failed_gov_name, tz->governor->name, tz->type);
97 			tz->governor = NULL;
98 		}
99 	}
100 }
101 
102 /**
103  * thermal_set_governor() - Switch to another governor
104  * @tz:		a valid pointer to a struct thermal_zone_device
105  * @new_gov:	pointer to the new governor
106  *
107  * Change the governor of thermal zone @tz.
108  *
109  * Return: 0 on success, an error if the new governor's bind_to_tz() failed.
110  */
111 static int thermal_set_governor(struct thermal_zone_device *tz,
112 				struct thermal_governor *new_gov)
113 {
114 	int ret = 0;
115 
116 	if (tz->governor && tz->governor->unbind_from_tz)
117 		tz->governor->unbind_from_tz(tz);
118 
119 	if (new_gov && new_gov->bind_to_tz) {
120 		ret = new_gov->bind_to_tz(tz);
121 		if (ret) {
122 			bind_previous_governor(tz, new_gov->name);
123 
124 			return ret;
125 		}
126 	}
127 
128 	tz->governor = new_gov;
129 
130 	return ret;
131 }
132 
133 int thermal_register_governor(struct thermal_governor *governor)
134 {
135 	int err;
136 	const char *name;
137 	struct thermal_zone_device *pos;
138 
139 	if (!governor)
140 		return -EINVAL;
141 
142 	mutex_lock(&thermal_governor_lock);
143 
144 	err = -EBUSY;
145 	if (__find_governor(governor->name) == NULL) {
146 		err = 0;
147 		list_add(&governor->governor_list, &thermal_governor_list);
148 		if (!def_governor && !strncmp(governor->name,
149 			DEFAULT_THERMAL_GOVERNOR, THERMAL_NAME_LENGTH))
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) == NULL)
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 	return;
207 }
208 
209 static int get_idr(struct idr *idr, struct mutex *lock, int *id)
210 {
211 	int ret;
212 
213 	if (lock)
214 		mutex_lock(lock);
215 	ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL);
216 	if (lock)
217 		mutex_unlock(lock);
218 	if (unlikely(ret < 0))
219 		return ret;
220 	*id = ret;
221 	return 0;
222 }
223 
224 static void release_idr(struct idr *idr, struct mutex *lock, int id)
225 {
226 	if (lock)
227 		mutex_lock(lock);
228 	idr_remove(idr, id);
229 	if (lock)
230 		mutex_unlock(lock);
231 }
232 
233 int get_tz_trend(struct thermal_zone_device *tz, int trip)
234 {
235 	enum thermal_trend trend;
236 
237 	if (tz->emul_temperature || !tz->ops->get_trend ||
238 	    tz->ops->get_trend(tz, trip, &trend)) {
239 		if (tz->temperature > tz->last_temperature)
240 			trend = THERMAL_TREND_RAISING;
241 		else if (tz->temperature < tz->last_temperature)
242 			trend = THERMAL_TREND_DROPPING;
243 		else
244 			trend = THERMAL_TREND_STABLE;
245 	}
246 
247 	return trend;
248 }
249 EXPORT_SYMBOL(get_tz_trend);
250 
251 struct thermal_instance *get_thermal_instance(struct thermal_zone_device *tz,
252 			struct thermal_cooling_device *cdev, int trip)
253 {
254 	struct thermal_instance *pos = NULL;
255 	struct thermal_instance *target_instance = NULL;
256 
257 	mutex_lock(&tz->lock);
258 	mutex_lock(&cdev->lock);
259 
260 	list_for_each_entry(pos, &tz->thermal_instances, tz_node) {
261 		if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
262 			target_instance = pos;
263 			break;
264 		}
265 	}
266 
267 	mutex_unlock(&cdev->lock);
268 	mutex_unlock(&tz->lock);
269 
270 	return target_instance;
271 }
272 EXPORT_SYMBOL(get_thermal_instance);
273 
274 static void print_bind_err_msg(struct thermal_zone_device *tz,
275 			struct thermal_cooling_device *cdev, int ret)
276 {
277 	dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n",
278 				tz->type, cdev->type, ret);
279 }
280 
281 static void __bind(struct thermal_zone_device *tz, int mask,
282 			struct thermal_cooling_device *cdev,
283 			unsigned long *limits,
284 			unsigned int weight)
285 {
286 	int i, ret;
287 
288 	for (i = 0; i < tz->trips; i++) {
289 		if (mask & (1 << i)) {
290 			unsigned long upper, lower;
291 
292 			upper = THERMAL_NO_LIMIT;
293 			lower = THERMAL_NO_LIMIT;
294 			if (limits) {
295 				lower = limits[i * 2];
296 				upper = limits[i * 2 + 1];
297 			}
298 			ret = thermal_zone_bind_cooling_device(tz, i, cdev,
299 							       upper, lower,
300 							       weight);
301 			if (ret)
302 				print_bind_err_msg(tz, cdev, ret);
303 		}
304 	}
305 }
306 
307 static void __unbind(struct thermal_zone_device *tz, int mask,
308 			struct thermal_cooling_device *cdev)
309 {
310 	int i;
311 
312 	for (i = 0; i < tz->trips; i++)
313 		if (mask & (1 << i))
314 			thermal_zone_unbind_cooling_device(tz, i, cdev);
315 }
316 
317 static void bind_cdev(struct thermal_cooling_device *cdev)
318 {
319 	int i, ret;
320 	const struct thermal_zone_params *tzp;
321 	struct thermal_zone_device *pos = NULL;
322 
323 	mutex_lock(&thermal_list_lock);
324 
325 	list_for_each_entry(pos, &thermal_tz_list, node) {
326 		if (!pos->tzp && !pos->ops->bind)
327 			continue;
328 
329 		if (pos->ops->bind) {
330 			ret = pos->ops->bind(pos, cdev);
331 			if (ret)
332 				print_bind_err_msg(pos, cdev, ret);
333 			continue;
334 		}
335 
336 		tzp = pos->tzp;
337 		if (!tzp || !tzp->tbp)
338 			continue;
339 
340 		for (i = 0; i < tzp->num_tbps; i++) {
341 			if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
342 				continue;
343 			if (tzp->tbp[i].match(pos, cdev))
344 				continue;
345 			tzp->tbp[i].cdev = cdev;
346 			__bind(pos, tzp->tbp[i].trip_mask, cdev,
347 			       tzp->tbp[i].binding_limits,
348 			       tzp->tbp[i].weight);
349 		}
350 	}
351 
352 	mutex_unlock(&thermal_list_lock);
353 }
354 
355 static void bind_tz(struct thermal_zone_device *tz)
356 {
357 	int i, ret;
358 	struct thermal_cooling_device *pos = NULL;
359 	const struct thermal_zone_params *tzp = tz->tzp;
360 
361 	if (!tzp && !tz->ops->bind)
362 		return;
363 
364 	mutex_lock(&thermal_list_lock);
365 
366 	/* If there is ops->bind, try to use ops->bind */
367 	if (tz->ops->bind) {
368 		list_for_each_entry(pos, &thermal_cdev_list, node) {
369 			ret = tz->ops->bind(tz, pos);
370 			if (ret)
371 				print_bind_err_msg(tz, pos, ret);
372 		}
373 		goto exit;
374 	}
375 
376 	if (!tzp || !tzp->tbp)
377 		goto exit;
378 
379 	list_for_each_entry(pos, &thermal_cdev_list, node) {
380 		for (i = 0; i < tzp->num_tbps; i++) {
381 			if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
382 				continue;
383 			if (tzp->tbp[i].match(tz, pos))
384 				continue;
385 			tzp->tbp[i].cdev = pos;
386 			__bind(tz, tzp->tbp[i].trip_mask, pos,
387 			       tzp->tbp[i].binding_limits,
388 			       tzp->tbp[i].weight);
389 		}
390 	}
391 exit:
392 	mutex_unlock(&thermal_list_lock);
393 }
394 
395 static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
396 					    int delay)
397 {
398 	if (delay > 1000)
399 		mod_delayed_work(system_freezable_wq, &tz->poll_queue,
400 				 round_jiffies(msecs_to_jiffies(delay)));
401 	else if (delay)
402 		mod_delayed_work(system_freezable_wq, &tz->poll_queue,
403 				 msecs_to_jiffies(delay));
404 	else
405 		cancel_delayed_work(&tz->poll_queue);
406 }
407 
408 static void monitor_thermal_zone(struct thermal_zone_device *tz)
409 {
410 	mutex_lock(&tz->lock);
411 
412 	if (tz->passive)
413 		thermal_zone_device_set_polling(tz, tz->passive_delay);
414 	else if (tz->polling_delay)
415 		thermal_zone_device_set_polling(tz, tz->polling_delay);
416 	else
417 		thermal_zone_device_set_polling(tz, 0);
418 
419 	mutex_unlock(&tz->lock);
420 }
421 
422 static void handle_non_critical_trips(struct thermal_zone_device *tz,
423 			int trip, enum thermal_trip_type trip_type)
424 {
425 	tz->governor ? tz->governor->throttle(tz, trip) :
426 		       def_governor->throttle(tz, trip);
427 }
428 
429 static void handle_critical_trips(struct thermal_zone_device *tz,
430 				int trip, enum thermal_trip_type trip_type)
431 {
432 	int trip_temp;
433 
434 	tz->ops->get_trip_temp(tz, trip, &trip_temp);
435 
436 	/* If we have not crossed the trip_temp, we do not care. */
437 	if (trip_temp <= 0 || tz->temperature < trip_temp)
438 		return;
439 
440 	trace_thermal_zone_trip(tz, trip, trip_type);
441 
442 	if (tz->ops->notify)
443 		tz->ops->notify(tz, trip, trip_type);
444 
445 	if (trip_type == THERMAL_TRIP_CRITICAL) {
446 		dev_emerg(&tz->device,
447 			  "critical temperature reached(%d C),shutting down\n",
448 			  tz->temperature / 1000);
449 		orderly_poweroff(true);
450 	}
451 }
452 
453 static void handle_thermal_trip(struct thermal_zone_device *tz, int trip)
454 {
455 	enum thermal_trip_type type;
456 
457 	/* Ignore disabled trip points */
458 	if (test_bit(trip, &tz->trips_disabled))
459 		return;
460 
461 	tz->ops->get_trip_type(tz, trip, &type);
462 
463 	if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT)
464 		handle_critical_trips(tz, trip, type);
465 	else
466 		handle_non_critical_trips(tz, trip, type);
467 	/*
468 	 * Alright, we handled this trip successfully.
469 	 * So, start monitoring again.
470 	 */
471 	monitor_thermal_zone(tz);
472 }
473 
474 /**
475  * thermal_zone_get_temp() - returns the temperature of a thermal zone
476  * @tz: a valid pointer to a struct thermal_zone_device
477  * @temp: a valid pointer to where to store the resulting temperature.
478  *
479  * When a valid thermal zone reference is passed, it will fetch its
480  * temperature and fill @temp.
481  *
482  * Return: On success returns 0, an error code otherwise
483  */
484 int thermal_zone_get_temp(struct thermal_zone_device *tz, int *temp)
485 {
486 	int ret = -EINVAL;
487 	int count;
488 	int crit_temp = INT_MAX;
489 	enum thermal_trip_type type;
490 
491 	if (!tz || IS_ERR(tz) || !tz->ops->get_temp)
492 		goto exit;
493 
494 	mutex_lock(&tz->lock);
495 
496 	ret = tz->ops->get_temp(tz, temp);
497 
498 	if (IS_ENABLED(CONFIG_THERMAL_EMULATION) && tz->emul_temperature) {
499 		for (count = 0; count < tz->trips; count++) {
500 			ret = tz->ops->get_trip_type(tz, count, &type);
501 			if (!ret && type == THERMAL_TRIP_CRITICAL) {
502 				ret = tz->ops->get_trip_temp(tz, count,
503 						&crit_temp);
504 				break;
505 			}
506 		}
507 
508 		/*
509 		 * Only allow emulating a temperature when the real temperature
510 		 * is below the critical temperature so that the emulation code
511 		 * cannot hide critical conditions.
512 		 */
513 		if (!ret && *temp < crit_temp)
514 			*temp = tz->emul_temperature;
515 	}
516 
517 	mutex_unlock(&tz->lock);
518 exit:
519 	return ret;
520 }
521 EXPORT_SYMBOL_GPL(thermal_zone_get_temp);
522 
523 void thermal_zone_set_trips(struct thermal_zone_device *tz)
524 {
525 	int low = -INT_MAX;
526 	int high = INT_MAX;
527 	int trip_temp, hysteresis;
528 	int i, ret;
529 
530 	mutex_lock(&tz->lock);
531 
532 	if (!tz->ops->set_trips || !tz->ops->get_trip_hyst)
533 		goto exit;
534 
535 	for (i = 0; i < tz->trips; i++) {
536 		int trip_low;
537 
538 		tz->ops->get_trip_temp(tz, i, &trip_temp);
539 		tz->ops->get_trip_hyst(tz, i, &hysteresis);
540 
541 		trip_low = trip_temp - hysteresis;
542 
543 		if (trip_low < tz->temperature && trip_low > low)
544 			low = trip_low;
545 
546 		if (trip_temp > tz->temperature && trip_temp < high)
547 			high = trip_temp;
548 	}
549 
550 	/* No need to change trip points */
551 	if (tz->prev_low_trip == low && tz->prev_high_trip == high)
552 		goto exit;
553 
554 	tz->prev_low_trip = low;
555 	tz->prev_high_trip = high;
556 
557 	dev_dbg(&tz->device,
558 		"new temperature boundaries: %d < x < %d\n", low, high);
559 
560 	/*
561 	 * Set a temperature window. When this window is left the driver
562 	 * must inform the thermal core via thermal_zone_device_update.
563 	 */
564 	ret = tz->ops->set_trips(tz, low, high);
565 	if (ret)
566 		dev_err(&tz->device, "Failed to set trips: %d\n", ret);
567 
568 exit:
569 	mutex_unlock(&tz->lock);
570 }
571 EXPORT_SYMBOL_GPL(thermal_zone_set_trips);
572 
573 static void update_temperature(struct thermal_zone_device *tz)
574 {
575 	int temp, ret;
576 
577 	ret = thermal_zone_get_temp(tz, &temp);
578 	if (ret) {
579 		if (ret != -EAGAIN)
580 			dev_warn(&tz->device,
581 				 "failed to read out thermal zone (%d)\n",
582 				 ret);
583 		return;
584 	}
585 
586 	mutex_lock(&tz->lock);
587 	tz->last_temperature = tz->temperature;
588 	tz->temperature = temp;
589 	mutex_unlock(&tz->lock);
590 
591 	trace_thermal_temperature(tz);
592 	if (tz->last_temperature == THERMAL_TEMP_INVALID)
593 		dev_dbg(&tz->device, "last_temperature N/A, current_temperature=%d\n",
594 			tz->temperature);
595 	else
596 		dev_dbg(&tz->device, "last_temperature=%d, current_temperature=%d\n",
597 			tz->last_temperature, tz->temperature);
598 }
599 
600 static void thermal_zone_device_reset(struct thermal_zone_device *tz)
601 {
602 	struct thermal_instance *pos;
603 
604 	tz->temperature = THERMAL_TEMP_INVALID;
605 	tz->passive = 0;
606 	list_for_each_entry(pos, &tz->thermal_instances, tz_node)
607 		pos->initialized = false;
608 }
609 
610 void thermal_zone_device_update(struct thermal_zone_device *tz,
611 				enum thermal_notify_event event)
612 {
613 	int count;
614 
615 	if (atomic_read(&in_suspend))
616 		return;
617 
618 	if (!tz->ops->get_temp)
619 		return;
620 
621 	update_temperature(tz);
622 
623 	thermal_zone_set_trips(tz);
624 
625 	tz->notify_event = event;
626 
627 	for (count = 0; count < tz->trips; count++)
628 		handle_thermal_trip(tz, count);
629 }
630 EXPORT_SYMBOL_GPL(thermal_zone_device_update);
631 
632 static void thermal_zone_device_check(struct work_struct *work)
633 {
634 	struct thermal_zone_device *tz = container_of(work, struct
635 						      thermal_zone_device,
636 						      poll_queue.work);
637 	thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
638 }
639 
640 /* sys I/F for thermal zone */
641 
642 #define to_thermal_zone(_dev) \
643 	container_of(_dev, struct thermal_zone_device, device)
644 
645 static ssize_t
646 type_show(struct device *dev, struct device_attribute *attr, char *buf)
647 {
648 	struct thermal_zone_device *tz = to_thermal_zone(dev);
649 
650 	return sprintf(buf, "%s\n", tz->type);
651 }
652 
653 static ssize_t
654 temp_show(struct device *dev, struct device_attribute *attr, char *buf)
655 {
656 	struct thermal_zone_device *tz = to_thermal_zone(dev);
657 	int temperature, ret;
658 
659 	ret = thermal_zone_get_temp(tz, &temperature);
660 
661 	if (ret)
662 		return ret;
663 
664 	return sprintf(buf, "%d\n", temperature);
665 }
666 
667 static ssize_t
668 mode_show(struct device *dev, struct device_attribute *attr, char *buf)
669 {
670 	struct thermal_zone_device *tz = to_thermal_zone(dev);
671 	enum thermal_device_mode mode;
672 	int result;
673 
674 	if (!tz->ops->get_mode)
675 		return -EPERM;
676 
677 	result = tz->ops->get_mode(tz, &mode);
678 	if (result)
679 		return result;
680 
681 	return sprintf(buf, "%s\n", mode == THERMAL_DEVICE_ENABLED ? "enabled"
682 		       : "disabled");
683 }
684 
685 static ssize_t
686 mode_store(struct device *dev, struct device_attribute *attr,
687 	   const char *buf, size_t count)
688 {
689 	struct thermal_zone_device *tz = to_thermal_zone(dev);
690 	int result;
691 
692 	if (!tz->ops->set_mode)
693 		return -EPERM;
694 
695 	if (!strncmp(buf, "enabled", sizeof("enabled") - 1))
696 		result = tz->ops->set_mode(tz, THERMAL_DEVICE_ENABLED);
697 	else if (!strncmp(buf, "disabled", sizeof("disabled") - 1))
698 		result = tz->ops->set_mode(tz, THERMAL_DEVICE_DISABLED);
699 	else
700 		result = -EINVAL;
701 
702 	if (result)
703 		return result;
704 
705 	return count;
706 }
707 
708 static ssize_t
709 trip_point_type_show(struct device *dev, struct device_attribute *attr,
710 		     char *buf)
711 {
712 	struct thermal_zone_device *tz = to_thermal_zone(dev);
713 	enum thermal_trip_type type;
714 	int trip, result;
715 
716 	if (!tz->ops->get_trip_type)
717 		return -EPERM;
718 
719 	if (!sscanf(attr->attr.name, "trip_point_%d_type", &trip))
720 		return -EINVAL;
721 
722 	result = tz->ops->get_trip_type(tz, trip, &type);
723 	if (result)
724 		return result;
725 
726 	switch (type) {
727 	case THERMAL_TRIP_CRITICAL:
728 		return sprintf(buf, "critical\n");
729 	case THERMAL_TRIP_HOT:
730 		return sprintf(buf, "hot\n");
731 	case THERMAL_TRIP_PASSIVE:
732 		return sprintf(buf, "passive\n");
733 	case THERMAL_TRIP_ACTIVE:
734 		return sprintf(buf, "active\n");
735 	default:
736 		return sprintf(buf, "unknown\n");
737 	}
738 }
739 
740 static ssize_t
741 trip_point_temp_store(struct device *dev, struct device_attribute *attr,
742 		     const char *buf, size_t count)
743 {
744 	struct thermal_zone_device *tz = to_thermal_zone(dev);
745 	int trip, ret;
746 	int temperature;
747 
748 	if (!tz->ops->set_trip_temp)
749 		return -EPERM;
750 
751 	if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip))
752 		return -EINVAL;
753 
754 	if (kstrtoint(buf, 10, &temperature))
755 		return -EINVAL;
756 
757 	ret = tz->ops->set_trip_temp(tz, trip, temperature);
758 	if (ret)
759 		return ret;
760 
761 	thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
762 
763 	return count;
764 }
765 
766 static ssize_t
767 trip_point_temp_show(struct device *dev, struct device_attribute *attr,
768 		     char *buf)
769 {
770 	struct thermal_zone_device *tz = to_thermal_zone(dev);
771 	int trip, ret;
772 	int temperature;
773 
774 	if (!tz->ops->get_trip_temp)
775 		return -EPERM;
776 
777 	if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip))
778 		return -EINVAL;
779 
780 	ret = tz->ops->get_trip_temp(tz, trip, &temperature);
781 
782 	if (ret)
783 		return ret;
784 
785 	return sprintf(buf, "%d\n", temperature);
786 }
787 
788 static ssize_t
789 trip_point_hyst_store(struct device *dev, struct device_attribute *attr,
790 			const char *buf, size_t count)
791 {
792 	struct thermal_zone_device *tz = to_thermal_zone(dev);
793 	int trip, ret;
794 	int temperature;
795 
796 	if (!tz->ops->set_trip_hyst)
797 		return -EPERM;
798 
799 	if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip))
800 		return -EINVAL;
801 
802 	if (kstrtoint(buf, 10, &temperature))
803 		return -EINVAL;
804 
805 	/*
806 	 * We are not doing any check on the 'temperature' value
807 	 * here. The driver implementing 'set_trip_hyst' has to
808 	 * take care of this.
809 	 */
810 	ret = tz->ops->set_trip_hyst(tz, trip, temperature);
811 
812 	if (!ret)
813 		thermal_zone_set_trips(tz);
814 
815 	return ret ? ret : count;
816 }
817 
818 static ssize_t
819 trip_point_hyst_show(struct device *dev, struct device_attribute *attr,
820 			char *buf)
821 {
822 	struct thermal_zone_device *tz = to_thermal_zone(dev);
823 	int trip, ret;
824 	int temperature;
825 
826 	if (!tz->ops->get_trip_hyst)
827 		return -EPERM;
828 
829 	if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip))
830 		return -EINVAL;
831 
832 	ret = tz->ops->get_trip_hyst(tz, trip, &temperature);
833 
834 	return ret ? ret : sprintf(buf, "%d\n", temperature);
835 }
836 
837 static ssize_t
838 passive_store(struct device *dev, struct device_attribute *attr,
839 		    const char *buf, size_t count)
840 {
841 	struct thermal_zone_device *tz = to_thermal_zone(dev);
842 	struct thermal_cooling_device *cdev = NULL;
843 	int state;
844 
845 	if (!sscanf(buf, "%d\n", &state))
846 		return -EINVAL;
847 
848 	/* sanity check: values below 1000 millicelcius don't make sense
849 	 * and can cause the system to go into a thermal heart attack
850 	 */
851 	if (state && state < 1000)
852 		return -EINVAL;
853 
854 	if (state && !tz->forced_passive) {
855 		mutex_lock(&thermal_list_lock);
856 		list_for_each_entry(cdev, &thermal_cdev_list, node) {
857 			if (!strncmp("Processor", cdev->type,
858 				     sizeof("Processor")))
859 				thermal_zone_bind_cooling_device(tz,
860 						THERMAL_TRIPS_NONE, cdev,
861 						THERMAL_NO_LIMIT,
862 						THERMAL_NO_LIMIT,
863 						THERMAL_WEIGHT_DEFAULT);
864 		}
865 		mutex_unlock(&thermal_list_lock);
866 		if (!tz->passive_delay)
867 			tz->passive_delay = 1000;
868 	} else if (!state && tz->forced_passive) {
869 		mutex_lock(&thermal_list_lock);
870 		list_for_each_entry(cdev, &thermal_cdev_list, node) {
871 			if (!strncmp("Processor", cdev->type,
872 				     sizeof("Processor")))
873 				thermal_zone_unbind_cooling_device(tz,
874 								   THERMAL_TRIPS_NONE,
875 								   cdev);
876 		}
877 		mutex_unlock(&thermal_list_lock);
878 		tz->passive_delay = 0;
879 	}
880 
881 	tz->forced_passive = state;
882 
883 	thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
884 
885 	return count;
886 }
887 
888 static ssize_t
889 passive_show(struct device *dev, struct device_attribute *attr,
890 		   char *buf)
891 {
892 	struct thermal_zone_device *tz = to_thermal_zone(dev);
893 
894 	return sprintf(buf, "%d\n", tz->forced_passive);
895 }
896 
897 static ssize_t
898 policy_store(struct device *dev, struct device_attribute *attr,
899 		    const char *buf, size_t count)
900 {
901 	int ret = -EINVAL;
902 	struct thermal_zone_device *tz = to_thermal_zone(dev);
903 	struct thermal_governor *gov;
904 	char name[THERMAL_NAME_LENGTH];
905 
906 	snprintf(name, sizeof(name), "%s", buf);
907 
908 	mutex_lock(&thermal_governor_lock);
909 	mutex_lock(&tz->lock);
910 
911 	gov = __find_governor(strim(name));
912 	if (!gov)
913 		goto exit;
914 
915 	ret = thermal_set_governor(tz, gov);
916 	if (!ret)
917 		ret = count;
918 
919 exit:
920 	mutex_unlock(&tz->lock);
921 	mutex_unlock(&thermal_governor_lock);
922 	return ret;
923 }
924 
925 static ssize_t
926 policy_show(struct device *dev, struct device_attribute *devattr, char *buf)
927 {
928 	struct thermal_zone_device *tz = to_thermal_zone(dev);
929 
930 	return sprintf(buf, "%s\n", tz->governor->name);
931 }
932 
933 static ssize_t
934 available_policies_show(struct device *dev, struct device_attribute *devattr,
935 			char *buf)
936 {
937 	struct thermal_governor *pos;
938 	ssize_t count = 0;
939 	ssize_t size = PAGE_SIZE;
940 
941 	mutex_lock(&thermal_governor_lock);
942 
943 	list_for_each_entry(pos, &thermal_governor_list, governor_list) {
944 		size = PAGE_SIZE - count;
945 		count += scnprintf(buf + count, size, "%s ", pos->name);
946 	}
947 	count += scnprintf(buf + count, size, "\n");
948 
949 	mutex_unlock(&thermal_governor_lock);
950 
951 	return count;
952 }
953 
954 static ssize_t
955 emul_temp_store(struct device *dev, struct device_attribute *attr,
956 		     const char *buf, size_t count)
957 {
958 	struct thermal_zone_device *tz = to_thermal_zone(dev);
959 	int ret = 0;
960 	int temperature;
961 
962 	if (kstrtoint(buf, 10, &temperature))
963 		return -EINVAL;
964 
965 	if (!tz->ops->set_emul_temp) {
966 		mutex_lock(&tz->lock);
967 		tz->emul_temperature = temperature;
968 		mutex_unlock(&tz->lock);
969 	} else {
970 		ret = tz->ops->set_emul_temp(tz, temperature);
971 	}
972 
973 	if (!ret)
974 		thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
975 
976 	return ret ? ret : count;
977 }
978 static DEVICE_ATTR(emul_temp, S_IWUSR, NULL, emul_temp_store);
979 
980 static ssize_t
981 sustainable_power_show(struct device *dev, struct device_attribute *devattr,
982 		       char *buf)
983 {
984 	struct thermal_zone_device *tz = to_thermal_zone(dev);
985 
986 	if (tz->tzp)
987 		return sprintf(buf, "%u\n", tz->tzp->sustainable_power);
988 	else
989 		return -EIO;
990 }
991 
992 static ssize_t
993 sustainable_power_store(struct device *dev, struct device_attribute *devattr,
994 			const char *buf, size_t count)
995 {
996 	struct thermal_zone_device *tz = to_thermal_zone(dev);
997 	u32 sustainable_power;
998 
999 	if (!tz->tzp)
1000 		return -EIO;
1001 
1002 	if (kstrtou32(buf, 10, &sustainable_power))
1003 		return -EINVAL;
1004 
1005 	tz->tzp->sustainable_power = sustainable_power;
1006 
1007 	return count;
1008 }
1009 static DEVICE_ATTR(sustainable_power, S_IWUSR | S_IRUGO, sustainable_power_show,
1010 		sustainable_power_store);
1011 
1012 #define create_s32_tzp_attr(name)					\
1013 	static ssize_t							\
1014 	name##_show(struct device *dev, struct device_attribute *devattr, \
1015 		char *buf)						\
1016 	{								\
1017 	struct thermal_zone_device *tz = to_thermal_zone(dev);		\
1018 									\
1019 	if (tz->tzp)							\
1020 		return sprintf(buf, "%d\n", tz->tzp->name);		\
1021 	else								\
1022 		return -EIO;						\
1023 	}								\
1024 									\
1025 	static ssize_t							\
1026 	name##_store(struct device *dev, struct device_attribute *devattr, \
1027 		const char *buf, size_t count)				\
1028 	{								\
1029 		struct thermal_zone_device *tz = to_thermal_zone(dev);	\
1030 		s32 value;						\
1031 									\
1032 		if (!tz->tzp)						\
1033 			return -EIO;					\
1034 									\
1035 		if (kstrtos32(buf, 10, &value))				\
1036 			return -EINVAL;					\
1037 									\
1038 		tz->tzp->name = value;					\
1039 									\
1040 		return count;						\
1041 	}								\
1042 	static DEVICE_ATTR(name, S_IWUSR | S_IRUGO, name##_show, name##_store)
1043 
1044 create_s32_tzp_attr(k_po);
1045 create_s32_tzp_attr(k_pu);
1046 create_s32_tzp_attr(k_i);
1047 create_s32_tzp_attr(k_d);
1048 create_s32_tzp_attr(integral_cutoff);
1049 create_s32_tzp_attr(slope);
1050 create_s32_tzp_attr(offset);
1051 #undef create_s32_tzp_attr
1052 
1053 static struct device_attribute *dev_tzp_attrs[] = {
1054 	&dev_attr_sustainable_power,
1055 	&dev_attr_k_po,
1056 	&dev_attr_k_pu,
1057 	&dev_attr_k_i,
1058 	&dev_attr_k_d,
1059 	&dev_attr_integral_cutoff,
1060 	&dev_attr_slope,
1061 	&dev_attr_offset,
1062 };
1063 
1064 static int create_tzp_attrs(struct device *dev)
1065 {
1066 	int i;
1067 
1068 	for (i = 0; i < ARRAY_SIZE(dev_tzp_attrs); i++) {
1069 		int ret;
1070 		struct device_attribute *dev_attr = dev_tzp_attrs[i];
1071 
1072 		ret = device_create_file(dev, dev_attr);
1073 		if (ret)
1074 			return ret;
1075 	}
1076 
1077 	return 0;
1078 }
1079 
1080 /**
1081  * power_actor_get_max_power() - get the maximum power that a cdev can consume
1082  * @cdev:	pointer to &thermal_cooling_device
1083  * @tz:		a valid thermal zone device pointer
1084  * @max_power:	pointer in which to store the maximum power
1085  *
1086  * Calculate the maximum power consumption in milliwats that the
1087  * cooling device can currently consume and store it in @max_power.
1088  *
1089  * Return: 0 on success, -EINVAL if @cdev doesn't support the
1090  * power_actor API or -E* on other error.
1091  */
1092 int power_actor_get_max_power(struct thermal_cooling_device *cdev,
1093 			      struct thermal_zone_device *tz, u32 *max_power)
1094 {
1095 	if (!cdev_is_power_actor(cdev))
1096 		return -EINVAL;
1097 
1098 	return cdev->ops->state2power(cdev, tz, 0, max_power);
1099 }
1100 
1101 /**
1102  * power_actor_get_min_power() - get the mainimum power that a cdev can consume
1103  * @cdev:	pointer to &thermal_cooling_device
1104  * @tz:		a valid thermal zone device pointer
1105  * @min_power:	pointer in which to store the minimum power
1106  *
1107  * Calculate the minimum power consumption in milliwatts that the
1108  * cooling device can currently consume and store it in @min_power.
1109  *
1110  * Return: 0 on success, -EINVAL if @cdev doesn't support the
1111  * power_actor API or -E* on other error.
1112  */
1113 int power_actor_get_min_power(struct thermal_cooling_device *cdev,
1114 			      struct thermal_zone_device *tz, u32 *min_power)
1115 {
1116 	unsigned long max_state;
1117 	int ret;
1118 
1119 	if (!cdev_is_power_actor(cdev))
1120 		return -EINVAL;
1121 
1122 	ret = cdev->ops->get_max_state(cdev, &max_state);
1123 	if (ret)
1124 		return ret;
1125 
1126 	return cdev->ops->state2power(cdev, tz, max_state, min_power);
1127 }
1128 
1129 /**
1130  * power_actor_set_power() - limit the maximum power that a cooling device can consume
1131  * @cdev:	pointer to &thermal_cooling_device
1132  * @instance:	thermal instance to update
1133  * @power:	the power in milliwatts
1134  *
1135  * Set the cooling device to consume at most @power milliwatts.
1136  *
1137  * Return: 0 on success, -EINVAL if the cooling device does not
1138  * implement the power actor API or -E* for other failures.
1139  */
1140 int power_actor_set_power(struct thermal_cooling_device *cdev,
1141 			  struct thermal_instance *instance, u32 power)
1142 {
1143 	unsigned long state;
1144 	int ret;
1145 
1146 	if (!cdev_is_power_actor(cdev))
1147 		return -EINVAL;
1148 
1149 	ret = cdev->ops->power2state(cdev, instance->tz, power, &state);
1150 	if (ret)
1151 		return ret;
1152 
1153 	instance->target = state;
1154 	mutex_lock(&cdev->lock);
1155 	cdev->updated = false;
1156 	mutex_unlock(&cdev->lock);
1157 	thermal_cdev_update(cdev);
1158 
1159 	return 0;
1160 }
1161 
1162 static DEVICE_ATTR(type, 0444, type_show, NULL);
1163 static DEVICE_ATTR(temp, 0444, temp_show, NULL);
1164 static DEVICE_ATTR(mode, 0644, mode_show, mode_store);
1165 static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store);
1166 static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store);
1167 static DEVICE_ATTR(available_policies, S_IRUGO, available_policies_show, NULL);
1168 
1169 /* sys I/F for cooling device */
1170 #define to_cooling_device(_dev)	\
1171 	container_of(_dev, struct thermal_cooling_device, device)
1172 
1173 static ssize_t
1174 thermal_cooling_device_type_show(struct device *dev,
1175 				 struct device_attribute *attr, char *buf)
1176 {
1177 	struct thermal_cooling_device *cdev = to_cooling_device(dev);
1178 
1179 	return sprintf(buf, "%s\n", cdev->type);
1180 }
1181 
1182 static ssize_t
1183 thermal_cooling_device_max_state_show(struct device *dev,
1184 				      struct device_attribute *attr, char *buf)
1185 {
1186 	struct thermal_cooling_device *cdev = to_cooling_device(dev);
1187 	unsigned long state;
1188 	int ret;
1189 
1190 	ret = cdev->ops->get_max_state(cdev, &state);
1191 	if (ret)
1192 		return ret;
1193 	return sprintf(buf, "%ld\n", state);
1194 }
1195 
1196 static ssize_t
1197 thermal_cooling_device_cur_state_show(struct device *dev,
1198 				      struct device_attribute *attr, char *buf)
1199 {
1200 	struct thermal_cooling_device *cdev = to_cooling_device(dev);
1201 	unsigned long state;
1202 	int ret;
1203 
1204 	ret = cdev->ops->get_cur_state(cdev, &state);
1205 	if (ret)
1206 		return ret;
1207 	return sprintf(buf, "%ld\n", state);
1208 }
1209 
1210 static ssize_t
1211 thermal_cooling_device_cur_state_store(struct device *dev,
1212 				       struct device_attribute *attr,
1213 				       const char *buf, size_t count)
1214 {
1215 	struct thermal_cooling_device *cdev = to_cooling_device(dev);
1216 	unsigned long state;
1217 	int result;
1218 
1219 	if (!sscanf(buf, "%ld\n", &state))
1220 		return -EINVAL;
1221 
1222 	if ((long)state < 0)
1223 		return -EINVAL;
1224 
1225 	result = cdev->ops->set_cur_state(cdev, state);
1226 	if (result)
1227 		return result;
1228 	return count;
1229 }
1230 
1231 static struct device_attribute dev_attr_cdev_type =
1232 __ATTR(type, 0444, thermal_cooling_device_type_show, NULL);
1233 static DEVICE_ATTR(max_state, 0444,
1234 		   thermal_cooling_device_max_state_show, NULL);
1235 static DEVICE_ATTR(cur_state, 0644,
1236 		   thermal_cooling_device_cur_state_show,
1237 		   thermal_cooling_device_cur_state_store);
1238 
1239 static ssize_t
1240 thermal_cooling_device_trip_point_show(struct device *dev,
1241 				       struct device_attribute *attr, char *buf)
1242 {
1243 	struct thermal_instance *instance;
1244 
1245 	instance =
1246 	    container_of(attr, struct thermal_instance, attr);
1247 
1248 	if (instance->trip == THERMAL_TRIPS_NONE)
1249 		return sprintf(buf, "-1\n");
1250 	else
1251 		return sprintf(buf, "%d\n", instance->trip);
1252 }
1253 
1254 static struct attribute *cooling_device_attrs[] = {
1255 	&dev_attr_cdev_type.attr,
1256 	&dev_attr_max_state.attr,
1257 	&dev_attr_cur_state.attr,
1258 	NULL,
1259 };
1260 
1261 static const struct attribute_group cooling_device_attr_group = {
1262 	.attrs = cooling_device_attrs,
1263 };
1264 
1265 static const struct attribute_group *cooling_device_attr_groups[] = {
1266 	&cooling_device_attr_group,
1267 	NULL,
1268 };
1269 
1270 static ssize_t
1271 thermal_cooling_device_weight_show(struct device *dev,
1272 				   struct device_attribute *attr, char *buf)
1273 {
1274 	struct thermal_instance *instance;
1275 
1276 	instance = container_of(attr, struct thermal_instance, weight_attr);
1277 
1278 	return sprintf(buf, "%d\n", instance->weight);
1279 }
1280 
1281 static ssize_t
1282 thermal_cooling_device_weight_store(struct device *dev,
1283 				    struct device_attribute *attr,
1284 				    const char *buf, size_t count)
1285 {
1286 	struct thermal_instance *instance;
1287 	int ret, weight;
1288 
1289 	ret = kstrtoint(buf, 0, &weight);
1290 	if (ret)
1291 		return ret;
1292 
1293 	instance = container_of(attr, struct thermal_instance, weight_attr);
1294 	instance->weight = weight;
1295 
1296 	return count;
1297 }
1298 /* Device management */
1299 
1300 /**
1301  * thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone
1302  * @tz:		pointer to struct thermal_zone_device
1303  * @trip:	indicates which trip point the cooling devices is
1304  *		associated with in this thermal zone.
1305  * @cdev:	pointer to struct thermal_cooling_device
1306  * @upper:	the Maximum cooling state for this trip point.
1307  *		THERMAL_NO_LIMIT means no upper limit,
1308  *		and the cooling device can be in max_state.
1309  * @lower:	the Minimum cooling state can be used for this trip point.
1310  *		THERMAL_NO_LIMIT means no lower limit,
1311  *		and the cooling device can be in cooling state 0.
1312  * @weight:	The weight of the cooling device to be bound to the
1313  *		thermal zone. Use THERMAL_WEIGHT_DEFAULT for the
1314  *		default value
1315  *
1316  * This interface function bind a thermal cooling device to the certain trip
1317  * point of a thermal zone device.
1318  * This function is usually called in the thermal zone device .bind callback.
1319  *
1320  * Return: 0 on success, the proper error value otherwise.
1321  */
1322 int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
1323 				     int trip,
1324 				     struct thermal_cooling_device *cdev,
1325 				     unsigned long upper, unsigned long lower,
1326 				     unsigned int weight)
1327 {
1328 	struct thermal_instance *dev;
1329 	struct thermal_instance *pos;
1330 	struct thermal_zone_device *pos1;
1331 	struct thermal_cooling_device *pos2;
1332 	unsigned long max_state;
1333 	int result, ret;
1334 
1335 	if (trip >= tz->trips || (trip < 0 && trip != THERMAL_TRIPS_NONE))
1336 		return -EINVAL;
1337 
1338 	list_for_each_entry(pos1, &thermal_tz_list, node) {
1339 		if (pos1 == tz)
1340 			break;
1341 	}
1342 	list_for_each_entry(pos2, &thermal_cdev_list, node) {
1343 		if (pos2 == cdev)
1344 			break;
1345 	}
1346 
1347 	if (tz != pos1 || cdev != pos2)
1348 		return -EINVAL;
1349 
1350 	ret = cdev->ops->get_max_state(cdev, &max_state);
1351 	if (ret)
1352 		return ret;
1353 
1354 	/* lower default 0, upper default max_state */
1355 	lower = lower == THERMAL_NO_LIMIT ? 0 : lower;
1356 	upper = upper == THERMAL_NO_LIMIT ? max_state : upper;
1357 
1358 	if (lower > upper || upper > max_state)
1359 		return -EINVAL;
1360 
1361 	dev =
1362 	    kzalloc(sizeof(struct thermal_instance), GFP_KERNEL);
1363 	if (!dev)
1364 		return -ENOMEM;
1365 	dev->tz = tz;
1366 	dev->cdev = cdev;
1367 	dev->trip = trip;
1368 	dev->upper = upper;
1369 	dev->lower = lower;
1370 	dev->target = THERMAL_NO_TARGET;
1371 	dev->weight = weight;
1372 
1373 	result = get_idr(&tz->idr, &tz->lock, &dev->id);
1374 	if (result)
1375 		goto free_mem;
1376 
1377 	sprintf(dev->name, "cdev%d", dev->id);
1378 	result =
1379 	    sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);
1380 	if (result)
1381 		goto release_idr;
1382 
1383 	sprintf(dev->attr_name, "cdev%d_trip_point", dev->id);
1384 	sysfs_attr_init(&dev->attr.attr);
1385 	dev->attr.attr.name = dev->attr_name;
1386 	dev->attr.attr.mode = 0444;
1387 	dev->attr.show = thermal_cooling_device_trip_point_show;
1388 	result = device_create_file(&tz->device, &dev->attr);
1389 	if (result)
1390 		goto remove_symbol_link;
1391 
1392 	sprintf(dev->weight_attr_name, "cdev%d_weight", dev->id);
1393 	sysfs_attr_init(&dev->weight_attr.attr);
1394 	dev->weight_attr.attr.name = dev->weight_attr_name;
1395 	dev->weight_attr.attr.mode = S_IWUSR | S_IRUGO;
1396 	dev->weight_attr.show = thermal_cooling_device_weight_show;
1397 	dev->weight_attr.store = thermal_cooling_device_weight_store;
1398 	result = device_create_file(&tz->device, &dev->weight_attr);
1399 	if (result)
1400 		goto remove_trip_file;
1401 
1402 	mutex_lock(&tz->lock);
1403 	mutex_lock(&cdev->lock);
1404 	list_for_each_entry(pos, &tz->thermal_instances, tz_node)
1405 	    if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
1406 		result = -EEXIST;
1407 		break;
1408 	}
1409 	if (!result) {
1410 		list_add_tail(&dev->tz_node, &tz->thermal_instances);
1411 		list_add_tail(&dev->cdev_node, &cdev->thermal_instances);
1412 		atomic_set(&tz->need_update, 1);
1413 	}
1414 	mutex_unlock(&cdev->lock);
1415 	mutex_unlock(&tz->lock);
1416 
1417 	if (!result)
1418 		return 0;
1419 
1420 	device_remove_file(&tz->device, &dev->weight_attr);
1421 remove_trip_file:
1422 	device_remove_file(&tz->device, &dev->attr);
1423 remove_symbol_link:
1424 	sysfs_remove_link(&tz->device.kobj, dev->name);
1425 release_idr:
1426 	release_idr(&tz->idr, &tz->lock, dev->id);
1427 free_mem:
1428 	kfree(dev);
1429 	return result;
1430 }
1431 EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device);
1432 
1433 /**
1434  * thermal_zone_unbind_cooling_device() - unbind a cooling device from a
1435  *					  thermal zone.
1436  * @tz:		pointer to a struct thermal_zone_device.
1437  * @trip:	indicates which trip point the cooling devices is
1438  *		associated with in this thermal zone.
1439  * @cdev:	pointer to a struct thermal_cooling_device.
1440  *
1441  * This interface function unbind a thermal cooling device from the certain
1442  * trip point of a thermal zone device.
1443  * This function is usually called in the thermal zone device .unbind callback.
1444  *
1445  * Return: 0 on success, the proper error value otherwise.
1446  */
1447 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
1448 				       int trip,
1449 				       struct thermal_cooling_device *cdev)
1450 {
1451 	struct thermal_instance *pos, *next;
1452 
1453 	mutex_lock(&tz->lock);
1454 	mutex_lock(&cdev->lock);
1455 	list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) {
1456 		if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
1457 			list_del(&pos->tz_node);
1458 			list_del(&pos->cdev_node);
1459 			mutex_unlock(&cdev->lock);
1460 			mutex_unlock(&tz->lock);
1461 			goto unbind;
1462 		}
1463 	}
1464 	mutex_unlock(&cdev->lock);
1465 	mutex_unlock(&tz->lock);
1466 
1467 	return -ENODEV;
1468 
1469 unbind:
1470 	device_remove_file(&tz->device, &pos->weight_attr);
1471 	device_remove_file(&tz->device, &pos->attr);
1472 	sysfs_remove_link(&tz->device.kobj, pos->name);
1473 	release_idr(&tz->idr, &tz->lock, pos->id);
1474 	kfree(pos);
1475 	return 0;
1476 }
1477 EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device);
1478 
1479 static void thermal_release(struct device *dev)
1480 {
1481 	struct thermal_zone_device *tz;
1482 	struct thermal_cooling_device *cdev;
1483 
1484 	if (!strncmp(dev_name(dev), "thermal_zone",
1485 		     sizeof("thermal_zone") - 1)) {
1486 		tz = to_thermal_zone(dev);
1487 		kfree(tz);
1488 	} else if(!strncmp(dev_name(dev), "cooling_device",
1489 			sizeof("cooling_device") - 1)){
1490 		cdev = to_cooling_device(dev);
1491 		kfree(cdev);
1492 	}
1493 }
1494 
1495 static struct class thermal_class = {
1496 	.name = "thermal",
1497 	.dev_release = thermal_release,
1498 };
1499 
1500 /**
1501  * __thermal_cooling_device_register() - register a new thermal cooling device
1502  * @np:		a pointer to a device tree node.
1503  * @type:	the thermal cooling device type.
1504  * @devdata:	device private data.
1505  * @ops:		standard thermal cooling devices callbacks.
1506  *
1507  * This interface function adds a new thermal cooling device (fan/processor/...)
1508  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1509  * to all the thermal zone devices registered at the same time.
1510  * It also gives the opportunity to link the cooling device to a device tree
1511  * node, so that it can be bound to a thermal zone created out of device tree.
1512  *
1513  * Return: a pointer to the created struct thermal_cooling_device or an
1514  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1515  */
1516 static struct thermal_cooling_device *
1517 __thermal_cooling_device_register(struct device_node *np,
1518 				  char *type, void *devdata,
1519 				  const struct thermal_cooling_device_ops *ops)
1520 {
1521 	struct thermal_cooling_device *cdev;
1522 	struct thermal_zone_device *pos = NULL;
1523 	int result;
1524 
1525 	if (type && strlen(type) >= THERMAL_NAME_LENGTH)
1526 		return ERR_PTR(-EINVAL);
1527 
1528 	if (!ops || !ops->get_max_state || !ops->get_cur_state ||
1529 	    !ops->set_cur_state)
1530 		return ERR_PTR(-EINVAL);
1531 
1532 	cdev = kzalloc(sizeof(struct thermal_cooling_device), GFP_KERNEL);
1533 	if (!cdev)
1534 		return ERR_PTR(-ENOMEM);
1535 
1536 	result = get_idr(&thermal_cdev_idr, &thermal_idr_lock, &cdev->id);
1537 	if (result) {
1538 		kfree(cdev);
1539 		return ERR_PTR(result);
1540 	}
1541 
1542 	strlcpy(cdev->type, type ? : "", sizeof(cdev->type));
1543 	mutex_init(&cdev->lock);
1544 	INIT_LIST_HEAD(&cdev->thermal_instances);
1545 	cdev->np = np;
1546 	cdev->ops = ops;
1547 	cdev->updated = false;
1548 	cdev->device.class = &thermal_class;
1549 	cdev->device.groups = cooling_device_attr_groups;
1550 	cdev->devdata = devdata;
1551 	dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
1552 	result = device_register(&cdev->device);
1553 	if (result) {
1554 		release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
1555 		kfree(cdev);
1556 		return ERR_PTR(result);
1557 	}
1558 
1559 	/* Add 'this' new cdev to the global cdev list */
1560 	mutex_lock(&thermal_list_lock);
1561 	list_add(&cdev->node, &thermal_cdev_list);
1562 	mutex_unlock(&thermal_list_lock);
1563 
1564 	/* Update binding information for 'this' new cdev */
1565 	bind_cdev(cdev);
1566 
1567 	mutex_lock(&thermal_list_lock);
1568 	list_for_each_entry(pos, &thermal_tz_list, node)
1569 		if (atomic_cmpxchg(&pos->need_update, 1, 0))
1570 			thermal_zone_device_update(pos,
1571 						   THERMAL_EVENT_UNSPECIFIED);
1572 	mutex_unlock(&thermal_list_lock);
1573 
1574 	return cdev;
1575 }
1576 
1577 /**
1578  * thermal_cooling_device_register() - register a new thermal cooling device
1579  * @type:	the thermal cooling device type.
1580  * @devdata:	device private data.
1581  * @ops:		standard thermal cooling devices callbacks.
1582  *
1583  * This interface function adds a new thermal cooling device (fan/processor/...)
1584  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1585  * to all the thermal zone devices registered at the same time.
1586  *
1587  * Return: a pointer to the created struct thermal_cooling_device or an
1588  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1589  */
1590 struct thermal_cooling_device *
1591 thermal_cooling_device_register(char *type, void *devdata,
1592 				const struct thermal_cooling_device_ops *ops)
1593 {
1594 	return __thermal_cooling_device_register(NULL, type, devdata, ops);
1595 }
1596 EXPORT_SYMBOL_GPL(thermal_cooling_device_register);
1597 
1598 /**
1599  * thermal_of_cooling_device_register() - register an OF thermal cooling device
1600  * @np:		a pointer to a device tree node.
1601  * @type:	the thermal cooling device type.
1602  * @devdata:	device private data.
1603  * @ops:		standard thermal cooling devices callbacks.
1604  *
1605  * This function will register a cooling device with device tree node reference.
1606  * This interface function adds a new thermal cooling device (fan/processor/...)
1607  * to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
1608  * to all the thermal zone devices registered at the same time.
1609  *
1610  * Return: a pointer to the created struct thermal_cooling_device or an
1611  * ERR_PTR. Caller must check return value with IS_ERR*() helpers.
1612  */
1613 struct thermal_cooling_device *
1614 thermal_of_cooling_device_register(struct device_node *np,
1615 				   char *type, void *devdata,
1616 				   const struct thermal_cooling_device_ops *ops)
1617 {
1618 	return __thermal_cooling_device_register(np, type, devdata, ops);
1619 }
1620 EXPORT_SYMBOL_GPL(thermal_of_cooling_device_register);
1621 
1622 /**
1623  * thermal_cooling_device_unregister - removes the registered thermal cooling device
1624  * @cdev:	the thermal cooling device to remove.
1625  *
1626  * thermal_cooling_device_unregister() must be called when the device is no
1627  * longer needed.
1628  */
1629 void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev)
1630 {
1631 	int i;
1632 	const struct thermal_zone_params *tzp;
1633 	struct thermal_zone_device *tz;
1634 	struct thermal_cooling_device *pos = NULL;
1635 
1636 	if (!cdev)
1637 		return;
1638 
1639 	mutex_lock(&thermal_list_lock);
1640 	list_for_each_entry(pos, &thermal_cdev_list, node)
1641 	    if (pos == cdev)
1642 		break;
1643 	if (pos != cdev) {
1644 		/* thermal cooling device not found */
1645 		mutex_unlock(&thermal_list_lock);
1646 		return;
1647 	}
1648 	list_del(&cdev->node);
1649 
1650 	/* Unbind all thermal zones associated with 'this' cdev */
1651 	list_for_each_entry(tz, &thermal_tz_list, node) {
1652 		if (tz->ops->unbind) {
1653 			tz->ops->unbind(tz, cdev);
1654 			continue;
1655 		}
1656 
1657 		if (!tz->tzp || !tz->tzp->tbp)
1658 			continue;
1659 
1660 		tzp = tz->tzp;
1661 		for (i = 0; i < tzp->num_tbps; i++) {
1662 			if (tzp->tbp[i].cdev == cdev) {
1663 				__unbind(tz, tzp->tbp[i].trip_mask, cdev);
1664 				tzp->tbp[i].cdev = NULL;
1665 			}
1666 		}
1667 	}
1668 
1669 	mutex_unlock(&thermal_list_lock);
1670 
1671 	if (cdev->type[0])
1672 		device_remove_file(&cdev->device, &dev_attr_cdev_type);
1673 	device_remove_file(&cdev->device, &dev_attr_max_state);
1674 	device_remove_file(&cdev->device, &dev_attr_cur_state);
1675 
1676 	release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id);
1677 	device_unregister(&cdev->device);
1678 	return;
1679 }
1680 EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister);
1681 
1682 void thermal_cdev_update(struct thermal_cooling_device *cdev)
1683 {
1684 	struct thermal_instance *instance;
1685 	unsigned long target = 0;
1686 
1687 	mutex_lock(&cdev->lock);
1688 	/* cooling device is updated*/
1689 	if (cdev->updated) {
1690 		mutex_unlock(&cdev->lock);
1691 		return;
1692 	}
1693 
1694 	/* Make sure cdev enters the deepest cooling state */
1695 	list_for_each_entry(instance, &cdev->thermal_instances, cdev_node) {
1696 		dev_dbg(&cdev->device, "zone%d->target=%lu\n",
1697 				instance->tz->id, instance->target);
1698 		if (instance->target == THERMAL_NO_TARGET)
1699 			continue;
1700 		if (instance->target > target)
1701 			target = instance->target;
1702 	}
1703 	cdev->ops->set_cur_state(cdev, target);
1704 	cdev->updated = true;
1705 	mutex_unlock(&cdev->lock);
1706 	trace_cdev_update(cdev, target);
1707 	dev_dbg(&cdev->device, "set to state %lu\n", target);
1708 }
1709 EXPORT_SYMBOL(thermal_cdev_update);
1710 
1711 /**
1712  * thermal_notify_framework - Sensor drivers use this API to notify framework
1713  * @tz:		thermal zone device
1714  * @trip:	indicates which trip point has been crossed
1715  *
1716  * This function handles the trip events from sensor drivers. It starts
1717  * throttling the cooling devices according to the policy configured.
1718  * For CRITICAL and HOT trip points, this notifies the respective drivers,
1719  * and does actual throttling for other trip points i.e ACTIVE and PASSIVE.
1720  * The throttling policy is based on the configured platform data; if no
1721  * platform data is provided, this uses the step_wise throttling policy.
1722  */
1723 void thermal_notify_framework(struct thermal_zone_device *tz, int trip)
1724 {
1725 	handle_thermal_trip(tz, trip);
1726 }
1727 EXPORT_SYMBOL_GPL(thermal_notify_framework);
1728 
1729 /**
1730  * create_trip_attrs() - create attributes for trip points
1731  * @tz:		the thermal zone device
1732  * @mask:	Writeable trip point bitmap.
1733  *
1734  * helper function to instantiate sysfs entries for every trip
1735  * point and its properties of a struct thermal_zone_device.
1736  *
1737  * Return: 0 on success, the proper error value otherwise.
1738  */
1739 static int create_trip_attrs(struct thermal_zone_device *tz, int mask)
1740 {
1741 	int indx;
1742 	int size = sizeof(struct thermal_attr) * tz->trips;
1743 
1744 	tz->trip_type_attrs = kzalloc(size, GFP_KERNEL);
1745 	if (!tz->trip_type_attrs)
1746 		return -ENOMEM;
1747 
1748 	tz->trip_temp_attrs = kzalloc(size, GFP_KERNEL);
1749 	if (!tz->trip_temp_attrs) {
1750 		kfree(tz->trip_type_attrs);
1751 		return -ENOMEM;
1752 	}
1753 
1754 	if (tz->ops->get_trip_hyst) {
1755 		tz->trip_hyst_attrs = kzalloc(size, GFP_KERNEL);
1756 		if (!tz->trip_hyst_attrs) {
1757 			kfree(tz->trip_type_attrs);
1758 			kfree(tz->trip_temp_attrs);
1759 			return -ENOMEM;
1760 		}
1761 	}
1762 
1763 
1764 	for (indx = 0; indx < tz->trips; indx++) {
1765 		/* create trip type attribute */
1766 		snprintf(tz->trip_type_attrs[indx].name, THERMAL_NAME_LENGTH,
1767 			 "trip_point_%d_type", indx);
1768 
1769 		sysfs_attr_init(&tz->trip_type_attrs[indx].attr.attr);
1770 		tz->trip_type_attrs[indx].attr.attr.name =
1771 						tz->trip_type_attrs[indx].name;
1772 		tz->trip_type_attrs[indx].attr.attr.mode = S_IRUGO;
1773 		tz->trip_type_attrs[indx].attr.show = trip_point_type_show;
1774 
1775 		device_create_file(&tz->device,
1776 				   &tz->trip_type_attrs[indx].attr);
1777 
1778 		/* create trip temp attribute */
1779 		snprintf(tz->trip_temp_attrs[indx].name, THERMAL_NAME_LENGTH,
1780 			 "trip_point_%d_temp", indx);
1781 
1782 		sysfs_attr_init(&tz->trip_temp_attrs[indx].attr.attr);
1783 		tz->trip_temp_attrs[indx].attr.attr.name =
1784 						tz->trip_temp_attrs[indx].name;
1785 		tz->trip_temp_attrs[indx].attr.attr.mode = S_IRUGO;
1786 		tz->trip_temp_attrs[indx].attr.show = trip_point_temp_show;
1787 		if (IS_ENABLED(CONFIG_THERMAL_WRITABLE_TRIPS) &&
1788 		    mask & (1 << indx)) {
1789 			tz->trip_temp_attrs[indx].attr.attr.mode |= S_IWUSR;
1790 			tz->trip_temp_attrs[indx].attr.store =
1791 							trip_point_temp_store;
1792 		}
1793 
1794 		device_create_file(&tz->device,
1795 				   &tz->trip_temp_attrs[indx].attr);
1796 
1797 		/* create Optional trip hyst attribute */
1798 		if (!tz->ops->get_trip_hyst)
1799 			continue;
1800 		snprintf(tz->trip_hyst_attrs[indx].name, THERMAL_NAME_LENGTH,
1801 			 "trip_point_%d_hyst", indx);
1802 
1803 		sysfs_attr_init(&tz->trip_hyst_attrs[indx].attr.attr);
1804 		tz->trip_hyst_attrs[indx].attr.attr.name =
1805 					tz->trip_hyst_attrs[indx].name;
1806 		tz->trip_hyst_attrs[indx].attr.attr.mode = S_IRUGO;
1807 		tz->trip_hyst_attrs[indx].attr.show = trip_point_hyst_show;
1808 		if (tz->ops->set_trip_hyst) {
1809 			tz->trip_hyst_attrs[indx].attr.attr.mode |= S_IWUSR;
1810 			tz->trip_hyst_attrs[indx].attr.store =
1811 					trip_point_hyst_store;
1812 		}
1813 
1814 		device_create_file(&tz->device,
1815 				   &tz->trip_hyst_attrs[indx].attr);
1816 	}
1817 	return 0;
1818 }
1819 
1820 static void remove_trip_attrs(struct thermal_zone_device *tz)
1821 {
1822 	int indx;
1823 
1824 	for (indx = 0; indx < tz->trips; indx++) {
1825 		device_remove_file(&tz->device,
1826 				   &tz->trip_type_attrs[indx].attr);
1827 		device_remove_file(&tz->device,
1828 				   &tz->trip_temp_attrs[indx].attr);
1829 		if (tz->ops->get_trip_hyst)
1830 			device_remove_file(&tz->device,
1831 				  &tz->trip_hyst_attrs[indx].attr);
1832 	}
1833 	kfree(tz->trip_type_attrs);
1834 	kfree(tz->trip_temp_attrs);
1835 	kfree(tz->trip_hyst_attrs);
1836 }
1837 
1838 /**
1839  * thermal_zone_device_register() - register a new thermal zone device
1840  * @type:	the thermal zone device type
1841  * @trips:	the number of trip points the thermal zone support
1842  * @mask:	a bit string indicating the writeablility of trip points
1843  * @devdata:	private device data
1844  * @ops:	standard thermal zone device callbacks
1845  * @tzp:	thermal zone platform parameters
1846  * @passive_delay: number of milliseconds to wait between polls when
1847  *		   performing passive cooling
1848  * @polling_delay: number of milliseconds to wait between polls when checking
1849  *		   whether trip points have been crossed (0 for interrupt
1850  *		   driven systems)
1851  *
1852  * This interface function adds a new thermal zone device (sensor) to
1853  * /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the
1854  * thermal cooling devices registered at the same time.
1855  * thermal_zone_device_unregister() must be called when the device is no
1856  * longer needed. The passive cooling depends on the .get_trend() return value.
1857  *
1858  * Return: a pointer to the created struct thermal_zone_device or an
1859  * in case of error, an ERR_PTR. Caller must check return value with
1860  * IS_ERR*() helpers.
1861  */
1862 struct thermal_zone_device *thermal_zone_device_register(const char *type,
1863 	int trips, int mask, void *devdata,
1864 	struct thermal_zone_device_ops *ops,
1865 	struct thermal_zone_params *tzp,
1866 	int passive_delay, int polling_delay)
1867 {
1868 	struct thermal_zone_device *tz;
1869 	enum thermal_trip_type trip_type;
1870 	int trip_temp;
1871 	int result;
1872 	int count;
1873 	int passive = 0;
1874 	struct thermal_governor *governor;
1875 
1876 	if (type && strlen(type) >= THERMAL_NAME_LENGTH)
1877 		return ERR_PTR(-EINVAL);
1878 
1879 	if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips)
1880 		return ERR_PTR(-EINVAL);
1881 
1882 	if (!ops)
1883 		return ERR_PTR(-EINVAL);
1884 
1885 	if (trips > 0 && (!ops->get_trip_type || !ops->get_trip_temp))
1886 		return ERR_PTR(-EINVAL);
1887 
1888 	tz = kzalloc(sizeof(struct thermal_zone_device), GFP_KERNEL);
1889 	if (!tz)
1890 		return ERR_PTR(-ENOMEM);
1891 
1892 	INIT_LIST_HEAD(&tz->thermal_instances);
1893 	idr_init(&tz->idr);
1894 	mutex_init(&tz->lock);
1895 	result = get_idr(&thermal_tz_idr, &thermal_idr_lock, &tz->id);
1896 	if (result) {
1897 		kfree(tz);
1898 		return ERR_PTR(result);
1899 	}
1900 
1901 	strlcpy(tz->type, type ? : "", sizeof(tz->type));
1902 	tz->ops = ops;
1903 	tz->tzp = tzp;
1904 	tz->device.class = &thermal_class;
1905 	tz->devdata = devdata;
1906 	tz->trips = trips;
1907 	tz->passive_delay = passive_delay;
1908 	tz->polling_delay = polling_delay;
1909 	/* A new thermal zone needs to be updated anyway. */
1910 	atomic_set(&tz->need_update, 1);
1911 
1912 	dev_set_name(&tz->device, "thermal_zone%d", tz->id);
1913 	result = device_register(&tz->device);
1914 	if (result) {
1915 		release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
1916 		kfree(tz);
1917 		return ERR_PTR(result);
1918 	}
1919 
1920 	/* sys I/F */
1921 	if (type) {
1922 		result = device_create_file(&tz->device, &dev_attr_type);
1923 		if (result)
1924 			goto unregister;
1925 	}
1926 
1927 	result = device_create_file(&tz->device, &dev_attr_temp);
1928 	if (result)
1929 		goto unregister;
1930 
1931 	if (ops->get_mode) {
1932 		result = device_create_file(&tz->device, &dev_attr_mode);
1933 		if (result)
1934 			goto unregister;
1935 	}
1936 
1937 	result = create_trip_attrs(tz, mask);
1938 	if (result)
1939 		goto unregister;
1940 
1941 	for (count = 0; count < trips; count++) {
1942 		if (tz->ops->get_trip_type(tz, count, &trip_type))
1943 			set_bit(count, &tz->trips_disabled);
1944 		if (trip_type == THERMAL_TRIP_PASSIVE)
1945 			passive = 1;
1946 		if (tz->ops->get_trip_temp(tz, count, &trip_temp))
1947 			set_bit(count, &tz->trips_disabled);
1948 		/* Check for bogus trip points */
1949 		if (trip_temp == 0)
1950 			set_bit(count, &tz->trips_disabled);
1951 	}
1952 
1953 	if (!passive) {
1954 		result = device_create_file(&tz->device, &dev_attr_passive);
1955 		if (result)
1956 			goto unregister;
1957 	}
1958 
1959 	if (IS_ENABLED(CONFIG_THERMAL_EMULATION)) {
1960 		result = device_create_file(&tz->device, &dev_attr_emul_temp);
1961 		if (result)
1962 			goto unregister;
1963 	}
1964 
1965 	/* Create policy attribute */
1966 	result = device_create_file(&tz->device, &dev_attr_policy);
1967 	if (result)
1968 		goto unregister;
1969 
1970 	/* Add thermal zone params */
1971 	result = create_tzp_attrs(&tz->device);
1972 	if (result)
1973 		goto unregister;
1974 
1975 	/* Create available_policies attribute */
1976 	result = device_create_file(&tz->device, &dev_attr_available_policies);
1977 	if (result)
1978 		goto unregister;
1979 
1980 	/* Update 'this' zone's governor information */
1981 	mutex_lock(&thermal_governor_lock);
1982 
1983 	if (tz->tzp)
1984 		governor = __find_governor(tz->tzp->governor_name);
1985 	else
1986 		governor = def_governor;
1987 
1988 	result = thermal_set_governor(tz, governor);
1989 	if (result) {
1990 		mutex_unlock(&thermal_governor_lock);
1991 		goto unregister;
1992 	}
1993 
1994 	mutex_unlock(&thermal_governor_lock);
1995 
1996 	if (!tz->tzp || !tz->tzp->no_hwmon) {
1997 		result = thermal_add_hwmon_sysfs(tz);
1998 		if (result)
1999 			goto unregister;
2000 	}
2001 
2002 	mutex_lock(&thermal_list_lock);
2003 	list_add_tail(&tz->node, &thermal_tz_list);
2004 	mutex_unlock(&thermal_list_lock);
2005 
2006 	/* Bind cooling devices for this zone */
2007 	bind_tz(tz);
2008 
2009 	INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check);
2010 
2011 	thermal_zone_device_reset(tz);
2012 	/* Update the new thermal zone and mark it as already updated. */
2013 	if (atomic_cmpxchg(&tz->need_update, 1, 0))
2014 		thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
2015 
2016 	return tz;
2017 
2018 unregister:
2019 	release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
2020 	device_unregister(&tz->device);
2021 	return ERR_PTR(result);
2022 }
2023 EXPORT_SYMBOL_GPL(thermal_zone_device_register);
2024 
2025 /**
2026  * thermal_device_unregister - removes the registered thermal zone device
2027  * @tz: the thermal zone device to remove
2028  */
2029 void thermal_zone_device_unregister(struct thermal_zone_device *tz)
2030 {
2031 	int i;
2032 	const struct thermal_zone_params *tzp;
2033 	struct thermal_cooling_device *cdev;
2034 	struct thermal_zone_device *pos = NULL;
2035 
2036 	if (!tz)
2037 		return;
2038 
2039 	tzp = tz->tzp;
2040 
2041 	mutex_lock(&thermal_list_lock);
2042 	list_for_each_entry(pos, &thermal_tz_list, node)
2043 	    if (pos == tz)
2044 		break;
2045 	if (pos != tz) {
2046 		/* thermal zone device not found */
2047 		mutex_unlock(&thermal_list_lock);
2048 		return;
2049 	}
2050 	list_del(&tz->node);
2051 
2052 	/* Unbind all cdevs associated with 'this' thermal zone */
2053 	list_for_each_entry(cdev, &thermal_cdev_list, node) {
2054 		if (tz->ops->unbind) {
2055 			tz->ops->unbind(tz, cdev);
2056 			continue;
2057 		}
2058 
2059 		if (!tzp || !tzp->tbp)
2060 			break;
2061 
2062 		for (i = 0; i < tzp->num_tbps; i++) {
2063 			if (tzp->tbp[i].cdev == cdev) {
2064 				__unbind(tz, tzp->tbp[i].trip_mask, cdev);
2065 				tzp->tbp[i].cdev = NULL;
2066 			}
2067 		}
2068 	}
2069 
2070 	mutex_unlock(&thermal_list_lock);
2071 
2072 	thermal_zone_device_set_polling(tz, 0);
2073 
2074 	if (tz->type[0])
2075 		device_remove_file(&tz->device, &dev_attr_type);
2076 	device_remove_file(&tz->device, &dev_attr_temp);
2077 	if (tz->ops->get_mode)
2078 		device_remove_file(&tz->device, &dev_attr_mode);
2079 	device_remove_file(&tz->device, &dev_attr_policy);
2080 	device_remove_file(&tz->device, &dev_attr_available_policies);
2081 	remove_trip_attrs(tz);
2082 	thermal_set_governor(tz, NULL);
2083 
2084 	thermal_remove_hwmon_sysfs(tz);
2085 	release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id);
2086 	idr_destroy(&tz->idr);
2087 	mutex_destroy(&tz->lock);
2088 	device_unregister(&tz->device);
2089 	return;
2090 }
2091 EXPORT_SYMBOL_GPL(thermal_zone_device_unregister);
2092 
2093 /**
2094  * thermal_zone_get_zone_by_name() - search for a zone and returns its ref
2095  * @name: thermal zone name to fetch the temperature
2096  *
2097  * When only one zone is found with the passed name, returns a reference to it.
2098  *
2099  * Return: On success returns a reference to an unique thermal zone with
2100  * matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid
2101  * paramenters, -ENODEV for not found and -EEXIST for multiple matches).
2102  */
2103 struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name)
2104 {
2105 	struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL);
2106 	unsigned int found = 0;
2107 
2108 	if (!name)
2109 		goto exit;
2110 
2111 	mutex_lock(&thermal_list_lock);
2112 	list_for_each_entry(pos, &thermal_tz_list, node)
2113 		if (!strncasecmp(name, pos->type, THERMAL_NAME_LENGTH)) {
2114 			found++;
2115 			ref = pos;
2116 		}
2117 	mutex_unlock(&thermal_list_lock);
2118 
2119 	/* nothing has been found, thus an error code for it */
2120 	if (found == 0)
2121 		ref = ERR_PTR(-ENODEV);
2122 	else if (found > 1)
2123 	/* Success only when an unique zone is found */
2124 		ref = ERR_PTR(-EEXIST);
2125 
2126 exit:
2127 	return ref;
2128 }
2129 EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name);
2130 
2131 /**
2132  * thermal_zone_get_slope - return the slope attribute of the thermal zone
2133  * @tz: thermal zone device with the slope attribute
2134  *
2135  * Return: If the thermal zone device has a slope attribute, return it, else
2136  * return 1.
2137  */
2138 int thermal_zone_get_slope(struct thermal_zone_device *tz)
2139 {
2140 	if (tz && tz->tzp)
2141 		return tz->tzp->slope;
2142 	return 1;
2143 }
2144 EXPORT_SYMBOL_GPL(thermal_zone_get_slope);
2145 
2146 /**
2147  * thermal_zone_get_offset - return the offset attribute of the thermal zone
2148  * @tz: thermal zone device with the offset attribute
2149  *
2150  * Return: If the thermal zone device has a offset attribute, return it, else
2151  * return 0.
2152  */
2153 int thermal_zone_get_offset(struct thermal_zone_device *tz)
2154 {
2155 	if (tz && tz->tzp)
2156 		return tz->tzp->offset;
2157 	return 0;
2158 }
2159 EXPORT_SYMBOL_GPL(thermal_zone_get_offset);
2160 
2161 #ifdef CONFIG_NET
2162 static const struct genl_multicast_group thermal_event_mcgrps[] = {
2163 	{ .name = THERMAL_GENL_MCAST_GROUP_NAME, },
2164 };
2165 
2166 static struct genl_family thermal_event_genl_family = {
2167 	.id = GENL_ID_GENERATE,
2168 	.name = THERMAL_GENL_FAMILY_NAME,
2169 	.version = THERMAL_GENL_VERSION,
2170 	.maxattr = THERMAL_GENL_ATTR_MAX,
2171 	.mcgrps = thermal_event_mcgrps,
2172 	.n_mcgrps = ARRAY_SIZE(thermal_event_mcgrps),
2173 };
2174 
2175 int thermal_generate_netlink_event(struct thermal_zone_device *tz,
2176 					enum events event)
2177 {
2178 	struct sk_buff *skb;
2179 	struct nlattr *attr;
2180 	struct thermal_genl_event *thermal_event;
2181 	void *msg_header;
2182 	int size;
2183 	int result;
2184 	static unsigned int thermal_event_seqnum;
2185 
2186 	if (!tz)
2187 		return -EINVAL;
2188 
2189 	/* allocate memory */
2190 	size = nla_total_size(sizeof(struct thermal_genl_event)) +
2191 	       nla_total_size(0);
2192 
2193 	skb = genlmsg_new(size, GFP_ATOMIC);
2194 	if (!skb)
2195 		return -ENOMEM;
2196 
2197 	/* add the genetlink message header */
2198 	msg_header = genlmsg_put(skb, 0, thermal_event_seqnum++,
2199 				 &thermal_event_genl_family, 0,
2200 				 THERMAL_GENL_CMD_EVENT);
2201 	if (!msg_header) {
2202 		nlmsg_free(skb);
2203 		return -ENOMEM;
2204 	}
2205 
2206 	/* fill the data */
2207 	attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT,
2208 			   sizeof(struct thermal_genl_event));
2209 
2210 	if (!attr) {
2211 		nlmsg_free(skb);
2212 		return -EINVAL;
2213 	}
2214 
2215 	thermal_event = nla_data(attr);
2216 	if (!thermal_event) {
2217 		nlmsg_free(skb);
2218 		return -EINVAL;
2219 	}
2220 
2221 	memset(thermal_event, 0, sizeof(struct thermal_genl_event));
2222 
2223 	thermal_event->orig = tz->id;
2224 	thermal_event->event = event;
2225 
2226 	/* send multicast genetlink message */
2227 	genlmsg_end(skb, msg_header);
2228 
2229 	result = genlmsg_multicast(&thermal_event_genl_family, skb, 0,
2230 				   0, GFP_ATOMIC);
2231 	if (result)
2232 		dev_err(&tz->device, "Failed to send netlink event:%d", result);
2233 
2234 	return result;
2235 }
2236 EXPORT_SYMBOL_GPL(thermal_generate_netlink_event);
2237 
2238 static int genetlink_init(void)
2239 {
2240 	return genl_register_family(&thermal_event_genl_family);
2241 }
2242 
2243 static void genetlink_exit(void)
2244 {
2245 	genl_unregister_family(&thermal_event_genl_family);
2246 }
2247 #else /* !CONFIG_NET */
2248 static inline int genetlink_init(void) { return 0; }
2249 static inline void genetlink_exit(void) {}
2250 #endif /* !CONFIG_NET */
2251 
2252 static int __init thermal_register_governors(void)
2253 {
2254 	int result;
2255 
2256 	result = thermal_gov_step_wise_register();
2257 	if (result)
2258 		return result;
2259 
2260 	result = thermal_gov_fair_share_register();
2261 	if (result)
2262 		return result;
2263 
2264 	result = thermal_gov_bang_bang_register();
2265 	if (result)
2266 		return result;
2267 
2268 	result = thermal_gov_user_space_register();
2269 	if (result)
2270 		return result;
2271 
2272 	return thermal_gov_power_allocator_register();
2273 }
2274 
2275 static void thermal_unregister_governors(void)
2276 {
2277 	thermal_gov_step_wise_unregister();
2278 	thermal_gov_fair_share_unregister();
2279 	thermal_gov_bang_bang_unregister();
2280 	thermal_gov_user_space_unregister();
2281 	thermal_gov_power_allocator_unregister();
2282 }
2283 
2284 static int thermal_pm_notify(struct notifier_block *nb,
2285 				unsigned long mode, void *_unused)
2286 {
2287 	struct thermal_zone_device *tz;
2288 
2289 	switch (mode) {
2290 	case PM_HIBERNATION_PREPARE:
2291 	case PM_RESTORE_PREPARE:
2292 	case PM_SUSPEND_PREPARE:
2293 		atomic_set(&in_suspend, 1);
2294 		break;
2295 	case PM_POST_HIBERNATION:
2296 	case PM_POST_RESTORE:
2297 	case PM_POST_SUSPEND:
2298 		atomic_set(&in_suspend, 0);
2299 		list_for_each_entry(tz, &thermal_tz_list, node) {
2300 			thermal_zone_device_reset(tz);
2301 			thermal_zone_device_update(tz,
2302 						   THERMAL_EVENT_UNSPECIFIED);
2303 		}
2304 		break;
2305 	default:
2306 		break;
2307 	}
2308 	return 0;
2309 }
2310 
2311 static struct notifier_block thermal_pm_nb = {
2312 	.notifier_call = thermal_pm_notify,
2313 };
2314 
2315 static int __init thermal_init(void)
2316 {
2317 	int result;
2318 
2319 	result = thermal_register_governors();
2320 	if (result)
2321 		goto error;
2322 
2323 	result = class_register(&thermal_class);
2324 	if (result)
2325 		goto unregister_governors;
2326 
2327 	result = genetlink_init();
2328 	if (result)
2329 		goto unregister_class;
2330 
2331 	result = of_parse_thermal_zones();
2332 	if (result)
2333 		goto exit_netlink;
2334 
2335 	result = register_pm_notifier(&thermal_pm_nb);
2336 	if (result)
2337 		pr_warn("Thermal: Can not register suspend notifier, return %d\n",
2338 			result);
2339 
2340 	return 0;
2341 
2342 exit_netlink:
2343 	genetlink_exit();
2344 unregister_class:
2345 	class_unregister(&thermal_class);
2346 unregister_governors:
2347 	thermal_unregister_governors();
2348 error:
2349 	idr_destroy(&thermal_tz_idr);
2350 	idr_destroy(&thermal_cdev_idr);
2351 	mutex_destroy(&thermal_idr_lock);
2352 	mutex_destroy(&thermal_list_lock);
2353 	mutex_destroy(&thermal_governor_lock);
2354 	return result;
2355 }
2356 
2357 static void __exit thermal_exit(void)
2358 {
2359 	unregister_pm_notifier(&thermal_pm_nb);
2360 	of_thermal_destroy_zones();
2361 	genetlink_exit();
2362 	class_unregister(&thermal_class);
2363 	thermal_unregister_governors();
2364 	idr_destroy(&thermal_tz_idr);
2365 	idr_destroy(&thermal_cdev_idr);
2366 	mutex_destroy(&thermal_idr_lock);
2367 	mutex_destroy(&thermal_list_lock);
2368 	mutex_destroy(&thermal_governor_lock);
2369 }
2370 
2371 fs_initcall(thermal_init);
2372 module_exit(thermal_exit);
2373