mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 03:27:44 -04:00
Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/rzhang/linux into thermal
Conflicts: drivers/staging/omap-thermal/omap-thermal-common. OMAP supplied dummy TC1 and TC2, at the same time that the thermal tree removed them from thermal_zone_device_register() drivers/thermal/cpu_cooling.c b/drivers/thermal/cpu_cooling.c propogate the upstream MAX_IDR_LEVEL re-name to prevent a build failure Previously-fixed-by: Stephen Rothwell <[email protected]> Signed-off-by: Len Brown <[email protected]>
This commit is contained in:
Len Brown
commit
29b19e2504
21 changed files with 2177 additions and 728 deletions
|
|
@ -19,6 +19,17 @@ config THERMAL_HWMON
|
|||
depends on HWMON=y || HWMON=THERMAL
|
||||
default y
|
||||
|
||||
config CPU_THERMAL
|
||||
bool "generic cpu cooling support"
|
||||
depends on THERMAL && CPU_FREQ
|
||||
help
|
||||
This implements the generic cpu cooling mechanism through frequency
|
||||
reduction, cpu hotplug and any other ways of reducing temperature. An
|
||||
ACPI version of this already exists(drivers/acpi/processor_thermal.c).
|
||||
This will be useful for platforms using the generic thermal interface
|
||||
and not the ACPI interface.
|
||||
If you want this support, you should say Y here.
|
||||
|
||||
config SPEAR_THERMAL
|
||||
bool "SPEAr thermal sensor driver"
|
||||
depends on THERMAL
|
||||
|
|
@ -27,3 +38,18 @@ config SPEAR_THERMAL
|
|||
help
|
||||
Enable this to plug the SPEAr thermal sensor driver into the Linux
|
||||
thermal framework
|
||||
|
||||
config RCAR_THERMAL
|
||||
tristate "Renesas R-Car thermal driver"
|
||||
depends on THERMAL
|
||||
depends on ARCH_SHMOBILE
|
||||
help
|
||||
Enable this to plug the R-Car thermal sensor driver into the Linux
|
||||
thermal framework
|
||||
|
||||
config EXYNOS_THERMAL
|
||||
tristate "Temperature sensor on Samsung EXYNOS"
|
||||
depends on (ARCH_EXYNOS4 || ARCH_EXYNOS5) && THERMAL
|
||||
help
|
||||
If you say yes here you get support for TMU (Thermal Managment
|
||||
Unit) on SAMSUNG EXYNOS series of SoC.
|
||||
|
|
|
|||
|
|
@ -3,4 +3,7 @@
|
|||
#
|
||||
|
||||
obj-$(CONFIG_THERMAL) += thermal_sys.o
|
||||
obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o
|
||||
obj-$(CONFIG_CPU_THERMAL) += cpu_cooling.o
|
||||
obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o
|
||||
obj-$(CONFIG_RCAR_THERMAL) += rcar_thermal.o
|
||||
obj-$(CONFIG_EXYNOS_THERMAL) += exynos_thermal.o
|
||||
|
|
|
|||
449
drivers/thermal/cpu_cooling.c
Normal file
449
drivers/thermal/cpu_cooling.c
Normal file
|
|
@ -0,0 +1,449 @@
|
|||
/*
|
||||
* linux/drivers/thermal/cpu_cooling.c
|
||||
*
|
||||
* Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
|
||||
* Copyright (C) 2012 Amit Daniel <amit.kachhap@linaro.org>
|
||||
*
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; version 2 of the License.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
||||
*
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
*/
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/thermal.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/cpufreq.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/cpu.h>
|
||||
#include <linux/cpu_cooling.h>
|
||||
|
||||
/**
|
||||
* struct cpufreq_cooling_device
|
||||
* @id: unique integer value corresponding to each cpufreq_cooling_device
|
||||
* registered.
|
||||
* @cool_dev: thermal_cooling_device pointer to keep track of the the
|
||||
* egistered cooling device.
|
||||
* @cpufreq_state: integer value representing the current state of cpufreq
|
||||
* cooling devices.
|
||||
* @cpufreq_val: integer value representing the absolute value of the clipped
|
||||
* frequency.
|
||||
* @allowed_cpus: all the cpus involved for this cpufreq_cooling_device.
|
||||
* @node: list_head to link all cpufreq_cooling_device together.
|
||||
*
|
||||
* This structure is required for keeping information of each
|
||||
* cpufreq_cooling_device registered as a list whose head is represented by
|
||||
* cooling_cpufreq_list. In order to prevent corruption of this list a
|
||||
* mutex lock cooling_cpufreq_lock is used.
|
||||
*/
|
||||
struct cpufreq_cooling_device {
|
||||
int id;
|
||||
struct thermal_cooling_device *cool_dev;
|
||||
unsigned int cpufreq_state;
|
||||
unsigned int cpufreq_val;
|
||||
struct cpumask allowed_cpus;
|
||||
struct list_head node;
|
||||
};
|
||||
static LIST_HEAD(cooling_cpufreq_list);
|
||||
static DEFINE_IDR(cpufreq_idr);
|
||||
|
||||
static struct mutex cooling_cpufreq_lock;
|
||||
|
||||
/* notify_table passes value to the CPUFREQ_ADJUST callback function. */
|
||||
#define NOTIFY_INVALID NULL
|
||||
struct cpufreq_cooling_device *notify_device;
|
||||
|
||||
/**
|
||||
* get_idr - function to get a unique id.
|
||||
* @idr: struct idr * handle used to create a id.
|
||||
* @id: int * value generated by this function.
|
||||
*/
|
||||
static int get_idr(struct idr *idr, int *id)
|
||||
{
|
||||
int err;
|
||||
again:
|
||||
if (unlikely(idr_pre_get(idr, GFP_KERNEL) == 0))
|
||||
return -ENOMEM;
|
||||
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
err = idr_get_new(idr, NULL, id);
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
|
||||
if (unlikely(err == -EAGAIN))
|
||||
goto again;
|
||||
else if (unlikely(err))
|
||||
return err;
|
||||
|
||||
*id = *id & MAX_IDR_MASK;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* release_idr - function to free the unique id.
|
||||
* @idr: struct idr * handle used for creating the id.
|
||||
* @id: int value representing the unique id.
|
||||
*/
|
||||
static void release_idr(struct idr *idr, int id)
|
||||
{
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
idr_remove(idr, id);
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
}
|
||||
|
||||
/* Below code defines functions to be used for cpufreq as cooling device */
|
||||
|
||||
/**
|
||||
* is_cpufreq_valid - function to check if a cpu has frequency transition policy.
|
||||
* @cpu: cpu for which check is needed.
|
||||
*/
|
||||
static int is_cpufreq_valid(int cpu)
|
||||
{
|
||||
struct cpufreq_policy policy;
|
||||
return !cpufreq_get_policy(&policy, cpu);
|
||||
}
|
||||
|
||||
/**
|
||||
* get_cpu_frequency - get the absolute value of frequency from level.
|
||||
* @cpu: cpu for which frequency is fetched.
|
||||
* @level: level of frequency of the CPU
|
||||
* e.g level=1 --> 1st MAX FREQ, LEVEL=2 ---> 2nd MAX FREQ, .... etc
|
||||
*/
|
||||
static unsigned int get_cpu_frequency(unsigned int cpu, unsigned long level)
|
||||
{
|
||||
int ret = 0, i = 0;
|
||||
unsigned long level_index;
|
||||
bool descend = false;
|
||||
struct cpufreq_frequency_table *table =
|
||||
cpufreq_frequency_get_table(cpu);
|
||||
if (!table)
|
||||
return ret;
|
||||
|
||||
while (table[i].frequency != CPUFREQ_TABLE_END) {
|
||||
if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
|
||||
continue;
|
||||
|
||||
/*check if table in ascending or descending order*/
|
||||
if ((table[i + 1].frequency != CPUFREQ_TABLE_END) &&
|
||||
(table[i + 1].frequency < table[i].frequency)
|
||||
&& !descend) {
|
||||
descend = true;
|
||||
}
|
||||
|
||||
/*return if level matched and table in descending order*/
|
||||
if (descend && i == level)
|
||||
return table[i].frequency;
|
||||
i++;
|
||||
}
|
||||
i--;
|
||||
|
||||
if (level > i || descend)
|
||||
return ret;
|
||||
level_index = i - level;
|
||||
|
||||
/*Scan the table in reverse order and match the level*/
|
||||
while (i >= 0) {
|
||||
if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
|
||||
continue;
|
||||
/*return if level matched*/
|
||||
if (i == level_index)
|
||||
return table[i].frequency;
|
||||
i--;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* cpufreq_apply_cooling - function to apply frequency clipping.
|
||||
* @cpufreq_device: cpufreq_cooling_device pointer containing frequency
|
||||
* clipping data.
|
||||
* @cooling_state: value of the cooling state.
|
||||
*/
|
||||
static int cpufreq_apply_cooling(struct cpufreq_cooling_device *cpufreq_device,
|
||||
unsigned long cooling_state)
|
||||
{
|
||||
unsigned int cpuid, clip_freq;
|
||||
struct cpumask *maskPtr = &cpufreq_device->allowed_cpus;
|
||||
unsigned int cpu = cpumask_any(maskPtr);
|
||||
|
||||
|
||||
/* Check if the old cooling action is same as new cooling action */
|
||||
if (cpufreq_device->cpufreq_state == cooling_state)
|
||||
return 0;
|
||||
|
||||
clip_freq = get_cpu_frequency(cpu, cooling_state);
|
||||
if (!clip_freq)
|
||||
return -EINVAL;
|
||||
|
||||
cpufreq_device->cpufreq_state = cooling_state;
|
||||
cpufreq_device->cpufreq_val = clip_freq;
|
||||
notify_device = cpufreq_device;
|
||||
|
||||
for_each_cpu(cpuid, maskPtr) {
|
||||
if (is_cpufreq_valid(cpuid))
|
||||
cpufreq_update_policy(cpuid);
|
||||
}
|
||||
|
||||
notify_device = NOTIFY_INVALID;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* cpufreq_thermal_notifier - notifier callback for cpufreq policy change.
|
||||
* @nb: struct notifier_block * with callback info.
|
||||
* @event: value showing cpufreq event for which this function invoked.
|
||||
* @data: callback-specific data
|
||||
*/
|
||||
static int cpufreq_thermal_notifier(struct notifier_block *nb,
|
||||
unsigned long event, void *data)
|
||||
{
|
||||
struct cpufreq_policy *policy = data;
|
||||
unsigned long max_freq = 0;
|
||||
|
||||
if (event != CPUFREQ_ADJUST || notify_device == NOTIFY_INVALID)
|
||||
return 0;
|
||||
|
||||
if (cpumask_test_cpu(policy->cpu, ¬ify_device->allowed_cpus))
|
||||
max_freq = notify_device->cpufreq_val;
|
||||
|
||||
/* Never exceed user_policy.max*/
|
||||
if (max_freq > policy->user_policy.max)
|
||||
max_freq = policy->user_policy.max;
|
||||
|
||||
if (policy->max != max_freq)
|
||||
cpufreq_verify_within_limits(policy, 0, max_freq);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* cpufreq cooling device callback functions are defined below
|
||||
*/
|
||||
|
||||
/**
|
||||
* cpufreq_get_max_state - callback function to get the max cooling state.
|
||||
* @cdev: thermal cooling device pointer.
|
||||
* @state: fill this variable with the max cooling state.
|
||||
*/
|
||||
static int cpufreq_get_max_state(struct thermal_cooling_device *cdev,
|
||||
unsigned long *state)
|
||||
{
|
||||
int ret = -EINVAL, i = 0;
|
||||
struct cpufreq_cooling_device *cpufreq_device;
|
||||
struct cpumask *maskPtr;
|
||||
unsigned int cpu;
|
||||
struct cpufreq_frequency_table *table;
|
||||
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
list_for_each_entry(cpufreq_device, &cooling_cpufreq_list, node) {
|
||||
if (cpufreq_device && cpufreq_device->cool_dev == cdev)
|
||||
break;
|
||||
}
|
||||
if (cpufreq_device == NULL)
|
||||
goto return_get_max_state;
|
||||
|
||||
maskPtr = &cpufreq_device->allowed_cpus;
|
||||
cpu = cpumask_any(maskPtr);
|
||||
table = cpufreq_frequency_get_table(cpu);
|
||||
if (!table) {
|
||||
*state = 0;
|
||||
ret = 0;
|
||||
goto return_get_max_state;
|
||||
}
|
||||
|
||||
while (table[i].frequency != CPUFREQ_TABLE_END) {
|
||||
if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
|
||||
continue;
|
||||
i++;
|
||||
}
|
||||
if (i > 0) {
|
||||
*state = --i;
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
return_get_max_state:
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* cpufreq_get_cur_state - callback function to get the current cooling state.
|
||||
* @cdev: thermal cooling device pointer.
|
||||
* @state: fill this variable with the current cooling state.
|
||||
*/
|
||||
static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev,
|
||||
unsigned long *state)
|
||||
{
|
||||
int ret = -EINVAL;
|
||||
struct cpufreq_cooling_device *cpufreq_device;
|
||||
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
list_for_each_entry(cpufreq_device, &cooling_cpufreq_list, node) {
|
||||
if (cpufreq_device && cpufreq_device->cool_dev == cdev) {
|
||||
*state = cpufreq_device->cpufreq_state;
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* cpufreq_set_cur_state - callback function to set the current cooling state.
|
||||
* @cdev: thermal cooling device pointer.
|
||||
* @state: set this variable to the current cooling state.
|
||||
*/
|
||||
static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev,
|
||||
unsigned long state)
|
||||
{
|
||||
int ret = -EINVAL;
|
||||
struct cpufreq_cooling_device *cpufreq_device;
|
||||
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
list_for_each_entry(cpufreq_device, &cooling_cpufreq_list, node) {
|
||||
if (cpufreq_device && cpufreq_device->cool_dev == cdev) {
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!ret)
|
||||
ret = cpufreq_apply_cooling(cpufreq_device, state);
|
||||
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Bind cpufreq callbacks to thermal cooling device ops */
|
||||
static struct thermal_cooling_device_ops const cpufreq_cooling_ops = {
|
||||
.get_max_state = cpufreq_get_max_state,
|
||||
.get_cur_state = cpufreq_get_cur_state,
|
||||
.set_cur_state = cpufreq_set_cur_state,
|
||||
};
|
||||
|
||||
/* Notifier for cpufreq policy change */
|
||||
static struct notifier_block thermal_cpufreq_notifier_block = {
|
||||
.notifier_call = cpufreq_thermal_notifier,
|
||||
};
|
||||
|
||||
/**
|
||||
* cpufreq_cooling_register - function to create cpufreq cooling device.
|
||||
* @clip_cpus: cpumask of cpus where the frequency constraints will happen.
|
||||
*/
|
||||
struct thermal_cooling_device *cpufreq_cooling_register(
|
||||
struct cpumask *clip_cpus)
|
||||
{
|
||||
struct thermal_cooling_device *cool_dev;
|
||||
struct cpufreq_cooling_device *cpufreq_dev = NULL;
|
||||
unsigned int cpufreq_dev_count = 0, min = 0, max = 0;
|
||||
char dev_name[THERMAL_NAME_LENGTH];
|
||||
int ret = 0, i;
|
||||
struct cpufreq_policy policy;
|
||||
|
||||
list_for_each_entry(cpufreq_dev, &cooling_cpufreq_list, node)
|
||||
cpufreq_dev_count++;
|
||||
|
||||
/*Verify that all the clip cpus have same freq_min, freq_max limit*/
|
||||
for_each_cpu(i, clip_cpus) {
|
||||
/*continue if cpufreq policy not found and not return error*/
|
||||
if (!cpufreq_get_policy(&policy, i))
|
||||
continue;
|
||||
if (min == 0 && max == 0) {
|
||||
min = policy.cpuinfo.min_freq;
|
||||
max = policy.cpuinfo.max_freq;
|
||||
} else {
|
||||
if (min != policy.cpuinfo.min_freq ||
|
||||
max != policy.cpuinfo.max_freq)
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
}
|
||||
cpufreq_dev = kzalloc(sizeof(struct cpufreq_cooling_device),
|
||||
GFP_KERNEL);
|
||||
if (!cpufreq_dev)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
cpumask_copy(&cpufreq_dev->allowed_cpus, clip_cpus);
|
||||
|
||||
if (cpufreq_dev_count == 0)
|
||||
mutex_init(&cooling_cpufreq_lock);
|
||||
|
||||
ret = get_idr(&cpufreq_idr, &cpufreq_dev->id);
|
||||
if (ret) {
|
||||
kfree(cpufreq_dev);
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
|
||||
sprintf(dev_name, "thermal-cpufreq-%d", cpufreq_dev->id);
|
||||
|
||||
cool_dev = thermal_cooling_device_register(dev_name, cpufreq_dev,
|
||||
&cpufreq_cooling_ops);
|
||||
if (!cool_dev) {
|
||||
release_idr(&cpufreq_idr, cpufreq_dev->id);
|
||||
kfree(cpufreq_dev);
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
cpufreq_dev->cool_dev = cool_dev;
|
||||
cpufreq_dev->cpufreq_state = 0;
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
list_add_tail(&cpufreq_dev->node, &cooling_cpufreq_list);
|
||||
|
||||
/* Register the notifier for first cpufreq cooling device */
|
||||
if (cpufreq_dev_count == 0)
|
||||
cpufreq_register_notifier(&thermal_cpufreq_notifier_block,
|
||||
CPUFREQ_POLICY_NOTIFIER);
|
||||
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
return cool_dev;
|
||||
}
|
||||
EXPORT_SYMBOL(cpufreq_cooling_register);
|
||||
|
||||
/**
|
||||
* cpufreq_cooling_unregister - function to remove cpufreq cooling device.
|
||||
* @cdev: thermal cooling device pointer.
|
||||
*/
|
||||
void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
|
||||
{
|
||||
struct cpufreq_cooling_device *cpufreq_dev = NULL;
|
||||
unsigned int cpufreq_dev_count = 0;
|
||||
|
||||
mutex_lock(&cooling_cpufreq_lock);
|
||||
list_for_each_entry(cpufreq_dev, &cooling_cpufreq_list, node) {
|
||||
if (cpufreq_dev && cpufreq_dev->cool_dev == cdev)
|
||||
break;
|
||||
cpufreq_dev_count++;
|
||||
}
|
||||
|
||||
if (!cpufreq_dev || cpufreq_dev->cool_dev != cdev) {
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
return;
|
||||
}
|
||||
|
||||
list_del(&cpufreq_dev->node);
|
||||
|
||||
/* Unregister the notifier for the last cpufreq cooling device */
|
||||
if (cpufreq_dev_count == 1) {
|
||||
cpufreq_unregister_notifier(&thermal_cpufreq_notifier_block,
|
||||
CPUFREQ_POLICY_NOTIFIER);
|
||||
}
|
||||
mutex_unlock(&cooling_cpufreq_lock);
|
||||
thermal_cooling_device_unregister(cpufreq_dev->cool_dev);
|
||||
release_idr(&cpufreq_idr, cpufreq_dev->id);
|
||||
if (cpufreq_dev_count == 1)
|
||||
mutex_destroy(&cooling_cpufreq_lock);
|
||||
kfree(cpufreq_dev);
|
||||
}
|
||||
EXPORT_SYMBOL(cpufreq_cooling_unregister);
|
||||
997
drivers/thermal/exynos_thermal.c
Normal file
997
drivers/thermal/exynos_thermal.c
Normal file
|
|
@ -0,0 +1,997 @@
|
|||
/*
|
||||
* exynos_thermal.c - Samsung EXYNOS TMU (Thermal Management Unit)
|
||||
*
|
||||
* Copyright (C) 2011 Samsung Electronics
|
||||
* Donggeun Kim <dg77.kim@samsung.com>
|
||||
* Amit Daniel Kachhap <amit.kachhap@linaro.org>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/sysfs.h>
|
||||
#include <linux/kobject.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/platform_data/exynos_thermal.h>
|
||||
#include <linux/thermal.h>
|
||||
#include <linux/cpufreq.h>
|
||||
#include <linux/cpu_cooling.h>
|
||||
#include <linux/of.h>
|
||||
|
||||
#include <plat/cpu.h>
|
||||
|
||||
/* Exynos generic registers */
|
||||
#define EXYNOS_TMU_REG_TRIMINFO 0x0
|
||||
#define EXYNOS_TMU_REG_CONTROL 0x20
|
||||
#define EXYNOS_TMU_REG_STATUS 0x28
|
||||
#define EXYNOS_TMU_REG_CURRENT_TEMP 0x40
|
||||
#define EXYNOS_TMU_REG_INTEN 0x70
|
||||
#define EXYNOS_TMU_REG_INTSTAT 0x74
|
||||
#define EXYNOS_TMU_REG_INTCLEAR 0x78
|
||||
|
||||
#define EXYNOS_TMU_TRIM_TEMP_MASK 0xff
|
||||
#define EXYNOS_TMU_GAIN_SHIFT 8
|
||||
#define EXYNOS_TMU_REF_VOLTAGE_SHIFT 24
|
||||
#define EXYNOS_TMU_CORE_ON 3
|
||||
#define EXYNOS_TMU_CORE_OFF 2
|
||||
#define EXYNOS_TMU_DEF_CODE_TO_TEMP_OFFSET 50
|
||||
|
||||
/* Exynos4210 specific registers */
|
||||
#define EXYNOS4210_TMU_REG_THRESHOLD_TEMP 0x44
|
||||
#define EXYNOS4210_TMU_REG_TRIG_LEVEL0 0x50
|
||||
#define EXYNOS4210_TMU_REG_TRIG_LEVEL1 0x54
|
||||
#define EXYNOS4210_TMU_REG_TRIG_LEVEL2 0x58
|
||||
#define EXYNOS4210_TMU_REG_TRIG_LEVEL3 0x5C
|
||||
#define EXYNOS4210_TMU_REG_PAST_TEMP0 0x60
|
||||
#define EXYNOS4210_TMU_REG_PAST_TEMP1 0x64
|
||||
#define EXYNOS4210_TMU_REG_PAST_TEMP2 0x68
|
||||
#define EXYNOS4210_TMU_REG_PAST_TEMP3 0x6C
|
||||
|
||||
#define EXYNOS4210_TMU_TRIG_LEVEL0_MASK 0x1
|
||||
#define EXYNOS4210_TMU_TRIG_LEVEL1_MASK 0x10
|
||||
#define EXYNOS4210_TMU_TRIG_LEVEL2_MASK 0x100
|
||||
#define EXYNOS4210_TMU_TRIG_LEVEL3_MASK 0x1000
|
||||
#define EXYNOS4210_TMU_INTCLEAR_VAL 0x1111
|
||||
|
||||
/* Exynos5250 and Exynos4412 specific registers */
|
||||
#define EXYNOS_TMU_TRIMINFO_CON 0x14
|
||||
#define EXYNOS_THD_TEMP_RISE 0x50
|
||||
#define EXYNOS_THD_TEMP_FALL 0x54
|
||||
#define EXYNOS_EMUL_CON 0x80
|
||||
|
||||
#define EXYNOS_TRIMINFO_RELOAD 0x1
|
||||
#define EXYNOS_TMU_CLEAR_RISE_INT 0x111
|
||||
#define EXYNOS_TMU_CLEAR_FALL_INT (0x111 << 16)
|
||||
#define EXYNOS_MUX_ADDR_VALUE 6
|
||||
#define EXYNOS_MUX_ADDR_SHIFT 20
|
||||
#define EXYNOS_TMU_TRIP_MODE_SHIFT 13
|
||||
|
||||
#define EFUSE_MIN_VALUE 40
|
||||
#define EFUSE_MAX_VALUE 100
|
||||
|
||||
/* In-kernel thermal framework related macros & definations */
|
||||
#define SENSOR_NAME_LEN 16
|
||||
#define MAX_TRIP_COUNT 8
|
||||
#define MAX_COOLING_DEVICE 4
|
||||
|
||||
#define ACTIVE_INTERVAL 500
|
||||
#define IDLE_INTERVAL 10000
|
||||
#define MCELSIUS 1000
|
||||
|
||||
/* CPU Zone information */
|
||||
#define PANIC_ZONE 4
|
||||
#define WARN_ZONE 3
|
||||
#define MONITOR_ZONE 2
|
||||
#define SAFE_ZONE 1
|
||||
|
||||
#define GET_ZONE(trip) (trip + 2)
|
||||
#define GET_TRIP(zone) (zone - 2)
|
||||
|
||||
#define EXYNOS_ZONE_COUNT 3
|
||||
|
||||
struct exynos_tmu_data {
|
||||
struct exynos_tmu_platform_data *pdata;
|
||||
struct resource *mem;
|
||||
void __iomem *base;
|
||||
int irq;
|
||||
enum soc_type soc;
|
||||
struct work_struct irq_work;
|
||||
struct mutex lock;
|
||||
struct clk *clk;
|
||||
u8 temp_error1, temp_error2;
|
||||
};
|
||||
|
||||
struct thermal_trip_point_conf {
|
||||
int trip_val[MAX_TRIP_COUNT];
|
||||
int trip_count;
|
||||
};
|
||||
|
||||
struct thermal_cooling_conf {
|
||||
struct freq_clip_table freq_data[MAX_TRIP_COUNT];
|
||||
int freq_clip_count;
|
||||
};
|
||||
|
||||
struct thermal_sensor_conf {
|
||||
char name[SENSOR_NAME_LEN];
|
||||
int (*read_temperature)(void *data);
|
||||
struct thermal_trip_point_conf trip_data;
|
||||
struct thermal_cooling_conf cooling_data;
|
||||
void *private_data;
|
||||
};
|
||||
|
||||
struct exynos_thermal_zone {
|
||||
enum thermal_device_mode mode;
|
||||
struct thermal_zone_device *therm_dev;
|
||||
struct thermal_cooling_device *cool_dev[MAX_COOLING_DEVICE];
|
||||
unsigned int cool_dev_size;
|
||||
struct platform_device *exynos4_dev;
|
||||
struct thermal_sensor_conf *sensor_conf;
|
||||
bool bind;
|
||||
};
|
||||
|
||||
static struct exynos_thermal_zone *th_zone;
|
||||
static void exynos_unregister_thermal(void);
|
||||
static int exynos_register_thermal(struct thermal_sensor_conf *sensor_conf);
|
||||
|
||||
/* Get mode callback functions for thermal zone */
|
||||
static int exynos_get_mode(struct thermal_zone_device *thermal,
|
||||
enum thermal_device_mode *mode)
|
||||
{
|
||||
if (th_zone)
|
||||
*mode = th_zone->mode;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Set mode callback functions for thermal zone */
|
||||
static int exynos_set_mode(struct thermal_zone_device *thermal,
|
||||
enum thermal_device_mode mode)
|
||||
{
|
||||
if (!th_zone->therm_dev) {
|
||||
pr_notice("thermal zone not registered\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
mutex_lock(&th_zone->therm_dev->lock);
|
||||
|
||||
if (mode == THERMAL_DEVICE_ENABLED)
|
||||
th_zone->therm_dev->polling_delay = IDLE_INTERVAL;
|
||||
else
|
||||
th_zone->therm_dev->polling_delay = 0;
|
||||
|
||||
mutex_unlock(&th_zone->therm_dev->lock);
|
||||
|
||||
th_zone->mode = mode;
|
||||
thermal_zone_device_update(th_zone->therm_dev);
|
||||
pr_info("thermal polling set for duration=%d msec\n",
|
||||
th_zone->therm_dev->polling_delay);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Get trip type callback functions for thermal zone */
|
||||
static int exynos_get_trip_type(struct thermal_zone_device *thermal, int trip,
|
||||
enum thermal_trip_type *type)
|
||||
{
|
||||
switch (GET_ZONE(trip)) {
|
||||
case MONITOR_ZONE:
|
||||
case WARN_ZONE:
|
||||
*type = THERMAL_TRIP_ACTIVE;
|
||||
break;
|
||||
case PANIC_ZONE:
|
||||
*type = THERMAL_TRIP_CRITICAL;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Get trip temperature callback functions for thermal zone */
|
||||
static int exynos_get_trip_temp(struct thermal_zone_device *thermal, int trip,
|
||||
unsigned long *temp)
|
||||
{
|
||||
if (trip < GET_TRIP(MONITOR_ZONE) || trip > GET_TRIP(PANIC_ZONE))
|
||||
return -EINVAL;
|
||||
|
||||
*temp = th_zone->sensor_conf->trip_data.trip_val[trip];
|
||||
/* convert the temperature into millicelsius */
|
||||
*temp = *temp * MCELSIUS;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Get critical temperature callback functions for thermal zone */
|
||||
static int exynos_get_crit_temp(struct thermal_zone_device *thermal,
|
||||
unsigned long *temp)
|
||||
{
|
||||
int ret;
|
||||
/* Panic zone */
|
||||
ret = exynos_get_trip_temp(thermal, GET_TRIP(PANIC_ZONE), temp);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int exynos_get_frequency_level(unsigned int cpu, unsigned int freq)
|
||||
{
|
||||
int i = 0, ret = -EINVAL;
|
||||
struct cpufreq_frequency_table *table = NULL;
|
||||
#ifdef CONFIG_CPU_FREQ
|
||||
table = cpufreq_frequency_get_table(cpu);
|
||||
#endif
|
||||
if (!table)
|
||||
return ret;
|
||||
|
||||
while (table[i].frequency != CPUFREQ_TABLE_END) {
|
||||
if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
|
||||
continue;
|
||||
if (table[i].frequency == freq)
|
||||
return i;
|
||||
i++;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Bind callback functions for thermal zone */
|
||||
static int exynos_bind(struct thermal_zone_device *thermal,
|
||||
struct thermal_cooling_device *cdev)
|
||||
{
|
||||
int ret = 0, i, tab_size, level;
|
||||
struct freq_clip_table *tab_ptr, *clip_data;
|
||||
struct thermal_sensor_conf *data = th_zone->sensor_conf;
|
||||
|
||||
tab_ptr = (struct freq_clip_table *)data->cooling_data.freq_data;
|
||||
tab_size = data->cooling_data.freq_clip_count;
|
||||
|
||||
if (tab_ptr == NULL || tab_size == 0)
|
||||
return -EINVAL;
|
||||
|
||||
/* find the cooling device registered*/
|
||||
for (i = 0; i < th_zone->cool_dev_size; i++)
|
||||
if (cdev == th_zone->cool_dev[i])
|
||||
break;
|
||||
|
||||
/* No matching cooling device */
|
||||
if (i == th_zone->cool_dev_size)
|
||||
return 0;
|
||||
|
||||
/* Bind the thermal zone to the cpufreq cooling device */
|
||||
for (i = 0; i < tab_size; i++) {
|
||||
clip_data = (struct freq_clip_table *)&(tab_ptr[i]);
|
||||
level = exynos_get_frequency_level(0, clip_data->freq_clip_max);
|
||||
if (level < 0)
|
||||
return 0;
|
||||
switch (GET_ZONE(i)) {
|
||||
case MONITOR_ZONE:
|
||||
case WARN_ZONE:
|
||||
if (thermal_zone_bind_cooling_device(thermal, i, cdev,
|
||||
level, level)) {
|
||||
pr_err("error binding cdev inst %d\n", i);
|
||||
ret = -EINVAL;
|
||||
}
|
||||
th_zone->bind = true;
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Unbind callback functions for thermal zone */
|
||||
static int exynos_unbind(struct thermal_zone_device *thermal,
|
||||
struct thermal_cooling_device *cdev)
|
||||
{
|
||||
int ret = 0, i, tab_size;
|
||||
struct thermal_sensor_conf *data = th_zone->sensor_conf;
|
||||
|
||||
if (th_zone->bind == false)
|
||||
return 0;
|
||||
|
||||
tab_size = data->cooling_data.freq_clip_count;
|
||||
|
||||
if (tab_size == 0)
|
||||
return -EINVAL;
|
||||
|
||||
/* find the cooling device registered*/
|
||||
for (i = 0; i < th_zone->cool_dev_size; i++)
|
||||
if (cdev == th_zone->cool_dev[i])
|
||||
break;
|
||||
|
||||
/* No matching cooling device */
|
||||
if (i == th_zone->cool_dev_size)
|
||||
return 0;
|
||||
|
||||
/* Bind the thermal zone to the cpufreq cooling device */
|
||||
for (i = 0; i < tab_size; i++) {
|
||||
switch (GET_ZONE(i)) {
|
||||
case MONITOR_ZONE:
|
||||
case WARN_ZONE:
|
||||
if (thermal_zone_unbind_cooling_device(thermal, i,
|
||||
cdev)) {
|
||||
pr_err("error unbinding cdev inst=%d\n", i);
|
||||
ret = -EINVAL;
|
||||
}
|
||||
th_zone->bind = false;
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Get temperature callback functions for thermal zone */
|
||||
static int exynos_get_temp(struct thermal_zone_device *thermal,
|
||||
unsigned long *temp)
|
||||
{
|
||||
void *data;
|
||||
|
||||
if (!th_zone->sensor_conf) {
|
||||
pr_info("Temperature sensor not initialised\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
data = th_zone->sensor_conf->private_data;
|
||||
*temp = th_zone->sensor_conf->read_temperature(data);
|
||||
/* convert the temperature into millicelsius */
|
||||
*temp = *temp * MCELSIUS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Get the temperature trend */
|
||||
static int exynos_get_trend(struct thermal_zone_device *thermal,
|
||||
int trip, enum thermal_trend *trend)
|
||||
{
|
||||
if (thermal->temperature >= trip)
|
||||
*trend = THERMAL_TREND_RAISING;
|
||||
else
|
||||
*trend = THERMAL_TREND_DROPPING;
|
||||
|
||||
return 0;
|
||||
}
|
||||
/* Operation callback functions for thermal zone */
|
||||
static struct thermal_zone_device_ops const exynos_dev_ops = {
|
||||
.bind = exynos_bind,
|
||||
.unbind = exynos_unbind,
|
||||
.get_temp = exynos_get_temp,
|
||||
.get_trend = exynos_get_trend,
|
||||
.get_mode = exynos_get_mode,
|
||||
.set_mode = exynos_set_mode,
|
||||
.get_trip_type = exynos_get_trip_type,
|
||||
.get_trip_temp = exynos_get_trip_temp,
|
||||
.get_crit_temp = exynos_get_crit_temp,
|
||||
};
|
||||
|
||||
/*
|
||||
* This function may be called from interrupt based temperature sensor
|
||||
* when threshold is changed.
|
||||
*/
|
||||
static void exynos_report_trigger(void)
|
||||
{
|
||||
unsigned int i;
|
||||
char data[10];
|
||||
char *envp[] = { data, NULL };
|
||||
|
||||
if (!th_zone || !th_zone->therm_dev)
|
||||
return;
|
||||
if (th_zone->bind == false) {
|
||||
for (i = 0; i < th_zone->cool_dev_size; i++) {
|
||||
if (!th_zone->cool_dev[i])
|
||||
continue;
|
||||
exynos_bind(th_zone->therm_dev,
|
||||
th_zone->cool_dev[i]);
|
||||
}
|
||||
}
|
||||
|
||||
thermal_zone_device_update(th_zone->therm_dev);
|
||||
|
||||
mutex_lock(&th_zone->therm_dev->lock);
|
||||
/* Find the level for which trip happened */
|
||||
for (i = 0; i < th_zone->sensor_conf->trip_data.trip_count; i++) {
|
||||
if (th_zone->therm_dev->last_temperature <
|
||||
th_zone->sensor_conf->trip_data.trip_val[i] * MCELSIUS)
|
||||
break;
|
||||
}
|
||||
|
||||
if (th_zone->mode == THERMAL_DEVICE_ENABLED) {
|
||||
if (i > 0)
|
||||
th_zone->therm_dev->polling_delay = ACTIVE_INTERVAL;
|
||||
else
|
||||
th_zone->therm_dev->polling_delay = IDLE_INTERVAL;
|
||||
}
|
||||
|
||||
snprintf(data, sizeof(data), "%u", i);
|
||||
kobject_uevent_env(&th_zone->therm_dev->device.kobj, KOBJ_CHANGE, envp);
|
||||
mutex_unlock(&th_zone->therm_dev->lock);
|
||||
}
|
||||
|
||||
/* Register with the in-kernel thermal management */
|
||||
static int exynos_register_thermal(struct thermal_sensor_conf *sensor_conf)
|
||||
{
|
||||
int ret;
|
||||
struct cpumask mask_val;
|
||||
|
||||
if (!sensor_conf || !sensor_conf->read_temperature) {
|
||||
pr_err("Temperature sensor not initialised\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
th_zone = kzalloc(sizeof(struct exynos_thermal_zone), GFP_KERNEL);
|
||||
if (!th_zone)
|
||||
return -ENOMEM;
|
||||
|
||||
th_zone->sensor_conf = sensor_conf;
|
||||
cpumask_set_cpu(0, &mask_val);
|
||||
th_zone->cool_dev[0] = cpufreq_cooling_register(&mask_val);
|
||||
if (IS_ERR(th_zone->cool_dev[0])) {
|
||||
pr_err("Failed to register cpufreq cooling device\n");
|
||||
ret = -EINVAL;
|
||||
goto err_unregister;
|
||||
}
|
||||
th_zone->cool_dev_size++;
|
||||
|
||||
th_zone->therm_dev = thermal_zone_device_register(sensor_conf->name,
|
||||
EXYNOS_ZONE_COUNT, 0, NULL, &exynos_dev_ops, 0,
|
||||
IDLE_INTERVAL);
|
||||
|
||||
if (IS_ERR(th_zone->therm_dev)) {
|
||||
pr_err("Failed to register thermal zone device\n");
|
||||
ret = -EINVAL;
|
||||
goto err_unregister;
|
||||
}
|
||||
th_zone->mode = THERMAL_DEVICE_ENABLED;
|
||||
|
||||
pr_info("Exynos: Kernel Thermal management registered\n");
|
||||
|
||||
return 0;
|
||||
|
||||
err_unregister:
|
||||
exynos_unregister_thermal();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Un-Register with the in-kernel thermal management */
|
||||
static void exynos_unregister_thermal(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!th_zone)
|
||||
return;
|
||||
|
||||
if (th_zone->therm_dev)
|
||||
thermal_zone_device_unregister(th_zone->therm_dev);
|
||||
|
||||
for (i = 0; i < th_zone->cool_dev_size; i++) {
|
||||
if (th_zone->cool_dev[i])
|
||||
cpufreq_cooling_unregister(th_zone->cool_dev[i]);
|
||||
}
|
||||
|
||||
kfree(th_zone);
|
||||
pr_info("Exynos: Kernel Thermal management unregistered\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* TMU treats temperature as a mapped temperature code.
|
||||
* The temperature is converted differently depending on the calibration type.
|
||||
*/
|
||||
static int temp_to_code(struct exynos_tmu_data *data, u8 temp)
|
||||
{
|
||||
struct exynos_tmu_platform_data *pdata = data->pdata;
|
||||
int temp_code;
|
||||
|
||||
if (data->soc == SOC_ARCH_EXYNOS4210)
|
||||
/* temp should range between 25 and 125 */
|
||||
if (temp < 25 || temp > 125) {
|
||||
temp_code = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
switch (pdata->cal_type) {
|
||||
case TYPE_TWO_POINT_TRIMMING:
|
||||
temp_code = (temp - 25) *
|
||||
(data->temp_error2 - data->temp_error1) /
|
||||
(85 - 25) + data->temp_error1;
|
||||
break;
|
||||
case TYPE_ONE_POINT_TRIMMING:
|
||||
temp_code = temp + data->temp_error1 - 25;
|
||||
break;
|
||||
default:
|
||||
temp_code = temp + EXYNOS_TMU_DEF_CODE_TO_TEMP_OFFSET;
|
||||
break;
|
||||
}
|
||||
out:
|
||||
return temp_code;
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate a temperature value from a temperature code.
|
||||
* The unit of the temperature is degree Celsius.
|
||||
*/
|
||||
static int code_to_temp(struct exynos_tmu_data *data, u8 temp_code)
|
||||
{
|
||||
struct exynos_tmu_platform_data *pdata = data->pdata;
|
||||
int temp;
|
||||
|
||||
if (data->soc == SOC_ARCH_EXYNOS4210)
|
||||
/* temp_code should range between 75 and 175 */
|
||||
if (temp_code < 75 || temp_code > 175) {
|
||||
temp = -ENODATA;
|
||||
goto out;
|
||||
}
|
||||
|
||||
switch (pdata->cal_type) {
|
||||
case TYPE_TWO_POINT_TRIMMING:
|
||||
temp = (temp_code - data->temp_error1) * (85 - 25) /
|
||||
(data->temp_error2 - data->temp_error1) + 25;
|
||||
break;
|
||||
case TYPE_ONE_POINT_TRIMMING:
|
||||
temp = temp_code - data->temp_error1 + 25;
|
||||
break;
|
||||
default:
|
||||
temp = temp_code - EXYNOS_TMU_DEF_CODE_TO_TEMP_OFFSET;
|
||||
break;
|
||||
}
|
||||
out:
|
||||
return temp;
|
||||
}
|
||||
|
||||
static int exynos_tmu_initialize(struct platform_device *pdev)
|
||||
{
|
||||
struct exynos_tmu_data *data = platform_get_drvdata(pdev);
|
||||
struct exynos_tmu_platform_data *pdata = data->pdata;
|
||||
unsigned int status, trim_info, rising_threshold;
|
||||
int ret = 0, threshold_code;
|
||||
|
||||
mutex_lock(&data->lock);
|
||||
clk_enable(data->clk);
|
||||
|
||||
status = readb(data->base + EXYNOS_TMU_REG_STATUS);
|
||||
if (!status) {
|
||||
ret = -EBUSY;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (data->soc == SOC_ARCH_EXYNOS) {
|
||||
__raw_writel(EXYNOS_TRIMINFO_RELOAD,
|
||||
data->base + EXYNOS_TMU_TRIMINFO_CON);
|
||||
}
|
||||
/* Save trimming info in order to perform calibration */
|
||||
trim_info = readl(data->base + EXYNOS_TMU_REG_TRIMINFO);
|
||||
data->temp_error1 = trim_info & EXYNOS_TMU_TRIM_TEMP_MASK;
|
||||
data->temp_error2 = ((trim_info >> 8) & EXYNOS_TMU_TRIM_TEMP_MASK);
|
||||
|
||||
if ((EFUSE_MIN_VALUE > data->temp_error1) ||
|
||||
(data->temp_error1 > EFUSE_MAX_VALUE) ||
|
||||
(data->temp_error2 != 0))
|
||||
data->temp_error1 = pdata->efuse_value;
|
||||
|
||||
if (data->soc == SOC_ARCH_EXYNOS4210) {
|
||||
/* Write temperature code for threshold */
|
||||
threshold_code = temp_to_code(data, pdata->threshold);
|
||||
if (threshold_code < 0) {
|
||||
ret = threshold_code;
|
||||
goto out;
|
||||
}
|
||||
writeb(threshold_code,
|
||||
data->base + EXYNOS4210_TMU_REG_THRESHOLD_TEMP);
|
||||
|
||||
writeb(pdata->trigger_levels[0],
|
||||
data->base + EXYNOS4210_TMU_REG_TRIG_LEVEL0);
|
||||
writeb(pdata->trigger_levels[1],
|
||||
data->base + EXYNOS4210_TMU_REG_TRIG_LEVEL1);
|
||||
writeb(pdata->trigger_levels[2],
|
||||
data->base + EXYNOS4210_TMU_REG_TRIG_LEVEL2);
|
||||
writeb(pdata->trigger_levels[3],
|
||||
data->base + EXYNOS4210_TMU_REG_TRIG_LEVEL3);
|
||||
|
||||
writel(EXYNOS4210_TMU_INTCLEAR_VAL,
|
||||
data->base + EXYNOS_TMU_REG_INTCLEAR);
|
||||
} else if (data->soc == SOC_ARCH_EXYNOS) {
|
||||
/* Write temperature code for threshold */
|
||||
threshold_code = temp_to_code(data, pdata->trigger_levels[0]);
|
||||
if (threshold_code < 0) {
|
||||
ret = threshold_code;
|
||||
goto out;
|
||||
}
|
||||
rising_threshold = threshold_code;
|
||||
threshold_code = temp_to_code(data, pdata->trigger_levels[1]);
|
||||
if (threshold_code < 0) {
|
||||
ret = threshold_code;
|
||||
goto out;
|
||||
}
|
||||
rising_threshold |= (threshold_code << 8);
|
||||
threshold_code = temp_to_code(data, pdata->trigger_levels[2]);
|
||||
if (threshold_code < 0) {
|
||||
ret = threshold_code;
|
||||
goto out;
|
||||
}
|
||||
rising_threshold |= (threshold_code << 16);
|
||||
|
||||
writel(rising_threshold,
|
||||
data->base + EXYNOS_THD_TEMP_RISE);
|
||||
writel(0, data->base + EXYNOS_THD_TEMP_FALL);
|
||||
|
||||
writel(EXYNOS_TMU_CLEAR_RISE_INT|EXYNOS_TMU_CLEAR_FALL_INT,
|
||||
data->base + EXYNOS_TMU_REG_INTCLEAR);
|
||||
}
|
||||
out:
|
||||
clk_disable(data->clk);
|
||||
mutex_unlock(&data->lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void exynos_tmu_control(struct platform_device *pdev, bool on)
|
||||
{
|
||||
struct exynos_tmu_data *data = platform_get_drvdata(pdev);
|
||||
struct exynos_tmu_platform_data *pdata = data->pdata;
|
||||
unsigned int con, interrupt_en;
|
||||
|
||||
mutex_lock(&data->lock);
|
||||
clk_enable(data->clk);
|
||||
|
||||
con = pdata->reference_voltage << EXYNOS_TMU_REF_VOLTAGE_SHIFT |
|
||||
pdata->gain << EXYNOS_TMU_GAIN_SHIFT;
|
||||
|
||||
if (data->soc == SOC_ARCH_EXYNOS) {
|
||||
con |= pdata->noise_cancel_mode << EXYNOS_TMU_TRIP_MODE_SHIFT;
|
||||
con |= (EXYNOS_MUX_ADDR_VALUE << EXYNOS_MUX_ADDR_SHIFT);
|
||||
}
|
||||
|
||||
if (on) {
|
||||
con |= EXYNOS_TMU_CORE_ON;
|
||||
interrupt_en = pdata->trigger_level3_en << 12 |
|
||||
pdata->trigger_level2_en << 8 |
|
||||
pdata->trigger_level1_en << 4 |
|
||||
pdata->trigger_level0_en;
|
||||
} else {
|
||||
con |= EXYNOS_TMU_CORE_OFF;
|
||||
interrupt_en = 0; /* Disable all interrupts */
|
||||
}
|
||||
writel(interrupt_en, data->base + EXYNOS_TMU_REG_INTEN);
|
||||
writel(con, data->base + EXYNOS_TMU_REG_CONTROL);
|
||||
|
||||
clk_disable(data->clk);
|
||||
mutex_unlock(&data->lock);
|
||||
}
|
||||
|
||||
static int exynos_tmu_read(struct exynos_tmu_data *data)
|
||||
{
|
||||
u8 temp_code;
|
||||
int temp;
|
||||
|
||||
mutex_lock(&data->lock);
|
||||
clk_enable(data->clk);
|
||||
|
||||
temp_code = readb(data->base + EXYNOS_TMU_REG_CURRENT_TEMP);
|
||||
temp = code_to_temp(data, temp_code);
|
||||
|
||||
clk_disable(data->clk);
|
||||
mutex_unlock(&data->lock);
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
static void exynos_tmu_work(struct work_struct *work)
|
||||
{
|
||||
struct exynos_tmu_data *data = container_of(work,
|
||||
struct exynos_tmu_data, irq_work);
|
||||
|
||||
mutex_lock(&data->lock);
|
||||
clk_enable(data->clk);
|
||||
|
||||
|
||||
if (data->soc == SOC_ARCH_EXYNOS)
|
||||
writel(EXYNOS_TMU_CLEAR_RISE_INT,
|
||||
data->base + EXYNOS_TMU_REG_INTCLEAR);
|
||||
else
|
||||
writel(EXYNOS4210_TMU_INTCLEAR_VAL,
|
||||
data->base + EXYNOS_TMU_REG_INTCLEAR);
|
||||
|
||||
clk_disable(data->clk);
|
||||
mutex_unlock(&data->lock);
|
||||
exynos_report_trigger();
|
||||
enable_irq(data->irq);
|
||||
}
|
||||
|
||||
static irqreturn_t exynos_tmu_irq(int irq, void *id)
|
||||
{
|
||||
struct exynos_tmu_data *data = id;
|
||||
|
||||
disable_irq_nosync(irq);
|
||||
schedule_work(&data->irq_work);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
static struct thermal_sensor_conf exynos_sensor_conf = {
|
||||
.name = "exynos-therm",
|
||||
.read_temperature = (int (*)(void *))exynos_tmu_read,
|
||||
};
|
||||
|
||||
#if defined(CONFIG_CPU_EXYNOS4210)
|
||||
static struct exynos_tmu_platform_data const exynos4210_default_tmu_data = {
|
||||
.threshold = 80,
|
||||
.trigger_levels[0] = 5,
|
||||
.trigger_levels[1] = 20,
|
||||
.trigger_levels[2] = 30,
|
||||
.trigger_level0_en = 1,
|
||||
.trigger_level1_en = 1,
|
||||
.trigger_level2_en = 1,
|
||||
.trigger_level3_en = 0,
|
||||
.gain = 15,
|
||||
.reference_voltage = 7,
|
||||
.cal_type = TYPE_ONE_POINT_TRIMMING,
|
||||
.freq_tab[0] = {
|
||||
.freq_clip_max = 800 * 1000,
|
||||
.temp_level = 85,
|
||||
},
|
||||
.freq_tab[1] = {
|
||||
.freq_clip_max = 200 * 1000,
|
||||
.temp_level = 100,
|
||||
},
|
||||
.freq_tab_count = 2,
|
||||
.type = SOC_ARCH_EXYNOS4210,
|
||||
};
|
||||
#define EXYNOS4210_TMU_DRV_DATA (&exynos4210_default_tmu_data)
|
||||
#else
|
||||
#define EXYNOS4210_TMU_DRV_DATA (NULL)
|
||||
#endif
|
||||
|
||||
#if defined(CONFIG_SOC_EXYNOS5250) || defined(CONFIG_SOC_EXYNOS4412)
|
||||
static struct exynos_tmu_platform_data const exynos_default_tmu_data = {
|
||||
.trigger_levels[0] = 85,
|
||||
.trigger_levels[1] = 103,
|
||||
.trigger_levels[2] = 110,
|
||||
.trigger_level0_en = 1,
|
||||
.trigger_level1_en = 1,
|
||||
.trigger_level2_en = 1,
|
||||
.trigger_level3_en = 0,
|
||||
.gain = 8,
|
||||
.reference_voltage = 16,
|
||||
.noise_cancel_mode = 4,
|
||||
.cal_type = TYPE_ONE_POINT_TRIMMING,
|
||||
.efuse_value = 55,
|
||||
.freq_tab[0] = {
|
||||
.freq_clip_max = 800 * 1000,
|
||||
.temp_level = 85,
|
||||
},
|
||||
.freq_tab[1] = {
|
||||
.freq_clip_max = 200 * 1000,
|
||||
.temp_level = 103,
|
||||
},
|
||||
.freq_tab_count = 2,
|
||||
.type = SOC_ARCH_EXYNOS,
|
||||
};
|
||||
#define EXYNOS_TMU_DRV_DATA (&exynos_default_tmu_data)
|
||||
#else
|
||||
#define EXYNOS_TMU_DRV_DATA (NULL)
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_OF
|
||||
static const struct of_device_id exynos_tmu_match[] = {
|
||||
{
|
||||
.compatible = "samsung,exynos4210-tmu",
|
||||
.data = (void *)EXYNOS4210_TMU_DRV_DATA,
|
||||
},
|
||||
{
|
||||
.compatible = "samsung,exynos5250-tmu",
|
||||
.data = (void *)EXYNOS_TMU_DRV_DATA,
|
||||
},
|
||||
{},
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, exynos_tmu_match);
|
||||
#else
|
||||
#define exynos_tmu_match NULL
|
||||
#endif
|
||||
|
||||
static struct platform_device_id exynos_tmu_driver_ids[] = {
|
||||
{
|
||||
.name = "exynos4210-tmu",
|
||||
.driver_data = (kernel_ulong_t)EXYNOS4210_TMU_DRV_DATA,
|
||||
},
|
||||
{
|
||||
.name = "exynos5250-tmu",
|
||||
.driver_data = (kernel_ulong_t)EXYNOS_TMU_DRV_DATA,
|
||||
},
|
||||
{ },
|
||||
};
|
||||
MODULE_DEVICE_TABLE(platform, exynos4_tmu_driver_ids);
|
||||
|
||||
static inline struct exynos_tmu_platform_data *exynos_get_driver_data(
|
||||
struct platform_device *pdev)
|
||||
{
|
||||
#ifdef CONFIG_OF
|
||||
if (pdev->dev.of_node) {
|
||||
const struct of_device_id *match;
|
||||
match = of_match_node(exynos_tmu_match, pdev->dev.of_node);
|
||||
if (!match)
|
||||
return NULL;
|
||||
return (struct exynos_tmu_platform_data *) match->data;
|
||||
}
|
||||
#endif
|
||||
return (struct exynos_tmu_platform_data *)
|
||||
platform_get_device_id(pdev)->driver_data;
|
||||
}
|
||||
static int __devinit exynos_tmu_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct exynos_tmu_data *data;
|
||||
struct exynos_tmu_platform_data *pdata = pdev->dev.platform_data;
|
||||
int ret, i;
|
||||
|
||||
if (!pdata)
|
||||
pdata = exynos_get_driver_data(pdev);
|
||||
|
||||
if (!pdata) {
|
||||
dev_err(&pdev->dev, "No platform init data supplied.\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
data = devm_kzalloc(&pdev->dev, sizeof(struct exynos_tmu_data),
|
||||
GFP_KERNEL);
|
||||
if (!data) {
|
||||
dev_err(&pdev->dev, "Failed to allocate driver structure\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
data->irq = platform_get_irq(pdev, 0);
|
||||
if (data->irq < 0) {
|
||||
dev_err(&pdev->dev, "Failed to get platform irq\n");
|
||||
return data->irq;
|
||||
}
|
||||
|
||||
INIT_WORK(&data->irq_work, exynos_tmu_work);
|
||||
|
||||
data->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!data->mem) {
|
||||
dev_err(&pdev->dev, "Failed to get platform resource\n");
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
data->base = devm_request_and_ioremap(&pdev->dev, data->mem);
|
||||
if (!data->base) {
|
||||
dev_err(&pdev->dev, "Failed to ioremap memory\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
ret = devm_request_irq(&pdev->dev, data->irq, exynos_tmu_irq,
|
||||
IRQF_TRIGGER_RISING, "exynos-tmu", data);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "Failed to request irq: %d\n", data->irq);
|
||||
return ret;
|
||||
}
|
||||
|
||||
data->clk = clk_get(NULL, "tmu_apbif");
|
||||
if (IS_ERR(data->clk)) {
|
||||
dev_err(&pdev->dev, "Failed to get clock\n");
|
||||
return PTR_ERR(data->clk);
|
||||
}
|
||||
|
||||
if (pdata->type == SOC_ARCH_EXYNOS ||
|
||||
pdata->type == SOC_ARCH_EXYNOS4210)
|
||||
data->soc = pdata->type;
|
||||
else {
|
||||
ret = -EINVAL;
|
||||
dev_err(&pdev->dev, "Platform not supported\n");
|
||||
goto err_clk;
|
||||
}
|
||||
|
||||
data->pdata = pdata;
|
||||
platform_set_drvdata(pdev, data);
|
||||
mutex_init(&data->lock);
|
||||
|
||||
ret = exynos_tmu_initialize(pdev);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "Failed to initialize TMU\n");
|
||||
goto err_clk;
|
||||
}
|
||||
|
||||
exynos_tmu_control(pdev, true);
|
||||
|
||||
/* Register the sensor with thermal management interface */
|
||||
(&exynos_sensor_conf)->private_data = data;
|
||||
exynos_sensor_conf.trip_data.trip_count = pdata->trigger_level0_en +
|
||||
pdata->trigger_level1_en + pdata->trigger_level2_en +
|
||||
pdata->trigger_level3_en;
|
||||
|
||||
for (i = 0; i < exynos_sensor_conf.trip_data.trip_count; i++)
|
||||
exynos_sensor_conf.trip_data.trip_val[i] =
|
||||
pdata->threshold + pdata->trigger_levels[i];
|
||||
|
||||
exynos_sensor_conf.cooling_data.freq_clip_count =
|
||||
pdata->freq_tab_count;
|
||||
for (i = 0; i < pdata->freq_tab_count; i++) {
|
||||
exynos_sensor_conf.cooling_data.freq_data[i].freq_clip_max =
|
||||
pdata->freq_tab[i].freq_clip_max;
|
||||
exynos_sensor_conf.cooling_data.freq_data[i].temp_level =
|
||||
pdata->freq_tab[i].temp_level;
|
||||
}
|
||||
|
||||
ret = exynos_register_thermal(&exynos_sensor_conf);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "Failed to register thermal interface\n");
|
||||
goto err_clk;
|
||||
}
|
||||
return 0;
|
||||
err_clk:
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
clk_put(data->clk);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __devexit exynos_tmu_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct exynos_tmu_data *data = platform_get_drvdata(pdev);
|
||||
|
||||
exynos_tmu_control(pdev, false);
|
||||
|
||||
exynos_unregister_thermal();
|
||||
|
||||
clk_put(data->clk);
|
||||
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_SLEEP
|
||||
static int exynos_tmu_suspend(struct device *dev)
|
||||
{
|
||||
exynos_tmu_control(to_platform_device(dev), false);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int exynos_tmu_resume(struct device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
|
||||
exynos_tmu_initialize(pdev);
|
||||
exynos_tmu_control(pdev, true);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(exynos_tmu_pm,
|
||||
exynos_tmu_suspend, exynos_tmu_resume);
|
||||
#define EXYNOS_TMU_PM (&exynos_tmu_pm)
|
||||
#else
|
||||
#define EXYNOS_TMU_PM NULL
|
||||
#endif
|
||||
|
||||
static struct platform_driver exynos_tmu_driver = {
|
||||
.driver = {
|
||||
.name = "exynos-tmu",
|
||||
.owner = THIS_MODULE,
|
||||
.pm = EXYNOS_TMU_PM,
|
||||
.of_match_table = exynos_tmu_match,
|
||||
},
|
||||
.probe = exynos_tmu_probe,
|
||||
.remove = __devexit_p(exynos_tmu_remove),
|
||||
.id_table = exynos_tmu_driver_ids,
|
||||
};
|
||||
|
||||
module_platform_driver(exynos_tmu_driver);
|
||||
|
||||
MODULE_DESCRIPTION("EXYNOS TMU Driver");
|
||||
MODULE_AUTHOR("Donggeun Kim <[email protected]>");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("platform:exynos-tmu");
|
||||
260
drivers/thermal/rcar_thermal.c
Normal file
260
drivers/thermal/rcar_thermal.c
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
/*
|
||||
* R-Car THS/TSC thermal sensor driver
|
||||
*
|
||||
* Copyright (C) 2012 Renesas Solutions Corp.
|
||||
* Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; version 2 of the License.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
||||
*/
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/thermal.h>
|
||||
|
||||
#define THSCR 0x2c
|
||||
#define THSSR 0x30
|
||||
|
||||
/* THSCR */
|
||||
#define CPTAP 0xf
|
||||
|
||||
/* THSSR */
|
||||
#define CTEMP 0x3f
|
||||
|
||||
|
||||
struct rcar_thermal_priv {
|
||||
void __iomem *base;
|
||||
struct device *dev;
|
||||
spinlock_t lock;
|
||||
u32 comp;
|
||||
};
|
||||
|
||||
/*
|
||||
* basic functions
|
||||
*/
|
||||
static u32 rcar_thermal_read(struct rcar_thermal_priv *priv, u32 reg)
|
||||
{
|
||||
unsigned long flags;
|
||||
u32 ret;
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
|
||||
ret = ioread32(priv->base + reg);
|
||||
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if 0 /* no user at this point */
|
||||
static void rcar_thermal_write(struct rcar_thermal_priv *priv,
|
||||
u32 reg, u32 data)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
|
||||
iowrite32(data, priv->base + reg);
|
||||
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
static void rcar_thermal_bset(struct rcar_thermal_priv *priv, u32 reg,
|
||||
u32 mask, u32 data)
|
||||
{
|
||||
unsigned long flags;
|
||||
u32 val;
|
||||
|
||||
spin_lock_irqsave(&priv->lock, flags);
|
||||
|
||||
val = ioread32(priv->base + reg);
|
||||
val &= ~mask;
|
||||
val |= (data & mask);
|
||||
iowrite32(val, priv->base + reg);
|
||||
|
||||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
}
|
||||
|
||||
/*
|
||||
* zone device functions
|
||||
*/
|
||||
static int rcar_thermal_get_temp(struct thermal_zone_device *zone,
|
||||
unsigned long *temp)
|
||||
{
|
||||
struct rcar_thermal_priv *priv = zone->devdata;
|
||||
int val, min, max, tmp;
|
||||
|
||||
tmp = -200; /* default */
|
||||
while (1) {
|
||||
if (priv->comp < 1 || priv->comp > 12) {
|
||||
dev_err(priv->dev,
|
||||
"THSSR invalid data (%d)\n", priv->comp);
|
||||
priv->comp = 4; /* for next thermal */
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* THS comparator offset and the reference temperature
|
||||
*
|
||||
* Comparator | reference | Temperature field
|
||||
* offset | temperature | measurement
|
||||
* | (degrees C) | (degrees C)
|
||||
* -------------+---------------+-------------------
|
||||
* 1 | -45 | -45 to -30
|
||||
* 2 | -30 | -30 to -15
|
||||
* 3 | -15 | -15 to 0
|
||||
* 4 | 0 | 0 to +15
|
||||
* 5 | +15 | +15 to +30
|
||||
* 6 | +30 | +30 to +45
|
||||
* 7 | +45 | +45 to +60
|
||||
* 8 | +60 | +60 to +75
|
||||
* 9 | +75 | +75 to +90
|
||||
* 10 | +90 | +90 to +105
|
||||
* 11 | +105 | +105 to +120
|
||||
* 12 | +120 | +120 to +135
|
||||
*/
|
||||
|
||||
/* calculate thermal limitation */
|
||||
min = (priv->comp * 15) - 60;
|
||||
max = min + 15;
|
||||
|
||||
/*
|
||||
* we need to wait 300us after changing comparator offset
|
||||
* to get stable temperature.
|
||||
* see "Usage Notes" on datasheet
|
||||
*/
|
||||
rcar_thermal_bset(priv, THSCR, CPTAP, priv->comp);
|
||||
udelay(300);
|
||||
|
||||
/* calculate current temperature */
|
||||
val = rcar_thermal_read(priv, THSSR) & CTEMP;
|
||||
val = (val * 5) - 65;
|
||||
|
||||
dev_dbg(priv->dev, "comp/min/max/val = %d/%d/%d/%d\n",
|
||||
priv->comp, min, max, val);
|
||||
|
||||
/*
|
||||
* If val is same as min/max, then,
|
||||
* it should try again on next comparator.
|
||||
* But the val might be correct temperature.
|
||||
* Keep it on "tmp" and compare with next val.
|
||||
*/
|
||||
if (tmp == val)
|
||||
break;
|
||||
|
||||
if (val <= min) {
|
||||
tmp = min;
|
||||
priv->comp--; /* try again */
|
||||
} else if (val >= max) {
|
||||
tmp = max;
|
||||
priv->comp++; /* try again */
|
||||
} else {
|
||||
tmp = val;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
*temp = tmp;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct thermal_zone_device_ops rcar_thermal_zone_ops = {
|
||||
.get_temp = rcar_thermal_get_temp,
|
||||
};
|
||||
|
||||
/*
|
||||
* platform functions
|
||||
*/
|
||||
static int rcar_thermal_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct thermal_zone_device *zone;
|
||||
struct rcar_thermal_priv *priv;
|
||||
struct resource *res;
|
||||
int ret;
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
if (!res) {
|
||||
dev_err(&pdev->dev, "Could not get platform resource\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv) {
|
||||
dev_err(&pdev->dev, "Could not allocate priv\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
priv->comp = 4; /* basic setup */
|
||||
priv->dev = &pdev->dev;
|
||||
spin_lock_init(&priv->lock);
|
||||
priv->base = devm_ioremap_nocache(&pdev->dev,
|
||||
res->start, resource_size(res));
|
||||
if (!priv->base) {
|
||||
dev_err(&pdev->dev, "Unable to ioremap thermal register\n");
|
||||
ret = -ENOMEM;
|
||||
goto error_free_priv;
|
||||
}
|
||||
|
||||
zone = thermal_zone_device_register("rcar_thermal", 0, priv,
|
||||
&rcar_thermal_zone_ops, 0, 0);
|
||||
if (IS_ERR(zone)) {
|
||||
dev_err(&pdev->dev, "thermal zone device is NULL\n");
|
||||
ret = PTR_ERR(zone);
|
||||
goto error_iounmap;
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, zone);
|
||||
|
||||
dev_info(&pdev->dev, "proved\n");
|
||||
|
||||
return 0;
|
||||
|
||||
error_iounmap:
|
||||
devm_iounmap(&pdev->dev, priv->base);
|
||||
error_free_priv:
|
||||
devm_kfree(&pdev->dev, priv);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int rcar_thermal_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct thermal_zone_device *zone = platform_get_drvdata(pdev);
|
||||
struct rcar_thermal_priv *priv = zone->devdata;
|
||||
|
||||
thermal_zone_device_unregister(zone);
|
||||
platform_set_drvdata(pdev, NULL);
|
||||
|
||||
devm_iounmap(&pdev->dev, priv->base);
|
||||
devm_kfree(&pdev->dev, priv);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver rcar_thermal_driver = {
|
||||
.driver = {
|
||||
.name = "rcar_thermal",
|
||||
},
|
||||
.probe = rcar_thermal_probe,
|
||||
.remove = rcar_thermal_remove,
|
||||
};
|
||||
module_platform_driver(rcar_thermal_driver);
|
||||
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_DESCRIPTION("R-Car THS/TSC thermal sensor driver");
|
||||
MODULE_AUTHOR("Kuninori Morimoto <[email protected]>");
|
||||
|
|
@ -147,7 +147,7 @@ static int spear_thermal_probe(struct platform_device *pdev)
|
|||
writel_relaxed(stdev->flags, stdev->thermal_base);
|
||||
|
||||
spear_thermal = thermal_zone_device_register("spear_thermal", 0, 0,
|
||||
stdev, &ops, 0, 0, 0, 0);
|
||||
stdev, &ops, 0, 0);
|
||||
if (IS_ERR(spear_thermal)) {
|
||||
dev_err(&pdev->dev, "thermal zone device is NULL\n");
|
||||
ret = PTR_ERR(spear_thermal);
|
||||
|
|
|
|||
|
|
@ -41,15 +41,25 @@ MODULE_AUTHOR("Zhang Rui");
|
|||
MODULE_DESCRIPTION("Generic thermal management sysfs support");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
struct thermal_cooling_device_instance {
|
||||
#define THERMAL_NO_TARGET -1UL
|
||||
/*
|
||||
* This structure is used to describe the behavior of
|
||||
* a certain cooling device on a certain trip point
|
||||
* in a certain thermal zone
|
||||
*/
|
||||
struct thermal_instance {
|
||||
int id;
|
||||
char name[THERMAL_NAME_LENGTH];
|
||||
struct thermal_zone_device *tz;
|
||||
struct thermal_cooling_device *cdev;
|
||||
int trip;
|
||||
unsigned long upper; /* Highest cooling state for this trip point */
|
||||
unsigned long lower; /* Lowest cooling state for this trip point */
|
||||
unsigned long target; /* expected cooling state */
|
||||
char attr_name[THERMAL_NAME_LENGTH];
|
||||
struct device_attribute attr;
|
||||
struct list_head node;
|
||||
struct list_head tz_node; /* node in tz->thermal_instances */
|
||||
struct list_head cdev_node; /* node in cdev->thermal_instances */
|
||||
};
|
||||
|
||||
static DEFINE_IDR(thermal_tz_idr);
|
||||
|
|
@ -308,8 +318,9 @@ passive_store(struct device *dev, struct device_attribute *attr,
|
|||
if (!strncmp("Processor", cdev->type,
|
||||
sizeof("Processor")))
|
||||
thermal_zone_bind_cooling_device(tz,
|
||||
THERMAL_TRIPS_NONE,
|
||||
cdev);
|
||||
THERMAL_TRIPS_NONE, cdev,
|
||||
THERMAL_NO_LIMIT,
|
||||
THERMAL_NO_LIMIT);
|
||||
}
|
||||
mutex_unlock(&thermal_list_lock);
|
||||
if (!tz->passive_delay)
|
||||
|
|
@ -327,9 +338,6 @@ passive_store(struct device *dev, struct device_attribute *attr,
|
|||
tz->passive_delay = 0;
|
||||
}
|
||||
|
||||
tz->tc1 = 1;
|
||||
tz->tc2 = 1;
|
||||
|
||||
tz->forced_passive = state;
|
||||
|
||||
thermal_zone_device_update(tz);
|
||||
|
|
@ -425,10 +433,10 @@ static ssize_t
|
|||
thermal_cooling_device_trip_point_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct thermal_cooling_device_instance *instance;
|
||||
struct thermal_instance *instance;
|
||||
|
||||
instance =
|
||||
container_of(attr, struct thermal_cooling_device_instance, attr);
|
||||
container_of(attr, struct thermal_instance, attr);
|
||||
|
||||
if (instance->trip == THERMAL_TRIPS_NONE)
|
||||
return sprintf(buf, "-1\n");
|
||||
|
|
@ -590,7 +598,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
|
|||
temp->tz = tz;
|
||||
hwmon->count++;
|
||||
|
||||
snprintf(temp->temp_input.name, THERMAL_NAME_LENGTH,
|
||||
snprintf(temp->temp_input.name, sizeof(temp->temp_input.name),
|
||||
"temp%d_input", hwmon->count);
|
||||
temp->temp_input.attr.attr.name = temp->temp_input.name;
|
||||
temp->temp_input.attr.attr.mode = 0444;
|
||||
|
|
@ -603,7 +611,8 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
|
|||
if (tz->ops->get_crit_temp) {
|
||||
unsigned long temperature;
|
||||
if (!tz->ops->get_crit_temp(tz, &temperature)) {
|
||||
snprintf(temp->temp_crit.name, THERMAL_NAME_LENGTH,
|
||||
snprintf(temp->temp_crit.name,
|
||||
sizeof(temp->temp_crit.name),
|
||||
"temp%d_crit", hwmon->count);
|
||||
temp->temp_crit.attr.attr.name = temp->temp_crit.name;
|
||||
temp->temp_crit.attr.attr.mode = 0444;
|
||||
|
|
@ -704,74 +713,6 @@ static void thermal_zone_device_set_polling(struct thermal_zone_device *tz,
|
|||
cancel_delayed_work(&tz->poll_queue);
|
||||
}
|
||||
|
||||
static void thermal_zone_device_passive(struct thermal_zone_device *tz,
|
||||
int temp, int trip_temp, int trip)
|
||||
{
|
||||
int trend = 0;
|
||||
struct thermal_cooling_device_instance *instance;
|
||||
struct thermal_cooling_device *cdev;
|
||||
long state, max_state;
|
||||
|
||||
/*
|
||||
* Above Trip?
|
||||
* -----------
|
||||
* Calculate the thermal trend (using the passive cooling equation)
|
||||
* and modify the performance limit for all passive cooling devices
|
||||
* accordingly. Note that we assume symmetry.
|
||||
*/
|
||||
if (temp >= trip_temp) {
|
||||
tz->passive = true;
|
||||
|
||||
trend = (tz->tc1 * (temp - tz->last_temperature)) +
|
||||
(tz->tc2 * (temp - trip_temp));
|
||||
|
||||
/* Heating up? */
|
||||
if (trend > 0) {
|
||||
list_for_each_entry(instance, &tz->cooling_devices,
|
||||
node) {
|
||||
if (instance->trip != trip)
|
||||
continue;
|
||||
cdev = instance->cdev;
|
||||
cdev->ops->get_cur_state(cdev, &state);
|
||||
cdev->ops->get_max_state(cdev, &max_state);
|
||||
if (state++ < max_state)
|
||||
cdev->ops->set_cur_state(cdev, state);
|
||||
}
|
||||
} else if (trend < 0) { /* Cooling off? */
|
||||
list_for_each_entry(instance, &tz->cooling_devices,
|
||||
node) {
|
||||
if (instance->trip != trip)
|
||||
continue;
|
||||
cdev = instance->cdev;
|
||||
cdev->ops->get_cur_state(cdev, &state);
|
||||
cdev->ops->get_max_state(cdev, &max_state);
|
||||
if (state > 0)
|
||||
cdev->ops->set_cur_state(cdev, --state);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Below Trip?
|
||||
* -----------
|
||||
* Implement passive cooling hysteresis to slowly increase performance
|
||||
* and avoid thrashing around the passive trip point. Note that we
|
||||
* assume symmetry.
|
||||
*/
|
||||
list_for_each_entry(instance, &tz->cooling_devices, node) {
|
||||
if (instance->trip != trip)
|
||||
continue;
|
||||
cdev = instance->cdev;
|
||||
cdev->ops->get_cur_state(cdev, &state);
|
||||
cdev->ops->get_max_state(cdev, &max_state);
|
||||
if (state > 0)
|
||||
cdev->ops->set_cur_state(cdev, --state);
|
||||
if (state == 0)
|
||||
tz->passive = false;
|
||||
}
|
||||
}
|
||||
|
||||
static void thermal_zone_device_check(struct work_struct *work)
|
||||
{
|
||||
struct thermal_zone_device *tz = container_of(work, struct
|
||||
|
|
@ -791,12 +732,14 @@ static void thermal_zone_device_check(struct work_struct *work)
|
|||
*/
|
||||
int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
|
||||
int trip,
|
||||
struct thermal_cooling_device *cdev)
|
||||
struct thermal_cooling_device *cdev,
|
||||
unsigned long upper, unsigned long lower)
|
||||
{
|
||||
struct thermal_cooling_device_instance *dev;
|
||||
struct thermal_cooling_device_instance *pos;
|
||||
struct thermal_instance *dev;
|
||||
struct thermal_instance *pos;
|
||||
struct thermal_zone_device *pos1;
|
||||
struct thermal_cooling_device *pos2;
|
||||
unsigned long max_state;
|
||||
int result;
|
||||
|
||||
if (trip >= tz->trips || (trip < 0 && trip != THERMAL_TRIPS_NONE))
|
||||
|
|
@ -814,13 +757,26 @@ int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
|
|||
if (tz != pos1 || cdev != pos2)
|
||||
return -EINVAL;
|
||||
|
||||
cdev->ops->get_max_state(cdev, &max_state);
|
||||
|
||||
/* 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;
|
||||
|
||||
dev =
|
||||
kzalloc(sizeof(struct thermal_cooling_device_instance), GFP_KERNEL);
|
||||
kzalloc(sizeof(struct thermal_instance), GFP_KERNEL);
|
||||
if (!dev)
|
||||
return -ENOMEM;
|
||||
dev->tz = tz;
|
||||
dev->cdev = cdev;
|
||||
dev->trip = trip;
|
||||
dev->upper = upper;
|
||||
dev->lower = lower;
|
||||
dev->target = THERMAL_NO_TARGET;
|
||||
|
||||
result = get_idr(&tz->idr, &tz->lock, &dev->id);
|
||||
if (result)
|
||||
goto free_mem;
|
||||
|
|
@ -841,13 +797,17 @@ int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz,
|
|||
goto remove_symbol_link;
|
||||
|
||||
mutex_lock(&tz->lock);
|
||||
list_for_each_entry(pos, &tz->cooling_devices, node)
|
||||
mutex_lock(&cdev->lock);
|
||||
list_for_each_entry(pos, &tz->thermal_instances, tz_node)
|
||||
if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
|
||||
result = -EEXIST;
|
||||
break;
|
||||
}
|
||||
if (!result)
|
||||
list_add_tail(&dev->node, &tz->cooling_devices);
|
||||
if (!result) {
|
||||
list_add_tail(&dev->tz_node, &tz->thermal_instances);
|
||||
list_add_tail(&dev->cdev_node, &cdev->thermal_instances);
|
||||
}
|
||||
mutex_unlock(&cdev->lock);
|
||||
mutex_unlock(&tz->lock);
|
||||
|
||||
if (!result)
|
||||
|
|
@ -877,16 +837,20 @@ int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz,
|
|||
int trip,
|
||||
struct thermal_cooling_device *cdev)
|
||||
{
|
||||
struct thermal_cooling_device_instance *pos, *next;
|
||||
struct thermal_instance *pos, *next;
|
||||
|
||||
mutex_lock(&tz->lock);
|
||||
list_for_each_entry_safe(pos, next, &tz->cooling_devices, node) {
|
||||
mutex_lock(&cdev->lock);
|
||||
list_for_each_entry_safe(pos, next, &tz->thermal_instances, tz_node) {
|
||||
if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) {
|
||||
list_del(&pos->node);
|
||||
list_del(&pos->tz_node);
|
||||
list_del(&pos->cdev_node);
|
||||
mutex_unlock(&cdev->lock);
|
||||
mutex_unlock(&tz->lock);
|
||||
goto unbind;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&cdev->lock);
|
||||
mutex_unlock(&tz->lock);
|
||||
|
||||
return -ENODEV;
|
||||
|
|
@ -934,7 +898,7 @@ thermal_cooling_device_register(char *type, void *devdata,
|
|||
struct thermal_zone_device *pos;
|
||||
int result;
|
||||
|
||||
if (strlen(type) >= THERMAL_NAME_LENGTH)
|
||||
if (type && strlen(type) >= THERMAL_NAME_LENGTH)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
if (!ops || !ops->get_max_state || !ops->get_cur_state ||
|
||||
|
|
@ -951,8 +915,11 @@ thermal_cooling_device_register(char *type, void *devdata,
|
|||
return ERR_PTR(result);
|
||||
}
|
||||
|
||||
strcpy(cdev->type, type);
|
||||
strcpy(cdev->type, type ? : "");
|
||||
mutex_init(&cdev->lock);
|
||||
INIT_LIST_HEAD(&cdev->thermal_instances);
|
||||
cdev->ops = ops;
|
||||
cdev->updated = true;
|
||||
cdev->device.class = &thermal_class;
|
||||
cdev->devdata = devdata;
|
||||
dev_set_name(&cdev->device, "cooling_device%d", cdev->id);
|
||||
|
|
@ -1044,6 +1011,136 @@ void thermal_cooling_device_unregister(struct
|
|||
}
|
||||
EXPORT_SYMBOL(thermal_cooling_device_unregister);
|
||||
|
||||
static void thermal_cdev_do_update(struct thermal_cooling_device *cdev)
|
||||
{
|
||||
struct thermal_instance *instance;
|
||||
unsigned long target = 0;
|
||||
|
||||
/* cooling device is updated*/
|
||||
if (cdev->updated)
|
||||
return;
|
||||
|
||||
mutex_lock(&cdev->lock);
|
||||
/* Make sure cdev enters the deepest cooling state */
|
||||
list_for_each_entry(instance, &cdev->thermal_instances, cdev_node) {
|
||||
if (instance->target == THERMAL_NO_TARGET)
|
||||
continue;
|
||||
if (instance->target > target)
|
||||
target = instance->target;
|
||||
}
|
||||
mutex_unlock(&cdev->lock);
|
||||
cdev->ops->set_cur_state(cdev, target);
|
||||
cdev->updated = true;
|
||||
}
|
||||
|
||||
static void thermal_zone_do_update(struct thermal_zone_device *tz)
|
||||
{
|
||||
struct thermal_instance *instance;
|
||||
|
||||
list_for_each_entry(instance, &tz->thermal_instances, tz_node)
|
||||
thermal_cdev_do_update(instance->cdev);
|
||||
}
|
||||
|
||||
/*
|
||||
* Cooling algorithm for both active and passive cooling
|
||||
*
|
||||
* 1. if the temperature is higher than a trip point,
|
||||
* a. if the trend is THERMAL_TREND_RAISING, use higher cooling
|
||||
* state for this trip point
|
||||
* b. if the trend is THERMAL_TREND_DROPPING, use lower cooling
|
||||
* state for this trip point
|
||||
*
|
||||
* 2. if the temperature is lower than a trip point, use lower
|
||||
* cooling state for this trip point
|
||||
*
|
||||
* Note that this behaves the same as the previous passive cooling
|
||||
* algorithm.
|
||||
*/
|
||||
|
||||
static void thermal_zone_trip_update(struct thermal_zone_device *tz,
|
||||
int trip, long temp)
|
||||
{
|
||||
struct thermal_instance *instance;
|
||||
struct thermal_cooling_device *cdev = NULL;
|
||||
unsigned long cur_state, max_state;
|
||||
long trip_temp;
|
||||
enum thermal_trip_type trip_type;
|
||||
enum thermal_trend trend;
|
||||
|
||||
if (trip == THERMAL_TRIPS_NONE) {
|
||||
trip_temp = tz->forced_passive;
|
||||
trip_type = THERMAL_TRIPS_NONE;
|
||||
} else {
|
||||
tz->ops->get_trip_temp(tz, trip, &trip_temp);
|
||||
tz->ops->get_trip_type(tz, trip, &trip_type);
|
||||
}
|
||||
|
||||
if (!tz->ops->get_trend || tz->ops->get_trend(tz, trip, &trend)) {
|
||||
/*
|
||||
* compare the current temperature and previous temperature
|
||||
* to get the thermal trend, if no special requirement
|
||||
*/
|
||||
if (tz->temperature > tz->last_temperature)
|
||||
trend = THERMAL_TREND_RAISING;
|
||||
else if (tz->temperature < tz->last_temperature)
|
||||
trend = THERMAL_TREND_DROPPING;
|
||||
else
|
||||
trend = THERMAL_TREND_STABLE;
|
||||
}
|
||||
|
||||
if (temp >= trip_temp) {
|
||||
list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
|
||||
if (instance->trip != trip)
|
||||
continue;
|
||||
|
||||
cdev = instance->cdev;
|
||||
|
||||
cdev->ops->get_cur_state(cdev, &cur_state);
|
||||
cdev->ops->get_max_state(cdev, &max_state);
|
||||
|
||||
if (trend == THERMAL_TREND_RAISING) {
|
||||
cur_state = cur_state < instance->upper ?
|
||||
(cur_state + 1) : instance->upper;
|
||||
} else if (trend == THERMAL_TREND_DROPPING) {
|
||||
cur_state = cur_state > instance->lower ?
|
||||
(cur_state - 1) : instance->lower;
|
||||
}
|
||||
|
||||
/* activate a passive thermal instance */
|
||||
if ((trip_type == THERMAL_TRIP_PASSIVE ||
|
||||
trip_type == THERMAL_TRIPS_NONE) &&
|
||||
instance->target == THERMAL_NO_TARGET)
|
||||
tz->passive++;
|
||||
|
||||
instance->target = cur_state;
|
||||
cdev->updated = false; /* cooling device needs update */
|
||||
}
|
||||
} else { /* below trip */
|
||||
list_for_each_entry(instance, &tz->thermal_instances, tz_node) {
|
||||
if (instance->trip != trip)
|
||||
continue;
|
||||
|
||||
/* Do not use the inactive thermal instance */
|
||||
if (instance->target == THERMAL_NO_TARGET)
|
||||
continue;
|
||||
cdev = instance->cdev;
|
||||
cdev->ops->get_cur_state(cdev, &cur_state);
|
||||
|
||||
cur_state = cur_state > instance->lower ?
|
||||
(cur_state - 1) : THERMAL_NO_TARGET;
|
||||
|
||||
/* deactivate a passive thermal instance */
|
||||
if ((trip_type == THERMAL_TRIP_PASSIVE ||
|
||||
trip_type == THERMAL_TRIPS_NONE) &&
|
||||
cur_state == THERMAL_NO_TARGET)
|
||||
tz->passive--;
|
||||
instance->target = cur_state;
|
||||
cdev->updated = false; /* cooling device needs update */
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
/**
|
||||
* thermal_zone_device_update - force an update of a thermal zone's state
|
||||
* @ttz: the thermal zone to update
|
||||
|
|
@ -1054,8 +1151,6 @@ void thermal_zone_device_update(struct thermal_zone_device *tz)
|
|||
int count, ret = 0;
|
||||
long temp, trip_temp;
|
||||
enum thermal_trip_type trip_type;
|
||||
struct thermal_cooling_device_instance *instance;
|
||||
struct thermal_cooling_device *cdev;
|
||||
|
||||
mutex_lock(&tz->lock);
|
||||
|
||||
|
|
@ -1065,6 +1160,9 @@ void thermal_zone_device_update(struct thermal_zone_device *tz)
|
|||
goto leave;
|
||||
}
|
||||
|
||||
tz->last_temperature = tz->temperature;
|
||||
tz->temperature = temp;
|
||||
|
||||
for (count = 0; count < tz->trips; count++) {
|
||||
tz->ops->get_trip_type(tz, count, &trip_type);
|
||||
tz->ops->get_trip_temp(tz, count, &trip_temp);
|
||||
|
|
@ -1088,32 +1186,18 @@ void thermal_zone_device_update(struct thermal_zone_device *tz)
|
|||
tz->ops->notify(tz, count, trip_type);
|
||||
break;
|
||||
case THERMAL_TRIP_ACTIVE:
|
||||
list_for_each_entry(instance, &tz->cooling_devices,
|
||||
node) {
|
||||
if (instance->trip != count)
|
||||
continue;
|
||||
|
||||
cdev = instance->cdev;
|
||||
|
||||
if (temp >= trip_temp)
|
||||
cdev->ops->set_cur_state(cdev, 1);
|
||||
else
|
||||
cdev->ops->set_cur_state(cdev, 0);
|
||||
}
|
||||
thermal_zone_trip_update(tz, count, temp);
|
||||
break;
|
||||
case THERMAL_TRIP_PASSIVE:
|
||||
if (temp >= trip_temp || tz->passive)
|
||||
thermal_zone_device_passive(tz, temp,
|
||||
trip_temp, count);
|
||||
thermal_zone_trip_update(tz, count, temp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (tz->forced_passive)
|
||||
thermal_zone_device_passive(tz, temp, tz->forced_passive,
|
||||
THERMAL_TRIPS_NONE);
|
||||
|
||||
tz->last_temperature = temp;
|
||||
thermal_zone_trip_update(tz, THERMAL_TRIPS_NONE, temp);
|
||||
thermal_zone_do_update(tz);
|
||||
|
||||
leave:
|
||||
if (tz->passive)
|
||||
|
|
@ -1236,8 +1320,6 @@ static void remove_trip_attrs(struct thermal_zone_device *tz)
|
|||
* @mask: a bit string indicating the writeablility of trip points
|
||||
* @devdata: private device data
|
||||
* @ops: standard thermal zone device callbacks
|
||||
* @tc1: thermal coefficient 1 for passive calculations
|
||||
* @tc2: thermal coefficient 2 for passive calculations
|
||||
* @passive_delay: number of milliseconds to wait between polls when
|
||||
* performing passive cooling
|
||||
* @polling_delay: number of milliseconds to wait between polls when checking
|
||||
|
|
@ -1245,13 +1327,12 @@ static void remove_trip_attrs(struct thermal_zone_device *tz)
|
|||
* driven systems)
|
||||
*
|
||||
* thermal_zone_device_unregister() must be called when the device is no
|
||||
* longer needed. The passive cooling formula uses tc1 and tc2 as described in
|
||||
* section 11.1.5.1 of the ACPI specification 3.0.
|
||||
* longer needed. The passive cooling depends on the .get_trend() return value.
|
||||
*/
|
||||
struct thermal_zone_device *thermal_zone_device_register(const char *type,
|
||||
int trips, int mask, void *devdata,
|
||||
const struct thermal_zone_device_ops *ops,
|
||||
int tc1, int tc2, int passive_delay, int polling_delay)
|
||||
int passive_delay, int polling_delay)
|
||||
{
|
||||
struct thermal_zone_device *tz;
|
||||
struct thermal_cooling_device *pos;
|
||||
|
|
@ -1260,7 +1341,7 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
|
|||
int count;
|
||||
int passive = 0;
|
||||
|
||||
if (strlen(type) >= THERMAL_NAME_LENGTH)
|
||||
if (type && strlen(type) >= THERMAL_NAME_LENGTH)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips)
|
||||
|
|
@ -1273,7 +1354,7 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
|
|||
if (!tz)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
INIT_LIST_HEAD(&tz->cooling_devices);
|
||||
INIT_LIST_HEAD(&tz->thermal_instances);
|
||||
idr_init(&tz->idr);
|
||||
mutex_init(&tz->lock);
|
||||
result = get_idr(&thermal_tz_idr, &thermal_idr_lock, &tz->id);
|
||||
|
|
@ -1282,13 +1363,11 @@ struct thermal_zone_device *thermal_zone_device_register(const char *type,
|
|||
return ERR_PTR(result);
|
||||
}
|
||||
|
||||
strcpy(tz->type, type);
|
||||
strcpy(tz->type, type ? : "");
|
||||
tz->ops = ops;
|
||||
tz->device.class = &thermal_class;
|
||||
tz->devdata = devdata;
|
||||
tz->trips = trips;
|
||||
tz->tc1 = tc1;
|
||||
tz->tc2 = tc2;
|
||||
tz->passive_delay = passive_delay;
|
||||
tz->polling_delay = polling_delay;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue