/*
* arch/arm/mach-tegra/tegra2_throttle.c
*
* Copyright (C) 2010 Google, Inc.
*
* Author:
* Colin Cross <ccross@google.com>
* Based on arch/arm/plat-omap/cpu-omap.c, (C) 2005 Nokia Corporation
*
* 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/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/cpufreq.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
#include <linux/debugfs.h>
#include "clock.h"
#include "cpu-tegra.h"
/* tegra throttling require frequencies in the table to be in ascending order */
static struct cpufreq_frequency_table *throttle_table;
static struct mutex *cpu_throttle_lock;
/* CPU frequency is gradually lowered when throttling is enabled */
#define THROTTLE_DELAY msecs_to_jiffies(2000)
static int is_throttling;
static int throttle_lowest_index;
static int throttle_highest_index;
static int throttle_index;
static int throttle_next_index;
static struct delayed_work throttle_work;
static struct workqueue_struct *workqueue;
static DEFINE_MUTEX(tegra_throttle_lock);
static void tegra_throttle_work_func(struct work_struct *work)
{
unsigned int current_freq;
mutex_lock(cpu_throttle_lock);
if (!is_throttling)
goto out;
current_freq = tegra_getspeed(0);
throttle_index = throttle_next_index;
if (throttle_table[throttle_index].frequency < current_freq)
tegra_cpu_set_speed_cap(NULL);
if (throttle_index > throttle_lowest_index) {
throttle_next_index = throttle_index - 1;
queue_delayed_work(workqueue, &throttle_work, THROTTLE_DELAY);
}
out:
mutex_unlock(cpu_throttle_lock);
}
/*
* 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++)) {
unsigned int current_freq = tegra_getspeed(0);
for (throttle_index = throttle_highest_index;
throttle_index >= throttle_lowest_index;
throttle_index--)
if (throttle_table[throttle_index].frequency
< current_freq)
break;
throttle_index = max(throttle_index, throttle_lowest_index);
throttle_next_index = throttle_index;
queue_delayed_work(workqueue, &throttle_work, 0);
} else if (!enable && is_throttling) {
if (!(--is_throttling)) {
/* restore speed requested by governor */
tegra_cpu_set_speed_cap(NULL);
mutex_unlock(cpu_throttle_lock);
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].frequency) :
requested_speed;
}
bool tegra_is_throttling(void)
{
return is_throttling;
}
int __init tegra_throttle_init(struct mutex *cpu_lock)
{
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);
throttle_lowest_index = table_data->throttle_lowest_index;
throttle_highest_index = table_data->throttle_highest_index;
throttle_table = table_data->freq_table;
cpu_throttle_lock = cpu_lock;
return 0;
}
void tegra_throttle_exit(void)
{
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");
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;
return 0;
}
#endif /* CONFIG_DEBUG_FS */
