cpufreq_conservative.c 17.9 KB
Newer Older
1 2 3 4 5 6
/*
 *  drivers/cpufreq/cpufreq_conservative.c
 *
 *  Copyright (C)  2001 Russell King
 *            (C)  2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
 *                      Jun Nakajima <jun.nakajima@intel.com>
7
 *            (C)  2009 Alexander Clouter <alex@digriz.org.uk>
8 9 10 11 12 13 14 15 16 17
 *
 * 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/init.h>
#include <linux/cpufreq.h>
A
Andrew Morton 已提交
18
#include <linux/cpu.h>
19 20
#include <linux/jiffies.h>
#include <linux/kernel_stat.h>
21
#include <linux/mutex.h>
22 23 24 25 26
#include <linux/hrtimer.h>
#include <linux/tick.h>
#include <linux/ktime.h>
#include <linux/sched.h>

27 28 29 30 31 32 33 34
/*
 * 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)

35 36
/*
 * The polling frequency of this governor depends on the capability of
37
 * the processor. Default polling frequency is 1000 times the transition
38 39
 * latency of the processor. The governor will work on any processor with
 * transition latency <= 10mS, using appropriate sampling
40
 * rate.
41 42
 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
 * this governor will not work.
43 44
 * All times here are in uS.
 */
45
#define MIN_SAMPLING_RATE_RATIO			(2)
46

47 48
static unsigned int min_sampling_rate;

49
#define LATENCY_MULTIPLIER			(1000)
50
#define MIN_LATENCY_MULTIPLIER			(100)
51 52
#define DEF_SAMPLING_DOWN_FACTOR		(1)
#define MAX_SAMPLING_DOWN_FACTOR		(10)
53
#define TRANSITION_LATENCY_LIMIT		(10 * 1000 * 1000)
54

D
David Howells 已提交
55
static void do_dbs_timer(struct work_struct *work);
56 57

struct cpu_dbs_info_s {
58 59 60
	cputime64_t prev_cpu_idle;
	cputime64_t prev_cpu_wall;
	cputime64_t prev_cpu_nice;
61
	struct cpufreq_policy *cur_policy;
62
	struct delayed_work work;
63 64
	unsigned int down_skip;
	unsigned int requested_freq;
65 66
	int cpu;
	unsigned int enable:1;
67 68 69 70 71
};
static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);

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

72 73 74 75 76 77 78
/*
 * 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
79 80 81
 * DEADLOCK ALERT! (2) : do_dbs_timer() must not take the dbs_mutex, because it
 * would deadlock with cancel_delayed_work_sync(), which is needed for proper
 * raceless workqueue teardown.
82
 */
83
static DEFINE_MUTEX(dbs_mutex);
84

85 86 87
static struct workqueue_struct	*kconservative_wq;

static struct dbs_tuners {
88 89 90 91 92 93
	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;
94
} dbs_tuners_ins = {
95 96 97 98 99
	.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,
100 101
};

102 103
static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu,
							cputime64_t *wall)
104
{
105 106 107 108 109 110 111
	cputime64_t idle_time;
	cputime64_t cur_wall_time;
	cputime64_t busy_time;

	cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
	busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,
			kstat_cpu(cpu).cpustat.system);
112

113 114 115 116
	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);
	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);
	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);
	busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice);
117

118 119 120
	idle_time = cputime64_sub(cur_wall_time, busy_time);
	if (wall)
		*wall = cur_wall_time;
121

122 123 124 125 126 127 128 129 130 131 132
	return idle_time;
}

static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall)
{
	u64 idle_time = get_cpu_idle_time_us(cpu, wall);

	if (idle_time == -1ULL)
		return get_cpu_idle_time_jiffy(cpu, wall);

	return idle_time;
133 134
}

135 136 137 138 139 140 141 142 143
/* keep track of frequency transitions */
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(cpu_dbs_info,
							freq->cpu);

144 145
	struct cpufreq_policy *policy;

146 147 148
	if (!this_dbs_info->enable)
		return 0;

149 150 151 152 153 154 155 156 157 158
	policy = this_dbs_info->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
	*/
	if (this_dbs_info->requested_freq > policy->max
			|| this_dbs_info->requested_freq < policy->min)
		this_dbs_info->requested_freq = freq->new;
