1 files changed, 544 insertions, 0 deletions

diff --git a/arch/arm/mach-tegra/tegra3_thermal.c b/arch/arm/mach-tegra/tegra3_thermal.c
new file mode 100644
index 00000000000..8ad7bd5b670
--- /dev/null
+++ b/arch/arm/mach-tegra/tegra3_thermal.c
@@ -0,0 +1,544 @@
+/*
+ * arch/arm/mach-tegra/tegra3_thermal.c
+ *
+ * Copyright (C) 2010-2011 NVIDIA Corporation.
+ *
+ * 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/kernel.h>
+#include <linux/cpufreq.h>
+#include <linux/delay.h>
+#include <linux/mutex.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/uaccess.h>
+#include <linux/thermal.h>
+#include <mach/thermal.h>
+#include <mach/edp.h>
+#include <linux/slab.h>
+
+#include "clock.h"
+#include "cpu-tegra.h"
+#include "dvfs.h"
+
+#define MAX_ZONES (16)
+
+struct tegra_thermal {
+        struct tegra_thermal_device *device;
+        long temp_throttle_tj;
+        long temp_shutdown_tj;
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        struct thermal_zone_device *thz;
+        int tc1;
+        int tc2;
+        long passive_delay;
+#else
+        long temp_throttle_low_tj;
+#endif
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+        int edp_thermal_zone_val;
+        long edp_offset;
+        long hysteresis_edp;
+#endif
+        struct mutex mutex;
+};
+
+static struct tegra_thermal thermal_state = {
+        .device = NULL,
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+        .edp_thermal_zone_val = -1,
+#endif
+};
+
+#ifndef CONFIG_TEGRA_THERMAL_SYSFS
+static bool throttle_enb;
+#endif
+
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+static inline long edp2tj(struct tegra_thermal *thermal,
+                                long edp_temp)
+{
+        return edp_temp + thermal->edp_offset;
+}
+
+static inline long tj2edp(struct tegra_thermal *thermal,
+                                long temp_tj)
+{
+        return temp_tj - thermal->edp_offset;
+}
+#endif
+
+static inline long dev2tj(struct tegra_thermal_device *dev,
+                                long dev_temp)
+{
+        return dev_temp + dev->offset;
+}
+
+static inline long tj2dev(struct tegra_thermal_device *dev,
+                                long tj_temp)
+{
+        return tj_temp - dev->offset;
+}
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+
+static int tegra_thermal_zone_bind(struct thermal_zone_device *thermal,
+                                struct thermal_cooling_device *cdevice) {
+        /* Support only Thermal Throttling (1 trip) for now */
+        return thermal_zone_bind_cooling_device(thermal, 0, cdevice);
+}
+
+static int tegra_thermal_zone_unbind(struct thermal_zone_device *thermal,
+                                struct thermal_cooling_device *cdevice) {
+        /* Support only Thermal Throttling (1 trip) for now */
+        return thermal_zone_unbind_cooling_device(thermal, 0, cdevice);
+}
+
+static int tegra_thermal_zone_get_temp(struct thermal_zone_device *thz,
+                                                long *temp)
+{
+        struct tegra_thermal *thermal = thz->devdata;
+        thermal->device->get_temp(thermal->device->data, temp);
+
+        return 0;
+}
+
+static int tegra_thermal_zone_get_trip_type(
+                        struct thermal_zone_device *thermal,
+                        int trip,
+                        enum thermal_trip_type *type) {
+
+        /* Support only Thermal Throttling (1 trip) for now */
+        if (trip != 0)
+                return -EINVAL;
+
+        *type = THERMAL_TRIP_PASSIVE;
+
+        return 0;
+}
+
+static int tegra_thermal_zone_get_trip_temp(struct thermal_zone_device *thz,
+                                                int trip,
+                                                long *temp) {
+        struct tegra_thermal *thermal = thz->devdata;
+
+        /* Support only Thermal Throttling (1 trip) for now */
+        if (trip != 0)
+                return -EINVAL;
+
+        *temp = tj2dev(thermal->device, thermal->temp_throttle_tj);
+
+        return 0;
+}
+
+static struct thermal_zone_device_ops tegra_thermal_zone_ops = {
+        .bind = tegra_thermal_zone_bind,
+        .unbind = tegra_thermal_zone_unbind,
+        .get_temp = tegra_thermal_zone_get_temp,
+        .get_trip_type = tegra_thermal_zone_get_trip_type,
+        .get_trip_temp = tegra_thermal_zone_get_trip_temp,
+};
+#endif
+
+/* The thermal sysfs handles notifying the throttling
+ * cooling device */
+#ifndef CONFIG_TEGRA_THERMAL_SYSFS
+static void tegra_therm_throttle(bool enable)
+{
+        if (throttle_enb != enable) {
+                mutex_lock(&thermal_state.mutex);
+                tegra_throttling_enable(enable);
+                throttle_enb = enable;
+                mutex_unlock(&thermal_state.mutex);
+        }
+}
+#endif
+
+/* Make sure this function remains stateless */
+void tegra_thermal_alert(void *data)
+{
+        struct tegra_thermal *thermal = data;
+        int err;
+        long temp_dev, temp_tj;
+        long lo_limit_throttle_tj, hi_limit_throttle_tj;
+        long lo_limit_edp_tj = 0, hi_limit_edp_tj = 0;
+        long temp_low_dev, temp_low_tj;
+        int lo_limit_tj = 0, hi_limit_tj = 0;
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+        const struct tegra_edp_limits *z;
+        int zones_sz;
+        int i;
+#endif
+
+        if (thermal != &thermal_state)
+                BUG();
+
+        mutex_lock(&thermal_state.mutex);
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        if (thermal->thz) {
+                if (!thermal->thz->passive)
+                        thermal_zone_device_update(thermal->thz);
+        }
+#endif
+
+        err = thermal->device->get_temp(thermal->device->data, &temp_dev);
+        if (err) {
+                pr_err("%s: get temp fail(%d)", __func__, err);
+                goto done;
+        }
+
+        /* Convert all temps to tj and then do all work/logic in terms of
+           tj in order to avoid confusion */
+        temp_tj = dev2tj(thermal->device, temp_dev);
+        thermal->device->get_temp_low(thermal->device, &temp_low_dev);
+        temp_low_tj = dev2tj(thermal->device, temp_low_dev);
+
+        lo_limit_throttle_tj = temp_low_tj;
+        hi_limit_throttle_tj = thermal->temp_throttle_tj;
+
+#ifndef CONFIG_TEGRA_THERMAL_SYSFS
+        /* Check to see if we are currently throttling */
+        if ((tegra_is_throttling() &&
+                (temp_tj > thermal->temp_throttle_low_tj))
+                || (temp_tj >= thermal->temp_throttle_tj)) {
+                lo_limit_throttle_tj = thermal->temp_throttle_low_tj;
+                hi_limit_throttle_tj = thermal->temp_shutdown_tj;
+        }
+#else
+        if (temp_tj > thermal->temp_throttle_tj) {
+                lo_limit_throttle_tj = thermal->temp_throttle_tj;
+                hi_limit_throttle_tj = thermal->temp_shutdown_tj;
+        }
+#endif
+
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+        tegra_get_cpu_edp_limits(&z, &zones_sz);
+
+/* edp table based off of tdiode measurements */
+#define EDP_TEMP_TJ(_index)     edp2tj(thermal, z[_index].temperature * 1000)
+
+        if (temp_tj < EDP_TEMP_TJ(0)) {
+                lo_limit_edp_tj = temp_low_tj;
+                hi_limit_edp_tj = EDP_TEMP_TJ(0);
+        } else if (temp_tj >= EDP_TEMP_TJ(zones_sz-1)) {
+                lo_limit_edp_tj = EDP_TEMP_TJ(zones_sz-1) -
+                                        thermal->hysteresis_edp;
+                hi_limit_edp_tj = thermal->temp_shutdown_tj;
+        } else {
+                for (i = 0; (i + 1) < zones_sz; i++) {
+                        if ((temp_tj >= EDP_TEMP_TJ(i)) &&
+                                (temp_tj < EDP_TEMP_TJ(i+1))) {
+                                lo_limit_edp_tj = EDP_TEMP_TJ(i) -
+                                                        thermal->hysteresis_edp;
+                                hi_limit_edp_tj = EDP_TEMP_TJ(i+1);
+                                break;
+                        }
+                }
+        }
+#undef EDP_TEMP_TJ
+#else
+        lo_limit_edp_tj = temp_low_tj;
+        hi_limit_edp_tj = thermal->temp_shutdown_tj;
+#endif
+
+        /* Get smallest window size */
+        lo_limit_tj = max(lo_limit_throttle_tj, lo_limit_edp_tj);
+        hi_limit_tj = min(hi_limit_throttle_tj, hi_limit_edp_tj);
+
+        thermal->device->set_limits(thermal->device->data,
+                                        tj2dev(thermal->device, lo_limit_tj),
+                                        tj2dev(thermal->device, hi_limit_tj));
+
+#ifndef CONFIG_TEGRA_THERMAL_SYSFS
+        if (temp_tj >= thermal->temp_throttle_tj) {
+                /* start throttling */
+                if (!tegra_is_throttling())
+                        tegra_therm_throttle(true);
+        } else if (temp_tj <= thermal->temp_throttle_low_tj) {
+                /* switch off throttling */
+                if (tegra_is_throttling())
+                        tegra_therm_throttle(false);
+        }
+#endif
+
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+        /* inform edp governor */
+        if (thermal->edp_thermal_zone_val != temp_tj)
+                tegra_edp_update_thermal_zone(tj2edp(thermal, temp_tj)/1000);
+
+        thermal->edp_thermal_zone_val = temp_tj;
+#endif
+
+done:
+        mutex_unlock(&thermal_state.mutex);
+}
+
+int tegra_thermal_set_device(struct tegra_thermal_device *device)
+{
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        struct thermal_zone_device *thz;
+#endif
+
+        /* only support one device */
+        if (thermal_state.device)
+                return -EINVAL;
+
+        thermal_state.device = device;
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        thz = thermal_zone_device_register(thermal_state.device->name,
+                                        1, /* trips */
+                                        &thermal_state,
+                                        &tegra_thermal_zone_ops,
+                                        thermal_state.tc1, /* dT/dt */
+                                        thermal_state.tc2, /* throttle */
+                                        thermal_state.passive_delay,
+                                        0); /* polling delay */
+
+        if (IS_ERR(thz)) {
+                thz = NULL;
+                return -ENODEV;
+        }
+
+        thermal_state.thz = thz;
+#endif
+        thermal_state.device->set_alert(thermal_state.device->data,
+                                        tegra_thermal_alert,
+                                        &thermal_state);
+
+        thermal_state.device->set_shutdown_temp(thermal_state.device->data,
+                                tj2dev(device, thermal_state.temp_shutdown_tj));
+
+        /* initialize limits */
+        tegra_thermal_alert(&thermal_state);
+
+        return 0;
+}
+
+int __init tegra_thermal_init(struct tegra_thermal_data *data)
+{
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        thermal_state.tc1 = data->tc1;
+        thermal_state.tc2 = data->tc2;
+        thermal_state.passive_delay = data->passive_delay;
+#else
+        thermal_state.temp_throttle_low_tj = data->temp_throttle +
+                                                data->temp_offset -
+                                                data->hysteresis_throttle;
+#endif
+        mutex_init(&thermal_state.mutex);
+#ifdef CONFIG_TEGRA_EDP_LIMITS
+        thermal_state.edp_offset = data->edp_offset;
+        thermal_state.hysteresis_edp = data->hysteresis_edp;
+#endif
+        thermal_state.temp_throttle_tj = data->temp_throttle +
+                                                data->temp_offset;
+        thermal_state.temp_shutdown_tj = data->temp_shutdown +
+                                                data->temp_offset;
+
+        return 0;
+}
+
+int tegra_thermal_exit(void)
+{
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        if (thermal_state.thz)
+                thermal_zone_device_unregister(thermal_state.thz);
+#endif
+
+        return 0;
+}
+
+#ifdef CONFIG_DEBUG_FS
+
+static int tegra_thermal_throttle_temp_tj_set(void *data, u64 val)
+{
+#ifndef CONFIG_TEGRA_THERMAL_SYSFS
+        long throttle_hysteresis = thermal_state.temp_throttle_tj -
+                                        thermal_state.temp_throttle_low_tj;
+#endif
+
+        mutex_lock(&thermal_state.mutex);
+        thermal_state.temp_throttle_tj = val;
+#ifndef CONFIG_TEGRA_THERMAL_SYSFS
+        thermal_state.temp_throttle_low_tj = thermal_state.temp_throttle_tj -
+                                                throttle_hysteresis;
+#endif
+        mutex_unlock(&thermal_state.mutex);
+
+        tegra_thermal_alert(&thermal_state);
+
+        return 0;
+}
+
+static int tegra_thermal_throttle_temp_tj_get(void *data, u64 *val)
+{
+        *val = (u64)thermal_state.temp_throttle_tj;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(throttle_temp_tj_fops,
+                        tegra_thermal_throttle_temp_tj_get,
+                        tegra_thermal_throttle_temp_tj_set,
+                        "%llu\n");
+
+static int tegra_thermal_shutdown_temp_tj_set(void *data, u64 val)
+{
+        thermal_state.temp_shutdown_tj = val;
+
+        if (thermal_state.device)
+                thermal_state.device->set_shutdown_temp(
+                                thermal_state.device->data,
+                                tj2dev(thermal_state.device,
+                                        thermal_state.temp_shutdown_tj));
+
+        tegra_thermal_alert(&thermal_state);
+
+        return 0;
+}
+
+static int tegra_thermal_shutdown_temp_tj_get(void *data, u64 *val)
+{
+        *val = (u64)thermal_state.temp_shutdown_tj;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(shutdown_temp_tj_fops,
+                        tegra_thermal_shutdown_temp_tj_get,
+                        tegra_thermal_shutdown_temp_tj_set,
+                        "%llu\n");
+
+
+static int tegra_thermal_temp_tj_get(void *data, u64 *val)
+{
+        long temp_tj, temp_dev;
+
+        if (thermal_state.device) {
+                thermal_state.device->get_temp(thermal_state.device->data,
+                                                &temp_dev);
+
+                /* Convert all temps to tj and then do all work/logic in
+                   terms of tj in order to avoid confusion */
+                temp_tj = dev2tj(thermal_state.device, temp_dev);
+        } else {
+                temp_tj = -1;
+        }
+
+        *val = (u64)temp_tj;
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(temp_tj_fops,
+                        tegra_thermal_temp_tj_get,
+                        NULL,
+                        "%llu\n");
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+static int tegra_thermal_tc1_set(void *data, u64 val)
+{
+        thermal_state.thz->tc1 = val;
+        return 0;
+}
+
+static int tegra_thermal_tc1_get(void *data, u64 *val)
+{
+        *val = (u64)thermal_state.thz->tc1;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(tc1_fops,
+                        tegra_thermal_tc1_get,
+                        tegra_thermal_tc1_set,
+                        "%llu\n");
+
+static int tegra_thermal_tc2_set(void *data, u64 val)
+{
+        thermal_state.thz->tc2 = val;
+        return 0;
+}
+
+static int tegra_thermal_tc2_get(void *data, u64 *val)
+{
+        *val = (u64)thermal_state.thz->tc2;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(tc2_fops,
+                        tegra_thermal_tc2_get,
+                        tegra_thermal_tc2_set,
+                        "%llu\n");
+
+static int tegra_thermal_passive_delay_set(void *data, u64 val)
+{
+        thermal_state.thz->passive_delay = val;
+        return 0;
+}
+
+static int tegra_thermal_passive_delay_get(void *data, u64 *val)
+{
+        *val = (u64)thermal_state.thz->passive_delay;
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(passive_delay_fops,
+                        tegra_thermal_passive_delay_get,
+                        tegra_thermal_passive_delay_set,
+                        "%llu\n");
+#endif
+
+
+static struct dentry *thermal_debugfs_root;
+
+static int __init tegra_thermal_debug_init(void)
+{
+        thermal_debugfs_root = debugfs_create_dir("tegra_thermal", 0);
+
+        if (!debugfs_create_file("throttle_temp_tj", 0644, thermal_debugfs_root,
+                                 NULL, &throttle_temp_tj_fops))
+                goto err_out;
+
+        if (!debugfs_create_file("shutdown_temp_tj", 0644, thermal_debugfs_root,
+                                 NULL, &shutdown_temp_tj_fops))
+                goto err_out;
+
+        if (!debugfs_create_file("temp_tj", 0644, thermal_debugfs_root,
+                                 NULL, &temp_tj_fops))
+                goto err_out;
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        if (!debugfs_create_file("tc1", 0644, thermal_debugfs_root,
+                                 NULL, &tc1_fops))
+                goto err_out;
+
+        if (!debugfs_create_file("tc2", 0644, thermal_debugfs_root,
+                                 NULL, &tc2_fops))
+                goto err_out;
+
+        if (!debugfs_create_file("passive_delay", 0644, thermal_debugfs_root,
+                                 NULL, &passive_delay_fops))
+                goto err_out;
+#endif
+
+        return 0;
+
+err_out:
+        debugfs_remove_recursive(thermal_debugfs_root);
+        return -ENOMEM;
+}
+
+late_initcall(tegra_thermal_debug_init);
+#endif