cpufreq_ondemand.c 16.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 *  drivers/cpufreq/cpufreq_ondemand.c
 *
 *  Copyright (C)  2001 Russell King
 *            (C)  2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
 *                      Jun Nakajima <jun.nakajima@intel.com>
 *
 * 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 已提交
17
#include <linux/cpu.h>
L
Linus Torvalds 已提交
18 19
#include <linux/jiffies.h>
#include <linux/kernel_stat.h>
20
#include <linux/mutex.h>
L
Linus Torvalds 已提交
21 22 23 24 25 26 27

/*
 * 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)
28
#define MIN_FREQUENCY_UP_THRESHOLD		(11)
L
Linus Torvalds 已提交
29 30
#define MAX_FREQUENCY_UP_THRESHOLD		(100)

31 32
/*
 * The polling frequency of this governor depends on the capability of
L
Linus Torvalds 已提交
33
 * the processor. Default polling frequency is 1000 times the transition
34 35
 * latency of the processor. The governor will work on any processor with
 * transition latency <= 10mS, using appropriate sampling
L
Linus Torvalds 已提交
36 37 38 39 40
 * rate.
 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
 * this governor will not work.
 * All times here are in uS.
 */
41
static unsigned int def_sampling_rate;
42 43 44 45
#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)
L
Linus Torvalds 已提交
46 47 48 49 50 51 52
#define MAX_SAMPLING_RATE			(500 * def_sampling_rate)
#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER	(1000)
#define TRANSITION_LATENCY_LIMIT		(10 * 1000)

static void do_dbs_timer(void *data);

struct cpu_dbs_info_s {
53 54
	cputime64_t prev_cpu_idle;
	cputime64_t prev_cpu_wall;
55
	struct cpufreq_policy *cur_policy;
56
 	struct work_struct work;
57
	unsigned int enable;
58 59 60 61
	struct cpufreq_frequency_table *freq_table;
	unsigned int freq_lo;
	unsigned int freq_lo_jiffies;
	unsigned int freq_hi_jiffies;
L
Linus Torvalds 已提交
62 63 64 65 66
};
static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);

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

67 68 69 70 71 72 73 74
/*
 * 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
 */
75
static DEFINE_MUTEX(dbs_mutex);
L
Linus Torvalds 已提交
76

77
static struct workqueue_struct	*kondemand_wq;
78

79
static struct dbs_tuners {
80 81 82
	unsigned int sampling_rate;
	unsigned int up_threshold;
	unsigned int ignore_nice;
83 84
	unsigned int powersave_bias;
} dbs_tuners_ins = {
85
	.up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
86
	.ignore_nice = 0,
87
	.powersave_bias = 0,
L
Linus Torvalds 已提交
88 89
};

90
static inline cputime64_t get_cpu_idle_time(unsigned int cpu)
91
{
92 93 94 95 96 97 98 99 100
	cputime64_t retval;

	retval = cputime64_add(kstat_cpu(cpu).cpustat.idle,
			kstat_cpu(cpu).cpustat.iowait);

	if (dbs_tuners_ins.ignore_nice)
		retval = cputime64_add(retval, kstat_cpu(cpu).cpustat.nice);

	return retval;
101 102
}

103 104 105 106 107 108 109 110 111 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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
/*
 * Find right freq to be set now with powersave_bias on.
 * Returns the freq_hi to be used right now and will set freq_hi_jiffies,
 * freq_lo, and freq_lo_jiffies in percpu area for averaging freqs.
 */
