cpufreq_conservative.c 15.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/*
 *  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)  2004 Alexander Clouter <alex-kernel@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/kernel.h>
#include <linux/module.h>
#include <linux/smp.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/ctype.h>
#include <linux/cpufreq.h>
#include <linux/sysctl.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/sched.h>
#include <linux/kmod.h>
#include <linux/workqueue.h>
#include <linux/jiffies.h>
#include <linux/kernel_stat.h>
#include <linux/percpu.h>
31
#include <linux/mutex.h>
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
/*
 * dbs is used in this file as a shortform for demandbased switching
 * It helps to keep variable names smaller, simpler
 */

#define DEF_FREQUENCY_UP_THRESHOLD		(80)
#define DEF_FREQUENCY_DOWN_THRESHOLD		(20)

/* 
 * 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.
 */
static unsigned int 				def_sampling_rate;
51 52 53 54
#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)
55
#define MAX_SAMPLING_RATE			(500 * def_sampling_rate)
56 57 58
#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER	(1000)
#define DEF_SAMPLING_DOWN_FACTOR		(1)
#define MAX_SAMPLING_DOWN_FACTOR		(10)
59 60 61 62 63 64 65 66 67
#define TRANSITION_LATENCY_LIMIT		(10 * 1000)

static void do_dbs_timer(void *data);

struct cpu_dbs_info_s {
	struct cpufreq_policy 	*cur_policy;
	unsigned int 		prev_cpu_idle_up;
	unsigned int 		prev_cpu_idle_down;
	unsigned int 		enable;
68 69
	unsigned int		down_skip;
	unsigned int		requested_freq;
70 71 72 73 74
};
static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);

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

75 76 77 78 79 80 81 82
/*
 * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug
 * lock and dbs_mutex. cpu_hotplug lock should always be held before
 * dbs_mutex. If any function that can potentially take cpu_hotplug lock
 * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then
 * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
 * is recursive for the same process. -Venki
 */
83
static DEFINE_MUTEX 	(dbs_mutex);
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
static DECLARE_WORK	(dbs_work, do_dbs_timer, NULL);

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;
};

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,
99 100
	.ignore_nice		= 0,
	.freq_step		= 5,
101 102
};

103 104 105 106
static inline unsigned int get_cpu_idle_time(unsigned int cpu)
{
	return	kstat_cpu(cpu).cpustat.idle +
		kstat_cpu(cpu).cpustat.iowait +
107
		( dbs_tuners_ins.ignore_nice ?
108 109 110 111
		  kstat_cpu(cpu).cpustat.nice :
		  0);
}

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
/************************** sysfs interface ************************/
static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
{
	return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
}

static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
{
	return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
}

#define define_one_ro(_name) 					\
static struct freq_attr _name =  				\
__ATTR(_name, 0444, show_##_name, NULL)

define_one_ro(sampling_rate_max);
define_one_ro(sampling_rate_min);

/* cpufreq_conservative Governor Tunables */
#define show_one(file_name, object)					\
static ssize_t show_##file_name						\
(struct cpufreq_policy *unused, 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);
141
show_one(ignore_nice_load, ignore_nice);
142 143 144 145 146 147 148 149
show_one(freq_step, freq_step);

static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
	ret = sscanf (buf, "%u", &input);
150
	if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
151 152
		return -EINVAL;

153
	mutex_lock(&dbs_mutex);
154
	dbs_tuners_ins.sampling_down_factor = input;
155
	mutex_unlock(&dbs_mutex);
156 157 158 159 160 161 162 163 164 165 166

	return count;
}

static ssize_t store_sampling_rate(struct cpufreq_policy *unused, 
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
	ret = sscanf (buf, "%u", &input);

167
	mutex_lock(&dbs_mutex);
168
	if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
169
		mutex_unlock(&dbs_mutex);
170 171 172 173
		return -EINVAL;
	}

	dbs_tuners_ins.sampling_rate = input;
174
	mutex_unlock(&dbs_mutex);
175 176 177 178 179 180 181 182 183 184 185

	return count;
}

static ssize_t store_up_threshold(struct cpufreq_policy *unused, 
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
	ret = sscanf (buf, "%u", &input);

186
	mutex_lock(&dbs_mutex);
187
	if (ret != 1 || input > 100 || input <= dbs_tuners_ins.down_threshold) {
188
		mutex_unlock(&dbs_mutex);
189 190 191 192
		return -EINVAL;
	}

	dbs_tuners_ins.up_threshold = input;
193
	mutex_unlock(&dbs_mutex);
194 195 196 197 198 199 200 201 202 203 204

	return count;
}

static ssize_t store_down_threshold(struct cpufreq_policy *unused, 
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
	ret = sscanf (buf, "%u", &input);

205
	mutex_lock(&dbs_mutex);
206
	if (ret != 1 || input > 100 || input >= dbs_tuners_ins.up_threshold) {
207
		mutex_unlock(&dbs_mutex);
208 209 210 211
		return -EINVAL;
	}

	dbs_tuners_ins.down_threshold = input;
212
	mutex_unlock(&dbs_mutex);
213 214 215 216

	return count;
}

