]> git.karo-electronics.de Git - mv-sheeva.git/blobdiff - drivers/cpufreq/cpufreq_ondemand.c
[CPUFREQ] ondemand,conservative governor store the idle ticks for all cpus
[mv-sheeva.git] / drivers / cpufreq / cpufreq_ondemand.c
index 7d7244314ac9a4d55e78d9427102dbe7ab59366a..f239545ac1b84df92b4e0fa04d5078726d68ea08 100644 (file)
@@ -79,6 +79,7 @@ struct dbs_tuners {
        unsigned int            up_threshold;
        unsigned int            down_threshold;
        unsigned int            ignore_nice;
+       unsigned int            freq_step;
 };
 
 static struct dbs_tuners dbs_tuners_ins = {
@@ -87,6 +88,15 @@ static struct dbs_tuners dbs_tuners_ins = {
        .sampling_down_factor   = DEF_SAMPLING_DOWN_FACTOR,
 };
 
+static inline unsigned int get_cpu_idle_time(unsigned int cpu)
+{
+       return  kstat_cpu(cpu).cpustat.idle +
+               kstat_cpu(cpu).cpustat.iowait +
+               ( !dbs_tuners_ins.ignore_nice ? 
+                 kstat_cpu(cpu).cpustat.nice :
+                 0);
+}
+
 /************************** sysfs interface ************************/
 static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
 {
@@ -117,6 +127,7 @@ show_one(sampling_down_factor, sampling_down_factor);
 show_one(up_threshold, up_threshold);
 show_one(down_threshold, down_threshold);
 show_one(ignore_nice, 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)
@@ -218,16 +229,10 @@ static ssize_t store_ignore_nice(struct cpufreq_policy *policy,
        dbs_tuners_ins.ignore_nice = input;
 
        /* we need to re-evaluate prev_cpu_idle_up and prev_cpu_idle_down */
-       for_each_cpu_mask(j, policy->cpus) {
+       for_each_online_cpu(j) {
                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_up =
-                       kstat_cpu(j).cpustat.idle +
-                       kstat_cpu(j).cpustat.iowait +
-                       ( !dbs_tuners_ins.ignore_nice
-                         ? kstat_cpu(j).cpustat.nice : 0 );
+               j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
                j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;
        }
        up(&dbs_sem);
@@ -235,6 +240,29 @@ static ssize_t store_ignore_nice(struct cpufreq_policy *policy,
        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 :) */
+       down(&dbs_sem);
+       dbs_tuners_ins.freq_step = input;
+       up(&dbs_sem);
+
+       return count;
+}
+
 #define define_one_rw(_name) \
 static struct freq_attr _name = \
 __ATTR(_name, 0644, show_##_name, store_##_name)
@@ -244,6 +272,7 @@ define_one_rw(sampling_down_factor);
 define_one_rw(up_threshold);
 define_one_rw(down_threshold);
 define_one_rw(ignore_nice);
+define_one_rw(freq_step);
 
 static struct attribute * dbs_attributes[] = {
        &sampling_rate_max.attr,
@@ -253,6 +282,7 @@ static struct attribute * dbs_attributes[] = {
        &up_threshold.attr,
        &down_threshold.attr,
        &ignore_nice.attr,
+       &freq_step.attr,
        NULL
 };
 
@@ -291,19 +321,14 @@ static void dbs_check_cpu(int cpu)
         *
         * Any frequency increase takes it to the maximum frequency. 
         * Frequency reduction happens at minimum steps of 
-        * 5% of max_frequency 
+        * 5% (default) of max_frequency 
         */
 
        /* Check for frequency increase */
-       total_idle_ticks = kstat_cpu(cpu).cpustat.idle +
-               kstat_cpu(cpu).cpustat.iowait;
-         /* consider 'nice' tasks as 'idle' time too if required */
-         if (dbs_tuners_ins.ignore_nice == 0)
-               total_idle_ticks += kstat_cpu(cpu).cpustat.nice;
+       total_idle_ticks = get_cpu_idle_time(cpu);
        idle_ticks = total_idle_ticks -
                this_dbs_info->prev_cpu_idle_up;
        this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
-       
 
        for_each_cpu_mask(j, policy->cpus) {
                unsigned int tmp_idle_ticks;
@@ -314,11 +339,7 @@ static void dbs_check_cpu(int cpu)
 
                j_dbs_info = &per_cpu(cpu_dbs_info, j);
                /* Check for frequency increase */
-               total_idle_ticks = kstat_cpu(j).cpustat.idle +
-                       kstat_cpu(j).cpustat.iowait;
-                 /* consider 'nice' too? */
-                 if (dbs_tuners_ins.ignore_nice == 0)
-                          total_idle_ticks += kstat_cpu(j).cpustat.nice;
+               total_idle_ticks = get_cpu_idle_time(j);
                tmp_idle_ticks = total_idle_ticks -
                        j_dbs_info->prev_cpu_idle_up;
                j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
@@ -333,10 +354,20 @@ static void dbs_check_cpu(int cpu)
                        usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
 
        if (idle_ticks < up_idle_ticks) {
+               down_skip[cpu] = 0;
+               for_each_cpu_mask(j, policy->cpus) {
+                       struct cpu_dbs_info_s *j_dbs_info;
+
+                       j_dbs_info = &per_cpu(cpu_dbs_info, j);
+                       j_dbs_info->prev_cpu_idle_down = 
+                                       j_dbs_info->prev_cpu_idle_up;
+               }
+               /* if we are already at full speed then break out early */
+               if (policy->cur == policy->max)
+                       return;
+               
                __cpufreq_driver_target(policy, policy->max, 
                        CPUFREQ_RELATION_H);
-               down_skip[cpu] = 0;
-               this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
                return;
        }
 
@@ -345,11 +376,7 @@ static void dbs_check_cpu(int cpu)
        if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
                return;
 
-       total_idle_ticks = kstat_cpu(cpu).cpustat.idle +
-               kstat_cpu(cpu).cpustat.iowait;
-         /* consider 'nice' too? */
-         if (dbs_tuners_ins.ignore_nice == 0)
-                 total_idle_ticks += kstat_cpu(cpu).cpustat.nice;
+       total_idle_ticks = this_dbs_info->prev_cpu_idle_up;
        idle_ticks = total_idle_ticks -
                this_dbs_info->prev_cpu_idle_down;
        this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
@@ -362,12 +389,8 @@ static void dbs_check_cpu(int cpu)
                        continue;
 
                j_dbs_info = &per_cpu(cpu_dbs_info, j);
-               /* Check for frequency increase */
-               total_idle_ticks = kstat_cpu(j).cpustat.idle +
-                       kstat_cpu(j).cpustat.iowait;
-                 /* consider 'nice' too? */
-                 if (dbs_tuners_ins.ignore_nice == 0)
-                       total_idle_ticks += kstat_cpu(j).cpustat.nice;
+               /* Check for frequency decrease */
+               total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
                tmp_idle_ticks = total_idle_ticks -
                        j_dbs_info->prev_cpu_idle_down;
                j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
@@ -383,17 +406,23 @@ static void dbs_check_cpu(int cpu)
        freq_down_sampling_rate = dbs_tuners_ins.sampling_rate *
                dbs_tuners_ins.sampling_down_factor;
        down_idle_ticks = (100 - dbs_tuners_ins.down_threshold) *
-                       usecs_to_jiffies(freq_down_sampling_rate);
+               usecs_to_jiffies(freq_down_sampling_rate);
 
        if (idle_ticks > down_idle_ticks ) {
-               freq_down_step = (5 * policy->max) / 100;
+               /* if we are already at the lowest speed then break out early
+                * or if we 'cannot' reduce the speed as the user might want
+                * freq_step to be zero */
+               if (policy->cur == policy->min || dbs_tuners_ins.freq_step == 0)
+                       return;
+
+               freq_down_step = (dbs_tuners_ins.freq_step * policy->max) / 100;
 
                /* max freq cannot be less than 100. But who knows.... */
                if (unlikely(freq_down_step == 0))
                        freq_down_step = 5;
 
                __cpufreq_driver_target(policy,
-                       policy->cur - freq_down_step, 
+                       policy->cur - freq_down_step,
                        CPUFREQ_RELATION_H);
                return;
        }
@@ -451,11 +480,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                        j_dbs_info = &per_cpu(cpu_dbs_info, j);
                        j_dbs_info->cur_policy = policy;
                
-                       j_dbs_info->prev_cpu_idle_up = 
-                               kstat_cpu(j).cpustat.idle +
-                               kstat_cpu(j).cpustat.iowait +
-                               ( !dbs_tuners_ins.ignore_nice
-                                 ? kstat_cpu(j).cpustat.nice : 0 );
+                       j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);
                        j_dbs_info->prev_cpu_idle_down
                                = j_dbs_info->prev_cpu_idle_up;
                }
@@ -478,6 +503,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                                        DEF_SAMPLING_RATE_LATENCY_MULTIPLIER;
                        dbs_tuners_ins.sampling_rate = def_sampling_rate;
                        dbs_tuners_ins.ignore_nice = 0;
+                       dbs_tuners_ins.freq_step = 5;
 
                        dbs_timer_init();
                }