cpufreq: governors: remove redundant code

Initially ondemand governor was written and then using its code conservative
governor is written. It used a lot of code from ondemand governor, but copy of
code was created instead of using the same routines from both governors. Which
increased code redundancy, which is difficult to manage.

This patch is an attempt to move common part of both the governors to
cpufreq_governor.c file to come over above mentioned issues.

This shouldn't change anything from functionality point of view.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

1 files changed, 159 insertions, 389 deletions

diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 181abad07266..64ef737e7e72 100644
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -11,83 +11,30 @@
  * 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/init.h>
+#include <linux/kernel.h>
 #include <linux/kernel_stat.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
 #include <linux/mutex.h>
-#include <linux/hrtimer.h>
-#include <linux/tick.h>
-#include <linux/ktime.h>
-#include <linux/sched.h>
+#include <linux/notifier.h>
+#include <linux/percpu-defs.h>
+#include <linux/sysfs.h>
+#include <linux/types.h>
 
-/*
- * dbs is used in this file as a shortform for demandbased switching
- * It helps to keep variable names smaller, simpler
- */
+#include "cpufreq_governor.h"
 
+/* Conservative governor macors */
 #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;
-        /*
-         * percpu mutex that serializes governor limit change with
-         * do_dbs_timer invocation. We do not want do_dbs_timer to run
-         * when user is changing the governor or limits.
-         */
-        struct mutex timer_mutex;
-};
-static DEFINE_PER_CPU(struct cpu_dbs_info_s, cs_cpu_dbs_info);
 
-static unsigned int dbs_enable; /* number of CPUs using this policy */
+static struct dbs_data cs_dbs_data;
+static DEFINE_PER_CPU(struct cs_cpu_dbs_info_s, cs_cpu_dbs_info);
 
-/*
- * dbs_mutex protects dbs_enable in governor start/stop.
- */
-static DEFINE_MUTEX(dbs_mutex);
-
-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 = {
+static struct cs_dbs_tuners cs_tuners = {
         .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
         .down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD,
         .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR,
@@ -95,61 +42,121 @@ static struct dbs_tuners {
         .freq_step = 5,
 };
 
-/* keep track of frequency transitions */
-static int
-dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
-                     void *data)
+/*
+ * 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
+ */
+static void cs_check_cpu(int cpu, unsigned int load)
 {
-        struct cpufreq_freqs *freq = data;
-        struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cs_cpu_dbs_info,
-                                                        freq->cpu);
+        struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, cpu);
+        struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy;
+        unsigned int freq_target;
+
+        /*
+         * break out if we 'cannot' reduce the speed as the user might
+         * want freq_step to be zero
+         */
+        if (cs_tuners.freq_step == 0)
+                return;
+
+        /* Check for frequency increase */
+        if (load > cs_tuners.up_threshold) {
+                dbs_info->down_skip = 0;
+
+                /* if we are already at full speed then break out early */
+                if (dbs_info->requested_freq == policy->max)
+                        return;
+
+                freq_target = (cs_tuners.freq_step * policy->max) / 100;
+
+                /* max freq cannot be less than 100. But who knows.... */
+                if (unlikely(freq_target == 0))
+                        freq_target = 5;
+
+                dbs_info->requested_freq += freq_target;
+                if (dbs_info->requested_freq > policy->max)
+                        dbs_info->requested_freq = policy->max;
 
+                __cpufreq_driver_target(policy, 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 < (cs_tuners.down_threshold - 10)) {
+                freq_target = (cs_tuners.freq_step * policy->max) / 100;
+
+                dbs_info->requested_freq -= freq_target;
+                if (dbs_info->requested_freq < policy->min)
+                        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, dbs_info->requested_freq,
+                                CPUFREQ_RELATION_H);
+                return;
+        }
+}
+
+static void cs_dbs_timer(struct work_struct *work)
+{
+        struct cs_cpu_dbs_info_s *dbs_info = container_of(work,
+                        struct cs_cpu_dbs_info_s, cdbs.work.work);
+        unsigned int cpu = dbs_info->cdbs.cpu;
+        int delay = delay_for_sampling_rate(cs_tuners.sampling_rate);
+
+        mutex_lock(&dbs_info->cdbs.timer_mutex);
+
+        dbs_check_cpu(&cs_dbs_data, cpu);
+
+        schedule_delayed_work_on(cpu, &dbs_info->cdbs.work, delay);
+        mutex_unlock(&dbs_info->cdbs.timer_mutex);
+}
+
+static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
+                void *data)
+{
+        struct cpufreq_freqs *freq = data;
+        struct cs_cpu_dbs_info_s *dbs_info =
+                                        &per_cpu(cs_cpu_dbs_info, freq->cpu);
         struct cpufreq_policy *policy;
 
-        if (!this_dbs_info->enable)
+        if (!dbs_info->enable)
                 return 0;
 
-        policy = this_dbs_info->cur_policy;
+        policy = dbs_info->cdbs.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
+         * 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;
+        if (dbs_info->requested_freq > policy->max
+                        || dbs_info->requested_freq < policy->min)
+                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_min(struct kobject *kobj,
                                       struct attribute *attr, char *buf)
 {
-        return sprintf(buf, "%u\n", min_sampling_rate);
+        return sprintf(buf, "%u\n", cs_dbs_data.min_sampling_rate);
 }
 
-define_one_global_ro(sampling_rate_min);
-
-/* cpufreq_conservative Governor Tunables */
-#define show_one(file_name, object)                                     \
-static ssize_t show_##file_name                                         \
-(struct kobject *kobj, struct attribute *attr, 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 kobject *a,
                                           struct attribute *b,
                                           const char *buf, size_t count)
@@ -161,7 +168,7 @@ static ssize_t store_sampling_down_factor(struct kobject *a,
         if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
                 return -EINVAL;
 
-        dbs_tuners_ins.sampling_down_factor = input;
+        cs_tuners.sampling_down_factor = input;
         return count;
 }
 
@@ -175,7 +182,7 @@ static ssize_t store_sampling_rate(struct kobject *a, struct attribute *b,
         if (ret != 1)
                 return -EINVAL;
 
-        dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate);
+        cs_tuners.sampling_rate = max(input, cs_dbs_data.min_sampling_rate);
         return count;
 }
 