217
static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
218 219 220 221 222 223 224 225 226 227 228 229 230 231
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;

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

	if ( input > 1 )
		input = 1;
	
232
	mutex_lock(&dbs_mutex);
233
	if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
234
		mutex_unlock(&dbs_mutex);
235 236 237 238 239
		return count;
	}
	dbs_tuners_ins.ignore_nice = input;

	/* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
240
	for_each_online_cpu(j) {
241 242
		struct cpu_dbs_info_s *j_dbs_info;
		j_dbs_info = &per_cpu(cpu_dbs_info, j);
243
		j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
244 245
		j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
	}
246
	mutex_unlock(&dbs_mutex);
247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266

	return count;
}

static ssize_t store_freq_step(struct cpufreq_policy *policy,
		const char *buf, size_t count)
{
	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 :) */
267
	mutex_lock(&dbs_mutex);
268
	dbs_tuners_ins.freq_step = input;
269
	mutex_unlock(&dbs_mutex);
270 271 272 273 274 275 276 277 278 279 280 281

	return count;
}

#define define_one_rw(_name) \
static struct freq_attr _name = \
__ATTR(_name, 0644, show_##_name, store_##_name)

define_one_rw(sampling_rate);
define_one_rw(sampling_down_factor);
define_one_rw(up_threshold);
define_one_rw(down_threshold);
282
define_one_rw(ignore_nice_load);
283 284 285 286 287 288 289 290 291
define_one_rw(freq_step);

static struct attribute * dbs_attributes[] = {
	&sampling_rate_max.attr,
	&sampling_rate_min.attr,
	&sampling_rate.attr,
	&sampling_down_factor.attr,
	&up_threshold.attr,
	&down_threshold.attr,
292
	&ignore_nice_load.attr,
293 294 295 296 297 298 299 300 301 302 303 304 305 306
	&freq_step.attr,
	NULL
};

static struct attribute_group dbs_attr_group = {
	.attrs = dbs_attributes,
	.name = "conservative",
};

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

static void dbs_check_cpu(int cpu)
{
	unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
307
	unsigned int tmp_idle_ticks, total_idle_ticks;
308 309
	unsigned int freq_step;
	unsigned int freq_down_sampling_rate;
310
	struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
311 312 313 314 315
	struct cpufreq_policy *policy;

	if (!this_dbs_info->enable)
		return;

316 317
	policy = this_dbs_info->cur_policy;

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
	/* 
	 * The default safe range is 20% to 80% 
	 * Every sampling_rate, we check
	 * 	- If current idle time is less than 20%, 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 max_frequency 
	 */

	/* Check for frequency increase */
333
	idle_ticks = UINT_MAX;
334

335 336 337 338 339 340 341 342
	/* Check for frequency increase */
	total_idle_ticks = get_cpu_idle_time(cpu);
	tmp_idle_ticks = 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;
343 344 345 346

	/* Scale idle ticks by 100 and compare with up and down ticks */
	idle_ticks *= 100;
	up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
347
			usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
348 349

	if (idle_ticks < up_idle_ticks) {
350
		this_dbs_info->down_skip = 0;
351 352
		this_dbs_info->prev_cpu_idle_down =
			this_dbs_info->prev_cpu_idle_up;
353

354
		/* if we are already at full speed then break out early */
355
		if (this_dbs_info->requested_freq == policy->max)
356 357 358 359 360 361 362 363
			return;
		
		freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;

		/* max freq cannot be less than 100. But who knows.... */
		if (unlikely(freq_step == 0))
			freq_step = 5;
		
364 365 366
		this_dbs_info->requested_freq += freq_step;
		if (this_dbs_info->requested_freq > policy->max)
			this_dbs_info->requested_freq = policy->max;
367

368
		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,
369 370 371 372 373
			CPUFREQ_RELATION_H);
		return;
	}

	/* Check for frequency decrease */
374 375
	this_dbs_info->down_skip++;
	if (this_dbs_info->down_skip < dbs_tuners_ins.sampling_down_factor)
376 377
		return;

378 379 380 381 382
	/* Check for frequency decrease */
	total_idle_ticks = this_dbs_info->prev_cpu_idle_up;
	tmp_idle_ticks = total_idle_ticks -
		this_dbs_info->prev_cpu_idle_down;
	this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
383

384 385
	if (tmp_idle_ticks < idle_ticks)
		idle_ticks = tmp_idle_ticks;
386 387 388

	/* Scale idle ticks by 100 and compare with up and down ticks */
	idle_ticks *= 100;
389
	this_dbs_info->down_skip = 0;
390 391 392 393

	freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
		dbs_tuners_ins.sampling_down_factor;
	down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
394
		usecs_to_jiffies(freq_down_sampling_rate);
395

396
	if (idle_ticks > down_idle_ticks) {
397 398
		/*
		 * if we are already at the lowest speed then break out early
399
		 * or if we 'cannot' reduce the speed as the user might want
400 401
		 * freq_step to be zero
		 */
402
		if (this_dbs_info->requested_freq == policy->min
403 404 405 406 407 408 409 410 411
				|| dbs_tuners_ins.freq_step == 0)
			return;

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

		/* max freq cannot be less than 100. But who knows.... */
		if (unlikely(freq_step == 0))
			freq_step = 5;

412 413 414
		this_dbs_info->requested_freq -= freq_step;
		if (this_dbs_info->requested_freq < policy->min)
			this_dbs_info->requested_freq = policy->min;
415

416
		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,
417
				CPUFREQ_RELATION_H);
418 419 420 421 422 423 424
		return;
	}
}

