cpufreq_ondemand.c 18.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  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.
 */

13 14
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

L
Linus Torvalds 已提交
15
#include <linux/cpufreq.h>
16 17
#include <linux/init.h>
#include <linux/kernel.h>
L
Linus Torvalds 已提交
18
#include <linux/kernel_stat.h>
19 20
#include <linux/kobject.h>
#include <linux/module.h>
21
#include <linux/mutex.h>
22
#include <linux/percpu-defs.h>
23
#include <linux/slab.h>
24
#include <linux/sysfs.h>
25
#include <linux/tick.h>
26
#include <linux/types.h>
27
#include <linux/cpu.h>
L
Linus Torvalds 已提交
28

29
#include "cpufreq_governor.h"
L
Linus Torvalds 已提交
30

31
/* On-demand governor macros */
32
#define DEF_FREQUENCY_DOWN_DIFFERENTIAL		(10)
L
Linus Torvalds 已提交
33
#define DEF_FREQUENCY_UP_THRESHOLD		(80)
34 35
#define DEF_SAMPLING_DOWN_FACTOR		(1)
#define MAX_SAMPLING_DOWN_FACTOR		(100000)
36 37
#define MICRO_FREQUENCY_DOWN_DIFFERENTIAL	(3)
#define MICRO_FREQUENCY_UP_THRESHOLD		(95)
38
#define MICRO_FREQUENCY_MIN_SAMPLE_RATE		(10000)
39
#define MIN_FREQUENCY_UP_THRESHOLD		(11)
L
Linus Torvalds 已提交
40 41
#define MAX_FREQUENCY_UP_THRESHOLD		(100)

42
static DEFINE_PER_CPU(struct od_cpu_dbs_info_s, od_cpu_dbs_info);
L
Linus Torvalds 已提交
43

44 45
static struct od_ops od_ops;

46 47 48 49
#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
static struct cpufreq_governor cpufreq_gov_ondemand;
#endif

50 51
static unsigned int default_powersave_bias;

52
static void ondemand_powersave_bias_init_cpu(int cpu)
53
{
54
	struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu);
55

56 57 58
	dbs_info->freq_table = cpufreq_frequency_get_table(cpu);
	dbs_info->freq_lo = 0;
}
59

60 61 62 63 64
/*
 * Not all CPUs want IO time to be accounted as busy; this depends on how
 * efficient idling at a higher frequency/voltage is.
 * Pavel Machek says this is not so for various generations of AMD and old
 * Intel systems.
65
 * Mike Chan (android.com) claims this is also not true for ARM.
66 67 68 69 70 71 72
 * Because of this, whitelist specific known (series) of CPUs by default, and
 * leave all others up to the user.
 */
static int should_io_be_busy(void)
{
#if defined(CONFIG_X86)
	/*
73
	 * For Intel, Core 2 (model 15) and later have an efficient idle.
74 75 76 77 78 79 80
	 */
	if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL &&
			boot_cpu_data.x86 == 6 &&
			boot_cpu_data.x86_model >= 15)
		return 1;
#endif
	return 0;
81 82
}

83 84 85 86 87
/*
 * 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.
 */
88
static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy,
89
		unsigned int freq_next, unsigned int relation)
90 91 92 93 94
{
	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;
95
	struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info,
96
						   policy->cpu);
97 98
	struct dbs_data *dbs_data = policy->governor_data;
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
99 100 101 102 103 104 105 106 107 108

	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;
109
	freq_reduc = freq_req * od_tuners->powersave_bias / 1000;
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
	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;
	}
128
	jiffies_total = usecs_to_jiffies(od_tuners->sampling_rate);
129 130 131 132 133 134 135 136 137 138 139 140 141 142
	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) {
143
		ondemand_powersave_bias_init_cpu(i);
144 145 146
	}
}

147 148
static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq)
{
149 150 151 152
	struct dbs_data *dbs_data = p->governor_data;
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;

	if (od_tuners->powersave_bias)
153 154
		freq = od_ops.powersave_bias_target(p, freq,
				CPUFREQ_RELATION_H);
155 156
	else if (p->cur == p->max)
		return;
157

158
	__cpufreq_driver_target(p, freq, od_tuners->powersave_bias ?
159 160 161 162 163
			CPUFREQ_RELATION_L : CPUFREQ_RELATION_H);
}

/*
 * Every sampling_rate, we check, if current idle time is less than 20%
164 165
 * (default), then we try to increase frequency. Every sampling_rate, we look
 * for the lowest frequency which can sustain the load while keeping idle time
166 167 168 169 170 171
 * over 30%. If such a frequency exist, we try to decrease to this frequency.
 *
 * Any frequency increase takes it to the maximum frequency. Frequency reduction
 * happens at minimum steps of 5% (default) of current frequency
 */
