?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rcu: increment quiescent state counter in ksoftirqd()
[linux-2.6/verdex.git] / drivers / cpufreq / cpufreq_ondemand.c
blob6f45b1658a67d0bee41c5156cdca709e639d0b67
1 /*
2 * drivers/cpufreq/cpufreq_ondemand.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 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/cpufreq.h>
17 #include <linux/cpu.h>
18 #include <linux/jiffies.h>
19 #include <linux/kernel_stat.h>
20 #include <linux/mutex.h>
21 #include <linux/hrtimer.h>
22 #include <linux/tick.h>
23 #include <linux/ktime.h>
24
25 /*
26 * dbs is used in this file as a shortform for demandbased switching
27 * It helps to keep variable names smaller, simpler
28 */
29
30 #define DEF_FREQUENCY_DOWN_DIFFERENTIAL (10)
31 #define DEF_FREQUENCY_UP_THRESHOLD (80)
32 #define MICRO_FREQUENCY_DOWN_DIFFERENTIAL (3)
33 #define MICRO_FREQUENCY_UP_THRESHOLD (95)
34 #define MIN_FREQUENCY_UP_THRESHOLD (11)
35 #define MAX_FREQUENCY_UP_THRESHOLD (100)
36
37 /*
38 * The polling frequency of this governor depends on the capability of
39 * the processor. Default polling frequency is 1000 times the transition
40 * latency of the processor. The governor will work on any processor with
41 * transition latency <= 10mS, using appropriate sampling
42 * rate.
43 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
44 * this governor will not work.
45 * All times here are in uS.
46 */
47 static unsigned int def_sampling_rate;
48 #define MIN_SAMPLING_RATE_RATIO (2)
49 /* for correct statistics, we need at least 10 ticks between each measure */
50 #define MIN_STAT_SAMPLING_RATE \
51 (MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10))
52 #define MIN_SAMPLING_RATE \
53 (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
54 #define MAX_SAMPLING_RATE (500 * def_sampling_rate)
55 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER (1000)
56 #define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000)
57
58 static void do_dbs_timer(struct work_struct *work);
59
60 /* Sampling types */
61 enum {DBS_NORMAL_SAMPLE, DBS_SUB_SAMPLE};
62
63 struct cpu_dbs_info_s {
64 cputime64_t prev_cpu_idle;
65 cputime64_t prev_cpu_wall;
66 cputime64_t prev_cpu_nice;
67 struct cpufreq_policy *cur_policy;
68 struct delayed_work work;
69 struct cpufreq_frequency_table *freq_table;
70 unsigned int freq_lo;
71 unsigned int freq_lo_jiffies;
72 unsigned int freq_hi_jiffies;
73 int cpu;
74 unsigned int enable:1,
75 sample_type:1;
76 };
77 static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
78
79 static unsigned int dbs_enable; /* number of CPUs using this policy */
80
81 /*
82 * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug
83 * lock and dbs_mutex. cpu_hotplug lock should always be held before
84 * dbs_mutex. If any function that can potentially take cpu_hotplug lock
85 * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then
86 * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
87 * is recursive for the same process. -Venki
88 */
89 static DEFINE_MUTEX(dbs_mutex);
90
91 static struct workqueue_struct *kondemand_wq;
92
93 static struct dbs_tuners {
94 unsigned int sampling_rate;
95 unsigned int up_threshold;
96 unsigned int down_differential;
97 unsigned int ignore_nice;
98 unsigned int powersave_bias;
99 } dbs_tuners_ins = {
100 .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
101 .down_differential = DEF_FREQUENCY_DOWN_DIFFERENTIAL,
102 .ignore_nice = 0,
103 .powersave_bias = 0,
104 };
105
106 static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu,
107 cputime64_t *wall)
108 {
109 cputime64_t idle_time;
110 cputime64_t cur_wall_time;
111 cputime64_t busy_time;
112
113 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
114 busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user,
115 kstat_cpu(cpu).cpustat.system);
116
117 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq);
118 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq);
119 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal);
120 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice);
121
122 idle_time = cputime64_sub(cur_wall_time, busy_time);
123 if (wall)
124 *wall = cur_wall_time;
125
126 return idle_time;
127 }
128
129 static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall)
130 {
131 u64 idle_time = get_cpu_idle_time_us(cpu, wall);
132
133 if (idle_time == -1ULL)
134 return get_cpu_idle_time_jiffy(cpu, wall);
135
136 return idle_time;
137 }
138
139 /*
140 * Find right freq to be set now with powersave_bias on.
141 * Returns the freq_hi to be used right now and will set freq_hi_jiffies,
142 * freq_lo, and freq_lo_jiffies in percpu area for averaging freqs.
143 */
144 static unsigned int powersave_bias_target(struct cpufreq_policy *policy,
145 unsigned int freq_next,
146 unsigned int relation)
147 {
148 unsigned int freq_req, freq_reduc, freq_avg;
149 unsigned int freq_hi, freq_lo;
150 unsigned int index = 0;
151 unsigned int jiffies_total, jiffies_hi, jiffies_lo;
152 struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, policy->cpu);
153
154 if (!dbs_info->freq_table) {
155 dbs_info->freq_lo = 0;
156 dbs_info->freq_lo_jiffies = 0;
157 return freq_next;
158 }
159
160 cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next,
161 relation, &index);
162 freq_req = dbs_info->freq_table[index].frequency;
163 freq_reduc = freq_req * dbs_tuners_ins.powersave_bias / 1000;
164 freq_avg = freq_req - freq_reduc;
165
166 /* Find freq bounds for freq_avg in freq_table */
167 index = 0;
168 cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
169 CPUFREQ_RELATION_H, &index);
170 freq_lo = dbs_info->freq_table[index].frequency;
171 index = 0;
172 cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
173 CPUFREQ_RELATION_L, &index);
174 freq_hi = dbs_info->freq_table[index].frequency;
175
176 /* Find out how long we have to be in hi and lo freqs */
177 if (freq_hi == freq_lo) {
178 dbs_info->freq_lo = 0;
179 dbs_info->freq_lo_jiffies = 0;
180 return freq_lo;
181 }
182 jiffies_total = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
183 jiffies_hi = (freq_avg - freq_lo) * jiffies_total;
184 jiffies_hi += ((freq_hi - freq_lo) / 2);
185 jiffies_hi /= (freq_hi - freq_lo);
186 jiffies_lo = jiffies_total - jiffies_hi;
187 dbs_info->freq_lo = freq_lo;
188 dbs_info->freq_lo_jiffies = jiffies_lo;
189 dbs_info->freq_hi_jiffies = jiffies_hi;
190 return freq_hi;
191 }
192
193 static void ondemand_powersave_bias_init(void)
194 {
195 int i;
196 for_each_online_cpu(i) {
197 struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, i);
198 dbs_info->freq_table = cpufreq_frequency_get_table(i);
199 dbs_info->freq_lo = 0;
200 }
201 }
202
203 /************************** sysfs interface ************************/
204 static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
205 {
206 return sprintf (buf, "%u\n", MAX_SAMPLING_RATE);
207 }
208
209 static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
210 {
211 return sprintf (buf, "%u\n", MIN_SAMPLING_RATE);
212 }
213
214 #define define_one_ro(_name) \
215 static struct freq_attr _name = \
216 __ATTR(_name, 0444, show_##_name, NULL)
217
218 define_one_ro(sampling_rate_max);
219 define_one_ro(sampling_rate_min);
220
221 /* cpufreq_ondemand Governor Tunables */
222 #define show_one(file_name, object) \
223 static ssize_t show_##file_name \
224 (struct cpufreq_policy *unused, char *buf) \
225 { \
226 return sprintf(buf, "%u\n", dbs_tuners_ins.object); \
227 }
228 show_one(sampling_rate, sampling_rate);
229 show_one(up_threshold, up_threshold);
230 show_one(ignore_nice_load, ignore_nice);
231 show_one(powersave_bias, powersave_bias);
232
233 static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
234 const char *buf, size_t count)
235 {
236 unsigned int input;
237 int ret;
238 ret = sscanf(buf, "%u", &input);
239
240 mutex_lock(&dbs_mutex);
241 if (ret != 1 || input > MAX_SAMPLING_RATE
242 || input < MIN_SAMPLING_RATE) {
243 mutex_unlock(&dbs_mutex);
244 return -EINVAL;
245 }
246
247 dbs_tuners_ins.sampling_rate = input;
248 mutex_unlock(&dbs_mutex);
249
250 return count;
251 }
252
253 static ssize_t store_up_threshold(struct cpufreq_policy *unused,
254 const char *buf, size_t count)
255 {
256 unsigned int input;
257 int ret;
258 ret = sscanf(buf, "%u", &input);
259
260 mutex_lock(&dbs_mutex);
261 if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
262 input < MIN_FREQUENCY_UP_THRESHOLD) {
263 mutex_unlock(&dbs_mutex);
264 return -EINVAL;
265 }
266
267 dbs_tuners_ins.up_threshold = input;
268 mutex_unlock(&dbs_mutex);
269
270 return count;
271 }
272
273 static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
274 const char *buf, size_t count)
275 {
276 unsigned int input;
277 int ret;
278
279 unsigned int j;
280
281 ret = sscanf(buf, "%u", &input);
282 if ( ret != 1 )
283 return -EINVAL;
284
285 if ( input > 1 )
286 input = 1;
287
288 mutex_lock(&dbs_mutex);
289 if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */
290 mutex_unlock(&dbs_mutex);
291 return count;
292 }
293 dbs_tuners_ins.ignore_nice = input;
294
295 /* we need to re-evaluate prev_cpu_idle */
296 for_each_online_cpu(j) {
297 struct cpu_dbs_info_s *dbs_info;
298 dbs_info = &per_cpu(cpu_dbs_info, j);
299 dbs_info->prev_cpu_idle = get_cpu_idle_time(j,
300 &dbs_info->prev_cpu_wall);
301 if (dbs_tuners_ins.ignore_nice)
302 dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice;
303
304 }
305 mutex_unlock(&dbs_mutex);
306
307 return count;
308 }
309
310 static ssize_t store_powersave_bias(struct cpufreq_policy *unused,
311 const char *buf, size_t count)
312 {
313 unsigned int input;
314 int ret;
315 ret = sscanf(buf, "%u", &input);
316
317 if (ret != 1)
318 return -EINVAL;
319
320 if (input > 1000)
321 input = 1000;
322
323 mutex_lock(&dbs_mutex);
324 dbs_tuners_ins.powersave_bias = input;
325 ondemand_powersave_bias_init();
326 mutex_unlock(&dbs_mutex);
327
328 return count;
329 }
330
331 #define define_one_rw(_name) \
332 static struct freq_attr _name = \
333 __ATTR(_name, 0644, show_##_name, store_##_name)
334
335 define_one_rw(sampling_rate);
336 define_one_rw(up_threshold);
337 define_one_rw(ignore_nice_load);
338 define_one_rw(powersave_bias);
339
340 static struct attribute * dbs_attributes[] = {
341 &sampling_rate_max.attr,
342 &sampling_rate_min.attr,
343 &sampling_rate.attr,
344 &up_threshold.attr,
345 &ignore_nice_load.attr,
346 &powersave_bias.attr,
347 NULL
348 };
349
350 static struct attribute_group dbs_attr_group = {
351 .attrs = dbs_attributes,
352 .name = "ondemand",
353 };
354
355 /************************** sysfs end ************************/
356
357 static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
358 {
359 unsigned int max_load_freq;
360
361 struct cpufreq_policy *policy;
362 unsigned int j;
363
364 if (!this_dbs_info->enable)
365 return;
366
367 this_dbs_info->freq_lo = 0;
368 policy = this_dbs_info->cur_policy;
369
370 /*
371 * Every sampling_rate, we check, if current idle time is less
372 * than 20% (default), then we try to increase frequency
373 * Every sampling_rate, we look for a the lowest
374 * frequency which can sustain the load while keeping idle time over
375 * 30%. If such a frequency exist, we try to decrease to this frequency.
376 *
377 * Any frequency increase takes it to the maximum frequency.
378 * Frequency reduction happens at minimum steps of
379 * 5% (default) of current frequency
380 */
381
382 /* Get Absolute Load - in terms of freq */
383 max_load_freq = 0;
384
385 for_each_cpu(j, policy->cpus) {
386 struct cpu_dbs_info_s *j_dbs_info;
387 cputime64_t cur_wall_time, cur_idle_time;
388 unsigned int idle_time, wall_time;
389 unsigned int load, load_freq;
390 int freq_avg;
391
392 j_dbs_info = &per_cpu(cpu_dbs_info, j);
393
394 cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);
395
396 wall_time = (unsigned int) cputime64_sub(cur_wall_time,
397 j_dbs_info->prev_cpu_wall);
398 j_dbs_info->prev_cpu_wall = cur_wall_time;
399
400 idle_time = (unsigned int) cputime64_sub(cur_idle_time,
401 j_dbs_info->prev_cpu_idle);
402 j_dbs_info->prev_cpu_idle = cur_idle_time;
403
404 if (dbs_tuners_ins.ignore_nice) {
405 cputime64_t cur_nice;
406 unsigned long cur_nice_jiffies;
407
408 cur_nice = cputime64_sub(kstat_cpu(j).cpustat.nice,
409 j_dbs_info->prev_cpu_nice);
410 /*
411 * Assumption: nice time between sampling periods will
412 * be less than 2^32 jiffies for 32 bit sys
413 */
414 cur_nice_jiffies = (unsigned long)
415 cputime64_to_jiffies64(cur_nice);
416
417 j_dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice;
418 idle_time += jiffies_to_usecs(cur_nice_jiffies);
419 }
420
421 if (unlikely(!wall_time || wall_time < idle_time))
422 continue;
423
424 load = 100 * (wall_time - idle_time) / wall_time;
425
426 freq_avg = __cpufreq_driver_getavg(policy, j);
427 if (freq_avg <= 0)
428 freq_avg = policy->cur;
429
430 load_freq = load * freq_avg;
431 if (load_freq > max_load_freq)
432 max_load_freq = load_freq;
433 }
434
435 /* Check for frequency increase */
436 if (max_load_freq > dbs_tuners_ins.up_threshold * policy->cur) {
437 /* if we are already at full speed then break out early */
438 if (!dbs_tuners_ins.powersave_bias) {
439 if (policy->cur == policy->max)
440 return;
441
442 __cpufreq_driver_target(policy, policy->max,
443 CPUFREQ_RELATION_H);
444 } else {
445 int freq = powersave_bias_target(policy, policy->max,
446 CPUFREQ_RELATION_H);
447 __cpufreq_driver_target(policy, freq,
448 CPUFREQ_RELATION_L);
449 }
450 return;
451 }
452
453 /* Check for frequency decrease */
454 /* if we cannot reduce the frequency anymore, break out early */
455 if (policy->cur == policy->min)
456 return;
457
458 /*
459 * The optimal frequency is the frequency that is the lowest that
460 * can support the current CPU usage without triggering the up
461 * policy. To be safe, we focus 10 points under the threshold.
462 */
463 if (max_load_freq <
464 (dbs_tuners_ins.up_threshold - dbs_tuners_ins.down_differential) *
465 policy->cur) {
466 unsigned int freq_next;
467 freq_next = max_load_freq /
468 (dbs_tuners_ins.up_threshold -
469 dbs_tuners_ins.down_differential);
470
471 if (!dbs_tuners_ins.powersave_bias) {
472 __cpufreq_driver_target(policy, freq_next,
473 CPUFREQ_RELATION_L);
474 } else {
475 int freq = powersave_bias_target(policy, freq_next,
476 CPUFREQ_RELATION_L);
477 __cpufreq_driver_target(policy, freq,
478 CPUFREQ_RELATION_L);
479 }
480 }
481 }
482
483 static void do_dbs_timer(struct work_struct *work)
484 {
485 struct cpu_dbs_info_s *dbs_info =
486 container_of(work, struct cpu_dbs_info_s, work.work);
487 unsigned int cpu = dbs_info->cpu;
488 int sample_type = dbs_info->sample_type;
489
490 /* We want all CPUs to do sampling nearly on same jiffy */
491 int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
492
493 delay -= jiffies % delay;
494
495 if (lock_policy_rwsem_write(cpu) < 0)
496 return;
497
498 if (!dbs_info->enable) {
499 unlock_policy_rwsem_write(cpu);
500 return;
501 }
502
503 /* Common NORMAL_SAMPLE setup */
504 dbs_info->sample_type = DBS_NORMAL_SAMPLE;
505 if (!dbs_tuners_ins.powersave_bias ||
506 sample_type == DBS_NORMAL_SAMPLE) {
507 dbs_check_cpu(dbs_info);
508 if (dbs_info->freq_lo) {
509 /* Setup timer for SUB_SAMPLE */
510 dbs_info->sample_type = DBS_SUB_SAMPLE;
511 delay = dbs_info->freq_hi_jiffies;
512 }
513 } else {
514 __cpufreq_driver_target(dbs_info->cur_policy,
515 dbs_info->freq_lo,
516 CPUFREQ_RELATION_H);
517 }
518 queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay);
519 unlock_policy_rwsem_write(cpu);
520 }
521
522 static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
523 {
524 /* We want all CPUs to do sampling nearly on same jiffy */
525 int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
526 delay -= jiffies % delay;
527
528 dbs_info->enable = 1;
529 ondemand_powersave_bias_init();
530 dbs_info->sample_type = DBS_NORMAL_SAMPLE;
531 INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
532 queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work,
533 delay);
534 }
535
536 static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
537 {
538 dbs_info->enable = 0;
539 cancel_delayed_work(&dbs_info->work);
540 }
541
542 static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
543 unsigned int event)
544 {
545 unsigned int cpu = policy->cpu;
546 struct cpu_dbs_info_s *this_dbs_info;
547 unsigned int j;
548 int rc;
549
550 this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
551
552 switch (event) {
553 case CPUFREQ_GOV_START:
554 if ((!cpu_online(cpu)) || (!policy->cur))
555 return -EINVAL;
556
557 if (this_dbs_info->enable) /* Already enabled */
558 break;
559
560 mutex_lock(&dbs_mutex);
561 dbs_enable++;
562
563 rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
564 if (rc) {
565 dbs_enable--;
566 mutex_unlock(&dbs_mutex);
567 return rc;
568 }
569
570 for_each_cpu(j, policy->cpus) {
571 struct cpu_dbs_info_s *j_dbs_info;
572 j_dbs_info = &per_cpu(cpu_dbs_info, j);
573 j_dbs_info->cur_policy = policy;
574
575 j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j,
576 &j_dbs_info->prev_cpu_wall);
577 if (dbs_tuners_ins.ignore_nice) {
578 j_dbs_info->prev_cpu_nice =
579 kstat_cpu(j).cpustat.nice;
580 }
581 }
582 this_dbs_info->cpu = cpu;
583 /*
584 * Start the timerschedule work, when this governor
585 * is used for first time
586 */
587 if (dbs_enable == 1) {
588 unsigned int latency;
589 /* policy latency is in nS. Convert it to uS first */
590 latency = policy->cpuinfo.transition_latency / 1000;
591 if (latency == 0)
592 latency = 1;
593
594 def_sampling_rate = latency *
595 DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
596
597 if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
598 def_sampling_rate = MIN_STAT_SAMPLING_RATE;
599
600 dbs_tuners_ins.sampling_rate = def_sampling_rate;
601 }
602 dbs_timer_init(this_dbs_info);
603
604 mutex_unlock(&dbs_mutex);
605 break;
606
607 case CPUFREQ_GOV_STOP:
608 mutex_lock(&dbs_mutex);
609 dbs_timer_exit(this_dbs_info);
610 sysfs_remove_group(&policy->kobj, &dbs_attr_group);
611 dbs_enable--;
612 mutex_unlock(&dbs_mutex);
613
614 break;
615
616 case CPUFREQ_GOV_LIMITS:
617 mutex_lock(&dbs_mutex);
618 if (policy->max < this_dbs_info->cur_policy->cur)
619 __cpufreq_driver_target(this_dbs_info->cur_policy,
620 policy->max,
621 CPUFREQ_RELATION_H);
622 else if (policy->min > this_dbs_info->cur_policy->cur)
623 __cpufreq_driver_target(this_dbs_info->cur_policy,
624 policy->min,
625 CPUFREQ_RELATION_L);
626 mutex_unlock(&dbs_mutex);
627 break;
628 }
629 return 0;
630 }
631
632 #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
633 static
634 #endif
635 struct cpufreq_governor cpufreq_gov_ondemand = {
636 .name = "ondemand",
637 .governor = cpufreq_governor_dbs,
638 .max_transition_latency = TRANSITION_LATENCY_LIMIT,
639 .owner = THIS_MODULE,
640 };
641
642 static int __init cpufreq_gov_dbs_init(void)
643 {
644 int err;
645 cputime64_t wall;
646 u64 idle_time;
647 int cpu = get_cpu();
648
649 idle_time = get_cpu_idle_time_us(cpu, &wall);
650 put_cpu();
651 if (idle_time != -1ULL) {
652 /* Idle micro accounting is supported. Use finer thresholds */
653 dbs_tuners_ins.up_threshold = MICRO_FREQUENCY_UP_THRESHOLD;
654 dbs_tuners_ins.down_differential =
655 MICRO_FREQUENCY_DOWN_DIFFERENTIAL;
656 }
657
658 kondemand_wq = create_workqueue("kondemand");
659 if (!kondemand_wq) {
660 printk(KERN_ERR "Creation of kondemand failed\n");
661 return -EFAULT;
662 }
663 err = cpufreq_register_governor(&cpufreq_gov_ondemand);
664 if (err)
665 destroy_workqueue(kondemand_wq);
666
667 return err;
668 }
669
670 static void __exit cpufreq_gov_dbs_exit(void)
671 {
672 cpufreq_unregister_governor(&cpufreq_gov_ondemand);
673 destroy_workqueue(kondemand_wq);
674 }
675
676
677 MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>");
678 MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>");
679 MODULE_DESCRIPTION("'cpufreq_ondemand' - A dynamic cpufreq governor for "
680 "Low Latency Frequency Transition capable processors");
681 MODULE_LICENSE("GPL");
682
683 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
684 fs_initcall(cpufreq_gov_dbs_init);
685 #else
686 module_init(cpufreq_gov_dbs_init);
687 #endif
688 module_exit(cpufreq_gov_dbs_exit);
Verdex Pro support