cpufreq: governors: remove redundant code

 * published by the Free Software Foundation.

 */

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/cpufreq.h>

#include <linux/cpu.h>

#include <linux/jiffies.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/kernel_stat.h>

#include <linux/kobject.h>

#include <linux/module.h>

#include <linux/mutex.h>

#include <linux/hrtimer.h>

#include <linux/tick.h>

#include <linux/ktime.h>

#include <linux/sched.h>

#include <linux/notifier.h>

#include <linux/percpu-defs.h>

#include <linux/sysfs.h>

#include <linux/types.h>

/*

 * dbs is used in this file as a shortform for demandbased switching

 * It helps to keep variable names smaller, simpler

 */

#include "cpufreq_governor.h"

/* Conservative governor macors */

#define DEF_FREQUENCY_UP_THRESHOLD		(80)

#define DEF_FREQUENCY_DOWN_THRESHOLD		(20)

#define DEF_SAMPLING_DOWN_FACTOR		(1)

#define MAX_SAMPLING_DOWN_FACTOR		(10)

static struct dbs_data cs_dbs_data;

static DEFINE_PER_CPU(struct cs_cpu_dbs_info_s, cs_cpu_dbs_info);

static struct cs_dbs_tuners cs_tuners = {

	.up_threshold = DEF_FREQUENCY_UP_THRESHOLD,

	.down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,

	.sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,

	.ignore_nice = 0,

	.freq_step = 5,

};

/*

 * The polling frequency of this governor depends on the capability of

 * the processor. Default polling frequency is 1000 times the transition

 * latency of the processor. The governor will work on any processor with

 * transition latency <= 10mS, using appropriate sampling

 * rate.

 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)

 * this governor will not work.

 * All times here are in uS.

 * Every sampling_rate, we check, if current idle time is less than 20%

 * (default), then we try to increase frequency Every sampling_rate *

 * sampling_down_factor, we check, if current idle time is more than 80%, then

 * we try to decrease frequency

 *

 * Any frequency increase takes it to the maximum frequency. Frequency reduction

 * happens at minimum steps of 5% (default) of maximum frequency

 */

#define MIN_SAMPLING_RATE_RATIO			(2)

static void cs_check_cpu(int cpu, unsigned int load)

{

	struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, cpu);

	struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy;

	unsigned int freq_target;

static unsigned int min_sampling_rate;

	/*

	 * break out if we 'cannot' reduce the speed as the user might

	 * want freq_step to be zero

	 */

	if (cs_tuners.freq_step == 0)

		return;

	/* Check for frequency increase */

	if (load > cs_tuners.up_threshold) {

		dbs_info->down_skip = 0;

		/* if we are already at full speed then break out early */

		if (dbs_info->requested_freq == policy->max)

			return;

		freq_target = (cs_tuners.freq_step * policy->max) / 100;

		/* max freq cannot be less than 100. But who knows.... */

		if (unlikely(freq_target == 0))

			freq_target = 5;

		dbs_info->requested_freq += freq_target;

		if (dbs_info->requested_freq > policy->max)

			dbs_info->requested_freq = policy->max;

		__cpufreq_driver_target(policy, dbs_info->requested_freq,

			CPUFREQ_RELATION_H);

		return;

	}

#define LATENCY_MULTIPLIER			(1000)

#define MIN_LATENCY_MULTIPLIER			(100)

#define DEF_SAMPLING_DOWN_FACTOR		(1)

#define MAX_SAMPLING_DOWN_FACTOR		(10)

#define TRANSITION_LATENCY_LIMIT		(10 * 1000 * 1000)

static void do_dbs_timer(struct work_struct *work);

struct cpu_dbs_info_s {

	cputime64_t prev_cpu_idle;

	cputime64_t prev_cpu_wall;

	cputime64_t prev_cpu_nice;

	struct cpufreq_policy *cur_policy;

	struct delayed_work work;

	unsigned int down_skip;

	unsigned int requested_freq;

	int cpu;

	unsigned int enable:1;

	/*

	 * percpu mutex that serializes governor limit change with

	 * do_dbs_timer invocation. We do not want do_dbs_timer to run

	 * when user is changing the governor or limits.

	 * The optimal frequency is the frequency that is the lowest that can

	 * support the current CPU usage without triggering the up policy. To be

	 * safe, we focus 10 points under the threshold.

	 */

	struct mutex timer_mutex;

};