unsigned int powersave_bias_target(struct cpufreq_policy *policy,
		unsigned int freq_next, unsigned int relation)
{
	unsigned int freq_req, freq_reduc, freq_avg;
	unsigned int freq_hi, freq_lo;
	unsigned int index = 0;
	unsigned int jiffies_total, jiffies_hi, jiffies_lo;
	struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, policy->cpu);

	if (!dbs_info->freq_table) {
		dbs_info->freq_lo = 0;
		dbs_info->freq_lo_jiffies = 0;
		return freq_next;
	}

	cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next,
			relation, &index);
	freq_req = dbs_info->freq_table[index].frequency;
	freq_reduc = freq_req * dbs_tuners_ins.powersave_bias / 1000;
	freq_avg = freq_req - freq_reduc;

	/* Find freq bounds for freq_avg in freq_table */
	index = 0;
	cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
			CPUFREQ_RELATION_H, &index);
	freq_lo = dbs_info->freq_table[index].frequency;
	index = 0;
	cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
			CPUFREQ_RELATION_L, &index);
	freq_hi = dbs_info->freq_table[index].frequency;

	/* Find out how long we have to be in hi and lo freqs */
	if (freq_hi == freq_lo) {
		dbs_info->freq_lo = 0;
		dbs_info->freq_lo_jiffies = 0;
		return freq_lo;
	}
	jiffies_total = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
	jiffies_hi = (freq_avg - freq_lo) * jiffies_total;
	jiffies_hi += ((freq_hi - freq_lo) / 2);
	jiffies_hi /= (freq_hi - freq_lo);
	jiffies_lo = jiffies_total - jiffies_hi;
	dbs_info->freq_lo = freq_lo;
	dbs_info->freq_lo_jiffies = jiffies_lo;
	dbs_info->freq_hi_jiffies = jiffies_hi;
	return freq_hi;
}

static void ondemand_powersave_bias_init(void)
{
	int i;
	for_each_online_cpu(i) {
		struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, i);
		dbs_info->freq_table = cpufreq_frequency_get_table(i);
		dbs_info->freq_lo = 0;
	}
}

L
Linus Torvalds 已提交
166 167 168 169 170 171 172 173 174 175 176
/************************** 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);
}

177 178
#define define_one_ro(_name)		\
static struct freq_attr _name =		\
L
Linus Torvalds 已提交
179 180 181 182 183 184 185 186 187 188 189 190 191 192
__ATTR(_name, 0444, show_##_name, NULL)

define_one_ro(sampling_rate_max);
define_one_ro(sampling_rate_min);

/* cpufreq_ondemand 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(up_threshold, up_threshold);
193
show_one(ignore_nice_load, ignore_nice);
194
show_one(powersave_bias, powersave_bias);
L
Linus Torvalds 已提交
195

196
static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
L
Linus Torvalds 已提交
197 198 199 200
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
201
	ret = sscanf(buf, "%u", &input);
L
Linus Torvalds 已提交
202

203
	mutex_lock(&dbs_mutex);
L
Linus Torvalds 已提交
204
	if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
205
		mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
206 207 208 209
		return -EINVAL;
	}

	dbs_tuners_ins.sampling_rate = input;
210
	mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
211 212 213 214

	return count;
}

215
static ssize_t store_up_threshold(struct cpufreq_policy *unused,
L
Linus Torvalds 已提交
216 217 218 219
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
220
	ret = sscanf(buf, "%u", &input);
L
Linus Torvalds 已提交
221

222
	mutex_lock(&dbs_mutex);
223
	if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
224
			input < MIN_FREQUENCY_UP_THRESHOLD) {
225
		mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
226 227 228 229
		return -EINVAL;
	}

	dbs_tuners_ins.up_threshold = input;
230
	mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
231 232 233 234

	return count;
}

235
static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
236 237 238 239 240 241
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;

	unsigned int j;
242

243
	ret = sscanf(buf, "%u", &input);
244 245 246 247 248
	if ( ret != 1 )
		return -EINVAL;

	if ( input > 1 )
		input = 1;
249

250
	mutex_lock(&dbs_mutex);
251
	if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
252
		mutex_unlock(&dbs_mutex);
253 254 255 256
		return count;
	}
	dbs_tuners_ins.ignore_nice = input;

257
	/* we need to re-evaluate prev_cpu_idle */
258
	for_each_online_cpu(j) {
259 260 261 262
		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 = get_jiffies_64();
263
	}
