Initial file dump from open source releaseHEADmaster

1 files changed, 729 insertions, 0 deletions

diff --git a/drivers/devfreq/governor_ondemand.c b/drivers/devfreq/governor_ondemand.c
new file mode 100644
index 00000000..ac358bae
--- /dev/null
+++ b/drivers/devfreq/governor_ondemand.c
@@ -0,0 +1,729 @@
+/*
+ * 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/errno.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/devfreq.h>
+#include <linux/math64.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/earlysuspend.h>
+#include "governor.h"
+
+/* Default constants for DevFreq-Ondemand (DFO) */
+#define DFO_UPTHRESHOLD		(80)
+#define DFO_DOWNDIFFERENCTIAL	(30)
+
+/*
+* TODO: add kernel space requests
+*/
+#ifdef CONFIG_SPRD_SCX35_DMC_FREQ
+extern void devfreq_min_freq_cnt_reset(unsigned int, unsigned int);
+extern int devfreq_request_ignore(void);
+#endif
+
+static void dfs_req_timer_timeout(unsigned long arg);
+#define REQ_TIMEOUT_DEF (HZ/20);
+static DEFINE_SPINLOCK(dfs_req_lock);
+static unsigned int dfs_req_timeout;
+static DEFINE_TIMER(dfs_req_timer, dfs_req_timer_timeout, 0, 0);
+struct dfs_request_state{
+	int req_sum;  /* in KHz */
+	int req_timeout;  /* in KHz */
+	int req_quirk;  /* in KHz */
+	u32 ddr_freq_after_req;  /* in KHz */
+};
+static struct dfs_request_state user_requests;
+static struct devfreq *g_devfreq; /* for requests from kernel */
+static int gov_eb = 1;
+struct userspace_data {
+	int req_bw;
+	unsigned long set_freq;
+	unsigned long set_count;
+	unsigned long upthreshold;
+	unsigned long downdifferential;
+	unsigned long (*convert_bw_to_freq)(u32 req_bw);
+	bool enable; /*sysfs only*/
+	bool devfreq_enable;
+};
+
+/************ kernel interface *****************/
+/*
+* get dfs enable flag
+* enabled == 0 --> dfs disable
+* enabled == 1 --> dfs enable
+*/
+bool dfs_get_enable(void)
+{
+	struct userspace_data *user_data;
+	bool enabled;
+
+	if(g_devfreq && g_devfreq->data){
+                user_data = (struct userspace_data *)(g_devfreq->data);
+		enabled = user_data->enable;
+		pr_debug("%s, enabled = %d, user_data->enable = %d\n", __func__, enabled, user_data->enable);
+	}
+
+	return enabled;
+}
+EXPORT_SYMBOL(dfs_get_enable);
+/*
+* set ddr frequnecy
+* @freq: KHz
+* if ddr frequency is set through this function, DVS is disabled
+*/
+int dfs_set_freq(int freq)
+{
+	struct userspace_data *user_data;
+	int err;
+
+	if(freq < 0){
+		err = -1;
+		pr_debug("*** %s,freq < 0\n",__func__);
+		goto done;
+	}
+
+	user_data = (struct userspace_data *)(g_devfreq->data);
+	mutex_lock(&g_devfreq->lock);
+	if(user_data){
+		if(freq > 0){
+			user_data->set_count++;
+			user_data->devfreq_enable = false;
+			if(freq > user_data->set_freq)
+				user_data->set_freq = freq;
+		}else{
+			if(user_data->set_count > 0){
+				user_data->set_count--;
+				if(user_data->set_count == 0){
+					user_data->set_freq = 0;
+					user_data->devfreq_enable = true;
+				}
+			}
+		}
+		pr_debug("*** %s, set freq:%d KHz, set_count:%lu ***\n", __func__, freq, user_data->set_count );
+	}
+	else
+	{
+		pr_debug("*** %s,user_data == 0\n",__func__);
+	}
+	err = update_devfreq(g_devfreq);
+	mutex_unlock(&g_devfreq->lock);	
+done:
+	return err;
+}
+
+/*
+*  add a new ddr bandwidth request.
+*  @req_bw: KB
+*      + addition(add>=0) or - subtraction(add<0)
+*/
+void dfs_request_bw(int req_bw)
+{
+	u32 req_freq = 0;
+	int add = 1;
+	struct userspace_data *user_data;
+
+	if (req_bw < 0) {
+		req_bw = -req_bw;
+		add = -1;
+	}
+
+	if(g_devfreq && g_devfreq->data){
+		user_data = (struct userspace_data *)(g_devfreq->data);
+		if(user_data->convert_bw_to_freq){
+			req_freq = (user_data->convert_bw_to_freq)(req_bw);
+		}
+	}
+	pr_debug("*** %s, pid:%u, %creq_bw:%u, req_freq:%u ***\n",
+				__func__, current->pid, add>=0?'+':'-', req_bw, req_freq );
+	if(req_freq){
+		mutex_lock(&g_devfreq->lock);
+		if(add >= 0)
+			user_requests.req_sum += req_freq;
+		else
+			user_requests.req_sum -= req_freq;
+		if(user_requests.req_sum < 0)
+			user_requests.req_sum = 0;
+		update_devfreq(g_devfreq);
+		mutex_unlock(&g_devfreq->lock);
+	}
+}
+
+/*
+* set request timer timeout
+* @timeout, ms
+*/
+void dfs_req_set_timeout(unsigned int timeout)
+{
+	spin_lock(&dfs_req_lock);
+	dfs_req_timeout = msecs_to_jiffies(timeout);
+	spin_unlock(&dfs_req_lock);
+}
+EXPORT_SYMBOL(dfs_req_set_timeout);
+
+/*
+* get request timer timeout
+* @return, ms
+*/
+unsigned int dfs_req_get_timeout(void)
+{
+	unsigned int timeout;
+
+	spin_lock(&dfs_req_lock);
+	timeout = dfs_req_timeout;
+	spin_unlock(&dfs_req_lock);
+
+	timeout = jiffies_to_msecs(timeout);
+	return timeout;
+}
+EXPORT_SYMBOL(dfs_req_get_timeout);
+
+static void dfs_req_timer_timeout(unsigned long arg)
+{
+	spin_lock(&dfs_req_lock);
+	user_requests.req_timeout = 0;
+	spin_unlock(&dfs_req_lock);
+	return;
+}
+
+/*
+*  add a new ddr bandwidth request. when time is up, request is cleared automatically
+*  @req_bw, KB
+*/
+void dfs_request_bw_timeout(unsigned int req_bw)
+{
+	struct userspace_data *user_data;
+	unsigned int req_freq;
+
+	req_freq = 0;
+	if(req_bw == 0)
+		return;
+
+	spin_lock(&dfs_req_lock);
+	if( user_requests.req_timeout ){
+		spin_unlock(&dfs_req_lock);
+		pr_debug("*** %s, ignore, req_timeout:%d ***\n", __func__, user_requests.req_timeout);
+		return;
+	}
+	spin_unlock(&dfs_req_lock);
+
+	if(g_devfreq && g_devfreq->data){
+		user_data = (struct userspace_data *)(g_devfreq->data);
+		if(user_data->convert_bw_to_freq){
+			req_freq = (user_data->convert_bw_to_freq)(req_bw);
+			printk("*** %s, req_freq:%d ***\n", __func__, req_freq );
+		}
+	}
+	spin_lock(&dfs_req_lock);
+	user_requests.req_timeout = req_freq;
+	spin_unlock(&dfs_req_lock);
+
+	if(req_freq)
+		mod_timer(&dfs_req_timer, jiffies+dfs_req_timeout);
+	else
+		del_timer_sync(&dfs_req_timer);
+
+	if(req_freq){
+		mutex_lock(&g_devfreq->lock);
+		update_devfreq(g_devfreq);
+		mutex_unlock(&g_devfreq->lock);
+	}
+}
+EXPORT_SYMBOL(dfs_request_bw_timeout);
+
+/*
+*  raise ddr frequency up temporarily
+*  @req_bw, KB
+*/
+#ifdef CONFIG_SPRD_SCX35_DMC_FREQ
+void dfs_freq_raise_quirk(unsigned int req_bw)
+{
+	if(req_bw == 0)
+		return;
+
+	spin_lock(&dfs_req_lock);
+	if(user_requests.req_quirk || devfreq_request_ignore() ){
+		spin_unlock(&dfs_req_lock);
+		return;
+	}
+	user_requests.req_quirk = req_bw;
+	spin_unlock(&dfs_req_lock);
+
+	mutex_lock(&g_devfreq->lock);
+	devfreq_min_freq_cnt_reset(-1, 1);
+	update_devfreq(g_devfreq);
+	devfreq_min_freq_cnt_reset(-1, 0);
+	user_requests.req_quirk = 0;
+	mutex_unlock(&g_devfreq->lock);
+}
+EXPORT_SYMBOL(dfs_freq_raise_quirk);
+#endif
+
+/************ early suspend  *****************/
+
+static void devfreq_early_suspend(struct early_suspend *h)
+{
+#ifdef CONFIG_ARCH_SCX15
+	dfs_set_freq(192000);
+#else
+#ifdef CONFIG_ARCH_SCX35
+        dfs_set_freq(200000);
+#endif
+#endif
+	gov_eb = 0;
+}
+
+static void devfreq_late_resume(struct early_suspend *h)
+{
+	dfs_set_freq(0);
+}
+
+static struct early_suspend devfreq_early_suspend_desc = {
+        .level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 100,
+        .suspend = devfreq_early_suspend,
+        .resume = devfreq_late_resume,
+};
+
+static void devfreq_enable_late_resume(struct early_suspend *h)
+{
+	gov_eb = 1;
+}
+static struct early_suspend devfreq_enable_desc = {
+        .level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN,
+        .resume = devfreq_enable_late_resume,
+};
+/************ userspace interface *****************/
+
+static ssize_t store_upthreshold(struct device *dev, struct device_attribute *attr,
+			  const char *buf, size_t count)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	unsigned long wanted;
+
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	sscanf(buf, "%lu", &wanted);
+	if(data)
+		data->upthreshold = wanted;
+	mutex_unlock(&devfreq->lock);
+	return count;
+}
+
+static ssize_t show_upthreshold(struct device *dev, struct device_attribute *attr,
+			 char *buf)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	int err = 0;
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	if(data){
+		err = sprintf(buf, "%lu\n", data->upthreshold);
+	}else
+		err = sprintf(buf, "%d\n", DFO_UPTHRESHOLD);
+	mutex_unlock(&devfreq->lock);
+	return err;
+}
+
+static ssize_t store_downdifferential(struct device *dev, struct device_attribute *attr,
+			const char *buf, size_t count)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	unsigned long wanted;
+
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	sscanf(buf, "%lu", &wanted);
+	if(data)
+		data->downdifferential = wanted;
+	mutex_unlock(&devfreq->lock);
+	return count;
+}
+
+static ssize_t show_downdifferential(struct device *dev, struct device_attribute *attr,
+			char *buf)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	int err = 0;
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	if(data){
+		err = sprintf(buf, "%lu\n", data->downdifferential);
+	}else{
+		err = sprintf(buf, "%d\n", DFO_DOWNDIFFERENCTIAL);
+	}
+	mutex_unlock(&devfreq->lock);
+	return err;
+}
+
+
+static ssize_t store_request(struct device *dev, struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	int wanted;
+	int req_freq;
+	int err = 0;
+
+	req_freq = 0;
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	sscanf(buf, "%d", &wanted);
+	if(data){
+		data->req_bw += wanted;
+		pr_debug("*** %s, request:%d, total request:%d ***\n",
+				__func__, wanted, data->req_bw);
+		if(data->req_bw < 0)
+			data->req_bw = 0;
+		if(data->convert_bw_to_freq)
+			req_freq = data->convert_bw_to_freq(wanted);
+	}
+	user_requests.req_sum += req_freq;
+	if(user_requests.req_sum < 0)
+		user_requests.req_sum = 0;
+	err = update_devfreq(devfreq);
+	if (err == 0)
+		err = count;
+	mutex_unlock(&devfreq->lock);
+	return err;
+
+}
+
+static ssize_t show_request(struct device *dev, struct device_attribute *attr,
+		char *buf)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	int err = 0;
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	if(data)
+		err = sprintf(buf, "%d KB\n", data->req_bw);
+	mutex_unlock(&devfreq->lock);
+	return err;
+}
+
+static ssize_t store_enable(struct device *dev, struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	unsigned long wanted;
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	sscanf(buf, "%lu", &wanted);
+	if(data){
+		data->enable = wanted;
+	}
+	mutex_unlock(&devfreq->lock);
+	return count;
+}
+
+static ssize_t show_enable(struct device *dev, struct device_attribute *attr,
+		char *buf)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	int err = 0;
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	if(data)
+		err = sprintf(buf, "%d \n", data->enable);
+	mutex_unlock(&devfreq->lock);
+	return err;
+}
+
+static ssize_t store_freq(struct device *dev, struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	unsigned long wanted;
+	int err = 0;
+
+	sscanf(buf, "%lu", &wanted);
+	err = dfs_set_freq(wanted);
+	if (err == 0)
+		err = count;
+	return err;
+}
+
+static ssize_t show_freq(struct device *dev, struct device_attribute *attr,
+		char *buf)
+{
+	struct devfreq *devfreq = to_devfreq(dev);
+	struct userspace_data *data;
+	int err = 0;
+
+	mutex_lock(&devfreq->lock);
+	data = devfreq->data;
+	if(data)
+		err = sprintf(buf, "%lu KHz, set count:%lu\n", data->set_freq, data->set_count);
+	mutex_unlock(&devfreq->lock);
+	return err;
+}
+
+static DEVICE_ATTR(set_freq, 0644, show_freq, store_freq);
+static DEVICE_ATTR(set_enable, 0644, show_enable, store_enable);
+static DEVICE_ATTR(set_request, 0644, show_request, store_request);
+static DEVICE_ATTR(set_upthreshold, 0644, show_upthreshold, store_upthreshold);
+static DEVICE_ATTR(set_downdifferential, 0644, show_downdifferential, store_downdifferential);
+static struct attribute *dev_entries[] = {
+	&dev_attr_set_freq.attr,
+	&dev_attr_set_enable.attr,
+	&dev_attr_set_request.attr,
+	&dev_attr_set_upthreshold.attr,
+	&dev_attr_set_downdifferential.attr,
+	NULL,
+};
+static struct attribute_group dev_attr_group = {
+	.name	= "ondemand",
+	.attrs	= dev_entries,
+};
+
+static int devfreq_ondemand_start(struct devfreq *devfreq)
+{
+	int err = 0;
+	struct userspace_data *data = kzalloc(sizeof(struct userspace_data),
+			GFP_KERNEL);
+
+	if (!data) {
+		err = -ENOMEM;
+		goto out;
+	}
+	data->req_bw = 0;
+	data->set_freq = 0;
+	data->upthreshold = DFO_UPTHRESHOLD;
+	data->downdifferential = DFO_DOWNDIFFERENCTIAL;
+#if defined(CONFIG_ARCH_SCX30G)
+	data->enable = false;
+#else
+	data->enable = true;
+#endif
+	data->devfreq_enable = true;
+	if(devfreq->data){
+		data->convert_bw_to_freq = devfreq->data;
+		pr_info("*** %s, data->convert_bw_to_freq:%pf ***\n", __func__, data->convert_bw_to_freq);
+	}
+	devfreq->data = data;
+	g_devfreq = devfreq;
+	err = sysfs_create_group(&devfreq->dev.kobj, &dev_attr_group);
+	register_early_suspend(&devfreq_early_suspend_desc);
+	/*
+	* disable DFS before DISPC late resume
+	*/
+	register_early_suspend(&devfreq_enable_desc);
+
+	spin_lock(&dfs_req_lock);
+	dfs_req_timeout = REQ_TIMEOUT_DEF;
+	spin_unlock(&dfs_req_lock);
+out:
+	return err;
+}
+
+static int devfreq_ondemand_stop(struct devfreq *devfreq)
+{
+	int err = 0;
+	if(devfreq->data){
+		kfree(devfreq->data);
+	}
+
+	return err;
+
+}
+/************ userspace interface *****************/
+
+static int devfreq_ondemand_func(struct devfreq *df,
+					unsigned long *freq)
+{
+	struct devfreq_dev_status stat;
+	int err = df->profile->get_dev_status(df->dev.parent, &stat);
+	unsigned long long a, b;
+	unsigned int dfso_upthreshold = DFO_UPTHRESHOLD;
+	unsigned int dfso_downdifferential = DFO_DOWNDIFFERENCTIAL;
+	struct userspace_data *data = df->data;
+	unsigned long max = (df->max_freq) ? df->max_freq : UINT_MAX;
+	unsigned long req_freq;
+
+	if (err)
+		return err;
+
+	if(user_requests.req_quirk &&
+		stat.current_frequency==df->min_freq){
+		/*
+		* QUIRK: only set frequency larger than minimum
+		*/
+		*freq = df->min_freq + 1;
+		pr_debug("*** %s, req_quirk, freq:%lu, return ***\n", __func__, *freq);
+		return 0;
+	}
+	/*
+	* TODO: add request frequency
+	*/
+	req_freq = user_requests.req_sum + user_requests.req_timeout;
+
+	if (data) {
+		if (data->enable==false || !(data->devfreq_enable) ||
+					data->set_freq || !gov_eb){
+			if(user_requests.ddr_freq_after_req == 0)
+				user_requests.ddr_freq_after_req = max;
+			*freq = (data->set_freq?data->set_freq:user_requests.ddr_freq_after_req);
+			pr_debug("*** %s, data->enable:%d, data->set_freq:%u, gov_eb:%d ***\n",
+				__func__, data->enable, data->set_freq, gov_eb );
+			return 0;
+		}
+		if (data->upthreshold)
+			dfso_upthreshold = data->upthreshold;
+		if (data->downdifferential)
+			dfso_downdifferential = data->downdifferential;
+	}else{
+		printk("*** %s, data is NULL ***\n", __func__ );
+	}
+
+	if (dfso_upthreshold > 100 ||
+	    dfso_upthreshold < dfso_downdifferential){
+		printk("*** %s, dfso_upthreshold:%u, dfso_downdifferential:%u ***\n",
+				__func__, dfso_upthreshold, dfso_downdifferential );
+		return -EINVAL;
+	}
+
+	/* Assume MAX if it is going to be divided by zero */
+	if (stat.total_time == 0) {
+		*freq = max;
+		user_requests.ddr_freq_after_req = *freq;
+		pr_debug("*** %s, stat.total_time == 0, freq:%lu ***\n", __func__, *freq);
+		return 0;
+	}
+
+	/* Prevent overflow */
+	if (stat.busy_time >= (1 << 24) || stat.total_time >= (1 << 24)) {
+		stat.busy_time >>= 7;
+		stat.total_time >>= 7;
+	}
+
+	/* Set MAX if it's busy enough */
+	if (stat.busy_time * 100 >
+	    stat.total_time * dfso_upthreshold) {
+		*freq = max;
+		user_requests.ddr_freq_after_req = *freq;
+		pr_debug("*** %s, set max freq:%lu ***\n", __func__, *freq);
+		return 0;
+	}
+
+	/* Set MAX if we do not know the initial frequency */
+	if (stat.current_frequency == 0) {
+		*freq = max;
+		user_requests.ddr_freq_after_req = *freq;
+		pr_debug("*** %s, stat.current_frequency == 0, freq:%lu ***\n", __func__, *freq);
+		return 0;
+	}
+
+	/* Keep the current frequency */
+	if (stat.busy_time * 100 >
+	    stat.total_time * (dfso_upthreshold - dfso_downdifferential)) {
+		*freq = stat.current_frequency + req_freq;
+		user_requests.ddr_freq_after_req = *freq;
+		pr_debug("*** %s, Keep the current frequency %lu, req_freq:%lu ***\n",
+				__func__, stat.current_frequency, req_freq);
+		return 0;
+	}
+
+	/* Set the desired frequency based on the load */
+	a = stat.busy_time;
+	a *= stat.current_frequency;
+	b = div_u64(a, stat.total_time);
+	b *= 100;
+	b = div_u64(b, (dfso_upthreshold - dfso_downdifferential / 2));
+	*freq = (unsigned long) b + req_freq;
+	user_requests.ddr_freq_after_req = *freq;
+	pr_debug("*** %s, calculate freq:%lu, req_freq:%lu ***\n",
+				__func__, (unsigned long)b, req_freq);
+
+	if (df->min_freq && *freq < df->min_freq)
+		*freq = df->min_freq;
+	if (df->max_freq && *freq > df->max_freq)
+		*freq = df->max_freq;
+
+	return 0;
+}
+
+static int devfreq_ondemand_handler(struct devfreq *devfreq,
+				unsigned int event, void *data)
+{
+	switch (event) {
+	case DEVFREQ_GOV_START:
+		devfreq_ondemand_start(devfreq);
+		devfreq_monitor_start(devfreq);
+		break;
+
+	case DEVFREQ_GOV_STOP:
+		devfreq_monitor_stop(devfreq);
+		//devfreq_ondemand_stop(devfreq);
+		break;
+
+	case DEVFREQ_GOV_INTERVAL:
+		devfreq_interval_update(devfreq, (unsigned int *)data);
+		break;
+
+	case DEVFREQ_GOV_SUSPEND:
+		devfreq_monitor_suspend(devfreq);
+		break;
+
+	case DEVFREQ_GOV_RESUME:
+		devfreq_monitor_resume(devfreq);
+		break;
+
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+const struct devfreq_governor devfreq_ondemand = {
+	.name = "ondemand",
+	.get_target_freq = devfreq_ondemand_func,
+	.event_handler = devfreq_ondemand_handler,
+};
+
+static int __init devfreq_ondemand_init(void)
+{
+	return devfreq_add_governor(&devfreq_ondemand);
+}
+subsys_initcall(devfreq_ondemand_init);
+
+static void __exit devfreq_ondemand_exit(void)
+{
+	int ret;
+
+	ret = devfreq_remove_governor(&devfreq_ondemand);
+	if (ret)
+		pr_err("%s: failed remove governor %d\n", __func__, ret);
+
+	return;
+}
+module_exit(devfreq_ondemand_exit);
+MODULE_LICENSE("GPL");