static DEFINE_PER_CPU(struct cpu_dbs_info_s, cs_cpu_dbs_info);

	if (load < (cs_tuners.down_threshold - 10)) {

		freq_target = (cs_tuners.freq_step * policy->max) / 100;

static unsigned int dbs_enable;	/* number of CPUs using this policy */

		dbs_info->requested_freq -= freq_target;

		if (dbs_info->requested_freq < policy->min)

			dbs_info->requested_freq = policy->min;

		/*

 * dbs_mutex protects dbs_enable in governor start/stop.

		 * if we cannot reduce the frequency anymore, break out early

		 */

static DEFINE_MUTEX(dbs_mutex);

static struct dbs_tuners {

	unsigned int sampling_rate;

	unsigned int sampling_down_factor;

	unsigned int up_threshold;

	unsigned int down_threshold;

	unsigned int ignore_nice;

	unsigned int freq_step;

} dbs_tuners_ins = {

	.up_threshold = DEF_FREQUENCY_UP_THRESHOLD,

	.down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,

	.sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,

	.ignore_nice = 0,

	.freq_step = 5,

};

		if (policy->cur == policy->min)

			return;

/* keep track of frequency transitions */

static int

dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,

		__cpufreq_driver_target(policy, dbs_info->requested_freq,

				CPUFREQ_RELATION_H);

		return;

	}

}

static void cs_dbs_timer(struct work_struct *work)

{

	struct cs_cpu_dbs_info_s *dbs_info = container_of(work,

			struct cs_cpu_dbs_info_s, cdbs.work.work);

	unsigned int cpu = dbs_info->cdbs.cpu;

	int delay = delay_for_sampling_rate(cs_tuners.sampling_rate);

	mutex_lock(&dbs_info->cdbs.timer_mutex);

	dbs_check_cpu(&cs_dbs_data, cpu);

	schedule_delayed_work_on(cpu, &dbs_info->cdbs.work, delay);

	mutex_unlock(&dbs_info->cdbs.timer_mutex);

}

static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,

		void *data)

{

	struct cpufreq_freqs *freq = data;

	struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cs_cpu_dbs_info,

							freq->cpu);

	struct cs_cpu_dbs_info_s *dbs_info =

					&per_cpu(cs_cpu_dbs_info, freq->cpu);

	struct cpufreq_policy *policy;

	if (!this_dbs_info->enable)

	if (!dbs_info->enable)

		return 0;

	policy = this_dbs_info->cur_policy;

	policy = dbs_info->cdbs.cur_policy;

	/*

	 * we only care if our internally tracked freq moves outside

	 * the 'valid' ranges of freqency available to us otherwise

	 * we do not change it

	 * we only care if our internally tracked freq moves outside the 'valid'

	 * ranges of freqency available to us otherwise we do not change it

	*/

	if (this_dbs_info->requested_freq > policy->max

			|| this_dbs_info->requested_freq < policy->min)

		this_dbs_info->requested_freq = freq->new;

	if (dbs_info->requested_freq > policy->max

			|| dbs_info->requested_freq < policy->min)

		dbs_info->requested_freq = freq->new;

	return 0;

}

static struct notifier_block dbs_cpufreq_notifier_block = {

	.notifier_call = dbs_cpufreq_notifier

};

/************************** sysfs interface ************************/

static ssize_t show_sampling_rate_min(struct kobject *kobj,

				      struct attribute *attr, char *buf)

{

	return sprintf(buf, "%u\n", min_sampling_rate);

	return sprintf(buf, "%u\n", cs_dbs_data.min_sampling_rate);

}

define_one_global_ro(sampling_rate_min);

/* cpufreq_conservative Governor Tunables */

#define show_one(file_name, object)					\

static ssize_t show_##file_name						\

(struct kobject *kobj, struct attribute *attr, char *buf)		\

{									\

	return sprintf(buf, "%u\n", dbs_tuners_ins.object);		\

}

show_one(sampling_rate, sampling_rate);

show_one(sampling_down_factor, sampling_down_factor);

show_one(up_threshold, up_threshold);

show_one(down_threshold, down_threshold);

show_one(ignore_nice_load, ignore_nice);

show_one(freq_step, freq_step);

