whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

thermal_core.c (42601B)


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