static void od_check_cpu(int cpu, unsigned int load_freq)
L
Linus Torvalds 已提交
172
{
173 174
	struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu);
	struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy;
175 176
	struct dbs_data *dbs_data = policy->governor_data;
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
177 178 179 180

	dbs_info->freq_lo = 0;

	/* Check for frequency increase */
181
	if (load_freq > od_tuners->up_threshold * policy->cur) {
182 183 184
		/* If switching to max speed, apply sampling_down_factor */
		if (policy->cur < policy->max)
			dbs_info->rate_mult =
185
				od_tuners->sampling_down_factor;
186 187 188 189 190 191 192 193 194 195 196 197 198 199
		dbs_freq_increase(policy, policy->max);
		return;
	}

	/* Check for frequency decrease */
	/* if we cannot reduce the frequency anymore, break out early */
	if (policy->cur == policy->min)
		return;

	/*
	 * 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.
	 */
200 201
	if (load_freq < od_tuners->adj_up_threshold
			* policy->cur) {
202
		unsigned int freq_next;
203
		freq_next = load_freq / od_tuners->adj_up_threshold;
204 205 206 207 208 209 210

		/* No longer fully busy, reset rate_mult */
		dbs_info->rate_mult = 1;

		if (freq_next < policy->min)
			freq_next = policy->min;

211
		if (!od_tuners->powersave_bias) {
212 213
			__cpufreq_driver_target(policy, freq_next,
					CPUFREQ_RELATION_L);
214
			return;
215
		}
216 217 218 219

		freq_next = od_ops.powersave_bias_target(policy, freq_next,
					CPUFREQ_RELATION_L);
		__cpufreq_driver_target(policy, freq_next, CPUFREQ_RELATION_L);
220
	}
L
Linus Torvalds 已提交
221 222
}

223
static void od_dbs_timer(struct work_struct *work)
224
{
225 226
	struct od_cpu_dbs_info_s *dbs_info =
		container_of(work, struct od_cpu_dbs_info_s, cdbs.work.work);
227
	unsigned int cpu = dbs_info->cdbs.cur_policy->cpu;
228 229
	struct od_cpu_dbs_info_s *core_dbs_info = &per_cpu(od_cpu_dbs_info,
			cpu);
230 231
	struct dbs_data *dbs_data = dbs_info->cdbs.cur_policy->governor_data;
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
232
	int delay = 0, sample_type = core_dbs_info->sample_type;
233
	bool modify_all = true;
234 235

	mutex_lock(&core_dbs_info->cdbs.timer_mutex);
236 237
	if (!need_load_eval(&core_dbs_info->cdbs, od_tuners->sampling_rate)) {
		modify_all = false;
238
		goto max_delay;
239
	}
L
Linus Torvalds 已提交
240

241
	/* Common NORMAL_SAMPLE setup */
242
	core_dbs_info->sample_type = OD_NORMAL_SAMPLE;
243
	if (sample_type == OD_SUB_SAMPLE) {
244
		delay = core_dbs_info->freq_lo_jiffies;
245 246
		__cpufreq_driver_target(core_dbs_info->cdbs.cur_policy,
				core_dbs_info->freq_lo, CPUFREQ_RELATION_H);
247
	} else {
248
		dbs_check_cpu(dbs_data, cpu);
249
		if (core_dbs_info->freq_lo) {
250
			/* Setup timer for SUB_SAMPLE */
251 252
			core_dbs_info->sample_type = OD_SUB_SAMPLE;
			delay = core_dbs_info->freq_hi_jiffies;
253 254 255
		}
	}

256 257 258 259 260
max_delay:
	if (!delay)
		delay = delay_for_sampling_rate(od_tuners->sampling_rate
				* core_dbs_info->rate_mult);

261
	gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy, delay, modify_all);
262
	mutex_unlock(&core_dbs_info->cdbs.timer_mutex);
263 264
}

265
/************************** sysfs interface ************************/
266
static struct common_dbs_data od_dbs_cdata;
L
Linus Torvalds 已提交
267

268 269 270 271
/**
 * update_sampling_rate - update sampling rate effective immediately if needed.
 * @new_rate: new sampling rate
 *
272
 * If new rate is smaller than the old, simply updating
273 274 275 276 277 278 279
 * dbs_tuners_int.sampling_rate might not be appropriate. For example, if the
 * original sampling_rate was 1 second and the requested new sampling rate is 10
 * ms because the user needs immediate reaction from ondemand governor, but not
 * sure if higher frequency will be required or not, then, the governor may
 * change the sampling rate too late; up to 1 second later. Thus, if we are
 * reducing the sampling rate, we need to make the new value effective
 * immediately.
280
 */