static ssize_t store_sampling_down_factor(struct kobject *a,

					  struct attribute *b,

					  const char *buf, size_t count)

	if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)

		return -EINVAL;

	dbs_tuners_ins.sampling_down_factor = input;

	cs_tuners.sampling_down_factor = input;

	return count;

}

	if (ret != 1)

		return -EINVAL;

	dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate);

	cs_tuners.sampling_rate = max(input, cs_dbs_data.min_sampling_rate);

	return count;

}

	int ret;

	ret = sscanf(buf, "%u", &input);

	if (ret != 1 || input > 100 ||

			input <= dbs_tuners_ins.down_threshold)

	if (ret != 1 || input > 100 || input <= cs_tuners.down_threshold)

		return -EINVAL;

	dbs_tuners_ins.up_threshold = input;

	cs_tuners.up_threshold = input;

	return count;

}

	/* cannot be lower than 11 otherwise freq will not fall */

	if (ret != 1 || input < 11 || input > 100 ||

			input >= dbs_tuners_ins.up_threshold)

			input >= cs_tuners.up_threshold)

		return -EINVAL;

	dbs_tuners_ins.down_threshold = input;

	cs_tuners.down_threshold = input;

	return count;

}

static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b,

				      const char *buf, size_t count)

{

	unsigned int input;

	unsigned int input, j;

	int ret;

	unsigned int j;

	ret = sscanf(buf, "%u", &input);

	if (ret != 1)

		return -EINVAL;

	if (input > 1)

		input = 1;

	if (input == dbs_tuners_ins.ignore_nice) /* nothing to do */

	if (input == cs_tuners.ignore_nice) /* nothing to do */

		return count;

	dbs_tuners_ins.ignore_nice = input;

	cs_tuners.ignore_nice = input;

	/* we need to re-evaluate prev_cpu_idle */

	for_each_online_cpu(j) {

		struct cpu_dbs_info_s *dbs_info;

		struct cs_cpu_dbs_info_s *dbs_info;

		dbs_info = &per_cpu(cs_cpu_dbs_info, j);

		dbs_info->prev_cpu_idle = get_cpu_idle_time(j,

						&dbs_info->prev_cpu_wall);

		if (dbs_tuners_ins.ignore_nice)

			dbs_info->prev_cpu_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE];

		dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,

						&dbs_info->cdbs.prev_cpu_wall);

		if (cs_tuners.ignore_nice)

			dbs_info->cdbs.prev_cpu_nice =

				kcpustat_cpu(j).cpustat[CPUTIME_NICE];

	}

	return count;

}

	if (input > 100)

		input = 100;

	/* no need to test here if freq_step is zero as the user might actually

	 * want this, they would be crazy though :) */

	dbs_tuners_ins.freq_step = input;

	/*

	 * no need to test here if freq_step is zero as the user might actually

	 * want this, they would be crazy though :)

	 */

	cs_tuners.freq_step = input;

	return count;

}

show_one(cs, sampling_rate, sampling_rate);

show_one(cs, sampling_down_factor, sampling_down_factor);

show_one(cs, up_threshold, up_threshold);

show_one(cs, down_threshold, down_threshold);

show_one(cs, ignore_nice_load, ignore_nice);

show_one(cs, freq_step, freq_step);

define_one_global_rw(sampling_rate);

define_one_global_rw(sampling_down_factor);

define_one_global_rw(up_threshold);

define_one_global_rw(down_threshold);

define_one_global_rw(ignore_nice_load);

define_one_global_rw(freq_step);

define_one_global_ro(sampling_rate_min);

static struct attribute *dbs_attributes[] = {

	&sampling_rate_min.attr,

	NULL

};

static struct attribute_group dbs_attr_group = {

static struct attribute_group cs_attr_group = {

	.attrs = dbs_attributes,

	.name = "conservative",

};

/************************** sysfs end ************************/

static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)