264
	mutex_unlock(&dbs_mutex);
265 266 267 268

	return count;
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
static ssize_t store_powersave_bias(struct cpufreq_policy *unused,
		const char *buf, size_t count)
{
	unsigned int input;
	int ret;
	ret = sscanf(buf, "%u", &input);

	if (ret != 1)
		return -EINVAL;

	if (input > 1000)
		input = 1000;

	mutex_lock(&dbs_mutex);
	dbs_tuners_ins.powersave_bias = input;
	ondemand_powersave_bias_init();
	mutex_unlock(&dbs_mutex);

	return count;
}

L
Linus Torvalds 已提交
290 291 292 293 294 295
#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(up_threshold);
296
define_one_rw(ignore_nice_load);
297
define_one_rw(powersave_bias);
L
Linus Torvalds 已提交
298 299 300 301 302 303

static struct attribute * dbs_attributes[] = {
	&sampling_rate_max.attr,
	&sampling_rate_min.attr,
	&sampling_rate.attr,
	&up_threshold.attr,
304
	&ignore_nice_load.attr,
305
	&powersave_bias.attr,
L
Linus Torvalds 已提交
306 307 308 309 310 311 312 313 314 315
	NULL
};

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

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

316
static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
L
Linus Torvalds 已提交
317
{
318 319 320
	unsigned int idle_ticks, total_ticks;
	unsigned int load;
	cputime64_t cur_jiffies;
L
Linus Torvalds 已提交
321 322 323 324 325 326 327

	struct cpufreq_policy *policy;
	unsigned int j;

	if (!this_dbs_info->enable)
		return;

328
	this_dbs_info->freq_lo = 0;
L
Linus Torvalds 已提交
329
	policy = this_dbs_info->cur_policy;
330 331 332 333
	cur_jiffies = jiffies64_to_cputime64(get_jiffies_64());
	total_ticks = (unsigned int) cputime64_sub(cur_jiffies,
			this_dbs_info->prev_cpu_wall);
	this_dbs_info->prev_cpu_wall = cur_jiffies;
334 335
	if (!total_ticks)
		return;
336
	/*
337 338
	 * Every sampling_rate, we check, if current idle time is less
	 * than 20% (default), then we try to increase frequency
339
	 * Every sampling_rate, we look for a the lowest
340 341
	 * frequency which can sustain the load while keeping idle time over
	 * 30%. If such a frequency exist, we try to decrease to this frequency.
L
Linus Torvalds 已提交
342
	 *
343 344 345
	 * Any frequency increase takes it to the maximum frequency.
	 * Frequency reduction happens at minimum steps of
	 * 5% (default) of current frequency
L
Linus Torvalds 已提交
346 347
	 */

348
	/* Get Idle Time */
349
	idle_ticks = UINT_MAX;
L
Linus Torvalds 已提交
350
	for_each_cpu_mask(j, policy->cpus) {
351 352
		cputime64_t total_idle_ticks;
		unsigned int tmp_idle_ticks;
L
Linus Torvalds 已提交
353 354 355
		struct cpu_dbs_info_s *j_dbs_info;

		j_dbs_info = &per_cpu(cpu_dbs_info, j);
356
		total_idle_ticks = get_cpu_idle_time(j);
357 358 359
		tmp_idle_ticks = (unsigned int) cputime64_sub(total_idle_ticks,
				j_dbs_info->prev_cpu_idle);
		j_dbs_info->prev_cpu_idle = total_idle_ticks;
L
Linus Torvalds 已提交
360 361 362 363

		if (tmp_idle_ticks < idle_ticks)
			idle_ticks = tmp_idle_ticks;
	}
364
	load = (100 * (total_ticks - idle_ticks)) / total_ticks;
L
Linus Torvalds 已提交
365

366 367
	/* Check for frequency increase */
	if (load > dbs_tuners_ins.up_threshold) {
368
		/* if we are already at full speed then break out early */
369 370 371 372 373 374 375 376 377 378 379 380
		if (!dbs_tuners_ins.powersave_bias) {
			if (policy->cur == policy->max)
				return;

			__cpufreq_driver_target(policy, policy->max,
				CPUFREQ_RELATION_H);
		} else {
			int freq = powersave_bias_target(policy, policy->max,
					CPUFREQ_RELATION_H);
			__cpufreq_driver_target(policy, freq,
				CPUFREQ_RELATION_L);
		}
L
Linus Torvalds 已提交
381 382 383 384
		return;
	}

	/* Check for frequency decrease */
385 386 387
	/* if we cannot reduce the frequency anymore, break out early */
	if (policy->cur == policy->min)
		return;
L
Linus Torvalds 已提交
388

389 390 391 392 393
	/*
	 * 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.
	 */
394
	if (load < (dbs_tuners_ins.up_threshold - 10)) {
395
		unsigned int freq_next = (policy->cur * load) /
396
			(dbs_tuners_ins.up_threshold - 10);
397 398 399 400 401 402 403 404 405
		if (!dbs_tuners_ins.powersave_bias) {
			__cpufreq_driver_target(policy, freq_next,
					CPUFREQ_RELATION_L);
		} else {
			int freq = powersave_bias_target(policy, freq_next,
					CPUFREQ_RELATION_L);
			__cpufreq_driver_target(policy, freq,
				CPUFREQ_RELATION_L);
		}
406
	}
L
Linus Torvalds 已提交
407 408
}