@@ -186,11 +193,10 @@ static ssize_t store_up_threshold(struct kobject *a, struct attribute *b,
         int ret;
         ret = sscanf(buf, "%u", &input);
 
-        if (ret != 1 || input > 100 ||
-                        input <= dbs_tuners_ins.down_threshold)
+        if (ret != 1 || input > 100 || input <= cs_tuners.down_threshold)
                 return -EINVAL;
 
-        dbs_tuners_ins.up_threshold = input;
+        cs_tuners.up_threshold = input;
         return count;
 }
 
@@ -203,21 +209,19 @@ static ssize_t store_down_threshold(struct kobject *a, struct attribute *b,
 
         /* cannot be lower than 11 otherwise freq will not fall */
         if (ret != 1 || input < 11 || input > 100 ||
-                        input >= dbs_tuners_ins.up_threshold)
+                        input >= cs_tuners.up_threshold)
                 return -EINVAL;
 
-        dbs_tuners_ins.down_threshold = input;
+        cs_tuners.down_threshold = input;
         return count;
 }
 
 static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b,
                                       const char *buf, size_t count)
 {
-        unsigned int input;
+        unsigned int input, j;
         int ret;
 
-        unsigned int j;
-
         ret = sscanf(buf, "%u", &input);
         if (ret != 1)
                 return -EINVAL;
@@ -225,19 +229,20 @@ static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b,
         if (input > 1)
                 input = 1;
 
-        if (input == dbs_tuners_ins.ignore_nice) /* nothing to do */
+        if (input == cs_tuners.ignore_nice) /* nothing to do */
                 return count;
 
-        dbs_tuners_ins.ignore_nice = input;
+        cs_tuners.ignore_nice = input;
 
         /* we need to re-evaluate prev_cpu_idle */
         for_each_online_cpu(j) {
-                struct cpu_dbs_info_s *dbs_info;
+                struct cs_cpu_dbs_info_s *dbs_info;
                 dbs_info = &per_cpu(cs_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 = kcpustat_cpu(j).cpustat[CPUTIME_NICE];
+                dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
+                                                &dbs_info->cdbs.prev_cpu_wall);
+                if (cs_tuners.ignore_nice)
+                        dbs_info->cdbs.prev_cpu_nice =
+                                kcpustat_cpu(j).cpustat[CPUTIME_NICE];
         }
         return count;
 }
@@ -255,18 +260,28 @@ static ssize_t store_freq_step(struct kobject *a, struct attribute *b,
         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 :) */
-        dbs_tuners_ins.freq_step = input;
+        /*
+         * no need to test here if freq_step is zero as the user might actually
+         * want this, they would be crazy though :)
+         */
+        cs_tuners.freq_step = input;
         return count;
 }
 
+show_one(cs, sampling_rate, sampling_rate);
+show_one(cs, sampling_down_factor, sampling_down_factor);
+show_one(cs, up_threshold, up_threshold);
+show_one(cs, down_threshold, down_threshold);
+show_one(cs, ignore_nice_load, ignore_nice);
+show_one(cs, freq_step, freq_step);
+
 define_one_global_rw(sampling_rate);
 define_one_global_rw(sampling_down_factor);
 define_one_global_rw(up_threshold);
 define_one_global_rw(down_threshold);
 define_one_global_rw(ignore_nice_load);
 define_one_global_rw(freq_step);