{

	unsigned int load = 0;

	unsigned int max_load = 0;

	unsigned int freq_target;

	struct cpufreq_policy *policy;

	unsigned int j;

	policy = this_dbs_info->cur_policy;

	/*

	 * Every sampling_rate, we check, if current idle time is less

	 * than 20% (default), then we try to increase frequency

	 * Every sampling_rate*sampling_down_factor, we check, if current

	 * idle time is more than 80%, then we try to decrease frequency

	 *

	 * Any frequency increase takes it to the maximum frequency.

	 * Frequency reduction happens at minimum steps of

	 * 5% (default) of maximum frequency

	 */

	/* Get Absolute Load */

	for_each_cpu(j, policy->cpus) {

		struct cpu_dbs_info_s *j_dbs_info;

		cputime64_t cur_wall_time, cur_idle_time;

		unsigned int idle_time, wall_time;

		j_dbs_info = &per_cpu(cs_cpu_dbs_info, j);

		cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);

define_get_cpu_dbs_routines(cs_cpu_dbs_info);

		wall_time = (unsigned int)

			(cur_wall_time - j_dbs_info->prev_cpu_wall);

		j_dbs_info->prev_cpu_wall = cur_wall_time;

		idle_time = (unsigned int)

			(cur_idle_time - j_dbs_info->prev_cpu_idle);

		j_dbs_info->prev_cpu_idle = cur_idle_time;

		if (dbs_tuners_ins.ignore_nice) {

			u64 cur_nice;

			unsigned long cur_nice_jiffies;

			cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE] -

					 j_dbs_info->prev_cpu_nice;

			/*

			 * Assumption: nice time between sampling periods will

			 * be less than 2^32 jiffies for 32 bit sys

			 */

			cur_nice_jiffies = (unsigned long)

					cputime64_to_jiffies64(cur_nice);

			j_dbs_info->prev_cpu_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE];

			idle_time += jiffies_to_usecs(cur_nice_jiffies);

		}

		if (unlikely(!wall_time || wall_time < idle_time))

			continue;

		load = 100 * (wall_time - idle_time) / wall_time;

		if (load > max_load)

			max_load = load;

	}

	/*

	 * break out if we 'cannot' reduce the speed as the user might

	 * want freq_step to be zero

	 */

	if (dbs_tuners_ins.freq_step == 0)

		return;

	/* Check for frequency increase */

	if (max_load > dbs_tuners_ins.up_threshold) {

		this_dbs_info->down_skip = 0;

		/* if we are already at full speed then break out early */

		if (this_dbs_info->requested_freq == policy->max)

			return;

		freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100;

		/* max freq cannot be less than 100. But who knows.... */

		if (unlikely(freq_target == 0))

			freq_target = 5;

		this_dbs_info->requested_freq += freq_target;

		if (this_dbs_info->requested_freq > policy->max)

			this_dbs_info->requested_freq = policy->max;

		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,

			CPUFREQ_RELATION_H);

		return;

	}

	/*

	 * The optimal frequency is the frequency that is the lowest that

	 * can support the current CPU usage without triggering the up

	 * policy. To be safe, we focus 10 points under the threshold.

	 */

	if (max_load < (dbs_tuners_ins.down_threshold - 10)) {

		freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100;

		this_dbs_info->requested_freq -= freq_target;

		if (this_dbs_info->requested_freq < policy->min)

			this_dbs_info->requested_freq = policy->min;

		/*

		 * if we cannot reduce the frequency anymore, break out early

		 */

		if (policy->cur == policy->min)

			return;

		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,

				CPUFREQ_RELATION_H);

		return;

	}

}

static void do_dbs_timer(struct work_struct *work)

{

	struct cpu_dbs_info_s *dbs_info =

		container_of(work, struct cpu_dbs_info_s, work.work);

	unsigned int cpu = dbs_info->cpu;

	/* We want all CPUs to do sampling nearly on same jiffy */

	int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);

	delay -= jiffies % delay;

	mutex_lock(&dbs_info->timer_mutex);

	dbs_check_cpu(dbs_info);

	schedule_delayed_work_on(cpu, &dbs_info->work, delay);

	mutex_unlock(&dbs_info->timer_mutex);

}

static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)

{

	/* We want all CPUs to do sampling nearly on same jiffy */

	int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);

	delay -= jiffies % delay;

static struct notifier_block cs_cpufreq_notifier_block = {

	.notifier_call = dbs_cpufreq_notifier,

};

	dbs_info->enable = 1;

	INIT_DEFERRABLE_WORK(&dbs_info->work, do_dbs_timer);

	schedule_delayed_work_on(dbs_info->cpu, &dbs_info->work, delay);

}

static struct cs_ops cs_ops = {

	.notifier_block = &cs_cpufreq_notifier_block,

};

static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)

{

	dbs_info->enable = 0;

	cancel_delayed_work_sync(&dbs_info->work);

}

static struct dbs_data cs_dbs_data = {

	.governor = GOV_CONSERVATIVE,

	.attr_group = &cs_attr_group,

	.tuners = &cs_tuners,

	.get_cpu_cdbs = get_cpu_cdbs,

	.get_cpu_dbs_info_s = get_cpu_dbs_info_s,

	.gov_dbs_timer = cs_dbs_timer,

	.gov_check_cpu = cs_check_cpu,

	.gov_ops = &cs_ops,

};

