Release 4.7 drivers/cpufreq/cpufreq_conservative.c

Directory: drivers/cpufreq
/*
 *  drivers/cpufreq/cpufreq_conservative.c
 *
 *  Copyright (C)  2001 Russell King
 *            (C)  2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
 *                      Jun Nakajima <jun.nakajima@intel.com>
 *            (C)  2009 Alexander Clouter <alex@digriz.org.uk>
 *
 * 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/slab.h>
#include "cpufreq_governor.h"


struct cs_policy_dbs_info {
	
struct policy_dbs_info policy_dbs;
	
unsigned int down_skip;
	
unsigned int requested_freq;
};



static inline struct cs_policy_dbs_info *to_dbs_info(struct policy_dbs_info *policy_dbs)
{
	return container_of(policy_dbs, struct cs_policy_dbs_info, policy_dbs);
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%


struct cs_dbs_tuners {
	
unsigned int down_threshold;
	
unsigned int freq_step;
};

/* Conservative governor macros */

#define DEF_FREQUENCY_UP_THRESHOLD		(80)

#define DEF_FREQUENCY_DOWN_THRESHOLD		(20)

#define DEF_FREQUENCY_STEP			(5)

#define DEF_SAMPLING_DOWN_FACTOR		(1)

#define MAX_SAMPLING_DOWN_FACTOR		(10)



static inline unsigned int get_freq_target(struct cs_dbs_tuners *cs_tuners,
					   struct cpufreq_policy *policy)
{
	unsigned int 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 = DEF_FREQUENCY_STEP;

	return freq_target;
}

Contributors
Person Tokens Prop Commits CommitProp
stratos karafotis stratos karafotis 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%

/*
 * 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%
 * (default), 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
 */


static unsigned int cs_dbs_timer(struct cpufreq_policy *policy)
{
	struct policy_dbs_info *policy_dbs = policy->governor_data;
	struct cs_policy_dbs_info *dbs_info = to_dbs_info(policy_dbs);
	struct dbs_data *dbs_data = policy_dbs->dbs_data;
	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
	unsigned int load = dbs_update(policy);

	/*
         * break out if we 'cannot' reduce the speed as the user might
         * want freq_step to be zero
         */
	if (cs_tuners->freq_step == 0)
		goto out;

	/* Check for frequency increase */
	if (load > dbs_data->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)
			goto out;

		dbs_info->requested_freq += get_freq_target(cs_tuners, policy);

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

		__cpufreq_driver_target(policy, dbs_info->requested_freq,
			CPUFREQ_RELATION_H);
		goto out;
	}

	/* if sampling_down_factor is active break out early */
	if (++dbs_info->down_skip < dbs_data->sampling_down_factor)
		goto out;
	dbs_info->down_skip = 0;

	/* Check for frequency decrease */
	if (load < cs_tuners->down_threshold) {
		unsigned int freq_target;
		/*
                 * if we cannot reduce the frequency anymore, break out early
                 */
		if (policy->cur == policy->min)
			goto out;

		freq_target = get_freq_target(cs_tuners, policy);
		if (dbs_info->requested_freq > freq_target)
			dbs_info->requested_freq -= freq_target;
		else
			dbs_info->requested_freq = policy->min;

		__cpufreq_driver_target(policy, dbs_info->requested_freq,
				CPUFREQ_RELATION_L);
	}

 out:
	return dbs_data->sampling_rate;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 85 34.84% 5 29.41%
rafael j. wysocki rafael j. wysocki 50 20.49% 3 17.65%
xiaoguang chen xiaoguang chen 47 19.26% 2 11.76%
stratos karafotis stratos karafotis 30 12.30% 3 17.65%
elias oltmanns elias oltmanns 17 6.97% 1 5.88%
namhyung kim namhyung kim 12 4.92% 2 11.76%
alexander clouter alexander clouter 3 1.23% 1 5.88%
Total 244 100.00% 17 100.00%

static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
				void *data);


static struct notifier_block cs_cpufreq_notifier_block = {
	.notifier_call = dbs_cpufreq_notifier,
};

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

static struct dbs_governor cs_dbs_gov;



