1 files changed, 367 insertions, 0 deletions

diff --git a/arch/arm/mach-tegra/tegra3_throttle.c b/arch/arm/mach-tegra/tegra3_throttle.c
new file mode 100644
index 00000000000..f927be7800d
--- /dev/null
+++ b/arch/arm/mach-tegra/tegra3_throttle.c
@@ -0,0 +1,367 @@
+/*
+ * arch/arm/mach-tegra/tegra3_throttle.c
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpufreq.h>
+#include <linux/delay.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 "clock.h"
+#include "cpu-tegra.h"
+#include "dvfs.h"
+
+/* tegra throttling require frequencies in the table to be in ascending order */
+static struct cpufreq_frequency_table *cpu_freq_table;
+static struct mutex *cpu_throttle_lock;
+
+static struct {
+        unsigned int cpu_freq;
+        int core_cap_level;
+        int ms;
+} throttle_table[] = {
+        {      0, 1000, 2000 }, /* placeholder for cpu floor rate */
+        { 640000, 1000, 2000 },
+        { 640000, 1000, 2000 },
+        { 640000, 1000, 2000 },
+        { 640000, 1000, 2000 },
+        { 640000, 1000, 2000 },
+        { 760000, 1000, 2000 },
+        { 760000, 1050, 2000 },
+        {1000000, 1050, 2000 },
+        {1000000, 1100, 2000 },
+};
+
+static int is_throttling;
+static int throttle_index;
+static struct delayed_work throttle_work;
+static struct workqueue_struct *workqueue;
+static DEFINE_MUTEX(tegra_throttle_lock);
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+static struct thermal_cooling_device *cdev;
+#endif
+
+static unsigned int clip_to_table(unsigned int cpu_freq)
+{
+        int i;
+
+        for (i = 0; cpu_freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+                if (cpu_freq_table[i].frequency > cpu_freq)
+                        break;
+        }
+        i = (i == 0) ? 0 : i-1;
+        return cpu_freq_table[i].frequency;
+}
+
+static void tegra_throttle_work_func(struct work_struct *work)
+{
+        unsigned int cpu_freq;
+        int core_level;
+
+        mutex_lock(cpu_throttle_lock);
+        if (!is_throttling) {
+                mutex_unlock(cpu_throttle_lock);
+                return;
+        }
+
+        cpu_freq = tegra_getspeed(0);
+        throttle_index -= throttle_index ? 1 : 0;
+
+        core_level = throttle_table[throttle_index].core_cap_level;
+        if (throttle_table[throttle_index].cpu_freq < cpu_freq)
+                tegra_cpu_set_speed_cap(NULL);
+
+        if (throttle_index || (throttle_table[0].cpu_freq < cpu_freq))
+                queue_delayed_work(workqueue, &throttle_work,
+                        msecs_to_jiffies(throttle_table[throttle_index].ms));
+
+        mutex_unlock(cpu_throttle_lock);
+
+        tegra_dvfs_core_cap_level_set(core_level);
+}
+
+/*
+ * tegra_throttling_enable
+ * This function may sleep
+ */
+void tegra_throttling_enable(bool enable)
+{
+        mutex_lock(&tegra_throttle_lock);
+        mutex_lock(cpu_throttle_lock);
+
+        if (enable && !(is_throttling++)) {
+                int core_level;
+                unsigned int cpu_freq = tegra_getspeed(0);
+                throttle_index = ARRAY_SIZE(throttle_table) - 1;
+
+                core_level = throttle_table[throttle_index].core_cap_level;
+                if (throttle_table[throttle_index].cpu_freq < cpu_freq)
+                        tegra_cpu_set_speed_cap(NULL);
+
+                queue_delayed_work(workqueue, &throttle_work,
+                        msecs_to_jiffies(throttle_table[throttle_index].ms));
+
+                mutex_unlock(cpu_throttle_lock);
+
+                tegra_dvfs_core_cap_level_set(core_level);
+                tegra_dvfs_core_cap_enable(true);
+
+                mutex_unlock(&tegra_throttle_lock);
+                return;
+        }
+
+        if (!enable && is_throttling) {
+                if (!(--is_throttling)) {
+                        /* restore speed requested by governor */
+                        tegra_cpu_set_speed_cap(NULL);
+                        mutex_unlock(cpu_throttle_lock);
+
+                        tegra_dvfs_core_cap_enable(false);
+                        cancel_delayed_work_sync(&throttle_work);
+                        mutex_unlock(&tegra_throttle_lock);
+                        return;
+                }
+        }
+
+        mutex_unlock(cpu_throttle_lock);
+        mutex_unlock(&tegra_throttle_lock);
+}
+EXPORT_SYMBOL_GPL(tegra_throttling_enable);
+
+unsigned int tegra_throttle_governor_speed(unsigned int requested_speed)
+{
+        return is_throttling ?
+                min(requested_speed, throttle_table[throttle_index].cpu_freq) :
+                requested_speed;
+}
+
+bool tegra_is_throttling(void)
+{
+        return is_throttling;
+}
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+
+static int
+tegra_throttle_get_max_state(struct thermal_cooling_device *cdev,
+                                unsigned long *max_state)
+{
+        *max_state = ARRAY_SIZE(throttle_table);
+        return 0;
+}
+
+static int
+tegra_throttle_get_cur_state(struct thermal_cooling_device *cdev,
+                                unsigned long *cur_state)
+{
+        mutex_lock(cpu_throttle_lock);
+        *cur_state = is_throttling ?
+                        (ARRAY_SIZE(throttle_table) - throttle_index) :
+                        0;
+        mutex_unlock(cpu_throttle_lock);
+
+        return 0;
+}
+
+static int
+tegra_throttle_set_cur_state(struct thermal_cooling_device *cdev,
+                                unsigned long cur_state)
+{
+        int core_level;
+
+        mutex_lock(cpu_throttle_lock);
+        if (cur_state == 0) {
+                /* restore speed requested by governor */
+                if (is_throttling) {
+                        tegra_dvfs_core_cap_enable(false);
+                        is_throttling = false;
+                }
+
+                tegra_cpu_set_speed_cap(NULL);
+        } else {
+                if (!is_throttling) {
+                        tegra_dvfs_core_cap_enable(true);
+                        is_throttling = true;
+                }
+
+                throttle_index = ARRAY_SIZE(throttle_table) - cur_state;
+                core_level = throttle_table[throttle_index].core_cap_level;
+                tegra_dvfs_core_cap_level_set(core_level);
+
+                tegra_cpu_set_speed_cap(NULL);
+        }
+
+        mutex_unlock(cpu_throttle_lock);
+
+        return 0;
+}
+
+struct thermal_cooling_device_ops tegra_throttle_cooling_ops = {
+        .get_max_state = tegra_throttle_get_max_state,
+        .get_cur_state = tegra_throttle_get_cur_state,
+        .set_cur_state = tegra_throttle_set_cur_state,
+};
+#endif
+
+int __init tegra_throttle_init(struct mutex *cpu_lock)
+{
+        int i;
+        struct tegra_cpufreq_table_data *table_data =
+                tegra_cpufreq_table_get();
+        if (IS_ERR_OR_NULL(table_data))
+                return -EINVAL;
+
+        /*
+         * High-priority, others flags default: not bound to a specific
+         * CPU, has rescue worker task (in case of allocation deadlock,
+         * etc.).  Single-threaded.
+         */
+        workqueue = alloc_workqueue("cpu-tegra",
+                                    WQ_HIGHPRI | WQ_UNBOUND | WQ_RESCUER, 1);
+        if (!workqueue)
+                return -ENOMEM;
+        INIT_DELAYED_WORK(&throttle_work, tegra_throttle_work_func);
+
+        cpu_throttle_lock = cpu_lock;
+        cpu_freq_table = table_data->freq_table;
+        throttle_table[0].cpu_freq =
+                cpu_freq_table[table_data->throttle_lowest_index].frequency;
+
+        for (i = 0; i < ARRAY_SIZE(throttle_table); i++) {
+                unsigned int cpu_freq = throttle_table[i].cpu_freq;
+                throttle_table[i].cpu_freq = clip_to_table(cpu_freq);
+        }
+
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        cdev = thermal_cooling_device_register("Throttle", NULL,
+                                                &tegra_throttle_cooling_ops);
+
+        if (IS_ERR(cdev)) {
+                cdev = NULL;
+                return -ENODEV;
+        }
+#endif
+
+        return 0;
+}
+
+void tegra_throttle_exit(void)
+{
+#ifdef CONFIG_TEGRA_THERMAL_SYSFS
+        if (cdev) {
+                thermal_cooling_device_unregister(cdev);
+                cdev = NULL;
+        }
+#endif
+        destroy_workqueue(workqueue);
+}
+
+#ifdef CONFIG_DEBUG_FS
+
+static int throttle_debug_set(void *data, u64 val)
+{
+        tegra_throttling_enable(val);
+        return 0;
+}
+static int throttle_debug_get(void *data, u64 *val)
+{
+        *val = (u64) is_throttling;
+        return 0;
+}
+DEFINE_SIMPLE_ATTRIBUTE(throttle_fops, throttle_debug_get, throttle_debug_set,
+                        "%llu\n");
+static int table_show(struct seq_file *s, void *data)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(throttle_table); i++)
+                seq_printf(s, "[%d] = %7u %4d %5d\n",
+                        i, throttle_table[i].cpu_freq,
+                        throttle_table[i].core_cap_level, throttle_table[i].ms);
+        return 0;
+}
+
+static int table_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, table_show, inode->i_private);
+}
+
+static ssize_t table_write(struct file *file,
+        const char __user *userbuf, size_t count, loff_t *ppos)
+{
+        char buf[80];
+        int table_idx;
+        unsigned int cpu_freq;
+        int core_cap_level;
+        int ms;
+
+        if (sizeof(buf) <= count)
+                return -EINVAL;
+
+        if (copy_from_user(buf, userbuf, count))
+                return -EFAULT;
+
+        /* terminate buffer and trim - white spaces may be appended
+         *  at the end when invoked from shell command line */
+        buf[count] = '\0';
+        strim(buf);
+
+        if (sscanf(buf, "[%d] = %u %d %d",
+                   &table_idx, &cpu_freq, &core_cap_level, &ms) != 4)
+                return -1;
+
+        if ((table_idx < 0) || (table_idx >= ARRAY_SIZE(throttle_table)))
+                return -EINVAL;
+
+        /* round new settings before updating table */
+        throttle_table[table_idx].cpu_freq = clip_to_table(cpu_freq);
+        throttle_table[table_idx].core_cap_level = (core_cap_level / 50) * 50;
+        throttle_table[table_idx].ms = jiffies_to_msecs(msecs_to_jiffies(ms));
+
+        return count;
+}
+
+static const struct file_operations table_fops = {
+        .open           = table_open,
+        .read           = seq_read,
+        .write          = table_write,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+
+int __init tegra_throttle_debug_init(struct dentry *cpu_tegra_debugfs_root)
+{
+        if (!debugfs_create_file("throttle", 0644, cpu_tegra_debugfs_root,
+                                 NULL, &throttle_fops))
+                return -ENOMEM;
+
+        if (!debugfs_create_file("throttle_table", 0644, cpu_tegra_debugfs_root,
+                                 NULL, &table_fops))
+                return -ENOMEM;
+
+        return 0;
+}
+#endif /* CONFIG_DEBUG_FS */
+