blob: c4c578defabfa0e5df0251d430fde58fee7d45ab [file] [log] [blame]
Dave Jonesb9170832005-05-31 19:03:47 -07001/*
2 * drivers/cpufreq/cpufreq_conservative.c
3 *
4 * Copyright (C) 2001 Russell King
5 * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
6 * Jun Nakajima <jun.nakajima@intel.com>
7 * (C) 2004 Alexander Clouter <alex-kernel@digriz.org.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/smp.h>
17#include <linux/init.h>
18#include <linux/interrupt.h>
19#include <linux/ctype.h>
20#include <linux/cpufreq.h>
21#include <linux/sysctl.h>
22#include <linux/types.h>
23#include <linux/fs.h>
24#include <linux/sysfs.h>
Andrew Morton138a01282006-06-23 03:31:19 -070025#include <linux/cpu.h>
Dave Jonesb9170832005-05-31 19:03:47 -070026#include <linux/sched.h>
27#include <linux/kmod.h>
28#include <linux/workqueue.h>
29#include <linux/jiffies.h>
30#include <linux/kernel_stat.h>
31#include <linux/percpu.h>
akpm@osdl.org3fc54d32006-01-13 15:54:22 -080032#include <linux/mutex.h>
Dave Jonesb9170832005-05-31 19:03:47 -070033/*
34 * dbs is used in this file as a shortform for demandbased switching
35 * It helps to keep variable names smaller, simpler
36 */
37
38#define DEF_FREQUENCY_UP_THRESHOLD (80)
Dave Jonesb9170832005-05-31 19:03:47 -070039#define DEF_FREQUENCY_DOWN_THRESHOLD (20)
Dave Jonesb9170832005-05-31 19:03:47 -070040
41/*
42 * The polling frequency of this governor depends on the capability of
43 * the processor. Default polling frequency is 1000 times the transition
44 * latency of the processor. The governor will work on any processor with
45 * transition latency <= 10mS, using appropriate sampling
46 * rate.
47 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
48 * this governor will not work.
49 * All times here are in uS.
50 */
51static unsigned int def_sampling_rate;
Alexander Clouter2c906b32006-03-22 09:54:10 +000052#define MIN_SAMPLING_RATE_RATIO (2)
53/* for correct statistics, we need at least 10 ticks between each measure */
54#define MIN_STAT_SAMPLING_RATE (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
55#define MIN_SAMPLING_RATE (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
Dave Jonesb9170832005-05-31 19:03:47 -070056#define MAX_SAMPLING_RATE (500 * def_sampling_rate)
Alexander Clouter2c906b32006-03-22 09:54:10 +000057#define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER (1000)
58#define DEF_SAMPLING_DOWN_FACTOR (1)
59#define MAX_SAMPLING_DOWN_FACTOR (10)
Dave Jonesb9170832005-05-31 19:03:47 -070060#define TRANSITION_LATENCY_LIMIT (10 * 1000)
61
62static void do_dbs_timer(void *data);
63
64struct cpu_dbs_info_s {
65 struct cpufreq_policy *cur_policy;
66 unsigned int prev_cpu_idle_up;
67 unsigned int prev_cpu_idle_down;
68 unsigned int enable;
Alexander Cloutera159b822006-03-22 10:00:18 +000069 unsigned int down_skip;
70 unsigned int requested_freq;
Dave Jonesb9170832005-05-31 19:03:47 -070071};
72static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
73
74static unsigned int dbs_enable; /* number of CPUs using this policy */
75
Venkatesh Pallipadi4ec223d2006-06-21 15:18:34 -070076/*
77 * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug
78 * lock and dbs_mutex. cpu_hotplug lock should always be held before
79 * dbs_mutex. If any function that can potentially take cpu_hotplug lock
80 * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then
81 * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
82 * is recursive for the same process. -Venki
83 */
akpm@osdl.org3fc54d32006-01-13 15:54:22 -080084static DEFINE_MUTEX (dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -070085static DECLARE_WORK (dbs_work, do_dbs_timer, NULL);
86
87struct dbs_tuners {
88 unsigned int sampling_rate;
89 unsigned int sampling_down_factor;
90 unsigned int up_threshold;
91 unsigned int down_threshold;
92 unsigned int ignore_nice;
93 unsigned int freq_step;
94};
95
96static struct dbs_tuners dbs_tuners_ins = {
97 .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
98 .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,
99 .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,
Mattia Dongilic326e272006-03-27 22:55:55 +0200100 .ignore_nice = 0,
101 .freq_step = 5,
Dave Jonesb9170832005-05-31 19:03:47 -0700102};
103
Dave Jonesdac1c1a2005-05-31 19:03:49 -0700104static inline unsigned int get_cpu_idle_time(unsigned int cpu)
105{
106 return kstat_cpu(cpu).cpustat.idle +
107 kstat_cpu(cpu).cpustat.iowait +
Alexander Clouter001893c2005-12-01 01:09:25 -0800108 ( dbs_tuners_ins.ignore_nice ?
Dave Jonesdac1c1a2005-05-31 19:03:49 -0700109 kstat_cpu(cpu).cpustat.nice :
110 0);
111}
112
Dave Jonesb9170832005-05-31 19:03:47 -0700113/************************** sysfs interface ************************/
114static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
115{
116 return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
117}
118
119static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
120{
121 return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
122}
123
124#define define_one_ro(_name) \
125static struct freq_attr _name = \
126__ATTR(_name, 0444, show_##_name, NULL)
127
128define_one_ro(sampling_rate_max);
129define_one_ro(sampling_rate_min);
130
131/* cpufreq_conservative Governor Tunables */
132#define show_one(file_name, object) \
133static ssize_t show_##file_name \
134(struct cpufreq_policy *unused, char *buf) \
135{ \
136 return sprintf(buf, "%u\n", dbs_tuners_ins.object); \
137}
138show_one(sampling_rate, sampling_rate);
139show_one(sampling_down_factor, sampling_down_factor);
140show_one(up_threshold, up_threshold);
141show_one(down_threshold, down_threshold);
Alexander Clouter001893c2005-12-01 01:09:25 -0800142show_one(ignore_nice_load, ignore_nice);
Dave Jonesb9170832005-05-31 19:03:47 -0700143show_one(freq_step, freq_step);
144
145static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused,
146 const char *buf, size_t count)
147{
148 unsigned int input;
149 int ret;
150 ret = sscanf (buf, "%u", &input);
Alexander Clouter2c906b32006-03-22 09:54:10 +0000151 if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
Dave Jonesb9170832005-05-31 19:03:47 -0700152 return -EINVAL;
153
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800154 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700155 dbs_tuners_ins.sampling_down_factor = input;
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800156 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700157
158 return count;
159}
160
161static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
162 const char *buf, size_t count)
163{
164 unsigned int input;
165 int ret;
166 ret = sscanf (buf, "%u", &input);
167
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800168 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700169 if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800170 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700171 return -EINVAL;
172 }
173
174 dbs_tuners_ins.sampling_rate = input;
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800175 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700176
177 return count;
178}
179
180static ssize_t store_up_threshold(struct cpufreq_policy *unused,
181 const char *buf, size_t count)
182{
183 unsigned int input;
184 int ret;
185 ret = sscanf (buf, "%u", &input);
186
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800187 mutex_lock(&dbs_mutex);
Dave Jonesb82fbe62006-04-01 22:07:07 -0500188 if (ret != 1 || input > 100 || input <= dbs_tuners_ins.down_threshold) {
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800189 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700190 return -EINVAL;
191 }
192
193 dbs_tuners_ins.up_threshold = input;
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800194 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700195
196 return count;
197}
198
199static ssize_t store_down_threshold(struct cpufreq_policy *unused,
200 const char *buf, size_t count)
201{
202 unsigned int input;
203 int ret;
204 ret = sscanf (buf, "%u", &input);
205
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800206 mutex_lock(&dbs_mutex);
Dave Jonesb82fbe62006-04-01 22:07:07 -0500207 if (ret != 1 || input > 100 || input >= dbs_tuners_ins.up_threshold) {
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800208 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700209 return -EINVAL;
210 }
211
212 dbs_tuners_ins.down_threshold = input;
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800213 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700214
215 return count;
216}
217
Alexander Clouter001893c2005-12-01 01:09:25 -0800218static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
Dave Jonesb9170832005-05-31 19:03:47 -0700219 const char *buf, size_t count)
220{
221 unsigned int input;
222 int ret;
223
224 unsigned int j;
225
226 ret = sscanf (buf, "%u", &input);
227 if ( ret != 1 )
228 return -EINVAL;
229
230 if ( input > 1 )
231 input = 1;
232
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800233 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700234 if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800235 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700236 return count;
237 }
238 dbs_tuners_ins.ignore_nice = input;
239
240 /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
Dave Jonesdac1c1a2005-05-31 19:03:49 -0700241 for_each_online_cpu(j) {
Dave Jonesb9170832005-05-31 19:03:47 -0700242 struct cpu_dbs_info_s *j_dbs_info;
243 j_dbs_info = &per_cpu(cpu_dbs_info, j);
Dave Jonesdac1c1a2005-05-31 19:03:49 -0700244 j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
Dave Jonesb9170832005-05-31 19:03:47 -0700245 j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
246 }
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800247 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700248
249 return count;
250}
251
252static ssize_t store_freq_step(struct cpufreq_policy *policy,
253 const char *buf, size_t count)
254{
255 unsigned int input;
256 int ret;
257
258 ret = sscanf (buf, "%u", &input);
259
260 if ( ret != 1 )
261 return -EINVAL;
262
263 if ( input > 100 )
264 input = 100;
265
266 /* no need to test here if freq_step is zero as the user might actually
267 * want this, they would be crazy though :) */
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800268 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700269 dbs_tuners_ins.freq_step = input;
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800270 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700271
272 return count;
273}
274
275#define define_one_rw(_name) \
276static struct freq_attr _name = \
277__ATTR(_name, 0644, show_##_name, store_##_name)
278
279define_one_rw(sampling_rate);
280define_one_rw(sampling_down_factor);
281define_one_rw(up_threshold);
282define_one_rw(down_threshold);
Alexander Clouter001893c2005-12-01 01:09:25 -0800283define_one_rw(ignore_nice_load);
Dave Jonesb9170832005-05-31 19:03:47 -0700284define_one_rw(freq_step);
285
286static struct attribute * dbs_attributes[] = {
287 &sampling_rate_max.attr,
288 &sampling_rate_min.attr,
289 &sampling_rate.attr,
290 &sampling_down_factor.attr,
291 &up_threshold.attr,
292 &down_threshold.attr,
Alexander Clouter001893c2005-12-01 01:09:25 -0800293 &ignore_nice_load.attr,
Dave Jonesb9170832005-05-31 19:03:47 -0700294 &freq_step.attr,
295 NULL
296};
297
298static struct attribute_group dbs_attr_group = {
299 .attrs = dbs_attributes,
300 .name = "conservative",
301};
302
303/************************** sysfs end ************************/
304
305static void dbs_check_cpu(int cpu)
306{
307 unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
Alexander Clouter08a28e22006-03-22 09:59:16 +0000308 unsigned int tmp_idle_ticks, total_idle_ticks;
Dave Jonesb9170832005-05-31 19:03:47 -0700309 unsigned int freq_step;
310 unsigned int freq_down_sampling_rate;
Alexander Clouter08a28e22006-03-22 09:59:16 +0000311 struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
Dave Jonesb9170832005-05-31 19:03:47 -0700312 struct cpufreq_policy *policy;
Dave Jonesb9170832005-05-31 19:03:47 -0700313
Dave Jonesb9170832005-05-31 19:03:47 -0700314 if (!this_dbs_info->enable)
315 return;
316
Alexander Clouter08a28e22006-03-22 09:59:16 +0000317 policy = this_dbs_info->cur_policy;
318
Dave Jonesb9170832005-05-31 19:03:47 -0700319 /*
320 * The default safe range is 20% to 80%
321 * Every sampling_rate, we check
322 * - If current idle time is less than 20%, then we try to
323 * increase frequency
324 * Every sampling_rate*sampling_down_factor, we check
325 * - If current idle time is more than 80%, then we try to
326 * decrease frequency
327 *
328 * Any frequency increase takes it to the maximum frequency.
329 * Frequency reduction happens at minimum steps of
330 * 5% (default) of max_frequency
331 */
332
333 /* Check for frequency increase */
Dave Jones9c7d2692005-05-31 19:03:49 -0700334 idle_ticks = UINT_MAX;
Dave Jonesb9170832005-05-31 19:03:47 -0700335
Alexander Clouter08a28e22006-03-22 09:59:16 +0000336 /* Check for frequency increase */
337 total_idle_ticks = get_cpu_idle_time(cpu);
338 tmp_idle_ticks = total_idle_ticks -
339 this_dbs_info->prev_cpu_idle_up;
340 this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
Dave Jonesb9170832005-05-31 19:03:47 -0700341
Alexander Clouter08a28e22006-03-22 09:59:16 +0000342 if (tmp_idle_ticks < idle_ticks)
343 idle_ticks = tmp_idle_ticks;
Dave Jonesb9170832005-05-31 19:03:47 -0700344
345 /* Scale idle ticks by 100 and compare with up and down ticks */
346 idle_ticks *= 100;
347 up_idle_ticks = (100 - dbs_tuners_ins.up_threshold) *
Alexander Clouter2c906b32006-03-22 09:54:10 +0000348 usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
Dave Jonesb9170832005-05-31 19:03:47 -0700349
350 if (idle_ticks < up_idle_ticks) {
Alexander Cloutera159b822006-03-22 10:00:18 +0000351 this_dbs_info->down_skip = 0;
Alexander Clouter08a28e22006-03-22 09:59:16 +0000352 this_dbs_info->prev_cpu_idle_down =
353 this_dbs_info->prev_cpu_idle_up;
Dave Jones790d76f2005-05-31 19:03:49 -0700354
Dave Jonesb9170832005-05-31 19:03:47 -0700355 /* if we are already at full speed then break out early */
Alexander Cloutera159b822006-03-22 10:00:18 +0000356 if (this_dbs_info->requested_freq == policy->max)
Dave Jonesb9170832005-05-31 19:03:47 -0700357 return;
358
359 freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
360
361 /* max freq cannot be less than 100. But who knows.... */
362 if (unlikely(freq_step == 0))
363 freq_step = 5;
364
Alexander Cloutera159b822006-03-22 10:00:18 +0000365 this_dbs_info->requested_freq += freq_step;
366 if (this_dbs_info->requested_freq > policy->max)
367 this_dbs_info->requested_freq = policy->max;
Dave Jonesb9170832005-05-31 19:03:47 -0700368
Alexander Cloutera159b822006-03-22 10:00:18 +0000369 __cpufreq_driver_target(policy, this_dbs_info->requested_freq,
Dave Jonesb9170832005-05-31 19:03:47 -0700370 CPUFREQ_RELATION_H);
Dave Jonesb9170832005-05-31 19:03:47 -0700371 return;
372 }
373
374 /* Check for frequency decrease */
Alexander Cloutera159b822006-03-22 10:00:18 +0000375 this_dbs_info->down_skip++;
376 if (this_dbs_info->down_skip < dbs_tuners_ins.sampling_down_factor)
Dave Jonesb9170832005-05-31 19:03:47 -0700377 return;
378
Alexander Clouter08a28e22006-03-22 09:59:16 +0000379 /* Check for frequency decrease */
380 total_idle_ticks = this_dbs_info->prev_cpu_idle_up;
381 tmp_idle_ticks = total_idle_ticks -
382 this_dbs_info->prev_cpu_idle_down;
383 this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
Dave Jonesb9170832005-05-31 19:03:47 -0700384
Alexander Clouter08a28e22006-03-22 09:59:16 +0000385 if (tmp_idle_ticks < idle_ticks)
386 idle_ticks = tmp_idle_ticks;
Dave Jonesb9170832005-05-31 19:03:47 -0700387
388 /* Scale idle ticks by 100 and compare with up and down ticks */
389 idle_ticks *= 100;
Alexander Cloutera159b822006-03-22 10:00:18 +0000390 this_dbs_info->down_skip = 0;
Dave Jonesb9170832005-05-31 19:03:47 -0700391
392 freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
393 dbs_tuners_ins.sampling_down_factor;
394 down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
Alexander Clouter2c906b32006-03-22 09:54:10 +0000395 usecs_to_jiffies(freq_down_sampling_rate);
Dave Jonesb9170832005-05-31 19:03:47 -0700396
Dave Jones9c7d2692005-05-31 19:03:49 -0700397 if (idle_ticks > down_idle_ticks) {
Alexander Clouter2c906b32006-03-22 09:54:10 +0000398 /*
399 * if we are already at the lowest speed then break out early
Dave Jonesb9170832005-05-31 19:03:47 -0700400 * or if we 'cannot' reduce the speed as the user might want
Alexander Clouter2c906b32006-03-22 09:54:10 +0000401 * freq_step to be zero
402 */
Alexander Cloutera159b822006-03-22 10:00:18 +0000403 if (this_dbs_info->requested_freq == policy->min
Dave Jonesb9170832005-05-31 19:03:47 -0700404 || dbs_tuners_ins.freq_step == 0)
405 return;
406
407 freq_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
408
409 /* max freq cannot be less than 100. But who knows.... */
410 if (unlikely(freq_step == 0))
411 freq_step = 5;
412
Alexander Cloutera159b822006-03-22 10:00:18 +0000413 this_dbs_info->requested_freq -= freq_step;
414 if (this_dbs_info->requested_freq < policy->min)
415 this_dbs_info->requested_freq = policy->min;
Dave Jonesb9170832005-05-31 19:03:47 -0700416
Alexander Cloutera159b822006-03-22 10:00:18 +0000417 __cpufreq_driver_target(policy, this_dbs_info->requested_freq,
Alexander Clouter2c906b32006-03-22 09:54:10 +0000418 CPUFREQ_RELATION_H);
Dave Jonesb9170832005-05-31 19:03:47 -0700419 return;
420 }
421}
422
423static void do_dbs_timer(void *data)
424{
425 int i;
Venkatesh Pallipadi4ec223d2006-06-21 15:18:34 -0700426 lock_cpu_hotplug();
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800427 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700428 for_each_online_cpu(i)
429 dbs_check_cpu(i);
430 schedule_delayed_work(&dbs_work,
431 usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800432 mutex_unlock(&dbs_mutex);
Venkatesh Pallipadi4ec223d2006-06-21 15:18:34 -0700433 unlock_cpu_hotplug();
Dave Jonesb9170832005-05-31 19:03:47 -0700434}
435
436static inline void dbs_timer_init(void)
437{
438 INIT_WORK(&dbs_work, do_dbs_timer, NULL);
439 schedule_delayed_work(&dbs_work,
440 usecs_to_jiffies(dbs_tuners_ins.sampling_rate));
441 return;
442}
443
444static inline void dbs_timer_exit(void)
445{
446 cancel_delayed_work(&dbs_work);
447 return;
448}
449
450static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
451 unsigned int event)
452{
453 unsigned int cpu = policy->cpu;
454 struct cpu_dbs_info_s *this_dbs_info;
455 unsigned int j;
456
457 this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
458
459 switch (event) {
460 case CPUFREQ_GOV_START:
461 if ((!cpu_online(cpu)) ||
462 (!policy->cur))
463 return -EINVAL;
464
465 if (policy->cpuinfo.transition_latency >
466 (TRANSITION_LATENCY_LIMIT * 1000))
467 return -EINVAL;
468 if (this_dbs_info->enable) /* Already enabled */
469 break;
470
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800471 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700472 for_each_cpu_mask(j, policy->cpus) {
473 struct cpu_dbs_info_s *j_dbs_info;
474 j_dbs_info = &per_cpu(cpu_dbs_info, j);
475 j_dbs_info->cur_policy = policy;
476
Alexander Clouter08a28e22006-03-22 09:59:16 +0000477 j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu);
Dave Jonesb9170832005-05-31 19:03:47 -0700478 j_dbs_info->prev_cpu_idle_down
479 = j_dbs_info->prev_cpu_idle_up;
480 }
481 this_dbs_info->enable = 1;
Alexander Cloutera159b822006-03-22 10:00:18 +0000482 this_dbs_info->down_skip = 0;
483 this_dbs_info->requested_freq = policy->cur;
Dave Jonesb9170832005-05-31 19:03:47 -0700484 sysfs_create_group(&policy->kobj, &dbs_attr_group);
485 dbs_enable++;
486 /*
487 * Start the timerschedule work, when this governor
488 * is used for first time
489 */
490 if (dbs_enable == 1) {
491 unsigned int latency;
492 /* policy latency is in nS. Convert it to uS first */
Alexander Clouter2c906b32006-03-22 09:54:10 +0000493 latency = policy->cpuinfo.transition_latency / 1000;
494 if (latency == 0)
495 latency = 1;
Dave Jonesb9170832005-05-31 19:03:47 -0700496
Alexander Cloutere8a02572006-03-22 09:56:23 +0000497 def_sampling_rate = 10 * latency *
Dave Jonesb9170832005-05-31 19:03:47 -0700498 DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
Alexander Clouter2c906b32006-03-22 09:54:10 +0000499
500 if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
501 def_sampling_rate = MIN_STAT_SAMPLING_RATE;
502
Dave Jonesb9170832005-05-31 19:03:47 -0700503 dbs_tuners_ins.sampling_rate = def_sampling_rate;
Dave Jonesb9170832005-05-31 19:03:47 -0700504
505 dbs_timer_init();
506 }
507
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800508 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700509 break;
510
511 case CPUFREQ_GOV_STOP:
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800512 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700513 this_dbs_info->enable = 0;
514 sysfs_remove_group(&policy->kobj, &dbs_attr_group);
515 dbs_enable--;
516 /*
517 * Stop the timerschedule work, when this governor
518 * is used for first time
519 */
520 if (dbs_enable == 0)
521 dbs_timer_exit();
522
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800523 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700524
525 break;
526
527 case CPUFREQ_GOV_LIMITS:
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800528 mutex_lock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700529 if (policy->max < this_dbs_info->cur_policy->cur)
530 __cpufreq_driver_target(
531 this_dbs_info->cur_policy,
532 policy->max, CPUFREQ_RELATION_H);
533 else if (policy->min > this_dbs_info->cur_policy->cur)
534 __cpufreq_driver_target(
535 this_dbs_info->cur_policy,
536 policy->min, CPUFREQ_RELATION_L);
akpm@osdl.org3fc54d32006-01-13 15:54:22 -0800537 mutex_unlock(&dbs_mutex);
Dave Jonesb9170832005-05-31 19:03:47 -0700538 break;
539 }
540 return 0;
541}
542
543static struct cpufreq_governor cpufreq_gov_dbs = {
544 .name = "conservative",
545 .governor = cpufreq_governor_dbs,
546 .owner = THIS_MODULE,
547};
548
549static int __init cpufreq_gov_dbs_init(void)
550{
551 return cpufreq_register_governor(&cpufreq_gov_dbs);
552}
553
554static void __exit cpufreq_gov_dbs_exit(void)
555{
556 /* Make sure that the scheduled work is indeed not running */
557 flush_scheduled_work();
558
559 cpufreq_unregister_governor(&cpufreq_gov_dbs);
560}
561
562
563MODULE_AUTHOR ("Alexander Clouter <alex-kernel@digriz.org.uk>");
564MODULE_DESCRIPTION ("'cpufreq_conservative' - A dynamic cpufreq governor for "
565 "Low Latency Frequency Transition capable processors "
566 "optimised for use in a battery environment");
567MODULE_LICENSE ("GPL");
568
569module_init(cpufreq_gov_dbs_init);
570module_exit(cpufreq_gov_dbs_exit);