static ssize_t store_sampling_down_factor(struct gov_attr_set *attr_set,
					  const char *buf, size_t count)
{
	struct dbs_data *dbs_data = to_dbs_data(attr_set);
	unsigned int input;
	int ret;
	ret = sscanf(buf, "%u", &input);

	if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
		return -EINVAL;

	dbs_data->sampling_down_factor = input;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 53 70.67% 3 42.86%
rafael j. wysocki rafael j. wysocki 12 16.00% 1 14.29%
alexander clouter alexander clouter 5 6.67% 1 14.29%
dave jones dave jones 4 5.33% 1 14.29%
venkatesh pallipadi venkatesh pallipadi 1 1.33% 1 14.29%
Total 75 100.00% 7 100.00%



static ssize_t store_up_threshold(struct gov_attr_set *attr_set,
				  const char *buf, size_t count)
{
	struct dbs_data *dbs_data = to_dbs_data(attr_set);
	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
	unsigned int input;
	int ret;
	ret = sscanf(buf, "%u", &input);

	if (ret != 1 || input > 100 || input <= cs_tuners->down_threshold)
		return -EINVAL;

	dbs_data->up_threshold = input;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 59 68.60% 3 50.00%
rafael j. wysocki rafael j. wysocki 12 13.95% 1 16.67%
dave jones dave jones 9 10.47% 1 16.67%
alexander clouter alexander clouter 6 6.98% 1 16.67%
Total 86 100.00% 6 100.00%



static ssize_t store_down_threshold(struct gov_attr_set *attr_set,
				    const char *buf, size_t count)
{
	struct dbs_data *dbs_data = to_dbs_data(attr_set);
	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
	unsigned int input;
	int ret;
	ret = sscanf(buf, "%u", &input);

	/* cannot be lower than 11 otherwise freq will not fall */
	if (ret != 1 || input < 11 || input > 100 ||
			input >= dbs_data->up_threshold)
		return -EINVAL;

	cs_tuners->down_threshold = input;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 68 74.73% 3 50.00%
rafael j. wysocki rafael j. wysocki 12 13.19% 1 16.67%
dave jones dave jones 9 9.89% 1 16.67%
alexander clouter alexander clouter 2 2.20% 1 16.67%
Total 91 100.00% 6 100.00%



static ssize_t store_ignore_nice_load(struct gov_attr_set *attr_set,
				      const char *buf, size_t count)
{
	struct dbs_data *dbs_data = to_dbs_data(attr_set);
	unsigned int input;
	int ret;

	ret = sscanf(buf, "%u", &input);
	if (ret != 1)
		return -EINVAL;

	if (input > 1)
		input = 1;

	if (input == dbs_data->ignore_nice_load) /* nothing to do */
		return count;

	dbs_data->ignore_nice_load = input;

	/* we need to re-evaluate prev_cpu_idle */
	gov_update_cpu_data(dbs_data);

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 57 60.00% 4 44.44%
dave jones dave jones 22 23.16% 1 11.11%
rafael j. wysocki rafael j. wysocki 13 13.68% 2 22.22%
jeff garzik jeff garzik 2 2.11% 1 11.11%
alexander clouter alexander clouter 1 1.05% 1 11.11%
Total 95 100.00% 9 100.00%



static ssize_t store_freq_step(struct gov_attr_set *attr_set, const char *buf,
			       size_t count)
{
	struct dbs_data *dbs_data = to_dbs_data(attr_set);
	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
	unsigned int input;
	int ret;
	ret = sscanf(buf, "%u", &input);

	if (ret != 1)
		return -EINVAL;

	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 :)
         */
	cs_tuners->freq_step = input;
	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 60 68.97% 2 28.57%
rafael j. wysocki rafael j. wysocki 12 13.79% 1 14.29%
dave jones dave jones 9 10.34% 1 14.29%
venkatesh pallipadi venkatesh pallipadi 4 4.60% 1 14.29%
thomas renninger thomas renninger 1 1.15% 1 14.29%
alexander clouter alexander clouter 1 1.15% 1 14.29%
Total 87 100.00% 7 100.00%


gov_show_one_common(sampling_rate);

gov_show_one_common(sampling_down_factor);

gov_show_one_common(up_threshold);

gov_show_one_common(ignore_nice_load);

gov_show_one_common(min_sampling_rate);
gov_show_one(cs, down_threshold);
gov_show_one(cs, freq_step);


gov_attr_rw(sampling_rate);

gov_attr_rw(sampling_down_factor);

gov_attr_rw(up_threshold);

gov_attr_rw(ignore_nice_load);

gov_attr_ro(min_sampling_rate);

gov_attr_rw(down_threshold);

gov_attr_rw(freq_step);


static struct attribute *cs_attributes[] = {
	&min_sampling_rate.attr,
	&sampling_rate.attr,
	&sampling_down_factor.attr,
	&up_threshold.attr,
	&down_threshold.attr,
	&ignore_nice_load.attr,
	&freq_step.attr,
	NULL
};

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



static struct policy_dbs_info *cs_alloc(void)
{
	struct cs_policy_dbs_info *dbs_info;

	dbs_info = kzalloc(sizeof(*dbs_info), GFP_KERNEL);
	return dbs_info ? &dbs_info->policy_dbs : NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 38 100.00% 1 100.00%
Total 38 100.00% 1 100.00%



static void cs_free(struct policy_dbs_info *policy_dbs)
{
	kfree(to_dbs_info(policy_dbs));
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



static int cs_init(struct dbs_data *dbs_data, bool notify)
{
	struct cs_dbs_tuners *tuners;

	tuners = kzalloc(sizeof(*tuners), GFP_KERNEL);
	if (!tuners) {
		pr_err("%s: kzalloc failed\n", __func__);
		return -ENOMEM;
	}

	tuners->down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD;
	tuners->freq_step = DEF_FREQUENCY_STEP;
	dbs_data->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
	dbs_data->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;
	dbs_data->ignore_nice_load = 0;

	dbs_data->tuners = tuners;
	dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
		jiffies_to_usecs(10);

	if (notify)
		cpufreq_register_notifier(&cs_cpufreq_notifier_block,
					  CPUFREQ_TRANSITION_NOTIFIER);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 112 100.00% 5 100.00%
Total 112 100.00% 5 100.00%



static void cs_exit(struct dbs_data *dbs_data, bool notify)
{
	if (notify)
		cpufreq_unregister_notifier(&cs_cpufreq_notifier_block,
					    CPUFREQ_TRANSITION_NOTIFIER);

	kfree(dbs_data->tuners);
}

Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 33 100.00% 2 100.00%
Total 33 100.00% 2 100.00%



static void cs_start(struct cpufreq_policy *policy)
{
	struct cs_policy_dbs_info *dbs_info = to_dbs_info(policy->governor_data);

	dbs_info->down_skip = 0;
	dbs_info->requested_freq = policy->cur;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 37 100.00% 2 100.00%
Total 37 100.00% 2 100.00%


static struct dbs_governor cs_dbs_gov = {
	.gov = {
		.name = "conservative",
		.governor = cpufreq_governor_dbs,
		.max_transition_latency = TRANSITION_LATENCY_LIMIT,
		.owner = THIS_MODULE,
        },
	.kobj_type = { .default_attrs = cs_attributes },
	.gov_dbs_timer = cs_dbs_timer,
	.alloc = cs_alloc,
	.free = cs_free,
	.init = cs_init,
	.exit = cs_exit,
	.start = cs_start,
};


#define CPU_FREQ_GOV_CONSERVATIVE	(&cs_dbs_gov.gov)



static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
				void *data)
{
	struct cpufreq_freqs *freq = data;
	struct cpufreq_policy *policy = cpufreq_cpu_get_raw(freq->cpu);
	struct cs_policy_dbs_info *dbs_info;

	if (!policy)
		return 0;

	/* policy isn't governed by conservative governor */
	if (policy->governor != CPU_FREQ_GOV_CONSERVATIVE)
		return 0;

	dbs_info = to_dbs_info(policy->governor_data);
	/*
         * we only care if our internally tracked freq moves outside the 'valid'
         * ranges of frequency available to us otherwise we do not change it
        */
	if (dbs_info->requested_freq > policy->max
			|| dbs_info->requested_freq < policy->min)
		dbs_info->requested_freq = freq->new;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 102 100.00% 2 100.00%
Total 102 100.00% 2 100.00%



static int __init cpufreq_gov_dbs_init(void)
{
	return cpufreq_register_governor(CPU_FREQ_GOV_CONSERVATIVE);
}

Contributors
Person Tokens Prop Commits CommitProp
dave jones dave jones 14 93.33% 1 50.00%
rafael j. wysocki rafael j. wysocki 1 6.67% 1 50.00%
Total 15 100.00% 2 100.00%



static void __exit cpufreq_gov_dbs_exit(void)
{
	cpufreq_unregister_governor(CPU_FREQ_GOV_CONSERVATIVE);
}

Contributors
Person Tokens Prop Commits CommitProp
dave jones dave jones 13 92.86% 1 50.00%
rafael j. wysocki rafael j. wysocki 1 7.14% 1 50.00%
Total 14 100.00% 2 100.00%

MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for "
		"Low Latency Frequency Transition capable processors "
		"optimised for use in a battery environment");
MODULE_LICENSE("GPL");

#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE


struct cpufreq_governor *cpufreq_default_governor(void)
{
	return CPU_FREQ_GOV_CONSERVATIVE;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 12 100.00% 2 100.00%
Total 12 100.00% 2 100.00%


fs_initcall(cpufreq_gov_dbs_init);
#else

module_init(cpufreq_gov_dbs_init);
#endif

module_exit(cpufreq_gov_dbs_exit);
Overall Contributors
Person Tokens Prop Commits CommitProp
viresh kumar viresh kumar 675 46.01% 10 22.73%
rafael j. wysocki rafael j. wysocki 425 28.97% 11 25.00%
dave jones dave jones 133 9.07% 1 2.27%
stratos karafotis stratos karafotis 87 5.93% 4 9.09%
xiaoguang chen xiaoguang chen 47 3.20% 2 4.55%
alexander clouter alexander clouter 30 2.04% 5 11.36%
elias oltmanns elias oltmanns 20 1.36% 1 2.27%
thomas renninger thomas renninger 14 0.95% 3 6.82%
namhyung kim namhyung kim 12 0.82% 2 4.55%
johannes weiner johannes weiner 12 0.82% 1 2.27%
venkatesh pallipadi venkatesh pallipadi 9 0.61% 2 4.55%
jeff garzik jeff garzik 2 0.14% 1 2.27%
david howells david howells 1 0.07% 1 2.27%
Total 1467 100.00% 44 100.00%
  Directory: drivers/cpufreq

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
rafael j. wysocki	rafael j. wysocki	25	100.00%	1	100.00%
	Total	25	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/cpufreq/cpufreq_conservative.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