409 410 411
/* Sampling types */
enum {DBS_NORMAL_SAMPLE, DBS_SUB_SAMPLE};

L
Linus Torvalds 已提交
412
static void do_dbs_timer(void *data)
413
{
414 415
	unsigned int cpu = smp_processor_id();
	struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu);
416 417 418
	/* We want all CPUs to do sampling nearly on same jiffy */
	int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
	delay -= jiffies % delay;
419

420 421
	if (!dbs_info->enable)
		return;
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
	/* Common NORMAL_SAMPLE setup */
	INIT_WORK(&dbs_info->work, do_dbs_timer, (void *)DBS_NORMAL_SAMPLE);
	if (!dbs_tuners_ins.powersave_bias ||
	    (unsigned long) data == DBS_NORMAL_SAMPLE) {
		lock_cpu_hotplug();
		dbs_check_cpu(dbs_info);
		unlock_cpu_hotplug();
		if (dbs_info->freq_lo) {
			/* Setup timer for SUB_SAMPLE */
			INIT_WORK(&dbs_info->work, do_dbs_timer,
					(void *)DBS_SUB_SAMPLE);
			delay = dbs_info->freq_hi_jiffies;
		}
	} else {
		__cpufreq_driver_target(dbs_info->cur_policy,
	                        	dbs_info->freq_lo,
	                        	CPUFREQ_RELATION_H);
	}
440
	queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay);
441
}
L
Linus Torvalds 已提交
442

443
static inline void dbs_timer_init(unsigned int cpu)
L
Linus Torvalds 已提交
444
{
445
	struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu);
446 447 448
	/* We want all CPUs to do sampling nearly on same jiffy */
	int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
	delay -= jiffies % delay;
449

450
	ondemand_powersave_bias_init();
451
	INIT_WORK(&dbs_info->work, do_dbs_timer, 0);
452
	queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay);
L
Linus Torvalds 已提交
453 454
}

455
static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
L
Linus Torvalds 已提交
456
{
457 458 459
	dbs_info->enable = 0;
	cancel_delayed_work(&dbs_info->work);
	flush_workqueue(kondemand_wq);
L
Linus Torvalds 已提交
460 461 462 463 464 465 466 467 468 469 470 471 472
}

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:
473
		if ((!cpu_online(cpu)) || (!policy->cur))
