1/* 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) 2009 Alexander Clouter <alex@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/init.h> 17#include <linux/cpufreq.h> 18#include <linux/cpu.h> 19#include <linux/jiffies.h> 20#include <linux/kernel_stat.h> 21#include <linux/mutex.h> 22#include <linux/hrtimer.h> 23#include <linux/tick.h> 24#include <linux/ktime.h> 25#include <linux/sched.h> 26 27/* 28 * dbs is used in this file as a shortform for demandbased switching 29 * It helps to keep variable names smaller, simpler 30 */ 31 32#define DEF_FREQUENCY_UP_THRESHOLD (80) 33#define DEF_FREQUENCY_DOWN_THRESHOLD (20) 34 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 * latency of the processor. The governor will work on any processor with 39 * transition latency <= 10mS, using appropriate sampling 40 * rate. 41 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL) 42 * this governor will not work. 43 * All times here are in uS. 44 */ 45#define MIN_SAMPLING_RATE_RATIO (2) 46 47static unsigned int min_sampling_rate; 48 49#define LATENCY_MULTIPLIER (1000) 50#define MIN_LATENCY_MULTIPLIER (100) 51#define DEF_SAMPLING_DOWN_FACTOR (1) 52#define MAX_SAMPLING_DOWN_FACTOR (10) 53#define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000) 54 55static void do_dbs_timer(struct work_struct *work); 56 57struct cpu_dbs_info_s { 58 cputime64_t prev_cpu_idle; 59 cputime64_t prev_cpu_wall; 60 cputime64_t prev_cpu_nice; 61 struct cpufreq_policy *cur_policy; 62 struct delayed_work work; 63 unsigned int down_skip; 64 unsigned int requested_freq; 65 int cpu; 66 unsigned int enable:1; 67 /* 68 * percpu mutex that serializes governor limit change with 69 * do_dbs_timer invocation. We do not want do_dbs_timer to run 70 * when user is changing the governor or limits. 71 */ 72 struct mutex timer_mutex; 73}; 74static DEFINE_PER_CPU(struct cpu_dbs_info_s, cs_cpu_dbs_info); 75 76static unsigned int dbs_enable; /* number of CPUs using this policy */ 77 78/* 79 * dbs_mutex protects data in dbs_tuners_ins from concurrent changes on 80 * different CPUs. It protects dbs_enable in governor start/stop. 81 */ 82static DEFINE_MUTEX(dbs_mutex); 83 84static struct workqueue_struct *kconservative_wq; 85 86static struct dbs_tuners { 87 unsigned int sampling_rate; 88 unsigned int sampling_down_factor; 89 unsigned int up_threshold; 90 unsigned int down_threshold; 91 unsigned int ignore_nice; 92 unsigned int freq_step; 93} dbs_tuners_ins = { 94 .up_threshold = DEF_FREQUENCY_UP_THRESHOLD, 95 .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD, 96 .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR, 97 .ignore_nice = 0, 98 .freq_step = 5, 99}; 100 101static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu, 102 cputime64_t *wall) 103{ 104 cputime64_t idle_time; 105 cputime64_t cur_wall_time; 106 cputime64_t busy_time; 107 108 cur_wall_time = jiffies64_to_cputime64(get_jiffies_64()); 109 busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user, 110 kstat_cpu(cpu).cpustat.system); 111 112 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq); 113 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq); 114 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal); 115 busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice); 116 117 idle_time = cputime64_sub(cur_wall_time, busy_time); 118 if (wall) 119 *wall = (cputime64_t)jiffies_to_usecs(cur_wall_time); 120 121 return (cputime64_t)jiffies_to_usecs(idle_time);; 122} 123 124static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall) 125{ 126 u64 idle_time = get_cpu_idle_time_us(cpu, wall); 127 128 if (idle_time == -1ULL) 129 return get_cpu_idle_time_jiffy(cpu, wall); 130 131 return idle_time; 132} 133 134/* keep track of frequency transitions */ 135static int 136dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, 137 void *data) 138{ 139 struct cpufreq_freqs *freq = data; 140 struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cs_cpu_dbs_info, 141 freq->cpu); 142 143 struct cpufreq_policy *policy; 144 145 if (!this_dbs_info->enable) 146 return 0; 147 148 policy = this_dbs_info->cur_policy; 149 150 /* 151 * we only care if our internally tracked freq moves outside 152 * the 'valid' ranges of freqency available to us otherwise 153 * we do not change it 154 */ 155 if (this_dbs_info->requested_freq > policy->max 156 || this_dbs_info->requested_freq < policy->min) 157 this_dbs_info->requested_freq = freq->new; 158 159 return 0; 160} 161 162static struct notifier_block dbs_cpufreq_notifier_block = { 163 .notifier_call = dbs_cpufreq_notifier 164}; 165 166/************************** sysfs interface ************************/ 167static ssize_t show_sampling_rate_max(struct kobject *kobj, 168 struct attribute *attr, char *buf) 169{ 170 printk_once(KERN_INFO "CPUFREQ: conservative sampling_rate_max " 171 "sysfs file is deprecated - used by: %s\n", current->comm); 172 return sprintf(buf, "%u\n", -1U); 173} 174 175static ssize_t show_sampling_rate_min(struct kobject *kobj, 176 struct attribute *attr, char *buf) 177{ 178 return sprintf(buf, "%u\n", min_sampling_rate); 179} 180 181define_one_global_ro(sampling_rate_max); 182define_one_global_ro(sampling_rate_min); 183 184/* cpufreq_conservative Governor Tunables */ 185#define show_one(file_name, object) \ 186static ssize_t show_##file_name \ 187(struct kobject *kobj, struct attribute *attr, char *buf) \ 188{ \ 189 return sprintf(buf, "%u\n", dbs_tuners_ins.object); \ 190} 191show_one(sampling_rate, sampling_rate); 192show_one(sampling_down_factor, sampling_down_factor); 193show_one(up_threshold, up_threshold); 194show_one(down_threshold, down_threshold); 195show_one(ignore_nice_load, ignore_nice); 196show_one(freq_step, freq_step); 197 198/*** delete after deprecation time ***/ 199#define DEPRECATION_MSG(file_name) \ 200 printk_once(KERN_INFO "CPUFREQ: Per core conservative sysfs " \ 201 "interface is deprecated - " #file_name "\n"); 202 203#define show_one_old(file_name) \ 204static ssize_t show_##file_name##_old \ 205(struct cpufreq_policy *unused, char *buf) \ 206{ \ 207 printk_once(KERN_INFO "CPUFREQ: Per core conservative sysfs " \ 208 "interface is deprecated - " #file_name "\n"); \ 209 return show_##file_name(NULL, NULL, buf); \ 210} 211show_one_old(sampling_rate); 212show_one_old(sampling_down_factor); 213show_one_old(up_threshold); 214show_one_old(down_threshold); 215show_one_old(ignore_nice_load); 216show_one_old(freq_step); 217show_one_old(sampling_rate_min); 218show_one_old(sampling_rate_max); 219 220cpufreq_freq_attr_ro_old(sampling_rate_min); 221cpufreq_freq_attr_ro_old(sampling_rate_max); 222 223/*** delete after deprecation time ***/ 224 225static ssize_t store_sampling_down_factor(struct kobject *a, 226 struct attribute *b, 227 const char *buf, size_t count) 228{ 229 unsigned int input; 230 int ret; 231 ret = sscanf(buf, "%u", &input); 232 233 if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) 234 return -EINVAL; 235 236 mutex_lock(&dbs_mutex); 237 dbs_tuners_ins.sampling_down_factor = input; 238 mutex_unlock(&dbs_mutex); 239 240 return count; 241} 242 243static ssize_t store_sampling_rate(struct kobject *a, struct attribute *b, 244 const char *buf, size_t count) 245{ 246 unsigned int input; 247 int ret; 248 ret = sscanf(buf, "%u", &input); 249 250 if (ret != 1) 251 return -EINVAL; 252 253 mutex_lock(&dbs_mutex); 254 dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate); 255 mutex_unlock(&dbs_mutex); 256 257 return count; 258} 259 260static ssize_t store_up_threshold(struct kobject *a, struct attribute *b, 261 const char *buf, size_t count) 262{ 263 unsigned int input; 264 int ret; 265 ret = sscanf(buf, "%u", &input); 266 267 mutex_lock(&dbs_mutex); 268 if (ret != 1 || input > 100 || 269 input <= dbs_tuners_ins.down_threshold) { 270 mutex_unlock(&dbs_mutex); 271 return -EINVAL; 272 } 273 274 dbs_tuners_ins.up_threshold = input; 275 mutex_unlock(&dbs_mutex); 276 277 return count; 278} 279 280static ssize_t store_down_threshold(struct kobject *a, struct attribute *b, 281 const char *buf, size_t count) 282{ 283 unsigned int input; 284 int ret; 285 ret = sscanf(buf, "%u", &input); 286 287 mutex_lock(&dbs_mutex); 288 /* cannot be lower than 11 otherwise freq will not fall */ 289 if (ret != 1 || input < 11 || input > 100 || 290 input >= dbs_tuners_ins.up_threshold) { 291 mutex_unlock(&dbs_mutex); 292 return -EINVAL; 293 } 294 295 dbs_tuners_ins.down_threshold = input; 296 mutex_unlock(&dbs_mutex); 297 298 return count; 299} 300 301static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b, 302 const char *buf, size_t count) 303{ 304 unsigned int input; 305 int ret; 306 307 unsigned int j; 308 309 ret = sscanf(buf, "%u", &input); 310 if (ret != 1) 311 return -EINVAL; 312 313 if (input > 1) 314 input = 1; 315 316 mutex_lock(&dbs_mutex); 317 if (input == dbs_tuners_ins.ignore_nice) { /* nothing to do */ 318 mutex_unlock(&dbs_mutex); 319 return count; 320 } 321 dbs_tuners_ins.ignore_nice = input; 322 323 /* we need to re-evaluate prev_cpu_idle */ 324 for_each_online_cpu(j) { 325 struct cpu_dbs_info_s *dbs_info; 326 dbs_info = &per_cpu(cs_cpu_dbs_info, j); 327 dbs_info->prev_cpu_idle = get_cpu_idle_time(j, 328 &dbs_info->prev_cpu_wall); 329 if (dbs_tuners_ins.ignore_nice) 330 dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice; 331 } 332 mutex_unlock(&dbs_mutex); 333 334 return count; 335} 336 337static ssize_t store_freq_step(struct kobject *a, struct attribute *b, 338 const char *buf, size_t count) 339{ 340 unsigned int input; 341 int ret; 342 ret = sscanf(buf, "%u", &input); 343 344 if (ret != 1) 345 return -EINVAL; 346 347 if (input > 100) 348 input = 100; 349 350 /* no need to test here if freq_step is zero as the user might actually 351 * want this, they would be crazy though :) */ 352 mutex_lock(&dbs_mutex); 353 dbs_tuners_ins.freq_step = input; 354 mutex_unlock(&dbs_mutex); 355 356 return count; 357} 358 359define_one_global_rw(sampling_rate); 360define_one_global_rw(sampling_down_factor); 361define_one_global_rw(up_threshold); 362define_one_global_rw(down_threshold); 363define_one_global_rw(ignore_nice_load); 364define_one_global_rw(freq_step); 365 366static struct attribute *dbs_attributes[] = { 367 &sampling_rate_max.attr, 368 &sampling_rate_min.attr, 369 &sampling_rate.attr, 370 &sampling_down_factor.attr, 371 &up_threshold.attr, 372 &down_threshold.attr, 373 &ignore_nice_load.attr, 374 &freq_step.attr, 375 NULL 376}; 377 378static struct attribute_group dbs_attr_group = { 379 .attrs = dbs_attributes, 380 .name = "conservative", 381}; 382 383/*** delete after deprecation time ***/ 384 385#define write_one_old(file_name) \ 386static ssize_t store_##file_name##_old \ 387(struct cpufreq_policy *unused, const char *buf, size_t count) \ 388{ \ 389 printk_once(KERN_INFO "CPUFREQ: Per core conservative sysfs " \ 390 "interface is deprecated - " #file_name "\n"); \ 391 return store_##file_name(NULL, NULL, buf, count); \ 392} 393write_one_old(sampling_rate); 394write_one_old(sampling_down_factor); 395write_one_old(up_threshold); 396write_one_old(down_threshold); 397write_one_old(ignore_nice_load); 398write_one_old(freq_step); 399 400cpufreq_freq_attr_rw_old(sampling_rate); 401cpufreq_freq_attr_rw_old(sampling_down_factor); 402cpufreq_freq_attr_rw_old(up_threshold); 403cpufreq_freq_attr_rw_old(down_threshold); 404cpufreq_freq_attr_rw_old(ignore_nice_load); 405cpufreq_freq_attr_rw_old(freq_step); 406 407static struct attribute *dbs_attributes_old[] = { 408 &sampling_rate_max_old.attr, 409 &sampling_rate_min_old.attr, 410 &sampling_rate_old.attr, 411 &sampling_down_factor_old.attr, 412 &up_threshold_old.attr, 413 &down_threshold_old.attr, 414 &ignore_nice_load_old.attr, 415 &freq_step_old.attr, 416 NULL 417}; 418 419static struct attribute_group dbs_attr_group_old = { 420 .attrs = dbs_attributes_old, 421 .name = "conservative", 422}; 423 424/*** delete after deprecation time ***/ 425 426/************************** sysfs end ************************/ 427 428static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info) 429{ 430 unsigned int load = 0; 431 unsigned int max_load = 0; 432 unsigned int freq_target; 433 434 struct cpufreq_policy *policy; 435 unsigned int j; 436 437 policy = this_dbs_info->cur_policy; 438 439 /* 440 * Every sampling_rate, we check, if current idle time is less 441 * than 20% (default), then we try to increase frequency 442 * Every sampling_rate*sampling_down_factor, we check, if current 443 * idle time is more than 80%, then we try to decrease frequency 444 * 445 * Any frequency increase takes it to the maximum frequency. 446 * Frequency reduction happens at minimum steps of 447 * 5% (default) of maximum frequency 448 */ 449 450 /* Get Absolute Load */ 451 for_each_cpu(j, policy->cpus) { 452 struct cpu_dbs_info_s *j_dbs_info; 453 cputime64_t cur_wall_time, cur_idle_time; 454 unsigned int idle_time, wall_time; 455 456 j_dbs_info = &per_cpu(cs_cpu_dbs_info, j); 457 458 cur_idle_time = get_cpu_idle_time(j, &cur_wall_time); 459 460 wall_time = (unsigned int) cputime64_sub(cur_wall_time, 461 j_dbs_info->prev_cpu_wall); 462 j_dbs_info->prev_cpu_wall = cur_wall_time; 463 464 idle_time = (unsigned int) cputime64_sub(cur_idle_time, 465 j_dbs_info->prev_cpu_idle); 466 j_dbs_info->prev_cpu_idle = cur_idle_time; 467 468 if (dbs_tuners_ins.ignore_nice) { 469 cputime64_t cur_nice; 470 unsigned long cur_nice_jiffies; 471 472 cur_nice = cputime64_sub(kstat_cpu(j).cpustat.nice, 473 j_dbs_info->prev_cpu_nice); 474 /* 475 * Assumption: nice time between sampling periods will 476 * be less than 2^32 jiffies for 32 bit sys 477 */ 478 cur_nice_jiffies = (unsigned long) 479 cputime64_to_jiffies64(cur_nice); 480 481 j_dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice; 482 idle_time += jiffies_to_usecs(cur_nice_jiffies); 483 } 484 485 if (unlikely(!wall_time || wall_time < idle_time)) 486 continue; 487 488 load = 100 * (wall_time - idle_time) / wall_time; 489 490 if (load > max_load) 491 max_load = load; 492 } 493 494 /* 495 * break out if we 'cannot' reduce the speed as the user might 496 * want freq_step to be zero 497 */ 498 if (dbs_tuners_ins.freq_step == 0) 499 return; 500 501 /* Check for frequency increase */ 502 if (max_load > dbs_tuners_ins.up_threshold) { 503 this_dbs_info->down_skip = 0; 504 505 /* if we are already at full speed then break out early */ 506 if (this_dbs_info->requested_freq == policy->max) 507 return; 508 509 freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100; 510 511 /* max freq cannot be less than 100. But who knows.... */ 512 if (unlikely(freq_target == 0)) 513 freq_target = 5; 514 515 this_dbs_info->requested_freq += freq_target; 516 if (this_dbs_info->requested_freq > policy->max) 517 this_dbs_info->requested_freq = policy->max; 518 519 __cpufreq_driver_target(policy, this_dbs_info->requested_freq, 520 CPUFREQ_RELATION_H); 521 return; 522 } 523 524 /* 525 * The optimal frequency is the frequency that is the lowest that 526 * can support the current CPU usage without triggering the up 527 * policy. To be safe, we focus 10 points under the threshold. 528 */ 529 if (max_load < (dbs_tuners_ins.down_threshold - 10)) { 530 freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100; 531 532 this_dbs_info->requested_freq -= freq_target; 533 if (this_dbs_info->requested_freq < policy->min) 534 this_dbs_info->requested_freq = policy->min; 535 536 /* 537 * if we cannot reduce the frequency anymore, break out early 538 */ 539 if (policy->cur == policy->min) 540 return; 541 542 __cpufreq_driver_target(policy, this_dbs_info->requested_freq, 543 CPUFREQ_RELATION_H); 544 return; 545 } 546} 547 548static void do_dbs_timer(struct work_struct *work) 549{ 550 struct cpu_dbs_info_s *dbs_info = 551 container_of(work, struct cpu_dbs_info_s, work.work); 552 unsigned int cpu = dbs_info->cpu; 553 554 /* We want all CPUs to do sampling nearly on same jiffy */ 555 int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); 556 557 delay -= jiffies % delay; 558 559 mutex_lock(&dbs_info->timer_mutex); 560 561 dbs_check_cpu(dbs_info); 562 563 queue_delayed_work_on(cpu, kconservative_wq, &dbs_info->work, delay); 564 mutex_unlock(&dbs_info->timer_mutex); 565} 566 567static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) 568{ 569 /* We want all CPUs to do sampling nearly on same jiffy */ 570 int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); 571 delay -= jiffies % delay; 572 573 dbs_info->enable = 1; 574 INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer); 575 queue_delayed_work_on(dbs_info->cpu, kconservative_wq, &dbs_info->work, 576 delay); 577} 578 579static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info) 580{ 581 dbs_info->enable = 0; 582 cancel_delayed_work_sync(&dbs_info->work); 583} 584 585static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 586 unsigned int event) 587{ 588 unsigned int cpu = policy->cpu; 589 struct cpu_dbs_info_s *this_dbs_info; 590 unsigned int j; 591 int rc; 592 593 this_dbs_info = &per_cpu(cs_cpu_dbs_info, cpu); 594 595 switch (event) { 596 case CPUFREQ_GOV_START: 597 if ((!cpu_online(cpu)) || (!policy->cur)) 598 return -EINVAL; 599 600 mutex_lock(&dbs_mutex); 601 602 rc = sysfs_create_group(&policy->kobj, &dbs_attr_group_old); 603 if (rc) { 604 mutex_unlock(&dbs_mutex); 605 return rc; 606 } 607 608 for_each_cpu(j, policy->cpus) { 609 struct cpu_dbs_info_s *j_dbs_info; 610 j_dbs_info = &per_cpu(cs_cpu_dbs_info, j); 611 j_dbs_info->cur_policy = policy; 612 613 j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j, 614 &j_dbs_info->prev_cpu_wall); 615 if (dbs_tuners_ins.ignore_nice) { 616 j_dbs_info->prev_cpu_nice = 617 kstat_cpu(j).cpustat.nice; 618 } 619 } 620 this_dbs_info->down_skip = 0; 621 this_dbs_info->requested_freq = policy->cur; 622 623 mutex_init(&this_dbs_info->timer_mutex); 624 dbs_enable++; 625 /* 626 * Start the timerschedule work, when this governor 627 * is used for first time 628 */ 629 if (dbs_enable == 1) { 630 unsigned int latency; 631 /* policy latency is in nS. Convert it to uS first */ 632 latency = policy->cpuinfo.transition_latency / 1000; 633 if (latency == 0) 634 latency = 1; 635 636 rc = sysfs_create_group(cpufreq_global_kobject, 637 &dbs_attr_group); 638 if (rc) { 639 mutex_unlock(&dbs_mutex); 640 return rc; 641 } 642 643 /* 644 * conservative does not implement micro like ondemand 645 * governor, thus we are bound to jiffes/HZ 646 */ 647 min_sampling_rate = 648 MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10); 649 /* Bring kernel and HW constraints together */ 650 min_sampling_rate = max(min_sampling_rate, 651 MIN_LATENCY_MULTIPLIER * latency); 652 dbs_tuners_ins.sampling_rate = 653 max(min_sampling_rate, 654 latency * LATENCY_MULTIPLIER); 655 656 cpufreq_register_notifier( 657 &dbs_cpufreq_notifier_block, 658 CPUFREQ_TRANSITION_NOTIFIER); 659 } 660 mutex_unlock(&dbs_mutex); 661 662 dbs_timer_init(this_dbs_info); 663 664 break; 665 666 case CPUFREQ_GOV_STOP: 667 dbs_timer_exit(this_dbs_info); 668 669 mutex_lock(&dbs_mutex); 670 sysfs_remove_group(&policy->kobj, &dbs_attr_group_old); 671 dbs_enable--; 672 mutex_destroy(&this_dbs_info->timer_mutex); 673 674 /* 675 * Stop the timerschedule work, when this governor 676 * is used for first time 677 */ 678 if (dbs_enable == 0) 679 cpufreq_unregister_notifier( 680 &dbs_cpufreq_notifier_block, 681 CPUFREQ_TRANSITION_NOTIFIER); 682 683 mutex_unlock(&dbs_mutex); 684 if (!dbs_enable) 685 sysfs_remove_group(cpufreq_global_kobject, 686 &dbs_attr_group); 687 688 break; 689 690 case CPUFREQ_GOV_LIMITS: 691 mutex_lock(&this_dbs_info->timer_mutex); 692 if (policy->max < this_dbs_info->cur_policy->cur) 693 __cpufreq_driver_target( 694 this_dbs_info->cur_policy, 695 policy->max, CPUFREQ_RELATION_H); 696 else if (policy->min > this_dbs_info->cur_policy->cur) 697 __cpufreq_driver_target( 698 this_dbs_info->cur_policy, 699 policy->min, CPUFREQ_RELATION_L); 700 mutex_unlock(&this_dbs_info->timer_mutex); 701 702 break; 703 } 704 return 0; 705} 706 707#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE 708static 709#endif 710struct cpufreq_governor cpufreq_gov_conservative = { 711 .name = "conservative", 712 .governor = cpufreq_governor_dbs, 713 .max_transition_latency = TRANSITION_LATENCY_LIMIT, 714 .owner = THIS_MODULE, 715}; 716 717static int __init cpufreq_gov_dbs_init(void) 718{ 719 int err; 720 721 kconservative_wq = create_workqueue("kconservative"); 722 if (!kconservative_wq) { 723 printk(KERN_ERR "Creation of kconservative failed\n"); 724 return -EFAULT; 725 } 726 727 err = cpufreq_register_governor(&cpufreq_gov_conservative); 728 if (err) 729 destroy_workqueue(kconservative_wq); 730 731 return err; 732} 733 734static void __exit cpufreq_gov_dbs_exit(void) 735{ 736 cpufreq_unregister_governor(&cpufreq_gov_conservative); 737 destroy_workqueue(kconservative_wq); 738} 739 740 741MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>"); 742MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for " 743 "Low Latency Frequency Transition capable processors " 744 "optimised for use in a battery environment"); 745MODULE_LICENSE("GPL"); 746 747#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE 748fs_initcall(cpufreq_gov_dbs_init); 749#else 750module_init(cpufreq_gov_dbs_init); 751#endif 752module_exit(cpufreq_gov_dbs_exit); 753