159 160 161 162 163 164 165 166

	return 0;
}

static struct notifier_block dbs_cpufreq_notifier_block = {
	.notifier_call = dbs_cpufreq_notifier
};

167 168 169
/************************** sysfs interface ************************/
static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
{
170 171 172 173 174 175 176 177
	static int print_once;

	if (!print_once) {
		printk(KERN_INFO "CPUFREQ: conservative sampling_rate_max "
		       "sysfs file is deprecated - used by: %s\n",
		       current->comm);
		print_once = 1;
	}
178
	return sprintf(buf, "%u\n", -1U);
179 180 181 182
}

static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
{
183 184 185 186 187 188 189
	static int print_once;

	if (!print_once) {
		printk(KERN_INFO "CPUFREQ: conservative sampling_rate_max "
		       "sysfs file is deprecated - used by: %s\n", current->comm);
		print_once = 1;
	}
190
	return sprintf(buf, "%u\n", min_sampling_rate);
191 192
}

193 194
#define define_one_ro(_name)		\
static struct freq_attr _name =		\
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
__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);
211
show_one(ignore_nice_load, ignore_nice);
212 213
show_one(freq_step, freq_step);

214
static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
215 216 217 218
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
219
	ret = sscanf(buf, "%u", &input);
220

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

224
	mutex_lock(&dbs_mutex);
225
	dbs_tuners_ins.sampling_down_factor = input;
226
	mutex_unlock(&dbs_mutex);
227 228 229 230

	return count;
}

231
static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
232 233 234 235
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
236
	ret = sscanf(buf, "%u", &input);
237

238
	if (ret != 1)
239
		return -EINVAL;
240 241

	mutex_lock(&dbs_mutex);
242
	dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate);
243
	mutex_unlock(&dbs_mutex);
244 245 246 247

	return count;
}

248
static ssize_t store_up_threshold(struct cpufreq_policy *unused,
249 250 251 252
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
253
	ret = sscanf(buf, "%u", &input);
254

255
	mutex_lock(&dbs_mutex);
256
	if (ret != 1 || input > 100 ||
257
			input <= dbs_tuners_ins.down_threshold) {
258
		mutex_unlock(&dbs_mutex);
259 260 261 262
		return -EINVAL;
	}

	dbs_tuners_ins.up_threshold = input;
263
	mutex_unlock(&dbs_mutex);
264 265 266 267

	return count;
}

268
static ssize_t store_down_threshold(struct cpufreq_policy *unused,
269 270 271 272
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
273
	ret = sscanf(buf, "%u", &input);
274

275
	mutex_lock(&dbs_mutex);
276 277 278
	/* cannot be lower than 11 otherwise freq will not fall */
	if (ret != 1 || input < 11 || input > 100 ||
			input >= dbs_tuners_ins.up_threshold) {
279
		mutex_unlock(&dbs_mutex);
280 281 282 283
		return -EINVAL;
	}

	dbs_tuners_ins.down_threshold = input;
284
	mutex_unlock(&dbs_mutex);
285 286 287 288

	return count;
}

289
static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
290 291 292 293 294 295
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;

	unsigned int j;
296 297 298

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

301
	if (input > 1)
302
		input = 1;
303

304
	mutex_lock(&dbs_mutex);
305
	if (input == dbs_tuners_ins.ignore_nice) { /* nothing to do */
306
		mutex_unlock(&dbs_mutex);
307 308 309 310
		return count;
	}
	dbs_tuners_ins.ignore_nice = input;

311
	/* we need to re-evaluate prev_cpu_idle */
312
	for_each_online_cpu(j) {
313 314 315 316 317 318
		struct cpu_dbs_info_s *dbs_info;
		dbs_info = &per_cpu(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 = kstat_cpu(j).cpustat.nice;
319
	}
320
	mutex_unlock(&dbs_mutex);
321 322 323 324 325 326 327 328 329

	return count;
}

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

332
	if (ret != 1)
333 334
		return -EINVAL;

335
	if (input > 100)
336
		input = 100;
337

338 339
	/* no need to test here if freq_step is zero as the user might actually
	 * want this, they would be crazy though :) */
340
	mutex_lock(&dbs_mutex);
341
	dbs_tuners_ins.freq_step = input;
