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