2018-05-07 11:52:29 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2008-01-17 00:51:08 -07:00
|
|
|
/*
|
|
|
|
* thermal.c - Generic Thermal Management Sysfs support.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Intel Corp
|
|
|
|
* Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com>
|
|
|
|
* Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com>
|
|
|
|
*/
|
|
|
|
|
2012-03-21 13:55:02 -06:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/err.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2008-01-17 00:51:08 -07:00
|
|
|
#include <linux/kdev_t.h>
|
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/thermal.h>
|
2008-12-03 10:55:32 -07:00
|
|
|
#include <linux/reboot.h>
|
2013-05-17 05:52:02 -06:00
|
|
|
#include <linux/string.h>
|
2013-09-26 13:55:01 -06:00
|
|
|
#include <linux/of.h>
|
2010-10-26 16:03:29 -06:00
|
|
|
#include <net/netlink.h>
|
|
|
|
#include <net/genetlink.h>
|
2015-10-30 02:31:58 -06:00
|
|
|
#include <linux/suspend.h>
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2014-07-29 04:50:48 -06:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/thermal.h>
|
|
|
|
|
2012-09-17 23:34:53 -06:00
|
|
|
#include "thermal_core.h"
|
2013-07-03 13:14:28 -06:00
|
|
|
#include "thermal_hwmon.h"
|
2012-09-17 23:34:53 -06:00
|
|
|
|
2008-04-21 02:07:13 -06:00
|
|
|
MODULE_AUTHOR("Zhang Rui");
|
2008-01-17 00:51:08 -07:00
|
|
|
MODULE_DESCRIPTION("Generic thermal management sysfs support");
|
2013-04-23 15:48:13 -06:00
|
|
|
MODULE_LICENSE("GPL v2");
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
static DEFINE_IDA(thermal_tz_ida);
|
|
|
|
static DEFINE_IDA(thermal_cdev_ida);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
static LIST_HEAD(thermal_tz_list);
|
|
|
|
static LIST_HEAD(thermal_cdev_list);
|
2012-09-17 23:34:57 -06:00
|
|
|
static LIST_HEAD(thermal_governor_list);
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
static DEFINE_MUTEX(thermal_list_lock);
|
2012-09-17 23:34:57 -06:00
|
|
|
static DEFINE_MUTEX(thermal_governor_lock);
|
2017-04-17 22:29:58 -06:00
|
|
|
static DEFINE_MUTEX(poweroff_lock);
|
2012-09-17 23:34:57 -06:00
|
|
|
|
2015-10-30 02:31:58 -06:00
|
|
|
static atomic_t in_suspend;
|
2017-04-17 22:29:58 -06:00
|
|
|
static bool power_off_triggered;
|
2015-10-30 02:31:58 -06:00
|
|
|
|
2014-01-23 19:23:19 -07:00
|
|
|
static struct thermal_governor *def_governor;
|
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
/*
|
|
|
|
* Governor section: set of functions to handle thermal governors
|
|
|
|
*
|
|
|
|
* Functions to help in the life cycle of thermal governors within
|
|
|
|
* the thermal core and by the thermal governor code.
|
|
|
|
*/
|
|
|
|
|
2012-09-17 23:34:57 -06:00
|
|
|
static struct thermal_governor *__find_governor(const char *name)
|
|
|
|
{
|
|
|
|
struct thermal_governor *pos;
|
|
|
|
|
2014-01-23 19:23:19 -07:00
|
|
|
if (!name || !name[0])
|
|
|
|
return def_governor;
|
|
|
|
|
2012-09-17 23:34:57 -06:00
|
|
|
list_for_each_entry(pos, &thermal_governor_list, governor_list)
|
2014-10-13 16:55:01 -06:00
|
|
|
if (!strncasecmp(name, pos->name, THERMAL_NAME_LENGTH))
|
2012-09-17 23:34:57 -06:00
|
|
|
return pos;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-02-26 12:00:27 -07:00
|
|
|
/**
|
|
|
|
* bind_previous_governor() - bind the previous governor of the thermal zone
|
|
|
|
* @tz: a valid pointer to a struct thermal_zone_device
|
|
|
|
* @failed_gov_name: the name of the governor that failed to register
|
|
|
|
*
|
|
|
|
* Register the previous governor of the thermal zone after a new
|
|
|
|
* governor has failed to be bound.
|
|
|
|
*/
|
|
|
|
static void bind_previous_governor(struct thermal_zone_device *tz,
|
|
|
|
const char *failed_gov_name)
|
|
|
|
{
|
|
|
|
if (tz->governor && tz->governor->bind_to_tz) {
|
|
|
|
if (tz->governor->bind_to_tz(tz)) {
|
|
|
|
dev_err(&tz->device,
|
|
|
|
"governor %s failed to bind and the previous one (%s) failed to bind again, thermal zone %s has no governor\n",
|
|
|
|
failed_gov_name, tz->governor->name, tz->type);
|
|
|
|
tz->governor = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* thermal_set_governor() - Switch to another governor
|
|
|
|
* @tz: a valid pointer to a struct thermal_zone_device
|
|
|
|
* @new_gov: pointer to the new governor
|
|
|
|
*
|
|
|
|
* Change the governor of thermal zone @tz.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, an error if the new governor's bind_to_tz() failed.
|
|
|
|
*/
|
|
|
|
static int thermal_set_governor(struct thermal_zone_device *tz,
|
|
|
|
struct thermal_governor *new_gov)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (tz->governor && tz->governor->unbind_from_tz)
|
|
|
|
tz->governor->unbind_from_tz(tz);
|
|
|
|
|
|
|
|
if (new_gov && new_gov->bind_to_tz) {
|
|
|
|
ret = new_gov->bind_to_tz(tz);
|
|
|
|
if (ret) {
|
|
|
|
bind_previous_governor(tz, new_gov->name);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
tz->governor = new_gov;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-09-17 23:34:57 -06:00
|
|
|
int thermal_register_governor(struct thermal_governor *governor)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
const char *name;
|
|
|
|
struct thermal_zone_device *pos;
|
|
|
|
|
|
|
|
if (!governor)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&thermal_governor_lock);
|
|
|
|
|
|
|
|
err = -EBUSY;
|
2016-11-07 22:09:20 -07:00
|
|
|
if (!__find_governor(governor->name)) {
|
2016-11-07 22:09:21 -07:00
|
|
|
bool match_default;
|
|
|
|
|
2012-09-17 23:34:57 -06:00
|
|
|
err = 0;
|
|
|
|
list_add(&governor->governor_list, &thermal_governor_list);
|
2016-11-07 22:09:21 -07:00
|
|
|
match_default = !strncmp(governor->name,
|
|
|
|
DEFAULT_THERMAL_GOVERNOR,
|
|
|
|
THERMAL_NAME_LENGTH);
|
|
|
|
|
|
|
|
if (!def_governor && match_default)
|
2014-01-23 19:23:19 -07:00
|
|
|
def_governor = governor;
|
2012-09-17 23:34:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &thermal_tz_list, node) {
|
2014-01-23 19:23:19 -07:00
|
|
|
/*
|
|
|
|
* only thermal zones with specified tz->tzp->governor_name
|
|
|
|
* may run with tz->govenor unset
|
|
|
|
*/
|
2012-09-17 23:34:57 -06:00
|
|
|
if (pos->governor)
|
|
|
|
continue;
|
2014-01-23 19:23:19 -07:00
|
|
|
|
|
|
|
name = pos->tzp->governor_name;
|
|
|
|
|
2015-02-26 12:00:27 -07:00
|
|
|
if (!strncasecmp(name, governor->name, THERMAL_NAME_LENGTH)) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = thermal_set_governor(pos, governor);
|
|
|
|
if (ret)
|
|
|
|
dev_err(&pos->device,
|
|
|
|
"Failed to set governor %s for thermal zone %s: %d\n",
|
|
|
|
governor->name, pos->type, ret);
|
|
|
|
}
|
2012-09-17 23:34:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
mutex_unlock(&thermal_governor_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
void thermal_unregister_governor(struct thermal_governor *governor)
|
|
|
|
{
|
|
|
|
struct thermal_zone_device *pos;
|
|
|
|
|
|
|
|
if (!governor)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&thermal_governor_lock);
|
|
|
|
|
2016-11-07 22:09:20 -07:00
|
|
|
if (!__find_governor(governor->name))
|
2012-09-17 23:34:57 -06:00
|
|
|
goto exit;
|
|
|
|
|
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &thermal_tz_list, node) {
|
2014-10-13 16:55:01 -06:00
|
|
|
if (!strncasecmp(pos->governor->name, governor->name,
|
2016-11-07 22:09:21 -07:00
|
|
|
THERMAL_NAME_LENGTH))
|
2015-02-26 12:00:27 -07:00
|
|
|
thermal_set_governor(pos, NULL);
|
2012-09-17 23:34:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
list_del(&governor->governor_list);
|
|
|
|
exit:
|
|
|
|
mutex_unlock(&thermal_governor_lock);
|
2012-09-17 23:34:54 -06:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
int thermal_zone_device_set_policy(struct thermal_zone_device *tz,
|
|
|
|
char *policy)
|
2012-09-17 23:34:54 -06:00
|
|
|
{
|
2016-11-07 22:09:05 -07:00
|
|
|
struct thermal_governor *gov;
|
|
|
|
int ret = -EINVAL;
|
2012-09-17 23:34:54 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
mutex_lock(&thermal_governor_lock);
|
2012-09-17 23:34:54 -06:00
|
|
|
mutex_lock(&tz->lock);
|
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
gov = __find_governor(strim(policy));
|
|
|
|
if (!gov)
|
|
|
|
goto exit;
|
2012-09-17 23:34:54 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
ret = thermal_set_governor(tz, gov);
|
2012-09-17 23:34:54 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
exit:
|
|
|
|
mutex_unlock(&tz->lock);
|
|
|
|
mutex_unlock(&thermal_governor_lock);
|
2012-09-17 23:34:54 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
return ret;
|
2012-09-17 23:34:59 -06:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
int thermal_build_list_of_policies(char *buf)
|
2012-09-17 23:34:59 -06:00
|
|
|
{
|
2016-11-07 22:09:05 -07:00
|
|
|
struct thermal_governor *pos;
|
|
|
|
ssize_t count = 0;
|
|
|
|
ssize_t size = PAGE_SIZE;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
mutex_lock(&thermal_governor_lock);
|
2013-07-16 13:26:28 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
list_for_each_entry(pos, &thermal_governor_list, governor_list) {
|
|
|
|
size = PAGE_SIZE - count;
|
|
|
|
count += scnprintf(buf + count, size, "%s ", pos->name);
|
2012-09-17 23:34:59 -06:00
|
|
|
}
|
2016-11-07 22:09:05 -07:00
|
|
|
count += scnprintf(buf + count, size, "\n");
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
mutex_unlock(&thermal_governor_lock);
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
return count;
|
2012-09-17 23:34:59 -06:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
static int __init thermal_register_governors(void)
|
2012-09-17 23:34:59 -06:00
|
|
|
{
|
2016-11-07 22:09:05 -07:00
|
|
|
int result;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
result = thermal_gov_step_wise_register();
|
|
|
|
if (result)
|
|
|
|
return result;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
result = thermal_gov_fair_share_register();
|
|
|
|
if (result)
|
|
|
|
return result;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
result = thermal_gov_bang_bang_register();
|
|
|
|
if (result)
|
|
|
|
return result;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
result = thermal_gov_user_space_register();
|
|
|
|
if (result)
|
|
|
|
return result;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
return thermal_gov_power_allocator_register();
|
2012-09-17 23:34:59 -06:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:05 -07:00
|
|
|
static void thermal_unregister_governors(void)
|
2012-09-17 23:34:59 -06:00
|
|
|
{
|
2016-11-07 22:09:05 -07:00
|
|
|
thermal_gov_step_wise_unregister();
|
|
|
|
thermal_gov_fair_share_unregister();
|
|
|
|
thermal_gov_bang_bang_unregister();
|
|
|
|
thermal_gov_user_space_unregister();
|
|
|
|
thermal_gov_power_allocator_unregister();
|
2012-09-17 23:34:59 -06:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:15 -07:00
|
|
|
/*
|
|
|
|
* Zone update section: main control loop applied to each zone while monitoring
|
|
|
|
*
|
|
|
|
* in polling mode. The monitoring is done using a workqueue.
|
|
|
|
* Same update may be done on a zone by calling thermal_zone_device_update().
|
|
|
|
*
|
|
|
|
* An update means:
|
|
|
|
* - Non-critical trips will invoke the governor responsible for that zone;
|
|
|
|
* - Hot trips will produce a notification to userspace;
|
|
|
|
* - Critical trip point will cause a system shutdown.
|
|
|
|
*/
|
2012-09-17 23:35:04 -06:00
|
|
|
static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
|
|
|
|
int delay)
|
|
|
|
{
|
|
|
|
if (delay > 1000)
|
2018-09-04 01:14:08 -06:00
|
|
|
mod_delayed_work(system_freezable_power_efficient_wq,
|
|
|
|
&tz->poll_queue,
|
2012-09-17 23:35:04 -06:00
|
|
|
round_jiffies(msecs_to_jiffies(delay)));
|
|
|
|
else if (delay)
|
2018-09-04 01:14:08 -06:00
|
|
|
mod_delayed_work(system_freezable_power_efficient_wq,
|
|
|
|
&tz->poll_queue,
|
2012-09-17 23:35:04 -06:00
|
|
|
msecs_to_jiffies(delay));
|
|
|
|
else
|
|
|
|
cancel_delayed_work(&tz->poll_queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void monitor_thermal_zone(struct thermal_zone_device *tz)
|
|
|
|
{
|
|
|
|
mutex_lock(&tz->lock);
|
|
|
|
|
|
|
|
if (tz->passive)
|
|
|
|
thermal_zone_device_set_polling(tz, tz->passive_delay);
|
|
|
|
else if (tz->polling_delay)
|
|
|
|
thermal_zone_device_set_polling(tz, tz->polling_delay);
|
|
|
|
else
|
|
|
|
thermal_zone_device_set_polling(tz, 0);
|
|
|
|
|
|
|
|
mutex_unlock(&tz->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_non_critical_trips(struct thermal_zone_device *tz,
|
2016-11-07 22:09:21 -07:00
|
|
|
int trip,
|
|
|
|
enum thermal_trip_type trip_type)
|
2012-09-17 23:35:04 -06:00
|
|
|
{
|
2014-01-23 19:23:19 -07:00
|
|
|
tz->governor ? tz->governor->throttle(tz, trip) :
|
|
|
|
def_governor->throttle(tz, trip);
|
2012-09-17 23:35:04 -06:00
|
|
|
}
|
|
|
|
|
2017-04-17 22:29:59 -06:00
|
|
|
/**
|
|
|
|
* thermal_emergency_poweroff_func - emergency poweroff work after a known delay
|
|
|
|
* @work: work_struct associated with the emergency poweroff function
|
|
|
|
*
|
|
|
|
* This function is called in very critical situations to force
|
|
|
|
* a kernel poweroff after a configurable timeout value.
|
|
|
|
*/
|
|
|
|
static void thermal_emergency_poweroff_func(struct work_struct *work)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We have reached here after the emergency thermal shutdown
|
|
|
|
* Waiting period has expired. This means orderly_poweroff has
|
|
|
|
* not been able to shut off the system for some reason.
|
|
|
|
* Try to shut down the system immediately using kernel_power_off
|
|
|
|
* if populated
|
|
|
|
*/
|
|
|
|
WARN(1, "Attempting kernel_power_off: Temperature too high\n");
|
|
|
|
kernel_power_off();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Worst of the worst case trigger emergency restart
|
|
|
|
*/
|
|
|
|
WARN(1, "Attempting emergency_restart: Temperature too high\n");
|
|
|
|
emergency_restart();
|
|
|
|
}
|
|
|
|
|
|
|
|
static DECLARE_DELAYED_WORK(thermal_emergency_poweroff_work,
|
|
|
|
thermal_emergency_poweroff_func);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* thermal_emergency_poweroff - Trigger an emergency system poweroff
|
|
|
|
*
|
|
|
|
* This may be called from any critical situation to trigger a system shutdown
|
|
|
|
* after a known period of time. By default this is not scheduled.
|
|
|
|
*/
|
2017-05-08 04:36:43 -06:00
|
|
|
static void thermal_emergency_poweroff(void)
|
2017-04-17 22:29:59 -06:00
|
|
|
{
|
|
|
|
int poweroff_delay_ms = CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS;
|
|
|
|
/*
|
|
|
|
* poweroff_delay_ms must be a carefully profiled positive value.
|
|
|
|
* Its a must for thermal_emergency_poweroff_work to be scheduled
|
|
|
|
*/
|
|
|
|
if (poweroff_delay_ms <= 0)
|
|
|
|
return;
|
|
|
|
schedule_delayed_work(&thermal_emergency_poweroff_work,
|
|
|
|
msecs_to_jiffies(poweroff_delay_ms));
|
|
|
|
}
|
|
|
|
|
2012-09-17 23:35:04 -06:00
|
|
|
static void handle_critical_trips(struct thermal_zone_device *tz,
|
2016-11-07 22:09:21 -07:00
|
|
|
int trip, enum thermal_trip_type trip_type)
|
2012-09-17 23:35:04 -06:00
|
|
|
{
|
2015-07-24 00:12:54 -06:00
|
|
|
int trip_temp;
|
2012-09-17 23:35:04 -06:00
|
|
|
|
|
|
|
tz->ops->get_trip_temp(tz, trip, &trip_temp);
|
|
|
|
|
|
|
|
/* If we have not crossed the trip_temp, we do not care. */
|
2014-11-12 16:43:29 -07:00
|
|
|
if (trip_temp <= 0 || tz->temperature < trip_temp)
|
2012-09-17 23:35:04 -06:00
|
|
|
return;
|
|
|
|
|
2014-07-29 04:50:50 -06:00
|
|
|
trace_thermal_zone_trip(tz, trip, trip_type);
|
|
|
|
|
2012-09-17 23:35:04 -06:00
|
|
|
if (tz->ops->notify)
|
|
|
|
tz->ops->notify(tz, trip, trip_type);
|
|
|
|
|
|
|
|
if (trip_type == THERMAL_TRIP_CRITICAL) {
|
2013-01-02 08:29:41 -07:00
|
|
|
dev_emerg(&tz->device,
|
2017-07-23 08:21:49 -06:00
|
|
|
"critical temperature reached (%d C), shutting down\n",
|
2013-01-02 08:29:41 -07:00
|
|
|
tz->temperature / 1000);
|
2017-04-17 22:29:58 -06:00
|
|
|
mutex_lock(&poweroff_lock);
|
|
|
|
if (!power_off_triggered) {
|
2017-04-17 22:29:59 -06:00
|
|
|
/*
|
|
|
|
* Queue a backup emergency shutdown in the event of
|
|
|
|
* orderly_poweroff failure
|
|
|
|
*/
|
|
|
|
thermal_emergency_poweroff();
|
2017-04-17 22:29:58 -06:00
|
|
|
orderly_poweroff(true);
|
|
|
|
power_off_triggered = true;
|
|
|
|
}
|
|
|
|
mutex_unlock(&poweroff_lock);
|
2012-09-17 23:35:04 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_thermal_trip(struct thermal_zone_device *tz, int trip)
|
|
|
|
{
|
|
|
|
enum thermal_trip_type type;
|
|
|
|
|
2016-03-17 20:03:24 -06:00
|
|
|
/* Ignore disabled trip points */
|
|
|
|
if (test_bit(trip, &tz->trips_disabled))
|
|
|
|
return;
|
|
|
|
|
2012-09-17 23:35:04 -06:00
|
|
|
tz->ops->get_trip_type(tz, trip, &type);
|
|
|
|
|
|
|
|
if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT)
|
|
|
|
handle_critical_trips(tz, trip, type);
|
|
|
|
else
|
|
|
|
handle_non_critical_trips(tz, trip, type);
|
|
|
|
/*
|
|
|
|
* Alright, we handled this trip successfully.
|
|
|
|
* So, start monitoring again.
|
|
|
|
*/
|
|
|
|
monitor_thermal_zone(tz);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void update_temperature(struct thermal_zone_device *tz)
|
|
|
|
{
|
2015-07-24 00:12:54 -06:00
|
|
|
int temp, ret;
|
2012-09-17 23:35:04 -06:00
|
|
|
|
2013-02-03 17:30:15 -07:00
|
|
|
ret = thermal_zone_get_temp(tz, &temp);
|
2012-09-17 23:35:04 -06:00
|
|
|
if (ret) {
|
2015-03-21 08:02:55 -06:00
|
|
|
if (ret != -EAGAIN)
|
|
|
|
dev_warn(&tz->device,
|
|
|
|
"failed to read out thermal zone (%d)\n",
|
|
|
|
ret);
|
2013-02-03 17:30:15 -07:00
|
|
|
return;
|
2012-09-17 23:35:04 -06:00
|
|
|
}
|
|
|
|
|
2013-02-03 17:30:15 -07:00
|
|
|
mutex_lock(&tz->lock);
|
2012-09-17 23:35:04 -06:00
|
|
|
tz->last_temperature = tz->temperature;
|
|
|
|
tz->temperature = temp;
|
|
|
|
mutex_unlock(&tz->lock);
|
thermal: debug: add debug statement for core and step_wise
To ease debugging thermal problem, add these dynamic debug statements
so that user do not need rebuild kernel to see these info.
Based on a patch from Zhang Rui for debugging on bugzilla:
https://bugzilla.kernel.org/attachment.cgi?id=98671
A sample output after we turn on dynamic debug with the following cmd:
# echo 'module thermal_sys +fp' > /sys/kernel/debug/dynamic_debug/control
is like:
[ 355.147627] update_temperature: thermal thermal_zone0: last_temperature=52000, current_temperature=55000
[ 355.147636] thermal_zone_trip_update: thermal thermal_zone0: Trip1[type=1,temp=79000]:trend=2,throttle=0
[ 355.147644] get_target_state: thermal cooling_device8: cur_state=0
[ 355.147647] thermal_zone_trip_update: thermal cooling_device8: old_target=-1, target=-1
[ 355.147652] get_target_state: thermal cooling_device7: cur_state=0
[ 355.147655] thermal_zone_trip_update: thermal cooling_device7: old_target=-1, target=-1
[ 355.147660] get_target_state: thermal cooling_device6: cur_state=0
[ 355.147663] thermal_zone_trip_update: thermal cooling_device6: old_target=-1, target=-1
[ 355.147668] get_target_state: thermal cooling_device5: cur_state=0
[ 355.147671] thermal_zone_trip_update: thermal cooling_device5: old_target=-1, target=-1
[ 355.147678] thermal_zone_trip_update: thermal thermal_zone0: Trip2[type=0,temp=90000]:trend=1,throttle=0
[ 355.147776] get_target_state: thermal cooling_device0: cur_state=0
[ 355.147783] thermal_zone_trip_update: thermal cooling_device0: old_target=-1, target=-1
[ 355.147792] thermal_zone_trip_update: thermal thermal_zone0: Trip3[type=0,temp=80000]:trend=1,throttle=0
[ 355.147845] get_target_state: thermal cooling_device1: cur_state=0
[ 355.147849] thermal_zone_trip_update: thermal cooling_device1: old_target=-1, target=-1
[ 355.147856] thermal_zone_trip_update: thermal thermal_zone0: Trip4[type=0,temp=70000]:trend=1,throttle=0
[ 355.147904] get_target_state: thermal cooling_device2: cur_state=0
[ 355.147908] thermal_zone_trip_update: thermal cooling_device2: old_target=-1, target=-1
[ 355.147915] thermal_zone_trip_update: thermal thermal_zone0: Trip5[type=0,temp=60000]:trend=1,throttle=0
[ 355.147963] get_target_state: thermal cooling_device3: cur_state=0
[ 355.147967] thermal_zone_trip_update: thermal cooling_device3: old_target=-1, target=-1
[ 355.147973] thermal_zone_trip_update: thermal thermal_zone0: Trip6[type=0,temp=55000]:trend=1,throttle=1
[ 355.148022] get_target_state: thermal cooling_device4: cur_state=0
[ 355.148025] thermal_zone_trip_update: thermal cooling_device4: old_target=-1, target=1
[ 355.148036] thermal_cdev_update: thermal cooling_device4: zone0->target=1
[ 355.169279] thermal_cdev_update: thermal cooling_device4: set to state 1
Signed-off-by: Aaron Lu <aaron.lu@intel.com>
Acked-by: Eduardo Valentin <eduardo.valentin@ti.com>
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
2013-12-01 22:54:26 -07:00
|
|
|
|
2014-07-29 04:50:48 -06:00
|
|
|
trace_thermal_temperature(tz);
|
2015-10-30 02:31:47 -06:00
|
|
|
if (tz->last_temperature == THERMAL_TEMP_INVALID)
|
|
|
|
dev_dbg(&tz->device, "last_temperature N/A, current_temperature=%d\n",
|
|
|
|
tz->temperature);
|
|
|
|
else
|
|
|
|
dev_dbg(&tz->device, "last_temperature=%d, current_temperature=%d\n",
|
|
|
|
tz->last_temperature, tz->temperature);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void thermal_zone_device_reset(struct thermal_zone_device *tz)
|
|
|
|
{
|
|
|
|
struct thermal_instance *pos;
|
|
|
|
|
|
|
|
tz->temperature = THERMAL_TEMP_INVALID;
|
|
|
|
tz->passive = 0;
|
|
|
|
list_for_each_entry(pos, &tz->thermal_instances, tz_node)
|
|
|
|
pos->initialized = false;
|
2012-09-17 23:35:04 -06:00
|
|
|
}
|
|
|
|
|
2016-08-26 17:21:16 -06:00
|
|
|
void thermal_zone_device_update(struct thermal_zone_device *tz,
|
|
|
|
enum thermal_notify_event event)
|
2012-09-17 23:35:04 -06:00
|
|
|
{
|
|
|
|
int count;
|
|
|
|
|
2015-10-30 02:31:58 -06:00
|
|
|
if (atomic_read(&in_suspend))
|
|
|
|
return;
|
|
|
|
|
2013-09-12 17:15:44 -06:00
|
|
|
if (!tz->ops->get_temp)
|
|
|
|
return;
|
|
|
|
|
2012-09-17 23:35:04 -06:00
|
|
|
update_temperature(tz);
|
|
|
|
|
2016-06-22 02:42:01 -06:00
|
|
|
thermal_zone_set_trips(tz);
|
|
|
|
|
2016-08-26 17:21:16 -06:00
|
|
|
tz->notify_event = event;
|
|
|
|
|
2012-09-17 23:35:04 -06:00
|
|
|
for (count = 0; count < tz->trips; count++)
|
|
|
|
handle_thermal_trip(tz, count);
|
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_zone_device_update);
|
2012-09-17 23:35:04 -06:00
|
|
|
|
2016-11-07 22:09:14 -07:00
|
|
|
/**
|
|
|
|
* thermal_notify_framework - Sensor drivers use this API to notify framework
|
|
|
|
* @tz: thermal zone device
|
|
|
|
* @trip: indicates which trip point has been crossed
|
|
|
|
*
|
|
|
|
* This function handles the trip events from sensor drivers. It starts
|
|
|
|
* throttling the cooling devices according to the policy configured.
|
|
|
|
* For CRITICAL and HOT trip points, this notifies the respective drivers,
|
|
|
|
* and does actual throttling for other trip points i.e ACTIVE and PASSIVE.
|
|
|
|
* The throttling policy is based on the configured platform data; if no
|
|
|
|
* platform data is provided, this uses the step_wise throttling policy.
|
|
|
|
*/
|
|
|
|
void thermal_notify_framework(struct thermal_zone_device *tz, int trip)
|
|
|
|
{
|
|
|
|
handle_thermal_trip(tz, trip);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(thermal_notify_framework);
|
|
|
|
|
2012-09-17 23:35:04 -06:00
|
|
|
static void thermal_zone_device_check(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct thermal_zone_device *tz = container_of(work, struct
|
|
|
|
thermal_zone_device,
|
|
|
|
poll_queue.work);
|
2016-08-26 17:21:16 -06:00
|
|
|
thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
|
2012-09-17 23:35:04 -06:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:16 -07:00
|
|
|
/*
|
|
|
|
* Power actor section: interface to power actors to estimate power
|
|
|
|
*
|
|
|
|
* Set of functions used to interact to cooling devices that know
|
|
|
|
* how to estimate their devices power consumption.
|
|
|
|
*/
|
2015-03-26 09:53:02 -06:00
|
|
|
|
2015-02-26 12:00:28 -07:00
|
|
|
/**
|
|
|
|
* power_actor_get_max_power() - get the maximum power that a cdev can consume
|
|
|
|
* @cdev: pointer to &thermal_cooling_device
|
|
|
|
* @tz: a valid thermal zone device pointer
|
|
|
|
* @max_power: pointer in which to store the maximum power
|
|
|
|
*
|
|
|
|
* Calculate the maximum power consumption in milliwats that the
|
|
|
|
* cooling device can currently consume and store it in @max_power.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -EINVAL if @cdev doesn't support the
|
|
|
|
* power_actor API or -E* on other error.
|
|
|
|
*/
|
|
|
|
int power_actor_get_max_power(struct thermal_cooling_device *cdev,
|
|
|
|
struct thermal_zone_device *tz, u32 *max_power)
|
|
|
|
{
|
|
|
|
if (!cdev_is_power_actor(cdev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return cdev->ops->state2power(cdev, tz, 0, max_power);
|
|
|
|
}
|
|
|
|
|
2015-09-14 07:23:50 -06:00
|
|
|
/**
|
|
|
|
* power_actor_get_min_power() - get the mainimum power that a cdev can consume
|
|
|
|
* @cdev: pointer to &thermal_cooling_device
|
|
|
|
* @tz: a valid thermal zone device pointer
|
|
|
|
* @min_power: pointer in which to store the minimum power
|
|
|
|
*
|
|
|
|
* Calculate the minimum power consumption in milliwatts that the
|
|
|
|
* cooling device can currently consume and store it in @min_power.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, -EINVAL if @cdev doesn't support the
|
|
|
|
* power_actor API or -E* on other error.
|
|
|
|
*/
|
|
|
|
int power_actor_get_min_power(struct thermal_cooling_device *cdev,
|
|
|
|
struct thermal_zone_device *tz, u32 *min_power)
|
|
|
|
{
|
|
|
|
unsigned long max_state;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!cdev_is_power_actor(cdev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ret = cdev->ops->get_max_state(cdev, &max_state);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return cdev->ops->state2power(cdev, tz, max_state, min_power);
|
|
|
|
}
|
|
|
|
|
2015-02-26 12:00:28 -07:00
|
|
|
/**
|
2016-11-07 22:08:47 -07:00
|
|
|
* power_actor_set_power() - limit the maximum power a cooling device consumes
|
2015-02-26 12:00:28 -07:00
|
|
|
* @cdev: pointer to &thermal_cooling_device
|
|
|
|
* @instance: thermal instance to update
|
|
|
|
* @power: the power in milliwatts
|
|
|
|
*
|
2016-11-07 22:08:47 -07:00
|
|
|
* Set the cooling device to consume at most @power milliwatts. The limit is
|
|
|
|
* expected to be a cap at the maximum power consumption.
|
2015-02-26 12:00:28 -07:00
|
|
|
*
|
|
|
|
* Return: 0 on success, -EINVAL if the cooling device does not
|
|
|
|
* implement the power actor API or -E* for other failures.
|
|
|
|
*/
|
|
|
|
int power_actor_set_power(struct thermal_cooling_device *cdev,
|
|
|
|
struct thermal_instance *instance, u32 power)
|
|
|
|
{
|
|
|
|
unsigned long state;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!cdev_is_power_actor(cdev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ret = cdev->ops->power2state(cdev, instance->tz, power, &state);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
instance->target = state;
|
thermal: fix race condition when updating cooling device
When multiple thermal zones are bound to the same cooling device, multiple
kernel threads may want to update the cooling device state by calling
thermal_cdev_update(). Having cdev not protected by a mutex can lead to a race
condition. Consider the following situation with two kernel threads k1 and k2:
Thread k1 Thread k2
||
|| call thermal_cdev_update()
|| ...
|| set_cur_state(cdev, target);
call power_actor_set_power() ||
... ||
instance->target = state; ||
cdev->updated = false; ||
|| cdev->updated = true;
|| // completes execution
call thermal_cdev_update() ||
// cdev->updated == true ||
return; ||
\/
time
k2 has already looped through the thermal instances looking for the deepest
cooling device state and is preempted right before setting cdev->updated to
true. Now, k1 runs, modifies the thermal instance state and sets cdev->updated
to false. Then, k1 is preempted and k2 continues the execution by setting
cdev->updated to true, therefore preventing k1 from performing the update.
Notice that this is not an issue if k2 looks at the instance->target modified by
k1 "after" it is assigned by k1. In fact, in this case the update will happen
anyway and k1 can safely return immediately from thermal_cdev_update().
This may lead to a situation where a thermal governor never updates the cooling
device. For example, this is the case for the step_wise governor: when calling
the function thermal_zone_trip_update(), the governor may always get a new state
equal to the old one (which, however, wasn't notified to the cooling device) and
will therefore skip the update.
CC: Zhang Rui <rui.zhang@intel.com>
CC: Eduardo Valentin <edubezval@gmail.com>
CC: Peter Feuerer <peter@piie.net>
Reported-by: Toby Huang <toby.huang@arm.com>
Signed-off-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Reviewed-by: Javi Merino <javi.merino@arm.com>
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
2016-06-02 08:25:31 -06:00
|
|
|
mutex_lock(&cdev->lock);
|
2015-02-26 12:00:28 -07:00
|
|
|
cdev->updated = false;
|
thermal: fix race condition when updating cooling device
When multiple thermal zones are bound to the same cooling device, multiple
kernel threads may want to update the cooling device state by calling
thermal_cdev_update(). Having cdev not protected by a mutex can lead to a race
condition. Consider the following situation with two kernel threads k1 and k2:
Thread k1 Thread k2
||
|| call thermal_cdev_update()
|| ...
|| set_cur_state(cdev, target);
call power_actor_set_power() ||
... ||
instance->target = state; ||
cdev->updated = false; ||
|| cdev->updated = true;
|| // completes execution
call thermal_cdev_update() ||
// cdev->updated == true ||
return; ||
\/
time
k2 has already looped through the thermal instances looking for the deepest
cooling device state and is preempted right before setting cdev->updated to
true. Now, k1 runs, modifies the thermal instance state and sets cdev->updated
to false. Then, k1 is preempted and k2 continues the execution by setting
cdev->updated to true, therefore preventing k1 from performing the update.
Notice that this is not an issue if k2 looks at the instance->target modified by
k1 "after" it is assigned by k1. In fact, in this case the update will happen
anyway and k1 can safely return immediately from thermal_cdev_update().
This may lead to a situation where a thermal governor never updates the cooling
device. For example, this is the case for the step_wise governor: when calling
the function thermal_zone_trip_update(), the governor may always get a new state
equal to the old one (which, however, wasn't notified to the cooling device) and
will therefore skip the update.
CC: Zhang Rui <rui.zhang@intel.com>
CC: Eduardo Valentin <edubezval@gmail.com>
CC: Peter Feuerer <peter@piie.net>
Reported-by: Toby Huang <toby.huang@arm.com>
Signed-off-by: Michele Di Giorgio <michele.digiorgio@arm.com>
Reviewed-by: Javi Merino <javi.merino@arm.com>
Signed-off-by: Zhang Rui <rui.zhang@intel.com>
2016-06-02 08:25:31 -06:00
|
|
|
mutex_unlock(&cdev->lock);
|
2015-02-26 12:00:28 -07:00
|
|
|
thermal_cdev_update(cdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-07 22:08:54 -07:00
|
|
|
void thermal_zone_device_rebind_exception(struct thermal_zone_device *tz,
|
|
|
|
const char *cdev_type, size_t size)
|
2008-01-17 00:51:08 -07:00
|
|
|
{
|
2016-11-07 22:08:54 -07:00
|
|
|
struct thermal_cooling_device *cdev = NULL;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-11-07 22:08:54 -07:00
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_for_each_entry(cdev, &thermal_cdev_list, node) {
|
|
|
|
/* skip non matching cdevs */
|
|
|
|
if (strncmp(cdev_type, cdev->type, size))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* re binding the exception matching the type pattern */
|
|
|
|
thermal_zone_bind_cooling_device(tz, THERMAL_TRIPS_NONE, cdev,
|
|
|
|
THERMAL_NO_LIMIT,
|
|
|
|
THERMAL_NO_LIMIT,
|
|
|
|
THERMAL_WEIGHT_DEFAULT);
|
|
|
|
}
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:08:54 -07:00
|
|
|
void thermal_zone_device_unbind_exception(struct thermal_zone_device *tz,
|
|
|
|
const char *cdev_type, size_t size)
|
2008-01-17 00:51:08 -07:00
|
|
|
{
|
2016-11-07 22:08:54 -07:00
|
|
|
struct thermal_cooling_device *cdev = NULL;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-11-07 22:08:54 -07:00
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_for_each_entry(cdev, &thermal_cdev_list, node) {
|
|
|
|
/* skip non matching cdevs */
|
|
|
|
if (strncmp(cdev_type, cdev->type, size))
|
|
|
|
continue;
|
|
|
|
/* unbinding the exception matching the type pattern */
|
|
|
|
thermal_zone_unbind_cooling_device(tz, THERMAL_TRIPS_NONE,
|
|
|
|
cdev);
|
|
|
|
}
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:17 -07:00
|
|
|
/*
|
|
|
|
* Device management section: cooling devices, zones devices, and binding
|
|
|
|
*
|
|
|
|
* Set of functions provided by the thermal core for:
|
|
|
|
* - cooling devices lifecycle: registration, unregistration,
|
|
|
|
* binding, and unbinding.
|
|
|
|
* - thermal zone devices lifecycle: registration, unregistration,
|
|
|
|
* binding, and unbinding.
|
|
|
|
*/
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
/**
|
2013-04-23 15:48:16 -06:00
|
|
|
* thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone
|
|
|
|
* @tz: pointer to struct thermal_zone_device
|
2008-01-17 00:51:08 -07:00
|
|
|
* @trip: indicates which trip point the cooling devices is
|
|
|
|
* associated with in this thermal zone.
|
2013-04-23 15:48:16 -06:00
|
|
|
* @cdev: pointer to struct thermal_cooling_device
|
|
|
|
* @upper: the Maximum cooling state for this trip point.
|
|
|
|
* THERMAL_NO_LIMIT means no upper limit,
|
|
|
|
* and the cooling device can be in max_state.
|
|
|
|
* @lower: the Minimum cooling state can be used for this trip point.
|
|
|
|
* THERMAL_NO_LIMIT means no lower limit,
|
|
|
|
* and the cooling device can be in cooling state 0.
|
2015-02-18 09:04:21 -07:00
|
|
|
* @weight: The weight of the cooling device to be bound to the
|
|
|
|
* thermal zone. Use THERMAL_WEIGHT_DEFAULT for the
|
|
|
|
* default value
|
2008-02-07 14:55:08 -07:00
|
|
|
*
|
2013-04-23 15:48:16 -06:00
|
|
|
* This interface function bind a thermal cooling device to the certain trip
|
|
|
|
* point of a thermal zone device.
|
2008-02-07 14:55:08 -07:00
|
|
|
* This function is usually called in the thermal zone device .bind callback.
|
2013-04-23 15:48:16 -06:00
|
|
|
*
|
|
|
|
* Return: 0 on success, the proper error value otherwise.
|
2008-01-17 00:51:08 -07:00
|
|
|
*/
|
|
|
|
int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
|
|
|
|
int trip,
|
2012-06-26 02:35:57 -06:00
|
|
|
struct thermal_cooling_device *cdev,
|
2015-02-18 09:04:21 -07:00
|
|
|
unsigned long upper, unsigned long lower,
|
|
|
|
unsigned int weight)
|
2008-01-17 00:51:08 -07:00
|
|
|
{
|
2012-06-26 20:08:19 -06:00
|
|
|
struct thermal_instance *dev;
|
|
|
|
struct thermal_instance *pos;
|
2008-02-14 22:58:50 -07:00
|
|
|
struct thermal_zone_device *pos1;
|
|
|
|
struct thermal_cooling_device *pos2;
|
2012-06-26 02:27:22 -06:00
|
|
|
unsigned long max_state;
|
2014-11-18 03:16:30 -07:00
|
|
|
int result, ret;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2008-02-07 14:55:08 -07:00
|
|
|
if (trip >= tz->trips || (trip < 0 && trip != THERMAL_TRIPS_NONE))
|
2008-01-17 00:51:08 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-02-14 22:58:50 -07:00
|
|
|
list_for_each_entry(pos1, &thermal_tz_list, node) {
|
|
|
|
if (pos1 == tz)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
list_for_each_entry(pos2, &thermal_cdev_list, node) {
|
|
|
|
if (pos2 == cdev)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tz != pos1 || cdev != pos2)
|
2008-01-17 00:51:08 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-11-18 03:16:30 -07:00
|
|
|
ret = cdev->ops->get_max_state(cdev, &max_state);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-06-26 02:35:57 -06:00
|
|
|
|
|
|
|
/* lower default 0, upper default max_state */
|
|
|
|
lower = lower == THERMAL_NO_LIMIT ? 0 : lower;
|
|
|
|
upper = upper == THERMAL_NO_LIMIT ? max_state : upper;
|
|
|
|
|
|
|
|
if (lower > upper || upper > max_state)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-11-07 22:09:25 -07:00
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
2008-01-17 00:51:08 -07:00
|
|
|
if (!dev)
|
|
|
|
return -ENOMEM;
|
|
|
|
dev->tz = tz;
|
|
|
|
dev->cdev = cdev;
|
|
|
|
dev->trip = trip;
|
2012-06-26 02:35:57 -06:00
|
|
|
dev->upper = upper;
|
|
|
|
dev->lower = lower;
|
2012-06-27 00:13:04 -06:00
|
|
|
dev->target = THERMAL_NO_TARGET;
|
2015-02-18 09:04:21 -07:00
|
|
|
dev->weight = weight;
|
2012-06-26 02:27:22 -06:00
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
result = ida_simple_get(&tz->ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (result < 0)
|
2008-01-17 00:51:08 -07:00
|
|
|
goto free_mem;
|
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
dev->id = result;
|
2008-01-17 00:51:08 -07:00
|
|
|
sprintf(dev->name, "cdev%d", dev->id);
|
|
|
|
result =
|
|
|
|
sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name);
|
|
|
|
if (result)
|
2016-12-21 10:47:03 -07:00
|
|
|
goto release_ida;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
sprintf(dev->attr_name, "cdev%d_trip_point", dev->id);
|
2010-04-06 15:34:51 -06:00
|
|
|
sysfs_attr_init(&dev->attr.attr);
|
2008-01-17 00:51:08 -07:00
|
|
|
dev->attr.attr.name = dev->attr_name;
|
|
|
|
dev->attr.attr.mode = 0444;
|
2018-04-03 03:49:03 -06:00
|
|
|
dev->attr.show = trip_point_show;
|
2008-01-17 00:51:08 -07:00
|
|
|
result = device_create_file(&tz->device, &dev->attr);
|
|
|
|
if (result)
|
|
|
|
goto remove_symbol_link;
|
|
|
|
|
2015-02-18 09:04:24 -07:00
|
|
|
sprintf(dev->weight_attr_name, "cdev%d_weight", dev->id);
|
|
|
|
sysfs_attr_init(&dev->weight_attr.attr);
|
|
|
|
dev->weight_attr.attr.name = dev->weight_attr_name;
|
|
|
|
dev->weight_attr.attr.mode = S_IWUSR | S_IRUGO;
|
2018-04-03 03:49:03 -06:00
|
|
|
dev->weight_attr.show = weight_show;
|
|
|
|
dev->weight_attr.store = weight_store;
|
2015-02-18 09:04:24 -07:00
|
|
|
result = device_create_file(&tz->device, &dev->weight_attr);
|
|
|
|
if (result)
|
|
|
|
goto remove_trip_file;
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_lock(&tz->lock);
|
2012-07-24 02:56:21 -06:00
|
|
|
mutex_lock(&cdev->lock);
|
2012-06-26 20:09:36 -06:00
|
|
|
list_for_each_entry(pos, &tz->thermal_instances, tz_node)
|
2016-11-07 22:09:23 -07:00
|
|
|
if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
|
|
|
|
result = -EEXIST;
|
|
|
|
break;
|
|
|
|
}
|
2012-06-27 00:11:52 -06:00
|
|
|
if (!result) {
|
2012-06-26 20:09:36 -06:00
|
|
|
list_add_tail(&dev->tz_node, &tz->thermal_instances);
|
2012-06-27 00:11:52 -06:00
|
|
|
list_add_tail(&dev->cdev_node, &cdev->thermal_instances);
|
2015-10-30 02:32:10 -06:00
|
|
|
atomic_set(&tz->need_update, 1);
|
2012-06-27 00:11:52 -06:00
|
|
|
}
|
2012-07-24 02:56:21 -06:00
|
|
|
mutex_unlock(&cdev->lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_unlock(&tz->lock);
|
|
|
|
|
|
|
|
if (!result)
|
|
|
|
return 0;
|
|
|
|
|
2015-02-18 09:04:24 -07:00
|
|
|
device_remove_file(&tz->device, &dev->weight_attr);
|
|
|
|
remove_trip_file:
|
2008-01-17 00:51:08 -07:00
|
|
|
device_remove_file(&tz->device, &dev->attr);
|
2012-03-21 13:55:02 -06:00
|
|
|
remove_symbol_link:
|
2008-01-17 00:51:08 -07:00
|
|
|
sysfs_remove_link(&tz->device.kobj, dev->name);
|
2016-12-21 10:47:03 -07:00
|
|
|
release_ida:
|
|
|
|
ida_simple_remove(&tz->ida, dev->id);
|
2012-03-21 13:55:02 -06:00
|
|
|
free_mem:
|
2008-01-17 00:51:08 -07:00
|
|
|
kfree(dev);
|
|
|
|
return result;
|
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
/**
|
2013-04-23 15:48:17 -06:00
|
|
|
* thermal_zone_unbind_cooling_device() - unbind a cooling device from a
|
|
|
|
* thermal zone.
|
|
|
|
* @tz: pointer to a struct thermal_zone_device.
|
2008-01-17 00:51:08 -07:00
|
|
|
* @trip: indicates which trip point the cooling devices is
|
|
|
|
* associated with in this thermal zone.
|
2013-04-23 15:48:17 -06:00
|
|
|
* @cdev: pointer to a struct thermal_cooling_device.
|
2008-02-07 14:55:08 -07:00
|
|
|
*
|
2013-04-23 15:48:17 -06:00
|
|
|
* This interface function unbind a thermal cooling device from the certain
|
|
|
|
* trip point of a thermal zone device.
|
2008-02-07 14:55:08 -07:00
|
|
|
* This function is usually called in the thermal zone device .unbind callback.
|
2013-04-23 15:48:17 -06:00
|
|
|
*
|
|
|
|
* Return: 0 on success, the proper error value otherwise.
|
2008-01-17 00:51:08 -07:00
|
|
|
*/
|
|
|
|
int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
|
|
|
|
int trip,
|
|
|
|
struct thermal_cooling_device *cdev)
|
|
|
|
{
|
2012-06-26 20:08:19 -06:00
|
|
|
struct thermal_instance *pos, *next;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
mutex_lock(&tz->lock);
|
2012-07-24 02:56:21 -06:00
|
|
|
mutex_lock(&cdev->lock);
|
2012-06-26 20:09:36 -06:00
|
|
|
list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) {
|
2008-02-07 14:55:08 -07:00
|
|
|
if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
|
2012-06-26 20:09:36 -06:00
|
|
|
list_del(&pos->tz_node);
|
2012-06-27 00:11:52 -06:00
|
|
|
list_del(&pos->cdev_node);
|
2012-07-24 02:56:21 -06:00
|
|
|
mutex_unlock(&cdev->lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_unlock(&tz->lock);
|
|
|
|
goto unbind;
|
|
|
|
}
|
|
|
|
}
|
2012-07-24 02:56:21 -06:00
|
|
|
mutex_unlock(&cdev->lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_unlock(&tz->lock);
|
|
|
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
2012-03-21 13:55:02 -06:00
|
|
|
unbind:
|
2015-07-23 03:02:32 -06:00
|
|
|
device_remove_file(&tz->device, &pos->weight_attr);
|
2008-01-17 00:51:08 -07:00
|
|
|
device_remove_file(&tz->device, &pos->attr);
|
|
|
|
sysfs_remove_link(&tz->device.kobj, pos->name);
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_simple_remove(&tz->ida, pos->id);
|
2008-01-17 00:51:08 -07:00
|
|
|
kfree(pos);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
static void thermal_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct thermal_zone_device *tz;
|
|
|
|
struct thermal_cooling_device *cdev;
|
|
|
|
|
2012-03-21 13:55:02 -06:00
|
|
|
if (!strncmp(dev_name(dev), "thermal_zone",
|
|
|
|
sizeof("thermal_zone") - 1)) {
|
2008-01-17 00:51:08 -07:00
|
|
|
tz = to_thermal_zone(dev);
|
2017-08-08 08:39:53 -06:00
|
|
|
thermal_zone_destroy_device_groups(tz);
|
2008-01-17 00:51:08 -07:00
|
|
|
kfree(tz);
|
2016-11-07 22:09:23 -07:00
|
|
|
} else if (!strncmp(dev_name(dev), "cooling_device",
|
|
|
|
sizeof("cooling_device") - 1)) {
|
2008-01-17 00:51:08 -07:00
|
|
|
cdev = to_cooling_device(dev);
|
|
|
|
kfree(cdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct class thermal_class = {
|
|
|
|
.name = "thermal",
|
|
|
|
.dev_release = thermal_release,
|
|
|
|
};
|
|
|
|
|
2016-11-07 22:09:13 -07:00
|
|
|
static inline
|
|
|
|
void print_bind_err_msg(struct thermal_zone_device *tz,
|
|
|
|
struct thermal_cooling_device *cdev, int ret)
|
2016-11-07 22:09:12 -07:00
|
|
|
{
|
|
|
|
dev_err(&tz->device, "binding zone %s with cdev %s failed:%d\n",
|
|
|
|
tz->type, cdev->type, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __bind(struct thermal_zone_device *tz, int mask,
|
|
|
|
struct thermal_cooling_device *cdev,
|
|
|
|
unsigned long *limits,
|
|
|
|
unsigned int weight)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0; i < tz->trips; i++) {
|
|
|
|
if (mask & (1 << i)) {
|
|
|
|
unsigned long upper, lower;
|
|
|
|
|
|
|
|
upper = THERMAL_NO_LIMIT;
|
|
|
|
lower = THERMAL_NO_LIMIT;
|
|
|
|
if (limits) {
|
|
|
|
lower = limits[i * 2];
|
|
|
|
upper = limits[i * 2 + 1];
|
|
|
|
}
|
|
|
|
ret = thermal_zone_bind_cooling_device(tz, i, cdev,
|
|
|
|
upper, lower,
|
|
|
|
weight);
|
|
|
|
if (ret)
|
|
|
|
print_bind_err_msg(tz, cdev, ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-07 22:09:09 -07:00
|
|
|
static void bind_cdev(struct thermal_cooling_device *cdev)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
const struct thermal_zone_params *tzp;
|
|
|
|
struct thermal_zone_device *pos = NULL;
|
|
|
|
|
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &thermal_tz_list, node) {
|
|
|
|
if (!pos->tzp && !pos->ops->bind)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (pos->ops->bind) {
|
|
|
|
ret = pos->ops->bind(pos, cdev);
|
|
|
|
if (ret)
|
|
|
|
print_bind_err_msg(pos, cdev, ret);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
tzp = pos->tzp;
|
|
|
|
if (!tzp || !tzp->tbp)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (i = 0; i < tzp->num_tbps; i++) {
|
|
|
|
if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
|
|
|
|
continue;
|
|
|
|
if (tzp->tbp[i].match(pos, cdev))
|
|
|
|
continue;
|
|
|
|
tzp->tbp[i].cdev = cdev;
|
|
|
|
__bind(pos, tzp->tbp[i].trip_mask, cdev,
|
|
|
|
tzp->tbp[i].binding_limits,
|
|
|
|
tzp->tbp[i].weight);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
/**
|
2013-09-26 13:55:01 -06:00
|
|
|
* __thermal_cooling_device_register() - register a new thermal cooling device
|
|
|
|
* @np: a pointer to a device tree node.
|
2008-01-17 00:51:08 -07:00
|
|
|
* @type: the thermal cooling device type.
|
|
|
|
* @devdata: device private data.
|
|
|
|
* @ops: standard thermal cooling devices callbacks.
|
2013-04-23 15:48:18 -06:00
|
|
|
*
|
|
|
|
* This interface function adds a new thermal cooling device (fan/processor/...)
|
|
|
|
* to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
|
|
|
|
* to all the thermal zone devices registered at the same time.
|
2013-09-26 13:55:01 -06:00
|
|
|
* It also gives the opportunity to link the cooling device to a device tree
|
|
|
|
* node, so that it can be bound to a thermal zone created out of device tree.
|
2013-04-23 15:48:18 -06:00
|
|
|
*
|
|
|
|
* Return: a pointer to the created struct thermal_cooling_device or an
|
|
|
|
* ERR_PTR. Caller must check return value with IS_ERR*() helpers.
|
2008-01-17 00:51:08 -07:00
|
|
|
*/
|
2013-09-26 13:55:01 -06:00
|
|
|
static struct thermal_cooling_device *
|
|
|
|
__thermal_cooling_device_register(struct device_node *np,
|
|
|
|
char *type, void *devdata,
|
|
|
|
const struct thermal_cooling_device_ops *ops)
|
2008-01-17 00:51:08 -07:00
|
|
|
{
|
|
|
|
struct thermal_cooling_device *cdev;
|
2015-10-30 02:32:10 -06:00
|
|
|
struct thermal_zone_device *pos = NULL;
|
2008-01-17 00:51:08 -07:00
|
|
|
int result;
|
|
|
|
|
2012-08-07 23:36:45 -06:00
|
|
|
if (type && strlen(type) >= THERMAL_NAME_LENGTH)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
if (!ops || !ops->get_max_state || !ops->get_cur_state ||
|
2008-02-07 14:55:08 -07:00
|
|
|
!ops->set_cur_state)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-11-07 22:09:25 -07:00
|
|
|
cdev = kzalloc(sizeof(*cdev), GFP_KERNEL);
|
2008-01-17 00:51:08 -07:00
|
|
|
if (!cdev)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
result = ida_simple_get(&thermal_cdev_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (result < 0) {
|
2008-01-17 00:51:08 -07:00
|
|
|
kfree(cdev);
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(result);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
cdev->id = result;
|
2013-04-23 15:48:12 -06:00
|
|
|
strlcpy(cdev->type, type ? : "", sizeof(cdev->type));
|
2012-07-24 02:56:21 -06:00
|
|
|
mutex_init(&cdev->lock);
|
2012-06-27 00:11:52 -06:00
|
|
|
INIT_LIST_HEAD(&cdev->thermal_instances);
|
2013-09-26 13:55:01 -06:00
|
|
|
cdev->np = np;
|
2008-01-17 00:51:08 -07:00
|
|
|
cdev->ops = ops;
|
2014-02-16 20:02:55 -07:00
|
|
|
cdev->updated = false;
|
2008-01-17 00:51:08 -07:00
|
|
|
cdev->device.class = &thermal_class;
|
|
|
|
cdev->devdata = devdata;
|
2018-04-02 04:56:25 -06:00
|
|
|
thermal_cooling_device_setup_sysfs(cdev);
|
2009-01-06 11:44:37 -07:00
|
|
|
dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
|
2008-01-17 00:51:08 -07:00
|
|
|
result = device_register(&cdev->device);
|
|
|
|
if (result) {
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_simple_remove(&thermal_cdev_ida, cdev->id);
|
2008-01-17 00:51:08 -07:00
|
|
|
kfree(cdev);
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(result);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
|
|
|
|
2012-09-17 23:34:59 -06:00
|
|
|
/* Add 'this' new cdev to the global cdev list */
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_add(&cdev->node, &thermal_cdev_list);
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
|
2012-09-17 23:34:59 -06:00
|
|
|
/* Update binding information for 'this' new cdev */
|
|
|
|
bind_cdev(cdev);
|
|
|
|
|
2015-10-30 02:32:10 -06:00
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_for_each_entry(pos, &thermal_tz_list, node)
|
|
|
|
if (atomic_cmpxchg(&pos->need_update, 1, 0))
|
2016-08-26 17:21:16 -06:00
|
|
|
thermal_zone_device_update(pos,
|
|
|
|
THERMAL_EVENT_UNSPECIFIED);
|
2015-10-30 02:32:10 -06:00
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
|
2012-09-17 23:34:59 -06:00
|
|
|
return cdev;
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
2013-09-26 13:55:01 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* thermal_cooling_device_register() - register a new thermal cooling device
|
|
|
|
* @type: the thermal cooling device type.
|
|
|
|
* @devdata: device private data.
|
|
|
|
* @ops: standard thermal cooling devices callbacks.
|
|
|
|
*
|
|
|
|
* This interface function adds a new thermal cooling device (fan/processor/...)
|
|
|
|
* to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
|
|
|
|
* to all the thermal zone devices registered at the same time.
|
|
|
|
*
|
|
|
|
* Return: a pointer to the created struct thermal_cooling_device or an
|
|
|
|
* ERR_PTR. Caller must check return value with IS_ERR*() helpers.
|
|
|
|
*/
|
|
|
|
struct thermal_cooling_device *
|
|
|
|
thermal_cooling_device_register(char *type, void *devdata,
|
|
|
|
const struct thermal_cooling_device_ops *ops)
|
|
|
|
{
|
|
|
|
return __thermal_cooling_device_register(NULL, type, devdata, ops);
|
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_cooling_device_register);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2013-09-26 13:55:01 -06:00
|
|
|
/**
|
|
|
|
* thermal_of_cooling_device_register() - register an OF thermal cooling device
|
|
|
|
* @np: a pointer to a device tree node.
|
|
|
|
* @type: the thermal cooling device type.
|
|
|
|
* @devdata: device private data.
|
|
|
|
* @ops: standard thermal cooling devices callbacks.
|
|
|
|
*
|
|
|
|
* This function will register a cooling device with device tree node reference.
|
|
|
|
* This interface function adds a new thermal cooling device (fan/processor/...)
|
|
|
|
* to /sys/class/thermal/ folder as cooling_device[0-*]. It tries to bind itself
|
|
|
|
* to all the thermal zone devices registered at the same time.
|
|
|
|
*
|
|
|
|
* Return: a pointer to the created struct thermal_cooling_device or an
|
|
|
|
* ERR_PTR. Caller must check return value with IS_ERR*() helpers.
|
|
|
|
*/
|
|
|
|
struct thermal_cooling_device *
|
|
|
|
thermal_of_cooling_device_register(struct device_node *np,
|
|
|
|
char *type, void *devdata,
|
|
|
|
const struct thermal_cooling_device_ops *ops)
|
|
|
|
{
|
|
|
|
return __thermal_cooling_device_register(np, type, devdata, ops);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(thermal_of_cooling_device_register);
|
|
|
|
|
2016-11-07 22:09:08 -07:00
|
|
|
static void __unbind(struct thermal_zone_device *tz, int mask,
|
|
|
|
struct thermal_cooling_device *cdev)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < tz->trips; i++)
|
|
|
|
if (mask & (1 << i))
|
|
|
|
thermal_zone_unbind_cooling_device(tz, i, cdev);
|
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
/**
|
2016-11-07 22:09:24 -07:00
|
|
|
* thermal_cooling_device_unregister - removes a thermal cooling device
|
2008-01-17 00:51:08 -07:00
|
|
|
* @cdev: the thermal cooling device to remove.
|
|
|
|
*
|
2016-11-07 22:09:24 -07:00
|
|
|
* thermal_cooling_device_unregister() must be called when a registered
|
|
|
|
* thermal cooling device is no longer needed.
|
2008-01-17 00:51:08 -07:00
|
|
|
*/
|
2012-09-17 23:34:59 -06:00
|
|
|
void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev)
|
2008-01-17 00:51:08 -07:00
|
|
|
{
|
2012-09-17 23:34:59 -06:00
|
|
|
int i;
|
|
|
|
const struct thermal_zone_params *tzp;
|
2008-01-17 00:51:08 -07:00
|
|
|
struct thermal_zone_device *tz;
|
|
|
|
struct thermal_cooling_device *pos = NULL;
|
|
|
|
|
|
|
|
if (!cdev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_for_each_entry(pos, &thermal_cdev_list, node)
|
2016-11-07 22:09:23 -07:00
|
|
|
if (pos == cdev)
|
|
|
|
break;
|
2008-01-17 00:51:08 -07:00
|
|
|
if (pos != cdev) {
|
|
|
|
/* thermal cooling device not found */
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
list_del(&cdev->node);
|
2012-09-17 23:34:59 -06:00
|
|
|
|
|
|
|
/* Unbind all thermal zones associated with 'this' cdev */
|
2008-01-17 00:51:08 -07:00
|
|
|
list_for_each_entry(tz, &thermal_tz_list, node) {
|
2012-09-17 23:34:59 -06:00
|
|
|
if (tz->ops->unbind) {
|
|
|
|
tz->ops->unbind(tz, cdev);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tz->tzp || !tz->tzp->tbp)
|
2008-01-17 00:51:08 -07:00
|
|
|
continue;
|
2012-09-17 23:34:59 -06:00
|
|
|
|
|
|
|
tzp = tz->tzp;
|
|
|
|
for (i = 0; i < tzp->num_tbps; i++) {
|
|
|
|
if (tzp->tbp[i].cdev == cdev) {
|
|
|
|
__unbind(tz, tzp->tbp[i].trip_mask, cdev);
|
|
|
|
tzp->tbp[i].cdev = NULL;
|
|
|
|
}
|
|
|
|
}
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_unlock(&thermal_list_lock);
|
2012-09-17 23:34:59 -06:00
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_simple_remove(&thermal_cdev_ida, cdev->id);
|
2018-08-13 11:14:00 -06:00
|
|
|
device_del(&cdev->device);
|
2018-04-02 04:56:25 -06:00
|
|
|
thermal_cooling_device_destroy_sysfs(cdev);
|
2018-08-13 11:14:00 -06:00
|
|
|
put_device(&cdev->device);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-11-07 22:09:10 -07:00
|
|
|
static void bind_tz(struct thermal_zone_device *tz)
|
2012-06-27 00:13:04 -06:00
|
|
|
{
|
2016-11-07 22:09:10 -07:00
|
|
|
int i, ret;
|
|
|
|
struct thermal_cooling_device *pos = NULL;
|
|
|
|
const struct thermal_zone_params *tzp = tz->tzp;
|
2012-06-27 00:13:04 -06:00
|
|
|
|
2016-11-07 22:09:10 -07:00
|
|
|
if (!tzp && !tz->ops->bind)
|
2012-06-27 00:13:04 -06:00
|
|
|
return;
|
2012-07-24 20:10:58 -06:00
|
|
|
|
2016-11-07 22:09:10 -07:00
|
|
|
mutex_lock(&thermal_list_lock);
|
2012-07-24 20:10:58 -06:00
|
|
|
|
2016-11-07 22:09:10 -07:00
|
|
|
/* If there is ops->bind, try to use ops->bind */
|
|
|
|
if (tz->ops->bind) {
|
|
|
|
list_for_each_entry(pos, &thermal_cdev_list, node) {
|
|
|
|
ret = tz->ops->bind(tz, pos);
|
|
|
|
if (ret)
|
|
|
|
print_bind_err_msg(tz, pos, ret);
|
2012-07-24 20:10:59 -06:00
|
|
|
}
|
2016-11-07 22:09:10 -07:00
|
|
|
goto exit;
|
2012-07-24 20:10:59 -06:00
|
|
|
}
|
2012-07-24 20:10:58 -06:00
|
|
|
|
2016-11-07 22:09:10 -07:00
|
|
|
if (!tzp || !tzp->tbp)
|
|
|
|
goto exit;
|
2012-07-24 20:10:59 -06:00
|
|
|
|
2016-11-07 22:09:10 -07:00
|
|
|
list_for_each_entry(pos, &thermal_cdev_list, node) {
|
|
|
|
for (i = 0; i < tzp->num_tbps; i++) {
|
|
|
|
if (tzp->tbp[i].cdev || !tzp->tbp[i].match)
|
|
|
|
continue;
|
|
|
|
if (tzp->tbp[i].match(tz, pos))
|
|
|
|
continue;
|
|
|
|
tzp->tbp[i].cdev = pos;
|
|
|
|
__bind(tz, tzp->tbp[i].trip_mask, pos,
|
|
|
|
tzp->tbp[i].binding_limits,
|
|
|
|
tzp->tbp[i].weight);
|
2012-07-24 20:10:59 -06:00
|
|
|
}
|
2012-07-24 20:10:58 -06:00
|
|
|
}
|
2016-11-07 22:09:10 -07:00
|
|
|
exit:
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
2012-07-24 20:10:58 -06:00
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
/**
|
2013-04-23 15:48:20 -06:00
|
|
|
* thermal_zone_device_register() - register a new thermal zone device
|
2008-01-17 00:51:08 -07:00
|
|
|
* @type: the thermal zone device type
|
|
|
|
* @trips: the number of trip points the thermal zone support
|
2012-07-24 20:10:58 -06:00
|
|
|
* @mask: a bit string indicating the writeablility of trip points
|
2008-01-17 00:51:08 -07:00
|
|
|
* @devdata: private device data
|
|
|
|
* @ops: standard thermal zone device callbacks
|
2012-09-17 23:34:56 -06:00
|
|
|
* @tzp: thermal zone platform parameters
|
2008-12-03 10:55:32 -07:00
|
|
|
* @passive_delay: number of milliseconds to wait between polls when
|
|
|
|
* performing passive cooling
|
|
|
|
* @polling_delay: number of milliseconds to wait between polls when checking
|
|
|
|
* whether trip points have been crossed (0 for interrupt
|
|
|
|
* driven systems)
|
2008-01-17 00:51:08 -07:00
|
|
|
*
|
2013-04-23 15:48:20 -06:00
|
|
|
* This interface function adds a new thermal zone device (sensor) to
|
|
|
|
* /sys/class/thermal folder as thermal_zone[0-*]. It tries to bind all the
|
|
|
|
* thermal cooling devices registered at the same time.
|
2008-01-17 00:51:08 -07:00
|
|
|
* thermal_zone_device_unregister() must be called when the device is no
|
2012-06-26 19:51:12 -06:00
|
|
|
* longer needed. The passive cooling depends on the .get_trend() return value.
|
2013-04-23 15:48:20 -06:00
|
|
|
*
|
|
|
|
* Return: a pointer to the created struct thermal_zone_device or an
|
|
|
|
* in case of error, an ERR_PTR. Caller must check return value with
|
|
|
|
* IS_ERR*() helpers.
|
2008-01-17 00:51:08 -07:00
|
|
|
*/
|
2016-11-07 22:09:21 -07:00
|
|
|
struct thermal_zone_device *
|
|
|
|
thermal_zone_device_register(const char *type, int trips, int mask,
|
|
|
|
void *devdata, struct thermal_zone_device_ops *ops,
|
|
|
|
struct thermal_zone_params *tzp, int passive_delay,
|
|
|
|
int polling_delay)
|
2008-01-17 00:51:08 -07:00
|
|
|
{
|
|
|
|
struct thermal_zone_device *tz;
|
2008-12-03 11:00:38 -07:00
|
|
|
enum thermal_trip_type trip_type;
|
2016-03-17 20:03:24 -06:00
|
|
|
int trip_temp;
|
2008-01-17 00:51:08 -07:00
|
|
|
int result;
|
|
|
|
int count;
|
2015-02-26 12:00:27 -07:00
|
|
|
struct thermal_governor *governor;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-11-07 22:08:39 -07:00
|
|
|
if (!type || strlen(type) == 0)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2012-08-07 23:36:45 -06:00
|
|
|
if (type && strlen(type) >= THERMAL_NAME_LENGTH)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2012-07-24 20:10:58 -06:00
|
|
|
if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2013-09-12 17:15:44 -06:00
|
|
|
if (!ops)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2013-05-18 03:50:26 -06:00
|
|
|
if (trips > 0 && (!ops->get_trip_type || !ops->get_trip_temp))
|
2013-01-02 08:29:42 -07:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2016-11-07 22:09:25 -07:00
|
|
|
tz = kzalloc(sizeof(*tz), GFP_KERNEL);
|
2008-01-17 00:51:08 -07:00
|
|
|
if (!tz)
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2012-06-26 20:09:00 -06:00
|
|
|
INIT_LIST_HEAD(&tz->thermal_instances);
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_init(&tz->ida);
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_init(&tz->lock);
|
2016-12-21 10:47:03 -07:00
|
|
|
result = ida_simple_get(&thermal_tz_ida, 0, 0, GFP_KERNEL);
|
2017-08-08 08:39:54 -06:00
|
|
|
if (result < 0)
|
|
|
|
goto free_tz;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2016-12-21 10:47:03 -07:00
|
|
|
tz->id = result;
|
2016-11-07 22:08:39 -07:00
|
|
|
strlcpy(tz->type, type, sizeof(tz->type));
|
2008-01-17 00:51:08 -07:00
|
|
|
tz->ops = ops;
|
2012-09-17 23:34:56 -06:00
|
|
|
tz->tzp = tzp;
|
2008-01-17 00:51:08 -07:00
|
|
|
tz->device.class = &thermal_class;
|
|
|
|
tz->devdata = devdata;
|
|
|
|
tz->trips = trips;
|
2008-12-03 10:55:32 -07:00
|
|
|
tz->passive_delay = passive_delay;
|
|
|
|
tz->polling_delay = polling_delay;
|
2016-11-07 22:08:42 -07:00
|
|
|
|
2016-11-07 22:08:52 -07:00
|
|
|
/* sys I/F */
|
2016-11-07 22:08:42 -07:00
|
|
|
/* Add nodes that are always present via .groups */
|
2016-11-07 22:08:52 -07:00
|
|
|
result = thermal_zone_create_device_groups(tz, mask);
|
|
|
|
if (result)
|
2017-08-08 08:39:54 -06:00
|
|
|
goto remove_id;
|
2016-11-07 22:08:52 -07:00
|
|
|
|
2015-10-30 02:32:10 -06:00
|
|
|
/* A new thermal zone needs to be updated anyway. */
|
|
|
|
atomic_set(&tz->need_update, 1);
|
2008-12-03 10:55:32 -07:00
|
|
|
|
2009-01-06 11:44:37 -07:00
|
|
|
dev_set_name(&tz->device, "thermal_zone%d", tz->id);
|
2008-01-17 00:51:08 -07:00
|
|
|
result = device_register(&tz->device);
|
2017-08-08 08:39:54 -06:00
|
|
|
if (result)
|
|
|
|
goto remove_device_groups;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
for (count = 0; count < trips; count++) {
|
2016-03-17 20:03:24 -06:00
|
|
|
if (tz->ops->get_trip_type(tz, count, &trip_type))
|
|
|
|
set_bit(count, &tz->trips_disabled);
|
|
|
|
if (tz->ops->get_trip_temp(tz, count, &trip_temp))
|
|
|
|
set_bit(count, &tz->trips_disabled);
|
|
|
|
/* Check for bogus trip points */
|
|
|
|
if (trip_temp == 0)
|
|
|
|
set_bit(count, &tz->trips_disabled);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
|
|
|
|
2012-09-17 23:34:57 -06:00
|
|
|
/* Update 'this' zone's governor information */
|
|
|
|
mutex_lock(&thermal_governor_lock);
|
|
|
|
|
|
|
|
if (tz->tzp)
|
2015-02-26 12:00:27 -07:00
|
|
|
governor = __find_governor(tz->tzp->governor_name);
|
2012-09-17 23:34:57 -06:00
|
|
|
else
|
2015-02-26 12:00:27 -07:00
|
|
|
governor = def_governor;
|
|
|
|
|
|
|
|
result = thermal_set_governor(tz, governor);
|
|
|
|
if (result) {
|
|
|
|
mutex_unlock(&thermal_governor_lock);
|
|
|
|
goto unregister;
|
|
|
|
}
|
2012-09-17 23:34:57 -06:00
|
|
|
|
|
|
|
mutex_unlock(&thermal_governor_lock);
|
|
|
|
|
2013-08-15 09:34:17 -06:00
|
|
|
if (!tz->tzp || !tz->tzp->no_hwmon) {
|
|
|
|
result = thermal_add_hwmon_sysfs(tz);
|
|
|
|
if (result)
|
|
|
|
goto unregister;
|
|
|
|
}
|
2008-04-21 02:07:52 -06:00
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_add_tail(&tz->node, &thermal_tz_list);
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
|
2012-09-17 23:34:59 -06:00
|
|
|
/* Bind cooling devices for this zone */
|
|
|
|
bind_tz(tz);
|
|
|
|
|
2016-11-07 22:09:23 -07:00
|
|
|
INIT_DELAYED_WORK(&tz->poll_queue, thermal_zone_device_check);
|
2008-12-03 10:55:32 -07:00
|
|
|
|
2015-10-30 02:31:47 -06:00
|
|
|
thermal_zone_device_reset(tz);
|
2015-10-30 02:32:10 -06:00
|
|
|
/* Update the new thermal zone and mark it as already updated. */
|
|
|
|
if (atomic_cmpxchg(&tz->need_update, 1, 0))
|
2016-08-26 17:21:16 -06:00
|
|
|
thermal_zone_device_update(tz, THERMAL_EVENT_UNSPECIFIED);
|
2008-12-03 10:55:32 -07:00
|
|
|
|
2014-10-28 01:40:25 -06:00
|
|
|
return tz;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2012-03-21 13:55:02 -06:00
|
|
|
unregister:
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_simple_remove(&thermal_tz_ida, tz->id);
|
2008-01-17 00:51:08 -07:00
|
|
|
device_unregister(&tz->device);
|
2008-02-14 22:59:50 -07:00
|
|
|
return ERR_PTR(result);
|
2017-08-08 08:39:54 -06:00
|
|
|
|
|
|
|
remove_device_groups:
|
|
|
|
thermal_zone_destroy_device_groups(tz);
|
|
|
|
remove_id:
|
|
|
|
ida_simple_remove(&thermal_tz_ida, tz->id);
|
|
|
|
free_tz:
|
|
|
|
kfree(tz);
|
|
|
|
return ERR_PTR(result);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_zone_device_register);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* thermal_device_unregister - removes the registered thermal zone device
|
|
|
|
* @tz: the thermal zone device to remove
|
|
|
|
*/
|
|
|
|
void thermal_zone_device_unregister(struct thermal_zone_device *tz)
|
|
|
|
{
|
2012-09-17 23:34:59 -06:00
|
|
|
int i;
|
|
|
|
const struct thermal_zone_params *tzp;
|
2008-01-17 00:51:08 -07:00
|
|
|
struct thermal_cooling_device *cdev;
|
|
|
|
struct thermal_zone_device *pos = NULL;
|
|
|
|
|
|
|
|
if (!tz)
|
|
|
|
return;
|
|
|
|
|
2012-09-17 23:34:59 -06:00
|
|
|
tzp = tz->tzp;
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_for_each_entry(pos, &thermal_tz_list, node)
|
2016-11-07 22:09:23 -07:00
|
|
|
if (pos == tz)
|
|
|
|
break;
|
2008-01-17 00:51:08 -07:00
|
|
|
if (pos != tz) {
|
|
|
|
/* thermal zone device not found */
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
list_del(&tz->node);
|
2012-09-17 23:34:59 -06:00
|
|
|
|
|
|
|
/* Unbind all cdevs associated with 'this' thermal zone */
|
|
|
|
list_for_each_entry(cdev, &thermal_cdev_list, node) {
|
|
|
|
if (tz->ops->unbind) {
|
|
|
|
tz->ops->unbind(tz, cdev);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tzp || !tzp->tbp)
|
|
|
|
break;
|
|
|
|
|
|
|
|
for (i = 0; i < tzp->num_tbps; i++) {
|
|
|
|
if (tzp->tbp[i].cdev == cdev) {
|
|
|
|
__unbind(tz, tzp->tbp[i].trip_mask, cdev);
|
|
|
|
tzp->tbp[i].cdev = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
|
2008-12-03 10:55:32 -07:00
|
|
|
thermal_zone_device_set_polling(tz, 0);
|
|
|
|
|
2015-02-26 12:00:27 -07:00
|
|
|
thermal_set_governor(tz, NULL);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2008-04-21 02:07:52 -06:00
|
|
|
thermal_remove_hwmon_sysfs(tz);
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_simple_remove(&thermal_tz_ida, tz->id);
|
|
|
|
ida_destroy(&tz->ida);
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_destroy(&tz->lock);
|
|
|
|
device_unregister(&tz->device);
|
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_zone_device_unregister);
|
2008-01-17 00:51:08 -07:00
|
|
|
|
2013-04-05 06:32:28 -06:00
|
|
|
/**
|
|
|
|
* thermal_zone_get_zone_by_name() - search for a zone and returns its ref
|
|
|
|
* @name: thermal zone name to fetch the temperature
|
|
|
|
*
|
|
|
|
* When only one zone is found with the passed name, returns a reference to it.
|
|
|
|
*
|
|
|
|
* Return: On success returns a reference to an unique thermal zone with
|
|
|
|
* matching name equals to @name, an ERR_PTR otherwise (-EINVAL for invalid
|
|
|
|
* paramenters, -ENODEV for not found and -EEXIST for multiple matches).
|
|
|
|
*/
|
|
|
|
struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name)
|
|
|
|
{
|
|
|
|
struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL);
|
|
|
|
unsigned int found = 0;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
mutex_lock(&thermal_list_lock);
|
|
|
|
list_for_each_entry(pos, &thermal_tz_list, node)
|
2014-10-13 16:55:01 -06:00
|
|
|
if (!strncasecmp(name, pos->type, THERMAL_NAME_LENGTH)) {
|
2013-04-05 06:32:28 -06:00
|
|
|
found++;
|
|
|
|
ref = pos;
|
|
|
|
}
|
|
|
|
mutex_unlock(&thermal_list_lock);
|
|
|
|
|
|
|
|
/* nothing has been found, thus an error code for it */
|
|
|
|
if (found == 0)
|
|
|
|
ref = ERR_PTR(-ENODEV);
|
|
|
|
else if (found > 1)
|
|
|
|
/* Success only when an unique zone is found */
|
|
|
|
ref = ERR_PTR(-EEXIST);
|
|
|
|
|
|
|
|
exit:
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(thermal_zone_get_zone_by_name);
|
|
|
|
|
2011-02-28 17:12:19 -07:00
|
|
|
#ifdef CONFIG_NET
|
2013-11-19 07:19:39 -07:00
|
|
|
static const struct genl_multicast_group thermal_event_mcgrps[] = {
|
|
|
|
{ .name = THERMAL_GENL_MCAST_GROUP_NAME, },
|
|
|
|
};
|
|
|
|
|
2016-10-24 06:40:05 -06:00
|
|
|
static struct genl_family thermal_event_genl_family __ro_after_init = {
|
2016-10-24 06:40:03 -06:00
|
|
|
.module = THIS_MODULE,
|
2011-02-28 17:12:19 -07:00
|
|
|
.name = THERMAL_GENL_FAMILY_NAME,
|
|
|
|
.version = THERMAL_GENL_VERSION,
|
|
|
|
.maxattr = THERMAL_GENL_ATTR_MAX,
|
2013-11-19 07:19:39 -07:00
|
|
|
.mcgrps = thermal_event_mcgrps,
|
|
|
|
.n_mcgrps = ARRAY_SIZE(thermal_event_mcgrps),
|
2011-02-28 17:12:19 -07:00
|
|
|
};
|
|
|
|
|
2013-01-02 08:29:39 -07:00
|
|
|
int thermal_generate_netlink_event(struct thermal_zone_device *tz,
|
2016-11-07 22:09:21 -07:00
|
|
|
enum events event)
|
2010-10-26 16:03:29 -06:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct nlattr *attr;
|
|
|
|
struct thermal_genl_event *thermal_event;
|
|
|
|
void *msg_header;
|
|
|
|
int size;
|
|
|
|
int result;
|
2012-03-21 13:55:00 -06:00
|
|
|
static unsigned int thermal_event_seqnum;
|
2010-10-26 16:03:29 -06:00
|
|
|
|
2013-01-02 08:29:39 -07:00
|
|
|
if (!tz)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-10-26 16:03:29 -06:00
|
|
|
/* allocate memory */
|
2012-03-21 13:55:01 -06:00
|
|
|
size = nla_total_size(sizeof(struct thermal_genl_event)) +
|
|
|
|
nla_total_size(0);
|
2010-10-26 16:03:29 -06:00
|
|
|
|
|
|
|
skb = genlmsg_new(size, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* add the genetlink message header */
|
|
|
|
msg_header = genlmsg_put(skb, 0, thermal_event_seqnum++,
|
|
|
|
&thermal_event_genl_family, 0,
|
|
|
|
THERMAL_GENL_CMD_EVENT);
|
|
|
|
if (!msg_header) {
|
|
|
|
nlmsg_free(skb);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill the data */
|
2012-03-21 13:55:01 -06:00
|
|
|
attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT,
|
|
|
|
sizeof(struct thermal_genl_event));
|
2010-10-26 16:03:29 -06:00
|
|
|
|
|
|
|
if (!attr) {
|
|
|
|
nlmsg_free(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
thermal_event = nla_data(attr);
|
|
|
|
if (!thermal_event) {
|
|
|
|
nlmsg_free(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(thermal_event, 0, sizeof(struct thermal_genl_event));
|
|
|
|
|
2013-01-02 08:29:39 -07:00
|
|
|
thermal_event->orig = tz->id;
|
2010-10-26 16:03:29 -06:00
|
|
|
thermal_event->event = event;
|
|
|
|
|
|
|
|
/* send multicast genetlink message */
|
2015-01-16 14:09:00 -07:00
|
|
|
genlmsg_end(skb, msg_header);
|
2010-10-26 16:03:29 -06:00
|
|
|
|
2013-11-19 07:19:38 -07:00
|
|
|
result = genlmsg_multicast(&thermal_event_genl_family, skb, 0,
|
2013-11-19 07:19:39 -07:00
|
|
|
0, GFP_ATOMIC);
|
2010-10-26 16:03:29 -06:00
|
|
|
if (result)
|
2013-01-02 08:29:41 -07:00
|
|
|
dev_err(&tz->device, "Failed to send netlink event:%d", result);
|
2010-10-26 16:03:29 -06:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
2013-04-23 15:48:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(thermal_generate_netlink_event);
|
2010-10-26 16:03:29 -06:00
|
|
|
|
2016-10-24 06:40:05 -06:00
|
|
|
static int __init genetlink_init(void)
|
2010-10-26 16:03:29 -06:00
|
|
|
{
|
2013-11-19 07:19:39 -07:00
|
|
|
return genl_register_family(&thermal_event_genl_family);
|
2010-10-26 16:03:29 -06:00
|
|
|
}
|
|
|
|
|
2011-02-28 17:12:19 -07:00
|
|
|
static void genetlink_exit(void)
|
|
|
|
{
|
|
|
|
genl_unregister_family(&thermal_event_genl_family);
|
|
|
|
}
|
|
|
|
#else /* !CONFIG_NET */
|
|
|
|
static inline int genetlink_init(void) { return 0; }
|
|
|
|
static inline void genetlink_exit(void) {}
|
|
|
|
#endif /* !CONFIG_NET */
|
|
|
|
|
2015-10-30 02:31:58 -06:00
|
|
|
static int thermal_pm_notify(struct notifier_block *nb,
|
2016-11-07 22:09:21 -07:00
|
|
|
unsigned long mode, void *_unused)
|
2015-10-30 02:31:58 -06:00
|
|
|
{
|
|
|
|
struct thermal_zone_device *tz;
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case PM_HIBERNATION_PREPARE:
|
|
|
|
case PM_RESTORE_PREPARE:
|
|
|
|
case PM_SUSPEND_PREPARE:
|
|
|
|
atomic_set(&in_suspend, 1);
|
|
|
|
break;
|
|
|
|
case PM_POST_HIBERNATION:
|
|
|
|
case PM_POST_RESTORE:
|
|
|
|
case PM_POST_SUSPEND:
|
|
|
|
atomic_set(&in_suspend, 0);
|
|
|
|
list_for_each_entry(tz, &thermal_tz_list, node) {
|
|
|
|
thermal_zone_device_reset(tz);
|
2016-08-26 17:21:16 -06:00
|
|
|
thermal_zone_device_update(tz,
|
|
|
|
THERMAL_EVENT_UNSPECIFIED);
|
2015-10-30 02:31:58 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block thermal_pm_nb = {
|
|
|
|
.notifier_call = thermal_pm_notify,
|
|
|
|
};
|
|
|
|
|
2008-01-17 00:51:08 -07:00
|
|
|
static int __init thermal_init(void)
|
|
|
|
{
|
2013-03-26 02:38:29 -06:00
|
|
|
int result;
|
|
|
|
|
2017-04-17 22:29:58 -06:00
|
|
|
mutex_init(&poweroff_lock);
|
2013-03-26 02:38:29 -06:00
|
|
|
result = thermal_register_governors();
|
|
|
|
if (result)
|
|
|
|
goto error;
|
2008-01-17 00:51:08 -07:00
|
|
|
|
|
|
|
result = class_register(&thermal_class);
|
2013-03-26 02:38:29 -06:00
|
|
|
if (result)
|
|
|
|
goto unregister_governors;
|
|
|
|
|
2010-10-26 16:03:29 -06:00
|
|
|
result = genetlink_init();
|
2013-03-26 02:38:29 -06:00
|
|
|
if (result)
|
|
|
|
goto unregister_class;
|
|
|
|
|
2013-07-03 13:35:39 -06:00
|
|
|
result = of_parse_thermal_zones();
|
|
|
|
if (result)
|
|
|
|
goto exit_netlink;
|
|
|
|
|
2015-10-30 02:31:58 -06:00
|
|
|
result = register_pm_notifier(&thermal_pm_nb);
|
|
|
|
if (result)
|
|
|
|
pr_warn("Thermal: Can not register suspend notifier, return %d\n",
|
|
|
|
result);
|
|
|
|
|
2013-03-26 02:38:29 -06:00
|
|
|
return 0;
|
|
|
|
|
2013-07-03 13:35:39 -06:00
|
|
|
exit_netlink:
|
|
|
|
genetlink_exit();
|
2013-03-26 02:38:29 -06:00
|
|
|
unregister_class:
|
|
|
|
class_unregister(&thermal_class);
|
2014-12-03 14:20:21 -07:00
|
|
|
unregister_governors:
|
|
|
|
thermal_unregister_governors();
|
2013-03-26 02:38:29 -06:00
|
|
|
error:
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_destroy(&thermal_tz_ida);
|
|
|
|
ida_destroy(&thermal_cdev_ida);
|
2013-03-26 02:38:29 -06:00
|
|
|
mutex_destroy(&thermal_list_lock);
|
|
|
|
mutex_destroy(&thermal_governor_lock);
|
2017-04-17 22:29:58 -06:00
|
|
|
mutex_destroy(&poweroff_lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit thermal_exit(void)
|
|
|
|
{
|
2015-10-30 02:31:58 -06:00
|
|
|
unregister_pm_notifier(&thermal_pm_nb);
|
2013-07-03 13:35:39 -06:00
|
|
|
of_thermal_destroy_zones();
|
2013-03-26 02:38:29 -06:00
|
|
|
genetlink_exit();
|
2008-01-17 00:51:08 -07:00
|
|
|
class_unregister(&thermal_class);
|
2013-03-26 02:38:29 -06:00
|
|
|
thermal_unregister_governors();
|
2016-12-21 10:47:03 -07:00
|
|
|
ida_destroy(&thermal_tz_ida);
|
|
|
|
ida_destroy(&thermal_cdev_ida);
|
2008-01-17 00:51:08 -07:00
|
|
|
mutex_destroy(&thermal_list_lock);
|
2013-03-26 02:38:29 -06:00
|
|
|
mutex_destroy(&thermal_governor_lock);
|
2008-01-17 00:51:08 -07:00
|
|
|
}
|
|
|
|
|
2010-10-26 16:03:29 -06:00
|
|
|
fs_initcall(thermal_init);
|
2008-01-17 00:51:08 -07:00
|
|
|
module_exit(thermal_exit);
|