342
	mutex_unlock(&dbs_mutex);
343 344 345 346 347 348 349 350 351 352 353 354

	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);
355
define_one_rw(ignore_nice_load);
356 357
define_one_rw(freq_step);

358
static struct attribute *dbs_attributes[] = {
359 360 361 362 363 364
	&sampling_rate_max.attr,
	&sampling_rate_min.attr,
	&sampling_rate.attr,
	&sampling_down_factor.attr,
	&up_threshold.attr,
	&down_threshold.attr,
365
	&ignore_nice_load.attr,
366 367 368 369 370 371 372 373 374 375 376
	&freq_step.attr,
	NULL
};

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

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

377
static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
378
{
379
	unsigned int load = 0;
380
	unsigned int freq_target;
381

382 383
	struct cpufreq_policy *policy;
	unsigned int j;
384

385 386
	policy = this_dbs_info->cur_policy;

387
	/*
388 389 390 391
	 * 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
392
	 *
393 394
	 * Any frequency increase takes it to the maximum frequency.
	 * Frequency reduction happens at minimum steps of
395
	 * 5% (default) of maximum frequency
396 397
	 */

398 399 400 401 402
	/* 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;
403

404 405 406 407 408 409 410
		j_dbs_info = &per_cpu(cpu_dbs_info, j);

		cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);

		wall_time = (unsigned int) cputime64_sub(cur_wall_time,
				j_dbs_info->prev_cpu_wall);
		j_dbs_info->prev_cpu_wall = cur_wall_time;
411

412 413 414
		idle_time = (unsigned int) cputime64_sub(cur_idle_time,
				j_dbs_info->prev_cpu_idle);
		j_dbs_info->prev_cpu_idle = cur_idle_time;
415

416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
		if (dbs_tuners_ins.ignore_nice) {
			cputime64_t cur_nice;
			unsigned long cur_nice_jiffies;

			cur_nice = cputime64_sub(kstat_cpu(j).cpustat.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 = kstat_cpu(j).cpustat.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;
	}

	/*
	 * 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;
445

446 447
	/* Check for frequency increase */
	if (load > dbs_tuners_ins.up_threshold) {
448
		this_dbs_info->down_skip = 0;
449

450
		/* if we are already at full speed then break out early */
451
		if (this_dbs_info->requested_freq == policy->max)
452
			return;
453

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

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

460
		this_dbs_info->requested_freq += freq_target;
461 462
		if (this_dbs_info->requested_freq > policy->max)
			this_dbs_info->requested_freq = policy->max;
463

464
		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,
465 466 467 468
			CPUFREQ_RELATION_H);
		return;
	}

469 470 471 472 473 474
	/*
	 * 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 (load < (dbs_tuners_ins.down_threshold - 10)) {
475
		freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100;
476

477
		this_dbs_info->requested_freq -= freq_target;
478 479
		if (this_dbs_info->requested_freq < policy->min)
			this_dbs_info->requested_freq = policy->min;
480

481 482 483 484 485 486
		/*
		 * if we cannot reduce the frequency anymore, break out early
		 */
		if (policy->cur == policy->min)
			return;

487
		__cpufreq_driver_target(policy, this_dbs_info->requested_freq,
488
				CPUFREQ_RELATION_H);
489 490 491 492
		return;
	}
}

D
David Howells 已提交
493
static void do_dbs_timer(struct work_struct *work)
494
{
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
	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;

	if (lock_policy_rwsem_write(cpu) < 0)
		return;

	if (!dbs_info->enable) {
		unlock_policy_rwsem_write(cpu);
		return;
	}

	dbs_check_cpu(dbs_info);

	queue_delayed_work_on(cpu, kconservative_wq, &dbs_info->work, delay);
	unlock_policy_rwsem_write(cpu);
516
}
517

518
static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
519
{
520 521 522 523 524 525 526 527
	/* We want all CPUs to do sampling nearly on same jiffy */
	int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
	delay -= jiffies % delay;

	dbs_info->enable = 1;
	INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
	queue_delayed_work_on(dbs_info->cpu, kconservative_wq, &dbs_info->work,
				delay);
528 529
}

530
static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
531
{
532
	dbs_info->enable = 0;
533
	cancel_delayed_work_sync(&dbs_info->work);
534 535 536 537 538 539 540 541
}

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;
J
Jeff Garzik 已提交
542
	int rc;
