[mirror_ubuntu-jammy-kernel.git] / drivers / devfreq / governor_simpleondemand.c

/*
 *  linux/drivers/devfreq/governor_simpleondemand.c
 *
 *  Copyright (C) 2011 Samsung Electronics
 *	MyungJoo Ham <myungjoo.ham@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/errno.h>
#include <linux/devfreq.h>
#include <linux/math64.h>
#include "governor.h"

/* Default constants for DevFreq-Simple-Ondemand (DFSO) */
#define DFSO_UPTHRESHOLD	(90)
#define DFSO_DOWNDIFFERENCTIAL	(5)
static int devfreq_simple_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 = DFSO_UPTHRESHOLD;
	unsigned int dfso_downdifferential = DFSO_DOWNDIFFERENCTIAL;
	struct devfreq_simple_ondemand_data *data = df->data;
	unsigned long max = (df->max_freq) ? df->max_freq : UINT_MAX;

	if (err)
		return err;

	if (data) {
		if (data->upthreshold)
			dfso_upthreshold = data->upthreshold;
		if (data->downdifferential)
			dfso_downdifferential = data->downdifferential;
	}
	if (dfso_upthreshold > 100 ||
	    dfso_upthreshold < dfso_downdifferential)
		return -EINVAL;

	/* Assume MAX if it is going to be divided by zero */
	if (stat.total_time == 0) {
		*freq = max;
		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;
		return 0;
	}

	/* Set MAX if we do not know the initial frequency */
	if (stat.current_frequency == 0) {
		*freq = max;
		return 0;
	}

	/* Keep the current frequency */
	if (stat.busy_time * 100 >
	    stat.total_time * (dfso_upthreshold - dfso_downdifferential)) {
		*freq = stat.current_frequency;
		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;

	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_simple_ondemand_handler(struct devfreq *devfreq,
				unsigned int event, void *data)
{
	switch (event) {
	case DEVFREQ_GOV_START:
		devfreq_monitor_start(devfreq);
		break;

	case DEVFREQ_GOV_STOP:
		devfreq_monitor_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;
}

static struct devfreq_governor devfreq_simple_ondemand = {
	.name = "simple_ondemand",
	.get_target_freq = devfreq_simple_ondemand_func,
	.event_handler = devfreq_simple_ondemand_handler,
};

static int __init devfreq_simple_ondemand_init(void)
{
	return devfreq_add_governor(&devfreq_simple_ondemand);
}
subsys_initcall(devfreq_simple_ondemand_init);

static void __exit devfreq_simple_ondemand_exit(void)
{
	int ret;

	ret = devfreq_remove_governor(&devfreq_simple_ondemand);
	if (ret)
		pr_err("%s: failed remove governor %d\n", __func__, ret);

	return;
}
module_exit(devfreq_simple_ondemand_exit);
Commit	Line	Data
ce26c5bb MH	1	/*
	2	* linux/drivers/devfreq/governor_simpleondemand.c
	3	*
	4	* Copyright (C) 2011 Samsung Electronics
	5	* MyungJoo Ham <myungjoo.ham@samsung.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/errno.h>
	13	#include <linux/devfreq.h>
	14	#include <linux/math64.h>
7e6fdd4b	15	#include "governor.h"
ce26c5bb MH	16
	17	/* Default constants for DevFreq-Simple-Ondemand (DFSO) */
	18	#define DFSO_UPTHRESHOLD (90)
	19	#define DFSO_DOWNDIFFERENCTIAL (5)
	20	static int devfreq_simple_ondemand_func(struct devfreq *df,
	21	unsigned long *freq)
	22	{
	23	struct devfreq_dev_status stat;
	24	int err = df->profile->get_dev_status(df->dev.parent, &stat);
	25	unsigned long long a, b;
	26	unsigned int dfso_upthreshold = DFSO_UPTHRESHOLD;
	27	unsigned int dfso_downdifferential = DFSO_DOWNDIFFERENCTIAL;
	28	struct devfreq_simple_ondemand_data *data = df->data;
6530b9de	29	unsigned long max = (df->max_freq) ? df->max_freq : UINT_MAX;
ce26c5bb MH	30
	31	if (err)
	32	return err;
	33
	34	if (data) {
	35	if (data->upthreshold)
	36	dfso_upthreshold = data->upthreshold;
	37	if (data->downdifferential)
	38	dfso_downdifferential = data->downdifferential;
	39	}
	40	if (dfso_upthreshold > 100 \|\|
	41	dfso_upthreshold < dfso_downdifferential)
	42	return -EINVAL;
	43
	44	/* Assume MAX if it is going to be divided by zero */
	45	if (stat.total_time == 0) {
6530b9de	46	*freq = max;
ce26c5bb MH	47	return 0;
	48	}
	49
	50	/* Prevent overflow */
	51	if (stat.busy_time >= (1 << 24) \|\| stat.total_time >= (1 << 24)) {
	52	stat.busy_time >>= 7;
	53	stat.total_time >>= 7;
	54	}
	55
	56	/* Set MAX if it's busy enough */
	57	if (stat.busy_time * 100 >
	58	stat.total_time * dfso_upthreshold) {
6530b9de	59	*freq = max;
ce26c5bb MH	60	return 0;
	61	}
	62
	63	/* Set MAX if we do not know the initial frequency */
	64	if (stat.current_frequency == 0) {
6530b9de	65	*freq = max;
ce26c5bb MH	66	return 0;
	67	}
	68
	69	/* Keep the current frequency */
	70	if (stat.busy_time * 100 >
	71	stat.total_time * (dfso_upthreshold - dfso_downdifferential)) {
	72	*freq = stat.current_frequency;
	73	return 0;
	74	}
	75
	76	/* Set the desired frequency based on the load */
	77	a = stat.busy_time;
	78	a *= stat.current_frequency;
	79	b = div_u64(a, stat.total_time);
	80	b *= 100;
	81	b = div_u64(b, (dfso_upthreshold - dfso_downdifferential / 2));
	82	*freq = (unsigned long) b;
	83
6530b9de MH	84	if (df->min_freq && *freq < df->min_freq)
	85	*freq = df->min_freq;
	86	if (df->max_freq && *freq > df->max_freq)
	87	*freq = df->max_freq;
	88
ce26c5bb MH	89	return 0;
	90	}
	91
7e6fdd4b RV	92	static int devfreq_simple_ondemand_handler(struct devfreq *devfreq,
	93	unsigned int event, void *data)
	94	{
	95	switch (event) {
	96	case DEVFREQ_GOV_START:
	97	devfreq_monitor_start(devfreq);
	98	break;
	99
	100	case DEVFREQ_GOV_STOP:
	101	devfreq_monitor_stop(devfreq);
	102	break;
	103
	104	case DEVFREQ_GOV_INTERVAL:
	105	devfreq_interval_update(devfreq, (unsigned int *)data);
	106	break;
206c30cf RV	107
	108	case DEVFREQ_GOV_SUSPEND:
	109	devfreq_monitor_suspend(devfreq);
	110	break;
	111
	112	case DEVFREQ_GOV_RESUME:
	113	devfreq_monitor_resume(devfreq);
	114	break;
	115
7e6fdd4b RV	116	default:
	117	break;
	118	}
	119
	120	return 0;
	121	}
	122
1b5c1be2	123	static struct devfreq_governor devfreq_simple_ondemand = {
ce26c5bb MH	124	.name = "simple_ondemand",
ce26c5bb MH	125	.get_target_freq = devfreq_simple_ondemand_func,
7e6fdd4b	126	.event_handler = devfreq_simple_ondemand_handler,
ce26c5bb	127	};
83116e66 NM	128
	129	static int __init devfreq_simple_ondemand_init(void)
	130	{
	131	return devfreq_add_governor(&devfreq_simple_ondemand);
	132	}
	133	subsys_initcall(devfreq_simple_ondemand_init);
	134
	135	static void __exit devfreq_simple_ondemand_exit(void)
	136	{
	137	int ret;
	138
	139	ret = devfreq_remove_governor(&devfreq_simple_ondemand);
	140	if (ret)
	141	pr_err("%s: failed remove governor %d\n", __func__, ret);
	142
	143	return;
	144	}
	145	module_exit(devfreq_simple_ondemand_exit);