static int cpufreq_governor_dbs(struct cpufreq_policy *policy,

static int cs_cpufreq_governor_dbs(struct cpufreq_policy *policy,

				   unsigned int event)

{

	unsigned int cpu = policy->cpu;

	struct cpu_dbs_info_s *this_dbs_info;

	unsigned int j;

	int rc;

	this_dbs_info = &per_cpu(cs_cpu_dbs_info, cpu);

	switch (event) {

	case CPUFREQ_GOV_START:

		if ((!cpu_online(cpu)) || (!policy->cur))

			return -EINVAL;

		mutex_lock(&dbs_mutex);

		for_each_cpu(j, policy->cpus) {

			struct cpu_dbs_info_s *j_dbs_info;

			j_dbs_info = &per_cpu(cs_cpu_dbs_info, j);

			j_dbs_info->cur_policy = policy;

			j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j,

						&j_dbs_info->prev_cpu_wall);

			if (dbs_tuners_ins.ignore_nice)

				j_dbs_info->prev_cpu_nice =

						kcpustat_cpu(j).cpustat[CPUTIME_NICE];

		}

		this_dbs_info->cpu = cpu;

		this_dbs_info->down_skip = 0;

		this_dbs_info->requested_freq = policy->cur;

		mutex_init(&this_dbs_info->timer_mutex);

		dbs_enable++;

		/*

		 * Start the timerschedule work, when this governor

		 * is used for first time

		 */

		if (dbs_enable == 1) {

			unsigned int latency;

			/* policy latency is in nS. Convert it to uS first */

			latency = policy->cpuinfo.transition_latency / 1000;

			if (latency == 0)

				latency = 1;

			rc = sysfs_create_group(cpufreq_global_kobject,

						&dbs_attr_group);

			if (rc) {

				mutex_unlock(&dbs_mutex);

				return rc;

			}

			/*

			 * conservative does not implement micro like ondemand

			 * governor, thus we are bound to jiffes/HZ

			 */

			min_sampling_rate =

				MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10);

			/* Bring kernel and HW constraints together */

			min_sampling_rate = max(min_sampling_rate,

					MIN_LATENCY_MULTIPLIER * latency);

			dbs_tuners_ins.sampling_rate =

				max(min_sampling_rate,

				    latency * LATENCY_MULTIPLIER);

			cpufreq_register_notifier(

					&dbs_cpufreq_notifier_block,

					CPUFREQ_TRANSITION_NOTIFIER);

		}

		mutex_unlock(&dbs_mutex);

		dbs_timer_init(this_dbs_info);

		break;

	case CPUFREQ_GOV_STOP:

		dbs_timer_exit(this_dbs_info);

		mutex_lock(&dbs_mutex);

		dbs_enable--;

		mutex_destroy(&this_dbs_info->timer_mutex);

		/*

		 * Stop the timerschedule work, when this governor

		 * is used for first time

		 */

		if (dbs_enable == 0)

			cpufreq_unregister_notifier(

					&dbs_cpufreq_notifier_block,

					CPUFREQ_TRANSITION_NOTIFIER);

		mutex_unlock(&dbs_mutex);

		if (!dbs_enable)

			sysfs_remove_group(cpufreq_global_kobject,

					   &dbs_attr_group);

		break;

	case CPUFREQ_GOV_LIMITS:

		mutex_lock(&this_dbs_info->timer_mutex);

		if (policy->max < this_dbs_info->cur_policy->cur)

			__cpufreq_driver_target(

					this_dbs_info->cur_policy,

					policy->max, CPUFREQ_RELATION_H);

		else if (policy->min > this_dbs_info->cur_policy->cur)

			__cpufreq_driver_target(

					this_dbs_info->cur_policy,

					policy->min, CPUFREQ_RELATION_L);

		dbs_check_cpu(this_dbs_info);

		mutex_unlock(&this_dbs_info->timer_mutex);

		break;

	}

	return 0;

	return cpufreq_governor_dbs(&cs_dbs_data, policy, event);

}

#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE

#endif

struct cpufreq_governor cpufreq_gov_conservative = {

	.name			= "conservative",

	.governor		= cpufreq_governor_dbs,

	.governor		= cs_cpufreq_governor_dbs,

	.max_transition_latency	= TRANSITION_LATENCY_LIMIT,

	.owner			= THIS_MODULE,

};

static int __init cpufreq_gov_dbs_init(void)

{

	mutex_init(&cs_dbs_data.mutex);

	return cpufreq_register_governor(&cpufreq_gov_conservative);

}

	cpufreq_unregister_governor(&cpufreq_gov_conservative);

}

MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");

MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for "

		"Low Latency Frequency Transition capable processors "

/*

 * drivers/cpufreq/cpufreq_governor.h

 *

 * Header file for CPUFreq governors common code

 *

 * Copyright	(C) 2001 Russell King

 *		(C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.

 *		(C) 2003 Jun Nakajima <jun.nakajima@intel.com>

 *		(C) 2009 Alexander Clouter <alex@digriz.org.uk>

 *		(c) 2012 Viresh Kumar <viresh.kumar@linaro.org>