Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9561b03d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq 

* master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq:
  [CPUFREQ] cpufreq_conservative: keep ignore_nice_load and freq_step values when reselected
  [CPUFREQ] powernow: remove private for_each_cpu_mask()
  [CPUFREQ] hotplug cpu fix for powernow-k8
  [PATCH] cpufreq_ondemand: add range check
  [PATCH] cpufreq_ondemand: keep ignore_nice_load value when it is reselected
  [PATCH] cpufreq_ondemand: Warn if it cannot run due to too long transition latency
  [PATCH] cpufreq_conservative: alternative initialise approach
  [PATCH] cpufreq_conservative: make for_each_cpu() safe
  [PATCH] cpufreq_conservative: alter default responsiveness
  [PATCH] cpufreq_conservative: aligning of codebase with ondemand
parents 7baf398f c326e27e

arch/i386/kernel/cpu/cpufreq/powernow-k8.c

+6 −1
Original line number Diff line number Diff line
@@ -1095,10 +1095,15 @@ static int __devexit powernowk8_cpu_exit (struct cpufreq_policy *pol) 


static unsigned int powernowk8_get (unsigned int cpu)

{

	struct powernow_k8_data *data = powernow_data[cpu];

	struct powernow_k8_data *data;

	cpumask_t oldmask = current->cpus_allowed;

	unsigned int khz = 0;



	data = powernow_data[first_cpu(cpu_core_map[cpu])];



	if (!data)

		return -EINVAL;



	set_cpus_allowed(current, cpumask_of_cpu(cpu));

	if (smp_processor_id() != cpu) {

		printk(KERN_ERR PFX "limiting to CPU %d failed in powernowk8_get\n", cpu);

arch/i386/kernel/cpu/cpufreq/powernow-k8.h

+0 −4
Original line number Diff line number Diff line
@@ -182,10 +182,6 @@ static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid); 


static void powernow_k8_acpi_pst_values(struct powernow_k8_data *data, unsigned int index);



#ifndef for_each_cpu_mask

#define for_each_cpu_mask(i,mask) for (i=0;i<1;i++)

#endif



#ifdef CONFIG_SMP

static inline void define_siblings(int cpu, cpumask_t cpu_sharedcore_mask[])

{

drivers/cpufreq/cpufreq_conservative.c

+65 −90
Original line number Diff line number Diff line
@@ -35,12 +35,7 @@ 
 */



#define DEF_FREQUENCY_UP_THRESHOLD		(80)

#define MIN_FREQUENCY_UP_THRESHOLD		(0)

#define MAX_FREQUENCY_UP_THRESHOLD		(100)



#define DEF_FREQUENCY_DOWN_THRESHOLD		(20)

#define MIN_FREQUENCY_DOWN_THRESHOLD		(0)

#define MAX_FREQUENCY_DOWN_THRESHOLD		(100)



/* 

 * The polling frequency of this governor depends on the capability of
@@ -53,10 +48,14 @@ 
 * All times here are in uS.

 */

static unsigned int 				def_sampling_rate;

#define MIN_SAMPLING_RATE			(def_sampling_rate / 2)

#define MIN_SAMPLING_RATE_RATIO			(2)

/* for correct statistics, we need at least 10 ticks between each measure */

#define MIN_STAT_SAMPLING_RATE			(MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))

#define MIN_SAMPLING_RATE			(def_sampling_rate / MIN_SAMPLING_RATE_RATIO)

#define MAX_SAMPLING_RATE			(500 * def_sampling_rate)

#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER	(100000)

#define DEF_SAMPLING_DOWN_FACTOR		(5)

#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER	(1000)

#define DEF_SAMPLING_DOWN_FACTOR		(1)

#define MAX_SAMPLING_DOWN_FACTOR		(10)

#define TRANSITION_LATENCY_LIMIT		(10 * 1000)



static void do_dbs_timer(void *data);
@@ -66,6 +65,8 @@ struct cpu_dbs_info_s { 
	unsigned int 		prev_cpu_idle_up;

	unsigned int 		prev_cpu_idle_down;

	unsigned int 		enable;

	unsigned int		down_skip;

	unsigned int		requested_freq;

};

static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
@@ -87,6 +88,8 @@ static struct dbs_tuners 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,

};



static inline unsigned int get_cpu_idle_time(unsigned int cpu)
@@ -136,7 +139,7 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 
	unsigned int input;

	int ret;

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

	if (ret != 1 )

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

		return -EINVAL;



	mutex_lock(&dbs_mutex);
@@ -173,8 +176,7 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused, 
	ret = sscanf (buf, "%u", &input);



	mutex_lock(&dbs_mutex);

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

			input < MIN_FREQUENCY_UP_THRESHOLD ||

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

			input <= dbs_tuners_ins.down_threshold) {

		mutex_unlock(&dbs_mutex);

		return -EINVAL;
@@ -194,8 +196,7 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused, 
	ret = sscanf (buf, "%u", &input);



	mutex_lock(&dbs_mutex);

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

			input < MIN_FREQUENCY_DOWN_THRESHOLD ||

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

			input >= dbs_tuners_ins.up_threshold) {

		mutex_unlock(&dbs_mutex);

		return -EINVAL;
@@ -297,31 +298,17 @@ static struct attribute_group dbs_attr_group = { 
static void dbs_check_cpu(int cpu)

{

	unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;

	unsigned int tmp_idle_ticks, total_idle_ticks;

	unsigned int freq_step;

	unsigned int freq_down_sampling_rate;

	static int down_skip[NR_CPUS];

	static int requested_freq[NR_CPUS];

	static unsigned short init_flag = 0;

	struct cpu_dbs_info_s *this_dbs_info;

	struct cpu_dbs_info_s *dbs_info;



	struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu);

	struct cpufreq_policy *policy;

	unsigned int j;



	this_dbs_info = &per_cpu(cpu_dbs_info, cpu);

	if (!this_dbs_info->enable)

		return;



	policy = this_dbs_info->cur_policy;



	if ( init_flag == 0 ) {

		for_each_online_cpu(j) {

			dbs_info = &per_cpu(cpu_dbs_info, j);

			requested_freq[j] = dbs_info->cur_policy->cur;

		}

		init_flag = 1;

	}

	

	/* 

	 * The default safe range is 20% to 80% 

	 * Every sampling_rate, we check
@@ -337,22 +324,16 @@ static void dbs_check_cpu(int cpu) 
	 */



	/* Check for frequency increase */



	idle_ticks = UINT_MAX;

	for_each_cpu_mask(j, policy->cpus) {

		unsigned int tmp_idle_ticks, total_idle_ticks;

		struct cpu_dbs_info_s *j_dbs_info;



		j_dbs_info = &per_cpu(cpu_dbs_info, j);

	/* Check for frequency increase */

		total_idle_ticks = get_cpu_idle_time(j);

	total_idle_ticks = get_cpu_idle_time(cpu);

	tmp_idle_ticks = total_idle_ticks -

			j_dbs_info->prev_cpu_idle_up;

		j_dbs_info->prev_cpu_idle_up = total_idle_ticks;

		this_dbs_info->prev_cpu_idle_up;

	this_dbs_info->prev_cpu_idle_up = total_idle_ticks;



	if (tmp_idle_ticks < idle_ticks)

		idle_ticks = tmp_idle_ticks;

	}



	/* Scale idle ticks by 100 and compare with up and down ticks */

	idle_ticks *= 100;
@@ -360,16 +341,12 @@ static void dbs_check_cpu(int cpu) 
			usecs_to_jiffies(dbs_tuners_ins.sampling_rate);



	if (idle_ticks < up_idle_ticks) {

		down_skip[cpu] = 0;

		for_each_cpu_mask(j, policy->cpus) {

			struct cpu_dbs_info_s *j_dbs_info;

		this_dbs_info->down_skip = 0;

		this_dbs_info->prev_cpu_idle_down =

			this_dbs_info->prev_cpu_idle_up;



			j_dbs_info = &per_cpu(cpu_dbs_info, j);

			j_dbs_info->prev_cpu_idle_down = 

					j_dbs_info->prev_cpu_idle_up;

		}

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

		if (requested_freq[cpu] == policy->max)

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

			return;

		

		freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
@@ -378,38 +355,32 @@ static void dbs_check_cpu(int cpu) 
		if (unlikely(freq_step == 0))

			freq_step = 5;

		

		requested_freq[cpu] += freq_step;

		if (requested_freq[cpu] > policy->max)

			requested_freq[cpu] = policy->max;

		this_dbs_info->requested_freq += freq_step;

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

			this_dbs_info->requested_freq = policy->max;



		__cpufreq_driver_target(policy, requested_freq[cpu], 

		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,

			CPUFREQ_RELATION_H);

		return;

	}



	/* Check for frequency decrease */

	down_skip[cpu]++;

	if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)

	this_dbs_info->down_skip++;

	if (this_dbs_info->down_skip < dbs_tuners_ins.sampling_down_factor)

		return;



	idle_ticks = UINT_MAX;

	for_each_cpu_mask(j, policy->cpus) {

		unsigned int tmp_idle_ticks, total_idle_ticks;

		struct cpu_dbs_info_s *j_dbs_info;



		j_dbs_info = &per_cpu(cpu_dbs_info, j);

		total_idle_ticks = j_dbs_info->prev_cpu_idle_up;

	/* Check for frequency decrease */

	total_idle_ticks = this_dbs_info->prev_cpu_idle_up;

	tmp_idle_ticks = total_idle_ticks -

			j_dbs_info->prev_cpu_idle_down;

		j_dbs_info->prev_cpu_idle_down = total_idle_ticks;

		this_dbs_info->prev_cpu_idle_down;

	this_dbs_info->prev_cpu_idle_down = total_idle_ticks;



	if (tmp_idle_ticks < idle_ticks)

		idle_ticks = tmp_idle_ticks;

	}



	/* Scale idle ticks by 100 and compare with up and down ticks */

	idle_ticks *= 100;

	down_skip[cpu] = 0;

	this_dbs_info->down_skip = 0;



	freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *

		dbs_tuners_ins.sampling_down_factor;
@@ -417,10 +388,12 @@ static void dbs_check_cpu(int cpu) 
		usecs_to_jiffies(freq_down_sampling_rate);



	if (idle_ticks > down_idle_ticks) {

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

		/*

		 * if we are already at the lowest speed then break out early

		 * or if we 'cannot' reduce the speed as the user might want

		 * freq_step to be zero */

		if (requested_freq[cpu] == policy->min

		 * freq_step to be zero

		 */

		if (this_dbs_info->requested_freq == policy->min

				|| dbs_tuners_ins.freq_step == 0)

			return;
@@ -430,12 +403,11 @@ static void dbs_check_cpu(int cpu) 
		if (unlikely(freq_step == 0))

			freq_step = 5;



		requested_freq[cpu] -= freq_step;

		if (requested_freq[cpu] < policy->min)

			requested_freq[cpu] = policy->min;

		this_dbs_info->requested_freq -= freq_step;

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

			this_dbs_info->requested_freq = policy->min;



		__cpufreq_driver_target(policy,

			requested_freq[cpu],

		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,

				CPUFREQ_RELATION_H);

		return;

	}
@@ -493,11 +465,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
			j_dbs_info = &per_cpu(cpu_dbs_info, j);

			j_dbs_info->cur_policy = policy;

		

			j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);

			j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu);

			j_dbs_info->prev_cpu_idle_down

				= j_dbs_info->prev_cpu_idle_up;

		}

		this_dbs_info->enable = 1;

		this_dbs_info->down_skip = 0;

		this_dbs_info->requested_freq = policy->cur;

		sysfs_create_group(&policy->kobj, &dbs_attr_group);

		dbs_enable++;

		/*
@@ -507,16 +481,17 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
		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;



			latency = policy->cpuinfo.transition_latency;

			if (latency < 1000)

				latency = 1000;



			def_sampling_rate = (latency / 1000) *

			def_sampling_rate = 10 * latency *

					DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;



			if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)

				def_sampling_rate = MIN_STAT_SAMPLING_RATE;



			dbs_tuners_ins.sampling_rate = def_sampling_rate;

			dbs_tuners_ins.ignore_nice = 0;

			dbs_tuners_ins.freq_step = 5;



			dbs_timer_init();

		}

drivers/cpufreq/cpufreq_ondemand.c

+8 −3
Original line number Diff line number Diff line
@@ -84,6 +84,7 @@ struct dbs_tuners { 
static struct dbs_tuners dbs_tuners_ins = {

	.up_threshold = DEF_FREQUENCY_UP_THRESHOLD,

	.sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,

	.ignore_nice = 0,

};



static inline unsigned int get_cpu_idle_time(unsigned int cpu)
@@ -350,6 +351,9 @@ static void dbs_check_cpu(int cpu) 
	freq_next = (freq_next * policy->cur) /

			(dbs_tuners_ins.up_threshold - 10);



	if (freq_next < policy->min)

		freq_next = policy->min;



	if (freq_next <= ((policy->cur * 95) / 100))

		__cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);

}
@@ -395,8 +399,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
			return -EINVAL;



		if (policy->cpuinfo.transition_latency >

				(TRANSITION_LATENCY_LIMIT * 1000))

				(TRANSITION_LATENCY_LIMIT * 1000)) {

			printk(KERN_WARNING "ondemand governor failed to load "

			       "due to too long transition latency\n");

			return -EINVAL;

		}

		if (this_dbs_info->enable) /* Already enabled */

			break;
@@ -431,8 +438,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
				def_sampling_rate = MIN_STAT_SAMPLING_RATE;



			dbs_tuners_ins.sampling_rate = def_sampling_rate;

			dbs_tuners_ins.ignore_nice = 0;



			dbs_timer_init();

		}