281 282
static void update_sampling_rate(struct dbs_data *dbs_data,
		unsigned int new_rate)
283
{
284
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
285 286
	int cpu;

287 288
	od_tuners->sampling_rate = new_rate = max(new_rate,
			dbs_data->min_sampling_rate);
289 290 291

	for_each_online_cpu(cpu) {
		struct cpufreq_policy *policy;
292
		struct od_cpu_dbs_info_s *dbs_info;
293 294 295 296 297
		unsigned long next_sampling, appointed_at;

		policy = cpufreq_cpu_get(cpu);
		if (!policy)
			continue;
298 299 300 301
		if (policy->governor != &cpufreq_gov_ondemand) {
			cpufreq_cpu_put(policy);
			continue;
		}
302
		dbs_info = &per_cpu(od_cpu_dbs_info, cpu);
303 304
		cpufreq_cpu_put(policy);

305
		mutex_lock(&dbs_info->cdbs.timer_mutex);
306

307 308
		if (!delayed_work_pending(&dbs_info->cdbs.work)) {
			mutex_unlock(&dbs_info->cdbs.timer_mutex);
309 310 311
			continue;
		}

312 313
		next_sampling = jiffies + usecs_to_jiffies(new_rate);
		appointed_at = dbs_info->cdbs.work.timer.expires;
314 315 316

		if (time_before(next_sampling, appointed_at)) {

317 318 319
			mutex_unlock(&dbs_info->cdbs.timer_mutex);
			cancel_delayed_work_sync(&dbs_info->cdbs.work);
			mutex_lock(&dbs_info->cdbs.timer_mutex);
320

321 322
			gov_queue_work(dbs_data, dbs_info->cdbs.cur_policy,
					usecs_to_jiffies(new_rate), true);
323 324

		}
325
		mutex_unlock(&dbs_info->cdbs.timer_mutex);
326 327 328
	}
}

329 330
static ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf,
		size_t count)
L
Linus Torvalds 已提交
331 332 333
{
	unsigned int input;
	int ret;
334
	ret = sscanf(buf, "%u", &input);
335 336
	if (ret != 1)
		return -EINVAL;
337 338

	update_sampling_rate(dbs_data, input);
L
Linus Torvalds 已提交
339 340 341
	return count;
}

342 343
static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf,
		size_t count)
344
{
345
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
346 347
	unsigned int input;
	int ret;
348
	unsigned int j;
349 350 351 352

	ret = sscanf(buf, "%u", &input);
	if (ret != 1)
		return -EINVAL;
353
	od_tuners->io_is_busy = !!input;
354 355 356 357 358 359 360 361

	/* we need to re-evaluate prev_cpu_idle */
	for_each_online_cpu(j) {
		struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info,
									j);
		dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
			&dbs_info->cdbs.prev_cpu_wall, od_tuners->io_is_busy);
	}
362 363 364
	return count;
}

365 366
static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf,
		size_t count)
L
Linus Torvalds 已提交
367
{
368
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
L
Linus Torvalds 已提交
369 370
	unsigned int input;
	int ret;
371
	ret = sscanf(buf, "%u", &input);
L
Linus Torvalds 已提交
372

373
	if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
374
			input < MIN_FREQUENCY_UP_THRESHOLD) {
L
Linus Torvalds 已提交
375 376
		return -EINVAL;
	}
377
	/* Calculate the new adj_up_threshold */
378 379
	od_tuners->adj_up_threshold += input;
	od_tuners->adj_up_threshold -= od_tuners->up_threshold;
380

381
	od_tuners->up_threshold = input;
L
Linus Torvalds 已提交
382 383 384
	return count;
}

385 386
static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data,
		const char *buf, size_t count)
387
{
388
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
389 390 391 392 393 394
	unsigned int input, j;
	int ret;
	ret = sscanf(buf, "%u", &input);

	if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
		return -EINVAL;
395
	od_tuners->sampling_down_factor = input;
396 397 398

	/* Reset down sampling multiplier in case it was active */
	for_each_online_cpu(j) {
399 400
		struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info,
				j);
401 402 403 404 405
		dbs_info->rate_mult = 1;
	}
	return count;
}

406 407
static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data,
		const char *buf, size_t count)