L
Linus Torvalds 已提交
474 475 476
			return -EINVAL;

		if (policy->cpuinfo.transition_latency >
477 478 479
				(TRANSITION_LATENCY_LIMIT * 1000)) {
			printk(KERN_WARNING "ondemand governor failed to load "
			       "due to too long transition latency\n");
L
Linus Torvalds 已提交
480
			return -EINVAL;
481
		}
L
Linus Torvalds 已提交
482 483
		if (this_dbs_info->enable) /* Already enabled */
			break;
484

485
		mutex_lock(&dbs_mutex);
486 487 488 489 490 491 492 493 494 495
		dbs_enable++;
		if (dbs_enable == 1) {
			kondemand_wq = create_workqueue("kondemand");
			if (!kondemand_wq) {
				printk(KERN_ERR "Creation of kondemand failed\n");
				dbs_enable--;
				mutex_unlock(&dbs_mutex);
				return -ENOSPC;
			}
		}
L
Linus Torvalds 已提交
496 497 498 499
		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;
500

501 502
			j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j);
			j_dbs_info->prev_cpu_wall = get_jiffies_64();
L
Linus Torvalds 已提交
503 504 505 506 507 508 509 510 511 512
		}
		this_dbs_info->enable = 1;
		sysfs_create_group(&policy->kobj, &dbs_attr_group);
		/*
		 * 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 */
513 514 515
			latency = policy->cpuinfo.transition_latency / 1000;
			if (latency == 0)
				latency = 1;
L
Linus Torvalds 已提交
516

517
			def_sampling_rate = latency *
L
Linus Torvalds 已提交
518
					DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
519 520 521 522

			if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
				def_sampling_rate = MIN_STAT_SAMPLING_RATE;

L
Linus Torvalds 已提交
523 524
			dbs_tuners_ins.sampling_rate = def_sampling_rate;
		}
525
		dbs_timer_init(policy->cpu);
526

527
		mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
528 529 530
		break;

	case CPUFREQ_GOV_STOP:
531
		mutex_lock(&dbs_mutex);
532
		dbs_timer_exit(this_dbs_info);
L
Linus Torvalds 已提交
533 534
		sysfs_remove_group(&policy->kobj, &dbs_attr_group);
		dbs_enable--;
535
		if (dbs_enable == 0)
536
			destroy_workqueue(kondemand_wq);
537

538
		mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
539 540 541 542

		break;

	case CPUFREQ_GOV_LIMITS:
543
		mutex_lock(&dbs_mutex);
L
Linus Torvalds 已提交
544
		if (policy->max < this_dbs_info->cur_policy->cur)
545 546 547
			__cpufreq_driver_target(this_dbs_info->cur_policy,
			                        policy->max,
			                        CPUFREQ_RELATION_H);
L
Linus Torvalds 已提交
548
		else if (policy->min > this_dbs_info->cur_policy->cur)
549 550 551
			__cpufreq_driver_target(this_dbs_info->cur_policy,
			                        policy->min,
			                        CPUFREQ_RELATION_L);
552
		mutex_unlock(&dbs_mutex);
L
Linus Torvalds 已提交
553 554 555 556 557
		break;
	}
	return 0;
}

558
static struct cpufreq_governor cpufreq_gov_dbs = {
559 560 561
	.name = "ondemand",
	.governor = cpufreq_governor_dbs,
	.owner = THIS_MODULE,
L
Linus Torvalds 已提交
562 563 564 565 566 567 568 569 570 571 572 573 574
};

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

static void __exit cpufreq_gov_dbs_exit(void)
{
	cpufreq_unregister_governor(&cpufreq_gov_dbs);
}


575 576 577 578 579
MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>");
MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>");
MODULE_DESCRIPTION("'cpufreq_ondemand' - A dynamic cpufreq governor for "
                   "Low Latency Frequency Transition capable processors");
MODULE_LICENSE("GPL");
L
Linus Torvalds 已提交
580 581 582

module_init(cpufreq_gov_dbs_init);
module_exit(cpufreq_gov_dbs_exit);