static void do_dbs_timer(void *data)
{ 
	int i;
425
	lock_cpu_hotplug();
426
	mutex_lock(&dbs_mutex);
427 428 429 430
	for_each_online_cpu(i)
		dbs_check_cpu(i);
	schedule_delayed_work(&dbs_work, 
			usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
431
	mutex_unlock(&dbs_mutex);
432
	unlock_cpu_hotplug();
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
} 

static inline void dbs_timer_init(void)
{
	INIT_WORK(&dbs_work, do_dbs_timer, NULL);
	schedule_delayed_work(&dbs_work,
			usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
	return;
}

static inline void dbs_timer_exit(void)
{
	cancel_delayed_work(&dbs_work);
	return;
}

static int 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;

	this_dbs_info = &per_cpu(cpu_dbs_info, cpu);

	switch (event) {
	case CPUFREQ_GOV_START:
		if ((!cpu_online(cpu)) || 
		    (!policy->cur))
			return -EINVAL;

		if (policy->cpuinfo.transition_latency >
				(TRANSITION_LATENCY_LIMIT * 1000))
			return -EINVAL;
		if (this_dbs_info->enable) /* Already enabled */
			break;
		 
470
		mutex_lock(&dbs_mutex);
471 472 473 474 475
		for_each_cpu_mask(j, policy->cpus) {
			struct cpu_dbs_info_s *j_dbs_info;
			j_dbs_info = &per_cpu(cpu_dbs_info, j);
			j_dbs_info->cur_policy = policy;
		
476
			j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu);
477 478 479 480
			j_dbs_info->prev_cpu_idle_down
				= j_dbs_info->prev_cpu_idle_up;
		}
		this_dbs_info->enable = 1;
481 482
		this_dbs_info->down_skip = 0;
		this_dbs_info->requested_freq = policy->cur;
483 484 485 486 487 488 489 490 491
		sysfs_create_group(&policy->kobj, &dbs_attr_group);
		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 */
492 493 494
			latency = policy->cpuinfo.transition_latency / 1000;
			if (latency == 0)
				latency = 1;
495

496
			def_sampling_rate = 10 * latency *
497
					DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
498 499 500 501

			if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
				def_sampling_rate = MIN_STAT_SAMPLING_RATE;

502 503 504 505 506
			dbs_tuners_ins.sampling_rate = def_sampling_rate;

			dbs_timer_init();
		}
		
507
		mutex_unlock(&dbs_mutex);
508 509 510
		break;

	case CPUFREQ_GOV_STOP:
511
		mutex_lock(&dbs_mutex);
512 513 514 515 516 517 518 519 520 521
		this_dbs_info->enable = 0;
		sysfs_remove_group(&policy->kobj, &dbs_attr_group);
		dbs_enable--;
		/*
		 * Stop the timerschedule work, when this governor
		 * is used for first time
		 */
		if (dbs_enable == 0) 
			dbs_timer_exit();
		
522
		mutex_unlock(&dbs_mutex);
523 524 525 526

		break;

	case CPUFREQ_GOV_LIMITS:
527
		lock_cpu_hotplug();
528
		mutex_lock(&dbs_mutex);
529 530 531 532 533 534 535 536
		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);
537
		mutex_unlock(&dbs_mutex);
538
		unlock_cpu_hotplug();
539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
		break;
	}
	return 0;
}

static struct cpufreq_governor cpufreq_gov_dbs = {
	.name		= "conservative",
	.governor	= cpufreq_governor_dbs,
	.owner		= THIS_MODULE,
};

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

static void __exit cpufreq_gov_dbs_exit(void)
{
	/* Make sure that the scheduled work is indeed not running */
	flush_scheduled_work();

	cpufreq_unregister_governor(&cpufreq_gov_dbs);
}


MODULE_AUTHOR ("Alexander Clouter <alex-kernel@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");

module_init(cpufreq_gov_dbs_init);
module_exit(cpufreq_gov_dbs_exit);