408
{
409
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
410 411 412 413
	unsigned int input;
	int ret;

	unsigned int j;
414

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

419
	if (input > 1)
420
		input = 1;
421

422
	if (input == od_tuners->ignore_nice_load) { /* nothing to do */
423 424
		return count;
	}
425
	od_tuners->ignore_nice_load = input;
426

427
	/* we need to re-evaluate prev_cpu_idle */
428
	for_each_online_cpu(j) {
429
		struct od_cpu_dbs_info_s *dbs_info;
430
		dbs_info = &per_cpu(od_cpu_dbs_info, j);
431
		dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
432
			&dbs_info->cdbs.prev_cpu_wall, od_tuners->io_is_busy);
433
		if (od_tuners->ignore_nice_load)
434 435
			dbs_info->cdbs.prev_cpu_nice =
				kcpustat_cpu(j).cpustat[CPUTIME_NICE];
436

437 438 439 440
	}
	return count;
}

441 442
static ssize_t store_powersave_bias(struct dbs_data *dbs_data, const char *buf,
		size_t count)
443
{
444
	struct od_dbs_tuners *od_tuners = dbs_data->tuners;
445 446 447 448 449 450 451 452 453 454
	unsigned int input;
	int ret;
	ret = sscanf(buf, "%u", &input);

	if (ret != 1)
		return -EINVAL;

	if (input > 1000)
		input = 1000;

455
	od_tuners->powersave_bias = input;
456 457 458 459
	ondemand_powersave_bias_init();
	return count;
}

460 461 462 463
show_store_one(od, sampling_rate);
show_store_one(od, io_is_busy);
show_store_one(od, up_threshold);
show_store_one(od, sampling_down_factor);
464
show_store_one(od, ignore_nice_load);
465 466 467 468 469 470 471
show_store_one(od, powersave_bias);
declare_show_sampling_rate_min(od);

gov_sys_pol_attr_rw(sampling_rate);
gov_sys_pol_attr_rw(io_is_busy);
gov_sys_pol_attr_rw(up_threshold);
gov_sys_pol_attr_rw(sampling_down_factor);
472
gov_sys_pol_attr_rw(ignore_nice_load);
473 474 475 476 477 478 479 480
gov_sys_pol_attr_rw(powersave_bias);
gov_sys_pol_attr_ro(sampling_rate_min);

static struct attribute *dbs_attributes_gov_sys[] = {
	&sampling_rate_min_gov_sys.attr,
	&sampling_rate_gov_sys.attr,
	&up_threshold_gov_sys.attr,
	&sampling_down_factor_gov_sys.attr,
481
	&ignore_nice_load_gov_sys.attr,
482 483
	&powersave_bias_gov_sys.attr,
	&io_is_busy_gov_sys.attr,
L
Linus Torvalds 已提交
484 485 486
	NULL
};

487 488 489 490 491 492 493 494 495 496
static struct attribute_group od_attr_group_gov_sys = {
	.attrs = dbs_attributes_gov_sys,
	.name = "ondemand",
};

static struct attribute *dbs_attributes_gov_pol[] = {
	&sampling_rate_min_gov_pol.attr,
	&sampling_rate_gov_pol.attr,
	&up_threshold_gov_pol.attr,
	&sampling_down_factor_gov_pol.attr,
497
	&ignore_nice_load_gov_pol.attr,
498 499 500 501 502 503 504
	&powersave_bias_gov_pol.attr,
	&io_is_busy_gov_pol.attr,
	NULL
};

static struct attribute_group od_attr_group_gov_pol = {
	.attrs = dbs_attributes_gov_pol,
L
Linus Torvalds 已提交
505 506 507 508 509
	.name = "ondemand",
};

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

510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
static int od_init(struct dbs_data *dbs_data)
{
	struct od_dbs_tuners *tuners;
	u64 idle_time;
	int cpu;

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

	cpu = get_cpu();
	idle_time = get_cpu_idle_time_us(cpu, NULL);
	put_cpu();
	if (idle_time != -1ULL) {
		/* Idle micro accounting is supported. Use finer thresholds */
		tuners->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD;
		tuners->adj_up_threshold = MICRO_FREQUENCY_UP_THRESHOLD -
			MICRO_FREQUENCY_DOWN_DIFFERENTIAL;
		/*
		 * In nohz/micro accounting case we set the minimum frequency
		 * not depending on HZ, but fixed (very low). The deferred
		 * timer might skip some samples if idle/sleeping as needed.
		*/
		dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE;
	} else {
		tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
		tuners->adj_up_threshold = DEF_FREQUENCY_UP_THRESHOLD -
			DEF_FREQUENCY_DOWN_DIFFERENTIAL;

		/* For correct statistics, we need 10 ticks for each measure */
		dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
			jiffies_to_usecs(10);
	}

	tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;
547
	tuners->ignore_nice_load = 0;
548
	tuners->powersave_bias = default_powersave_bias;
549 550 551 552 553 554 555 556 557 558 559 560
	tuners->io_is_busy = should_io_be_busy();

	dbs_data->tuners = tuners;
	mutex_init(&dbs_data->mutex);
	return 0;
}