+define_one_global_ro(sampling_rate_min);
 
 static struct attribute *dbs_attributes[] = {
         &sampling_rate_min.attr,
@@ -279,283 +294,38 @@ static struct attribute *dbs_attributes[] = {
         NULL
 };
 
-static struct attribute_group dbs_attr_group = {
+static struct attribute_group cs_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 max_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(cs_cpu_dbs_info, j);
-
-                cur_idle_time = get_cpu_idle_time(j, &cur_wall_time);
-
-                wall_time = (unsigned int)
-                        (cur_wall_time - j_dbs_info->prev_cpu_wall);
-                j_dbs_info->prev_cpu_wall = cur_wall_time;
-
-                idle_time = (unsigned int)
-                        (cur_idle_time - j_dbs_info->prev_cpu_idle);
-                j_dbs_info->prev_cpu_idle = cur_idle_time;
-
-                if (dbs_tuners_ins.ignore_nice) {
-                        u64 cur_nice;
-                        unsigned long cur_nice_jiffies;
-
-                        cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_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 = kcpustat_cpu(j).cpustat[CPUTIME_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;
-
-                if (load > max_load)
-                        max_load = load;
-        }
+define_get_cpu_dbs_routines(cs_cpu_dbs_info);
 
-        /*
-         * 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 (max_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 (max_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;
-
-        mutex_lock(&dbs_info->timer_mutex);
-
-        dbs_check_cpu(dbs_info);
-
-        schedule_delayed_work_on(cpu, &dbs_info->work, delay);
-        mutex_unlock(&dbs_info->timer_mutex);
-}
-
-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;
+static struct notifier_block cs_cpufreq_notifier_block = {
+        .notifier_call = dbs_cpufreq_notifier,
+};
 
-        dbs_info->enable = 1;
-        INIT_DEFERRABLE_WORK(&dbs_info->work, do_dbs_timer);
-        schedule_delayed_work_on(dbs_info->cpu, &dbs_info->work, delay);
-}
+static struct cs_ops cs_ops = {
+        .notifier_block = &cs_cpufreq_notifier_block,
+};
 
-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 struct dbs_data cs_dbs_data = {
+        .governor = GOV_CONSERVATIVE,
+        .attr_group = &cs_attr_group,
+        .tuners = &cs_tuners,
+        .get_cpu_cdbs = get_cpu_cdbs,
+        .get_cpu_dbs_info_s = get_cpu_dbs_info_s,
+        .gov_dbs_timer = cs_dbs_timer,
+        .gov_check_cpu = cs_check_cpu,
+        .gov_ops = &cs_ops,
+};
 
-static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
+static int cs_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(cs_cpu_dbs_info, cpu);
-
-        switch (event) {
-        case CPUFREQ_GOV_START:
-                if ((!cpu_online(cpu)) || (!policy->cur))
-                        return -EINVAL;
-
-                mutex_lock(&dbs_mutex);
-
-                for_each_cpu(j, policy->cpus) {
-                        struct cpu_dbs_info_s *j_dbs_info;
-                        j_dbs_info = &per_cpu(cs_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 =
-                                                kcpustat_cpu(j).cpustat[CPUTIME_NICE];
-                }
-                this_dbs_info->cpu = cpu;
-                this_dbs_info->down_skip = 0;
-                this_dbs_info->requested_freq = policy->cur;
-
-                mutex_init(&this_dbs_info->timer_mutex);
-                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;
-
-                        rc = sysfs_create_group(cpufreq_global_kobject,
-                                                &dbs_attr_group);
-                        if (rc) {
-                                mutex_unlock(&dbs_mutex);
-                                return rc;
-                        }
-
-                        /*
-                         * 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);
-                }
-                mutex_unlock(&dbs_mutex);
-
-                dbs_timer_init(this_dbs_info);
-
-                break;
-
-        case CPUFREQ_GOV_STOP:
-                dbs_timer_exit(this_dbs_info);
-
-                mutex_lock(&dbs_mutex);
-                dbs_enable--;
-                mutex_destroy(&this_dbs_info->timer_mutex);
-
-                /*
-                 * 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);
-                if (!dbs_enable)
-                        sysfs_remove_group(cpufreq_global_kobject,
-                                           &dbs_attr_group);
-
-                break;
-
-        case CPUFREQ_GOV_LIMITS:
-                mutex_lock(&this_dbs_info->timer_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);
-                dbs_check_cpu(this_dbs_info);
-                mutex_unlock(&this_dbs_info->timer_mutex);
-
-                break;
-        }
-        return 0;
+        return cpufreq_governor_dbs(&cs_dbs_data, policy, event);
 }
 
 #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
@@ -563,13 +333,14 @@ static
 #endif
 struct cpufreq_governor cpufreq_gov_conservative = {
         .name                   = "conservative",
-        .governor               = cpufreq_governor_dbs,
+        .governor               = cs_cpufreq_governor_dbs,
         .max_transition_latency = TRANSITION_LATENCY_LIMIT,
         .owner                  = THIS_MODULE,
 };
 
 static int __init cpufreq_gov_dbs_init(void)
 {
+        mutex_init(&cs_dbs_data.mutex);
         return cpufreq_register_governor(&cpufreq_gov_conservative);
 }
 
@@ -578,7 +349,6 @@ static void __exit cpufreq_gov_dbs_exit(void)
         cpufreq_unregister_governor(&cpufreq_gov_conservative);
 }
 
-
 MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
 MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for "
                 "Low Latency Frequency Transition capable processors "