| /* |
| * drivers/cpufreq/cpufreq_conservative.c |
| * |
| * Copyright (C) 2001 Russell King |
| * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>. |
| * Jun Nakajima <jun.nakajima@intel.com> |
| * (C) 2009 Alexander Clouter <alex@digriz.org.uk> |
| * |
| * 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> |
| #include <linux/cpu.h> |
| #include <linux/jiffies.h> |
| #include <linux/kernel_stat.h> |
| #include <linux/mutex.h> |
| #include <linux/hrtimer.h> |
| #include <linux/tick.h> |
| #include <linux/ktime.h> |
| #include <linux/sched.h> |
| |
| /* |
| * 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) |
| #define DEF_FREQUENCY_DOWN_THRESHOLD (20) |
| |
| /* |
| * The polling frequency of this governor depends on the capability of |
| * the processor. Default polling frequency is 1000 times the transition |
| * latency of the processor. The governor will work on any processor with |
| * transition latency <= 10mS, using appropriate sampling |
| * rate. |
| * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL) |
| * this governor will not work. |
| * All times here are in uS. |
| */ |
| #define MIN_SAMPLING_RATE_RATIO (2) |
| |
| static unsigned int min_sampling_rate; |
| |
| #define LATENCY_MULTIPLIER (1000) |
| #define MIN_LATENCY_MULTIPLIER (100) |
| #define DEF_SAMPLING_DOWN_FACTOR (1) |
| #define MAX_SAMPLING_DOWN_FACTOR (10) |
| #define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000) |
| |
| static void do_dbs_timer(struct work_struct *work); |
| |
| struct cpu_dbs_info_s { |
| cputime64_t prev_cpu_idle; |
| cputime64_t prev_cpu_wall; |
| cputime64_t prev_cpu_nice; |
| struct cpufreq_policy *cur_policy; |
| struct delayed_work work; |
| unsigned int down_skip; |
| unsigned int requested_freq; |
| int cpu; |
| unsigned int enable:1; |
| }; |
| static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info); |
| |
| static unsigned int dbs_enable; /* number of CPUs using this policy */ |
| |
| /* |
| * 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 |
| * DEADLOCK ALERT! (2) : do_dbs_timer() must not take the dbs_mutex, because it |
| * would deadlock with cancel_delayed_work_sync(), which is needed for proper |
| * raceless workqueue teardown. |
| */ |
| static DEFINE_MUTEX(dbs_mutex); |
| |
| static struct workqueue_struct *kconservative_wq; |
| |
| static struct dbs_tuners { |
| unsigned int sampling_rate; |
| unsigned int sampling_down_factor; |
| unsigned int up_threshold; |
| unsigned int down_threshold; |
| unsigned int ignore_nice; |
| unsigned int freq_step; |
| } dbs_tuners_ins = { |
| .up_threshold = DEF_FREQUENCY_UP_THRESHOLD, |
| .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD, |
| .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR, |
| .ignore_nice = 0, |
| .freq_step = 5, |
| }; |
| |
| static inline cputime64_t get_cpu_idle_time_jiffy(unsigned int cpu, |
| cputime64_t *wall) |
| { |
| cputime64_t idle_time; |
| cputime64_t cur_wall_time; |
| cputime64_t busy_time; |
| |
| cur_wall_time = jiffies64_to_cputime64(get_jiffies_64()); |
| busy_time = cputime64_add(kstat_cpu(cpu).cpustat.user, |
| kstat_cpu(cpu).cpustat.system); |
| |
| busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.irq); |
| busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.softirq); |
| busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.steal); |
| busy_time = cputime64_add(busy_time, kstat_cpu(cpu).cpustat.nice); |
| |
| idle_time = cputime64_sub(cur_wall_time, busy_time); |
| if (wall) |
| *wall = cur_wall_time; |
| |
| return idle_time; |
| } |
| |
| static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall) |
| { |
| u64 idle_time = get_cpu_idle_time_us(cpu, wall); |
| |
| if (idle_time == -1ULL) |
| return get_cpu_idle_time_jiffy(cpu, wall); |
| |
| return idle_time; |
| } |
| |
| /* keep track of frequency transitions */ |
| static int |
| dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, |
| void *data) |
| { |
| struct cpufreq_freqs *freq = data; |
| struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, |
| freq->cpu); |
| |
| struct cpufreq_policy *policy; |
| |
| if (!this_dbs_info->enable) |
| return 0; |
| |
| policy = this_dbs_info->cur_policy; |
| |
| /* |
| * we only care if our internally tracked freq moves outside |
| * the 'valid' ranges of freqency available to us otherwise |
| * we do not change it |
| */ |
| if (this_dbs_info->requested_freq > policy->max |
| || this_dbs_info->requested_freq < policy->min) |
| this_dbs_info->requested_freq = freq->new; |
| |
| return 0; |
| } |
| |
| static struct notifier_block dbs_cpufreq_notifier_block = { |
| .notifier_call = dbs_cpufreq_notifier |
| }; |
| |
| /************************** sysfs interface ************************/ |
| static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf) |
| { |
| static int print_once; |
| |
| if (!print_once) { |
| printk(KERN_INFO "CPUFREQ: conservative sampling_rate_max " |
| "sysfs file is deprecated - used by: %s\n", |
| current->comm); |
| print_once = 1; |
| } |
| return sprintf(buf, "%u\n", -1U); |
| } |
| |
| static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf) |
| { |
| static int print_once; |
| |
| if (!print_once) { |
| printk(KERN_INFO "CPUFREQ: conservative sampling_rate_max " |
| "sysfs file is deprecated - used by: %s\n", current->comm); |
| print_once = 1; |
| } |
| return sprintf(buf, "%u\n", min_sampling_rate); |
| } |
| |
| #define define_one_ro(_name) \ |
| static struct freq_attr _name = \ |
| __ATTR(_name, 0444, show_##_name, NULL) |
| |
| define_one_ro(sampling_rate_max); |
| define_one_ro(sampling_rate_min); |
| |
| /* cpufreq_conservative 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(sampling_down_factor, sampling_down_factor); |
| show_one(up_threshold, up_threshold); |
| show_one(down_threshold, down_threshold); |
| show_one(ignore_nice_load, ignore_nice); |
| show_one(freq_step, freq_step); |
| |
| static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, |
| const char *buf, size_t count) |
| { |
| unsigned int input; |
| int ret; |
| ret = sscanf(buf, "%u", &input); |
| |
| if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) |
| return -EINVAL; |
| |
| mutex_lock(&dbs_mutex); |
| dbs_tuners_ins.sampling_down_factor = input; |
| mutex_unlock(&dbs_mutex); |
| |
| return count; |
| } |
| |
| static ssize_t store_sampling_rate(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; |
| |
| mutex_lock(&dbs_mutex); |
| dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate); |
| mutex_unlock(&dbs_mutex); |
| |
| return count; |
| } |
| |
| static ssize_t store_up_threshold(struct cpufreq_policy *unused, |
| const char *buf, size_t count) |
| { |
| unsigned int input; |
| int ret; |
| ret = sscanf(buf, "%u", &input); |
| |
| mutex_lock(&dbs_mutex); |
| if (ret != 1 || input > 100 || |
| input <= dbs_tuners_ins.down_threshold) { |
| mutex_unlock(&dbs_mutex); |
| return -EINVAL; |
| } |
| |
| dbs_tuners_ins.up_threshold = input; |
| mutex_unlock(&dbs_mutex); |
| |
| return count; |
| } |
| |
| static ssize_t store_down_threshold(struct cpufreq_policy *unused, |
| const char *buf, size_t count) |
| { |
| unsigned int input; |
| int ret; |
| ret = sscanf(buf, "%u", &input); |
| |
| mutex_lock(&dbs_mutex); |
| /* cannot be lower than 11 otherwise freq will not fall */ |
| if (ret != 1 || input < 11 || input > 100 || |
| input >= dbs_tuners_ins.up_threshold) { |
| mutex_unlock(&dbs_mutex); |
| return -EINVAL; |
| } |
| |
| dbs_tuners_ins.down_threshold = input; |
| mutex_unlock(&dbs_mutex); |
| |
| return count; |
| } |
| |
| static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, |
| const char *buf, size_t count) |
| { |
| unsigned int input; |
| int ret; |
| |
| unsigned int j; |
| |
| ret = sscanf(buf, "%u", &input); |
| if (ret != 1) |
| return -EINVAL; |
| |
| if (input > 1) |
| input = 1; |
| |
| mutex_lock(&dbs_mutex); |
| if (input == dbs_tuners_ins.ignore_nice) { /* nothing to do */ |
| mutex_unlock(&dbs_mutex); |
| return count; |
| } |
| dbs_tuners_ins.ignore_nice = input; |
| |
| /* we need to re-evaluate prev_cpu_idle */ |
| for_each_online_cpu(j) { |
| 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); |
| if (dbs_tuners_ins.ignore_nice) |
| dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice; |
| } |
| mutex_unlock(&dbs_mutex); |
| |
| return count; |
| } |
| |
| static ssize_t store_freq_step(struct cpufreq_policy *policy, |
| const char *buf, size_t count) |
| { |
| unsigned int input; |
| int ret; |
| ret = sscanf(buf, "%u", &input); |
| |
| if (ret != 1) |
| return -EINVAL; |
| |
| if (input > 100) |
| input = 100; |
| |
| /* no need to test here if freq_step is zero as the user might actually |
| * want this, they would be crazy though :) */ |
| mutex_lock(&dbs_mutex); |
| dbs_tuners_ins.freq_step = input; |
| mutex_unlock(&dbs_mutex); |
| |
| return count; |
| } |
| |
| #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(sampling_down_factor); |
| define_one_rw(up_threshold); |
| define_one_rw(down_threshold); |
| define_one_rw(ignore_nice_load); |
| define_one_rw(freq_step); |
| |
| static struct attribute *dbs_attributes[] = { |
| &sampling_rate_max.attr, |
| &sampling_rate_min.attr, |
| &sampling_rate.attr, |
| &sampling_down_factor.attr, |
| &up_threshold.attr, |
| &down_threshold.attr, |
| &ignore_nice_load.attr, |
| &freq_step.attr, |
| NULL |
| }; |
| |
| static struct attribute_group dbs_attr_group = { |
| .attrs = dbs_attributes, |
| .name = "conservative", |
| }; |
| |
| /************************** sysfs end ************************/ |
| |
| static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info) |
| { |
| unsigned int load = 0; |
| unsigned int freq_target; |
| |
| struct cpufreq_policy *policy; |
| unsigned int j; |
| |
| policy = this_dbs_info->cur_policy; |
| |
| /* |
| * Every sampling_rate, we check, if current idle time is less |
| * than 20% (default), then we try to increase frequency |
| * Every sampling_rate*sampling_down_factor, we check, if current |
| * idle time is more than 80%, then we try to decrease frequency |
| * |
| * Any frequency increase takes it to the maximum frequency. |
| * Frequency reduction happens at minimum steps of |
| * 5% (default) of maximum frequency |
| */ |
| |
| /* Get Absolute Load */ |
| for_each_cpu(j, policy->cpus) { |
| struct cpu_dbs_info_s *j_dbs_info; |
| cputime64_t cur_wall_time, cur_idle_time; |
| unsigned int idle_time, wall_time; |
| |
| j_dbs_info = &per_cpu(cpu_dbs_info, j); |
| |
| cur_idle_time = get_cpu_idle_time(j, &cur_wall_time); |
| |
| wall_time = (unsigned int) cputime64_sub(cur_wall_time, |
| j_dbs_info->prev_cpu_wall); |
| j_dbs_info->prev_cpu_wall = cur_wall_time; |
| |
| idle_time = (unsigned int) cputime64_sub(cur_idle_time, |
| j_dbs_info->prev_cpu_idle); |
| j_dbs_info->prev_cpu_idle = cur_idle_time; |
| |
| if (dbs_tuners_ins.ignore_nice) { |
| cputime64_t cur_nice; |
| unsigned long cur_nice_jiffies; |
| |
| cur_nice = cputime64_sub(kstat_cpu(j).cpustat.nice, |
| j_dbs_info->prev_cpu_nice); |
| /* |
| * Assumption: nice time between sampling periods will |
| * be less than 2^32 jiffies for 32 bit sys |
| */ |
| cur_nice_jiffies = (unsigned long) |
| cputime64_to_jiffies64(cur_nice); |
| |
| j_dbs_info->prev_cpu_nice = kstat_cpu(j).cpustat.nice; |
| idle_time += jiffies_to_usecs(cur_nice_jiffies); |
| } |
| |
| if (unlikely(!wall_time || wall_time < idle_time)) |
| continue; |
| |
| load = 100 * (wall_time - idle_time) / wall_time; |
| } |
| |
| /* |
| * break out if we 'cannot' reduce the speed as the user might |
| * want freq_step to be zero |
| */ |
| if (dbs_tuners_ins.freq_step == 0) |
| return; |
| |
| /* Check for frequency increase */ |
| if (load > dbs_tuners_ins.up_threshold) { |
| this_dbs_info->down_skip = 0; |
| |
| /* if we are already at full speed then break out early */ |
| if (this_dbs_info->requested_freq == policy->max) |
| return; |
| |
| freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100; |
| |
| /* max freq cannot be less than 100. But who knows.... */ |
| if (unlikely(freq_target == 0)) |
| freq_target = 5; |
| |
| this_dbs_info->requested_freq += freq_target; |
| if (this_dbs_info->requested_freq > policy->max) |
| this_dbs_info->requested_freq = policy->max; |
| |
| __cpufreq_driver_target(policy, this_dbs_info->requested_freq, |
| CPUFREQ_RELATION_H); |
| 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. |
| */ |
| if (load < (dbs_tuners_ins.down_threshold - 10)) { |
| freq_target = (dbs_tuners_ins.freq_step * policy->max) / 100; |
| |
| this_dbs_info->requested_freq -= freq_target; |
| if (this_dbs_info->requested_freq < policy->min) |
| this_dbs_info->requested_freq = policy->min; |
| |
| /* |
| * if we cannot reduce the frequency anymore, break out early |
| */ |
| if (policy->cur == policy->min) |
| return; |
| |
| __cpufreq_driver_target(policy, this_dbs_info->requested_freq, |
| CPUFREQ_RELATION_H); |
| return; |
| } |
| } |
| |
| static void do_dbs_timer(struct work_struct *work) |
| { |
| struct cpu_dbs_info_s *dbs_info = |
| container_of(work, struct cpu_dbs_info_s, work.work); |
| unsigned int cpu = dbs_info->cpu; |
| |
| /* We want all CPUs to do sampling nearly on same jiffy */ |
| int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); |
| |
| delay -= jiffies % delay; |
| |
| if (lock_policy_rwsem_write(cpu) < 0) |
| return; |
| |
| if (!dbs_info->enable) { |
| unlock_policy_rwsem_write(cpu); |
| return; |
| } |
| |
| dbs_check_cpu(dbs_info); |
| |
| queue_delayed_work_on(cpu, kconservative_wq, &dbs_info->work, delay); |
| unlock_policy_rwsem_write(cpu); |
| } |
| |
| static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) |
| { |
| /* We want all CPUs to do sampling nearly on same jiffy */ |
| int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); |
| delay -= jiffies % delay; |
| |
| dbs_info->enable = 1; |
| INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer); |
| queue_delayed_work_on(dbs_info->cpu, kconservative_wq, &dbs_info->work, |
| delay); |
| } |
| |
| static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info) |
| { |
| dbs_info->enable = 0; |
| cancel_delayed_work_sync(&dbs_info->work); |
| } |
| |
| 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; |
| int rc; |
| |
| this_dbs_info = &per_cpu(cpu_dbs_info, cpu); |
| |
| switch (event) { |
| case CPUFREQ_GOV_START: |
| if ((!cpu_online(cpu)) || (!policy->cur)) |
| return -EINVAL; |
| |
| if (this_dbs_info->enable) /* Already enabled */ |
| break; |
| |
| mutex_lock(&dbs_mutex); |
| |
| rc = sysfs_create_group(&policy->kobj, &dbs_attr_group); |
| if (rc) { |
| mutex_unlock(&dbs_mutex); |
| return rc; |
| } |
| |
| for_each_cpu(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; |
| |
| j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j, |
| &j_dbs_info->prev_cpu_wall); |
| if (dbs_tuners_ins.ignore_nice) { |
| j_dbs_info->prev_cpu_nice = |
| kstat_cpu(j).cpustat.nice; |
| } |
| } |
| this_dbs_info->down_skip = 0; |
| this_dbs_info->requested_freq = policy->cur; |
| |
| dbs_enable++; |
| /* |
| * 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 */ |
| latency = policy->cpuinfo.transition_latency / 1000; |
| if (latency == 0) |
| latency = 1; |
| |
| /* |
| * conservative does not implement micro like ondemand |
| * governor, thus we are bound to jiffes/HZ |
| */ |
| min_sampling_rate = |
| MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10); |
| /* Bring kernel and HW constraints together */ |
| min_sampling_rate = max(min_sampling_rate, |
| MIN_LATENCY_MULTIPLIER * latency); |
| dbs_tuners_ins.sampling_rate = |
| max(min_sampling_rate, |
| latency * LATENCY_MULTIPLIER); |
| |
| cpufreq_register_notifier( |
| &dbs_cpufreq_notifier_block, |
| CPUFREQ_TRANSITION_NOTIFIER); |
| } |
| dbs_timer_init(this_dbs_info); |
| |
| mutex_unlock(&dbs_mutex); |
| |
| break; |
| |
| case CPUFREQ_GOV_STOP: |
| mutex_lock(&dbs_mutex); |
| dbs_timer_exit(this_dbs_info); |
| sysfs_remove_group(&policy->kobj, &dbs_attr_group); |
| dbs_enable--; |
| |
| /* |
| * Stop the timerschedule work, when this governor |
| * is used for first time |
| */ |
| if (dbs_enable == 0) |
| cpufreq_unregister_notifier( |
| &dbs_cpufreq_notifier_block, |
| CPUFREQ_TRANSITION_NOTIFIER); |
| |
| mutex_unlock(&dbs_mutex); |
| |
| break; |
| |
| case CPUFREQ_GOV_LIMITS: |
| mutex_lock(&dbs_mutex); |
| if (policy->max < this_dbs_info->cur_policy->cur) |
| __cpufreq_driver_target( |
| this_dbs_info->cur_policy, |
| policy->max, CPUFREQ_RELATION_H); |
| else if (policy->min > this_dbs_info->cur_policy->cur) |
| __cpufreq_driver_target( |
| this_dbs_info->cur_policy, |
| policy->min, CPUFREQ_RELATION_L); |
| mutex_unlock(&dbs_mutex); |
| |
| break; |
| } |
| return 0; |
| } |
| |
| #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE |
| static |
| #endif |
| struct cpufreq_governor cpufreq_gov_conservative = { |
| .name = "conservative", |
| .governor = cpufreq_governor_dbs, |
| .max_transition_latency = TRANSITION_LATENCY_LIMIT, |
| .owner = THIS_MODULE, |
| }; |
| |
| static int __init cpufreq_gov_dbs_init(void) |
| { |
| int err; |
| |
| kconservative_wq = create_workqueue("kconservative"); |
| if (!kconservative_wq) { |
| printk(KERN_ERR "Creation of kconservative failed\n"); |
| return -EFAULT; |
| } |
| |
| err = cpufreq_register_governor(&cpufreq_gov_conservative); |
| if (err) |
| destroy_workqueue(kconservative_wq); |
| |
| return err; |
| } |
| |
| static void __exit cpufreq_gov_dbs_exit(void) |
| { |
| cpufreq_unregister_governor(&cpufreq_gov_conservative); |
| destroy_workqueue(kconservative_wq); |
| } |
| |
| |
| MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>"); |
| MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for " |
| "Low Latency Frequency Transition capable processors " |
| "optimised for use in a battery environment"); |
| MODULE_LICENSE("GPL"); |
| |
| #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE |
| fs_initcall(cpufreq_gov_dbs_init); |
| #else |
| module_init(cpufreq_gov_dbs_init); |
| #endif |
| module_exit(cpufreq_gov_dbs_exit); |