static void od_exit(struct dbs_data *dbs_data)
{
	kfree(dbs_data->tuners);
}

561
define_get_cpu_dbs_routines(od_cpu_dbs_info);
562

563 564
static struct od_ops od_ops = {
	.powersave_bias_init_cpu = ondemand_powersave_bias_init_cpu,
565
	.powersave_bias_target = generic_powersave_bias_target,
566 567
	.freq_increase = dbs_freq_increase,
};
568

569
static struct common_dbs_data od_dbs_cdata = {
570
	.governor = GOV_ONDEMAND,
571 572
	.attr_group_gov_sys = &od_attr_group_gov_sys,
	.attr_group_gov_pol = &od_attr_group_gov_pol,
573 574 575 576 577
	.get_cpu_cdbs = get_cpu_cdbs,
	.get_cpu_dbs_info_s = get_cpu_dbs_info_s,
	.gov_dbs_timer = od_dbs_timer,
	.gov_check_cpu = od_check_cpu,
	.gov_ops = &od_ops,
578 579
	.init = od_init,
	.exit = od_exit,
580
};
L
Linus Torvalds 已提交
581

582 583 584 585 586 587 588 589
static void od_set_powersave_bias(unsigned int powersave_bias)
{
	struct cpufreq_policy *policy;
	struct dbs_data *dbs_data;
	struct od_dbs_tuners *od_tuners;
	unsigned int cpu;
	cpumask_t done;

590
	default_powersave_bias = powersave_bias;
591 592 593 594 595 596 597 598
	cpumask_clear(&done);

	get_online_cpus();
	for_each_online_cpu(cpu) {
		if (cpumask_test_cpu(cpu, &done))
			continue;

		policy = per_cpu(od_cpu_dbs_info, cpu).cdbs.cur_policy;
599 600
		if (!policy)
			continue;
601 602

		cpumask_or(&done, &done, policy->cpus);
603 604 605 606 607 608 609

		if (policy->governor != &cpufreq_gov_ondemand)
			continue;

		dbs_data = policy->governor_data;
		od_tuners = dbs_data->tuners;
		od_tuners->powersave_bias = default_powersave_bias;
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
	}
	put_online_cpus();
}

void od_register_powersave_bias_handler(unsigned int (*f)
		(struct cpufreq_policy *, unsigned int, unsigned int),
		unsigned int powersave_bias)
{
	od_ops.powersave_bias_target = f;
	od_set_powersave_bias(powersave_bias);
}
EXPORT_SYMBOL_GPL(od_register_powersave_bias_handler);

void od_unregister_powersave_bias_handler(void)
{
	od_ops.powersave_bias_target = generic_powersave_bias_target;
	od_set_powersave_bias(0);
}
EXPORT_SYMBOL_GPL(od_unregister_powersave_bias_handler);

630 631
static int od_cpufreq_governor_dbs(struct cpufreq_policy *policy,
		unsigned int event)
L
Linus Torvalds 已提交
632
{
633
	return cpufreq_governor_dbs(policy, &od_dbs_cdata, event);
L
Linus Torvalds 已提交
634 635
}

636 637
#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
static
638
#endif
639 640 641 642 643 644
struct cpufreq_governor cpufreq_gov_ondemand = {
	.name			= "ondemand",
	.governor		= od_cpufreq_governor_dbs,
	.max_transition_latency	= TRANSITION_LATENCY_LIMIT,
	.owner			= THIS_MODULE,
};
L
Linus Torvalds 已提交
645 646 647

static int __init cpufreq_gov_dbs_init(void)
{
648
	return cpufreq_register_governor(&cpufreq_gov_ondemand);
L
Linus Torvalds 已提交
649 650 651 652
}

static void __exit cpufreq_gov_dbs_exit(void)
{
653
	cpufreq_unregister_governor(&cpufreq_gov_ondemand);
L
Linus Torvalds 已提交
654 655
}

656 657 658
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 "
659
	"Low Latency Frequency Transition capable processors");
660
MODULE_LICENSE("GPL");
L
Linus Torvalds 已提交
661

662 663 664
#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
fs_initcall(cpufreq_gov_dbs_init);
#else
L
Linus Torvalds 已提交
665
module_init(cpufreq_gov_dbs_init);
666
#endif
L
Linus Torvalds 已提交
667
module_exit(cpufreq_gov_dbs_exit);