543 544 545 546 547

	this_dbs_info = &per_cpu(cpu_dbs_info, cpu);

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

		if (this_dbs_info->enable) /* Already enabled */
			break;
553

554
		mutex_lock(&dbs_mutex);
J
Jeff Garzik 已提交
555 556 557 558 559 560 561

		rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
		if (rc) {
			mutex_unlock(&dbs_mutex);
			return rc;
		}

562
		for_each_cpu(j, policy->cpus) {
563 564 565
			struct cpu_dbs_info_s *j_dbs_info;
			j_dbs_info = &per_cpu(cpu_dbs_info, j);
			j_dbs_info->cur_policy = policy;
566

567 568 569 570 571 572
			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 =
						kstat_cpu(j).cpustat.nice;
			}
573
		}
574 575
		this_dbs_info->down_skip = 0;
		this_dbs_info->requested_freq = policy->cur;
J
Jeff Garzik 已提交
576

577 578 579 580 581 582 583 584
		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 */
585 586 587
			latency = policy->cpuinfo.transition_latency / 1000;
			if (latency == 0)
				latency = 1;
588

589 590 591 592 593 594 595 596 597 598 599 600
			/*
			 * 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);
601

602 603 604
			cpufreq_register_notifier(
					&dbs_cpufreq_notifier_block,
					CPUFREQ_TRANSITION_NOTIFIER);
605
		}
606
		dbs_timer_init(this_dbs_info);
607

608
		mutex_unlock(&dbs_mutex);
609

610 611 612
		break;

	case CPUFREQ_GOV_STOP:
613
		mutex_lock(&dbs_mutex);
614
		dbs_timer_exit(this_dbs_info);
615 616
		sysfs_remove_group(&policy->kobj, &dbs_attr_group);
		dbs_enable--;
617

618 619 620 621
		/*
		 * Stop the timerschedule work, when this governor
		 * is used for first time
		 */
622
		if (dbs_enable == 0)
623 624 625 626
			cpufreq_unregister_notifier(
					&dbs_cpufreq_notifier_block,
					CPUFREQ_TRANSITION_NOTIFIER);

627
		mutex_unlock(&dbs_mutex);
628 629 630 631

		break;

	case CPUFREQ_GOV_LIMITS:
632
		mutex_lock(&dbs_mutex);
633 634 635
		if (policy->max < this_dbs_info->cur_policy->cur)
			__cpufreq_driver_target(
					this_dbs_info->cur_policy,
636
					policy->max, CPUFREQ_RELATION_H);
637 638 639
		else if (policy->min > this_dbs_info->cur_policy->cur)
			__cpufreq_driver_target(
					this_dbs_info->cur_policy,
640
					policy->min, CPUFREQ_RELATION_L);
641
		mutex_unlock(&dbs_mutex);
642

643 644 645 646 647
		break;
	}
	return 0;
}

648 649 650
#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
static
#endif
651 652 653 654 655
struct cpufreq_governor cpufreq_gov_conservative = {
	.name			= "conservative",
	.governor		= cpufreq_governor_dbs,
	.max_transition_latency	= TRANSITION_LATENCY_LIMIT,
	.owner			= THIS_MODULE,
656 657 658 659
};

static int __init cpufreq_gov_dbs_init(void)
{
660 661 662 663 664 665 666 667 668 669 670 671 672
	int err;

	kconservative_wq = create_workqueue("kconservative");
	if (!kconservative_wq) {
		printk(KERN_ERR "Creation of kconservative failed\n");
		return -EFAULT;
	}

	err = cpufreq_register_governor(&cpufreq_gov_conservative);
	if (err)
		destroy_workqueue(kconservative_wq);

	return err;
673 674 675 676
}

static void __exit cpufreq_gov_dbs_exit(void)
{
677
	cpufreq_unregister_governor(&cpufreq_gov_conservative);
678
	destroy_workqueue(kconservative_wq);
679 680 681
}


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

688 689 690
#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
fs_initcall(cpufreq_gov_dbs_init);
#else
691
module_init(cpufreq_gov_dbs_init);
692
#endif
693
module_exit(cpufreq_gov_dbs_exit);