diff options
Diffstat (limited to 'drivers/thermal')
28 files changed, 12413 insertions, 0 deletions
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig new file mode 100644 index 00000000..a1d5432e --- /dev/null +++ b/drivers/thermal/Kconfig @@ -0,0 +1,228 @@ +# +# Generic thermal sysfs drivers configuration +# + +menuconfig THERMAL + tristate "Generic Thermal sysfs driver" + help + Generic Thermal Sysfs driver offers a generic mechanism for + thermal management. Usually it's made up of one or more thermal + zone and cooling device. + Each thermal zone contains its own temperature, trip points, + cooling devices. + All platforms with ACPI thermal support can use this driver. + If you want this support, you should say Y or M here. + +if THERMAL + +config THERMAL_HWMON + bool + prompt "Expose thermal sensors as hwmon device" + depends on HWMON=y || HWMON=THERMAL + default y + help + In case a sensor is registered with the thermal + framework, this option will also register it + as a hwmon. The sensor will then have the common + hwmon sysfs interface. + + Say 'Y' here if you want all thermal sensors to + have hwmon sysfs interface too. + +config THERMAL_OF + bool + prompt "APIs to parse thermal data out of device tree" + depends on OF + default y + help + This options provides helpers to add the support to + read and parse thermal data definitions out of the + device tree blob. + + Say 'Y' here if you need to build thermal infrastructure + based on device tree. + +choice + prompt "Default Thermal governor" + default THERMAL_DEFAULT_GOV_STEP_WISE + help + This option sets which thermal governor shall be loaded at + startup. If in doubt, select 'step_wise'. + +config THERMAL_DEFAULT_GOV_STEP_WISE + bool "step_wise" + select THERMAL_GOV_STEP_WISE + help + Use the step_wise governor as default. This throttles the + devices one step at a time. + +config THERMAL_DEFAULT_GOV_FAIR_SHARE + bool "fair_share" + select THERMAL_GOV_FAIR_SHARE + help + Use the fair_share governor as default. This throttles the + devices based on their 'contribution' to a zone. The + contribution should be provided through platform data. + +config THERMAL_DEFAULT_GOV_USER_SPACE + bool "user_space" + select THERMAL_GOV_USER_SPACE + help + Select this if you want to let the user space manage the + lpatform thermals. + +endchoice + +config THERMAL_GOV_FAIR_SHARE + bool "Fair-share thermal governor" + help + Enable this to manage platform thermals using fair-share governor. + +config THERMAL_GOV_STEP_WISE + bool "Step_wise thermal governor" + help + Enable this to manage platform thermals using a simple linear + +config THERMAL_GOV_USER_SPACE + bool "User_space thermal governor" + help + Enable this to let the user space manage the platform thermals. + +config CPU_THERMAL + bool "generic cpu cooling support" + depends on CPU_FREQ + depends on THERMAL_OF + select CPU_FREQ_TABLE + help + This implements the generic cpu cooling mechanism through frequency + reduction. 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 THERMAL_EMULATION + bool "Thermal emulation mode support" + help + Enable this option to make a emul_temp sysfs node in thermal zone + directory to support temperature emulation. With emulation sysfs node, + user can manually input temperature and test the different trip + threshold behaviour for simulation purpose. + + WARNING: Be careful while enabling this option on production systems, + because userland can easily disable the thermal policy by simply + flooding this sysfs node with low temperature values. + +config SPEAR_THERMAL + bool "SPEAr thermal sensor driver" + depends on PLAT_SPEAR + depends on OF + 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 ARCH_SHMOBILE + help + Enable this to plug the R-Car thermal sensor driver into the Linux + thermal framework + +config KIRKWOOD_THERMAL + tristate "Temperature sensor on Marvell Kirkwood SoCs" + depends on ARCH_KIRKWOOD + depends on OF + help + Support for the Kirkwood thermal sensor driver into the Linux thermal + framework. Only kirkwood 88F6282 and 88F6283 have this sensor. + +config EXYNOS_THERMAL + tristate "Temperature sensor on Samsung EXYNOS" + depends on (ARCH_EXYNOS4 || ARCH_EXYNOS5) + depends on CPU_THERMAL + help + If you say yes here you get support for TMU (Thermal Management + Unit) on SAMSUNG EXYNOS series of SoC. + +config DOVE_THERMAL + tristate "Temperature sensor on Marvell Dove SoCs" + depends on ARCH_DOVE + depends on OF + help + Support for the Dove thermal sensor driver in the Linux thermal + framework. + +config DB8500_THERMAL + bool "DB8500 thermal management" + depends on ARCH_U8500 + default y + help + Adds DB8500 thermal management implementation according to the thermal + management framework. A thermal zone with several trip points will be + created. Cooling devices can be bound to the trip points to cool this + thermal zone if trip points reached. + +config ARMADA_THERMAL + tristate "Armada 370/XP thermal management" + depends on ARCH_MVEBU + depends on OF + help + Enable this option if you want to have support for thermal management + controller present in Armada 370 and Armada XP SoC. + +config DB8500_CPUFREQ_COOLING + tristate "DB8500 cpufreq cooling" + depends on ARCH_U8500 + depends on CPU_THERMAL + default y + help + Adds DB8500 cpufreq cooling devices, and these cooling devices can be + bound to thermal zone trip points. When a trip point reached, the + bound cpufreq cooling device turns active to set CPU frequency low to + cool down the CPU. + +config INTEL_POWERCLAMP + tristate "Intel PowerClamp idle injection driver" + depends on THERMAL + depends on X86 + depends on CPU_SUP_INTEL + help + Enable this to enable Intel PowerClamp idle injection driver. This + enforce idle time which results in more package C-state residency. The + user interface is exposed via generic thermal framework. + +config THERMAL_DDIE + bool "thermal ddie" + depends on THERMAL + help + Use the 2713s thermal system. +config THERMAL_SC2723S_PMIC + bool "thermal pmic" + depends on THERMAL + help + Use the 2713s thermal system. +config THERMAL_SC2713 + bool "thermal 2713" + depends on THERMAL + help + Choose the 2713 thermal system. + +config SPRD_CPU_COOLING + bool "sprd cpu cooling devices" + depends on THERMAL + help + Choose sprd cpu cooling devices. + +config THERMAL_BOARD_SENSOR + bool "thermal board sensor" + depends on THERMAL + help + the board thermal system +config THERMAL_ALONE_DDIE + bool "thermal alone ddie" + depends on THERMAL + help + the thermal system + +endif diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile new file mode 100644 index 00000000..2c5cba13 --- /dev/null +++ b/drivers/thermal/Makefile @@ -0,0 +1,38 @@ +# +# Makefile for sensor chip drivers. +# + +obj-$(CONFIG_THERMAL) += thermal_sys.o +obj-$(CONFIG_THERMAL) += sprd_thm.o +thermal_sys-y += thermal_core.o + +# interface to/from other layers providing sensors +thermal_sys-$(CONFIG_THERMAL_HWMON) += thermal_hwmon.o +thermal_sys-$(CONFIG_THERMAL_OF) += of-thermal.o + +# governors +thermal_sys-$(CONFIG_THERMAL_GOV_FAIR_SHARE) += fair_share.o +thermal_sys-$(CONFIG_THERMAL_GOV_STEP_WISE) += step_wise.o +thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE) += user_space.o + +# cpufreq cooling +thermal_sys-$(CONFIG_CPU_THERMAL) += cpu_cooling.o +obj-$(CONFIG_SPRD_CPU_COOLING) += sprd_cpu_cooling.o + +# platform thermal drivers +obj-$(CONFIG_SPEAR_THERMAL) += spear_thermal.o +obj-$(CONFIG_RCAR_THERMAL) += rcar_thermal.o +obj-$(CONFIG_KIRKWOOD_THERMAL) += kirkwood_thermal.o +obj-$(CONFIG_EXYNOS_THERMAL) += exynos_thermal.o +obj-$(CONFIG_DOVE_THERMAL) += dove_thermal.o +obj-$(CONFIG_DB8500_THERMAL) += db8500_thermal.o +obj-$(CONFIG_ARMADA_THERMAL) += armada_thermal.o +obj-$(CONFIG_DB8500_CPUFREQ_COOLING) += db8500_cpufreq_cooling.o +obj-$(CONFIG_INTEL_POWERCLAMP) += intel_powerclamp.o + +# Added for different sprd thm +obj-$(CONFIG_THERMAL_DDIE) += sprd_ddie_thm.o +obj-$(CONFIG_THERMAL_ALONE_DDIE) += sprd_ddie_alone_thm.o +obj-$(CONFIG_THERMAL_SC2713) += sprd_2713_thm.o +obj-$(CONFIG_THERMAL_SC2723S_PMIC) += sprd_pmic_2723s_thm.o +obj-$(CONFIG_THERMAL_BOARD_SENSOR) += sprd_board_sensor.o diff --git a/drivers/thermal/armada_thermal.c b/drivers/thermal/armada_thermal.c new file mode 100644 index 00000000..54ffd64c --- /dev/null +++ b/drivers/thermal/armada_thermal.c @@ -0,0 +1,222 @@ +/* + * Marvell Armada 370/XP thermal sensor driver + * + * Copyright (C) 2013 Marvell + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + * + */ +#include <linux/device.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/kernel.h> +#include <linux/of.h> +#include <linux/module.h> +#include <linux/delay.h> +#include <linux/platform_device.h> +#include <linux/of_device.h> +#include <linux/thermal.h> + +#define THERMAL_VALID_OFFSET 9 +#define THERMAL_VALID_MASK 0x1 +#define THERMAL_TEMP_OFFSET 10 +#define THERMAL_TEMP_MASK 0x1ff + +/* Thermal Manager Control and Status Register */ +#define PMU_TDC0_SW_RST_MASK (0x1 << 1) +#define PMU_TM_DISABLE_OFFS 0 +#define PMU_TM_DISABLE_MASK (0x1 << PMU_TM_DISABLE_OFFS) +#define PMU_TDC0_REF_CAL_CNT_OFFS 11 +#define PMU_TDC0_REF_CAL_CNT_MASK (0x1ff << PMU_TDC0_REF_CAL_CNT_OFFS) +#define PMU_TDC0_OTF_CAL_MASK (0x1 << 30) +#define PMU_TDC0_START_CAL_MASK (0x1 << 25) + +struct armada_thermal_ops; + +/* Marvell EBU Thermal Sensor Dev Structure */ +struct armada_thermal_priv { + void __iomem *sensor; + void __iomem *control; + struct armada_thermal_ops *ops; +}; + +struct armada_thermal_ops { + /* Initialize the sensor */ + void (*init_sensor)(struct armada_thermal_priv *); + + /* Test for a valid sensor value (optional) */ + bool (*is_valid)(struct armada_thermal_priv *); +}; + +static void armadaxp_init_sensor(struct armada_thermal_priv *priv) +{ + unsigned long reg; + + reg = readl_relaxed(priv->control); + reg |= PMU_TDC0_OTF_CAL_MASK; + writel(reg, priv->control); + + /* Reference calibration value */ + reg &= ~PMU_TDC0_REF_CAL_CNT_MASK; + reg |= (0xf1 << PMU_TDC0_REF_CAL_CNT_OFFS); + writel(reg, priv->control); + + /* Reset the sensor */ + reg = readl_relaxed(priv->control); + writel((reg | PMU_TDC0_SW_RST_MASK), priv->control); + + writel(reg, priv->control); + + /* Enable the sensor */ + reg = readl_relaxed(priv->sensor); + reg &= ~PMU_TM_DISABLE_MASK; + writel(reg, priv->sensor); +} + +static void armada370_init_sensor(struct armada_thermal_priv *priv) +{ + unsigned long reg; + + reg = readl_relaxed(priv->control); + reg |= PMU_TDC0_OTF_CAL_MASK; + writel(reg, priv->control); + + /* Reference calibration value */ + reg &= ~PMU_TDC0_REF_CAL_CNT_MASK; + reg |= (0xf1 << PMU_TDC0_REF_CAL_CNT_OFFS); + writel(reg, priv->control); + + reg &= ~PMU_TDC0_START_CAL_MASK; + writel(reg, priv->control); + + mdelay(10); +} + +static bool armada_is_valid(struct armada_thermal_priv *priv) +{ + unsigned long reg = readl_relaxed(priv->sensor); + + return (reg >> THERMAL_VALID_OFFSET) & THERMAL_VALID_MASK; +} + +static int armada_get_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + struct armada_thermal_priv *priv = thermal->devdata; + unsigned long reg; + + /* Valid check */ + if (priv->ops->is_valid && !priv->ops->is_valid(priv)) { + dev_err(&thermal->device, + "Temperature sensor reading not valid\n"); + return -EIO; + } + + reg = readl_relaxed(priv->sensor); + reg = (reg >> THERMAL_TEMP_OFFSET) & THERMAL_TEMP_MASK; + *temp = (3153000000UL - (10000000UL*reg)) / 13825; + return 0; +} + +static struct thermal_zone_device_ops ops = { + .get_temp = armada_get_temp, +}; + +static const struct armada_thermal_ops armadaxp_ops = { + .init_sensor = armadaxp_init_sensor, +}; + +static const struct armada_thermal_ops armada370_ops = { + .is_valid = armada_is_valid, + .init_sensor = armada370_init_sensor, +}; + +static const struct of_device_id armada_thermal_id_table[] = { + { + .compatible = "marvell,armadaxp-thermal", + .data = &armadaxp_ops, + }, + { + .compatible = "marvell,armada370-thermal", + .data = &armada370_ops, + }, + { + /* sentinel */ + }, +}; +MODULE_DEVICE_TABLE(of, armada_thermal_id_table); + +static int armada_thermal_probe(struct platform_device *pdev) +{ + struct thermal_zone_device *thermal; + const struct of_device_id *match; + struct armada_thermal_priv *priv; + struct resource *res; + + match = of_match_device(armada_thermal_id_table, &pdev->dev); + if (!match) + return -ENODEV; + + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + priv->sensor = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(priv->sensor)) + return PTR_ERR(priv->sensor); + + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + priv->control = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(priv->control)) + return PTR_ERR(priv->control); + + priv->ops = (struct armada_thermal_ops *)match->data; + priv->ops->init_sensor(priv); + + thermal = thermal_zone_device_register("armada_thermal", 0, 0, + priv, &ops, NULL, 0, 0); + if (IS_ERR(thermal)) { + dev_err(&pdev->dev, + "Failed to register thermal zone device\n"); + return PTR_ERR(thermal); + } + + platform_set_drvdata(pdev, thermal); + + return 0; +} + +static int armada_thermal_exit(struct platform_device *pdev) +{ + struct thermal_zone_device *armada_thermal = + platform_get_drvdata(pdev); + + thermal_zone_device_unregister(armada_thermal); + platform_set_drvdata(pdev, NULL); + + return 0; +} + +static struct platform_driver armada_thermal_driver = { + .probe = armada_thermal_probe, + .remove = armada_thermal_exit, + .driver = { + .name = "armada_thermal", + .owner = THIS_MODULE, + .of_match_table = of_match_ptr(armada_thermal_id_table), + }, +}; + +module_platform_driver(armada_thermal_driver); + +MODULE_AUTHOR("Ezequiel Garcia <ezequiel.garcia@free-electrons.com>"); +MODULE_DESCRIPTION("Armada 370/XP thermal driver"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/thermal/cpu_cooling.c b/drivers/thermal/cpu_cooling.c new file mode 100644 index 00000000..4246262c --- /dev/null +++ b/drivers/thermal/cpu_cooling.c @@ -0,0 +1,571 @@ +/* + * 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/module.h> +#include <linux/thermal.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 - data for cooling device with cpufreq + * @id: unique integer value corresponding to each cpufreq_cooling_device + * registered. + * @cool_dev: thermal_cooling_device pointer to keep track of the + * registered 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. + * + * This structure is required for keeping information of each + * cpufreq_cooling_device registered. In order to prevent corruption of this 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; +}; +static DEFINE_IDR(cpufreq_idr); +static DEFINE_MUTEX(cooling_cpufreq_lock); + +static unsigned int cpufreq_dev_count; + +/* notify_table passes value to the CPUFREQ_ADJUST callback function. */ +#define NOTIFY_INVALID NULL +static 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. + * + * This function will populate @id with an unique + * id, using the idr API. + * + * Return: 0 on success, an error code on failure. + */ +static int get_idr(struct idr *idr, int *id) +{ + int ret; + + mutex_lock(&cooling_cpufreq_lock); + ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL); + mutex_unlock(&cooling_cpufreq_lock); + if (unlikely(ret < 0)) + return ret; + *id = ret; + + 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 frequency transitioning capability. + * @cpu: cpu for which check is needed. + * + * This function will check the current state of the system if + * it is capable of changing the frequency for a given @cpu. + * + * Return: 0 if the system is not currently capable of changing + * the frequency of given cpu. !0 in case the frequency is changeable. + */ +static int is_cpufreq_valid(int cpu) +{ + struct cpufreq_policy policy; + + return !cpufreq_get_policy(&policy, cpu); +} + +enum cpufreq_cooling_property { + GET_LEVEL, + GET_FREQ, + GET_MAXL, +}; + +/** + * get_property - fetch a property of interest for a give cpu. + * @cpu: cpu for which the property is required + * @input: query parameter + * @output: query return + * @property: type of query (frequency, level, max level) + * + * This is the common function to + * 1. get maximum cpu cooling states + * 2. translate frequency to cooling state + * 3. translate cooling state to frequency + * Note that the code may be not in good shape + * but it is written in this way in order to: + * a) reduce duplicate code as most of the code can be shared. + * b) make sure the logic is consistent when translating between + * cooling states and frequencies. + * + * Return: 0 on success, -EINVAL when invalid parameters are passed. + */ +static int get_property(unsigned int cpu, unsigned long input, + unsigned int *output, + enum cpufreq_cooling_property property) +{ + int i, j; + unsigned long max_level = 0, level = 0; + unsigned int freq = CPUFREQ_ENTRY_INVALID; + int descend = -1; + struct cpufreq_frequency_table *table = + cpufreq_frequency_get_table(cpu); + + if (!output) + return -EINVAL; + + if (!table) + return -EINVAL; + + for (i = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) { + /* ignore invalid entries */ + if (table[i].frequency == CPUFREQ_ENTRY_INVALID) + continue; + + /* ignore duplicate entry */ + if (freq == table[i].frequency) + continue; + + /* get the frequency order */ + if (freq != CPUFREQ_ENTRY_INVALID && descend == -1) + descend = !!(freq > table[i].frequency); + + freq = table[i].frequency; + max_level++; + } + + /* No valid cpu frequency entry */ + if (max_level == 0) + return -EINVAL; + + /* max_level is an index, not a counter */ + max_level--; + + /* get max level */ + if (property == GET_MAXL) { + *output = (unsigned int)max_level; + return 0; + } + + if (property == GET_FREQ) + level = descend ? input : (max_level - input); + + for (i = 0, j = 0; table[i].frequency != CPUFREQ_TABLE_END; i++) { + /* ignore invalid entry */ + if (table[i].frequency == CPUFREQ_ENTRY_INVALID) + continue; + + /* ignore duplicate entry */ + if (freq == table[i].frequency) + continue; + + /* now we have a valid frequency entry */ + freq = table[i].frequency; + + if (property == GET_LEVEL && (unsigned int)input == freq) { + /* get level by frequency */ + *output = descend ? j : (max_level - j); + return 0; + } + if (property == GET_FREQ && level == j) { + /* get frequency by level */ + *output = freq; + return 0; + } + j++; + } + + return -EINVAL; +} + +/** + * cpufreq_cooling_get_level - for a give cpu, return the cooling level. + * @cpu: cpu for which the level is required + * @freq: the frequency of interest + * + * This function will match the cooling level corresponding to the + * requested @freq and return it. + * + * Return: The matched cooling level on success or THERMAL_CSTATE_INVALID + * otherwise. + */ +unsigned long cpufreq_cooling_get_level(unsigned int cpu, unsigned int freq) +{ + unsigned int val; + + if (get_property(cpu, (unsigned long)freq, &val, GET_LEVEL)) + return THERMAL_CSTATE_INVALID; + + return (unsigned long)val; +} +EXPORT_SYMBOL_GPL(cpufreq_cooling_get_level); + +/** + * get_cpu_frequency - get the absolute value of frequency from level. + * @cpu: cpu for which frequency is fetched. + * @level: cooling level + * + * This function matches cooling level with frequency. Based on a cooling level + * of frequency, equals cooling state of cpu cooling device, it will return + * the corresponding frequency. + * e.g level=0 --> 1st MAX FREQ, level=1 ---> 2nd MAX FREQ, .... etc + * + * Return: 0 on error, the corresponding frequency otherwise. + */ +static unsigned int get_cpu_frequency(unsigned int cpu, unsigned long level) +{ + int ret = 0; + unsigned int freq; + + ret = get_property(cpu, level, &freq, GET_FREQ); + if (ret) + return 0; + + return freq; +} + +/** + * 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. + * + * Function used to make sure the cpufreq layer is aware of current thermal + * limits. The limits are applied by updating the cpufreq policy. + * + * Return: 0 on success, an error code otherwise (-EINVAL in case wrong + * cooling state). + */ +static int cpufreq_apply_cooling(struct cpufreq_cooling_device *cpufreq_device, + unsigned long cooling_state) +{ + unsigned int cpuid, clip_freq; + struct cpumask *mask = &cpufreq_device->allowed_cpus; + unsigned int cpu = cpumask_any(mask); + + + /* 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, mask) { + 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 + * + * Callback to highjack the notification on cpufreq policy transition. + * Every time there is a change in policy, we will intercept and + * update the cpufreq policy with thermal constraints. + * + * Return: 0 (success) + */ +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; + else + return 0; + + /* 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. + * + * Callback for the thermal cooling device to return the cpufreq + * max cooling state. + * + * Return: 0 on success, an error code otherwise. + */ +static int cpufreq_get_max_state(struct thermal_cooling_device *cdev, + unsigned long *state) +{ + struct cpufreq_cooling_device *cpufreq_device = cdev->devdata; + struct cpumask *mask = &cpufreq_device->allowed_cpus; + unsigned int cpu; + unsigned int count = 0; + int ret; + + cpu = cpumask_any(mask); + + ret = get_property(cpu, 0, &count, GET_MAXL); + + if (count > 0) + *state = count; + + 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. + * + * Callback for the thermal cooling device to return the cpufreq + * current cooling state. + * + * Return: 0 on success, an error code otherwise. + */ +static int cpufreq_get_cur_state(struct thermal_cooling_device *cdev, + unsigned long *state) +{ + struct cpufreq_cooling_device *cpufreq_device = cdev->devdata; + + *state = cpufreq_device->cpufreq_state; + + return 0; +} + +/** + * 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. + * + * Callback for the thermal cooling device to change the cpufreq + * current cooling state. + * + * Return: 0 on success, an error code otherwise. + */ +static int cpufreq_set_cur_state(struct thermal_cooling_device *cdev, + unsigned long state) +{ + struct cpufreq_cooling_device *cpufreq_device = cdev->devdata; + + return cpufreq_apply_cooling(cpufreq_device, state); +} + +/* 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 - helper function to create cpufreq cooling device + * @np: a valid struct device_node to the cooling device device tree node + * @clip_cpus: cpumask of cpus where the frequency constraints will happen. + * + * This interface function registers the cpufreq cooling device with the name + * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq + * cooling devices. It also gives the opportunity to link the cooling device + * with a device tree node, in order to bind it via the thermal DT code. + * + * Return: a valid struct thermal_cooling_device pointer on success, + * on failure, it returns a corresponding ERR_PTR(). + */ +static struct thermal_cooling_device * +__cpufreq_cooling_register(struct device_node *np, + const struct cpumask *clip_cpus) +{ + struct thermal_cooling_device *cool_dev; + struct cpufreq_cooling_device *cpufreq_dev = NULL; + unsigned int min = 0, max = 0; + char dev_name[THERMAL_NAME_LENGTH]; + int ret = 0, i; + struct cpufreq_policy policy; + + /* 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); + + ret = get_idr(&cpufreq_idr, &cpufreq_dev->id); + if (ret) { + kfree(cpufreq_dev); + return ERR_PTR(-EINVAL); + } + + snprintf(dev_name, sizeof(dev_name), "thermal-cpufreq-%d", + cpufreq_dev->id); + + cool_dev = thermal_of_cooling_device_register(np, dev_name, cpufreq_dev, + &cpufreq_cooling_ops); + if (IS_ERR(cool_dev)) { + release_idr(&cpufreq_idr, cpufreq_dev->id); + kfree(cpufreq_dev); + return cool_dev; + } + cpufreq_dev->cool_dev = cool_dev; + cpufreq_dev->cpufreq_state = 0; + mutex_lock(&cooling_cpufreq_lock); + + /* Register the notifier for first cpufreq cooling device */ + if (cpufreq_dev_count == 0) + cpufreq_register_notifier(&thermal_cpufreq_notifier_block, + CPUFREQ_POLICY_NOTIFIER); + cpufreq_dev_count++; + + mutex_unlock(&cooling_cpufreq_lock); + + return cool_dev; +} + +/** + * cpufreq_cooling_register - function to create cpufreq cooling device. + * @clip_cpus: cpumask of cpus where the frequency constraints will happen. + * + * This interface function registers the cpufreq cooling device with the name + * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq + * cooling devices. + * + * Return: a valid struct thermal_cooling_device pointer on success, + * on failure, it returns a corresponding ERR_PTR(). + */ +struct thermal_cooling_device * +cpufreq_cooling_register(const struct cpumask *clip_cpus) +{ + return __cpufreq_cooling_register(NULL, clip_cpus); +} +EXPORT_SYMBOL_GPL(cpufreq_cooling_register); + +/** + * of_cpufreq_cooling_register - function to create cpufreq cooling device. + * @np: a valid struct device_node to the cooling device device tree node + * @clip_cpus: cpumask of cpus where the frequency constraints will happen. + * + * This interface function registers the cpufreq cooling device with the name + * "thermal-cpufreq-%x". This api can support multiple instances of cpufreq + * cooling devices. Using this API, the cpufreq cooling device will be + * linked to the device tree node provided. + * + * Return: a valid struct thermal_cooling_device pointer on success, + * on failure, it returns a corresponding ERR_PTR(). + */ +struct thermal_cooling_device * +of_cpufreq_cooling_register(struct device_node *np, + const struct cpumask *clip_cpus) +{ + if (!np) + return ERR_PTR(-EINVAL); + + return __cpufreq_cooling_register(np, clip_cpus); +} +EXPORT_SYMBOL_GPL(of_cpufreq_cooling_register); + +/** + * cpufreq_cooling_unregister - function to remove cpufreq cooling device. + * @cdev: thermal cooling device pointer. + * + * This interface function unregisters the "thermal-cpufreq-%x" cooling device. + */ +void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev) +{ + struct cpufreq_cooling_device *cpufreq_dev; + + if (!cdev) + return; + + cpufreq_dev = cdev->devdata; + mutex_lock(&cooling_cpufreq_lock); + cpufreq_dev_count--; + + /* Unregister the notifier for the last cpufreq cooling device */ + if (cpufreq_dev_count == 0) + 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); + kfree(cpufreq_dev); +} +EXPORT_SYMBOL_GPL(cpufreq_cooling_unregister); diff --git a/drivers/thermal/db8500_cpufreq_cooling.c b/drivers/thermal/db8500_cpufreq_cooling.c new file mode 100644 index 00000000..786d1926 --- /dev/null +++ b/drivers/thermal/db8500_cpufreq_cooling.c @@ -0,0 +1,107 @@ +/* + * db8500_cpufreq_cooling.c - DB8500 cpufreq works as cooling device. + * + * Copyright (C) 2012 ST-Ericsson + * Copyright (C) 2012 Linaro Ltd. + * + * Author: Hongbo Zhang <hongbo.zhang@linaro.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; 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. + */ + +#include <linux/cpu_cooling.h> +#include <linux/cpufreq.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/platform_device.h> +#include <linux/slab.h> + +static int db8500_cpufreq_cooling_probe(struct platform_device *pdev) +{ + struct thermal_cooling_device *cdev; + struct cpumask mask_val; + + /* make sure cpufreq driver has been initialized */ + if (!cpufreq_frequency_get_table(0)) + return -EPROBE_DEFER; + + cpumask_set_cpu(0, &mask_val); + cdev = cpufreq_cooling_register(&mask_val); + + if (IS_ERR(cdev)) { + dev_err(&pdev->dev, "Failed to register cooling device\n"); + return PTR_ERR(cdev); + } + + platform_set_drvdata(pdev, cdev); + + dev_info(&pdev->dev, "Cooling device registered: %s\n", cdev->type); + + return 0; +} + +static int db8500_cpufreq_cooling_remove(struct platform_device *pdev) +{ + struct thermal_cooling_device *cdev = platform_get_drvdata(pdev); + + cpufreq_cooling_unregister(cdev); + + return 0; +} + +static int db8500_cpufreq_cooling_suspend(struct platform_device *pdev, + pm_message_t state) +{ + return -ENOSYS; +} + +static int db8500_cpufreq_cooling_resume(struct platform_device *pdev) +{ + return -ENOSYS; +} + +#ifdef CONFIG_OF +static const struct of_device_id db8500_cpufreq_cooling_match[] = { + { .compatible = "stericsson,db8500-cpufreq-cooling" }, + {}, +}; +#endif + +static struct platform_driver db8500_cpufreq_cooling_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "db8500-cpufreq-cooling", + .of_match_table = of_match_ptr(db8500_cpufreq_cooling_match), + }, + .probe = db8500_cpufreq_cooling_probe, + .suspend = db8500_cpufreq_cooling_suspend, + .resume = db8500_cpufreq_cooling_resume, + .remove = db8500_cpufreq_cooling_remove, +}; + +static int __init db8500_cpufreq_cooling_init(void) +{ + return platform_driver_register(&db8500_cpufreq_cooling_driver); +} + +static void __exit db8500_cpufreq_cooling_exit(void) +{ + platform_driver_unregister(&db8500_cpufreq_cooling_driver); +} + +/* Should be later than db8500_cpufreq_register */ +late_initcall(db8500_cpufreq_cooling_init); +module_exit(db8500_cpufreq_cooling_exit); + +MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>"); +MODULE_DESCRIPTION("DB8500 cpufreq cooling driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/thermal/db8500_thermal.c b/drivers/thermal/db8500_thermal.c new file mode 100644 index 00000000..1e3b3bf9 --- /dev/null +++ b/drivers/thermal/db8500_thermal.c @@ -0,0 +1,534 @@ +/* + * db8500_thermal.c - DB8500 Thermal Management Implementation + * + * Copyright (C) 2012 ST-Ericsson + * Copyright (C) 2012 Linaro Ltd. + * + * Author: Hongbo Zhang <hongbo.zhang@linaro.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; 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. + */ + +#include <linux/cpu_cooling.h> +#include <linux/interrupt.h> +#include <linux/mfd/dbx500-prcmu.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/platform_data/db8500_thermal.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/thermal.h> + +#define PRCMU_DEFAULT_MEASURE_TIME 0xFFF +#define PRCMU_DEFAULT_LOW_TEMP 0 + +struct db8500_thermal_zone { + struct thermal_zone_device *therm_dev; + struct mutex th_lock; + struct work_struct therm_work; + struct db8500_thsens_platform_data *trip_tab; + enum thermal_device_mode mode; + enum thermal_trend trend; + unsigned long cur_temp_pseudo; + unsigned int cur_index; +}; + +/* Local function to check if thermal zone matches cooling devices */ +static int db8500_thermal_match_cdev(struct thermal_cooling_device *cdev, + struct db8500_trip_point *trip_point) +{ + int i; + + if (!strlen(cdev->type)) + return -EINVAL; + + for (i = 0; i < COOLING_DEV_MAX; i++) { + if (!strcmp(trip_point->cdev_name[i], cdev->type)) + return 0; + } + + return -ENODEV; +} + +/* Callback to bind cooling device to thermal zone */ +static int db8500_cdev_bind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + unsigned long max_state, upper, lower; + int i, ret = -EINVAL; + + cdev->ops->get_max_state(cdev, &max_state); + + for (i = 0; i < ptrips->num_trips; i++) { + if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i])) + continue; + + upper = lower = i > max_state ? max_state : i; + + ret = thermal_zone_bind_cooling_device(thermal, i, cdev, + upper, lower); + + dev_info(&cdev->device, "%s bind to %d: %d-%s\n", cdev->type, + i, ret, ret ? "fail" : "succeed"); + } + + return ret; +} + +/* Callback to unbind cooling device from thermal zone */ +static int db8500_cdev_unbind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + int i, ret = -EINVAL; + + for (i = 0; i < ptrips->num_trips; i++) { + if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i])) + continue; + + ret = thermal_zone_unbind_cooling_device(thermal, i, cdev); + + dev_info(&cdev->device, "%s unbind from %d: %s\n", cdev->type, + i, ret ? "fail" : "succeed"); + } + + return ret; +} + +/* Callback to get current temperature */ +static int db8500_sys_get_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + + /* + * TODO: There is no PRCMU interface to get temperature data currently, + * so a pseudo temperature is returned , it works for thermal framework + * and this will be fixed when the PRCMU interface is available. + */ + *temp = pzone->cur_temp_pseudo; + + return 0; +} + +/* Callback to get temperature changing trend */ +static int db8500_sys_get_trend(struct thermal_zone_device *thermal, + int trip, enum thermal_trend *trend) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + + *trend = pzone->trend; + + return 0; +} + +/* Callback to get thermal zone mode */ +static int db8500_sys_get_mode(struct thermal_zone_device *thermal, + enum thermal_device_mode *mode) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + + mutex_lock(&pzone->th_lock); + *mode = pzone->mode; + mutex_unlock(&pzone->th_lock); + + return 0; +} + +/* Callback to set thermal zone mode */ +static int db8500_sys_set_mode(struct thermal_zone_device *thermal, + enum thermal_device_mode mode) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + + mutex_lock(&pzone->th_lock); + + pzone->mode = mode; + if (mode == THERMAL_DEVICE_ENABLED) + schedule_work(&pzone->therm_work); + + mutex_unlock(&pzone->th_lock); + + return 0; +} + +/* Callback to get trip point type */ +static int db8500_sys_get_trip_type(struct thermal_zone_device *thermal, + int trip, enum thermal_trip_type *type) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + + if (trip >= ptrips->num_trips) + return -EINVAL; + + *type = ptrips->trip_points[trip].type; + + return 0; +} + +/* Callback to get trip point temperature */ +static int db8500_sys_get_trip_temp(struct thermal_zone_device *thermal, + int trip, unsigned long *temp) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + + if (trip >= ptrips->num_trips) + return -EINVAL; + + *temp = ptrips->trip_points[trip].temp; + + return 0; +} + +/* Callback to get critical trip point temperature */ +static int db8500_sys_get_crit_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + struct db8500_thermal_zone *pzone = thermal->devdata; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + int i; + + for (i = ptrips->num_trips - 1; i > 0; i--) { + if (ptrips->trip_points[i].type == THERMAL_TRIP_CRITICAL) { + *temp = ptrips->trip_points[i].temp; + return 0; + } + } + + return -EINVAL; +} + +static struct thermal_zone_device_ops thdev_ops = { + .bind = db8500_cdev_bind, + .unbind = db8500_cdev_unbind, + .get_temp = db8500_sys_get_temp, + .get_trend = db8500_sys_get_trend, + .get_mode = db8500_sys_get_mode, + .set_mode = db8500_sys_set_mode, + .get_trip_type = db8500_sys_get_trip_type, + .get_trip_temp = db8500_sys_get_trip_temp, + .get_crit_temp = db8500_sys_get_crit_temp, +}; + +static void db8500_thermal_update_config(struct db8500_thermal_zone *pzone, + unsigned int idx, enum thermal_trend trend, + unsigned long next_low, unsigned long next_high) +{ + prcmu_stop_temp_sense(); + + pzone->cur_index = idx; + pzone->cur_temp_pseudo = (next_low + next_high)/2; + pzone->trend = trend; + + prcmu_config_hotmon((u8)(next_low/1000), (u8)(next_high/1000)); + prcmu_start_temp_sense(PRCMU_DEFAULT_MEASURE_TIME); +} + +static irqreturn_t prcmu_low_irq_handler(int irq, void *irq_data) +{ + struct db8500_thermal_zone *pzone = irq_data; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + unsigned int idx = pzone->cur_index; + unsigned long next_low, next_high; + + if (unlikely(idx == 0)) + /* Meaningless for thermal management, ignoring it */ + return IRQ_HANDLED; + + if (idx == 1) { + next_high = ptrips->trip_points[0].temp; + next_low = PRCMU_DEFAULT_LOW_TEMP; + } else { + next_high = ptrips->trip_points[idx-1].temp; + next_low = ptrips->trip_points[idx-2].temp; + } + idx -= 1; + + db8500_thermal_update_config(pzone, idx, THERMAL_TREND_DROPPING, + next_low, next_high); + + dev_dbg(&pzone->therm_dev->device, + "PRCMU set max %ld, min %ld\n", next_high, next_low); + + schedule_work(&pzone->therm_work); + + return IRQ_HANDLED; +} + +static irqreturn_t prcmu_high_irq_handler(int irq, void *irq_data) +{ + struct db8500_thermal_zone *pzone = irq_data; + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + unsigned int idx = pzone->cur_index; + unsigned long next_low, next_high; + + if (idx < ptrips->num_trips - 1) { + next_high = ptrips->trip_points[idx+1].temp; + next_low = ptrips->trip_points[idx].temp; + idx += 1; + + db8500_thermal_update_config(pzone, idx, THERMAL_TREND_RAISING, + next_low, next_high); + + dev_dbg(&pzone->therm_dev->device, + "PRCMU set max %ld, min %ld\n", next_high, next_low); + } else if (idx == ptrips->num_trips - 1) + pzone->cur_temp_pseudo = ptrips->trip_points[idx].temp + 1; + + schedule_work(&pzone->therm_work); + + return IRQ_HANDLED; +} + +static void db8500_thermal_work(struct work_struct *work) +{ + enum thermal_device_mode cur_mode; + struct db8500_thermal_zone *pzone; + + pzone = container_of(work, struct db8500_thermal_zone, therm_work); + + mutex_lock(&pzone->th_lock); + cur_mode = pzone->mode; + mutex_unlock(&pzone->th_lock); + + if (cur_mode == THERMAL_DEVICE_DISABLED) + return; + + thermal_zone_device_update(pzone->therm_dev); + dev_dbg(&pzone->therm_dev->device, "thermal work finished.\n"); +} + +#ifdef CONFIG_OF +static struct db8500_thsens_platform_data* + db8500_thermal_parse_dt(struct platform_device *pdev) +{ + struct db8500_thsens_platform_data *ptrips; + struct device_node *np = pdev->dev.of_node; + char prop_name[32]; + const char *tmp_str; + u32 tmp_data; + int i, j; + + ptrips = devm_kzalloc(&pdev->dev, sizeof(*ptrips), GFP_KERNEL); + if (!ptrips) + return NULL; + + if (of_property_read_u32(np, "num-trips", &tmp_data)) + goto err_parse_dt; + + if (tmp_data > THERMAL_MAX_TRIPS) + goto err_parse_dt; + + ptrips->num_trips = tmp_data; + + for (i = 0; i < ptrips->num_trips; i++) { + sprintf(prop_name, "trip%d-temp", i); + if (of_property_read_u32(np, prop_name, &tmp_data)) + goto err_parse_dt; + + ptrips->trip_points[i].temp = tmp_data; + + sprintf(prop_name, "trip%d-type", i); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto err_parse_dt; + + if (!strcmp(tmp_str, "active")) + ptrips->trip_points[i].type = THERMAL_TRIP_ACTIVE; + else if (!strcmp(tmp_str, "passive")) + ptrips->trip_points[i].type = THERMAL_TRIP_PASSIVE; + else if (!strcmp(tmp_str, "hot")) + ptrips->trip_points[i].type = THERMAL_TRIP_HOT; + else if (!strcmp(tmp_str, "critical")) + ptrips->trip_points[i].type = THERMAL_TRIP_CRITICAL; + else + goto err_parse_dt; + + sprintf(prop_name, "trip%d-cdev-num", i); + if (of_property_read_u32(np, prop_name, &tmp_data)) + goto err_parse_dt; + + if (tmp_data > COOLING_DEV_MAX) + goto err_parse_dt; + + for (j = 0; j < tmp_data; j++) { + sprintf(prop_name, "trip%d-cdev-name%d", i, j); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto err_parse_dt; + + if (strlen(tmp_str) >= THERMAL_NAME_LENGTH) + goto err_parse_dt; + + strcpy(ptrips->trip_points[i].cdev_name[j], tmp_str); + } + } + return ptrips; + +err_parse_dt: + dev_err(&pdev->dev, "Parsing device tree data error.\n"); + return NULL; +} +#else +static inline struct db8500_thsens_platform_data* + db8500_thermal_parse_dt(struct platform_device *pdev) +{ + return NULL; +} +#endif + +static int db8500_thermal_probe(struct platform_device *pdev) +{ + struct db8500_thermal_zone *pzone = NULL; + struct db8500_thsens_platform_data *ptrips = NULL; + struct device_node *np = pdev->dev.of_node; + int low_irq, high_irq, ret = 0; + unsigned long dft_low, dft_high; + + if (np) + ptrips = db8500_thermal_parse_dt(pdev); + else + ptrips = dev_get_platdata(&pdev->dev); + + if (!ptrips) + return -EINVAL; + + pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL); + if (!pzone) + return -ENOMEM; + + mutex_init(&pzone->th_lock); + mutex_lock(&pzone->th_lock); + + pzone->mode = THERMAL_DEVICE_DISABLED; + pzone->trip_tab = ptrips; + + INIT_WORK(&pzone->therm_work, db8500_thermal_work); + + low_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW"); + if (low_irq < 0) { + dev_err(&pdev->dev, "Get IRQ_HOTMON_LOW failed.\n"); + ret = low_irq; + goto out_unlock; + } + + ret = devm_request_threaded_irq(&pdev->dev, low_irq, NULL, + prcmu_low_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, + "dbx500_temp_low", pzone); + if (ret < 0) { + dev_err(&pdev->dev, "Failed to allocate temp low irq.\n"); + goto out_unlock; + } + + high_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH"); + if (high_irq < 0) { + dev_err(&pdev->dev, "Get IRQ_HOTMON_HIGH failed.\n"); + ret = high_irq; + goto out_unlock; + } + + ret = devm_request_threaded_irq(&pdev->dev, high_irq, NULL, + prcmu_high_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, + "dbx500_temp_high", pzone); + if (ret < 0) { + dev_err(&pdev->dev, "Failed to allocate temp high irq.\n"); + goto out_unlock; + } + + pzone->therm_dev = thermal_zone_device_register("db8500_thermal_zone", + ptrips->num_trips, 0, pzone, &thdev_ops, NULL, 0, 0); + + if (IS_ERR(pzone->therm_dev)) { + dev_err(&pdev->dev, "Register thermal zone device failed.\n"); + ret = PTR_ERR(pzone->therm_dev); + goto out_unlock; + } + dev_info(&pdev->dev, "Thermal zone device registered.\n"); + + dft_low = PRCMU_DEFAULT_LOW_TEMP; + dft_high = ptrips->trip_points[0].temp; + + db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE, + dft_low, dft_high); + + platform_set_drvdata(pdev, pzone); + pzone->mode = THERMAL_DEVICE_ENABLED; + +out_unlock: + mutex_unlock(&pzone->th_lock); + + return ret; +} + +static int db8500_thermal_remove(struct platform_device *pdev) +{ + struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev); + + thermal_zone_device_unregister(pzone->therm_dev); + cancel_work_sync(&pzone->therm_work); + mutex_destroy(&pzone->th_lock); + + return 0; +} + +static int db8500_thermal_suspend(struct platform_device *pdev, + pm_message_t state) +{ + struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev); + + flush_work(&pzone->therm_work); + prcmu_stop_temp_sense(); + + return 0; +} + +static int db8500_thermal_resume(struct platform_device *pdev) +{ + struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev); + struct db8500_thsens_platform_data *ptrips = pzone->trip_tab; + unsigned long dft_low, dft_high; + + dft_low = PRCMU_DEFAULT_LOW_TEMP; + dft_high = ptrips->trip_points[0].temp; + + db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE, + dft_low, dft_high); + + return 0; +} + +#ifdef CONFIG_OF +static const struct of_device_id db8500_thermal_match[] = { + { .compatible = "stericsson,db8500-thermal" }, + {}, +}; +#endif + +static struct platform_driver db8500_thermal_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "db8500-thermal", + .of_match_table = of_match_ptr(db8500_thermal_match), + }, + .probe = db8500_thermal_probe, + .suspend = db8500_thermal_suspend, + .resume = db8500_thermal_resume, + .remove = db8500_thermal_remove, +}; + +module_platform_driver(db8500_thermal_driver); + +MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>"); +MODULE_DESCRIPTION("DB8500 thermal driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/thermal/dove_thermal.c b/drivers/thermal/dove_thermal.c new file mode 100644 index 00000000..a088d136 --- /dev/null +++ b/drivers/thermal/dove_thermal.c @@ -0,0 +1,202 @@ +/* + * Dove thermal sensor driver + * + * Copyright (C) 2013 Andrew Lunn <andrew@lunn.ch> + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + * + */ +#include <linux/device.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/kernel.h> +#include <linux/of.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/thermal.h> + +#define DOVE_THERMAL_TEMP_OFFSET 1 +#define DOVE_THERMAL_TEMP_MASK 0x1FF + +/* Dove Thermal Manager Control and Status Register */ +#define PMU_TM_DISABLE_OFFS 0 +#define PMU_TM_DISABLE_MASK (0x1 << PMU_TM_DISABLE_OFFS) + +/* Dove Theraml Diode Control 0 Register */ +#define PMU_TDC0_SW_RST_MASK (0x1 << 1) +#define PMU_TDC0_SEL_VCAL_OFFS 5 +#define PMU_TDC0_SEL_VCAL_MASK (0x3 << PMU_TDC0_SEL_VCAL_OFFS) +#define PMU_TDC0_REF_CAL_CNT_OFFS 11 +#define PMU_TDC0_REF_CAL_CNT_MASK (0x1FF << PMU_TDC0_REF_CAL_CNT_OFFS) +#define PMU_TDC0_AVG_NUM_OFFS 25 +#define PMU_TDC0_AVG_NUM_MASK (0x7 << PMU_TDC0_AVG_NUM_OFFS) + +/* Dove Thermal Diode Control 1 Register */ +#define PMU_TEMP_DIOD_CTRL1_REG 0x04 +#define PMU_TDC1_TEMP_VALID_MASK (0x1 << 10) + +/* Dove Thermal Sensor Dev Structure */ +struct dove_thermal_priv { + void __iomem *sensor; + void __iomem *control; +}; + +static int dove_init_sensor(const struct dove_thermal_priv *priv) +{ + u32 reg; + u32 i; + + /* Configure the Diode Control Register #0 */ + reg = readl_relaxed(priv->control); + + /* Use average of 2 */ + reg &= ~PMU_TDC0_AVG_NUM_MASK; + reg |= (0x1 << PMU_TDC0_AVG_NUM_OFFS); + + /* Reference calibration value */ + reg &= ~PMU_TDC0_REF_CAL_CNT_MASK; + reg |= (0x0F1 << PMU_TDC0_REF_CAL_CNT_OFFS); + + /* Set the high level reference for calibration */ + reg &= ~PMU_TDC0_SEL_VCAL_MASK; + reg |= (0x2 << PMU_TDC0_SEL_VCAL_OFFS); + writel(reg, priv->control); + + /* Reset the sensor */ + reg = readl_relaxed(priv->control); + writel((reg | PMU_TDC0_SW_RST_MASK), priv->control); + writel(reg, priv->control); + + /* Enable the sensor */ + reg = readl_relaxed(priv->sensor); + reg &= ~PMU_TM_DISABLE_MASK; + writel(reg, priv->sensor); + + /* Poll the sensor for the first reading */ + for (i = 0; i < 1000000; i++) { + reg = readl_relaxed(priv->sensor); + if (reg & DOVE_THERMAL_TEMP_MASK) + break; + } + + if (i == 1000000) + return -EIO; + + return 0; +} + +static int dove_get_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + unsigned long reg; + struct dove_thermal_priv *priv = thermal->devdata; + + /* Valid check */ + reg = readl_relaxed(priv->control + PMU_TEMP_DIOD_CTRL1_REG); + if ((reg & PMU_TDC1_TEMP_VALID_MASK) == 0x0) { + dev_err(&thermal->device, + "Temperature sensor reading not valid\n"); + return -EIO; + } + + /* + * Calculate temperature. According to Marvell internal + * documentation the formula for this is: + * Celsius = (322-reg)/1.3625 + */ + reg = readl_relaxed(priv->sensor); + reg = (reg >> DOVE_THERMAL_TEMP_OFFSET) & DOVE_THERMAL_TEMP_MASK; + *temp = ((3220000000UL - (10000000UL * reg)) / 13625); + + return 0; +} + +static struct thermal_zone_device_ops ops = { + .get_temp = dove_get_temp, +}; + +static const struct of_device_id dove_thermal_id_table[] = { + { .compatible = "marvell,dove-thermal" }, + {} +}; + +static int dove_thermal_probe(struct platform_device *pdev) +{ + struct thermal_zone_device *thermal = NULL; + struct dove_thermal_priv *priv; + struct resource *res; + int ret; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) { + dev_err(&pdev->dev, "Failed to get platform resource\n"); + return -ENODEV; + } + + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->sensor = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(priv->sensor)) + return PTR_ERR(priv->sensor); + + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + priv->control = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(priv->control)) + return PTR_ERR(priv->control); + + ret = dove_init_sensor(priv); + if (ret) { + dev_err(&pdev->dev, "Failed to initialize sensor\n"); + return ret; + } + + thermal = thermal_zone_device_register("dove_thermal", 0, 0, + priv, &ops, NULL, 0, 0); + if (IS_ERR(thermal)) { + dev_err(&pdev->dev, + "Failed to register thermal zone device\n"); + return PTR_ERR(thermal); + } + + platform_set_drvdata(pdev, thermal); + + return 0; +} + +static int dove_thermal_exit(struct platform_device *pdev) +{ + struct thermal_zone_device *dove_thermal = + platform_get_drvdata(pdev); + + thermal_zone_device_unregister(dove_thermal); + platform_set_drvdata(pdev, NULL); + + return 0; +} + +MODULE_DEVICE_TABLE(of, dove_thermal_id_table); + +static struct platform_driver dove_thermal_driver = { + .probe = dove_thermal_probe, + .remove = dove_thermal_exit, + .driver = { + .name = "dove_thermal", + .owner = THIS_MODULE, + .of_match_table = of_match_ptr(dove_thermal_id_table), + }, +}; + +module_platform_driver(dove_thermal_driver); + +MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>"); +MODULE_DESCRIPTION("Dove thermal driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/thermal/exynos_thermal.c b/drivers/thermal/exynos_thermal.c new file mode 100644 index 00000000..788b1ddc --- /dev/null +++ b/drivers/thermal/exynos_thermal.c @@ -0,0 +1,1061 @@ +/* + * 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> + +/* 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 << 12) +#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 MAX_THRESHOLD_LEVS 4 + +#define ACTIVE_INTERVAL 500 +#define IDLE_INTERVAL 10000 +#define MCELSIUS 1000 + +#ifdef CONFIG_THERMAL_EMULATION +#define EXYNOS_EMUL_TIME 0x57F0 +#define EXYNOS_EMUL_TIME_SHIFT 16 +#define EXYNOS_EMUL_DATA_SHIFT 8 +#define EXYNOS_EMUL_DATA_MASK 0xFF +#define EXYNOS_EMUL_ENABLE 0x1 +#endif /* CONFIG_THERMAL_EMULATION */ + +/* 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; + u8 trigger_falling; +}; + +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); + int (*write_emul_temp)(void *drv_data, unsigned long temp); + 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->sensor_conf->trip_data.trigger_falling) + 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; +} + +/* 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 = cpufreq_cooling_get_level(0, clip_data->freq_clip_max); + if (level == THERMAL_CSTATE_INVALID) + return 0; + switch (GET_ZONE(i)) { + case MONITOR_ZONE: + case WARN_ZONE: + if (thermal_zone_bind_cooling_device(thermal, i, cdev, + level, 0)) { + 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 temperature callback functions for thermal zone */ +static int exynos_set_emul_temp(struct thermal_zone_device *thermal, + unsigned long temp) +{ + void *data; + int ret = -EINVAL; + + if (!th_zone->sensor_conf) { + pr_info("Temperature sensor not initialised\n"); + return -EINVAL; + } + data = th_zone->sensor_conf->private_data; + if (th_zone->sensor_conf->write_emul_temp) + ret = th_zone->sensor_conf->write_emul_temp(data, temp); + return ret; +} + +/* Get the temperature trend */ +static int exynos_get_trend(struct thermal_zone_device *thermal, + int trip, enum thermal_trend *trend) +{ + int ret; + unsigned long trip_temp; + + ret = exynos_get_trip_temp(thermal, trip, &trip_temp); + if (ret < 0) + return ret; + + if (thermal->temperature >= trip_temp) + *trend = THERMAL_TREND_RAISE_FULL; + else + *trend = THERMAL_TREND_DROP_FULL; + + 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, + .set_emul_temp = exynos_set_emul_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 && + !th_zone->sensor_conf->trip_data.trigger_falling) { + 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, NULL, 0, + sensor_conf->trip_data.trigger_falling ? + 0 : IDLE_INTERVAL); + + if (IS_ERR(th_zone->therm_dev)) { + pr_err("Failed to register thermal zone device\n"); + ret = PTR_ERR(th_zone->therm_dev); + 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; + unsigned int rising_threshold = 0, falling_threshold = 0; + int ret = 0, threshold_code, i, trigger_levs = 0; + + 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; + + /* Count trigger levels to be enabled */ + for (i = 0; i < MAX_THRESHOLD_LEVS; i++) + if (pdata->trigger_levels[i]) + trigger_levs++; + + 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); + for (i = 0; i < trigger_levs; i++) + writeb(pdata->trigger_levels[i], + data->base + EXYNOS4210_TMU_REG_TRIG_LEVEL0 + i * 4); + + writel(EXYNOS4210_TMU_INTCLEAR_VAL, + data->base + EXYNOS_TMU_REG_INTCLEAR); + } else if (data->soc == SOC_ARCH_EXYNOS) { + /* Write temperature code for rising and falling threshold */ + for (i = 0; i < trigger_levs; i++) { + threshold_code = temp_to_code(data, + pdata->trigger_levels[i]); + if (threshold_code < 0) { + ret = threshold_code; + goto out; + } + rising_threshold |= threshold_code << 8 * i; + if (pdata->threshold_falling) { + threshold_code = temp_to_code(data, + pdata->trigger_levels[i] - + pdata->threshold_falling); + if (threshold_code > 0) + falling_threshold |= + threshold_code << 8 * i; + } + } + + writel(rising_threshold, + data->base + EXYNOS_THD_TEMP_RISE); + writel(falling_threshold, + 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; + if (pdata->threshold_falling) + interrupt_en |= interrupt_en << 16; + } 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; +} + +#ifdef CONFIG_THERMAL_EMULATION +static int exynos_tmu_set_emulation(void *drv_data, unsigned long temp) +{ + struct exynos_tmu_data *data = drv_data; + unsigned int reg; + int ret = -EINVAL; + + if (data->soc == SOC_ARCH_EXYNOS4210) + goto out; + + if (temp && temp < MCELSIUS) + goto out; + + mutex_lock(&data->lock); + clk_enable(data->clk); + + reg = readl(data->base + EXYNOS_EMUL_CON); + + if (temp) { + temp /= MCELSIUS; + + reg = (EXYNOS_EMUL_TIME << EXYNOS_EMUL_TIME_SHIFT) | + (temp_to_code(data, temp) + << EXYNOS_EMUL_DATA_SHIFT) | EXYNOS_EMUL_ENABLE; + } else { + reg &= ~EXYNOS_EMUL_ENABLE; + } + + writel(reg, data->base + EXYNOS_EMUL_CON); + + clk_disable(data->clk); + mutex_unlock(&data->lock); + return 0; +out: + return ret; +} +#else +static int exynos_tmu_set_emulation(void *drv_data, unsigned long temp) + { return -EINVAL; } +#endif/*CONFIG_THERMAL_EMULATION*/ + +static void exynos_tmu_work(struct work_struct *work) +{ + struct exynos_tmu_data *data = container_of(work, + struct exynos_tmu_data, irq_work); + + exynos_report_trigger(); + mutex_lock(&data->lock); + clk_enable(data->clk); + if (data->soc == SOC_ARCH_EXYNOS) + writel(EXYNOS_TMU_CLEAR_RISE_INT | + EXYNOS_TMU_CLEAR_FALL_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); + + 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, + .write_emul_temp = exynos_tmu_set_emulation, +}; + +#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 = { + .threshold_falling = 10, + .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,exynos4412-tmu", + .data = (void *)EXYNOS_TMU_DRV_DATA, + }, + { + .compatible = "samsung,exynos5250-tmu", + .data = (void *)EXYNOS_TMU_DRV_DATA, + }, + {}, +}; +MODULE_DEVICE_TABLE(of, exynos_tmu_match); +#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, exynos_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 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); + data->base = devm_ioremap_resource(&pdev->dev, data->mem); + if (IS_ERR(data->base)) + return PTR_ERR(data->base); + + 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 = devm_clk_get(&pdev->dev, "tmu_apbif"); + if (IS_ERR(data->clk)) { + dev_err(&pdev->dev, "Failed to get clock\n"); + return PTR_ERR(data->clk); + } + + ret = clk_prepare(data->clk); + if (ret) + return ret; + + 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.trip_data.trigger_falling = pdata->threshold_falling; + + 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_unprepare(data->clk); + return ret; +} + +static int 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_unprepare(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 = of_match_ptr(exynos_tmu_match), + }, + .probe = exynos_tmu_probe, + .remove = exynos_tmu_remove, + .id_table = exynos_tmu_driver_ids, +}; + +module_platform_driver(exynos_tmu_driver); + +MODULE_DESCRIPTION("EXYNOS TMU Driver"); +MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:exynos-tmu"); diff --git a/drivers/thermal/fair_share.c b/drivers/thermal/fair_share.c new file mode 100644 index 00000000..944ba2f3 --- /dev/null +++ b/drivers/thermal/fair_share.c @@ -0,0 +1,122 @@ +/* + * fair_share.c - A simple weight based Thermal governor + * + * Copyright (C) 2012 Intel Corp + * Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.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/thermal.h> + +#include "thermal_core.h" + +/** + * get_trip_level: - obtains the current trip level for a zone + * @tz: thermal zone device + */ +static int get_trip_level(struct thermal_zone_device *tz) +{ + int count = 0; + unsigned long trip_temp; + + if (tz->trips == 0 || !tz->ops->get_trip_temp) + return 0; + + for (count = 0; count < tz->trips; count++) { + tz->ops->get_trip_temp(tz, count, &trip_temp); + if (tz->temperature < trip_temp) + break; + } + return count; +} + +static long get_target_state(struct thermal_zone_device *tz, + struct thermal_cooling_device *cdev, int weight, int level) +{ + unsigned long max_state; + + cdev->ops->get_max_state(cdev, &max_state); + + return (long)(weight * level * max_state) / (100 * tz->trips); +} + +/** + * fair_share_throttle - throttles devices asscciated with the given zone + * @tz - thermal_zone_device + * + * Throttling Logic: This uses three parameters to calculate the new + * throttle state of the cooling devices associated with the given zone. + * + * Parameters used for Throttling: + * P1. max_state: Maximum throttle state exposed by the cooling device. + * P2. weight[i]/100: + * How 'effective' the 'i'th device is, in cooling the given zone. + * P3. cur_trip_level/max_no_of_trips: + * This describes the extent to which the devices should be throttled. + * We do not want to throttle too much when we trip a lower temperature, + * whereas the throttling is at full swing if we trip critical levels. + * (Heavily assumes the trip points are in ascending order) + * new_state of cooling device = P3 * P2 * P1 + */ +static int fair_share_throttle(struct thermal_zone_device *tz, int trip) +{ + const struct thermal_zone_params *tzp; + struct thermal_cooling_device *cdev; + struct thermal_instance *instance; + int i; + int cur_trip_level = get_trip_level(tz); + + if (!tz->tzp || !tz->tzp->tbp) + return -EINVAL; + + tzp = tz->tzp; + + for (i = 0; i < tzp->num_tbps; i++) { + if (!tzp->tbp[i].cdev) + continue; + + cdev = tzp->tbp[i].cdev; + instance = get_thermal_instance(tz, cdev, trip); + if (!instance) + continue; + + instance->target = get_target_state(tz, cdev, + tzp->tbp[i].weight, cur_trip_level); + + instance->cdev->updated = false; + thermal_cdev_update(cdev); + } + return 0; +} + +static struct thermal_governor thermal_gov_fair_share = { + .name = "fair_share", + .throttle = fair_share_throttle, +}; + +int thermal_gov_fair_share_register(void) +{ + return thermal_register_governor(&thermal_gov_fair_share); +} + +void thermal_gov_fair_share_unregister(void) +{ + thermal_unregister_governor(&thermal_gov_fair_share); +} + diff --git a/drivers/thermal/intel_powerclamp.c b/drivers/thermal/intel_powerclamp.c new file mode 100644 index 00000000..b40b37cd --- /dev/null +++ b/drivers/thermal/intel_powerclamp.c @@ -0,0 +1,795 @@ +/* + * intel_powerclamp.c - package c-state idle injection + * + * Copyright (c) 2012, Intel Corporation. + * + * Authors: + * Arjan van de Ven <arjan@linux.intel.com> + * Jacob Pan <jacob.jun.pan@linux.intel.com> + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope 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., + * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. + * + * + * TODO: + * 1. better handle wakeup from external interrupts, currently a fixed + * compensation is added to clamping duration when excessive amount + * of wakeups are observed during idle time. the reason is that in + * case of external interrupts without need for ack, clamping down + * cpu in non-irq context does not reduce irq. for majority of the + * cases, clamping down cpu does help reduce irq as well, we should + * be able to differenciate the two cases and give a quantitative + * solution for the irqs that we can control. perhaps based on + * get_cpu_iowait_time_us() + * + * 2. synchronization with other hw blocks + * + * + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/delay.h> +#include <linux/kthread.h> +#include <linux/freezer.h> +#include <linux/cpu.h> +#include <linux/thermal.h> +#include <linux/slab.h> +#include <linux/tick.h> +#include <linux/debugfs.h> +#include <linux/seq_file.h> +#include <linux/sched/rt.h> + +#include <asm/nmi.h> +#include <asm/msr.h> +#include <asm/mwait.h> +#include <asm/cpu_device_id.h> +#include <asm/idle.h> +#include <asm/hardirq.h> + +#define MAX_TARGET_RATIO (50U) +/* For each undisturbed clamping period (no extra wake ups during idle time), + * we increment the confidence counter for the given target ratio. + * CONFIDENCE_OK defines the level where runtime calibration results are + * valid. + */ +#define CONFIDENCE_OK (3) +/* Default idle injection duration, driver adjust sleep time to meet target + * idle ratio. Similar to frequency modulation. + */ +#define DEFAULT_DURATION_JIFFIES (6) + +static unsigned int target_mwait; +static struct dentry *debug_dir; + +/* user selected target */ +static unsigned int set_target_ratio; +static unsigned int current_ratio; +static bool should_skip; +static bool reduce_irq; +static atomic_t idle_wakeup_counter; +static unsigned int control_cpu; /* The cpu assigned to collect stat and update + * control parameters. default to BSP but BSP + * can be offlined. + */ +static bool clamping; + + +static struct task_struct * __percpu *powerclamp_thread; +static struct thermal_cooling_device *cooling_dev; +static unsigned long *cpu_clamping_mask; /* bit map for tracking per cpu + * clamping thread + */ + +static unsigned int duration; +static unsigned int pkg_cstate_ratio_cur; +static unsigned int window_size; + +static int duration_set(const char *arg, const struct kernel_param *kp) +{ + int ret = 0; + unsigned long new_duration; + + ret = kstrtoul(arg, 10, &new_duration); + if (ret) + goto exit; + if (new_duration > 25 || new_duration < 6) { + pr_err("Out of recommended range %lu, between 6-25ms\n", + new_duration); + ret = -EINVAL; + } + + duration = clamp(new_duration, 6ul, 25ul); + smp_mb(); + +exit: + + return ret; +} + +static struct kernel_param_ops duration_ops = { + .set = duration_set, + .get = param_get_int, +}; + + +module_param_cb(duration, &duration_ops, &duration, 0644); +MODULE_PARM_DESC(duration, "forced idle time for each attempt in msec."); + +struct powerclamp_calibration_data { + unsigned long confidence; /* used for calibration, basically a counter + * gets incremented each time a clamping + * period is completed without extra wakeups + * once that counter is reached given level, + * compensation is deemed usable. + */ + unsigned long steady_comp; /* steady state compensation used when + * no extra wakeups occurred. + */ + unsigned long dynamic_comp; /* compensate excessive wakeup from idle + * mostly from external interrupts. + */ +}; + +static struct powerclamp_calibration_data cal_data[MAX_TARGET_RATIO]; + +static int window_size_set(const char *arg, const struct kernel_param *kp) +{ + int ret = 0; + unsigned long new_window_size; + + ret = kstrtoul(arg, 10, &new_window_size); + if (ret) + goto exit_win; + if (new_window_size > 10 || new_window_size < 2) { + pr_err("Out of recommended window size %lu, between 2-10\n", + new_window_size); + ret = -EINVAL; + } + + window_size = clamp(new_window_size, 2ul, 10ul); + smp_mb(); + +exit_win: + + return ret; +} + +static struct kernel_param_ops window_size_ops = { + .set = window_size_set, + .get = param_get_int, +}; + +module_param_cb(window_size, &window_size_ops, &window_size, 0644); +MODULE_PARM_DESC(window_size, "sliding window in number of clamping cycles\n" + "\tpowerclamp controls idle ratio within this window. larger\n" + "\twindow size results in slower response time but more smooth\n" + "\tclamping results. default to 2."); + +static void find_target_mwait(void) +{ + unsigned int eax, ebx, ecx, edx; + unsigned int highest_cstate = 0; + unsigned int highest_subcstate = 0; + int i; + + if (boot_cpu_data.cpuid_level < CPUID_MWAIT_LEAF) + return; + + cpuid(CPUID_MWAIT_LEAF, &eax, &ebx, &ecx, &edx); + + if (!(ecx & CPUID5_ECX_EXTENSIONS_SUPPORTED) || + !(ecx & CPUID5_ECX_INTERRUPT_BREAK)) + return; + + edx >>= MWAIT_SUBSTATE_SIZE; + for (i = 0; i < 7 && edx; i++, edx >>= MWAIT_SUBSTATE_SIZE) { + if (edx & MWAIT_SUBSTATE_MASK) { + highest_cstate = i; + highest_subcstate = edx & MWAIT_SUBSTATE_MASK; + } + } + target_mwait = (highest_cstate << MWAIT_SUBSTATE_SIZE) | + (highest_subcstate - 1); + +} + +static u64 pkg_state_counter(void) +{ + u64 val; + u64 count = 0; + + static bool skip_c2; + static bool skip_c3; + static bool skip_c6; + static bool skip_c7; + + if (!skip_c2) { + if (!rdmsrl_safe(MSR_PKG_C2_RESIDENCY, &val)) + count += val; + else + skip_c2 = true; + } + + if (!skip_c3) { + if (!rdmsrl_safe(MSR_PKG_C3_RESIDENCY, &val)) + count += val; + else + skip_c3 = true; + } + + if (!skip_c6) { + if (!rdmsrl_safe(MSR_PKG_C6_RESIDENCY, &val)) + count += val; + else + skip_c6 = true; + } + + if (!skip_c7) { + if (!rdmsrl_safe(MSR_PKG_C7_RESIDENCY, &val)) + count += val; + else + skip_c7 = true; + } + + return count; +} + +static void noop_timer(unsigned long foo) +{ + /* empty... just the fact that we get the interrupt wakes us up */ +} + +static unsigned int get_compensation(int ratio) +{ + unsigned int comp = 0; + + /* we only use compensation if all adjacent ones are good */ + if (ratio == 1 && + cal_data[ratio].confidence >= CONFIDENCE_OK && + cal_data[ratio + 1].confidence >= CONFIDENCE_OK && + cal_data[ratio + 2].confidence >= CONFIDENCE_OK) { + comp = (cal_data[ratio].steady_comp + + cal_data[ratio + 1].steady_comp + + cal_data[ratio + 2].steady_comp) / 3; + } else if (ratio == MAX_TARGET_RATIO - 1 && + cal_data[ratio].confidence >= CONFIDENCE_OK && + cal_data[ratio - 1].confidence >= CONFIDENCE_OK && + cal_data[ratio - 2].confidence >= CONFIDENCE_OK) { + comp = (cal_data[ratio].steady_comp + + cal_data[ratio - 1].steady_comp + + cal_data[ratio - 2].steady_comp) / 3; + } else if (cal_data[ratio].confidence >= CONFIDENCE_OK && + cal_data[ratio - 1].confidence >= CONFIDENCE_OK && + cal_data[ratio + 1].confidence >= CONFIDENCE_OK) { + comp = (cal_data[ratio].steady_comp + + cal_data[ratio - 1].steady_comp + + cal_data[ratio + 1].steady_comp) / 3; + } + + /* REVISIT: simple penalty of double idle injection */ + if (reduce_irq) + comp = ratio; + /* do not exceed limit */ + if (comp + ratio >= MAX_TARGET_RATIO) + comp = MAX_TARGET_RATIO - ratio - 1; + + return comp; +} + +static void adjust_compensation(int target_ratio, unsigned int win) +{ + int delta; + struct powerclamp_calibration_data *d = &cal_data[target_ratio]; + + /* + * adjust compensations if confidence level has not been reached or + * there are too many wakeups during the last idle injection period, we + * cannot trust the data for compensation. + */ + if (d->confidence >= CONFIDENCE_OK || + atomic_read(&idle_wakeup_counter) > + win * num_online_cpus()) + return; + + delta = set_target_ratio - current_ratio; + /* filter out bad data */ + if (delta >= 0 && delta <= (1+target_ratio/10)) { + if (d->steady_comp) + d->steady_comp = + roundup(delta+d->steady_comp, 2)/2; + else + d->steady_comp = delta; + d->confidence++; + } +} + +static bool powerclamp_adjust_controls(unsigned int target_ratio, + unsigned int guard, unsigned int win) +{ + static u64 msr_last, tsc_last; + u64 msr_now, tsc_now; + u64 val64; + + /* check result for the last window */ + msr_now = pkg_state_counter(); + rdtscll(tsc_now); + + /* calculate pkg cstate vs tsc ratio */ + if (!msr_last || !tsc_last) + current_ratio = 1; + else if (tsc_now-tsc_last) { + val64 = 100*(msr_now-msr_last); + do_div(val64, (tsc_now-tsc_last)); + current_ratio = val64; + } + + /* update record */ + msr_last = msr_now; + tsc_last = tsc_now; + + adjust_compensation(target_ratio, win); + /* + * too many external interrupts, set flag such + * that we can take measure later. + */ + reduce_irq = atomic_read(&idle_wakeup_counter) >= + 2 * win * num_online_cpus(); + + atomic_set(&idle_wakeup_counter, 0); + /* if we are above target+guard, skip */ + return set_target_ratio + guard <= current_ratio; +} + +static int clamp_thread(void *arg) +{ + int cpunr = (unsigned long)arg; + DEFINE_TIMER(wakeup_timer, noop_timer, 0, 0); + static const struct sched_param param = { + .sched_priority = MAX_USER_RT_PRIO/2, + }; + unsigned int count = 0; + unsigned int target_ratio; + + set_bit(cpunr, cpu_clamping_mask); + set_freezable(); + init_timer_on_stack(&wakeup_timer); + sched_setscheduler(current, SCHED_FIFO, ¶m); + + while (true == clamping && !kthread_should_stop() && + cpu_online(cpunr)) { + int sleeptime; + unsigned long target_jiffies; + unsigned int guard; + unsigned int compensation = 0; + int interval; /* jiffies to sleep for each attempt */ + unsigned int duration_jiffies = msecs_to_jiffies(duration); + unsigned int window_size_now; + + try_to_freeze(); + /* + * make sure user selected ratio does not take effect until + * the next round. adjust target_ratio if user has changed + * target such that we can converge quickly. + */ + target_ratio = set_target_ratio; + guard = 1 + target_ratio/20; + window_size_now = window_size; + count++; + + /* + * systems may have different ability to enter package level + * c-states, thus we need to compensate the injected idle ratio + * to achieve the actual target reported by the HW. + */ + compensation = get_compensation(target_ratio); + interval = duration_jiffies*100/(target_ratio+compensation); + + /* align idle time */ + target_jiffies = roundup(jiffies, interval); + sleeptime = target_jiffies - jiffies; + if (sleeptime <= 0) + sleeptime = 1; + schedule_timeout_interruptible(sleeptime); + /* + * only elected controlling cpu can collect stats and update + * control parameters. + */ + if (cpunr == control_cpu && !(count%window_size_now)) { + should_skip = + powerclamp_adjust_controls(target_ratio, + guard, window_size_now); + smp_mb(); + } + + if (should_skip) + continue; + + target_jiffies = jiffies + duration_jiffies; + mod_timer(&wakeup_timer, target_jiffies); + if (unlikely(local_softirq_pending())) + continue; + /* + * stop tick sched during idle time, interrupts are still + * allowed. thus jiffies are updated properly. + */ + preempt_disable(); + tick_nohz_idle_enter(); + /* mwait until target jiffies is reached */ + while (time_before(jiffies, target_jiffies)) { + unsigned long ecx = 1; + unsigned long eax = target_mwait; + + /* + * REVISIT: may call enter_idle() to notify drivers who + * can save power during cpu idle. same for exit_idle() + */ + local_touch_nmi(); + stop_critical_timings(); + __monitor((void *)¤t_thread_info()->flags, 0, 0); + cpu_relax(); /* allow HT sibling to run */ + __mwait(eax, ecx); + start_critical_timings(); + atomic_inc(&idle_wakeup_counter); + } + tick_nohz_idle_exit(); + preempt_enable_no_resched(); + } + del_timer_sync(&wakeup_timer); + clear_bit(cpunr, cpu_clamping_mask); + + return 0; +} + +/* + * 1 HZ polling while clamping is active, useful for userspace + * to monitor actual idle ratio. + */ +static void poll_pkg_cstate(struct work_struct *dummy); +static DECLARE_DELAYED_WORK(poll_pkg_cstate_work, poll_pkg_cstate); +static void poll_pkg_cstate(struct work_struct *dummy) +{ + static u64 msr_last; + static u64 tsc_last; + static unsigned long jiffies_last; + + u64 msr_now; + unsigned long jiffies_now; + u64 tsc_now; + u64 val64; + + msr_now = pkg_state_counter(); + rdtscll(tsc_now); + jiffies_now = jiffies; + + /* calculate pkg cstate vs tsc ratio */ + if (!msr_last || !tsc_last) + pkg_cstate_ratio_cur = 1; + else { + if (tsc_now - tsc_last) { + val64 = 100 * (msr_now - msr_last); + do_div(val64, (tsc_now - tsc_last)); + pkg_cstate_ratio_cur = val64; + } + } + + /* update record */ + msr_last = msr_now; + jiffies_last = jiffies_now; + tsc_last = tsc_now; + + if (true == clamping) + schedule_delayed_work(&poll_pkg_cstate_work, HZ); +} + +static int start_power_clamp(void) +{ + unsigned long cpu; + struct task_struct *thread; + + /* check if pkg cstate counter is completely 0, abort in this case */ + if (!pkg_state_counter()) { + pr_err("pkg cstate counter not functional, abort\n"); + return -EINVAL; + } + + set_target_ratio = clamp(set_target_ratio, 0U, MAX_TARGET_RATIO - 1); + /* prevent cpu hotplug */ + get_online_cpus(); + + /* prefer BSP */ + control_cpu = 0; + if (!cpu_online(control_cpu)) + control_cpu = smp_processor_id(); + + clamping = true; + schedule_delayed_work(&poll_pkg_cstate_work, 0); + + /* start one thread per online cpu */ + for_each_online_cpu(cpu) { + struct task_struct **p = + per_cpu_ptr(powerclamp_thread, cpu); + + thread = kthread_create_on_node(clamp_thread, + (void *) cpu, + cpu_to_node(cpu), + "kidle_inject/%ld", cpu); + /* bind to cpu here */ + if (likely(!IS_ERR(thread))) { + kthread_bind(thread, cpu); + wake_up_process(thread); + *p = thread; + } + + } + put_online_cpus(); + + return 0; +} + +static void end_power_clamp(void) +{ + int i; + struct task_struct *thread; + + clamping = false; + /* + * make clamping visible to other cpus and give per cpu clamping threads + * sometime to exit, or gets killed later. + */ + smp_mb(); + msleep(20); + if (bitmap_weight(cpu_clamping_mask, num_possible_cpus())) { + for_each_set_bit(i, cpu_clamping_mask, num_possible_cpus()) { + pr_debug("clamping thread for cpu %d alive, kill\n", i); + thread = *per_cpu_ptr(powerclamp_thread, i); + kthread_stop(thread); + } + } +} + +static int powerclamp_cpu_callback(struct notifier_block *nfb, + unsigned long action, void *hcpu) +{ + unsigned long cpu = (unsigned long)hcpu; + struct task_struct *thread; + struct task_struct **percpu_thread = + per_cpu_ptr(powerclamp_thread, cpu); + + if (false == clamping) + goto exit_ok; + + switch (action) { + case CPU_ONLINE: + thread = kthread_create_on_node(clamp_thread, + (void *) cpu, + cpu_to_node(cpu), + "kidle_inject/%lu", cpu); + if (likely(!IS_ERR(thread))) { + kthread_bind(thread, cpu); + wake_up_process(thread); + *percpu_thread = thread; + } + /* prefer BSP as controlling CPU */ + if (cpu == 0) { + control_cpu = 0; + smp_mb(); + } + break; + case CPU_DEAD: + if (test_bit(cpu, cpu_clamping_mask)) { + pr_err("cpu %lu dead but powerclamping thread is not\n", + cpu); + kthread_stop(*percpu_thread); + } + if (cpu == control_cpu) { + control_cpu = smp_processor_id(); + smp_mb(); + } + } + +exit_ok: + return NOTIFY_OK; +} + +static struct notifier_block powerclamp_cpu_notifier = { + .notifier_call = powerclamp_cpu_callback, +}; + +static int powerclamp_get_max_state(struct thermal_cooling_device *cdev, + unsigned long *state) +{ + *state = MAX_TARGET_RATIO; + + return 0; +} + +static int powerclamp_get_cur_state(struct thermal_cooling_device *cdev, + unsigned long *state) +{ + if (true == clamping) + *state = pkg_cstate_ratio_cur; + else + /* to save power, do not poll idle ratio while not clamping */ + *state = -1; /* indicates invalid state */ + + return 0; +} + +static int powerclamp_set_cur_state(struct thermal_cooling_device *cdev, + unsigned long new_target_ratio) +{ + int ret = 0; + + new_target_ratio = clamp(new_target_ratio, 0UL, + (unsigned long) (MAX_TARGET_RATIO-1)); + if (set_target_ratio == 0 && new_target_ratio > 0) { + pr_info("Start idle injection to reduce power\n"); + set_target_ratio = new_target_ratio; + ret = start_power_clamp(); + goto exit_set; + } else if (set_target_ratio > 0 && new_target_ratio == 0) { + pr_info("Stop forced idle injection\n"); + set_target_ratio = 0; + end_power_clamp(); + } else /* adjust currently running */ { + set_target_ratio = new_target_ratio; + /* make new set_target_ratio visible to other cpus */ + smp_mb(); + } + +exit_set: + return ret; +} + +/* bind to generic thermal layer as cooling device*/ +static struct thermal_cooling_device_ops powerclamp_cooling_ops = { + .get_max_state = powerclamp_get_max_state, + .get_cur_state = powerclamp_get_cur_state, + .set_cur_state = powerclamp_set_cur_state, +}; + +/* runs on Nehalem and later */ +static const struct x86_cpu_id intel_powerclamp_ids[] = { + { X86_VENDOR_INTEL, 6, 0x1a}, + { X86_VENDOR_INTEL, 6, 0x1c}, + { X86_VENDOR_INTEL, 6, 0x1e}, + { X86_VENDOR_INTEL, 6, 0x1f}, + { X86_VENDOR_INTEL, 6, 0x25}, + { X86_VENDOR_INTEL, 6, 0x26}, + { X86_VENDOR_INTEL, 6, 0x2a}, + { X86_VENDOR_INTEL, 6, 0x2c}, + { X86_VENDOR_INTEL, 6, 0x2d}, + { X86_VENDOR_INTEL, 6, 0x2e}, + { X86_VENDOR_INTEL, 6, 0x2f}, + { X86_VENDOR_INTEL, 6, 0x3a}, + {} +}; +MODULE_DEVICE_TABLE(x86cpu, intel_powerclamp_ids); + +static int powerclamp_probe(void) +{ + if (!x86_match_cpu(intel_powerclamp_ids)) { + pr_err("Intel powerclamp does not run on family %d model %d\n", + boot_cpu_data.x86, boot_cpu_data.x86_model); + return -ENODEV; + } + if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC) || + !boot_cpu_has(X86_FEATURE_CONSTANT_TSC) || + !boot_cpu_has(X86_FEATURE_MWAIT) || + !boot_cpu_has(X86_FEATURE_ARAT)) + return -ENODEV; + + /* find the deepest mwait value */ + find_target_mwait(); + + return 0; +} + +static int powerclamp_debug_show(struct seq_file *m, void *unused) +{ + int i = 0; + + seq_printf(m, "controlling cpu: %d\n", control_cpu); + seq_printf(m, "pct confidence steady dynamic (compensation)\n"); + for (i = 0; i < MAX_TARGET_RATIO; i++) { + seq_printf(m, "%d\t%lu\t%lu\t%lu\n", + i, + cal_data[i].confidence, + cal_data[i].steady_comp, + cal_data[i].dynamic_comp); + } + + return 0; +} + +static int powerclamp_debug_open(struct inode *inode, + struct file *file) +{ + return single_open(file, powerclamp_debug_show, inode->i_private); +} + +static const struct file_operations powerclamp_debug_fops = { + .open = powerclamp_debug_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, + .owner = THIS_MODULE, +}; + +static inline void powerclamp_create_debug_files(void) +{ + debug_dir = debugfs_create_dir("intel_powerclamp", NULL); + if (!debug_dir) + return; + + if (!debugfs_create_file("powerclamp_calib", S_IRUGO, debug_dir, + cal_data, &powerclamp_debug_fops)) + goto file_error; + + return; + +file_error: + debugfs_remove_recursive(debug_dir); +} + +static int powerclamp_init(void) +{ + int retval; + int bitmap_size; + + bitmap_size = BITS_TO_LONGS(num_possible_cpus()) * sizeof(long); + cpu_clamping_mask = kzalloc(bitmap_size, GFP_KERNEL); + if (!cpu_clamping_mask) + return -ENOMEM; + + /* probe cpu features and ids here */ + retval = powerclamp_probe(); + if (retval) + return retval; + /* set default limit, maybe adjusted during runtime based on feedback */ + window_size = 2; + register_hotcpu_notifier(&powerclamp_cpu_notifier); + powerclamp_thread = alloc_percpu(struct task_struct *); + cooling_dev = thermal_cooling_device_register("intel_powerclamp", NULL, + &powerclamp_cooling_ops); + if (IS_ERR(cooling_dev)) + return -ENODEV; + + if (!duration) + duration = jiffies_to_msecs(DEFAULT_DURATION_JIFFIES); + powerclamp_create_debug_files(); + + return 0; +} +module_init(powerclamp_init); + +static void powerclamp_exit(void) +{ + unregister_hotcpu_notifier(&powerclamp_cpu_notifier); + end_power_clamp(); + free_percpu(powerclamp_thread); + thermal_cooling_device_unregister(cooling_dev); + kfree(cpu_clamping_mask); + + cancel_delayed_work_sync(&poll_pkg_cstate_work); + debugfs_remove_recursive(debug_dir); +} +module_exit(powerclamp_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Arjan van de Ven <arjan@linux.intel.com>"); +MODULE_AUTHOR("Jacob Pan <jacob.jun.pan@linux.intel.com>"); +MODULE_DESCRIPTION("Package Level C-state Idle Injection for Intel CPUs"); diff --git a/drivers/thermal/kirkwood_thermal.c b/drivers/thermal/kirkwood_thermal.c new file mode 100644 index 00000000..dfeceaff --- /dev/null +++ b/drivers/thermal/kirkwood_thermal.c @@ -0,0 +1,132 @@ +/* + * Kirkwood thermal sensor driver + * + * Copyright (C) 2012 Nobuhiro Iwamatsu <iwamatsu@nigauri.org> + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + * + */ +#include <linux/device.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/kernel.h> +#include <linux/of.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/thermal.h> + +#define KIRKWOOD_THERMAL_VALID_OFFSET 9 +#define KIRKWOOD_THERMAL_VALID_MASK 0x1 +#define KIRKWOOD_THERMAL_TEMP_OFFSET 10 +#define KIRKWOOD_THERMAL_TEMP_MASK 0x1FF + +/* Kirkwood Thermal Sensor Dev Structure */ +struct kirkwood_thermal_priv { + void __iomem *sensor; +}; + +static int kirkwood_get_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + unsigned long reg; + struct kirkwood_thermal_priv *priv = thermal->devdata; + + reg = readl_relaxed(priv->sensor); + + /* Valid check */ + if (!((reg >> KIRKWOOD_THERMAL_VALID_OFFSET) & + KIRKWOOD_THERMAL_VALID_MASK)) { + dev_err(&thermal->device, + "Temperature sensor reading not valid\n"); + return -EIO; + } + + /* + * Calculate temperature. According to Marvell internal + * documentation the formula for this is: + * Celsius = (322-reg)/1.3625 + */ + reg = (reg >> KIRKWOOD_THERMAL_TEMP_OFFSET) & + KIRKWOOD_THERMAL_TEMP_MASK; + *temp = ((3220000000UL - (10000000UL * reg)) / 13625); + + return 0; +} + +static struct thermal_zone_device_ops ops = { + .get_temp = kirkwood_get_temp, +}; + +static const struct of_device_id kirkwood_thermal_id_table[] = { + { .compatible = "marvell,kirkwood-thermal" }, + {} +}; + +static int kirkwood_thermal_probe(struct platform_device *pdev) +{ + struct thermal_zone_device *thermal = NULL; + struct kirkwood_thermal_priv *priv; + struct resource *res; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) { + dev_err(&pdev->dev, "Failed to get platform resource\n"); + return -ENODEV; + } + + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->sensor = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(priv->sensor)) + return PTR_ERR(priv->sensor); + + thermal = thermal_zone_device_register("kirkwood_thermal", 0, 0, + priv, &ops, NULL, 0, 0); + if (IS_ERR(thermal)) { + dev_err(&pdev->dev, + "Failed to register thermal zone device\n"); + return PTR_ERR(thermal); + } + + platform_set_drvdata(pdev, thermal); + + return 0; +} + +static int kirkwood_thermal_exit(struct platform_device *pdev) +{ + struct thermal_zone_device *kirkwood_thermal = + platform_get_drvdata(pdev); + + thermal_zone_device_unregister(kirkwood_thermal); + platform_set_drvdata(pdev, NULL); + + return 0; +} + +MODULE_DEVICE_TABLE(of, kirkwood_thermal_id_table); + +static struct platform_driver kirkwood_thermal_driver = { + .probe = kirkwood_thermal_probe, + .remove = kirkwood_thermal_exit, + .driver = { + .name = "kirkwood_thermal", + .owner = THIS_MODULE, + .of_match_table = of_match_ptr(kirkwood_thermal_id_table), + }, +}; + +module_platform_driver(kirkwood_thermal_driver); + +MODULE_AUTHOR("Nobuhiro Iwamatsu <iwamatsu@nigauri.org>"); +MODULE_DESCRIPTION("kirkwood thermal driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/thermal/of-thermal.c b/drivers/thermal/of-thermal.c new file mode 100644 index 00000000..4b2b999b --- /dev/null +++ b/drivers/thermal/of-thermal.c @@ -0,0 +1,850 @@ +/* + * of-thermal.c - Generic Thermal Management device tree support. + * + * Copyright (C) 2013 Texas Instruments + * Copyright (C) 2013 Eduardo Valentin <eduardo.valentin@ti.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/thermal.h> +#include <linux/slab.h> +#include <linux/types.h> +#include <linux/of_device.h> +#include <linux/of_platform.h> +#include <linux/err.h> +#include <linux/export.h> +#include <linux/string.h> + +#include "thermal_core.h" + +/*** Private data structures to represent thermal device tree data ***/ + +/** + * struct __thermal_trip - representation of a point in temperature domain + * @np: pointer to struct device_node that this trip point was created from + * @temperature: temperature value in miliCelsius + * @hysteresis: relative hysteresis in miliCelsius + * @type: trip point type + */ + +struct __thermal_trip { + struct device_node *np; + unsigned long int temperature; + unsigned long int hysteresis; + enum thermal_trip_type type; +}; + +/** + * struct __thermal_bind_param - a match between trip and cooling device + * @cooling_device: a pointer to identify the referred cooling device + * @trip_id: the trip point index + * @usage: the percentage (from 0 to 100) of cooling contribution + * @min: minimum cooling state used at this trip point + * @max: maximum cooling state used at this trip point + */ + +struct __thermal_bind_params { + struct device_node *cooling_device; + unsigned int trip_id; + unsigned int usage; + unsigned long min; + unsigned long max; +}; + +/** + * struct __thermal_zone - internal representation of a thermal zone + * @mode: current thermal zone device mode (enabled/disabled) + * @passive_delay: polling interval while passive cooling is activated + * @polling_delay: zone polling interval + * @ntrips: number of trip points + * @trips: an array of trip points (0..ntrips - 1) + * @num_tbps: number of thermal bind params + * @tbps: an array of thermal bind params (0..num_tbps - 1) + * @sensor_data: sensor private data used while reading temperature and trend + * @get_temp: sensor callback to read temperature + * @get_trend: sensor callback to read temperature trend + */ + +struct __thermal_zone { + enum thermal_device_mode mode; + int passive_delay; + int polling_delay; + + /* trip data */ + int ntrips; + struct __thermal_trip *trips; + + /* cooling binding data */ + int num_tbps; + struct __thermal_bind_params *tbps; + + /* sensor interface */ + void *sensor_data; + int (*get_temp)(void *, long *); + int (*get_trend)(void *, long *); +}; + +/*** DT thermal zone device callbacks ***/ + +static int of_thermal_get_temp(struct thermal_zone_device *tz, + unsigned long *temp) +{ + struct __thermal_zone *data = tz->devdata; + + if (!data->get_temp) + return -EINVAL; + + return data->get_temp(data->sensor_data, temp); +} + +static int of_thermal_get_trend(struct thermal_zone_device *tz, int trip, + enum thermal_trend *trend) +{ + struct __thermal_zone *data = tz->devdata; + long dev_trend; + int r; + + if (!data->get_trend) + return -EINVAL; + + r = data->get_trend(data->sensor_data, &dev_trend); + if (r) + return r; + + /* TODO: These intervals might have some thresholds, but in core code */ + if (dev_trend > 0) + *trend = THERMAL_TREND_RAISING; + else if (dev_trend < 0) + *trend = THERMAL_TREND_DROPPING; + else + *trend = THERMAL_TREND_STABLE; + + return 0; +} + +static int of_thermal_bind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + struct __thermal_zone *data = thermal->devdata; + int i; + + if (!data || IS_ERR(data)) + return -ENODEV; + + /* find where to bind */ + for (i = 0; i < data->num_tbps; i++) { + struct __thermal_bind_params *tbp = data->tbps + i; + + if (tbp->cooling_device == cdev->np) { + int ret; + + ret = thermal_zone_bind_cooling_device(thermal, + tbp->trip_id, cdev, + tbp->max, + tbp->min); + if (ret) + return ret; + } + } + + return 0; +} + +static int of_thermal_unbind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + struct __thermal_zone *data = thermal->devdata; + int i; + + if (!data || IS_ERR(data)) + return -ENODEV; + + /* find where to unbind */ + for (i = 0; i < data->num_tbps; i++) { + struct __thermal_bind_params *tbp = data->tbps + i; + + if (tbp->cooling_device == cdev->np) { + int ret; + + ret = thermal_zone_unbind_cooling_device(thermal, + tbp->trip_id, cdev); + if (ret) + return ret; + } + } + + return 0; +} + +static int of_thermal_get_mode(struct thermal_zone_device *tz, + enum thermal_device_mode *mode) +{ + struct __thermal_zone *data = tz->devdata; + + *mode = data->mode; + + return 0; +} + +static int of_thermal_set_mode(struct thermal_zone_device *tz, + enum thermal_device_mode mode) +{ + struct __thermal_zone *data = tz->devdata; + + mutex_lock(&tz->lock); + + if (mode == THERMAL_DEVICE_ENABLED) + tz->polling_delay = data->polling_delay; + else + tz->polling_delay = 0; + + mutex_unlock(&tz->lock); + + data->mode = mode; + thermal_zone_device_update(tz); + + return 0; +} + +static int of_thermal_get_trip_type(struct thermal_zone_device *tz, int trip, + enum thermal_trip_type *type) +{ + struct __thermal_zone *data = tz->devdata; + + if (trip >= data->ntrips || trip < 0) + return -EDOM; + + *type = data->trips[trip].type; + + return 0; +} + +static int of_thermal_get_trip_temp(struct thermal_zone_device *tz, int trip, + unsigned long *temp) +{ + struct __thermal_zone *data = tz->devdata; + + if (trip >= data->ntrips || trip < 0) + return -EDOM; + + *temp = data->trips[trip].temperature; + + return 0; +} + +static int of_thermal_set_trip_temp(struct thermal_zone_device *tz, int trip, + unsigned long temp) +{ + struct __thermal_zone *data = tz->devdata; + + if (trip >= data->ntrips || trip < 0) + return -EDOM; + + /* thermal framework should take care of data->mask & (1 << trip) */ + data->trips[trip].temperature = temp; + + return 0; +} + +static int of_thermal_get_trip_hyst(struct thermal_zone_device *tz, int trip, + unsigned long *hyst) +{ + struct __thermal_zone *data = tz->devdata; + + if (trip >= data->ntrips || trip < 0) + return -EDOM; + + *hyst = data->trips[trip].hysteresis; + + return 0; +} + +static int of_thermal_set_trip_hyst(struct thermal_zone_device *tz, int trip, + unsigned long hyst) +{ + struct __thermal_zone *data = tz->devdata; + + if (trip >= data->ntrips || trip < 0) + return -EDOM; + + /* thermal framework should take care of data->mask & (1 << trip) */ + data->trips[trip].hysteresis = hyst; + + return 0; +} + +static int of_thermal_get_crit_temp(struct thermal_zone_device *tz, + unsigned long *temp) +{ + struct __thermal_zone *data = tz->devdata; + int i; + + for (i = 0; i < data->ntrips; i++) + if (data->trips[i].type == THERMAL_TRIP_CRITICAL) { + *temp = data->trips[i].temperature; + return 0; + } + + return -EINVAL; +} + +static struct thermal_zone_device_ops of_thermal_ops = { + .get_mode = of_thermal_get_mode, + .set_mode = of_thermal_set_mode, + + .get_trip_type = of_thermal_get_trip_type, + .get_trip_temp = of_thermal_get_trip_temp, + .set_trip_temp = of_thermal_set_trip_temp, + .get_trip_hyst = of_thermal_get_trip_hyst, + .set_trip_hyst = of_thermal_set_trip_hyst, + .get_crit_temp = of_thermal_get_crit_temp, + + .bind = of_thermal_bind, + .unbind = of_thermal_unbind, +}; + +/*** sensor API ***/ + +static struct thermal_zone_device * +thermal_zone_of_add_sensor(struct device_node *zone, + struct device_node *sensor, void *data, + int (*get_temp)(void *, long *), + int (*get_trend)(void *, long *)) +{ + struct thermal_zone_device *tzd; + struct __thermal_zone *tz; + + tzd = thermal_zone_get_zone_by_name(zone->name); + if (IS_ERR(tzd)) + return ERR_PTR(-EPROBE_DEFER); + + tz = tzd->devdata; + + mutex_lock(&tzd->lock); + tz->get_temp = get_temp; + tz->get_trend = get_trend; + tz->sensor_data = data; + + tzd->ops->get_temp = of_thermal_get_temp; + tzd->ops->get_trend = of_thermal_get_trend; + mutex_unlock(&tzd->lock); + + return tzd; +} + +/** + * thermal_zone_of_sensor_register - registers a sensor to a DT thermal zone + * @dev: a valid struct device pointer of a sensor device. Must contain + * a valid .of_node, for the sensor node. + * @sensor_id: a sensor identifier, in case the sensor IP has more + * than one sensors + * @data: a private pointer (owned by the caller) that will be passed + * back, when a temperature reading is needed. + * @get_temp: a pointer to a function that reads the sensor temperature. + * @get_trend: a pointer to a function that reads the sensor temperature trend. + * + * This function will search the list of thermal zones described in device + * tree and look for the zone that refer to the sensor device pointed by + * @dev->of_node as temperature providers. For the zone pointing to the + * sensor node, the sensor will be added to the DT thermal zone device. + * + * The thermal zone temperature is provided by the @get_temp function + * pointer. When called, it will have the private pointer @data back. + * + * The thermal zone temperature trend is provided by the @get_trend function + * pointer. When called, it will have the private pointer @data back. + * + * TODO: + * 01 - This function must enqueue the new sensor instead of using + * it as the only source of temperature values. + * + * 02 - There must be a way to match the sensor with all thermal zones + * that refer to it. + * + * Return: On success returns a valid struct thermal_zone_device, + * otherwise, it returns a corresponding ERR_PTR(). Caller must + * check the return value with help of IS_ERR() helper. + */ +struct thermal_zone_device * +thermal_zone_of_sensor_register(struct device *dev, int sensor_id, + void *data, int (*get_temp)(void *, long *), + int (*get_trend)(void *, long *)) +{ + struct device_node *np, *child, *sensor_np; + + np = of_find_node_by_name(NULL, "thermal-zones"); + if (!np) + return ERR_PTR(-ENODEV); + + if (!dev || !dev->of_node) + return ERR_PTR(-EINVAL); + + sensor_np = dev->of_node; + + for_each_child_of_node(np, child) { + struct of_phandle_args sensor_specs; + int ret, id; + + /* For now, thermal framework supports only 1 sensor per zone */ + ret = of_parse_phandle_with_args(child, "thermal-sensors", + "#thermal-sensor-cells", + 0, &sensor_specs); + if (ret) + continue; + + if (sensor_specs.args_count >= 1) { + id = sensor_specs.args[0]; + WARN(sensor_specs.args_count > 1, + "%s: too many cells in sensor specifier %d\n", + sensor_specs.np->name, sensor_specs.args_count); + } else { + id = 0; + } + + if (sensor_specs.np == sensor_np && id == sensor_id) { + of_node_put(np); + return thermal_zone_of_add_sensor(child, sensor_np, + data, + get_temp, + get_trend); + } + } + of_node_put(np); + + return ERR_PTR(-ENODEV); +} +EXPORT_SYMBOL_GPL(thermal_zone_of_sensor_register); + +/** + * thermal_zone_of_sensor_unregister - unregisters a sensor from a DT thermal zone + * @dev: a valid struct device pointer of a sensor device. Must contain + * a valid .of_node, for the sensor node. + * @tzd: a pointer to struct thermal_zone_device where the sensor is registered. + * + * This function removes the sensor callbacks and private data from the + * thermal zone device registered with thermal_zone_of_sensor_register() + * API. It will also silent the zone by remove the .get_temp() and .get_trend() + * thermal zone device callbacks. + * + * TODO: When the support to several sensors per zone is added, this + * function must search the sensor list based on @dev parameter. + * + */ +void thermal_zone_of_sensor_unregister(struct device *dev, + struct thermal_zone_device *tzd) +{ + struct __thermal_zone *tz; + + if (!dev || !tzd || !tzd->devdata) + return; + + tz = tzd->devdata; + + /* no __thermal_zone, nothing to be done */ + if (!tz) + return; + + mutex_lock(&tzd->lock); + tzd->ops->get_temp = NULL; + tzd->ops->get_trend = NULL; + + tz->get_temp = NULL; + tz->get_trend = NULL; + tz->sensor_data = NULL; + mutex_unlock(&tzd->lock); +} +EXPORT_SYMBOL_GPL(thermal_zone_of_sensor_unregister); + +/*** functions parsing device tree nodes ***/ + +/** + * thermal_of_populate_bind_params - parse and fill cooling map data + * @np: DT node containing a cooling-map node + * @__tbp: data structure to be filled with cooling map info + * @trips: array of thermal zone trip points + * @ntrips: number of trip points inside trips. + * + * This function parses a cooling-map type of node represented by + * @np parameter and fills the read data into @__tbp data structure. + * It needs the already parsed array of trip points of the thermal zone + * in consideration. + * + * Return: 0 on success, proper error code otherwise + */ +static int thermal_of_populate_bind_params(struct device_node *np, + struct __thermal_bind_params *__tbp, + struct __thermal_trip *trips, + int ntrips) +{ + struct of_phandle_args cooling_spec; + struct device_node *trip; + int ret, i; + u32 prop; + + /* Default weight. Usage is optional */ + __tbp->usage = 0; + ret = of_property_read_u32(np, "contribution", &prop); + if (ret == 0) + __tbp->usage = prop; + + trip = of_parse_phandle(np, "trip", 0); + if (!trip) { + pr_err("missing trip property\n"); + return -ENODEV; + } + + /* match using device_node */ + for (i = 0; i < ntrips; i++) + if (trip == trips[i].np) { + __tbp->trip_id = i; + break; + } + + if (i == ntrips) { + ret = -ENODEV; + goto end; + } + + ret = of_parse_phandle_with_args(np, "cooling-device", "#cooling-cells", + 0, &cooling_spec); + if (ret < 0) { + pr_err("missing cooling_device property\n"); + goto end; + } + __tbp->cooling_device = cooling_spec.np; + if (cooling_spec.args_count >= 2) { /* at least min and max */ + __tbp->min = cooling_spec.args[0]; + __tbp->max = cooling_spec.args[1]; + } else { + pr_err("wrong reference to cooling device, missing limits\n"); + } + +end: + of_node_put(trip); + + return ret; +} + +/** + * It maps 'enum thermal_trip_type' found in include/linux/thermal.h + * into the device tree binding of 'trip', property type. + */ +static const char * const trip_types[] = { + [THERMAL_TRIP_ACTIVE] = "active", + [THERMAL_TRIP_PASSIVE] = "passive", + [THERMAL_TRIP_HOT] = "hot", + [THERMAL_TRIP_CRITICAL] = "critical", +}; + +/** + * thermal_of_get_trip_type - Get phy mode for given device_node + * @np: Pointer to the given device_node + * @type: Pointer to resulting trip type + * + * The function gets trip type string from property 'type', + * and store its index in trip_types table in @type, + * + * Return: 0 on success, or errno in error case. + */ +static int thermal_of_get_trip_type(struct device_node *np, + enum thermal_trip_type *type) +{ + const char *t; + int err, i; + + err = of_property_read_string(np, "type", &t); + if (err < 0) + return err; + + for (i = 0; i < ARRAY_SIZE(trip_types); i++) + if (!strcasecmp(t, trip_types[i])) { + *type = i; + return 0; + } + + return -ENODEV; +} + +/** + * thermal_of_populate_trip - parse and fill one trip point data + * @np: DT node containing a trip point node + * @trip: trip point data structure to be filled up + * + * This function parses a trip point type of node represented by + * @np parameter and fills the read data into @trip data structure. + * + * Return: 0 on success, proper error code otherwise + */ +static int thermal_of_populate_trip(struct device_node *np, + struct __thermal_trip *trip) +{ + int prop; + int ret; + + ret = of_property_read_u32(np, "temperature", &prop); + if (ret < 0) { + pr_err("missing temperature property\n"); + return ret; + } + trip->temperature = prop; + + ret = of_property_read_u32(np, "hysteresis", &prop); + if (ret < 0) { + pr_err("missing hysteresis property\n"); + return ret; + } + trip->hysteresis = prop; + + ret = thermal_of_get_trip_type(np, &trip->type); + if (ret < 0) { + pr_err("wrong trip type property\n"); + return ret; + } + + /* Required for cooling map matching */ + trip->np = np; + + return 0; +} + +/** + * thermal_of_build_thermal_zone - parse and fill one thermal zone data + * @np: DT node containing a thermal zone node + * + * This function parses a thermal zone type of node represented by + * @np parameter and fills the read data into a __thermal_zone data structure + * and return this pointer. + * + * TODO: Missing properties to parse: thermal-sensor-names and coefficients + * + * Return: On success returns a valid struct __thermal_zone, + * otherwise, it returns a corresponding ERR_PTR(). Caller must + * check the return value with help of IS_ERR() helper. + */ +static struct __thermal_zone * +thermal_of_build_thermal_zone(struct device_node *np) +{ + struct device_node *child = NULL, *gchild; + struct __thermal_zone *tz; + int ret, i; + u32 prop; + + if (!np) { + pr_err("no thermal zone np\n"); + return ERR_PTR(-EINVAL); + } + + tz = kzalloc(sizeof(*tz), GFP_KERNEL); + if (!tz) + return ERR_PTR(-ENOMEM); + + ret = of_property_read_u32(np, "polling-delay-passive", &prop); + if (ret < 0) { + pr_err("missing polling-delay-passive property\n"); + goto free_tz; + } + tz->passive_delay = prop; + + ret = of_property_read_u32(np, "polling-delay", &prop); + if (ret < 0) { + pr_err("missing polling-delay property\n"); + goto free_tz; + } + tz->polling_delay = prop; + + /* trips */ + child = of_get_child_by_name(np, "trips"); + + /* No trips provided */ + if (!child) + goto finish; + + tz->ntrips = of_get_child_count(child); + if (tz->ntrips == 0) /* must have at least one child */ + goto finish; + + tz->trips = kzalloc(tz->ntrips * sizeof(*tz->trips), GFP_KERNEL); + if (!tz->trips) { + ret = -ENOMEM; + goto free_tz; + } + + i = 0; + for_each_child_of_node(child, gchild) { + ret = thermal_of_populate_trip(gchild, &tz->trips[i++]); + if (ret) + goto free_trips; + } + + of_node_put(child); + + /* cooling-maps */ + child = of_get_child_by_name(np, "cooling-maps"); + + /* cooling-maps not provided */ + if (!child) + goto finish; + + tz->num_tbps = of_get_child_count(child); + if (tz->num_tbps == 0) + goto finish; + + tz->tbps = kzalloc(tz->num_tbps * sizeof(*tz->tbps), GFP_KERNEL); + if (!tz->tbps) { + ret = -ENOMEM; + goto free_trips; + } + + i = 0; + for_each_child_of_node(child, gchild) { + ret = thermal_of_populate_bind_params(gchild, &tz->tbps[i++], + tz->trips, tz->ntrips); + if (ret) + goto free_tbps; + } + +finish: + of_node_put(child); + tz->mode = THERMAL_DEVICE_DISABLED; + + return tz; + +free_tbps: + kfree(tz->tbps); +free_trips: + kfree(tz->trips); +free_tz: + kfree(tz); + of_node_put(child); + + return ERR_PTR(ret); +} + +static inline void of_thermal_free_zone(struct __thermal_zone *tz) +{ + kfree(tz->tbps); + kfree(tz->trips); + kfree(tz); +} + +/** + * of_parse_thermal_zones - parse device tree thermal data + * + * Initialization function that can be called by machine initialization + * code to parse thermal data and populate the thermal framework + * with hardware thermal zones info. This function only parses thermal zones. + * Cooling devices and sensor devices nodes are supposed to be parsed + * by their respective drivers. + * + * Return: 0 on success, proper error code otherwise + * + */ +int __init of_parse_thermal_zones(void) +{ + struct device_node *np, *child; + struct __thermal_zone *tz; + struct thermal_zone_device_ops *ops; + + np = of_find_node_by_name(NULL, "thermal-zones"); + if (!np) { + pr_debug("unable to find thermal zones\n"); + return 0; /* Run successfully on systems without thermal DT */ + } + + for_each_child_of_node(np, child) { + struct thermal_zone_device *zone; + struct thermal_zone_params *tzp; + + tz = thermal_of_build_thermal_zone(child); + if (IS_ERR(tz)) { + pr_err("failed to build thermal zone %s: %ld\n", + child->name, + PTR_ERR(tz)); + continue; + } + + ops = kmemdup(&of_thermal_ops, sizeof(*ops), GFP_KERNEL); + if (!ops) + goto exit_free; + + tzp = kzalloc(sizeof(*tzp), GFP_KERNEL); + if (!tzp) { + kfree(ops); + goto exit_free; + } + + /* No hwmon because there might be hwmon drivers registering */ + tzp->no_hwmon = true; + + zone = thermal_zone_device_register(child->name, tz->ntrips, + 0, tz, + ops, tzp, + tz->passive_delay, + tz->polling_delay); + if (IS_ERR(zone)) { + pr_err("Failed to build %s zone %ld\n", child->name, + PTR_ERR(zone)); + kfree(tzp); + kfree(ops); + of_thermal_free_zone(tz); + /* attempting to build remaining zones still */ + } + } + + return 0; + +exit_free: + of_thermal_free_zone(tz); + + /* no memory available, so free what we have built */ + of_thermal_destroy_zones(); + + return -ENOMEM; +} + +/** + * of_thermal_destroy_zones - remove all zones parsed and allocated resources + * + * Finds all zones parsed and added to the thermal framework and remove them + * from the system, together with their resources. + * + */ +void of_thermal_destroy_zones(void) +{ + struct device_node *np, *child; + + np = of_find_node_by_name(NULL, "thermal-zones"); + if (!np) { + pr_err("unable to find thermal zones\n"); + return; + } + + for_each_child_of_node(np, child) { + struct thermal_zone_device *zone; + + zone = thermal_zone_get_zone_by_name(child->name); + if (IS_ERR(zone)) + continue; + + thermal_zone_device_unregister(zone); + kfree(zone->tzp); + kfree(zone->ops); + of_thermal_free_zone(zone->devdata); + } +} diff --git a/drivers/thermal/rcar_thermal.c b/drivers/thermal/rcar_thermal.c new file mode 100644 index 00000000..8d7edd4c --- /dev/null +++ b/drivers/thermal/rcar_thermal.c @@ -0,0 +1,516 @@ +/* + * 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/irq.h> +#include <linux/interrupt.h> +#include <linux/io.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/pm_runtime.h> +#include <linux/reboot.h> +#include <linux/slab.h> +#include <linux/spinlock.h> +#include <linux/thermal.h> + +#define IDLE_INTERVAL 5000 + +#define COMMON_STR 0x00 +#define COMMON_ENR 0x04 +#define COMMON_INTMSK 0x0c + +#define REG_POSNEG 0x20 +#define REG_FILONOFF 0x28 +#define REG_THSCR 0x2c +#define REG_THSSR 0x30 +#define REG_INTCTRL 0x34 + +/* THSCR */ +#define CPCTL (1 << 12) + +/* THSSR */ +#define CTEMP 0x3f + +struct rcar_thermal_common { + void __iomem *base; + struct device *dev; + struct list_head head; + spinlock_t lock; +}; + +struct rcar_thermal_priv { + void __iomem *base; + struct rcar_thermal_common *common; + struct thermal_zone_device *zone; + struct delayed_work work; + struct mutex lock; + struct list_head list; + int id; + int ctemp; +}; + +#define rcar_thermal_for_each_priv(pos, common) \ + list_for_each_entry(pos, &common->head, list) + +#define MCELSIUS(temp) ((temp) * 1000) +#define rcar_zone_to_priv(zone) ((zone)->devdata) +#define rcar_priv_to_dev(priv) ((priv)->common->dev) +#define rcar_has_irq_support(priv) ((priv)->common->base) +#define rcar_id_to_shift(priv) ((priv)->id * 8) + +#ifdef DEBUG +# define rcar_force_update_temp(priv) 1 +#else +# define rcar_force_update_temp(priv) 0 +#endif + +/* + * basic functions + */ +#define rcar_thermal_common_read(c, r) \ + _rcar_thermal_common_read(c, COMMON_ ##r) +static u32 _rcar_thermal_common_read(struct rcar_thermal_common *common, + u32 reg) +{ + return ioread32(common->base + reg); +} + +#define rcar_thermal_common_write(c, r, d) \ + _rcar_thermal_common_write(c, COMMON_ ##r, d) +static void _rcar_thermal_common_write(struct rcar_thermal_common *common, + u32 reg, u32 data) +{ + iowrite32(data, common->base + reg); +} + +#define rcar_thermal_common_bset(c, r, m, d) \ + _rcar_thermal_common_bset(c, COMMON_ ##r, m, d) +static void _rcar_thermal_common_bset(struct rcar_thermal_common *common, + u32 reg, u32 mask, u32 data) +{ + u32 val; + + val = ioread32(common->base + reg); + val &= ~mask; + val |= (data & mask); + iowrite32(val, common->base + reg); +} + +#define rcar_thermal_read(p, r) _rcar_thermal_read(p, REG_ ##r) +static u32 _rcar_thermal_read(struct rcar_thermal_priv *priv, u32 reg) +{ + return ioread32(priv->base + reg); +} + +#define rcar_thermal_write(p, r, d) _rcar_thermal_write(p, REG_ ##r, d) +static void _rcar_thermal_write(struct rcar_thermal_priv *priv, + u32 reg, u32 data) +{ + iowrite32(data, priv->base + reg); +} + +#define rcar_thermal_bset(p, r, m, d) _rcar_thermal_bset(p, REG_ ##r, m, d) +static void _rcar_thermal_bset(struct rcar_thermal_priv *priv, u32 reg, + u32 mask, u32 data) +{ + u32 val; + + val = ioread32(priv->base + reg); + val &= ~mask; + val |= (data & mask); + iowrite32(val, priv->base + reg); +} + +/* + * zone device functions + */ +static int rcar_thermal_update_temp(struct rcar_thermal_priv *priv) +{ + struct device *dev = rcar_priv_to_dev(priv); + int i; + int ctemp, old, new; + int ret = -EINVAL; + + mutex_lock(&priv->lock); + + /* + * TSC decides a value of CPTAP automatically, + * and this is the conditions which validate interrupt. + */ + rcar_thermal_bset(priv, THSCR, CPCTL, CPCTL); + + ctemp = 0; + old = ~0; + for (i = 0; i < 128; i++) { + /* + * we need to wait 300us after changing comparator offset + * to get stable temperature. + * see "Usage Notes" on datasheet + */ + udelay(300); + + new = rcar_thermal_read(priv, THSSR) & CTEMP; + if (new == old) { + ctemp = new; + break; + } + old = new; + } + + if (!ctemp) { + dev_err(dev, "thermal sensor was broken\n"); + goto err_out_unlock; + } + + /* + * enable IRQ + */ + if (rcar_has_irq_support(priv)) { + rcar_thermal_write(priv, FILONOFF, 0); + + /* enable Rising/Falling edge interrupt */ + rcar_thermal_write(priv, POSNEG, 0x1); + rcar_thermal_write(priv, INTCTRL, (((ctemp - 0) << 8) | + ((ctemp - 1) << 0))); + } + + dev_dbg(dev, "thermal%d %d -> %d\n", priv->id, priv->ctemp, ctemp); + + priv->ctemp = ctemp; + ret = 0; +err_out_unlock: + mutex_unlock(&priv->lock); + return ret; +} + +static int rcar_thermal_get_temp(struct thermal_zone_device *zone, + unsigned long *temp) +{ + struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone); + + if (!rcar_has_irq_support(priv) || rcar_force_update_temp(priv)) + rcar_thermal_update_temp(priv); + + mutex_lock(&priv->lock); + *temp = MCELSIUS((priv->ctemp * 5) - 65); + mutex_unlock(&priv->lock); + + return 0; +} + +static int rcar_thermal_get_trip_type(struct thermal_zone_device *zone, + int trip, enum thermal_trip_type *type) +{ + struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone); + struct device *dev = rcar_priv_to_dev(priv); + + /* see rcar_thermal_get_temp() */ + switch (trip) { + case 0: /* +90 <= temp */ + *type = THERMAL_TRIP_CRITICAL; + break; + default: + dev_err(dev, "rcar driver trip error\n"); + return -EINVAL; + } + + return 0; +} + +static int rcar_thermal_get_trip_temp(struct thermal_zone_device *zone, + int trip, unsigned long *temp) +{ + struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone); + struct device *dev = rcar_priv_to_dev(priv); + + /* see rcar_thermal_get_temp() */ + switch (trip) { + case 0: /* +90 <= temp */ + *temp = MCELSIUS(90); + break; + default: + dev_err(dev, "rcar driver trip error\n"); + return -EINVAL; + } + + return 0; +} + +static int rcar_thermal_notify(struct thermal_zone_device *zone, + int trip, enum thermal_trip_type type) +{ + struct rcar_thermal_priv *priv = rcar_zone_to_priv(zone); + struct device *dev = rcar_priv_to_dev(priv); + + switch (type) { + case THERMAL_TRIP_CRITICAL: + /* FIXME */ + dev_warn(dev, "Thermal reached to critical temperature\n"); + break; + default: + break; + } + + return 0; +} + +static struct thermal_zone_device_ops rcar_thermal_zone_ops = { + .get_temp = rcar_thermal_get_temp, + .get_trip_type = rcar_thermal_get_trip_type, + .get_trip_temp = rcar_thermal_get_trip_temp, + .notify = rcar_thermal_notify, +}; + +/* + * interrupt + */ +#define rcar_thermal_irq_enable(p) _rcar_thermal_irq_ctrl(p, 1) +#define rcar_thermal_irq_disable(p) _rcar_thermal_irq_ctrl(p, 0) +static void _rcar_thermal_irq_ctrl(struct rcar_thermal_priv *priv, int enable) +{ + struct rcar_thermal_common *common = priv->common; + unsigned long flags; + u32 mask = 0x3 << rcar_id_to_shift(priv); /* enable Rising/Falling */ + + spin_lock_irqsave(&common->lock, flags); + + rcar_thermal_common_bset(common, INTMSK, mask, enable ? 0 : mask); + + spin_unlock_irqrestore(&common->lock, flags); +} + +static void rcar_thermal_work(struct work_struct *work) +{ + struct rcar_thermal_priv *priv; + + priv = container_of(work, struct rcar_thermal_priv, work.work); + + rcar_thermal_update_temp(priv); + rcar_thermal_irq_enable(priv); + thermal_zone_device_update(priv->zone); +} + +static u32 rcar_thermal_had_changed(struct rcar_thermal_priv *priv, u32 status) +{ + struct device *dev = rcar_priv_to_dev(priv); + + status = (status >> rcar_id_to_shift(priv)) & 0x3; + + if (status & 0x3) { + dev_dbg(dev, "thermal%d %s%s\n", + priv->id, + (status & 0x2) ? "Rising " : "", + (status & 0x1) ? "Falling" : ""); + } + + return status; +} + +static irqreturn_t rcar_thermal_irq(int irq, void *data) +{ + struct rcar_thermal_common *common = data; + struct rcar_thermal_priv *priv; + unsigned long flags; + u32 status, mask; + + spin_lock_irqsave(&common->lock, flags); + + mask = rcar_thermal_common_read(common, INTMSK); + status = rcar_thermal_common_read(common, STR); + rcar_thermal_common_write(common, STR, 0x000F0F0F & mask); + + spin_unlock_irqrestore(&common->lock, flags); + + status = status & ~mask; + + /* + * check the status + */ + rcar_thermal_for_each_priv(priv, common) { + if (rcar_thermal_had_changed(priv, status)) { + rcar_thermal_irq_disable(priv); + schedule_delayed_work(&priv->work, + msecs_to_jiffies(300)); + } + } + + return IRQ_HANDLED; +} + +/* + * platform functions + */ +static int rcar_thermal_probe(struct platform_device *pdev) +{ + struct rcar_thermal_common *common; + struct rcar_thermal_priv *priv; + struct device *dev = &pdev->dev; + struct resource *res, *irq; + int mres = 0; + int i; + int ret = -ENODEV; + int idle = IDLE_INTERVAL; + + common = devm_kzalloc(dev, sizeof(*common), GFP_KERNEL); + if (!common) { + dev_err(dev, "Could not allocate common\n"); + return -ENOMEM; + } + + INIT_LIST_HEAD(&common->head); + spin_lock_init(&common->lock); + common->dev = dev; + + pm_runtime_enable(dev); + pm_runtime_get_sync(dev); + + irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); + if (irq) { + int ret; + + /* + * platform has IRQ support. + * Then, drier use common register + */ + res = platform_get_resource(pdev, IORESOURCE_MEM, mres++); + if (!res) { + dev_err(dev, "Could not get platform resource\n"); + return -ENODEV; + } + + ret = devm_request_irq(dev, irq->start, rcar_thermal_irq, 0, + dev_name(dev), common); + if (ret) { + dev_err(dev, "irq request failed\n "); + return ret; + } + + /* + * rcar_has_irq_support() will be enabled + */ + common->base = devm_ioremap_resource(dev, res); + if (IS_ERR(common->base)) + return PTR_ERR(common->base); + + /* enable temperature comparation */ + rcar_thermal_common_write(common, ENR, 0x00030303); + + idle = 0; /* polling delaye is not needed */ + } + + for (i = 0;; i++) { + res = platform_get_resource(pdev, IORESOURCE_MEM, mres++); + if (!res) + break; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) { + dev_err(dev, "Could not allocate priv\n"); + ret = -ENOMEM; + goto error_unregister; + } + + priv->base = devm_ioremap_resource(dev, res); + if (IS_ERR(priv->base)) { + ret = PTR_ERR(priv->base); + goto error_unregister; + } + + priv->common = common; + priv->id = i; + mutex_init(&priv->lock); + INIT_LIST_HEAD(&priv->list); + INIT_DELAYED_WORK(&priv->work, rcar_thermal_work); + rcar_thermal_update_temp(priv); + + priv->zone = thermal_zone_device_register("rcar_thermal", + 1, 0, priv, + &rcar_thermal_zone_ops, NULL, 0, + idle); + if (IS_ERR(priv->zone)) { + dev_err(dev, "can't register thermal zone\n"); + ret = PTR_ERR(priv->zone); + goto error_unregister; + } + + if (rcar_has_irq_support(priv)) + rcar_thermal_irq_enable(priv); + + list_move_tail(&priv->list, &common->head); + } + + platform_set_drvdata(pdev, common); + + dev_info(dev, "%d sensor proved\n", i); + + return 0; + +error_unregister: + rcar_thermal_for_each_priv(priv, common) { + thermal_zone_device_unregister(priv->zone); + if (rcar_has_irq_support(priv)) + rcar_thermal_irq_disable(priv); + } + + pm_runtime_put_sync(dev); + pm_runtime_disable(dev); + + return ret; +} + +static int rcar_thermal_remove(struct platform_device *pdev) +{ + struct rcar_thermal_common *common = platform_get_drvdata(pdev); + struct device *dev = &pdev->dev; + struct rcar_thermal_priv *priv; + + rcar_thermal_for_each_priv(priv, common) { + thermal_zone_device_unregister(priv->zone); + if (rcar_has_irq_support(priv)) + rcar_thermal_irq_disable(priv); + } + + platform_set_drvdata(pdev, NULL); + + pm_runtime_put_sync(dev); + pm_runtime_disable(dev); + + return 0; +} + +static const struct of_device_id rcar_thermal_dt_ids[] = { + { .compatible = "renesas,rcar-thermal", }, + {}, +}; +MODULE_DEVICE_TABLE(of, rcar_thermal_dt_ids); + +static struct platform_driver rcar_thermal_driver = { + .driver = { + .name = "rcar_thermal", + .of_match_table = rcar_thermal_dt_ids, + }, + .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 <kuninori.morimoto.gx@renesas.com>"); diff --git a/drivers/thermal/spear_thermal.c b/drivers/thermal/spear_thermal.c new file mode 100644 index 00000000..3c5ee560 --- /dev/null +++ b/drivers/thermal/spear_thermal.c @@ -0,0 +1,209 @@ +/* + * SPEAr thermal driver. + * + * Copyright (C) 2011-2012 ST Microelectronics + * Author: Vincenzo Frascino <vincenzo.frascino@st.com> + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + * + */ + +#include <linux/clk.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/io.h> +#include <linux/kernel.h> +#include <linux/of.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/thermal.h> + +#define MD_FACTOR 1000 + +/* SPEAr Thermal Sensor Dev Structure */ +struct spear_thermal_dev { + /* pointer to base address of the thermal sensor */ + void __iomem *thermal_base; + /* clk structure */ + struct clk *clk; + /* pointer to thermal flags */ + unsigned int flags; +}; + +static inline int thermal_get_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + struct spear_thermal_dev *stdev = thermal->devdata; + + /* + * Data are ready to be read after 628 usec from POWERDOWN signal + * (PDN) = 1 + */ + *temp = (readl_relaxed(stdev->thermal_base) & 0x7F) * MD_FACTOR; + return 0; +} + +static struct thermal_zone_device_ops ops = { + .get_temp = thermal_get_temp, +}; + +#ifdef CONFIG_PM +static int spear_thermal_suspend(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct thermal_zone_device *spear_thermal = platform_get_drvdata(pdev); + struct spear_thermal_dev *stdev = spear_thermal->devdata; + unsigned int actual_mask = 0; + + /* Disable SPEAr Thermal Sensor */ + actual_mask = readl_relaxed(stdev->thermal_base); + writel_relaxed(actual_mask & ~stdev->flags, stdev->thermal_base); + + clk_disable(stdev->clk); + dev_info(dev, "Suspended.\n"); + + return 0; +} + +static int spear_thermal_resume(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct thermal_zone_device *spear_thermal = platform_get_drvdata(pdev); + struct spear_thermal_dev *stdev = spear_thermal->devdata; + unsigned int actual_mask = 0; + int ret = 0; + + ret = clk_enable(stdev->clk); + if (ret) { + dev_err(&pdev->dev, "Can't enable clock\n"); + return ret; + } + + /* Enable SPEAr Thermal Sensor */ + actual_mask = readl_relaxed(stdev->thermal_base); + writel_relaxed(actual_mask | stdev->flags, stdev->thermal_base); + + dev_info(dev, "Resumed.\n"); + + return 0; +} +#endif + +static SIMPLE_DEV_PM_OPS(spear_thermal_pm_ops, spear_thermal_suspend, + spear_thermal_resume); + +static int spear_thermal_probe(struct platform_device *pdev) +{ + struct thermal_zone_device *spear_thermal = NULL; + struct spear_thermal_dev *stdev; + struct device_node *np = pdev->dev.of_node; + struct resource *stres = platform_get_resource(pdev, IORESOURCE_MEM, 0); + int ret = 0, val; + + if (!np || !of_property_read_u32(np, "st,thermal-flags", &val)) { + dev_err(&pdev->dev, "Failed: DT Pdata not passed\n"); + return -EINVAL; + } + + if (!stres) { + dev_err(&pdev->dev, "memory resource missing\n"); + return -ENODEV; + } + + stdev = devm_kzalloc(&pdev->dev, sizeof(*stdev), GFP_KERNEL); + if (!stdev) { + dev_err(&pdev->dev, "kzalloc fail\n"); + return -ENOMEM; + } + + /* Enable thermal sensor */ + stdev->thermal_base = devm_ioremap(&pdev->dev, stres->start, + resource_size(stres)); + if (!stdev->thermal_base) { + dev_err(&pdev->dev, "ioremap failed\n"); + return -ENOMEM; + } + + stdev->clk = devm_clk_get(&pdev->dev, NULL); + if (IS_ERR(stdev->clk)) { + dev_err(&pdev->dev, "Can't get clock\n"); + return PTR_ERR(stdev->clk); + } + + ret = clk_enable(stdev->clk); + if (ret) { + dev_err(&pdev->dev, "Can't enable clock\n"); + return ret; + } + + stdev->flags = val; + writel_relaxed(stdev->flags, stdev->thermal_base); + + spear_thermal = thermal_zone_device_register("spear_thermal", 0, 0, + stdev, &ops, NULL, 0, 0); + if (IS_ERR(spear_thermal)) { + dev_err(&pdev->dev, "thermal zone device is NULL\n"); + ret = PTR_ERR(spear_thermal); + goto disable_clk; + } + + platform_set_drvdata(pdev, spear_thermal); + + dev_info(&spear_thermal->device, "Thermal Sensor Loaded at: 0x%p.\n", + stdev->thermal_base); + + return 0; + +disable_clk: + clk_disable(stdev->clk); + + return ret; +} + +static int spear_thermal_exit(struct platform_device *pdev) +{ + unsigned int actual_mask = 0; + struct thermal_zone_device *spear_thermal = platform_get_drvdata(pdev); + struct spear_thermal_dev *stdev = spear_thermal->devdata; + + thermal_zone_device_unregister(spear_thermal); + platform_set_drvdata(pdev, NULL); + + /* Disable SPEAr Thermal Sensor */ + actual_mask = readl_relaxed(stdev->thermal_base); + writel_relaxed(actual_mask & ~stdev->flags, stdev->thermal_base); + + clk_disable(stdev->clk); + + return 0; +} + +static const struct of_device_id spear_thermal_id_table[] = { + { .compatible = "st,thermal-spear1340" }, + {} +}; +MODULE_DEVICE_TABLE(of, spear_thermal_id_table); + +static struct platform_driver spear_thermal_driver = { + .probe = spear_thermal_probe, + .remove = spear_thermal_exit, + .driver = { + .name = "spear_thermal", + .owner = THIS_MODULE, + .pm = &spear_thermal_pm_ops, + .of_match_table = of_match_ptr(spear_thermal_id_table), + }, +}; + +module_platform_driver(spear_thermal_driver); + +MODULE_AUTHOR("Vincenzo Frascino <vincenzo.frascino@st.com>"); +MODULE_DESCRIPTION("SPEAr thermal driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/thermal/sprd_2713_thm.c b/drivers/thermal/sprd_2713_thm.c new file mode 100644 index 00000000..cdb96ae9 --- /dev/null +++ b/drivers/thermal/sprd_2713_thm.c @@ -0,0 +1,500 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * 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. + * + */ + +#include <linux/kernel.h> +#include <linux/err.h> +#include <mach/hardware.h> +#include <soc/sprd/sci.h> +#include <soc/sprd/sci_glb_regs.h> +#include <linux/io.h> +#include <soc/sprd/adi.h> +#include "thm.h" +#include <linux/sprd_thm.h> +#include <mach/arch_misc.h> + +#define SPRD_THM_DEBUG +#ifdef SPRD_THM_DEBUG +#define THM_DEBUG(format, arg...) printk("sprd thm: " "@@@" format, ## arg) +#else +#define THM_DEBUG(format, arg...) +#endif + +#define THM_CTRL (0x0000) +#define THM_INT_CTRL (0x0004) +#define SENSOR_CTRL (0x0020) +#define SENSOR_DET_PERI (0x0024) +#define SENSOR_INT_CTRL (0x0028) +#define SENSOR_INT_STS (0x002C) +#define SENSOR_INT_RAW_STS (0x0030) +#define SENSOR_INT_CLR (0x0034) +#define SENSOR_OVERHEAT_HOT_THRES (0X0040) +#define SENSOR_HOT2NOR__HIGHOFF_THRES (0X0044) +#define SENSOR_LOWOFF__COLD_THRES (0X0048) +#define SENSOR_TEMPER0_READ (0x0058) + +#define SEN_OVERHEAT_INT_BIT (1 << 5) +#define SEN_HOT_INT_BIT (1 << 4) +#define SEN_HOT2NOR_INT_BIT (1 << 3) +#define SEN_HIGHOFF_BIT (1 << 2) +#define SEN_LOWOFF_INT_BIT (1 << 1) + +#define RAW_TEMP_OFFSET 8 +#define RAW_TEMP_RANGE_MSK 0x7F + +#define HIGH_BITS_OFFSET 4 + +#define HIGH_TAB_SZ 8 +#define LOW_TAB_SZ 16 + +#define HOT2NOR_RANGE 15 +#define LOCAL_SENSOR_ADDR_OFF 0x100 +#define DELAY_TEMPERATURE 3 +#define INTOFFSET 3 + +#define TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +static const short temp_search_high_40nm[HIGH_TAB_SZ] = + { -41, -14, 14, 41, 68, 95, 122, 150 }; +static const short temp_search_low_40nm[LOW_TAB_SZ] = + { 0, 2, 4, 5, 7, 8, 10, 12, 14, 15, 17, 19, 20, 22, 24, 26 }; +static const short temp_search_high_152nm[HIGH_TAB_SZ] = + { -45, -19, 7, 33, 59, 85, 111, 137 }; +static const short temp_search_low_152nm[LOW_TAB_SZ] = + { 0, 2, 3, 5, 6, 8, 10, 11, 13, 14, 16, 18, 19, 21, 22, 24 }; + +static u32 current_trip_num = 0; +static int arm_sen_cal_offset = 0; +static int pmic_sen_cal_offset = 0; + +extern unsigned long SPRD_THM_BASE; +extern unsigned int SPRD_THM_SIZE; + +static inline int __thm_reg_write(u32 reg, u16 bits, u16 clear_msk); +static inline u32 __thm_reg_read(u32 reg); +int sprd_thm_set_active_trip(struct sprd_thermal_zone *pzone, int trip ); +u32 sprd_thm_temp2rawdata(u32 sensor, int temp); + +static inline int __thm_reg_write(u32 reg, u16 bits, u16 clear_msk) +{ + if (reg >= SPRD_THM_BASE && reg <= (SPRD_THM_BASE + SPRD_THM_SIZE)) { + __raw_writel(((__raw_readl((volatile void *)reg) & ~clear_msk) | bits), (volatile void *)(reg)); + } else if (reg >= ANA_THM_BASE && reg <= (ANA_THM_BASE + SPRD_THM_SIZE)) { + sci_adi_write(reg, bits, clear_msk); + } else { + printk(KERN_ERR "error thm reg0x:%x \n", reg); + } + return 0; +} + +static inline u32 __thm_reg_read(u32 reg) +{ + if (reg >= SPRD_THM_BASE && reg <= (SPRD_THM_BASE + SPRD_THM_SIZE)) { + return __raw_readl((volatile void *)reg); + } else if (reg >= ANA_THM_BASE && reg <= (ANA_THM_BASE + SPRD_THM_SIZE)) { + return sci_adi_read(reg); + } else { + printk(KERN_ERR "error thm reg0x:%x \n", reg); + } + return 0; +} + +int sprd_thm_set_active_trip(struct sprd_thermal_zone *pzone, int trip ) +{ + u32 raw_temp = 0; + u32 local_sen_id = 0; + u32 local_sensor_addr = 0; + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + + THM_DEBUG("thm sensor id:%d, trip:%d \n", pzone->sensor_id, trip); + if (trip < 0 || trip > (trip_tab->num_trips - 1)) + return -1; + if (trip_tab->trip_points[trip].type != THERMAL_TRIP_ACTIVE) + return -1; + + local_sen_id = pzone->sensor_id; + local_sensor_addr = + (u32) pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + + //Disable sensor int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL),0,(0x7F & (~SEN_OVERHEAT_INT_BIT))); + + //set hot int temp value + THM_DEBUG("thm sensor trip:%d, temperature:%d \n", trip, trip_tab->trip_points[trip].temp); + raw_temp = + sprd_thm_temp2rawdata(pzone->sensor_id, + trip_tab->trip_points[trip].temp - pmic_sen_cal_offset - INTOFFSET); + if (raw_temp < RAW_TEMP_RANGE_MSK) { + raw_temp++; + } + __thm_reg_write((local_sensor_addr + SENSOR_OVERHEAT_HOT_THRES), + raw_temp, + RAW_TEMP_RANGE_MSK); + + //set Hot2Normal int temp value + raw_temp = + sprd_thm_temp2rawdata(pzone->sensor_id, trip_tab->trip_points[trip].lowoff - INTOFFSET - pmic_sen_cal_offset); + __thm_reg_write((local_sensor_addr + SENSOR_HOT2NOR__HIGHOFF_THRES), + raw_temp << RAW_TEMP_OFFSET, + RAW_TEMP_RANGE_MSK << RAW_TEMP_OFFSET); + + //set cold int temp value + raw_temp = + sprd_thm_temp2rawdata(pzone->sensor_id, trip_tab->trip_points[trip].lowoff - INTOFFSET - pmic_sen_cal_offset); + __thm_reg_write((local_sensor_addr + SENSOR_LOWOFF__COLD_THRES), + raw_temp << RAW_TEMP_OFFSET, + RAW_TEMP_RANGE_MSK << RAW_TEMP_OFFSET); + + THM_DEBUG("thm OVERHEAT_HOT:0x%x, HOT2NOR__HIGHOFF:0x%x, LOWOFF__COLD:0x%x\n", __thm_reg_read(local_sensor_addr + SENSOR_OVERHEAT_HOT_THRES), + __thm_reg_read(local_sensor_addr + SENSOR_HOT2NOR__HIGHOFF_THRES), __thm_reg_read(local_sensor_addr + SENSOR_LOWOFF__COLD_THRES)); + + // Restart sensor to enable new paramter + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x9, 0x9); + + if (trip > 0) + { + //enable Hot int and Lowoff int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), + SEN_HOT_INT_BIT | SEN_LOWOFF_INT_BIT, + SEN_HOT_INT_BIT | SEN_LOWOFF_INT_BIT); + } + else + { + //enable Hot int and disable LOWOFF int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), + SEN_HOT_INT_BIT, + SEN_HOT_INT_BIT | SEN_LOWOFF_INT_BIT); + } + + return 0; +} + +u32 sprd_thm_temp2rawdata(u32 sensor, int temp) +{ + u32 high_bits, low_bits; + int i; + const short *high_tab; + const short *low_tab; + + if (SPRD_ARM_SENSOR == sensor) { + high_tab = temp_search_high_40nm; + low_tab = temp_search_low_40nm; + } else if (SPRD_PMIC_SENSOR == sensor) { + high_tab = temp_search_high_152nm; + low_tab = temp_search_low_152nm; + } else { + printk(KERN_ERR "error thm sensor id:%d \n", sensor); + return 0; + } + + if (temp < high_tab[0]) { + printk(KERN_ERR "temp over low temp:%d \n", temp); + return 0; + } + + for (i = HIGH_TAB_SZ - 1; i >= 0; i--) { + if (high_tab[i] <= temp) + break; + } + if (i < 0) { + i = 0; + } + temp -= high_tab[i]; + high_bits = i; + + for (i = LOW_TAB_SZ - 1; i >= 0; i--) { + if (low_tab[i] <= temp) + break; + } + if (i < 0) { + i = 0; + } + low_bits = i; + return ((high_bits << HIGH_BITS_OFFSET) | low_bits); + +} + +int sprd_thm_rawdata2temp(u32 sensor, int rawdata) +{ + const short *high_tab; + const short *low_tab; + + if (SPRD_ARM_SENSOR == sensor) { + high_tab = temp_search_high_40nm; + low_tab = temp_search_low_40nm; + } else if (SPRD_PMIC_SENSOR == sensor) { + high_tab = temp_search_high_152nm; + low_tab = temp_search_low_152nm; + } else { + printk(KERN_ERR "error thm sensor id:%d \n", sensor); + return 0; + } + + return high_tab[(rawdata >> HIGH_BITS_OFFSET) & 0x07] + + low_tab[rawdata & 0x0F]; +} + +int sprd_thm_temp_read(struct sprd_thermal_zone *pzone) +{ + u32 rawdata = 0; + int cal_offset = 0; + u32 sensor = pzone->sensor_id; + + if (SPRD_ARM_SENSOR == sensor) { + rawdata = __thm_reg_read((SPRD_THM_BASE + SENSOR_TEMPER0_READ)); + cal_offset = arm_sen_cal_offset; + } else if (SPRD_PMIC_SENSOR == sensor) { + rawdata = __thm_reg_read(ANA_THM_BASE + SENSOR_TEMPER0_READ); + cal_offset = pmic_sen_cal_offset; + } else { + printk(KERN_ERR "error thm sensor id:%d \n", sensor); + return 0; + } + THM_DEBUG("thm sensor id:%d, cal_offset:%d, rawdata:0x%x\n", sensor, + cal_offset, rawdata); + return sprd_thm_rawdata2temp(sensor, rawdata) + cal_offset; +} +int sprd_thm_chip_id_check(void) +{ + u32 chip_id_tmp; + + chip_id_tmp = sci_get_chip_id(); + +#if !defined(CONFIG_ARCH_SCX15) + return 0; +#else + if ((TSMC_DOLPHINW4T_CHIP_ID_1 == chip_id_tmp) || (TSMC_DOLPHINW4T_CHIP_ID_2 == chip_id_tmp) || + (TSMC_DOLPHINWT4T_CHIP_ID_1 == chip_id_tmp)) { + //printk("Sprd thm the chip support thermal CHIP_ID:0x%x \n",chip_id_tmp); + return 0; + } else { + printk("Sprd thm the chip don't support thermal CHIP_ID:0x%x \n",chip_id_tmp); + return -1; + } +#endif +} +int sprd_thm_hw_init(struct sprd_thermal_zone *pzone) +{ + u32 local_sensor_addr, base_addr = 0; + u32 local_sen_id = 0; + u32 raw_temp = 0; + int cal_offset = 0; + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + + base_addr = (u32) pzone->reg_base; + + printk(KERN_NOTICE "sprd_thm_hw_init 2713_thm id:%d,base 0x%x\n", + pzone->sensor_id, base_addr); + + if (SPRD_ARM_SENSOR == pzone->sensor_id) { + //ddie thm en + sci_glb_set(REG_AON_APB_APB_EB1, BIT_THM_EB); + sci_glb_set(REG_AON_APB_APB_RTC_EB, + (BIT_THM_RTC_EB | BIT_ARM_THMA_RTC_EB | + BIT_ARM_THMA_RTC_AUTO_EN)); + cal_offset = arm_sen_cal_offset = 0; + local_sen_id = 0; + } else if (SPRD_PMIC_SENSOR == pzone->sensor_id) { + //adie thm en + sci_adi_set(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_THM_EN); + sci_adi_set(ANA_REG_GLB_RTC_CLK_EN, + BIT_RTC_THMA_AUTO_EN | BIT_RTC_THMA_EN | + BIT_RTC_THM_EN); + cal_offset = pmic_sen_cal_offset = 0; + local_sen_id = 0; + } else { + printk(KERN_ERR "error thm sensor id:%d \n", pzone->sensor_id); + return -EINVAL; + } + __thm_reg_write((base_addr + THM_CTRL), 0x1 >> local_sen_id, 0); + __thm_reg_write((base_addr + THM_INT_CTRL), 0x3, 0); //enable top int + + local_sensor_addr = base_addr + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + + //set int + if (trip_tab->num_trips > 0) { +#if 0 + //set hot + if (trip_tab->trip_points[0].type == THERMAL_TRIP_ACTIVE) { + raw_temp = + sprd_thm_temp2rawdata(pzone->sensor_id, + trip_tab->trip_points[0]. + temp - cal_offset); + if (raw_temp < RAW_TEMP_RANGE_MSK) { + raw_temp++; + } + //set hot int temp value + __thm_reg_write((local_sensor_addr + + SENSOR_OVERHEAD_HOT_THRES), raw_temp, + RAW_TEMP_RANGE_MSK); + raw_temp = + sprd_thm_temp2rawdata(pzone->sensor_id, + trip_tab->trip_points[0]. + temp - HOT2NOR_RANGE - + cal_offset); + //set hot2nor int temp value + __thm_reg_write((local_sensor_addr + + SENSOR_HOT2NOR__HIGHOFF_THRES), + raw_temp << RAW_TEMP_OFFSET, + RAW_TEMP_RANGE_MSK << RAW_TEMP_OFFSET); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), //enable int + SEN_HOT2NOR_INT_BIT | SEN_HOT_INT_BIT, + 0); + } +#else + current_trip_num = 0; + sprd_thm_set_active_trip(pzone,current_trip_num); +#endif + //set overheat + if (trip_tab->trip_points[trip_tab->num_trips - 1].type == + THERMAL_TRIP_CRITICAL) { + raw_temp = + sprd_thm_temp2rawdata(pzone->sensor_id, + trip_tab->trip_points + [trip_tab->num_trips - + 1].temp - cal_offset); + //set overheat int temp value + __thm_reg_write((local_sensor_addr + + SENSOR_OVERHEAT_HOT_THRES), + raw_temp << RAW_TEMP_OFFSET, + RAW_TEMP_RANGE_MSK << RAW_TEMP_OFFSET); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), //enable int + SEN_OVERHEAT_INT_BIT, 0); + } + } + + printk(KERN_NOTICE "sprd_thm_hw_init addr 0x:%x,int ctrl 0x%x\n", + local_sensor_addr, + __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL))); + + // Set sensor det period is 2.25S + __thm_reg_write((local_sensor_addr + SENSOR_DET_PERI), 0x2000, 0x2000); + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x101, 0x101); + + // Start the sensor by set Sen_set_rdy(bit3) + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x8, 0x8); + + return 0; + +} + +int sprd_thm_hw_disable_sensor(struct sprd_thermal_zone *pzone) +{ + int ret = 0; + // Sensor minitor disable + if(SPRD_ARM_SENSOR == pzone->sensor_id){ + __thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL), 0x0, 0x8); + __thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL), 0x00, 0x01); + } + return ret; + +} + +int sprd_thm_hw_enable_sensor(struct sprd_thermal_zone *pzone) +{ + int ret = 0; + // Sensor minitor enable + THM_DEBUG("sprd_2713_thm enable sensor sensor_ID:0x%x \n",pzone->sensor_id); + if(SPRD_ARM_SENSOR == pzone->sensor_id){ + __thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL), 0x01, 0x01); + __thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL), 0x8, 0x8); + } + return ret; + +} + + +u16 int_ctrl_reg[SPRD_MAX_SENSOR]; +int sprd_thm_hw_suspend(struct sprd_thermal_zone *pzone) +{ + u32 local_sen_id = 0; + u32 local_sensor_addr; + int ret = 0; + + local_sensor_addr = + (u32) pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + int_ctrl_reg[pzone->sensor_id] = __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL)); + + sprd_thm_hw_disable_sensor(pzone); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + return ret; +} +int sprd_thm_hw_resume(struct sprd_thermal_zone *pzone) +{ + u32 local_sen_id = 0; + u32 local_sensor_addr; + int ret = 0; + + local_sensor_addr = + (u32) pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + + sprd_thm_hw_enable_sensor(pzone); + if(SPRD_ARM_SENSOR == pzone->sensor_id){ + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), int_ctrl_reg[pzone->sensor_id], ~0); //enable int of saved + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x9, 0); + } + return ret; +} + +int sprd_thm_hw_irq_handle(struct sprd_thermal_zone *pzone) +{ + u32 local_sen_id = 0; + u32 local_sensor_addr; + u32 int_sts; + int ret = 0; + u32 overhead_hot_tem_cur = 0; + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + int temp; + + local_sensor_addr = + (u32) pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + int_sts = __thm_reg_read(local_sensor_addr + SENSOR_INT_STS); + + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), int_sts, ~0); //CLR INT + temp = sprd_thm_temp_read(pzone->sensor_id); + + printk("sprd_thm_hw_irq_handle --------@@@------id:%d, int_sts :0x%x \n", + pzone->sensor_id, int_sts); + printk("sprd_thm_hw_irq_handle ------$$$--------temp:%d\n", temp); + + overhead_hot_tem_cur = __thm_reg_read((local_sensor_addr + SENSOR_OVERHEAT_HOT_THRES)) + & RAW_TEMP_RANGE_MSK; + + if (int_sts & SEN_HOT_INT_BIT){ + if ((current_trip_num) >= (trip_tab->num_trips - 2)){ + current_trip_num = trip_tab->num_trips - 2; + return ret; + } + if (temp >= trip_tab->trip_points[current_trip_num].temp - INTOFFSET){ + current_trip_num++; + sprd_thm_set_active_trip(pzone,current_trip_num); + } + }else if (int_sts & SEN_LOWOFF_INT_BIT){ + if (temp < trip_tab->trip_points[current_trip_num].lowoff + INTOFFSET){ + current_trip_num--; + sprd_thm_set_active_trip(pzone,current_trip_num); + } + }else{ + THM_DEBUG("sprd_thm_hw_irq_handle NOT a HOT or LOWOFF interrupt \n"); + return ret; + } + return ret; +} diff --git a/drivers/thermal/sprd_board_sensor.c b/drivers/thermal/sprd_board_sensor.c new file mode 100644 index 00000000..ed730e1f --- /dev/null +++ b/drivers/thermal/sprd_board_sensor.c @@ -0,0 +1,535 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * 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. + * + */ + + +#include <linux/kernel.h> +#include <linux/err.h> +#include <soc/sprd/sci.h> +#include <soc/sprd/sci_glb_regs.h> +#include <linux/io.h> +#include <soc/sprd/adi.h> +#include "thm.h" +#include <linux/sprd_thm.h> +#include <soc/sprd/arch_misc.h> +#include <soc/sprd/hardware.h> +#include "thermal_core.h" +#include <soc/sprd/adc.h> +#include <linux/module.h> +#include <linux/of_device.h> +#include <linux/platform_device.h> +#include <linux/thermal.h> +#include <linux/slab.h> + +//#define SPRD_THM_BOARD_DEBUG +#ifdef SPRD_THM_BOARD_DEBUG +#define THM_BOARD_DEBUG(format, arg...) printk("sprd board thm: " "@@@" format, ## arg) +#else +#define THM_BOARD_DEBUG(format, arg...) +#endif + +#define THM_SENOR_NUM 8 +extern int sprd_thermal_init(struct sprd_thermal_zone *pzone); +extern void sprd_thermal_remove(struct sprd_thermal_zone *pzone); + + +struct sprd_board_sensor_config *pthm_config; +//extern uint16_t sprdchg_bat_adc_to_vol(uint16_t adcvalue); + +static int sprdthm_read_temp_adc(void) +{ +#define SAMPLE_NUM 15 + int cnt = pthm_config->temp_adc_sample_cnt; + + if (cnt > SAMPLE_NUM) { + cnt = SAMPLE_NUM; + } else if (cnt < 1) { + cnt = 1; + } + + if (pthm_config->temp_support) { + int ret, i, j, temp; + int adc_val[cnt]; + struct adc_sample_data data = { + .channel_id = pthm_config->temp_adc_ch, + .channel_type = 0, /*sw */ + .hw_channel_delay = 0, /*reserved */ + .scale = pthm_config->temp_adc_scale, /*small scale */ + .pbuf = &adc_val[0], + .sample_num = cnt, + .sample_bits = 1, + .sample_speed = 0, /*quick mode */ + .signal_mode = 0, /*resistance path */ + }; + + ret = sci_adc_get_values(&data); + WARN_ON(0 != ret); + + for (j = 1; j <= cnt - 1; j++) { + for (i = 0; i < cnt - j; i++) { + if (adc_val[i] > adc_val[i + 1]) { + temp = adc_val[i]; + adc_val[i] = adc_val[i + 1]; + adc_val[i + 1] = temp; + } + } + } + THM_BOARD_DEBUG("sprdthm: channel:%d,sprdthm_read_temp_adc:%d\n", + data.channel_id, adc_val[cnt / 2]); + return adc_val[cnt / 2]; + } else { + return 3000; + } +} + +static int sprdthm_interpolate(int x, int n, struct sprdboard_table_data *tab) +{ + int index; + int y; + + if (x >= tab[0].x) + y = tab[0].y; + else if (x <= tab[n - 1].x) + y = tab[n - 1].y; + else { + /* find interval */ + for (index = 1; index < n; index++) + if (x > tab[index].x) + break; + /* interpolate */ + y = (tab[index - 1].y - tab[index].y) * (x - tab[index].x) + * 2 / (tab[index - 1].x - tab[index].x); + y = (y + 1) / 2; + y += tab[index].y; + } + return y; +} +static uint16_t sprdthm_adc_to_vol(uint16_t channel, int scale, + uint16_t adcvalue) +{ + uint32_t result; + uint32_t vthm_vol = adc2vbat(adcvalue,scale); + uint32_t m, n; + uint32_t thm_numerators, thm_denominators; + uint32_t numerators, denominators; + + sci_adc_get_vol_ratio(ADC_CHANNEL_VBAT, 0, &thm_numerators, + &thm_denominators); + sci_adc_get_vol_ratio(channel, scale, &numerators, &denominators); + + ///v1 = vbat_vol*0.268 = vol_bat_m * r2 /(r1+r2) + n = thm_denominators * numerators; + m = vthm_vol * thm_numerators * (denominators); + result = (m + n / 2) / n; + return result; +} + +static int sprdthm_search_temp_tab(int val) +{ + return sprdthm_interpolate(val, pthm_config->temp_tab_size, + pthm_config->temp_tab); +} + +static int sprd_board_thm_get_reg_base(struct sprd_thermal_zone *pzone ,struct resource *regs) +{ + return 0; +} +static int sprd_board_thm_set_active_trip(struct sprd_thermal_zone *pzone, int trip ) +{ + return 0; +} + +static unsigned long sprd_board_thm_temp_read(struct sprd_thermal_zone *pzone) +{ + int temp; + if (pthm_config->temp_support) { + int val = sprdthm_read_temp_adc(); + //voltage mode + if (pthm_config->temp_table_mode) { + val =sprdthm_adc_to_vol(pthm_config->temp_adc_ch, + pthm_config->temp_adc_scale, val); + THM_BOARD_DEBUG("sprdthm: sprdthm_read_temp voltage:%d\n", val); + } + THM_BOARD_DEBUG("sprd_board_thm_temp_read y=%d\n",sprdthm_search_temp_tab(val)); + temp = sprdthm_search_temp_tab(val); + printk("sensor id:%d,rawdata:0x%x, temp:%lu\n", pzone->sensor_id, val, temp*1000); + return temp*1000; + } else { + return -35000; + } + +} + +static int sprd_board_thm_hw_init(struct sprd_thermal_zone *pzone) +{ + THM_BOARD_DEBUG("sprd_board_thm_hw_init\n"); + pthm_config=pzone->sensor_config; + + return 0; +} + + +static int sprd_board_thm_hw_suspend(struct sprd_thermal_zone *pzone) +{ + THM_BOARD_DEBUG("sprd_board_thm_hw_suspend\n"); + + return 0; +} +static int sprd_board_thm_hw_resume(struct sprd_thermal_zone *pzone) +{ + + THM_BOARD_DEBUG("sprd_board_thm_hw_resume\n"); + + return 0; +} +#ifdef THM_TEST +static int sprd_board_thm_trip_set(struct sprd_thermal_zone *pzone,int trip) +{ + THM_BOARD_DEBUG("sprd_thm_trip_set trip=%d, temp=%ld,lowoff =%ld\n", + trip,pzone->trip_tab->trip_points[trip].temp,pzone->trip_tab->trip_points[trip].lowoff); + return 0; +} +#endif + +static int sprd_board_thm_get_trend(struct sprd_thermal_zone *pzone, int trip, enum thermal_trend *ptrend) +{ + *ptrend = pzone->trend_val; + return 0; +} + +static int sprd_board_thm_get_hyst(struct sprd_thermal_zone *pzone, int trip, unsigned long *physt) +{ + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + if (trip >= trip_tab->num_trips - 2){ + *physt = 0; + }else{ + *physt = trip_tab->trip_points[trip].temp - trip_tab->trip_points[trip + 1].lowoff; + } + return 0; +} + +struct thm_handle_ops sprd_boardthm_ops = +{ + .hw_init = sprd_board_thm_hw_init, + .get_reg_base = sprd_board_thm_get_reg_base, + .read_temp = sprd_board_thm_temp_read, + .get_trend = sprd_board_thm_get_trend, + .get_hyst = sprd_board_thm_get_hyst, + .suspend = sprd_board_thm_hw_suspend, + .resume = sprd_board_thm_hw_resume, + .trip_debug_set = sprd_board_thm_trip_set, +}; + +#ifdef CONFIG_OF +static struct sprd_thm_platform_data *thermal_detect_parse_dt( + struct device *dev) +{ + struct sprd_thm_platform_data *pdata; + struct device_node *np = dev->of_node; + u32 trip_points_critical,trip_num; + char prop_name[32]; + const char *tmp_str; + u32 tmp_data,tmp_lowoff; + int ret,i ,j = 0; + pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); + if (!pdata) { + dev_err(dev, "could not allocate memory for platform data\n"); + return NULL; + } + ret = of_property_read_u32(np, "trip-points-critical", &trip_points_critical); + if(ret){ + dev_err(dev, "fail to get trip_points_critical\n"); + goto fail; + } + ret = of_property_read_u32(np, "trip-num", &trip_num); + if(ret){ + dev_err(dev, "fail to get trip_num\n"); + goto fail; + } + for (i = 0; i <trip_num-1; ++i) { + sprintf(prop_name, "trip%d-temp-active", i); + if (of_property_read_u32(np, prop_name, &tmp_data)){ + dev_err(dev, "fail to get trip%d-temp-active\n",i); + goto fail; + } + + pdata->trip_points[i].temp = tmp_data; + sprintf(prop_name, "trip%d-temp-lowoff", i); + if (of_property_read_u32(np, prop_name, &tmp_lowoff)){ + dev_err(dev, "fail to get trip%d-temp-lowoff\n",i); + goto fail; + } + pdata->trip_points[i].lowoff = tmp_lowoff; + sprintf(prop_name, "trip%d-type", i); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto fail; + + if (!strcmp(tmp_str, "active")) + pdata->trip_points[i].type = THERMAL_TRIP_ACTIVE; + else if (!strcmp(tmp_str, "passive")) + pdata->trip_points[i].type = THERMAL_TRIP_PASSIVE; + else if (!strcmp(tmp_str, "hot")) + pdata->trip_points[i].type = THERMAL_TRIP_HOT; + else if (!strcmp(tmp_str, "critical")) + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + else + goto fail; + + sprintf(prop_name, "trip%d-cdev-num", i); + if (of_property_read_u32(np, prop_name, &tmp_data)) + goto fail; + for (j = 0; j < tmp_data; j++) { + sprintf(prop_name, "trip%d-cdev-name%d", i, j); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto fail; + strcpy(pdata->trip_points[i].cdev_name[j], tmp_str); + dev_info(dev,"cdev name: %s \n", pdata->trip_points[i].cdev_name[j]); + } + dev_info(dev, "trip[%d] temp: %lu lowoff: %lu\n", + i, pdata->trip_points[i].temp, pdata->trip_points[i].lowoff); + } + pdata->trip_points[i].temp = trip_points_critical; + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + dev_info(dev, "trip[%d] temp: %lu \n", + i, pdata->trip_points[i].temp); + pdata->num_trips = trip_num; + + return pdata; + +fail: + kfree(pdata); + return NULL; + +} + +static struct sprd_board_sensor_config *sprdboard_thermal_parse_dt( + struct device *dev) +{ + struct sprd_board_sensor_config *pconfig; + struct device_node *np = dev->of_node; + int ret,i; + int temp; + int temp_adc_ch,temp_adc_scale,temp_adc_sample_cnt; + int temp_table_mode,temp_tab_size,temp_support; + pconfig = kzalloc(sizeof(*pconfig), GFP_KERNEL); + if (!pconfig) { + dev_err(dev, "could not allocate memory for platform data\n"); + return NULL; + } + ret =of_property_read_u32(np, "temp-adc-ch",&temp_adc_ch); + if(ret){ + dev_err(dev, "sprd_thermal_probe No temp-adc-ch\n"); + goto fail; + } + ret =of_property_read_u32(np, "temp-adc-scale",&temp_adc_scale); + if(ret){ + dev_err(dev, "sprd_thermal_probe No temp_adc_scale\n"); + goto fail; + } + ret =of_property_read_u32(np, "temp-adc-sample-cnt",&temp_adc_sample_cnt); + if(ret){ + dev_err(dev, "fail to get temp_adc_sample_cnt\n"); + goto fail; + } + ret =of_property_read_u32(np, "temp-table-mode",&temp_table_mode); + if(ret){ + dev_err(dev, "fail to get temp_table_mode\n"); + goto fail; + } + ret =of_property_read_u32(np, "temp-tab-size",&temp_tab_size); + if(ret){ + dev_err(dev, "fail to get temp_tab_size\n"); + goto fail; + } + ret =of_property_read_u32(np, "temp-support",&temp_support); + if(ret){ + dev_err(dev, "fail to get temp_support\n"); + goto fail; + } + pconfig->temp_adc_ch=temp_adc_ch; + pconfig->temp_adc_sample_cnt=temp_adc_sample_cnt; + pconfig->temp_adc_scale=temp_adc_scale; + pconfig->temp_table_mode=temp_table_mode; + pconfig->temp_support=temp_support; + pconfig->temp_tab_size=temp_tab_size; + pconfig->temp_tab = kzalloc(sizeof(struct sprdboard_table_data) * + pconfig->temp_tab_size-1, GFP_KERNEL); + for (i = 0; i < pconfig->temp_tab_size-1; i++) { + ret = of_property_read_u32_index(np, "temp-tab-val", i, + &pconfig->temp_tab[i].x); + if(ret){ + dev_err(dev, "fail to get temp-tab-va\n"); + goto fail; + } + ret = of_property_read_u32_index(np, "temp-tab-temp", i, &temp); + if(ret){ + dev_err(dev, "fail to get temp-tab-temp\n"); + goto fail; + } + pconfig->temp_tab[i].y = temp - 1000; + } + return pconfig; +fail: + kfree(pconfig); + return NULL; +} + +#endif +static int sprd_board_thm_probe(struct platform_device *pdev) +{ + struct sprd_thermal_zone *pzone = NULL; + struct sprd_thm_platform_data *ptrips = NULL; + struct sprd_board_sensor_config *pconfig = NULL; + const char *thm_name; + int ret,temp_interval,sensor_id; + printk("sprd_thermal_probe---------start\n"); +#ifdef CONFIG_OF + struct device_node *np = pdev->dev.of_node; +#endif + +#ifdef CONFIG_OF + if (!np) { + dev_err(&pdev->dev, "device node not found\n"); + return -EINVAL; + } + pconfig = sprdboard_thermal_parse_dt(&pdev->dev); + if (!pconfig){ + dev_err(&pdev->dev, "not found ptrips\n"); + return -EINVAL; + } + ptrips = thermal_detect_parse_dt(&pdev->dev); +#else + ptrips = dev_get_platdata(&pdev->dev); +#endif + if (!ptrips){ + dev_err(&pdev->dev, "not found ptrips\n"); + return -EINVAL; + } + pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL); + if (!pzone){ + kfree(pconfig); + kfree(ptrips); + return -ENOMEM; + } + mutex_init(&pzone->th_lock); + mutex_lock(&pzone->th_lock); + printk("sprd_ddie_thm_probe start\n"); +#if 0 + pdev->id = of_alias_get_id(np, "thmzone"); + printk(KERN_INFO " sprd_thermal_probe id:%d\n", pdev->id); + if (unlikely(pdev->id < 0 || pdev->id >= THM_SENOR_NUM)) { + dev_err(&pdev->dev, "does not support id %d\n", pdev->id); + return -ENXIO; + } +#endif + ret = of_property_read_u32(np, "temp-inteval", &temp_interval); + if(ret){ + dev_err(&pdev->dev, "fail to get temp-inteval\n"); + return -EINVAL; + } + ret = of_property_read_u32(np, "id", &sensor_id); + if (ret) { + dev_err(&pdev->dev, "fail to get id\n"); + return -EINVAL; + } + of_property_read_string(np, "thermal-name",&thm_name); + strcpy(pzone->thermal_zone_name, thm_name); + pzone->trip_tab = ptrips; + pzone->mode = THERMAL_DEVICE_DISABLED; + pzone->trip_tab = ptrips; + pzone->sensor_config= pconfig; + pzone->trend_val = THERMAL_TREND_STABLE; + pzone->temp_inteval = temp_interval; + pzone->sensor_id = sensor_id; + pzone->ops = &sprd_boardthm_ops; + ret = sprd_board_thm_hw_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone hw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + ret = sprd_thermal_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone sw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + platform_set_drvdata(pdev, pzone); + printk("sprd_ddie_thm_probe end\n"); + mutex_unlock(&pzone->th_lock); + return 0; +} + +static int sprd_board_thm_remove(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + sprd_thermal_remove(pzone); + return 0; +} +static int sprd_board_thm_suspend(struct platform_device *pdev, + pm_message_t state) +{ + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + //flush_delayed_work(&pzone->thm_logtime_work); + flush_delayed_work(&pzone->thm_read_work); + flush_delayed_work(&pzone->resume_delay_work); + pzone->ops->suspend(pzone); + return 0; +} +static int sprd_board_thm_resume(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + schedule_delayed_work(&pzone->resume_delay_work, (HZ * 1)); + schedule_delayed_work(&pzone->thm_read_work, (HZ * 5)); + //schedule_delayed_work(&pzone->thm_logtime_work, (HZ * 7)); + //pzone->ops->resume(pzone); + return 0; +} + +#ifdef CONFIG_OF +static const struct of_device_id thermal_of_match[] = { + { .compatible = "sprd,board-thermal", }, + {} +}; +#endif + +static struct platform_driver sprd_thermal_driver = { + .probe = sprd_board_thm_probe, + .suspend = sprd_board_thm_suspend, + .resume = sprd_board_thm_resume, + .remove = sprd_board_thm_remove, + .driver = { + .owner = THIS_MODULE, + .name = "board-thermal", +#ifdef CONFIG_OF + .of_match_table = of_match_ptr(thermal_of_match), +#endif + }, +}; +static int __init sprd_board_thermal_init(void) +{ + return platform_driver_register(&sprd_thermal_driver); +} + +static void __exit sprd_board_thermal_exit(void) +{ + platform_driver_unregister(&sprd_thermal_driver); +} + +device_initcall_sync(sprd_board_thermal_init); +module_exit(sprd_board_thermal_exit); +MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>"); +MODULE_DESCRIPTION("sprd thermal driver"); +MODULE_LICENSE("GPL"); + diff --git a/drivers/thermal/sprd_cpu_cooling.c b/drivers/thermal/sprd_cpu_cooling.c new file mode 100644 index 00000000..29e14bc3 --- /dev/null +++ b/drivers/thermal/sprd_cpu_cooling.c @@ -0,0 +1,604 @@ +/* + * linux/drivers/thermal/sprd_cpu_cooling.c + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * 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/slab.h> +#include <linux/err.h> +#include <linux/types.h> +#include <linux/thermal.h> +#include <linux/sprd_cpu_cooling.h> +#include <linux/platform_device.h> +#include <linux/cpumask.h> +#ifdef CONFIG_OF +#include <linux/of_device.h> +#endif + +#define SPRDCPU_DEBUG__ +#ifdef SPRDCPU_DEBUG__ +#define SPRDCPU_DEBUG(format, arg...) pr_info("cpu-cooling: " format, ## arg) +#else +#define SPRDCPU_DEBUG(format, arg...) +#endif + +struct cpu_cooling_param_t { + int state; + int max_core; + int limit_freq; + int low_freq; + int low_vol; +}; + +struct thermal_cooling_info_t { + unsigned long cooling_state; + struct thermal_cooling_device *cdev; + struct sprd_cpu_cooling_platform_data *pdata; + int max_state; + int enable; + int cluster; + struct cpu_cooling_param_t param; +#if defined(CONFIG_ARCH_SCX35L) && !defined(CONFIG_ARCH_SCX35LT8) + int binning; +#endif +}; + +static ssize_t sprd_cpu_store_caliberate(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count); +static ssize_t sprd_cpu_show_caliberate(struct device *dev, + struct device_attribute *attr, + char *buf); + +/* sys I/F for cooling device */ +#define to_cooling_device(_dev) \ + container_of(_dev, struct thermal_cooling_device, device) + +#define SPRD_CPU_CALIBERATE_ATTR(_name) \ +{ \ + .attr = { .name = #_name, .mode = S_IRUGO | S_IWUSR | S_IWGRP,}, \ + .show = sprd_cpu_show_caliberate, \ + .store = sprd_cpu_store_caliberate, \ +} +#define SPRD_CPU_CALIBERATE_ATTR_RO(_name) \ +{ \ + .attr = { .name = #_name, .mode = S_IRUGO, }, \ + .show = sprd_cpu_show_caliberate, \ +} +#define SPRD_CPU_CALIBERATE_ATTR_WO(_name) \ +{ \ + .attr = { .name = #_name, .mode = S_IWUSR | S_IWGRP, }, \ + .store = sprd_cpu_store_caliberate, \ +} + +static struct device_attribute sprd_cpu_caliberate[] = { + SPRD_CPU_CALIBERATE_ATTR(cur_ctrl_param), +}; + +static int sprd_cpu_creat_caliberate_attr(struct device *dev) +{ + int i, rc; + + for (i = 0; i < ARRAY_SIZE(sprd_cpu_caliberate); i++) { + rc = device_create_file(dev, &sprd_cpu_caliberate[i]); + if (rc) + goto sprd_attrs_failed; + } + goto sprd_attrs_succeed; + +sprd_attrs_failed: + while (i--) + device_remove_file(dev, &sprd_cpu_caliberate[i]); + +sprd_attrs_succeed: + return rc; +} + +static int sprd_cpu_remove_caliberate_attr(struct device *dev) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(sprd_cpu_caliberate); i++) { + device_remove_file(dev, &sprd_cpu_caliberate[i]); + } + return 0; +} + + +static ssize_t sprd_cpu_show_caliberate(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int i = 0; + int offset = 0; + struct thermal_cooling_device *cdev = to_cooling_device(dev); + struct thermal_cooling_info_t *info = cdev->devdata; + unsigned long *data = &info->param; + int len = sizeof(info->param) / sizeof(info->param.state); + + for (i = 0; i < len; i++) + offset += sprintf(buf + offset, "%ld,", data[i]); + buf[offset - 1] = '\n'; + + SPRDCPU_DEBUG("dev_attr_cur_ctrl_param: %s\n", buf); + return offset; +} + +#define BUF_LEN 64 +static ssize_t sprd_cpu_store_caliberate(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int i = 0; + char *str = NULL; + char *pbuf; + char *after = NULL; + char buffer[BUF_LEN]; + struct thermal_cooling_device *cdev = to_cooling_device(dev); + struct thermal_cooling_info_t *info = cdev->devdata; + int *data = &info->param; + int len = sizeof(info->param) / sizeof(info->param.state); + + if (count > BUF_LEN){ + count = BUF_LEN; + } + strncpy(buffer, buf, count); + buffer[count] = '\0'; + printk("buf param form usespace:%s\n", buf); + printk("buffer parm:%s\n", buffer); + pbuf = buffer; + while ((pbuf!= NULL) && (i < len)) + { + str = strsep(&pbuf, ","); + data[i++] = simple_strtoul(str, &after, 0); + } + printk("sprd_cpu_cooling_param_t.status: %d\n", info->param.state); + printk("sprd_cpu_cooling_param_t.core_num: %d\n", info->param.max_core); + printk("sprd_cpu_cooling_param_t.freq: %d\n", info->param.limit_freq); + printk("sprd_cpu_cooling_param_t.low_freq: %d\n", info->param.low_freq); + printk("sprd_cpu_cooling_param_t.low_vol: %d\n", info->param.low_vol); + + cpufreq_thermal_limit(info->cluster, info->param.limit_freq); + cpu_core_thermal_limit(info->cluster, info->param.max_core); +#if defined(CONFIG_ARCH_SCX35L) && !defined(CONFIG_ARCH_SCX35LT8) + if (info->binning == 0){ +#endif + if (info->param.low_freq > 0 && info->param.low_vol > 0){ + cpufreq_table_thermal_update(info->param.low_freq, info->param.low_vol); + info->param.low_freq = 0; + info->param.low_vol = 0; + } +#if defined(CONFIG_ARCH_SCX35L) && !defined(CONFIG_ARCH_SCX35LT8) + } +#endif + + return count; +} + +#if !defined(CONFIG_SPRD_CPU_DYNAMIC_HOTPLUG) && !defined(CONFIG_CPU_FREQ_GOV_SPRDEMAND) +int cpu_core_thermal_limit(int cluster, int max_core) +{ +#ifdef CONFIG_HOTPLUG_CPU + int cpuid, cpus; + int first_cpu, last_cpu; + + if (cluster){ + first_cpu = NR_CPUS / 2; + last_cpu = NR_CPUS - 1; + }else{ + first_cpu = 0; +#ifdef CONFIG_SCHED_HMP + last_cpu = NR_CPUS / 2 -1; +#else + last_cpu = NR_CPUS - 1; +#endif + } + for (cpus = 0, cpuid = first_cpu; cpuid <= last_cpu; ++cpuid){ + if (cpu_online(cpuid)){ + cpus++; + } + } + if (max_core == cpus){ + return 0; + } + if (cpus < max_core){ + /* plug cpu */ + for (cpuid = first_cpu; cpuid <= last_cpu; ++cpuid){ + if (cpu_online(cpuid)){ + continue; + } + pr_info("cpu-cooling: we gonna plugin cpu%d !!\n", cpuid); + if (cpu_up(cpuid)){ + pr_info("plug cpu%d failed!\n", cpuid); + } + if (++cpus >= max_core){ + return 0; + } + } + }else{ + /* unplug cpu */ + for (cpuid = last_cpu; cpuid >= first_cpu; --cpuid){ + if (!cpu_online(cpuid)){ + continue; + } + pr_info("cpu-cooling: we gonna unplug cpu%d !!\n", cpuid); + if (cpu_down(cpuid)){ + pr_info("unplug cpu%d failed!\n", cpuid); + } + if (--cpus <= max_core){ + return 0; + } + } + } +#endif + + return 0; +} +#endif + +static int get_max_state(struct thermal_cooling_device *cdev, + unsigned long *state) +{ + struct thermal_cooling_info_t *info = cdev->devdata; + int ret = 0; + + *state = info->max_state; + + return ret; +} + +static int get_cur_state(struct thermal_cooling_device *cdev, + unsigned long *state) +{ + struct thermal_cooling_info_t *info = cdev->devdata; + int ret = 0; + + *state = info->cooling_state; + + return ret; +} + +static int thermal_set_vddarm(struct thermal_cooling_info_t *c_info, + unsigned long state) +{ + int i, j; + struct vddarm_update *pvddarm = c_info->pdata->vddarm_update; + struct freq_vddarm *pfreq_vddarm; + + if (pvddarm == NULL){ + printk("%s vddarm_update isn't configed.\n", __func__); + return -1; + } + for (i = 0; pvddarm[i].freq_vddarm; ++i){ + if (state != pvddarm[i].state){ + continue; + } + pfreq_vddarm = pvddarm[i].freq_vddarm; + for (j = 0; pfreq_vddarm[j].freq; ++j){ + cpufreq_table_thermal_update(pfreq_vddarm[j].freq, + pfreq_vddarm[j].vddarm_mv); + } + } + + return 0; +} + +static int set_cur_state(struct thermal_cooling_device *cdev, + unsigned long state) +{ + struct thermal_cooling_info_t *c_info = cdev->devdata; + int max_core; + int limit_freq; + + if (c_info->max_state <= 0){ + return 0; + } + thermal_set_vddarm(c_info, state); + + if (c_info->enable && c_info->cooling_state == state){ + return 0; + }else{ + c_info->cooling_state = state; + } + + limit_freq = c_info->pdata->cpu_state[state].max_freq; + max_core = c_info->pdata->cpu_state[state].max_core; + c_info->enable = 1; + pr_info("%s %s: %d limit_freq: %d kHz max_core: %d\n", + cdev->type, __func__, state, limit_freq, max_core); + cpufreq_thermal_limit(c_info->cluster, limit_freq); + cpu_core_thermal_limit(c_info->cluster, max_core); + + return 0; +} + +static struct thermal_cooling_device_ops sprd_cpufreq_cooling_ops = { + .get_max_state = get_max_state, + .get_cur_state = get_cur_state, + .set_cur_state = set_cur_state, +}; + +#ifdef CONFIG_OF +static int get_vddarm_updata_dt_data(struct device_node *np, + struct sprd_cpu_cooling_platform_data *pdata) +{ + struct vddarm_update *pvddarm; + int vddarm_nr[MAX_CPU_STATE]; + char name[32]; + int data[32]; + int freq_nr; + int i, j, k, ret; + + ret = of_property_read_u32_array(np, "vddarm_nr", vddarm_nr, 1); + if(ret){ + printk(KERN_ERR "fail to get vddarm_nr\n"); + goto error; + } + + ret = of_property_read_u32_array(np, "vddarm_nr", vddarm_nr, vddarm_nr[0] + 1); + if (ret){ + printk(KERN_ERR "fail to get all vddarm_nr data.\n"); + goto error; + } + printk("%s vddarm_nr:<", __func__); + for (i = 0; i < vddarm_nr[0]; ++i){ + printk("%d ", vddarm_nr[i + 1]); + } + printk(">\n"); + + pvddarm = kzalloc(sizeof(*pvddarm) * (vddarm_nr[0] + 1), GFP_KERNEL); + if (pvddarm == NULL){ + goto error; + } + + for (i = 0; i < vddarm_nr[0]; ++i){ + sprintf(name, "vddarm_update%d", i); + ret = of_property_read_u32_array(np, name, data, vddarm_nr[i + 1]); + if(ret){ + printk(KERN_ERR "fail to get %s len:%d\n", name, vddarm_nr[i + 1]); + goto vddarm_err; + } + freq_nr = (vddarm_nr[i + 1] - 1) / 2; + pvddarm[i].freq_vddarm = kzalloc(sizeof(struct freq_vddarm) * (freq_nr + 1), GFP_KERNEL); + if (pvddarm[i].freq_vddarm == NULL){ + goto vddarm_err; + } + printk("%s state: <", __func__); + for (j = 0; j < vddarm_nr[i + 1]; ++j){ + printk("%d ", data[j]); + } + printk(">\n"); + pvddarm[i].state = data[0]; + for (j = 0, k = 1; j < freq_nr; ++j){ + pvddarm[i].freq_vddarm[j].freq = data[k++]; + pvddarm[i].freq_vddarm[j].vddarm_mv = data[k++]; + } + pvddarm[i].freq_vddarm[j].freq = 0; + } + pvddarm[i].freq_vddarm = NULL; + pdata->vddarm_update = pvddarm; + + return 0; +vddarm_err: + for (j = 0; j < i; ++j){ + if (pvddarm[j].freq_vddarm){ + kfree(pvddarm[j].freq_vddarm); + pvddarm[j].freq_vddarm = NULL; + } + } + kfree(pvddarm); +error: + pdata->vddarm_update = NULL; + return -1; +} + +static struct sprd_cpu_cooling_platform_data *get_cpu_cooling_dt_data( + struct device *dev, struct thermal_cooling_info_t *info) +{ + struct sprd_cpu_cooling_platform_data *pdata = NULL; + struct device_node *np = dev->of_node; + int max_freq[MAX_CPU_STATE]; + int max_core[MAX_CPU_STATE]; + int ret, i; + + if (!np) { + dev_err(dev, "device node not found\n"); + return -EINVAL; + } + pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); + if (!pdata) { + dev_err(dev, "could not allocate memory for platform data\n"); + return -1; + } + ret = of_property_read_u32(np, "cluster", &info->cluster); + if(ret){ + info->cluster = 0; + } + dev_info(dev, "cluster: %s\n", info->cluster ? "big" : "little"); + ret = of_property_read_u32(np, "state_num", &pdata->state_num); + if(ret || pdata->state_num <= 0){ + dev_info(dev, "no state_num dts config, Don't use kernel thermal policy.\n"); + pdata->state_num = 0; + info->max_state = 0; + goto done; + } + dev_info(dev, "state_num=%d\n", pdata->state_num); + ret = of_property_read_u32_array(np, "max_freq", max_freq, pdata->state_num); + if(ret){ + dev_err(dev, "fail to get max_freq\n"); + goto error; + } + ret = of_property_read_u32_array(np, "max_core", max_core, pdata->state_num); + if(ret){ + dev_err(dev, "fail to get max_core\n"); + goto error; + } + for (i = 0; i < pdata->state_num; ++i){ + pdata->cpu_state[i].max_freq = max_freq[i]; + pdata->cpu_state[i].max_core = max_core[i]; + dev_info(dev, "state:%d, max_freq:%d, max_core:%d\n", i, max_freq[i], max_core[i]); + } + info->max_state = pdata->state_num - 1; +done: + get_vddarm_updata_dt_data(np, pdata); + + return pdata; + +error: + kfree(pdata); + pdata = NULL; + return pdata; +} +#endif + +#if defined(CONFIG_ARCH_SCX35L) && !defined(CONFIG_ARCH_SCX35LT8) +extern int sci_efuse_Dhryst_binning_get(int *val); +#endif +static int sprd_cpu_cooling_probe(struct platform_device *pdev) +{ + struct thermal_cooling_info_t *info = NULL; + struct sprd_cpu_cooling_platform_data *pdata = NULL; + char cdev_name[32]; + int ret = 0; +#if defined(CONFIG_ARCH_SCX35L) && !defined(CONFIG_ARCH_SCX35LT8) + int val = 0; +#endif + + if (NULL == pdev){ + return -1; + } + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) { + dev_err(&pdev->dev, "could not allocate memory for info data\n"); + return -1; + } +#ifdef CONFIG_OF + ret = of_property_read_u32(pdev->dev.of_node, "id", &pdev->id); + if(ret || pdev->id < 0){ + pdev->id = 0; + } + pdata = get_cpu_cooling_dt_data(&pdev->dev, info); + if (!pdata){ + ret = -1; + goto err; + } + pdev->dev.platform_data = pdata; +#else + pdata = dev_get_platdata(&pdev->dev); + if (NULL == pdata){ + dev_err(&pdev->dev, "%s platform data is NULL!\n", __func__); + ret = -1; + goto err; + } + info->max_state = pdata->state_num - 1; +#endif + + pdata->devdata = info; + info->pdata = pdata; + info->cooling_state = 0, + info->enable = 0, + + info->param.state = 0; + info->param.max_core = 0; + info->param.limit_freq = 0; + info->param.low_freq = 0; + info->param.low_vol = 0; +#if defined(CONFIG_ARCH_SCX35L) && !defined(CONFIG_ARCH_SCX35LT8) + sci_efuse_Dhryst_binning_get(&val); + dev_info(&pdev->dev, "sci_efuse_Dhryst_binning_get--val : %d\n", val); + if ((val < 28) && (val >= 22)){ + info->binning = 1; + }else{ + info->binning = 0; + } + dev_info(&pdev->dev, "binning : %d\n", info->binning); +#endif + + sprintf(cdev_name, "thermal-cpufreq-%d", pdev->id); + info->cdev = thermal_cooling_device_register(cdev_name, info, + &sprd_cpufreq_cooling_ops); + if (IS_ERR(info->cdev)){ + ret = PTR_ERR(info->cdev); + goto err; + } + + sprd_cpu_creat_caliberate_attr(&info->cdev->device); + + return ret; +err: + kfree(info); + return ret; +} + +static int sprd_cpu_cooling_remove(struct platform_device *pdev) +{ + struct sprd_cpu_cooling_platform_data *pdata = dev_get_platdata(&pdev->dev); + struct thermal_cooling_info_t *info = pdata->devdata; + + sprd_cpu_remove_caliberate_attr(&info->cdev->device); + +#ifdef CONFIG_OF + int i; + + if (pdata->vddarm_update){ + for (i = 0; pdata->vddarm_update[i].freq_vddarm; ++i){ + kfree(pdata->vddarm_update[i].freq_vddarm); + pdata->vddarm_update[i].freq_vddarm = NULL; + } + kfree(pdata->vddarm_update); + } + kfree(pdata); + pdata = NULL; +#endif + thermal_cooling_device_unregister(info->cdev); + kfree(info); + + return 0; +} + +#ifdef CONFIG_OF +static const struct of_device_id cpu_cooling_of_match[] = { + { .compatible = "sprd,sprd-cpu-cooling", }, + { } +}; +#endif + +static struct platform_driver cpu_cooling_driver = { + .probe = sprd_cpu_cooling_probe, + .remove = sprd_cpu_cooling_remove, + .driver = { + .owner = THIS_MODULE, + .name = "sprd-cpu-cooling", +#ifdef CONFIG_OF + .of_match_table = of_match_ptr(cpu_cooling_of_match), +#endif + }, +}; + + +static int __init sprd_cpu_cooling_init(void) +{ + return platform_driver_register(&cpu_cooling_driver); +} + +static void __exit sprd_cpu_cooling_exit(void) +{ + platform_driver_unregister(&cpu_cooling_driver); +} + +late_initcall(sprd_cpu_cooling_init); +module_exit(sprd_cpu_cooling_exit); diff --git a/drivers/thermal/sprd_ddie_alone_thm.c b/drivers/thermal/sprd_ddie_alone_thm.c new file mode 100644 index 00000000..63d1a205 --- /dev/null +++ b/drivers/thermal/sprd_ddie_alone_thm.c @@ -0,0 +1,636 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * 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. + * + */ + +#include <linux/kernel.h> +#include <linux/err.h> +#include <soc/sprd/sci.h> +#include <soc/sprd/sci_glb_regs.h> +#include <linux/io.h> +#include <soc/sprd/adi.h> +#include <soc/sprd/arch_misc.h> +#include <soc/sprd/hardware.h> +#include <linux/module.h> +#include <linux/of_device.h> +#include <linux/interrupt.h> +#include <linux/platform_device.h> +#include <linux/string.h> +#include <linux/of_irq.h> +#include <linux/thermal.h> +#include <linux/sprd_thm.h> +#include "thm.h" + +#ifdef CONFIG_OF +#include <linux/slab.h> +#include <linux/of_device.h> +#endif + +#define SPRD_THM_DEBUG +#ifdef SPRD_THM_DEBUG +#define THM_DEBUG(format, arg...) printk( "sprd thm: " "@@@" format, ## arg) +#else +#define THM_DEBUG(format, arg...) +#endif + +#define THM_CTRL (0x0000) +#define THM_INT_CTRL (0x0004) +#define SENSOR_CTRL (0x0020) +#define SENSOR_DET_PERI (0x0024) +#define SENSOR_INT_CTRL (0x0028) +#define SENSOR_INT_STS (0x002C) +#define SENSOR_INT_RAW_STS (0x0030) +#define SENSOR_INT_CLR (0x0034) +#define SENSOR_OVERHEAT_THRES (0X0040) +#define SENSOR_HOT_THRES (0X0044) +#define SENSOR_HOT2NOR_THRES (0X0048) +#define SENSOR_HIGHOFF_THRES (0X004C) +#define SENSOR_LOWOFF_THRES (0X0050) +#define SENSOR_MON_PERI (0X0058) +#define SENSOR_MON_CTL (0X005c) +#define SENSOR_TEMPER0_READ (0x0060) +#define SENSOR_READ_STATUS (0x0070) + + +#define A_SEN_OVERHEAT_INT_BIT (1 << 5) +#define A_SEN_HOT_INT_BIT (1 << 4) +#define A_SEN_HOT2NOR_INT_BIT (1 << 3) +#define A_SEN_HIGHOFF_BIT (1 << 2) +#define A_SEN_LOWOFF_INT_BIT (1 << 1) +#define SEN_OVERHEAT_ALARM_EN (1 << 7) +#define SEN0_OVERHEAT_ALARM_EN (1 << 8) + + +#define A_RAW_TEMP_OFFSET 8 +#define A_RAW_TEMP_RANGE_MSK 0x7F + +#define A_HIGH_BITS_OFFSET 4 + +#define A_HIGH_TAB_SZ 8 +#define A_LOW_TAB_SZ 16 + +#define A_HOT2NOR_RANGE 15 +#define A_LOCAL_SENSOR_ADDR_OFF 0x100 +#define A_DELAY_TEMPERATURE 3 +#define INTOFFSET 3 + +#define A_TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define A_TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define A_TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +static const short a_temp_search_high_152nm[A_HIGH_TAB_SZ] = + { -56, -29, -2, 26, 53, 79, 106, 133 }; +static const short a_temp_search_low_152nm[A_LOW_TAB_SZ] = + { 0, 2, 3, 5, 7, 8, 10, 11, 13, 15, 17, 18, 20, 21, 23, 25 }; + +#define SEN_OVERHEAT_INT_BIT (1 << 5) +#define SEN_HOT_INT_BIT (1 << 4) +#define SEN_HOT2NOR_INT_BIT (1 << 3) +#define SEN_HIGHOFF_BIT (1 << 2) +#define SEN_LOWOFF_INT_BIT (1 << 1) + +#define RAW_TEMP_RANGE_MSK 0x3FFF +#define RAW_READ_RANGE_MSK 0x7FFF + +#define HIGH_BITS_OFFSET 4 + +#define HOT2NOR_RANGE 15 +#define LOCAL_SENSOR_ADDR_OFF 0x100 +#define DELAY_TEMPERATURE 3 + +#define LOCAL_THM_ADDR_OFF 0x200 + + +#define SEN_DET_PRECISION (0x50) + +#define TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +#define TEMP_TO_RAM_DEGREE 8 +#define TEMP_LOW (-40000) +#define TEMP_HIGH (120000) +#define RAW_DATA_LOW (623) +#define RAW_DATA_HIGH (1030) +#define TEMP_DATA_LOW (-40000) +#define TEMP_DATA_HIGH (125000) + +#define CRITIC_TEMP 125000 + +#define RAW_ADC_LOW (550) +#define RAW_ADC_HIGH (1200) + +//static const u32 temp_to_raw[TEMP_TO_RAM_DEGREE + 1] = { RAW_DATA_LOW, 676, 725, 777, 828, 878, 928, 980,RAW_DATA_HIGH }; + +//static u32 current_trip_num = 0; +unsigned long SPRD_THM_BASE = 0; +unsigned int SPRD_THM_SIZE = 0; + +#define THM_SENOR_NUM 8 +extern int sprd_thermal_init(struct sprd_thermal_zone *pzone); +extern void sprd_thermal_remove(struct sprd_thermal_zone *pzone); +static inline void __thm_reg_write(unsigned long reg, u16 bits, u16 clear_msk); +static inline u32 __thm_reg_read(unsigned long reg); + +static inline void __thm_reg_write(unsigned long reg, u16 bits, u16 clear_msk) +{ + __raw_writel(((__raw_readl((volatile void *)reg) & ~clear_msk) | bits), ((volatile void *)reg)); +} + +static inline u32 __thm_reg_read(unsigned long reg) +{ + return __raw_readl((volatile void *)reg); +} + +int sprd_thm_rawdata2temp(struct sprd_thermal_zone *pzone, int rawdata) +{ + u32 temp_result; + if ((rawdata < RAW_ADC_LOW) || (rawdata > RAW_ADC_HIGH)) + return 0; + if (pzone->sensor_id == SPRD_ARM_SENSOR + || pzone->sensor_id == SPRD_BCORE_SENSOR) { + temp_result = + (pzone->thm_cal * rawdata - pzone->off_set) ; + } else { + temp_result = TEMP_LOW + + (rawdata - RAW_DATA_LOW) * (TEMP_HIGH - + TEMP_LOW) / (RAW_DATA_HIGH - + RAW_DATA_LOW); + } + return temp_result; +} + +u32 sprd_thm_temp2rawdata(struct sprd_thermal_zone * pzone, int temp) +{ + u32 raw_result; + if ((temp < TEMP_DATA_LOW) || (temp > TEMP_DATA_HIGH)) + return 0; + if (pzone->sensor_id == SPRD_ARM_SENSOR + || pzone->sensor_id == SPRD_BCORE_SENSOR) { + raw_result = (temp + pzone->off_set) / pzone->thm_cal; + } else { + raw_result = RAW_DATA_LOW + + (temp - TEMP_LOW) * (RAW_DATA_HIGH - + RAW_DATA_LOW) / (TEMP_HIGH - TEMP_LOW); + } + return raw_result; +} + + +static unsigned long sprd_thm_temp_read(struct sprd_thermal_zone *pzone) +{ + u32 rawdata = 0; + int cal_offset = 0; + unsigned long local_sensor_addr; + unsigned long temp1; + unsigned long temp2; + local_sensor_addr = pzone->reg_base; + rawdata = __thm_reg_read(local_sensor_addr + SENSOR_TEMPER0_READ); + rawdata = rawdata & RAW_READ_RANGE_MSK; + cal_offset = pzone->thm_cal; + if (pzone->sensor_id == SPRD_ARM_SENSOR + || pzone->sensor_id == SPRD_BCORE_SENSOR) { + temp1 = sprd_thm_rawdata2temp(pzone, rawdata); + printk("sensor id:%d, rawdata:0x%x, temp:%lu\n", pzone->sensor_id,rawdata,temp1); + return temp1; + } else { + temp2 = sprd_thm_rawdata2temp(pzone, rawdata) - cal_offset; + printk("sensor id:%d, rawdata:0x%x, temp:%lu\n", pzone->sensor_id,rawdata,temp2); + return temp2; + } +} + +#ifdef THM_TEST +static int sprd_thm_regs_read(struct sprd_thermal_zone *pzone,unsigned int *regs) +{ + unsigned long base_addr = 0; + printk(" sprd_thm_regs_read\n"); + if(pzone->sensor_id == SPRD_ARM_SENSOR){ + base_addr = (unsigned long) pzone->reg_base; + *regs = __thm_reg_read((base_addr + SENSOR_DET_PERI)); + *(regs + 1) = __thm_reg_read((base_addr + SENSOR_MON_CTL)); + *(regs + 2) = __thm_reg_read((base_addr + SENSOR_MON_PERI)); + *(regs + 3) = __thm_reg_read((base_addr + SENSOR_CTRL)); + } + return 0; +} + +static int sprd_thm_regs_set(struct sprd_thermal_zone *pzone,unsigned int*regs) +{ + u32 pre_data[4] = {0}; + unsigned long gpu_sensor_addr,base_addr; + gpu_sensor_addr = + (unsigned long ) pzone->reg_base +LOCAL_SENSOR_ADDR_OFF; + printk("sprd_thm_regs_set\n"); + base_addr = (unsigned long) pzone->reg_base; + pre_data[0] = __thm_reg_read(base_addr + SENSOR_DET_PERI); + pre_data[1] = __thm_reg_read(base_addr + SENSOR_MON_CTL); + pre_data[2] = __thm_reg_read(base_addr + SENSOR_MON_PERI); + pre_data[3] = __thm_reg_read(base_addr + SENSOR_CTRL); + __thm_reg_write((base_addr + SENSOR_CTRL), 0x00, 0x01); + __thm_reg_write((base_addr+ SENSOR_CTRL), 0x8, 0x08); + __thm_reg_write((base_addr + SENSOR_DET_PERI), regs[0], pre_data[0]); + __thm_reg_write((base_addr + SENSOR_MON_CTL), regs[1], pre_data[1]); + __thm_reg_write((base_addr + SENSOR_MON_PERI), regs[2], pre_data[2] |0x100 ); + __thm_reg_write((base_addr + SENSOR_CTRL), regs[3], pre_data[3]); + __thm_reg_write((base_addr + SENSOR_CTRL), 0x8, 0x8); + + pre_data[0] = __thm_reg_read(gpu_sensor_addr + SENSOR_DET_PERI); + pre_data[1] = __thm_reg_read(gpu_sensor_addr + SENSOR_MON_CTL); + pre_data[2] = __thm_reg_read(gpu_sensor_addr + SENSOR_MON_PERI); + pre_data[3] = __thm_reg_read(gpu_sensor_addr + SENSOR_CTRL); + __thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), 0x00, 0x01); + __thm_reg_write((gpu_sensor_addr+ SENSOR_CTRL), 0x8, 0x08); + __thm_reg_write((gpu_sensor_addr + SENSOR_DET_PERI), regs[0], pre_data[0]); + __thm_reg_write((gpu_sensor_addr + SENSOR_MON_CTL), regs[1], pre_data[1]); + __thm_reg_write((gpu_sensor_addr + SENSOR_MON_PERI), regs[2], pre_data[2] |0x100 ); + __thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), regs[3], pre_data[3]); + __thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), 0x8, 0x8); + return 0; +} + +static int sprd_thm_trip_set(struct sprd_thermal_zone *pzone,int trip) +{ + THM_DEBUG("sprd_thm_trip_set trip=%d, temp=%ld,lowoff =%ld\n", + trip,pzone->trip_tab->trip_points[trip].temp,pzone->trip_tab->trip_points[trip].lowoff); + return 0; +} + + +#endif + +static int sprd_thm_hw_init(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr, base_addr = 0; + int ret = 0 ; + u32 raw_temp = 0; + base_addr = pzone->reg_base; + local_sensor_addr = pzone->reg_base; + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + printk(KERN_NOTICE "sprd_thm_hw_init thm id:%d,base 0x%lx \n", + pzone->sensor_id, base_addr); + if (pzone->sensor_id == SPRD_ARM_SENSOR) { + ret = + sci_efuse_arm_thm_cal_get(&pzone->thm_cal, &pzone->off_set); + } else if (pzone->sensor_id == SPRD_BCORE_SENSOR) { + ret = + sci_efuse_bcore_thm_cal_get(&pzone->thm_cal,&pzone->off_set); + } else { + ret = sci_efuse_thermal_cal_get(&pzone->thm_cal); + } + THM_DEBUG("pzone->thm_cal =%d,ret =%d\n", pzone->thm_cal, ret); + sci_glb_set(REG_AON_APB_APB_EB1, BIT_THM_EB); + sci_glb_set(REG_AON_APB_APB_RTC_EB, + (BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB | + BIT_GPU_THMA_RTC_AUTO_EN | BIT_CA53_LIT_THMA_RTC_EB | + BIT_CA53_BIG_THMA_RTC_EB |BIT_ARM_THMA_RTC_AUTO_EN ) ); + __thm_reg_write((base_addr + THM_CTRL), 0x3, 0); + __thm_reg_write((base_addr + THM_INT_CTRL), 0x3, 0); + + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int +#if 0 + if (SPRD_ARM_SENSOR== pzone->sensor_id){ + //raw_temp = sprd_thm_temp2rawdata(pzone,CRITIC_TEMP); + if (trip_tab->trip_points[trip_tab->num_trips - 1].type == + THERMAL_TRIP_CRITICAL) { + raw_temp = + sprd_thm_temp2rawdata(pzone, trip_tab->trip_points[trip_tab->num_trips - 1].temp); + } + //set overheat int temp value + __thm_reg_write((local_sensor_addr +SENSOR_OVERHEAT_THRES),raw_temp, RAW_TEMP_RANGE_MSK); + __thm_reg_write((base_addr + THM_INT_CTRL), SEN0_OVERHEAT_ALARM_EN, 0); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL),SEN_OVERHEAT_ALARM_EN, 0); + } +#endif + printk(KERN_NOTICE "sprd_thm_hw_init addr 0x:%lx,int ctrl 0x%x\n", + local_sensor_addr, + __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL))); + + __thm_reg_write((local_sensor_addr + SENSOR_DET_PERI), 0x4000, 0x4000); + __thm_reg_write((local_sensor_addr + SENSOR_MON_CTL), 0x21, 0X21); + __thm_reg_write((local_sensor_addr + SENSOR_MON_PERI), 0x400, 0x100); + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x031, 0x131); + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x8, 0x8); + return 0; +} + + +static int sprd_thm_hw_disable_sensor(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr ; + local_sensor_addr = pzone->reg_base; + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x00, 0x01); + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x8, 0x8); + + return 0; +} + +static int sprd_thm_hw_enable_sensor(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr ; + local_sensor_addr = pzone->reg_base; + THM_DEBUG("sprd_2713S_thm enable sensor sensor_ID:0x%x \n",pzone->sensor_id); + sci_glb_set(REG_AON_APB_APB_RTC_EB, + (BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB | + BIT_GPU_THMA_RTC_AUTO_EN | BIT_CA53_LIT_THMA_RTC_EB | + BIT_CA53_BIG_THMA_RTC_EB |BIT_ARM_THMA_RTC_AUTO_EN ) ); + __thm_reg_write((local_sensor_addr+ SENSOR_CTRL), 0x01, 0x01); + __thm_reg_write((local_sensor_addr+ SENSOR_CTRL), 0x8, 0x8); + + return 0; +} + +u16 int_ctrl_reg[SPRD_MAX_SENSOR]; +static int sprd_thm_hw_suspend(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr ; + local_sensor_addr = pzone->reg_base; + int_ctrl_reg[pzone->sensor_id] = __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL)); + + sprd_thm_hw_disable_sensor(pzone); + + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + + return 0; +} +static int sprd_thm_hw_resume(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr ; + local_sensor_addr = pzone->reg_base; + sprd_thm_hw_enable_sensor(pzone); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), int_ctrl_reg[pzone->sensor_id], ~0); //enable int of saved + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x9, 0); + + return 0; +} + +int sprd_thm_get_trend(struct sprd_thermal_zone *pzone, int trip, enum thermal_trend *ptrend) +{ + *ptrend = pzone->trend_val; + return 0; +} + +int sprd_thm_get_hyst(struct sprd_thermal_zone *pzone, int trip, unsigned long *physt) +{ + + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + if (trip >= trip_tab->num_trips - 2){ + *physt = 0; + }else{ + *physt = trip_tab->trip_points[trip].temp - trip_tab->trip_points[trip + 1].lowoff; + } + return 0; +} + +struct thm_handle_ops sprd_ddie_ops = +{ + .hw_init = sprd_thm_hw_init, + .read_temp = sprd_thm_temp_read, + .get_trend = sprd_thm_get_trend, + .get_hyst = sprd_thm_get_hyst, + .suspend = sprd_thm_hw_suspend, + .resume = sprd_thm_hw_resume, + .trip_debug_set = sprd_thm_trip_set, + .reg_debug_get = sprd_thm_regs_read, + .reg_debug_set = sprd_thm_regs_set, +}; +#ifdef CONFIG_OF +static struct sprd_thm_platform_data *thermal_detect_parse_dt( + struct device *dev) +{ + struct sprd_thm_platform_data *pdata; + struct device_node *np = dev->of_node; + u32 trip_points_critical,trip_num; + char prop_name[32]; + const char *tmp_str; + u32 tmp_data,tmp_lowoff; + int ret,i ,j = 0; + pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); + if (!pdata) { + dev_err(dev, "could not allocate memory for platform data\n"); + return NULL; + } + ret = of_property_read_u32(np, "trip-points-critical", &trip_points_critical); + if(ret){ + dev_err(dev, "fail to get trip_points_critical\n"); + goto fail; + } + ret = of_property_read_u32(np, "trip-num", &trip_num); + if(ret){ + dev_err(dev, "fail to get trip_num\n"); + goto fail; + } + for (i = 0; i <trip_num-1; ++i) { + sprintf(prop_name, "trip%d-temp-active", i); + if (of_property_read_u32(np, prop_name, &tmp_data)){ + dev_err(dev, "fail to get trip%d-temp-active\n",i); + goto fail; + } + + pdata->trip_points[i].temp = tmp_data; + sprintf(prop_name, "trip%d-temp-lowoff", i); + if (of_property_read_u32(np, prop_name, &tmp_lowoff)){ + dev_err(dev, "fail to get trip%d-temp-lowoff\n",i); + goto fail; + } + pdata->trip_points[i].lowoff = tmp_lowoff; + sprintf(prop_name, "trip%d-type", i); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto fail; + + if (!strcmp(tmp_str, "active")) + pdata->trip_points[i].type = THERMAL_TRIP_ACTIVE; + else if (!strcmp(tmp_str, "passive")) + pdata->trip_points[i].type = THERMAL_TRIP_PASSIVE; + else if (!strcmp(tmp_str, "hot")) + pdata->trip_points[i].type = THERMAL_TRIP_HOT; + else if (!strcmp(tmp_str, "critical")) + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + else + goto fail; + + sprintf(prop_name, "trip%d-cdev-num", i); + if (of_property_read_u32(np, prop_name, &tmp_data)) + goto fail; + for (j = 0; j < tmp_data; j++) { + sprintf(prop_name, "trip%d-cdev-name%d", i, j); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto fail; + strcpy(pdata->trip_points[i].cdev_name[j], tmp_str); + dev_info(dev,"cdev name: %s \n", pdata->trip_points[i].cdev_name[j]); + } + dev_info(dev, "trip[%d] temp: %lu lowoff: %lu\n", + i, pdata->trip_points[i].temp, pdata->trip_points[i].lowoff); + } + pdata->trip_points[i].temp = trip_points_critical; + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + dev_info(dev, "trip[%d] temp: %lu \n", + i, pdata->trip_points[i].temp); + pdata->num_trips = trip_num; + + return pdata; + +fail: + kfree(pdata); + return NULL; + +} + +#endif +static int sprd_ddie_thm_probe(struct platform_device *pdev) +{ + struct sprd_thm_platform_data *ptrips = NULL; + struct sprd_thermal_zone *pzone = NULL; + struct resource *res; + const char *thm_name; + int ret,temp_interval,sensor_id; + unsigned long ddie_thm_base; +#ifdef CONFIG_OF + struct device_node *np = pdev->dev.of_node; + if (!np) { + dev_err(&pdev->dev, "device node not found\n"); + return -EINVAL; + } +#endif + printk("sprd_ddie_thm_probe start\n"); +#if 0 + pdev->id = of_alias_get_id(np, "thmzone"); + printk(KERN_INFO " sprd_thermal_probe id:%d\n", pdev->id); + if (unlikely(pdev->id < 0 || pdev->id >= THM_SENOR_NUM)) { + dev_err(&pdev->dev, "does not support id %d\n", pdev->id); + return -ENXIO; + } +#endif + ret = of_property_read_u32(np, "temp-inteval", &temp_interval); + if(ret){ + dev_err(&pdev->dev, "fail to get temp-inteval\n"); + return -EINVAL; + } + ret = of_property_read_u32(np, "id", &sensor_id); + if (ret) { + dev_err(&pdev->dev, "fail to get id\n"); + return -EINVAL; + } +#ifdef CONFIG_OF + ptrips = thermal_detect_parse_dt(&pdev->dev); +#else + ptrips = dev_get_platdata(&pdev->dev); +#endif + + if (!ptrips){ + dev_err(&pdev->dev, "not found ptrips\n"); + return -EINVAL; + } + pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL); + mutex_init(&pzone->th_lock); + mutex_lock(&pzone->th_lock); + if (!pzone) + return -ENOMEM; + of_property_read_string(np, "thermal-name", + &thm_name); + strcpy(pzone->thermal_zone_name, thm_name); + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + ddie_thm_base = (unsigned long)devm_ioremap_resource(&pdev->dev, res); + if (!ddie_thm_base) { + pr_err("thermal ioremap failed!\n"); + return -ENOMEM; + } + pzone->reg_base= ddie_thm_base; + pzone->trip_tab = ptrips; + pzone->temp_inteval = temp_interval; + pzone->sensor_id = sensor_id; + pzone->ops = &sprd_ddie_ops; + ret = sprd_thm_hw_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone hw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + ret = sprd_thermal_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone sw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + platform_set_drvdata(pdev, pzone); + printk("sprd_ddie_thm_probe end\n"); + mutex_unlock(&pzone->th_lock); + return 0; +} + +static int sprd_ddie_thm_remove(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + sprd_thermal_remove(pzone); + return 0; +} + +static int sprd_ddie_thm_suspend(struct platform_device *pdev, + pm_message_t state) +{ + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + flush_delayed_work(&pzone->thm_read_work); + //flush_delayed_work(&pzone->thm_logtime_work); + flush_delayed_work(&pzone->resume_delay_work); + pzone->ops->suspend(pzone); + return 0; +} + +static int sprd_ddie_thm_resume(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + schedule_delayed_work(&pzone->resume_delay_work, (HZ * 1)); + schedule_delayed_work(&pzone->thm_read_work, (HZ * 5)); + //schedule_delayed_work(&pzone->thm_logtime_work, (HZ * 7)); + //pzone->ops->resume(pzone); + return 0; +} + +static const struct of_device_id thermal_of_match[] = { + { .compatible = "sprd,ddie-thermal", }, + {} +}; + +static struct platform_driver sprd_thermal_driver = { + .probe = sprd_ddie_thm_probe, + .suspend = sprd_ddie_thm_suspend, + .resume = sprd_ddie_thm_resume, + .remove = sprd_ddie_thm_remove, + .driver = { + .owner = THIS_MODULE, + .name = "ddie-thermal", + .of_match_table = of_match_ptr(thermal_of_match), + }, +}; +static int __init sprd_ddie_thermal_init(void) +{ + return platform_driver_register(&sprd_thermal_driver); +} + +static void __exit sprd_ddie_thermal_exit(void) +{ + platform_driver_unregister(&sprd_thermal_driver); +} + + +device_initcall_sync(sprd_ddie_thermal_init); +module_exit(sprd_ddie_thermal_exit); +MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>"); +MODULE_DESCRIPTION("sprd thermal driver"); +MODULE_LICENSE("GPL"); + + + diff --git a/drivers/thermal/sprd_ddie_thm.c b/drivers/thermal/sprd_ddie_thm.c new file mode 100644 index 00000000..269bda77 --- /dev/null +++ b/drivers/thermal/sprd_ddie_thm.c @@ -0,0 +1,681 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * 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. + * + */ + +#include <linux/kernel.h> +#include <linux/err.h> +#include <soc/sprd/sci.h> +#include <soc/sprd/sci_glb_regs.h> +#include <linux/io.h> +#include <soc/sprd/adi.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/err.h> +#include<linux/string.h> +#include <soc/sprd/arch_misc.h> +#include <soc/sprd/hardware.h> +#include <linux/thermal.h> +#include <linux/sprd_thm.h> +#include "thm.h" + +#ifdef CONFIG_OF +#include <linux/slab.h> +#include <linux/of_device.h> +#include <linux/of_irq.h> +#endif + +#define THM_SENOR_NUM 8 +#define SPRD_THM_DEBUG +#ifdef SPRD_THM_DEBUG +#define THM_DEBUG(format, arg...) printk( "sprd thm: " "@@@" format, ## arg) +#else +#define THM_DEBUG(format, arg...) +#endif + +#define THM_CTRL (0x0000) +#define THM_INT_CTRL (0x0004) +#define SENSOR_CTRL (0x0020) +#define SENSOR_DET_PERI (0x0024) +#define SENSOR_INT_CTRL (0x0028) +#define SENSOR_INT_STS (0x002C) +#define SENSOR_INT_RAW_STS (0x0030) +#define SENSOR_INT_CLR (0x0034) +#define SENSOR_OVERHEAT_THRES (0X0040) +#define SENSOR_HOT_THRES (0X0044) +#define SENSOR_HOT2NOR_THRES (0X0048) +#define SENSOR_HIGHOFF_THRES (0X004C) +#define SENSOR_LOWOFF_THRES (0X0050) +#define SENSOR_MON_PERI (0X0058) +#define SENSOR_MON_CTL (0X005c) +#define SENSOR_TEMPER0_READ (0x0060) +#define SENSOR_READ_STATUS (0x0070) + + +#define A_SEN_OVERHEAT_INT_BIT (1 << 5) +#define A_SEN_HOT_INT_BIT (1 << 4) +#define A_SEN_HOT2NOR_INT_BIT (1 << 3) +#define A_SEN_HIGHOFF_BIT (1 << 2) +#define A_SEN_LOWOFF_INT_BIT (1 << 1) + +#define A_RAW_TEMP_OFFSET 8 +#define A_RAW_TEMP_RANGE_MSK 0x7F + +#define A_HIGH_BITS_OFFSET 4 + +#define A_HIGH_TAB_SZ 8 +#define A_LOW_TAB_SZ 16 + +#define A_HOT2NOR_RANGE 15 +#define A_LOCAL_SENSOR_ADDR_OFF 0x100 +#define A_DELAY_TEMPERATURE 3 +#define INTOFFSET 3 + +#define A_TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define A_TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define A_TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +static const short a_temp_search_high_152nm[A_HIGH_TAB_SZ] = + { -56, -29, -2, 26, 53, 79, 106, 133 }; +static const short a_temp_search_low_152nm[A_LOW_TAB_SZ] = + { 0, 2, 3, 5, 7, 8, 10, 11, 13, 15, 17, 18, 20, 21, 23, 25 }; + +#define SEN_OVERHEAT_INT_BIT (1 << 5) +#define SEN_HOT_INT_BIT (1 << 4) +#define SEN_HOT2NOR_INT_BIT (1 << 3) +#define SEN_HIGHOFF_BIT (1 << 2) +#define SEN_LOWOFF_INT_BIT (1 << 1) +#define SEN_OVERHEAT_ALARM_EN (1 << 7) +#define SEN0_OVERHEAT_ALARM_EN (1 << 8) + + +#define RAW_TEMP_RANGE_MSK 0x3FFF +#define RAW_READ_RANGE_MSK 0x7FFF + +#define HIGH_BITS_OFFSET 4 + +#define HOT2NOR_RANGE 15 +#define LOCAL_SENSOR_ADDR_OFF 0x100 +#define DELAY_TEMPERATURE 3 + +#define LOCAL_THM_ADDR_OFF 0x200 + + +#define SEN_DET_PRECISION (0x50) + +#define TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +#define TEMP_TO_RAM_DEGREE 8 +#define TEMP_LOW (-40000) +#define TEMP_HIGH (120000) +#ifdef CONFIG_ARCH_SCX20 +#define RAW_DATA_LOW (627) +#define RAW_DATA_HIGH (1075) +#else +#define RAW_DATA_LOW (623) +#define RAW_DATA_HIGH (1030) +#endif +#define CRITIC_TEMP 80000 + +#define RAW_ADC_LOW (550) +#define RAW_ADC_HIGH (1200) + +//static const u32 temp_to_raw[TEMP_TO_RAM_DEGREE + 1] = { RAW_DATA_LOW, 676, 725, 777, 828, 878, 928, 980,RAW_DATA_HIGH }; + +unsigned long SPRD_THM_BASE = 0; +unsigned int SPRD_THM_SIZE = 0; +extern int sprd_thermal_init(struct sprd_thermal_zone *pzone); +extern void sprd_thermal_remove(struct sprd_thermal_zone *pzone); + +static inline void __thm_reg_write(unsigned long reg, u16 bits, u16 clear_msk); +static inline u32 __thm_reg_read(unsigned long reg); +int sprd_thm_set_active_trip(struct sprd_thermal_zone *pzone, int trip ); +u32 sprd_thm_temp2rawdata( int temp); + +static inline void __thm_reg_write(unsigned long reg, u16 bits, u16 clear_msk) +{ + __raw_writel(((__raw_readl((volatile void *)reg) & ~clear_msk) | bits), ((volatile void *)reg)); +} + +static inline u32 __thm_reg_read(unsigned long reg) +{ + return __raw_readl((volatile void *)reg); +} + +u32 sprd_thm_temp2rawdata( int temp) +{ + u32 raw_result; + if ((temp < TEMP_LOW) || (temp > TEMP_HIGH)) + return 0; + raw_result = RAW_DATA_LOW + + (temp - TEMP_LOW) * (RAW_DATA_HIGH - RAW_DATA_LOW) / (TEMP_HIGH - TEMP_LOW); + + return raw_result; +} + +int sprd_thm_rawdata2temp( int rawdata) +{ + int temp_result; + if ((rawdata < RAW_ADC_LOW) || (rawdata > RAW_ADC_HIGH)) + return 0; + temp_result = TEMP_LOW + + (rawdata - RAW_DATA_LOW) * (TEMP_HIGH - TEMP_LOW) / (RAW_DATA_HIGH - RAW_DATA_LOW); + + return temp_result; +} + +static unsigned long sprd_thm_temp_read(struct sprd_thermal_zone *pzone) +{ + u32 rawdata = 0; + int cal_offset = 0; + u32 sensor = pzone->sensor_id, local_sen_id = 0; + unsigned long local_sensor_addr; + unsigned long temp; + if(pzone->sensor_id == SPRD_GPU_SENSOR) + local_sen_id = 1; + local_sensor_addr = pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + rawdata = __thm_reg_read(local_sensor_addr + SENSOR_TEMPER0_READ); + rawdata = rawdata & RAW_READ_RANGE_MSK; + cal_offset = pzone->thm_cal; + temp = sprd_thm_rawdata2temp( rawdata) -cal_offset; + printk("sensor id:%d, rawdata:0x%x, temp:%lu\n", sensor, rawdata,temp); + return temp; + +} + + +#ifdef THM_TEST +static int sprd_thm_regs_read(struct sprd_thermal_zone *pzone,unsigned int *regs) +{ + unsigned long base_addr = 0; + printk(" sprd_thm_regs_read\n"); + if(pzone->sensor_id == SPRD_ARM_SENSOR){ + base_addr = (unsigned long) pzone->reg_base; + *regs = __thm_reg_read((base_addr + SENSOR_DET_PERI)); + *(regs + 1) = __thm_reg_read((base_addr + SENSOR_MON_CTL)); + *(regs + 2) = __thm_reg_read((base_addr + SENSOR_MON_PERI)); + *(regs + 3) = __thm_reg_read((base_addr + SENSOR_CTRL)); + } + return 0; +} + +static int sprd_thm_regs_set(struct sprd_thermal_zone *pzone,unsigned int*regs) +{ + u32 pre_data[4] = {0}; + unsigned long gpu_sensor_addr,base_addr; + gpu_sensor_addr = + (unsigned long ) pzone->reg_base +LOCAL_SENSOR_ADDR_OFF; + printk("sprd_thm_regs_set\n"); + base_addr = (unsigned long) pzone->reg_base; + pre_data[0] = __thm_reg_read(base_addr + SENSOR_DET_PERI); + pre_data[1] = __thm_reg_read(base_addr + SENSOR_MON_CTL); + pre_data[2] = __thm_reg_read(base_addr + SENSOR_MON_PERI); + pre_data[3] = __thm_reg_read(base_addr + SENSOR_CTRL); + __thm_reg_write((base_addr + SENSOR_CTRL), 0x00, 0x01); + __thm_reg_write((base_addr+ SENSOR_CTRL), 0x8, 0x08); + __thm_reg_write((base_addr + SENSOR_DET_PERI), regs[0], pre_data[0]); + __thm_reg_write((base_addr + SENSOR_MON_CTL), regs[1], pre_data[1]); + __thm_reg_write((base_addr + SENSOR_MON_PERI), regs[2], pre_data[2] |0x100 ); + __thm_reg_write((base_addr + SENSOR_CTRL), regs[3], pre_data[3]); + __thm_reg_write((base_addr + SENSOR_CTRL), 0x8, 0x8); + + pre_data[0] = __thm_reg_read(gpu_sensor_addr + SENSOR_DET_PERI); + pre_data[1] = __thm_reg_read(gpu_sensor_addr + SENSOR_MON_CTL); + pre_data[2] = __thm_reg_read(gpu_sensor_addr + SENSOR_MON_PERI); + pre_data[3] = __thm_reg_read(gpu_sensor_addr + SENSOR_CTRL); + __thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), 0x00, 0x01); + __thm_reg_write((gpu_sensor_addr+ SENSOR_CTRL), 0x8, 0x08); + __thm_reg_write((gpu_sensor_addr + SENSOR_DET_PERI), regs[0], pre_data[0]); + __thm_reg_write((gpu_sensor_addr + SENSOR_MON_CTL), regs[1], pre_data[1]); + __thm_reg_write((gpu_sensor_addr + SENSOR_MON_PERI), regs[2], pre_data[2] |0x100 ); + __thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), regs[3], pre_data[3]); + __thm_reg_write((gpu_sensor_addr + SENSOR_CTRL), 0x8, 0x8); + return 0; +} + +static int sprd_thm_trip_set(struct sprd_thermal_zone *pzone,int trip) +{ + THM_DEBUG("sprd_thm_trip_set trip=%d, temp=%ld,lowoff =%ld\n", + trip,pzone->trip_tab->trip_points[trip].temp,pzone->trip_tab->trip_points[trip].lowoff); + return 0; +} + +#endif + +int sprd_thm_get_trend(struct sprd_thermal_zone *pzone, int trip, enum thermal_trend *ptrend) +{ + *ptrend = pzone->trend_val; + return 0; +} + +int sprd_thm_get_hyst(struct sprd_thermal_zone *pzone, int trip, unsigned long *physt) +{ + + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + if (trip >= trip_tab->num_trips - 2){ + *physt = 0; + }else{ + *physt = trip_tab->trip_points[trip].temp - trip_tab->trip_points[trip + 1].lowoff; + } + return 0; +} + +int init_flag=0; + +static int sprd_thm_hw_init(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr, base_addr = 0; + u32 local_sen_id = 0; + u32 raw_temp = 0; + int ret = 0; + int i; + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + ret = sci_efuse_thermal_cal_get(&pzone->thm_cal) ; + THM_DEBUG("arm_sen_cal_offset =%d,ret =%d\n",pzone->thm_cal,ret); + if(pzone->sensor_id == SPRD_GPU_SENSOR) + local_sen_id = 1; + base_addr = (unsigned long) pzone->reg_base ; + local_sensor_addr = base_addr + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + + printk(KERN_NOTICE "sprd_thm_hw_init 2713s_thm id:%d,base 0x%lx \n", + pzone->sensor_id, base_addr); + if(init_flag ==0) + { + sci_glb_set(REG_AON_APB_APB_EB1, BIT_THM_EB); + sci_glb_set(REG_AON_APB_APB_RTC_EB, + (BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB | + BIT_GPU_THMA_RTC_AUTO_EN | BIT_ARM_THMA_RTC_EB |BIT_ARM_THMA_RTC_AUTO_EN ) ); + sci_glb_set(REG_AON_APB_APB_RST1,BIT_THM_SOFT_RST); + for(i=0; i < 10000; i++); + sci_glb_clr(REG_AON_APB_APB_RST1,BIT_THM_SOFT_RST); + __thm_reg_write((base_addr + THM_CTRL), 0x3, 0); + __thm_reg_write((base_addr + THM_INT_CTRL), 0x1, 0); + init_flag =1; + } + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int +#if 0 + if (SPRD_ARM_SENSOR== pzone->sensor_id){ + if (trip_tab->trip_points[trip_tab->num_trips - 1].type == + THERMAL_TRIP_CRITICAL) { + raw_temp = + sprd_thm_temp2rawdata( trip_tab->trip_points[trip_tab->num_trips - 1].temp - cal_offset); + } +// raw_temp = sprd_thm_temp2rawdata(CRITIC_TEMP - cal_offset); + __thm_reg_write((local_sensor_addr + SENSOR_OVERHEAT_THRES),raw_temp, RAW_TEMP_RANGE_MSK);//set overheat temp value + __thm_reg_write((base_addr + THM_INT_CTRL), SEN0_OVERHEAT_ALARM_EN, 0); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL),SEN_OVERHEAT_ALARM_EN, 0); + } +#endif + printk(KERN_NOTICE "sprd_thm_hw_init addr 0x:%lx,int ctrl 0x%x\n", + local_sensor_addr, + __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL))); + + __thm_reg_write((local_sensor_addr + SENSOR_DET_PERI), 0x4000, 0x4000); + __thm_reg_write((local_sensor_addr + SENSOR_MON_CTL), 0x21, 0X21); + __thm_reg_write((local_sensor_addr + SENSOR_MON_PERI), 0x400, 0x100); + if (SPRD_ARM_SENSOR== pzone->sensor_id) + __thm_reg_write((base_addr + SENSOR_CTRL + LOCAL_SENSOR_ADDR_OFF), 0x030, 0x030); + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x39, 0x030); + return 0; +} + +int sprd_thm_hw_disable_sensor(struct sprd_thermal_zone *pzone) +{ + int ret = 0; + /* Sensor minitor disable */ + if (SPRD_ARM_SENSOR == pzone->sensor_id) { + /*__thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL), 0x00, 0x01);*/ + __thm_reg_write((pzone->reg_base + SENSOR_CTRL), 0x8, 0x01); + } else if (SPRD_GPU_SENSOR == pzone->sensor_id) { + /*__thm_reg_write((u32)(pzone->reg_base + SENSOR_CTRL+ LOCAL_SENSOR_ADDR_OFF), 0x00, 0x01);*/ + __thm_reg_write((pzone->reg_base + SENSOR_CTRL + LOCAL_SENSOR_ADDR_OFF), 0x8, 0x01); + } else { + THM_DEBUG("the sensor id is error \n"); + } + return ret; +} + +int sprd_thm_hw_enable_sensor(struct sprd_thermal_zone *pzone) +{ + int ret = 0; + // Sensor minitor enable + THM_DEBUG("sprd_2713S_thm enable sensor sensor_ID:0x%x \n",pzone->sensor_id); + if (SPRD_ARM_SENSOR == pzone->sensor_id) { + sci_glb_set(REG_AON_APB_APB_RTC_EB, + (BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB | + BIT_GPU_THMA_RTC_AUTO_EN | BIT_ARM_THMA_RTC_EB | BIT_ARM_THMA_RTC_AUTO_EN)); + __thm_reg_write((pzone->reg_base + SENSOR_CTRL + LOCAL_SENSOR_ADDR_OFF), 0x030, 0x0); + __thm_reg_write((pzone->reg_base + SENSOR_CTRL), 0x31, 0x0); + } else if (SPRD_GPU_SENSOR == pzone->sensor_id) { + /*sci_glb_set(REG_AON_APB_APB_RTC_EB, + (BIT_THM_RTC_EB | BIT_GPU_THMA_RTC_EB | + BIT_GPU_THMA_RTC_AUTO_EN | BIT_ARM_THMA_RTC_EB |BIT_ARM_THMA_RTC_AUTO_EN ) );*/ + __thm_reg_write((pzone->reg_base + SENSOR_CTRL+LOCAL_SENSOR_ADDR_OFF), 0x31, 0x0); + } else { + THM_DEBUG("the sensor id is error \n"); + } + + return ret; +} + + +u16 int_ctrl_reg[SPRD_MAX_SENSOR]; +int sprd_thm_hw_suspend(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr; + int ret = 0; + + local_sensor_addr = pzone->reg_base ; + /*int_ctrl_reg[pzone->sensor_id] = __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL));*/ + + sprd_thm_hw_disable_sensor(pzone); + if (SPRD_ARM_SENSOR == pzone->sensor_id) { + int_ctrl_reg[pzone->sensor_id] = __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL)); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + + } else if (SPRD_GPU_SENSOR == pzone->sensor_id) { + int_ctrl_reg[pzone->sensor_id] = + __thm_reg_read((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF)); + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF), 0, ~0); /*disable all int*/ + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF), ~0, 0); /*clr all int*/ + + } else { + THM_DEBUG("the sensor id is error \n"); + } + return ret; +} +int sprd_thm_hw_resume(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr; + int ret = 0; + + local_sensor_addr = pzone->reg_base ; + + sprd_thm_hw_enable_sensor(pzone); + if (SPRD_ARM_SENSOR == pzone->sensor_id) { + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR), ~0, 0); //clr all int + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL), int_ctrl_reg[pzone->sensor_id], ~0); //enable int of saved + __thm_reg_write((local_sensor_addr + SENSOR_CTRL+LOCAL_SENSOR_ADDR_OFF), 0x30, 0); + __thm_reg_write((local_sensor_addr + SENSOR_CTRL), 0x39, 0); + } else if (SPRD_GPU_SENSOR == pzone->sensor_id) { + __thm_reg_write((local_sensor_addr + SENSOR_INT_CLR+LOCAL_SENSOR_ADDR_OFF), ~0, 0); /*clr all int*/ + __thm_reg_write((local_sensor_addr + SENSOR_INT_CTRL+LOCAL_SENSOR_ADDR_OFF), int_ctrl_reg[pzone->sensor_id], ~0); /*enable int of saved*/ + __thm_reg_write((local_sensor_addr + SENSOR_CTRL+LOCAL_SENSOR_ADDR_OFF), 0x39, 0); + } else { + THM_DEBUG("the sensor id is error \n"); + } + return ret; +} + +struct thm_handle_ops sprd_ddie_ops = +{ + .hw_init = sprd_thm_hw_init, + .read_temp = sprd_thm_temp_read, + .get_trend = sprd_thm_get_trend, + .get_hyst = sprd_thm_get_hyst, + .suspend = sprd_thm_hw_suspend, + .resume = sprd_thm_hw_resume, + .trip_debug_set = sprd_thm_trip_set, + .reg_debug_get = sprd_thm_regs_read, + .reg_debug_set = sprd_thm_regs_set, +}; + +#ifdef CONFIG_OF +static struct sprd_thm *thermal_detect_parse_dt( + struct device *dev) +{ + struct sprd_thm_platform_data *pdata; + struct sprd_thm *thm_data; + struct device_node *np = dev->of_node,*sensor_child = NULL; + int nsensor,sensor_id; + int ret; + u32 trip_points_critical,trip_num; + int i = 0,j = 0,temp_interval; + char prop_name[32]; + const char *tmp_str; + const char *thm_name; + u32 tmp_data,tmp_lowoff; + nsensor = of_get_child_count(np); + if (nsensor == 0) { + dev_err(dev, "fail to get child node \n"); + goto fail; + } + printk("the nubutton %d\n",nsensor); + thm_data = kzalloc(sizeof(*thm_data), GFP_KERNEL); + if (!thm_data) { + dev_err(dev, "could not allocate memory for platform sprd_thm\n"); + return NULL; + } + thm_data->nsensor = nsensor; + pdata = kzalloc(thm_data->nsensor*sizeof(*pdata), GFP_KERNEL); + if (!pdata) { + dev_err(dev, "could not allocate memory for platform data\n"); + goto fail; + } + thm_data->sprd_data = pdata; + for_each_child_of_node(np,sensor_child) { + ret = of_property_read_u32(sensor_child, "trip-points-critical", &trip_points_critical); + if(ret){ + dev_err(dev, "fail to get trip_points_critical\n"); + goto fail; + } + ret = of_property_read_u32(sensor_child, "trip-num", &trip_num); + if(ret){ + dev_err(dev, "fail to get trip_num\n"); + goto fail; + } + ret = of_property_read_u32(sensor_child, "id", &sensor_id); + if (ret) { + dev_err(dev, "fail to get id\n"); + goto fail; + } + ret = of_property_read_u32(sensor_child, "temp-inteval", &temp_interval); + if(ret){ + dev_err(dev, "fail to get temp-inteval\n"); + goto fail; + } + of_property_read_string(sensor_child, "thermal-name", + &thm_name); + strcpy(pdata->thm_name, thm_name); + for (i = 0; i <trip_num-1; ++i) { + sprintf(prop_name, "trip%d-temp-active", i); + if (of_property_read_u32(sensor_child, prop_name, &tmp_data)){ + dev_err(dev, "fail to get trip%d-temp-active\n",i); + goto fail; + } + pdata->trip_points[i].temp = tmp_data; + sprintf(prop_name, "trip%d-temp-lowoff", i); + if (of_property_read_u32(sensor_child, prop_name, &tmp_lowoff)){ + dev_err(dev, "fail to get trip%d-temp-lowoff\n",i); + goto fail; + } + pdata->trip_points[i].lowoff = tmp_lowoff; + sprintf(prop_name, "trip%d-type", i); + if (of_property_read_string(sensor_child, prop_name, &tmp_str)) + goto fail; + + if (!strcmp(tmp_str, "active")) + pdata->trip_points[i].type = THERMAL_TRIP_ACTIVE; + else if (!strcmp(tmp_str, "passive")) + pdata->trip_points[i].type = THERMAL_TRIP_PASSIVE; + else if (!strcmp(tmp_str, "hot")) + pdata->trip_points[i].type = THERMAL_TRIP_HOT; + else if (!strcmp(tmp_str, "critical")) + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + else + goto fail; + + sprintf(prop_name, "trip%d-cdev-num", i); + if (of_property_read_u32(sensor_child, prop_name, &tmp_data)) + goto fail; + for (j = 0; j < tmp_data; j++) { + sprintf(prop_name, "trip%d-cdev-name%d", i, j); + if (of_property_read_string(sensor_child, prop_name, &tmp_str)) + goto fail; + strcpy(pdata->trip_points[i].cdev_name[j], tmp_str); + dev_info(dev,"cdev name: %s \n", pdata->trip_points[i].cdev_name[j]); + } + dev_info(dev, "trip[%d] temp: %lu lowoff: %lu\n", + i, pdata->trip_points[i].temp, pdata->trip_points[i].lowoff); + } + pdata->trip_points[i].temp = trip_points_critical; + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + dev_info(dev, "trip[%d] temp: %lu \n", + i, pdata->trip_points[i].temp); + pdata->num_trips = trip_num; + pdata->sensor_id = sensor_id; + pdata->temp_interval = temp_interval; + printk("the trip_num=%d,sensor_id =%d\n",pdata->num_trips,pdata->sensor_id); + pdata++; + }; + return thm_data; + +fail: + kfree(pdata); + kfree(thm_data); + return NULL; + +} +#endif + +static int sprd_ddie_thm_probe(struct platform_device *pdev) +{ + struct sprd_thm_platform_data *ptrips = NULL; + struct sprd_thermal_zone *pzone = NULL; + struct resource *res; + struct sprd_thm *pthm = NULL; + unsigned long ddie_thm_base; + int ret,i; +#ifdef CONFIG_OF + struct device_node *np = pdev->dev.of_node; + if (!np) { + dev_err(&pdev->dev, "device node not found\n"); + return -EINVAL; + } +#endif + printk("sprd_ddie_thm_probe start\n"); + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + ddie_thm_base = (unsigned long)devm_ioremap_resource(&pdev->dev, res); + if (!ddie_thm_base) { + pr_err("thermal ioremap failed!\n"); + return -ENOMEM; + } +#ifdef CONFIG_OF + pthm = thermal_detect_parse_dt(&pdev->dev); +#else + pthm = dev_get_platdata(&pdev->dev); +#endif + if (!pthm){ + dev_err(&pdev->dev, "not found pthm\n"); + return -EINVAL; + } + for (i = 0; i < pthm->nsensor; i++) { + pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL); + mutex_init(&pzone->th_lock); + mutex_lock(&pzone->th_lock); + if (!pzone) + return -ENOMEM; + pzone->reg_base= ddie_thm_base; + ptrips = &pthm->sprd_data[i]; + pzone->trip_tab = ptrips; + pzone->temp_inteval = ptrips->temp_interval; + pzone->sensor_id = ptrips->sensor_id; + memcpy(pzone->thermal_zone_name, + ptrips->thm_name, strlen(ptrips->thm_name)+1); + printk("the thermal-name1 is %s\n",pzone->thermal_zone_name); + pzone->ops = &sprd_ddie_ops; + ret = sprd_thm_hw_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone hw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + ret = sprd_thermal_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone sw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + platform_set_drvdata(pdev, pzone); + printk("sprd_ddie_thm_probe---end\n"); + mutex_unlock(&pzone->th_lock); + pzone++; + } + return 0; +} + +static int sprd_ddie_thm_remove(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + sprd_thermal_remove(pzone); + return 0; +} + +static int sprd_ddie_thm_suspend(struct platform_device *pdev, + pm_message_t state) +{ + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + flush_delayed_work(&pzone->thm_read_work); + //flush_delayed_work(&pzone->thm_logtime_work); + flush_delayed_work(&pzone->resume_delay_work); + pzone->ops->suspend(pzone); + return 0; +} + +static int sprd_ddie_thm_resume(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + schedule_delayed_work(&pzone->resume_delay_work, (HZ * 1)); + schedule_delayed_work(&pzone->thm_read_work, (HZ * 5)); + //schedule_delayed_work(&pzone->thm_logtime_work, (HZ * 7)); + //pzone->ops->resume(pzone); + return 0; +} + +static const struct of_device_id thermal_of_match[] = { + { .compatible = "sprd,ddie-thermal", }, + {} +}; + +static struct platform_driver sprd_thermal_driver = { + .probe = sprd_ddie_thm_probe, + .suspend = sprd_ddie_thm_suspend, + .resume = sprd_ddie_thm_resume, + .remove = sprd_ddie_thm_remove, + .driver = { + .owner = THIS_MODULE, + .name = "ddie-thermal", + .of_match_table = of_match_ptr(thermal_of_match), + }, +}; +static int __init sprd_ddie_thermal_init(void) +{ + return platform_driver_register(&sprd_thermal_driver); +} + +static void __exit sprd_ddie_thermal_exit(void) +{ + platform_driver_unregister(&sprd_thermal_driver); +} + + +device_initcall_sync(sprd_ddie_thermal_init); +module_exit(sprd_ddie_thermal_exit); +MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>"); +MODULE_DESCRIPTION("sprd thermal driver"); +MODULE_LICENSE("GPL"); + diff --git a/drivers/thermal/sprd_pmic_2723s_thm.c b/drivers/thermal/sprd_pmic_2723s_thm.c new file mode 100644 index 00000000..4d9d65c8 --- /dev/null +++ b/drivers/thermal/sprd_pmic_2723s_thm.c @@ -0,0 +1,547 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * 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. + * + */ + +#include <linux/kernel.h> +#include <linux/err.h> +#include <soc/sprd/sci.h> +#include <soc/sprd/sci_glb_regs.h> +#include <linux/io.h> +#include <soc/sprd/adi.h> +#include "thm.h" +#include <linux/sprd_thm.h> +#include <soc/sprd/arch_misc.h> +#include <soc/sprd/hardware.h> +#include "thermal_core.h" +#include <linux/kernel.h> +#include <linux/err.h> +#include <linux/interrupt.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/spi/spi.h> +#include <linux/of_device.h> +#include <linux/io.h> +#include <linux/sprd_thm.h> + +#define SPRD_THM_PMIC_DEBUG +#ifdef SPRD_THM_PMIC_DEBUG +#define THM_PMIC_DEBUG(format, arg...) printk("sprd PMIC thm: " "@@@" format, ## arg) +#else +#define THM_PMIC_DEBUG(format, arg...) +#endif + + +#define A_THM_CTRL (0x0000) +#define A_THM_INT_CTRL (0x0004) +#define A_SENSOR_CTRL (0x0020) +#define A_SENSOR_DET_PERI (0x0024) +#define A_SENSOR_INT_CTRL (0x0028) +#define A_SENSOR_INT_STS (0x002C) +#define A_SENSOR_INT_RAW_STS (0x0030) +#define A_SENSOR_INT_CLR (0x0034) +#define A_SENSOR_OVERHEAT_HOT_THRES (0X0040) +#define A_SENSOR_HOT2NOR__HIGHOFF_THRES (0X0044) +#define A_SENSOR_LOWOFF__COLD_THRES (0X0048) +#define A_SENSOR_TEMPER0_READ (0x0058) + +#define A_SEN_OVERHEAT_INT_BIT (1 << 5) +#define A_SEN_HOT_INT_BIT (1 << 4) +#define A_SEN_HOT2NOR_INT_BIT (1 << 3) +#define A_SEN_HIGHOFF_BIT (1 << 2) +#define A_SEN_LOWOFF_INT_BIT (1 << 1) + +#define A_RAW_TEMP_OFFSET 8 +#define A_RAW_TEMP_RANGE_MSK 0x7F + +#define A_HIGH_BITS_OFFSET 4 + +#define A_HIGH_TAB_SZ 8 +#define A_LOW_TAB_SZ 16 + +#define A_HOT2NOR_RANGE 15 +#define A_LOCAL_SENSOR_ADDR_OFF 0x100 +#define A_DELAY_TEMPERATURE 3 + +#define A_TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define A_TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define A_TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +static const short a_temp_search_high_152nm[A_HIGH_TAB_SZ] = + { -56, -29, -2, 26, 53, 79, 106, 133 }; +static const short a_temp_search_low_152nm[A_LOW_TAB_SZ] = + { 0, 2, 3, 5, 7, 8, 10, 11, 13, 15, 17, 18, 20, 21, 23, 25 }; + +#define SEN_OVERHEAT_INT_BIT (1 << 5) +#define SEN_HOT_INT_BIT (1 << 4) +#define SEN_HOT2NOR_INT_BIT (1 << 3) +#define SEN_HIGHOFF_BIT (1 << 2) +#define SEN_LOWOFF_INT_BIT (1 << 1) + +#define RAW_TEMP_RANGE_MSK 0x3FFF +#define RAW_READ_RANGE_MSK 0x7FFF + +#define HIGH_BITS_OFFSET 4 + +#define HOT2NOR_RANGE 15 +#define LOCAL_SENSOR_ADDR_OFF 0x100 +#define DELAY_TEMPERATURE 3 + +#define SEN_DET_PRECISION (0x50) + +#define TSMC_DOLPHINW4T_CHIP_ID_1 0x7715A001 +#define TSMC_DOLPHINW4T_CHIP_ID_2 0x7715A003 +#define TSMC_DOLPHINWT4T_CHIP_ID_1 0x8815A001 + +#define TEMP_TO_RAM_DEGREE 8 +#define TEMP_LOW (-40) +#define TEMP_HIGH (120) +#define RAW_DATA_LOW (623) +#define RAW_DATA_HIGH (1030) +#define THM_SENOR_NUM 8 + +//static const u32 temp_to_raw[TEMP_TO_RAM_DEGREE + 1] = { RAW_DATA_LOW, 676, 725, 777, 828, 878, 928, 980,RAW_DATA_HIGH }; + +static int pmic_sen_cal_offset = 0; + +unsigned long SPRD_ADIE_THM_BASE = 0; +unsigned int SPRD_ADIE_THM_SIZE = 0; + +extern int sprd_thermal_init(struct sprd_thermal_zone *pzone); +extern void sprd_thermal_remove(struct sprd_thermal_zone *pzone); + +static inline int __thm_pmic_reg_write(unsigned long reg, u16 bits, u16 clear_msk); +static inline u32 __thm_pmic_reg_read(unsigned long reg); + +static inline int __thm_pmic_reg_write(unsigned long reg, u16 bits, u16 clear_msk) +{ + sci_adi_write(reg, bits, clear_msk); + return 0; +} + +static inline u32 __thm_pmic_reg_read(unsigned long reg) +{ + return sci_adi_read(reg); +} +static u32 sprd_thm_temp2rawdata_a(u32 sensor, int temp) +{ + u32 high_bits, low_bits; + int i; + const short *high_tab; + const short *low_tab; + high_tab = a_temp_search_high_152nm; + low_tab = a_temp_search_low_152nm; + + if (temp < high_tab[0]) { + printk(KERN_ERR "temp over low temp:%d \n", temp); + return 0; + } + + for (i = A_HIGH_TAB_SZ - 1; i >= 0; i--) { + if (high_tab[i] <= temp) + break; + } + if (i < 0) { + i = 0; + } + temp -= high_tab[i]; + high_bits = i; + + for (i = A_LOW_TAB_SZ - 1; i >= 0; i--) { + if (low_tab[i] <= temp) + break; + } + if (i < 0) { + i = 0; + } + low_bits = i; + return ((high_bits << HIGH_BITS_OFFSET) | low_bits); + +} +static int sprd_thm_rawdata2temp_a(u32 sensor, int rawdata) +{ + const short *high_tab; + const short *low_tab; + high_tab = a_temp_search_high_152nm; + low_tab = a_temp_search_low_152nm; + + return high_tab[(rawdata >> HIGH_BITS_OFFSET) & 0x07] + + low_tab[rawdata & 0x0F]; +} + +static unsigned long sprd_pmic_thm_temp_read(struct sprd_thermal_zone *pzone) +{ + u32 rawdata = 0; + int cal_offset = 0; + u32 sensor = pzone->sensor_id; + + rawdata = __thm_pmic_reg_read(pzone->reg_base + A_SENSOR_TEMPER0_READ); + cal_offset = pmic_sen_cal_offset; + THM_PMIC_DEBUG("A thm sensor id:%d, cal_offset:%d, rawdata:0x%x\n", sensor, + cal_offset, rawdata); + return (sprd_thm_rawdata2temp_a(sensor, rawdata)*1000 + cal_offset*1000); +} + +static int sprd_pmic_thm_hw_init(struct sprd_thermal_zone *pzone) +{ + unsigned long local_sensor_addr, base_addr = 0; + u32 local_sen_id = 0; + int cal_offset = 0; + int i; + //struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + base_addr = pzone->reg_base; + local_sensor_addr = pzone->reg_base; + + THM_PMIC_DEBUG( "sprd_adie_thm_hw_init 2713s_thm id:%d,base 0x%lx \n", + pzone->sensor_id, base_addr); + // adie thm en + sci_adi_set(ANA_REG_GLB_ARM_MODULE_EN, BIT_ANA_THM_EN); + sci_adi_set(ANA_REG_GLB_RTC_CLK_EN, + BIT_RTC_THMA_AUTO_EN | BIT_RTC_THMA_EN | + BIT_RTC_THM_EN); + + // Reset Thermal + sci_adi_set(ANA_REG_GLB_ARM_RST, + BIT_ANA_THM_SOFT_RST | BIT_ANA_THMA_SOFT_RST); + for(i=0; i < 10000; i++); + sci_adi_clr(ANA_REG_GLB_ARM_RST, + BIT_ANA_THM_SOFT_RST | BIT_ANA_THMA_SOFT_RST); + + cal_offset = pmic_sen_cal_offset = 0; + local_sen_id = 0; + + __thm_pmic_reg_write((base_addr + A_THM_CTRL), 0x1 >> local_sen_id, 0); + __thm_pmic_reg_write((base_addr + A_THM_INT_CTRL), 0x3, 0); //enable top int + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_INT_CLR), ~0, 0); //clr all int + THM_PMIC_DEBUG( "sprd_thm_hw_init addr 0x:%lx,int ctrl 0x%x\n", + local_sensor_addr, + __thm_pmic_reg_read((local_sensor_addr + A_SENSOR_INT_CTRL))); + + // Set sensor det period is 0.25S + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_DET_PERI), 0x2000, 0x2000); + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_CTRL), 0x01, 0x01); + // Start the sensor by set Sen_set_rdy(bit3) + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_CTRL), 0x8, 0x8); + + return 0; +} + +static int sprd_pmic_thm_hw_disable_sensor(struct sprd_thermal_zone *pzone) +{ + int ret = 0; + THM_PMIC_DEBUG("sprd_2713S_thm disable PMIC sensor \n" ); + __thm_pmic_reg_write((unsigned long )(pzone->reg_base + A_SENSOR_CTRL), 0x0, 0x8); + __thm_pmic_reg_write((unsigned long )(pzone->reg_base + A_SENSOR_CTRL), 0x00, 0x01); + + return ret; +} + +static int sprd_pmic_thm_hw_enable_sensor(struct sprd_thermal_zone *pzone) +{ + int ret = 0; + // Sensor minitor enable + THM_PMIC_DEBUG("sprd_2713S_thm enable PMIC sensor \n"); + sci_adi_set(ANA_REG_GLB_RTC_CLK_EN, + BIT_RTC_THMA_AUTO_EN | BIT_RTC_THMA_EN | + BIT_RTC_THM_EN); + __thm_pmic_reg_write((unsigned long )(pzone->reg_base + A_SENSOR_CTRL), 0x01, 0x01); + __thm_pmic_reg_write((unsigned long )(pzone->reg_base + A_SENSOR_CTRL), 0x8, 0x8); + + + return ret; +} + + +u16 int_pmic_ctrl_reg[SPRD_MAX_SENSOR]; +static int sprd_pmic_thm_hw_suspend(struct sprd_thermal_zone *pzone) +{ + u32 local_sen_id = 0; + unsigned long local_sensor_addr; + int ret = 0; + + local_sensor_addr = + (unsigned long ) pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + int_pmic_ctrl_reg[pzone->sensor_id] = __thm_pmic_reg_read((local_sensor_addr + A_SENSOR_INT_CTRL)); + + sprd_pmic_thm_hw_disable_sensor(pzone); + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_INT_CTRL), 0, ~0); //disable all int + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_INT_CLR), ~0, 0); //clr all int + return ret; +} +static int sprd_pmic_thm_hw_resume(struct sprd_thermal_zone *pzone) +{ + u32 local_sen_id = 0; + unsigned long local_sensor_addr; + int ret = 0; + + local_sensor_addr = + (unsigned long ) pzone->reg_base + local_sen_id * LOCAL_SENSOR_ADDR_OFF; + + sprd_pmic_thm_hw_enable_sensor(pzone); + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_INT_CLR), ~0, 0); //clr all int + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_INT_CTRL), int_pmic_ctrl_reg[pzone->sensor_id], ~0); //enable int of saved + __thm_pmic_reg_write((local_sensor_addr + A_SENSOR_CTRL), 0x9, 0); + + return ret; +} + +static int sprd_pmic_thm_get_trend(struct sprd_thermal_zone *pzone, int trip, enum thermal_trend *ptrend) +{ + *ptrend = pzone->trend_val; + return 0; +} + +static int sprd_pmic_thm_get_hyst(struct sprd_thermal_zone *pzone, int trip, unsigned long *physt) +{ + struct sprd_thm_platform_data *trip_tab = pzone->trip_tab; + if (trip >= trip_tab->num_trips - 2){ + *physt = 0; + }else{ + *physt = trip_tab->trip_points[trip].temp - trip_tab->trip_points[trip + 1].lowoff; + } + return 0; +} + +struct thm_handle_ops sprd_pmic_ops = +{ + .hw_init = sprd_pmic_thm_hw_init, + .read_temp = sprd_pmic_thm_temp_read, + .get_trend = sprd_pmic_thm_get_trend, + .get_hyst = sprd_pmic_thm_get_hyst, + .suspend = sprd_pmic_thm_hw_suspend, + .resume = sprd_pmic_thm_hw_resume, +}; + +static struct sprd_thm_platform_data *thermal_detect_parse_dt( + struct device *dev) +{ + struct sprd_thm_platform_data *pdata; + struct device_node *np = dev->of_node; + u32 trip_points_critical,trip_num; + char prop_name[32]; + const char *tmp_str; + u32 tmp_data,tmp_lowoff; + int ret,i ,j = 0; + pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); + if (!pdata) { + dev_err(dev, "could not allocate memory for platform data\n"); + return NULL; + } + ret = of_property_read_u32(np, "trip-points-critical", &trip_points_critical); + if(ret){ + dev_err(dev, "fail to get trip_points_critical\n"); + goto fail; + } + ret = of_property_read_u32(np, "trip-num", &trip_num); + if(ret){ + dev_err(dev, "fail to get trip_num\n"); + goto fail; + } + for (i = 0; i <trip_num-1; ++i) { + sprintf(prop_name, "trip%d-temp-active", i); + if (of_property_read_u32(np, prop_name, &tmp_data)){ + dev_err(dev, "fail to get trip%d-temp-active\n",i); + goto fail; + } + + pdata->trip_points[i].temp = tmp_data; + sprintf(prop_name, "trip%d-temp-lowoff", i); + if (of_property_read_u32(np, prop_name, &tmp_lowoff)){ + dev_err(dev, "fail to get trip%d-temp-lowoff\n",i); + goto fail; + } + pdata->trip_points[i].lowoff = tmp_lowoff; + sprintf(prop_name, "trip%d-type", i); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto fail; + + if (!strcmp(tmp_str, "active")) + pdata->trip_points[i].type = THERMAL_TRIP_ACTIVE; + else if (!strcmp(tmp_str, "passive")) + pdata->trip_points[i].type = THERMAL_TRIP_PASSIVE; + else if (!strcmp(tmp_str, "hot")) + pdata->trip_points[i].type = THERMAL_TRIP_HOT; + else if (!strcmp(tmp_str, "critical")) + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + else + goto fail; + + sprintf(prop_name, "trip%d-cdev-num", i); + if (of_property_read_u32(np, prop_name, &tmp_data)) + goto fail; + for (j = 0; j < tmp_data; j++) { + sprintf(prop_name, "trip%d-cdev-name%d", i, j); + if (of_property_read_string(np, prop_name, &tmp_str)) + goto fail; + strcpy(pdata->trip_points[i].cdev_name[j], tmp_str); + dev_info(dev,"cdev name: %s \n", pdata->trip_points[i].cdev_name[j]); + } + dev_info(dev, "trip[%d] temp: %lu lowoff: %lu\n", + i, pdata->trip_points[i].temp, pdata->trip_points[i].lowoff); + } + pdata->trip_points[i].temp = trip_points_critical; + pdata->trip_points[i].type = THERMAL_TRIP_CRITICAL; + dev_info(dev, "trip[%d] temp: %lu \n", + i, pdata->trip_points[i].temp); + pdata->num_trips = trip_num; + + return pdata; + +fail: + kfree(pdata); + return NULL; + +} + + +static int sprd_adi_thm_probe(struct platform_device *pdev) +{ + struct sprd_thermal_zone *pzone = NULL; + struct sprd_thm_platform_data *ptrips = NULL; + struct resource *res; + const char *thm_name; + int ret,temp_interval,sensor_id; + unsigned long adie_thm_base; + struct device_node *np = pdev->dev.of_node; + if (!np) { + dev_err(&pdev->dev, "device node not found\n"); + return -EINVAL; + } + printk("sprd_adi_thm_probe start\n"); + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + adie_thm_base = (unsigned long)devm_ioremap_resource(&pdev->dev, res); + if (!adie_thm_base) { + pr_err("thermal ioremap failed!\n"); + return -ENOMEM; + } +#if 0 + pdev->id = of_alias_get_id(np, "thmzone"); + printk(KERN_INFO " sprd_thermal_probe id:%d\n", pdev->id); + if (unlikely(pdev->id < 0 || pdev->id >= THM_SENOR_NUM)) { + dev_err(&pdev->dev, "does not support id %d\n", pdev->id); + return -ENXIO; + } +#endif + ret = of_property_read_u32(np, "temp-inteval", &temp_interval); + if(ret){ + dev_err(&pdev->dev, "fail to get temp-inteval\n"); + return -EINVAL; + } + ret = of_property_read_u32(np, "id", &sensor_id); + if (ret) { + dev_err(&pdev->dev, "fail to get id\n"); + return -EINVAL; + } + ptrips = thermal_detect_parse_dt(&pdev->dev); + if (!ptrips){ + dev_err(&pdev->dev, "not found ptrips\n"); + return -EINVAL; + } + pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL); + mutex_init(&pzone->th_lock); + mutex_lock(&pzone->th_lock); + if (!pzone) + return -ENOMEM; + of_property_read_string(np, "thermal-name",&thm_name); + strcpy(pzone->thermal_zone_name, thm_name); + printk("the thermal-name1 is %s\n",pzone->thermal_zone_name); + pzone->reg_base = (unsigned long) ANA_THM_BASE; + pzone->trip_tab = ptrips; + pzone->temp_inteval = temp_interval; + pzone->sensor_id = sensor_id; + pzone->ops = &sprd_pmic_ops; + ret = sprd_pmic_thm_hw_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone hw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + ret = sprd_thermal_init(pzone); + if(ret){ + dev_err(&pdev->dev, " pzone sw init error id =%d\n",pzone->sensor_id); + return -ENODEV; + } + platform_set_drvdata(pdev, pzone); + mutex_unlock(&pzone->th_lock); + printk("sprd_adi_thm_probe end\n"); + return 0; +} + +static int sprd_adi_thm_remove(struct platform_device *pdev) +{ + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + sprd_thermal_remove(pzone); + return 0; +} + +static int sprd_adi_thm_suspend(struct platform_device *pdev, + pm_message_t state) +{ + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + //flush_delayed_work(&pzone->thm_logtime_work); + flush_delayed_work(&pzone->thm_read_work); + flush_delayed_work(&pzone->resume_delay_work); + pzone->ops->suspend(pzone); + return 0; +} + +static int sprd_adi_thm_resume(struct platform_device *pdev) +{ + + struct sprd_thermal_zone *pzone = platform_get_drvdata(pdev); + schedule_delayed_work(&pzone->resume_delay_work, (HZ * 1)); + schedule_delayed_work(&pzone->thm_read_work, (HZ * 5)); + //schedule_delayed_work(&pzone->thm_logtime_work, (HZ * 7)); + //pzone->ops->resume(pzone); + return 0; +} + +static const struct of_device_id thermal_of_match[] = { + { .compatible = "sprd,sc2723-thermal", }, + {} +}; + +static struct platform_driver sprd_thermal_driver = { + .probe = sprd_adi_thm_probe, + .suspend = sprd_adi_thm_suspend, + .resume = sprd_adi_thm_resume, + .remove = sprd_adi_thm_remove, + .driver = { + .owner = THIS_MODULE, + .name = "sc2723-thermal", +#ifdef CONFIG_OF + .of_match_table = of_match_ptr(thermal_of_match), +#endif + }, +}; +static int __init sprd_adi_thermal_init(void) +{ + return platform_driver_register(&sprd_thermal_driver); +} + +static void __exit sprd_adi_thermal_exit(void) +{ + platform_driver_unregister(&sprd_thermal_driver); +} + +device_initcall_sync(sprd_adi_thermal_init); +module_exit(sprd_adi_thermal_exit); + +MODULE_AUTHOR("Freeman Liu <freeman.liu@spreadtrum.com>"); +MODULE_DESCRIPTION("sprd thermal driver"); +MODULE_LICENSE("GPL"); + + + + diff --git a/drivers/thermal/sprd_thm.c b/drivers/thermal/sprd_thm.c new file mode 100644 index 00000000..4a56c3e6 --- /dev/null +++ b/drivers/thermal/sprd_thm.c @@ -0,0 +1,587 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + */ + +#include <linux/interrupt.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/err.h> +#include<linux/string.h> +#include <asm/io.h> +#include <linux/thermal.h> +#include <linux/sprd_thm.h> +#include "thm.h" +#include "linux/delay.h" +#ifdef CONFIG_OF +#include <linux/slab.h> +#include <linux/of_device.h> +//#include <linux/of_address.h> +#include <linux/of_irq.h> +#endif + +struct thm_handle_ops *sprd_thm_handle_ops[SPRD_MAX_SENSOR] = {NULL}; +char sprd_thm_name[SPRD_MAX_SENSOR][THERMAL_NAME_LENGTH] = {{0},{0}}; +extern struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name); +extern int thermal_zone_get_temp(struct thermal_zone_device *tz, unsigned long *temp); +int sprd_thermal_temp_get(enum sprd_thm_sensor_id thermal_id,unsigned long *temp) +{ + char thermal_name[SPRD_MAX_SENSOR][THERMAL_NAME_LENGTH] = { + "sprd_arm_thm", + "sprd_gpu_thm", + "sprd_pmic_thm" + }; + struct thermal_zone_device * tz = thermal_zone_get_zone_by_name(thermal_name[thermal_id]); + if(IS_ERR(tz) ) + return -1; + return thermal_zone_get_temp(tz, temp); +} +EXPORT_SYMBOL(sprd_thermal_temp_get); +#if 0 +static int sprd_thm_ops_init(struct sprd_thermal_zone *pzone) +{ + if((!sprd_thm_name[pzone->sensor_id]) ||(!sprd_thm_handle_ops[pzone->sensor_id]) ) + return -1; + strcpy(pzone->thermal_zone_name,sprd_thm_name[pzone->sensor_id]); + pzone->ops = sprd_thm_handle_ops[pzone->sensor_id]; + return 0; +} +int sprd_thm_add(struct thm_handle_ops* ops, char *p,int id) +{ + if( (ops == NULL) ||( p == NULL) ||( id >=SPRD_MAX_SENSOR)) + return -1; + sprd_thm_handle_ops[id] = ops; + strcpy(sprd_thm_name[id],p); + return 0; +} +void sprd_thm_delete(int id) +{ + sprd_thm_handle_ops[id] = NULL; + strcpy(sprd_thm_name[id],""); +} +#endif +static int sprd_thermal_match_cdev(struct thermal_cooling_device *cdev, + struct sprd_trip_point *trip_point) +{ + int i; + if (!strlen(cdev->type)) + return -EINVAL; + for (i = 0; i < COOLING_DEV_MAX; i++) { + if (!strcmp(trip_point->cdev_name[i], cdev->type)) + return 0; + } + return -ENODEV; +} + +/* Callback to bind cooling device to thermal zone */ +static int sprd_cdev_bind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + int i, ret = -EINVAL; + + printk(KERN_INFO "sprd_cdev_bind--%d \n", pzone->sensor_id); + for (i = 0; i < ptrips->num_trips; i++) { + if (sprd_thermal_match_cdev(cdev, &ptrips->trip_points[i])) + continue; + ret = thermal_zone_bind_cooling_device(thermal, i, cdev, THERMAL_NO_LIMIT, THERMAL_NO_LIMIT); + dev_info(&cdev->device, "%s bind to %d: %d-%s\n", cdev->type, + i, ret, ret ? "fail" : "succeed"); + } + return 0; +} + +/* Callback to unbind cooling device from thermal zone */ +static int sprd_cdev_unbind(struct thermal_zone_device *thermal, + struct thermal_cooling_device *cdev) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + int i, ret = -EINVAL; + + for (i = 0; i < ptrips->num_trips; i++) { + if (sprd_thermal_match_cdev(cdev, &ptrips->trip_points[i])) + continue; + ret = thermal_zone_unbind_cooling_device(thermal, i, cdev); + dev_info(&cdev->device, "%s unbind from %d: %s\n", + cdev->type, i, ret ? "fail" : "succeed"); + } + return ret; +} + +/* Callback to get current temperature */ +static int sprd_sys_get_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + if(!pzone->ops->read_temp) + return -1; + *temp = pzone->ops->read_temp(pzone); + return 0; +} + +/* Callback to get thermal zone mode */ +static int sprd_sys_get_mode(struct thermal_zone_device *thermal, + enum thermal_device_mode *mode) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + mutex_lock(&pzone->th_lock); + *mode = pzone->mode; + mutex_unlock(&pzone->th_lock); + return 0; +} + +/* Callback to set thermal zone mode */ +static int sprd_sys_set_mode(struct thermal_zone_device *thermal, + enum thermal_device_mode mode) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + mutex_lock(&pzone->th_lock); + pzone->mode = mode; + if (mode == THERMAL_DEVICE_ENABLED) + schedule_work(&pzone->therm_work); + mutex_unlock(&pzone->th_lock); + return 0; +} +#ifdef THM_TEST +static int sprd_sys_get_regs(struct thermal_zone_device *thermal, + unsigned int* regs) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + if(!pzone->ops->reg_debug_get) + return -1; + return pzone->ops->reg_debug_get(pzone,regs); +} + +static int sprd_sys_set_regs(struct thermal_zone_device *thermal, + unsigned int *regs) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + if(!pzone->ops->reg_debug_set) + return -1; + return pzone->ops->reg_debug_set(pzone,regs); +} + +/* Callback to get thermal zone logtime */ +static int sprd_sys_get_logtime(struct thermal_zone_device *thermal, + unsigned long *logtime) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + mutex_lock(&pzone->th_lock); + *logtime = pzone->logtime; + mutex_unlock(&pzone->th_lock); + return 0; +} + +/* Callback to set thermal zone logtime */ +static int sprd_sys_set_logtime(struct thermal_zone_device *thermal, + unsigned long logtime) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + mutex_lock(&pzone->th_lock); + pzone->logtime = logtime; + mutex_unlock(&pzone->th_lock); + return 0; +} + +/* Callback to get thermal log switch status*/ +static int sprd_sys_get_logswitch(struct thermal_zone_device *thermal, + enum thermal_log_switch *logswitch) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + mutex_lock(&pzone->th_lock); + *logswitch = pzone->thmlog_switch; + mutex_unlock(&pzone->th_lock); + return 0; +} + +/* Callback to set thermal log switch status */ +static int sprd_sys_set_logswitch(struct thermal_zone_device *thermal, + enum thermal_log_switch logswitch) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + mutex_lock(&pzone->th_lock); + pzone->thmlog_switch = logswitch; + if (logswitch == THERMAL_LOG_ENABLED) + schedule_delayed_work(&pzone->thm_logtime_work, (HZ * pzone->logtime)); + mutex_unlock(&pzone->th_lock); + return 0; +} + + +static ssize_t +debug_reg_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + u32 regs[4] = {0}; + sprd_sys_get_regs(tz,regs); + return sprintf(buf, "DET_PERI=%08x,MON_CTL=%08x,MON_PERI=%08x,SENSOR_CTL=%08x\n", + regs[0],regs[1],regs[2],regs[3]); +} + +static ssize_t +debug_reg_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + unsigned int regs[4]={0}; + if (!sscanf(buf, "%x,%x,%x,%x", ®s[0],®s[1],®s[2],®s[3])) + return -EINVAL; + + printk("%x,%x,%x,%x\n", regs[0],regs[1],regs[2],regs[3]); + sprd_sys_set_regs(tz,regs); + return count; +} +static DEVICE_ATTR(debug_reg, 0644,debug_reg_show, debug_reg_store); + +static int sprd_debug_get_trip_temp(struct thermal_zone_device *thermal, + int trip, unsigned long *temp,unsigned long *low_off) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + if (trip >= ptrips->num_trips) + return -EINVAL; + *temp = ptrips->trip_points[trip].temp; + *low_off = ptrips->trip_points[trip].lowoff; + return 0; +} + +static int sprd_debug_set_trip_temp(struct thermal_zone_device *thermal, + int trip, unsigned long temp,unsigned long low_off) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + if(!pzone->ops->trip_debug_set) + return 0; + ptrips->trip_points[trip].temp = temp; + ptrips->trip_points[trip].lowoff = low_off; + return pzone->ops->trip_debug_set(pzone,trip); +} +static ssize_t +trip_point_debug_temp_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + int trip, ret; + long temperature,low_off; + if (!sscanf(attr->attr.name, "trip_%d_temp", &trip)) + return -EINVAL; + ret = sprd_debug_get_trip_temp(tz, trip, &temperature,&low_off); + + if (ret) + return ret; + return sprintf(buf, "tem = %ld,low_off=%ld\n", temperature,low_off); +} +static ssize_t +trip_point_debug_temp_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + int trip, ret; + unsigned long temperature,low_off; + if (!sscanf(attr->attr.name, "trip_%d_temp", &trip)) + return -EINVAL; + if(!sscanf(buf,"%ld,%ld",&temperature,&low_off)) + return -EINVAL; + ret = sprd_debug_set_trip_temp(tz, trip, temperature, low_off); + return ret ? ret : count; +} + +static ssize_t +logtime_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + //struct thermal_zone_device *tz = to_thermal_zone(dev); + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + unsigned long logtime; + int result; + result = sprd_sys_get_logtime(tz, &logtime); + if (result) + return result; + + return sprintf(buf, "%ld\n", logtime); + +} +static ssize_t +logtime_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + //struct thermal_zone_device *tz = to_thermal_zone(dev); + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + int result; + unsigned long logtime; + if (kstrtoul(buf, 10, &logtime)) + return -EINVAL; + result = sprd_sys_set_logtime(tz, logtime); + if (result) + return result; + + return count; +} +static ssize_t +logswitch_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + //struct thermal_zone_device *tz = to_thermal_zone(dev); + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + enum thermal_log_switch logswtich; + int result; + + result = sprd_sys_get_logswitch(tz, &logswtich); + if (result) + return result; + + return sprintf(buf, "%s\n", logswtich == THERMAL_LOG_ENABLED ? "enabled" + : "disabled"); +} +static ssize_t +logswitch_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = container_of(dev, struct thermal_zone_device, device); + int result; + + if (!strncmp(buf, "enabled", sizeof("enabled") - 1)) + result = sprd_sys_set_logswitch(tz, THERMAL_LOG_ENABLED); + else if (!strncmp(buf, "disabled", sizeof("disabled") - 1)) + result = sprd_sys_set_logswitch(tz, THERMAL_LOG_DISABLED); + else + result = -EINVAL; + + if (result) + return result; + + return count; +} + +static DEVICE_ATTR(logtime, 0644, logtime_show, logtime_store); +static DEVICE_ATTR(logswitch, 0644, logswitch_show, logswitch_store); + +static int create_trip_attrs(struct thermal_zone_device *tz) +{ + int indx; + int size = sizeof(struct thermal_attr) * tz->trips; + int result; + result = device_create_file(&tz->device, &dev_attr_logswitch); + if (result) + return result; + result = device_create_file(&tz->device, &dev_attr_logtime); + if (result) + return result; + tz->trip_temp_attrs = kzalloc(size, GFP_KERNEL); + if (!tz->trip_temp_attrs) { + return -ENOMEM; + } + + for (indx = 0; indx < tz->trips; indx++) { + /* create trip temp attribute */ + snprintf(tz->trip_temp_attrs[indx].name, THERMAL_NAME_LENGTH, + "trip_%d_temp", indx); + + sysfs_attr_init(&tz->trip_temp_attrs[indx].attr.attr); + tz->trip_temp_attrs[indx].attr.attr.name = + tz->trip_temp_attrs[indx].name; + tz->trip_temp_attrs[indx].attr.attr.mode = S_IRUGO; + tz->trip_temp_attrs[indx].attr.show = trip_point_debug_temp_show; + tz->trip_temp_attrs[indx].attr.attr.mode |= S_IWUSR; + tz->trip_temp_attrs[indx].attr.store =trip_point_debug_temp_store; + device_create_file(&tz->device, + &tz->trip_temp_attrs[indx].attr); + } + return 0; +} + +static void remove_trip_attrs(struct thermal_zone_device *tz) +{ + int indx; + device_remove_file(&tz->device, &dev_attr_logswitch); + device_remove_file(&tz->device, &dev_attr_logtime); + for (indx = 0; indx < tz->trips; indx++) { + device_remove_file(&tz->device, + &tz->trip_temp_attrs[indx].attr); + } + kfree(tz->trip_temp_attrs); +} +#endif + +void sprd_thermal_remove(struct sprd_thermal_zone *pzone) +{ +#ifdef THM_TEST + remove_trip_attrs(pzone->therm_dev); + device_remove_file(&pzone->therm_dev->device, &dev_attr_debug_reg); + cancel_delayed_work_sync(&pzone->thm_logtime_work); +#endif + thermal_zone_device_unregister(pzone->therm_dev); + cancel_delayed_work_sync(&pzone->thm_read_work); + cancel_delayed_work_sync(&pzone->resume_delay_work); + mutex_destroy(&pzone->th_lock); +} + +static int sprd_sys_get_trend(struct thermal_zone_device *thermal, + int trip, enum thermal_trend * ptrend) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + return pzone->ops->get_trend(pzone, trip, ptrend); +} + +static int sprd_sys_get_hyst(struct thermal_zone_device *thermal, + int trip, unsigned long *physt) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + return pzone->ops->get_hyst(pzone, trip, physt); +} + + +/* Callback to get trip point type */ +static int sprd_sys_get_trip_type(struct thermal_zone_device *thermal, + int trip, enum thermal_trip_type *type) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + if (trip >= ptrips->num_trips) + return -EINVAL; + *type = ptrips->trip_points[trip].type; + return 0; +} + +/* Callback to get trip point temperature */ +static int sprd_sys_get_trip_temp(struct thermal_zone_device *thermal, + int trip, unsigned long *temp) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + if (trip >= ptrips->num_trips) + return -EINVAL; + *temp = ptrips->trip_points[trip].temp; + return 0; +} + +/* Callback to get critical trip point temperature */ +static int sprd_sys_get_crit_temp(struct thermal_zone_device *thermal, + unsigned long *temp) +{ + struct sprd_thermal_zone *pzone = thermal->devdata; + struct sprd_thm_platform_data *ptrips = pzone->trip_tab; + int i; + for (i = ptrips->num_trips - 1; i > 0; i--) { + if (ptrips->trip_points[i].type == THERMAL_TRIP_CRITICAL) { + *temp = ptrips->trip_points[i].temp; + return 0; + } + } + return -EINVAL; +} + +static struct thermal_zone_device_ops thdev_ops = { + .bind = sprd_cdev_bind, + .unbind = sprd_cdev_unbind, + .get_temp = sprd_sys_get_temp, + .get_mode = sprd_sys_get_mode, + .set_mode = sprd_sys_set_mode, + .get_trip_type = sprd_sys_get_trip_type, + .get_trip_temp = sprd_sys_get_trip_temp, + .get_trip_hyst = sprd_sys_get_hyst, + .get_crit_temp = sprd_sys_get_crit_temp, + .get_trend = sprd_sys_get_trend, +}; +static void sprd_thermal_resume_delay_work(struct work_struct *work) +{ + struct sprd_thermal_zone *pzone; + + pzone = container_of(work, struct sprd_thermal_zone, resume_delay_work.work); + dev_dbg(&pzone->therm_dev->device, "thermal resume delay work Started.\n"); + pzone->ops->resume(pzone); + dev_dbg(&pzone->therm_dev->device, "thermal resume delay work finished.\n"); +} +#ifdef THM_TEST +static void thm_logtime_work(struct work_struct *work) +{ + struct sprd_thermal_zone *pzone; + unsigned long temp; + pzone = container_of(work, struct sprd_thermal_zone, thm_logtime_work.work); + temp = pzone->ops->read_temp(pzone); + if(pzone->thmlog_switch == THERMAL_LOG_ENABLED ){ + schedule_delayed_work(&pzone->thm_logtime_work, (HZ * pzone->logtime)); + } +} +#endif + +static void thm_read_work(struct work_struct *work) +{ + int ret; + enum thermal_device_mode cur_mode; + struct sprd_thermal_zone *pzone; + pzone = container_of(work, struct sprd_thermal_zone, thm_read_work.work); + mutex_lock(&pzone->th_lock); + cur_mode = pzone->mode; + mutex_unlock(&pzone->th_lock); + if (cur_mode == THERMAL_DEVICE_DISABLED) + return; + if(pzone->temp_inteval == 0) + return; + ret = thermal_zone_get_temp(pzone->therm_dev, &pzone->cur_temp); + if (ret) { + dev_warn(&pzone->therm_dev->device, "failed to read out thermal zone %d\n", + pzone->therm_dev->id); + return; + } + printk("thm id:%d, inteval:%d, last_temp:%ld,cur_temp:%ld\n", pzone->sensor_id,pzone->temp_inteval,pzone->last_temp,pzone->cur_temp); + if(pzone->cur_temp > pzone->last_temp) + { + pzone->trend_val = THERMAL_TREND_RAISING; + if (pzone->cur_temp >= pzone->trip_tab->trip_points[pzone->current_trip_num].temp ){ + if((pzone->trip_tab->num_trips-1) > pzone->current_trip_num ) + pzone->current_trip_num++; + thermal_zone_device_update(pzone->therm_dev); + } + }else if(pzone->cur_temp < pzone->last_temp){ + pzone->trend_val = THERMAL_TREND_DROPPING; + printk("pzone->trend_val = THERMAL_TREND_DROPPING\n"); + if (pzone->cur_temp < pzone->trip_tab->trip_points[pzone->current_trip_num].lowoff ){ + pzone->current_trip_num--; + thermal_zone_device_update(pzone->therm_dev); + } + }else{ + printk("pzone->trend_val = THERMAL_TREND_STABLE\n"); + pzone->trend_val = THERMAL_TREND_STABLE; + } + pzone->last_temp = pzone->cur_temp; + schedule_delayed_work(&pzone->thm_read_work, (HZ * pzone->temp_inteval)); +} + +int sprd_thermal_init(struct sprd_thermal_zone *pzone) +{ + int ret=0; + pzone->mode = THERMAL_DEVICE_DISABLED; + pzone->trend_val = THERMAL_TREND_STABLE; + INIT_DELAYED_WORK(&pzone->thm_read_work, thm_read_work); + INIT_DELAYED_WORK(&pzone->resume_delay_work,sprd_thermal_resume_delay_work); + pzone->therm_dev = + thermal_zone_device_register(pzone->thermal_zone_name, + pzone->trip_tab->num_trips, 0, pzone, + &thdev_ops, 0, 0, 0); + if (IS_ERR_OR_NULL(pzone->therm_dev)) { + printk("Register thermal zone device failed.\n"); + return PTR_ERR(pzone->therm_dev); + } + pzone->mode = THERMAL_DEVICE_ENABLED; + schedule_delayed_work(&pzone->thm_read_work, (HZ * pzone->temp_inteval)); +#ifdef THM_TEST + pzone->logtime= 2; + pzone->thmlog_switch= THERMAL_LOG_DISABLED; + INIT_DELAYED_WORK(&pzone->thm_logtime_work, thm_logtime_work); + create_trip_attrs(pzone->therm_dev); + ret = device_create_file(&pzone->therm_dev->device, &dev_attr_debug_reg); +#endif + printk(" sprd_thermal_init end\n"); + return 0; +} + diff --git a/drivers/thermal/step_wise.c b/drivers/thermal/step_wise.c new file mode 100644 index 00000000..9f012873 --- /dev/null +++ b/drivers/thermal/step_wise.c @@ -0,0 +1,350 @@ +/* + * step_wise.c - A step-by-step Thermal throttling governor + * + * Copyright (C) 2012 Intel Corp + * Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.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/thermal.h> + +#include "thermal_core.h" + +/* + * 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 + * c. if the trend is THERMAL_TREND_RAISE_FULL, use upper limit + * for this trip point + * d. if the trend is THERMAL_TREND_DROP_FULL, use lower limit + * for this trip point + * If the temperature is lower than a trip point, + * a. if the trend is THERMAL_TREND_RAISING, do nothing + * b. if the trend is THERMAL_TREND_DROPPING, use lower cooling + * state for this trip point, if the cooling state already + * equals lower limit, deactivate the thermal instance + * c. if the trend is THERMAL_TREND_RAISE_FULL, do nothing + * d. if the trend is THERMAL_TREND_DROP_FULL, use lower limit, + * if the cooling state already equals lower limit, + * deactive the thermal instance + */ +#if 0 +static unsigned long get_target_state(struct thermal_instance *instance, + enum thermal_trend trend, bool throttle) +{ + struct thermal_cooling_device *cdev = instance->cdev; + unsigned long cur_state; + + cdev->ops->get_cur_state(cdev, &cur_state); + dev_dbg(&cdev->device, "cur_state=%ld\n", cur_state); + + switch (trend) { + case THERMAL_TREND_RAISING: + if (throttle) { + cur_state = cur_state < instance->upper ? + (cur_state + 1) : instance->upper; + if (cur_state < instance->lower) + cur_state = instance->lower; + } + break; + case THERMAL_TREND_RAISE_FULL: + if (throttle) + cur_state = instance->upper; + break; + case THERMAL_TREND_DROPPING: + if (cur_state == instance->lower) { + if (!throttle) + cur_state = -1; + } else { + cur_state -= 1; + if (cur_state > instance->upper) + cur_state = instance->upper; + } + break; + case THERMAL_TREND_DROP_FULL: + if (cur_state == instance->lower) { + if (!throttle) + cur_state = -1; + } else + cur_state = instance->lower; + break; + default: + break; + } + + return cur_state; +} + +static void update_passive_instance(struct thermal_zone_device *tz, + enum thermal_trip_type type, int value) +{ + /* + * If value is +1, activate a passive instance. + * If value is -1, deactivate a passive instance. + */ + if (type == THERMAL_TRIP_PASSIVE || type == THERMAL_TRIPS_NONE) + tz->passive += value; +} + +static void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip) +{ + long trip_temp; + enum thermal_trip_type trip_type; + enum thermal_trend trend; + struct thermal_instance *instance; + bool throttle = false; + int old_target; + + 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); + } + + trend = get_tz_trend(tz, trip); + + if (tz->temperature >= trip_temp) + throttle = true; + + dev_dbg(&tz->device, "Trip%d[type=%d,temp=%ld]:trend=%d,throttle=%d\n", + trip, trip_type, trip_temp, trend, throttle); + + mutex_lock(&tz->lock); + + list_for_each_entry(instance, &tz->thermal_instances, tz_node) { + if (instance->trip != trip) + continue; + + old_target = instance->target; + instance->target = get_target_state(instance, trend, throttle); + dev_dbg(&instance->cdev->device, "old_target=%d, target=%d\n", + old_target, (int)instance->target); + + /* Activate a passive thermal instance */ + if (old_target == THERMAL_NO_TARGET && + instance->target != THERMAL_NO_TARGET) + update_passive_instance(tz, trip_type, 1); + /* Deactivate a passive thermal instance */ + else if (old_target != THERMAL_NO_TARGET && + instance->target == THERMAL_NO_TARGET) + update_passive_instance(tz, trip_type, -1); + + + instance->cdev->updated = false; /* cdev needs update */ + } + + mutex_unlock(&tz->lock); +} +#else + +static unsigned long get_hyst_target(struct thermal_zone_device *tz, int trip) +{ + int count; + unsigned long trip_temp, trip_hyst, hyst_temp; + + if (tz->trips == 0 || !tz->ops->get_trip_hyst){ + return 0; + } + for (count = 0; count < tz->trips; count++) { + tz->ops->get_trip_temp(tz, count, &trip_temp); + tz->ops->get_trip_hyst(tz, count, &trip_hyst); + hyst_temp = trip_temp - trip_hyst; + printk("trip:%d, temp:%d, hyst_temp:%d\n", count, tz->temperature, hyst_temp); + if (tz->temperature < (long)hyst_temp + TRIP_TEMP_OFFSET) + break; + } + if (trip == count) { + return count; + } else { + return THERMAL_NO_TARGET; + } +} + +static unsigned long get_trip_target(struct thermal_zone_device *tz, int trip) +{ + int count = 0; + unsigned long trip_temp; + + if (tz->trips == 0 || !tz->ops->get_trip_temp) + return 0; + + for (count = tz->trips - 1; count >= 0; count--) { + tz->ops->get_trip_temp(tz, count, &trip_temp); + printk("trip:%d, temp:%d, trip_temp:%d\n", count, tz->temperature, trip_temp); + if (tz->temperature > (long)trip_temp - TRIP_TEMP_OFFSET) + break; + } + if (trip == count) { + return count + 1; + } else { + return THERMAL_NO_TARGET; + } + +} + +static unsigned long get_step_wise_target(struct thermal_instance *instance, + struct thermal_zone_device *tz, int trip) +{ + struct thermal_cooling_device *cdev = instance->cdev; + enum thermal_trend trend; + unsigned long cur_target; + unsigned long cdev_state; + unsigned long new_target; + + cur_target = instance->target; + printk("%s:%s trip:%d cur_target:%d\n", __func__, cdev->type, trip, cur_target); + cdev->ops->get_cur_state(cdev, &cdev_state); + printk("%s:%s trip:%d cdev_state:%d\n", __func__, cdev->type, trip, cdev_state); + if (cdev_state == THERMAL_NO_TARGET){ + cdev_state = instance->lower; + } + if (tz->ops->get_trend){ + tz->ops->get_trend(tz, trip, &trend); + }else{ + new_target = get_trip_target(tz, trip); + printk("%s: %s trip:%d new_target:%d\n", __func__, cdev->type, trip, new_target); + if (new_target == THERMAL_NO_TARGET) { + return THERMAL_NO_TARGET; + } + if (new_target < cdev_state){ + trend = THERMAL_TREND_DROPPING; + if (!tz->ops->get_trip_hyst){ + goto dropping; + } + }else if(new_target >= cdev_state){ + goto raising; + } + } + switch (trend){ + case THERMAL_TREND_RAISING: + new_target = get_trip_target(tz, trip); + printk("%s: %s trend raising, target:%d\n", __func__, cdev->type, new_target); + if (new_target == THERMAL_NO_TARGET) { + return THERMAL_NO_TARGET; + } + goto raising; + case THERMAL_TREND_DROPPING: +#if 0 + if (tz->ops->get_trip_hyst){ + new_target = get_hyst_target(tz, trip); + }else{ + new_target = get_trip_target(tz, trip); + } + printk("%s: %s trend dropping, target:%d\n", cdev->type, __func__, new_target); + if (new_target == THERMAL_NO_TARGET) { + return THERMAL_NO_TARGET; + } +#endif + goto dropping; + case THERMAL_TREND_STABLE: + default: + printk("%s: %s trend stable\n", cdev->type, __func__); + return THERMAL_NO_TARGET; + } +raising: + if (cdev_state > trip){ + cdev_state = trip; + } + return cdev_state + 1; +dropping: + if (cur_target != THERMAL_NO_TARGET && cur_target > 0){ + return cur_target - 1; + } + return cur_target; + +} + +static void thermal_zone_trip_update(struct thermal_zone_device *tz, int trip) +{ + struct thermal_instance *instance; + unsigned long target; + + mutex_lock(&tz->lock); + list_for_each_entry(instance, &tz->thermal_instances, tz_node) { + if (instance->trip != trip) + continue; + target = get_step_wise_target(instance, tz, trip); + printk("%s: get target_state: %d\n", instance->cdev->type, target); + if (target == THERMAL_NO_TARGET){ + continue; + } + if (target < instance->lower){ + target = instance->lower; + } + if (target > instance->upper){ + target = instance->upper; + } + instance->target = target; + instance->cdev->updated = false; /* cdev needs update */ + } + mutex_unlock(&tz->lock); + + return; +} +#endif + +/** + * step_wise_throttle - throttles devices asscciated with the given zone + * @tz - thermal_zone_device + * @trip - the trip point + * @trip_type - type of the trip point + * + * Throttling Logic: This uses the trend of the thermal zone to throttle. + * If the thermal zone is 'heating up' this throttles all the cooling + * devices associated with the zone and its particular trip point, by one + * step. If the zone is 'cooling down' it brings back the performance of + * the devices by one step. + */ +static int step_wise_throttle(struct thermal_zone_device *tz, int trip) +{ + struct thermal_instance *instance; + + thermal_zone_trip_update(tz, trip); + + if (tz->forced_passive) + thermal_zone_trip_update(tz, THERMAL_TRIPS_NONE); + + mutex_lock(&tz->lock); + + list_for_each_entry(instance, &tz->thermal_instances, tz_node) + thermal_cdev_update(instance->cdev); + + mutex_unlock(&tz->lock); + + return 0; +} + +static struct thermal_governor thermal_gov_step_wise = { + .name = "step_wise", + .throttle = step_wise_throttle, +}; + +int thermal_gov_step_wise_register(void) +{ + return thermal_register_governor(&thermal_gov_step_wise); +} + +void thermal_gov_step_wise_unregister(void) +{ + thermal_unregister_governor(&thermal_gov_step_wise); +} diff --git a/drivers/thermal/thermal_core.c b/drivers/thermal/thermal_core.c new file mode 100644 index 00000000..edc0cb88 --- /dev/null +++ b/drivers/thermal/thermal_core.c @@ -0,0 +1,1845 @@ +/* + * 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> + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * 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. + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/module.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/slab.h> +#include <linux/kdev_t.h> +#include <linux/idr.h> +#include <linux/thermal.h> +#include <linux/reboot.h> +#include <linux/string.h> +#include <linux/of.h> +#include <net/netlink.h> +#include <net/genetlink.h> + +#include "thermal_core.h" +#include "thermal_hwmon.h" + +MODULE_AUTHOR("Zhang Rui"); +MODULE_DESCRIPTION("Generic thermal management sysfs support"); +MODULE_LICENSE("GPL v2"); + +static DEFINE_IDR(thermal_tz_idr); +static DEFINE_IDR(thermal_cdev_idr); +static DEFINE_MUTEX(thermal_idr_lock); + +static LIST_HEAD(thermal_tz_list); +static LIST_HEAD(thermal_cdev_list); +static LIST_HEAD(thermal_governor_list); + +static DEFINE_MUTEX(thermal_list_lock); +static DEFINE_MUTEX(thermal_governor_lock); + +static struct thermal_governor *def_governor; + +static struct thermal_governor *__find_governor(const char *name) +{ + struct thermal_governor *pos; + + if (!name || !name[0]) + return def_governor; + + list_for_each_entry(pos, &thermal_governor_list, governor_list) + if (!strnicmp(name, pos->name, THERMAL_NAME_LENGTH)) + return pos; + + return NULL; +} + +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; + if (__find_governor(governor->name) == NULL) { + err = 0; + list_add(&governor->governor_list, &thermal_governor_list); + if (!def_governor && !strncmp(governor->name, + DEFAULT_THERMAL_GOVERNOR, THERMAL_NAME_LENGTH)) + def_governor = governor; + } + + mutex_lock(&thermal_list_lock); + + list_for_each_entry(pos, &thermal_tz_list, node) { + /* + * only thermal zones with specified tz->tzp->governor_name + * may run with tz->govenor unset + */ + if (pos->governor) + continue; + + name = pos->tzp->governor_name; + + if (!strnicmp(name, governor->name, THERMAL_NAME_LENGTH)) + pos->governor = governor; + } + + 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); + + if (__find_governor(governor->name) == NULL) + goto exit; + + mutex_lock(&thermal_list_lock); + + list_for_each_entry(pos, &thermal_tz_list, node) { + if (!strnicmp(pos->governor->name, governor->name, + THERMAL_NAME_LENGTH)) + pos->governor = NULL; + } + + mutex_unlock(&thermal_list_lock); + list_del(&governor->governor_list); +exit: + mutex_unlock(&thermal_governor_lock); + return; +} + +static int get_idr(struct idr *idr, struct mutex *lock, int *id) +{ + int ret; + + if (lock) + mutex_lock(lock); + ret = idr_alloc(idr, NULL, 0, 0, GFP_KERNEL); + if (lock) + mutex_unlock(lock); + if (unlikely(ret < 0)) + return ret; + *id = ret; + return 0; +} + +static void release_idr(struct idr *idr, struct mutex *lock, int id) +{ + if (lock) + mutex_lock(lock); + idr_remove(idr, id); + if (lock) + mutex_unlock(lock); +} + +int get_tz_trend(struct thermal_zone_device *tz, int trip) +{ + enum thermal_trend trend; + + if (!tz->ops->get_trend || tz->ops->get_trend(tz, trip, &trend)) { + 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; + } + + return trend; +} +EXPORT_SYMBOL(get_tz_trend); + +struct thermal_instance *get_thermal_instance(struct thermal_zone_device *tz, + struct thermal_cooling_device *cdev, int trip) +{ + struct thermal_instance *pos = NULL; + struct thermal_instance *target_instance = NULL; + + mutex_lock(&tz->lock); + mutex_lock(&cdev->lock); + + list_for_each_entry(pos, &tz->thermal_instances, tz_node) { + if (pos->tz == tz && pos->trip == trip && pos->cdev == cdev) { + target_instance = pos; + break; + } + } + + mutex_unlock(&cdev->lock); + mutex_unlock(&tz->lock); + + return target_instance; +} +EXPORT_SYMBOL(get_thermal_instance); + +static void print_bind_err_msg(struct thermal_zone_device *tz, + struct thermal_cooling_device *cdev, int ret) +{ + 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) +{ + int i, ret; + + for (i = 0; i < tz->trips; i++) { + if (mask & (1 << i)) { + ret = thermal_zone_bind_cooling_device(tz, i, cdev, + THERMAL_NO_LIMIT, THERMAL_NO_LIMIT); + if (ret) + print_bind_err_msg(tz, cdev, ret); + } + } +} + +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); +} + +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); + } + } + + mutex_unlock(&thermal_list_lock); +} + +static void bind_tz(struct thermal_zone_device *tz) +{ + int i, ret; + struct thermal_cooling_device *pos = NULL; + const struct thermal_zone_params *tzp = tz->tzp; + + if (!tzp && !tz->ops->bind) + return; + + mutex_lock(&thermal_list_lock); + + /* 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); + } + goto exit; + } + + if (!tzp || !tzp->tbp) + goto exit; + + 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); + } + } +exit: + mutex_unlock(&thermal_list_lock); +} + +static void thermal_zone_device_set_polling(struct thermal_zone_device *tz, + int delay) +{ + if (delay > 1000) + mod_delayed_work(system_freezable_wq, &tz->poll_queue, + round_jiffies(msecs_to_jiffies(delay))); + else if (delay) + mod_delayed_work(system_freezable_wq, &tz->poll_queue, + 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, + int trip, enum thermal_trip_type trip_type) +{ + tz->governor ? tz->governor->throttle(tz, trip) : + def_governor->throttle(tz, trip); +} + +static void handle_critical_trips(struct thermal_zone_device *tz, + int trip, enum thermal_trip_type trip_type) +{ + long trip_temp; + + tz->ops->get_trip_temp(tz, trip, &trip_temp); + + /* If we have not crossed the trip_temp, we do not care. */ + if (tz->temperature < trip_temp) + return; + + if (tz->ops->notify) + tz->ops->notify(tz, trip, trip_type); + + if (trip_type == THERMAL_TRIP_CRITICAL) { + dev_emerg(&tz->device, + "critical temperature reached(%d C),shutting down\n", + tz->temperature / 1000); + orderly_poweroff(true); + } +} + +static void handle_thermal_trip(struct thermal_zone_device *tz, int trip) +{ + enum thermal_trip_type type; + + 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); +} + +/** + * thermal_zone_get_temp() - returns its the temperature of thermal zone + * @tz: a valid pointer to a struct thermal_zone_device + * @temp: a valid pointer to where to store the resulting temperature. + * + * When a valid thermal zone reference is passed, it will fetch its + * temperature and fill @temp. + * + * Return: On success returns 0, an error code otherwise + */ +int thermal_zone_get_temp(struct thermal_zone_device *tz, unsigned long *temp) +{ + int ret = -EINVAL; +#ifdef CONFIG_THERMAL_EMULATION + int count; + unsigned long crit_temp = -1UL; + enum thermal_trip_type type; +#endif + + if (!tz || IS_ERR(tz) || !tz->ops->get_temp) + goto exit; + + mutex_lock(&tz->lock); + + ret = tz->ops->get_temp(tz, temp); +#ifdef CONFIG_THERMAL_EMULATION + if (!tz->emul_temperature) + goto skip_emul; + + for (count = 0; count < tz->trips; count++) { + ret = tz->ops->get_trip_type(tz, count, &type); + if (!ret && type == THERMAL_TRIP_CRITICAL) { + ret = tz->ops->get_trip_temp(tz, count, &crit_temp); + break; + } + } + + if (ret) + goto skip_emul; + + if (*temp < crit_temp) + *temp = tz->emul_temperature; +skip_emul: +#endif + mutex_unlock(&tz->lock); +exit: + return ret; +} +EXPORT_SYMBOL_GPL(thermal_zone_get_temp); + +static void update_temperature(struct thermal_zone_device *tz) +{ + long temp; + int ret; + + ret = thermal_zone_get_temp(tz, &temp); + if (ret) { + dev_warn(&tz->device, "failed to read out thermal zone %d\n", + tz->id); + return; + } + + mutex_lock(&tz->lock); + tz->last_temperature = tz->temperature; + tz->temperature = temp; + mutex_unlock(&tz->lock); + + dev_dbg(&tz->device, "last_temperature=%d, current_temperature=%d\n", + tz->last_temperature, tz->temperature); +} + +void thermal_zone_device_update(struct thermal_zone_device *tz) +{ + int count; + + if (!tz->ops->get_temp) + return; + + update_temperature(tz); + + for (count = 0; count < tz->trips; count++) + handle_thermal_trip(tz, count); +} +EXPORT_SYMBOL_GPL(thermal_zone_device_update); + +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); + thermal_zone_device_update(tz); +} + +/* sys I/F for thermal zone */ + +#define to_thermal_zone(_dev) \ + container_of(_dev, struct thermal_zone_device, device) + +static ssize_t +type_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + + return sprintf(buf, "%s\n", tz->type); +} + +static ssize_t +temp_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + long temperature; + int ret; + + ret = thermal_zone_get_temp(tz, &temperature); + + if (ret) + return ret; + + return sprintf(buf, "%ld\n", temperature); +} + +static ssize_t +mode_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + enum thermal_device_mode mode; + int result; + + if (!tz->ops->get_mode) + return -EPERM; + + result = tz->ops->get_mode(tz, &mode); + if (result) + return result; + + return sprintf(buf, "%s\n", mode == THERMAL_DEVICE_ENABLED ? "enabled" + : "disabled"); +} + +static ssize_t +mode_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + int result; + + if (!tz->ops->set_mode) + return -EPERM; + + if (!strncmp(buf, "enabled", sizeof("enabled") - 1)) + result = tz->ops->set_mode(tz, THERMAL_DEVICE_ENABLED); + else if (!strncmp(buf, "disabled", sizeof("disabled") - 1)) + result = tz->ops->set_mode(tz, THERMAL_DEVICE_DISABLED); + else + result = -EINVAL; + + if (result) + return result; + + return count; +} + +static ssize_t +trip_point_type_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + enum thermal_trip_type type; + int trip, result; + + if (!tz->ops->get_trip_type) + return -EPERM; + + if (!sscanf(attr->attr.name, "trip_point_%d_type", &trip)) + return -EINVAL; + + result = tz->ops->get_trip_type(tz, trip, &type); + if (result) + return result; + + switch (type) { + case THERMAL_TRIP_CRITICAL: + return sprintf(buf, "critical\n"); + case THERMAL_TRIP_HOT: + return sprintf(buf, "hot\n"); + case THERMAL_TRIP_PASSIVE: + return sprintf(buf, "passive\n"); + case THERMAL_TRIP_ACTIVE: + return sprintf(buf, "active\n"); + default: + return sprintf(buf, "unknown\n"); + } +} + +static ssize_t +trip_point_temp_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + int trip, ret; + unsigned long temperature; + + if (!tz->ops->set_trip_temp) + return -EPERM; + + if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip)) + return -EINVAL; + + if (kstrtoul(buf, 10, &temperature)) + return -EINVAL; + + ret = tz->ops->set_trip_temp(tz, trip, temperature); + + return ret ? ret : count; +} + +static ssize_t +trip_point_temp_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + int trip, ret; + long temperature; + + if (!tz->ops->get_trip_temp) + return -EPERM; + + if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip)) + return -EINVAL; + + ret = tz->ops->get_trip_temp(tz, trip, &temperature); + + if (ret) + return ret; + + return sprintf(buf, "%ld\n", temperature); +} + +static ssize_t +trip_point_hyst_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + int trip, ret; + unsigned long temperature; + + if (!tz->ops->set_trip_hyst) + return -EPERM; + + if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip)) + return -EINVAL; + + if (kstrtoul(buf, 10, &temperature)) + return -EINVAL; + + /* + * We are not doing any check on the 'temperature' value + * here. The driver implementing 'set_trip_hyst' has to + * take care of this. + */ + ret = tz->ops->set_trip_hyst(tz, trip, temperature); + + return ret ? ret : count; +} + +static ssize_t +trip_point_hyst_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + int trip, ret; + unsigned long temperature; + + if (!tz->ops->get_trip_hyst) + return -EPERM; + + if (!sscanf(attr->attr.name, "trip_point_%d_hyst", &trip)) + return -EINVAL; + + ret = tz->ops->get_trip_hyst(tz, trip, &temperature); + + return ret ? ret : sprintf(buf, "%ld\n", temperature); +} + +static ssize_t +passive_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + struct thermal_cooling_device *cdev = NULL; + int state; + + if (!sscanf(buf, "%d\n", &state)) + return -EINVAL; + + /* sanity check: values below 1000 millicelcius don't make sense + * and can cause the system to go into a thermal heart attack + */ + if (state && state < 1000) + return -EINVAL; + + if (state && !tz->forced_passive) { + mutex_lock(&thermal_list_lock); + list_for_each_entry(cdev, &thermal_cdev_list, node) { + if (!strncmp("Processor", cdev->type, + sizeof("Processor"))) + thermal_zone_bind_cooling_device(tz, + THERMAL_TRIPS_NONE, cdev, + THERMAL_NO_LIMIT, + THERMAL_NO_LIMIT); + } + mutex_unlock(&thermal_list_lock); + if (!tz->passive_delay) + tz->passive_delay = 1000; + } else if (!state && tz->forced_passive) { + mutex_lock(&thermal_list_lock); + list_for_each_entry(cdev, &thermal_cdev_list, node) { + if (!strncmp("Processor", cdev->type, + sizeof("Processor"))) + thermal_zone_unbind_cooling_device(tz, + THERMAL_TRIPS_NONE, + cdev); + } + mutex_unlock(&thermal_list_lock); + tz->passive_delay = 0; + } + + tz->forced_passive = state; + + thermal_zone_device_update(tz); + + return count; +} + +static ssize_t +passive_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + + return sprintf(buf, "%d\n", tz->forced_passive); +} + +static ssize_t +policy_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + int ret = -EINVAL; + struct thermal_zone_device *tz = to_thermal_zone(dev); + struct thermal_governor *gov; + + mutex_lock(&thermal_governor_lock); + + gov = __find_governor(buf); + if (!gov) + goto exit; + + tz->governor = gov; + ret = count; + +exit: + mutex_unlock(&thermal_governor_lock); + return ret; +} + +static ssize_t +policy_show(struct device *dev, struct device_attribute *devattr, char *buf) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + + return sprintf(buf, "%s\n", tz->governor->name); +} + +#ifdef CONFIG_THERMAL_EMULATION +static ssize_t +emul_temp_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_zone_device *tz = to_thermal_zone(dev); + int ret = 0; + unsigned long temperature; + + if (kstrtoul(buf, 10, &temperature)) + return -EINVAL; + + if (!tz->ops->set_emul_temp) { + mutex_lock(&tz->lock); + tz->emul_temperature = temperature; + mutex_unlock(&tz->lock); + } else { + ret = tz->ops->set_emul_temp(tz, temperature); + } + + if (!ret) + thermal_zone_device_update(tz); + + return ret ? ret : count; +} +static DEVICE_ATTR(emul_temp, S_IWUSR, NULL, emul_temp_store); +#endif/*CONFIG_THERMAL_EMULATION*/ + +static DEVICE_ATTR(type, 0444, type_show, NULL); +static DEVICE_ATTR(temp, 0444, temp_show, NULL); +static DEVICE_ATTR(mode, 0644, mode_show, mode_store); +static DEVICE_ATTR(passive, S_IRUGO | S_IWUSR, passive_show, passive_store); +static DEVICE_ATTR(policy, S_IRUGO | S_IWUSR, policy_show, policy_store); + +/* sys I/F for cooling device */ +#define to_cooling_device(_dev) \ + container_of(_dev, struct thermal_cooling_device, device) + +static ssize_t +thermal_cooling_device_type_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct thermal_cooling_device *cdev = to_cooling_device(dev); + + return sprintf(buf, "%s\n", cdev->type); +} + +static ssize_t +thermal_cooling_device_max_state_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct thermal_cooling_device *cdev = to_cooling_device(dev); + unsigned long state; + int ret; + + ret = cdev->ops->get_max_state(cdev, &state); + if (ret) + return ret; + return sprintf(buf, "%ld\n", state); +} + +static ssize_t +thermal_cooling_device_cur_state_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct thermal_cooling_device *cdev = to_cooling_device(dev); + unsigned long state; + int ret; + + ret = cdev->ops->get_cur_state(cdev, &state); + if (ret) + return ret; + return sprintf(buf, "%ld\n", state); +} + +static ssize_t +thermal_cooling_device_cur_state_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct thermal_cooling_device *cdev = to_cooling_device(dev); + unsigned long state; + int result; + + if (!sscanf(buf, "%ld\n", &state)) + return -EINVAL; + + if ((long)state < 0) + return -EINVAL; + + result = cdev->ops->set_cur_state(cdev, state); + if (result) + return result; + return count; +} + +static struct device_attribute dev_attr_cdev_type = +__ATTR(type, 0444, thermal_cooling_device_type_show, NULL); +static DEVICE_ATTR(max_state, 0444, + thermal_cooling_device_max_state_show, NULL); +static DEVICE_ATTR(cur_state, 0644, + thermal_cooling_device_cur_state_show, + thermal_cooling_device_cur_state_store); + +static ssize_t +thermal_cooling_device_trip_point_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct thermal_instance *instance; + + instance = + container_of(attr, struct thermal_instance, attr); + + if (instance->trip == THERMAL_TRIPS_NONE) + return sprintf(buf, "-1\n"); + else + return sprintf(buf, "%d\n", instance->trip); +} + +/* Device management */ + +/** + * thermal_zone_bind_cooling_device() - bind a cooling device to a thermal zone + * @tz: pointer to struct thermal_zone_device + * @trip: indicates which trip point the cooling devices is + * associated with in this thermal zone. + * @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. + * + * This interface function bind a thermal cooling device to the certain trip + * point of a thermal zone device. + * This function is usually called in the thermal zone device .bind callback. + * + * Return: 0 on success, the proper error value otherwise. + */ +int thermal_zone_bind_cooling_device(struct thermal_zone_device *tz, + int trip, + struct thermal_cooling_device *cdev, + unsigned long upper, unsigned long lower) +{ + 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)) + return -EINVAL; + + 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) + 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_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; + + sprintf(dev->name, "cdev%d", dev->id); + result = + sysfs_create_link(&tz->device.kobj, &cdev->device.kobj, dev->name); + if (result) + goto release_idr; + + sprintf(dev->attr_name, "cdev%d_trip_point", dev->id); + sysfs_attr_init(&dev->attr.attr); + dev->attr.attr.name = dev->attr_name; + dev->attr.attr.mode = 0444; + dev->attr.show = thermal_cooling_device_trip_point_show; + result = device_create_file(&tz->device, &dev->attr); + if (result) + goto remove_symbol_link; + + mutex_lock(&tz->lock); + 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->tz_node, &tz->thermal_instances); + list_add_tail(&dev->cdev_node, &cdev->thermal_instances); + } + mutex_unlock(&cdev->lock); + mutex_unlock(&tz->lock); + + if (!result) + return 0; + + device_remove_file(&tz->device, &dev->attr); +remove_symbol_link: + sysfs_remove_link(&tz->device.kobj, dev->name); +release_idr: + release_idr(&tz->idr, &tz->lock, dev->id); +free_mem: + kfree(dev); + return result; +} +EXPORT_SYMBOL_GPL(thermal_zone_bind_cooling_device); + +/** + * thermal_zone_unbind_cooling_device() - unbind a cooling device from a + * thermal zone. + * @tz: pointer to a struct thermal_zone_device. + * @trip: indicates which trip point the cooling devices is + * associated with in this thermal zone. + * @cdev: pointer to a struct thermal_cooling_device. + * + * This interface function unbind a thermal cooling device from the certain + * trip point of a thermal zone device. + * This function is usually called in the thermal zone device .unbind callback. + * + * Return: 0 on success, the proper error value otherwise. + */ +int thermal_zone_unbind_cooling_device(struct thermal_zone_device *tz, + int trip, + struct thermal_cooling_device *cdev) +{ + struct thermal_instance *pos, *next; + + mutex_lock(&tz->lock); + 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->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; + +unbind: + device_remove_file(&tz->device, &pos->attr); + sysfs_remove_link(&tz->device.kobj, pos->name); + release_idr(&tz->idr, &tz->lock, pos->id); + kfree(pos); + return 0; +} +EXPORT_SYMBOL_GPL(thermal_zone_unbind_cooling_device); + +static void thermal_release(struct device *dev) +{ + struct thermal_zone_device *tz; + struct thermal_cooling_device *cdev; + + if (!strncmp(dev_name(dev), "thermal_zone", + sizeof("thermal_zone") - 1)) { + tz = to_thermal_zone(dev); + kfree(tz); + } else { + cdev = to_cooling_device(dev); + kfree(cdev); + } +} + +static struct class thermal_class = { + .name = "thermal", + .dev_release = thermal_release, +}; + +/** + * __thermal_cooling_device_register() - register a new 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 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. + * 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. + * + * Return: a pointer to the created struct thermal_cooling_device or an + * ERR_PTR. Caller must check return value with IS_ERR*() helpers. + */ +static struct thermal_cooling_device * +__thermal_cooling_device_register(struct device_node *np, + char *type, void *devdata, + const struct thermal_cooling_device_ops *ops) +{ + struct thermal_cooling_device *cdev; + int result; + + if (type && strlen(type) >= THERMAL_NAME_LENGTH) + return ERR_PTR(-EINVAL); + + if (!ops || !ops->get_max_state || !ops->get_cur_state || + !ops->set_cur_state) + return ERR_PTR(-EINVAL); + + cdev = kzalloc(sizeof(struct thermal_cooling_device), GFP_KERNEL); + if (!cdev) + return ERR_PTR(-ENOMEM); + + result = get_idr(&thermal_cdev_idr, &thermal_idr_lock, &cdev->id); + if (result) { + kfree(cdev); + return ERR_PTR(result); + } + + strlcpy(cdev->type, type ? : "", sizeof(cdev->type)); + mutex_init(&cdev->lock); + INIT_LIST_HEAD(&cdev->thermal_instances); + cdev->np = np; + cdev->ops = ops; + cdev->updated = false; + cdev->device.class = &thermal_class; + cdev->devdata = devdata; + dev_set_name(&cdev->device, "cooling_device%d", cdev->id); + result = device_register(&cdev->device); + if (result) { + release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id); + kfree(cdev); + return ERR_PTR(result); + } + + /* sys I/F */ + if (type) { + result = device_create_file(&cdev->device, &dev_attr_cdev_type); + if (result) + goto unregister; + } + + result = device_create_file(&cdev->device, &dev_attr_max_state); + if (result) + goto unregister; + + result = device_create_file(&cdev->device, &dev_attr_cur_state); + if (result) + goto unregister; + + /* Add 'this' new cdev to the global cdev list */ + mutex_lock(&thermal_list_lock); + list_add(&cdev->node, &thermal_cdev_list); + mutex_unlock(&thermal_list_lock); + + /* Update binding information for 'this' new cdev */ + bind_cdev(cdev); + + return cdev; + +unregister: + release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id); + device_unregister(&cdev->device); + return ERR_PTR(result); +} + +/** + * 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); +} +EXPORT_SYMBOL_GPL(thermal_cooling_device_register); + +/** + * 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); + +/** + * thermal_cooling_device_unregister - removes the registered thermal cooling device + * @cdev: the thermal cooling device to remove. + * + * thermal_cooling_device_unregister() must be called when the device is no + * longer needed. + */ +void thermal_cooling_device_unregister(struct thermal_cooling_device *cdev) +{ + int i; + const struct thermal_zone_params *tzp; + 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) + if (pos == cdev) + break; + if (pos != cdev) { + /* thermal cooling device not found */ + mutex_unlock(&thermal_list_lock); + return; + } + list_del(&cdev->node); + + /* Unbind all thermal zones associated with 'this' cdev */ + list_for_each_entry(tz, &thermal_tz_list, node) { + if (tz->ops->unbind) { + tz->ops->unbind(tz, cdev); + continue; + } + + if (!tz->tzp || !tz->tzp->tbp) + continue; + + 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; + } + } + } + + mutex_unlock(&thermal_list_lock); + + if (cdev->type[0]) + device_remove_file(&cdev->device, &dev_attr_cdev_type); + device_remove_file(&cdev->device, &dev_attr_max_state); + device_remove_file(&cdev->device, &dev_attr_cur_state); + + release_idr(&thermal_cdev_idr, &thermal_idr_lock, cdev->id); + device_unregister(&cdev->device); + return; +} +EXPORT_SYMBOL_GPL(thermal_cooling_device_unregister); + +void thermal_cdev_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) { + dev_dbg(&cdev->device, "zone%d->target=%lu\n", + instance->tz->id, instance->target); + 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; + dev_dbg(&cdev->device, "set to state %lu\n", target); +} +EXPORT_SYMBOL(thermal_cdev_update); + +/** + * 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); + +/** + * create_trip_attrs() - create attributes for trip points + * @tz: the thermal zone device + * @mask: Writeable trip point bitmap. + * + * helper function to instantiate sysfs entries for every trip + * point and its properties of a struct thermal_zone_device. + * + * Return: 0 on success, the proper error value otherwise. + */ +static int create_trip_attrs(struct thermal_zone_device *tz, int mask) +{ + int indx; + int size = sizeof(struct thermal_attr) * tz->trips; + + tz->trip_type_attrs = kzalloc(size, GFP_KERNEL); + if (!tz->trip_type_attrs) + return -ENOMEM; + + tz->trip_temp_attrs = kzalloc(size, GFP_KERNEL); + if (!tz->trip_temp_attrs) { + kfree(tz->trip_type_attrs); + return -ENOMEM; + } + + if (tz->ops->get_trip_hyst) { + tz->trip_hyst_attrs = kzalloc(size, GFP_KERNEL); + if (!tz->trip_hyst_attrs) { + kfree(tz->trip_type_attrs); + kfree(tz->trip_temp_attrs); + return -ENOMEM; + } + } + + + for (indx = 0; indx < tz->trips; indx++) { + /* create trip type attribute */ + snprintf(tz->trip_type_attrs[indx].name, THERMAL_NAME_LENGTH, + "trip_point_%d_type", indx); + + sysfs_attr_init(&tz->trip_type_attrs[indx].attr.attr); + tz->trip_type_attrs[indx].attr.attr.name = + tz->trip_type_attrs[indx].name; + tz->trip_type_attrs[indx].attr.attr.mode = S_IRUGO; + tz->trip_type_attrs[indx].attr.show = trip_point_type_show; + + device_create_file(&tz->device, + &tz->trip_type_attrs[indx].attr); + + /* create trip temp attribute */ + snprintf(tz->trip_temp_attrs[indx].name, THERMAL_NAME_LENGTH, + "trip_point_%d_temp", indx); + + sysfs_attr_init(&tz->trip_temp_attrs[indx].attr.attr); + tz->trip_temp_attrs[indx].attr.attr.name = + tz->trip_temp_attrs[indx].name; + tz->trip_temp_attrs[indx].attr.attr.mode = S_IRUGO; + tz->trip_temp_attrs[indx].attr.show = trip_point_temp_show; + if (mask & (1 << indx)) { + tz->trip_temp_attrs[indx].attr.attr.mode |= S_IWUSR; + tz->trip_temp_attrs[indx].attr.store = + trip_point_temp_store; + } + + device_create_file(&tz->device, + &tz->trip_temp_attrs[indx].attr); + + /* create Optional trip hyst attribute */ + if (!tz->ops->get_trip_hyst) + continue; + snprintf(tz->trip_hyst_attrs[indx].name, THERMAL_NAME_LENGTH, + "trip_point_%d_hyst", indx); + + sysfs_attr_init(&tz->trip_hyst_attrs[indx].attr.attr); + tz->trip_hyst_attrs[indx].attr.attr.name = + tz->trip_hyst_attrs[indx].name; + tz->trip_hyst_attrs[indx].attr.attr.mode = S_IRUGO; + tz->trip_hyst_attrs[indx].attr.show = trip_point_hyst_show; + if (tz->ops->set_trip_hyst) { + tz->trip_hyst_attrs[indx].attr.attr.mode |= S_IWUSR; + tz->trip_hyst_attrs[indx].attr.store = + trip_point_hyst_store; + } + + device_create_file(&tz->device, + &tz->trip_hyst_attrs[indx].attr); + } + return 0; +} + +static void remove_trip_attrs(struct thermal_zone_device *tz) +{ + int indx; + + for (indx = 0; indx < tz->trips; indx++) { + device_remove_file(&tz->device, + &tz->trip_type_attrs[indx].attr); + device_remove_file(&tz->device, + &tz->trip_temp_attrs[indx].attr); + if (tz->ops->get_trip_hyst) + device_remove_file(&tz->device, + &tz->trip_hyst_attrs[indx].attr); + } + kfree(tz->trip_type_attrs); + kfree(tz->trip_temp_attrs); + kfree(tz->trip_hyst_attrs); +} + +/** + * thermal_zone_device_register() - register a new thermal zone device + * @type: the thermal zone device type + * @trips: the number of trip points the thermal zone support + * @mask: a bit string indicating the writeablility of trip points + * @devdata: private device data + * @ops: standard thermal zone device callbacks + * @tzp: thermal zone platform parameters + * @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) + * + * 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. + * thermal_zone_device_unregister() must be called when the device is no + * longer needed. The passive cooling depends on the .get_trend() return value. + * + * 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. + */ +struct thermal_zone_device *thermal_zone_device_register(const char *type, + int trips, int mask, void *devdata, + struct thermal_zone_device_ops *ops, + const struct thermal_zone_params *tzp, + int passive_delay, int polling_delay) +{ + struct thermal_zone_device *tz; + enum thermal_trip_type trip_type; + int result; + int count; + int passive = 0; + + if (type && strlen(type) >= THERMAL_NAME_LENGTH) + return ERR_PTR(-EINVAL); + + if (trips > THERMAL_MAX_TRIPS || trips < 0 || mask >> trips) + return ERR_PTR(-EINVAL); + + if (!ops) + return ERR_PTR(-EINVAL); + + if (trips > 0 && !ops->get_trip_type) + return ERR_PTR(-EINVAL); + + tz = kzalloc(sizeof(struct thermal_zone_device), GFP_KERNEL); + if (!tz) + return ERR_PTR(-ENOMEM); + + 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); + if (result) { + kfree(tz); + return ERR_PTR(result); + } + + strlcpy(tz->type, type ? : "", sizeof(tz->type)); + tz->ops = ops; + tz->tzp = tzp; + tz->device.class = &thermal_class; + tz->devdata = devdata; + tz->trips = trips; + tz->passive_delay = passive_delay; + tz->polling_delay = polling_delay; + + dev_set_name(&tz->device, "thermal_zone%d", tz->id); + result = device_register(&tz->device); + if (result) { + release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); + kfree(tz); + return ERR_PTR(result); + } + + /* sys I/F */ + if (type) { + result = device_create_file(&tz->device, &dev_attr_type); + if (result) + goto unregister; + } + + result = device_create_file(&tz->device, &dev_attr_temp); + if (result) + goto unregister; + + if (ops->get_mode) { + result = device_create_file(&tz->device, &dev_attr_mode); + if (result) + goto unregister; + } + + result = create_trip_attrs(tz, mask); + if (result) + goto unregister; + + for (count = 0; count < trips; count++) { + tz->ops->get_trip_type(tz, count, &trip_type); + if (trip_type == THERMAL_TRIP_PASSIVE) + passive = 1; + } + + if (!passive) { + result = device_create_file(&tz->device, &dev_attr_passive); + if (result) + goto unregister; + } + +#ifdef CONFIG_THERMAL_EMULATION + result = device_create_file(&tz->device, &dev_attr_emul_temp); + if (result) + goto unregister; +#endif + /* Create policy attribute */ + result = device_create_file(&tz->device, &dev_attr_policy); + if (result) + goto unregister; + + /* Update 'this' zone's governor information */ + mutex_lock(&thermal_governor_lock); + + if (tz->tzp) + tz->governor = __find_governor(tz->tzp->governor_name); + else + tz->governor = def_governor; + + mutex_unlock(&thermal_governor_lock); + + if (!tz->tzp || !tz->tzp->no_hwmon) { + result = thermal_add_hwmon_sysfs(tz); + if (result) + goto unregister; + } + + mutex_lock(&thermal_list_lock); + list_add_tail(&tz->node, &thermal_tz_list); + mutex_unlock(&thermal_list_lock); + + /* Bind cooling devices for this zone */ + bind_tz(tz); + + INIT_DELAYED_WORK(&(tz->poll_queue), thermal_zone_device_check); + + if (!tz->ops->get_temp) + thermal_zone_device_set_polling(tz, 0); + + thermal_zone_device_update(tz); + + if (!result) + return tz; + +unregister: + release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); + device_unregister(&tz->device); + return ERR_PTR(result); +} +EXPORT_SYMBOL_GPL(thermal_zone_device_register); + +/** + * 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) +{ + int i; + const struct thermal_zone_params *tzp; + struct thermal_cooling_device *cdev; + struct thermal_zone_device *pos = NULL; + + if (!tz) + return; + + tzp = tz->tzp; + + mutex_lock(&thermal_list_lock); + list_for_each_entry(pos, &thermal_tz_list, node) + if (pos == tz) + break; + if (pos != tz) { + /* thermal zone device not found */ + mutex_unlock(&thermal_list_lock); + return; + } + list_del(&tz->node); + + /* 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; + } + } + } + + mutex_unlock(&thermal_list_lock); + + thermal_zone_device_set_polling(tz, 0); + + if (tz->type[0]) + device_remove_file(&tz->device, &dev_attr_type); + device_remove_file(&tz->device, &dev_attr_temp); + if (tz->ops->get_mode) + device_remove_file(&tz->device, &dev_attr_mode); + device_remove_file(&tz->device, &dev_attr_policy); + remove_trip_attrs(tz); + tz->governor = NULL; + + thermal_remove_hwmon_sysfs(tz); + release_idr(&thermal_tz_idr, &thermal_idr_lock, tz->id); + idr_destroy(&tz->idr); + mutex_destroy(&tz->lock); + device_unregister(&tz->device); + return; +} +EXPORT_SYMBOL_GPL(thermal_zone_device_unregister); + +/** + * 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) + if (!strnicmp(name, pos->type, THERMAL_NAME_LENGTH)) { + 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); + +#ifdef CONFIG_NET +static struct genl_family thermal_event_genl_family = { + .id = GENL_ID_GENERATE, + .name = THERMAL_GENL_FAMILY_NAME, + .version = THERMAL_GENL_VERSION, + .maxattr = THERMAL_GENL_ATTR_MAX, +}; + +static struct genl_multicast_group thermal_event_mcgrp = { + .name = THERMAL_GENL_MCAST_GROUP_NAME, +}; + +int thermal_generate_netlink_event(struct thermal_zone_device *tz, + enum events event) +{ + struct sk_buff *skb; + struct nlattr *attr; + struct thermal_genl_event *thermal_event; + void *msg_header; + int size; + int result; + static unsigned int thermal_event_seqnum; + + if (!tz) + return -EINVAL; + + /* allocate memory */ + size = nla_total_size(sizeof(struct thermal_genl_event)) + + nla_total_size(0); + + 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 */ + attr = nla_reserve(skb, THERMAL_GENL_ATTR_EVENT, + sizeof(struct thermal_genl_event)); + + 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)); + + thermal_event->orig = tz->id; + thermal_event->event = event; + + /* send multicast genetlink message */ + result = genlmsg_end(skb, msg_header); + if (result < 0) { + nlmsg_free(skb); + return result; + } + + result = genlmsg_multicast(skb, 0, thermal_event_mcgrp.id, GFP_ATOMIC); + if (result) + dev_err(&tz->device, "Failed to send netlink event:%d", result); + + return result; +} +EXPORT_SYMBOL_GPL(thermal_generate_netlink_event); + +static int genetlink_init(void) +{ + int result; + + result = genl_register_family(&thermal_event_genl_family); + if (result) + return result; + + result = genl_register_mc_group(&thermal_event_genl_family, + &thermal_event_mcgrp); + if (result) + genl_unregister_family(&thermal_event_genl_family); + return result; +} + +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 */ + +static int __init thermal_register_governors(void) +{ + int result; + + result = thermal_gov_step_wise_register(); + if (result) + return result; + + result = thermal_gov_fair_share_register(); + if (result) + return result; + + return thermal_gov_user_space_register(); +} + +static void thermal_unregister_governors(void) +{ + thermal_gov_step_wise_unregister(); + thermal_gov_fair_share_unregister(); + thermal_gov_user_space_unregister(); +} + +static int __init thermal_init(void) +{ + int result; + + result = thermal_register_governors(); + if (result) + goto error; + + result = class_register(&thermal_class); + if (result) + goto unregister_governors; + + result = genetlink_init(); + if (result) + goto unregister_class; + + result = of_parse_thermal_zones(); + if (result) + goto exit_netlink; + + return 0; + +exit_netlink: + genetlink_exit(); +unregister_governors: + thermal_unregister_governors(); +unregister_class: + class_unregister(&thermal_class); +error: + idr_destroy(&thermal_tz_idr); + idr_destroy(&thermal_cdev_idr); + mutex_destroy(&thermal_idr_lock); + mutex_destroy(&thermal_list_lock); + mutex_destroy(&thermal_governor_lock); + return result; +} + +static void __exit thermal_exit(void) +{ + of_thermal_destroy_zones(); + genetlink_exit(); + class_unregister(&thermal_class); + thermal_unregister_governors(); + idr_destroy(&thermal_tz_idr); + idr_destroy(&thermal_cdev_idr); + mutex_destroy(&thermal_idr_lock); + mutex_destroy(&thermal_list_lock); + mutex_destroy(&thermal_governor_lock); +} + +fs_initcall(thermal_init); +module_exit(thermal_exit); diff --git a/drivers/thermal/thermal_core.h b/drivers/thermal/thermal_core.h new file mode 100644 index 00000000..6bd504e2 --- /dev/null +++ b/drivers/thermal/thermal_core.h @@ -0,0 +1,90 @@ +/* + * thermal_core.h + * + * Copyright (C) 2012 Intel Corp + * Author: Durgadoss R <durgadoss.r@intel.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. + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ + +#ifndef __THERMAL_CORE_H__ +#define __THERMAL_CORE_H__ + +#include <linux/device.h> +#include <linux/thermal.h> + +/* Initial state of a cooling device during binding */ +#define THERMAL_NO_TARGET -1UL + +#define TRIP_TEMP_OFFSET 2 +/* + * 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 tz_node; /* node in tz->thermal_instances */ + struct list_head cdev_node; /* node in cdev->thermal_instances */ +}; + +int thermal_register_governor(struct thermal_governor *); +void thermal_unregister_governor(struct thermal_governor *); + +#ifdef CONFIG_THERMAL_GOV_STEP_WISE +int thermal_gov_step_wise_register(void); +void thermal_gov_step_wise_unregister(void); +#else +static inline int thermal_gov_step_wise_register(void) { return 0; } +static inline void thermal_gov_step_wise_unregister(void) {} +#endif /* CONFIG_THERMAL_GOV_STEP_WISE */ + +#ifdef CONFIG_THERMAL_GOV_FAIR_SHARE +int thermal_gov_fair_share_register(void); +void thermal_gov_fair_share_unregister(void); +#else +static inline int thermal_gov_fair_share_register(void) { return 0; } +static inline void thermal_gov_fair_share_unregister(void) {} +#endif /* CONFIG_THERMAL_GOV_FAIR_SHARE */ + +#ifdef CONFIG_THERMAL_GOV_USER_SPACE +int thermal_gov_user_space_register(void); +void thermal_gov_user_space_unregister(void); +#else +static inline int thermal_gov_user_space_register(void) { return 0; } +static inline void thermal_gov_user_space_unregister(void) {} +#endif /* CONFIG_THERMAL_GOV_USER_SPACE */ + +/* device tree support */ +#ifdef CONFIG_THERMAL_OF +int of_parse_thermal_zones(void); +void of_thermal_destroy_zones(void); +#else +static inline int of_parse_thermal_zones(void) { return 0; } +static inline void of_thermal_destroy_zones(void) { } +#endif + +#endif /* __THERMAL_CORE_H__ */ diff --git a/drivers/thermal/thermal_hwmon.c b/drivers/thermal/thermal_hwmon.c new file mode 100644 index 00000000..fdb07199 --- /dev/null +++ b/drivers/thermal/thermal_hwmon.c @@ -0,0 +1,269 @@ +/* + * thermal_hwmon.c - Generic Thermal Management hwmon support. + * + * Code based on Intel thermal_core.c. Copyrights of the original code: + * Copyright (C) 2008 Intel Corp + * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com> + * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com> + * + * Copyright (C) 2013 Texas Instruments + * Copyright (C) 2013 Eduardo Valentin <eduardo.valentin@ti.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/hwmon.h> +#include <linux/thermal.h> +#include <linux/slab.h> +#include <linux/err.h> +#include "thermal_hwmon.h" + +/* hwmon sys I/F */ +/* thermal zone devices with the same type share one hwmon device */ +struct thermal_hwmon_device { + char type[THERMAL_NAME_LENGTH]; + struct device *device; + int count; + struct list_head tz_list; + struct list_head node; +}; + +struct thermal_hwmon_attr { + struct device_attribute attr; + char name[16]; +}; + +/* one temperature input for each thermal zone */ +struct thermal_hwmon_temp { + struct list_head hwmon_node; + struct thermal_zone_device *tz; + struct thermal_hwmon_attr temp_input; /* hwmon sys attr */ + struct thermal_hwmon_attr temp_crit; /* hwmon sys attr */ +}; + +static LIST_HEAD(thermal_hwmon_list); + +static DEFINE_MUTEX(thermal_hwmon_list_lock); + +static ssize_t +name_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct thermal_hwmon_device *hwmon = dev_get_drvdata(dev); + return sprintf(buf, "%s\n", hwmon->type); +} +static DEVICE_ATTR(name, 0444, name_show, NULL); + +static ssize_t +temp_input_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + long temperature; + int ret; + struct thermal_hwmon_attr *hwmon_attr + = container_of(attr, struct thermal_hwmon_attr, attr); + struct thermal_hwmon_temp *temp + = container_of(hwmon_attr, struct thermal_hwmon_temp, + temp_input); + struct thermal_zone_device *tz = temp->tz; + + ret = thermal_zone_get_temp(tz, &temperature); + + if (ret) + return ret; + + return sprintf(buf, "%ld\n", temperature); +} + +static ssize_t +temp_crit_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct thermal_hwmon_attr *hwmon_attr + = container_of(attr, struct thermal_hwmon_attr, attr); + struct thermal_hwmon_temp *temp + = container_of(hwmon_attr, struct thermal_hwmon_temp, + temp_crit); + struct thermal_zone_device *tz = temp->tz; + long temperature; + int ret; + + ret = tz->ops->get_trip_temp(tz, 0, &temperature); + if (ret) + return ret; + + return sprintf(buf, "%ld\n", temperature); +} + + +static struct thermal_hwmon_device * +thermal_hwmon_lookup_by_type(const struct thermal_zone_device *tz) +{ + struct thermal_hwmon_device *hwmon; + + mutex_lock(&thermal_hwmon_list_lock); + list_for_each_entry(hwmon, &thermal_hwmon_list, node) + if (!strcmp(hwmon->type, tz->type)) { + mutex_unlock(&thermal_hwmon_list_lock); + return hwmon; + } + mutex_unlock(&thermal_hwmon_list_lock); + + return NULL; +} + +/* Find the temperature input matching a given thermal zone */ +static struct thermal_hwmon_temp * +thermal_hwmon_lookup_temp(const struct thermal_hwmon_device *hwmon, + const struct thermal_zone_device *tz) +{ + struct thermal_hwmon_temp *temp; + + mutex_lock(&thermal_hwmon_list_lock); + list_for_each_entry(temp, &hwmon->tz_list, hwmon_node) + if (temp->tz == tz) { + mutex_unlock(&thermal_hwmon_list_lock); + return temp; + } + mutex_unlock(&thermal_hwmon_list_lock); + + return NULL; +} + +int thermal_add_hwmon_sysfs(struct thermal_zone_device *tz) +{ + struct thermal_hwmon_device *hwmon; + struct thermal_hwmon_temp *temp; + int new_hwmon_device = 1; + int result; + + hwmon = thermal_hwmon_lookup_by_type(tz); + if (hwmon) { + new_hwmon_device = 0; + goto register_sys_interface; + } + + hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL); + if (!hwmon) + return -ENOMEM; + + INIT_LIST_HEAD(&hwmon->tz_list); + strlcpy(hwmon->type, tz->type, THERMAL_NAME_LENGTH); + hwmon->device = hwmon_device_register(NULL); + if (IS_ERR(hwmon->device)) { + result = PTR_ERR(hwmon->device); + goto free_mem; + } + dev_set_drvdata(hwmon->device, hwmon); + result = device_create_file(hwmon->device, &dev_attr_name); + if (result) + goto free_mem; + + register_sys_interface: + temp = kzalloc(sizeof(*temp), GFP_KERNEL); + if (!temp) { + result = -ENOMEM; + goto unregister_name; + } + + temp->tz = tz; + hwmon->count++; + + 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; + temp->temp_input.attr.show = temp_input_show; + sysfs_attr_init(&temp->temp_input.attr.attr); + result = device_create_file(hwmon->device, &temp->temp_input.attr); + if (result) + goto free_temp_mem; + + if (tz->ops->get_crit_temp) { + unsigned long temperature; + if (!tz->ops->get_crit_temp(tz, &temperature)) { + 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; + temp->temp_crit.attr.show = temp_crit_show; + sysfs_attr_init(&temp->temp_crit.attr.attr); + result = device_create_file(hwmon->device, + &temp->temp_crit.attr); + if (result) + goto unregister_input; + } + } + + mutex_lock(&thermal_hwmon_list_lock); + if (new_hwmon_device) + list_add_tail(&hwmon->node, &thermal_hwmon_list); + list_add_tail(&temp->hwmon_node, &hwmon->tz_list); + mutex_unlock(&thermal_hwmon_list_lock); + + return 0; + + unregister_input: + device_remove_file(hwmon->device, &temp->temp_input.attr); + free_temp_mem: + kfree(temp); + unregister_name: + if (new_hwmon_device) { + device_remove_file(hwmon->device, &dev_attr_name); + hwmon_device_unregister(hwmon->device); + } + free_mem: + if (new_hwmon_device) + kfree(hwmon); + + return result; +} + +void thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz) +{ + struct thermal_hwmon_device *hwmon; + struct thermal_hwmon_temp *temp; + + hwmon = thermal_hwmon_lookup_by_type(tz); + if (unlikely(!hwmon)) { + /* Should never happen... */ + dev_dbg(&tz->device, "hwmon device lookup failed!\n"); + return; + } + + temp = thermal_hwmon_lookup_temp(hwmon, tz); + if (unlikely(!temp)) { + /* Should never happen... */ + dev_dbg(&tz->device, "temperature input lookup failed!\n"); + return; + } + + device_remove_file(hwmon->device, &temp->temp_input.attr); + if (tz->ops->get_crit_temp) + device_remove_file(hwmon->device, &temp->temp_crit.attr); + + mutex_lock(&thermal_hwmon_list_lock); + list_del(&temp->hwmon_node); + kfree(temp); + if (!list_empty(&hwmon->tz_list)) { + mutex_unlock(&thermal_hwmon_list_lock); + return; + } + list_del(&hwmon->node); + mutex_unlock(&thermal_hwmon_list_lock); + + device_remove_file(hwmon->device, &dev_attr_name); + hwmon_device_unregister(hwmon->device); + kfree(hwmon); +} diff --git a/drivers/thermal/thermal_hwmon.h b/drivers/thermal/thermal_hwmon.h new file mode 100644 index 00000000..c798fdb2 --- /dev/null +++ b/drivers/thermal/thermal_hwmon.h @@ -0,0 +1,49 @@ +/* + * thermal_hwmon.h - Generic Thermal Management hwmon support. + * + * Code based on Intel thermal_core.c. Copyrights of the original code: + * Copyright (C) 2008 Intel Corp + * Copyright (C) 2008 Zhang Rui <rui.zhang@intel.com> + * Copyright (C) 2008 Sujith Thomas <sujith.thomas@intel.com> + * + * Copyright (C) 2013 Texas Instruments + * Copyright (C) 2013 Eduardo Valentin <eduardo.valentin@ti.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. + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ +#ifndef __THERMAL_HWMON_H__ +#define __THERMAL_HWMON_H__ + +#include <linux/thermal.h> + +#ifdef CONFIG_THERMAL_HWMON +int thermal_add_hwmon_sysfs(struct thermal_zone_device *tz); +void thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz); +#else +static int +thermal_add_hwmon_sysfs(struct thermal_zone_device *tz) +{ + return 0; +} + +static void +thermal_remove_hwmon_sysfs(struct thermal_zone_device *tz) +{ +} +#endif + +#endif /* __THERMAL_HWMON_H__ */ diff --git a/drivers/thermal/thm.h b/drivers/thermal/thm.h new file mode 100644 index 00000000..1f212247 --- /dev/null +++ b/drivers/thermal/thm.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2013 Spreadtrum Communications Inc. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + * + ************************************************ + * Automatically generated C config: don't edit * + ************************************************ + */ + +#ifndef __CTL_THM_H__ +#define __CTL_THM_H__ +#include <linux/types.h> +#include <linux/sprd_thm.h> +#include <linux/interrupt.h> +#define THM_TEST +struct sprd_thermal_zone { + struct thermal_zone_device *therm_dev; + struct mutex th_lock; + struct work_struct therm_work; + struct delayed_work resume_delay_work; + struct delayed_work thm_read_work; + struct sprd_thm_platform_data *trip_tab; + struct sprd_board_sensor_config *sensor_config; + struct thm_handle_ops *ops; + struct delayed_work thm_logtime_work; + enum thermal_device_mode mode; + int sensor_id; + int thm_cal; + int off_set; + int temp_inteval; + int logtime; + int thmlog_switch; + struct regmap * thm_glb; + struct spi_device *spi_dev; + unsigned long reg_base; + unsigned long cur_temp; + unsigned long last_temp; + int current_trip_num; + int sen_cal_offset; + char thermal_zone_name[30]; + enum thermal_trend trend_val; +}; + +enum thermal_log_switch{ + THERMAL_LOG_DISABLED = 0, + THERMAL_LOG_ENABLED, +}; +struct thm_handle_ops{ + int (*hw_init)(struct sprd_thermal_zone*); + int (*get_reg_base)(struct sprd_thermal_zone*,struct resource *regs); + unsigned long (*read_temp)(struct sprd_thermal_zone*); + int (*get_trend)(struct sprd_thermal_zone*,int, enum thermal_trend *); + int (*get_hyst)(struct sprd_thermal_zone*,int,unsigned long *); + int (*irq_handle)(struct sprd_thermal_zone*); + int (*suspend)(struct sprd_thermal_zone*); + int (*resume)(struct sprd_thermal_zone*); + int (*reg_debug_set)(struct sprd_thermal_zone*, unsigned int*); + int (*reg_debug_get)(struct sprd_thermal_zone*, unsigned int*); + int (*trip_debug_set)(struct sprd_thermal_zone*,int ); +}; +extern int sprd_thm_add(struct thm_handle_ops* ops, char *p,int id); +extern void sprd_thm_delete(int id); +extern int sci_efuse_thermal_cal_get(int *cal); +extern int sci_efuse_arm_thm_cal_get(int *cal,int *offset); +extern int sci_efuse_bcore_thm_cal_get(int *cal,int *offset); +extern int sprd_boardthm_add(struct thm_handle_ops* ops, char *p,int id); +extern void sprd_boardthm_delete(int id); +#endif diff --git a/drivers/thermal/user_space.c b/drivers/thermal/user_space.c new file mode 100644 index 00000000..10adcddc --- /dev/null +++ b/drivers/thermal/user_space.c @@ -0,0 +1,57 @@ +/* + * user_space.c - A simple user space Thermal events notifier + * + * Copyright (C) 2012 Intel Corp + * Copyright (C) 2012 Durgadoss R <durgadoss.r@intel.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/thermal.h> + +#include "thermal_core.h" + +/** + * notify_user_space - Notifies user space about thermal events + * @tz - thermal_zone_device + * + * This function notifies the user space through UEvents. + */ +static int notify_user_space(struct thermal_zone_device *tz, int trip) +{ + mutex_lock(&tz->lock); + kobject_uevent(&tz->device.kobj, KOBJ_CHANGE); + mutex_unlock(&tz->lock); + return 0; +} + +static struct thermal_governor thermal_gov_user_space = { + .name = "user_space", + .throttle = notify_user_space, +}; + +int thermal_gov_user_space_register(void) +{ + return thermal_register_governor(&thermal_gov_user_space); +} + +void thermal_gov_user_space_unregister(void) +{ + thermal_unregister_governor(&thermal_gov_user_space); +} + |