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/slab.h> 15 #include "cpufreq_governor.h" 16 17 /* Conservative governor macros */ 18 #define DEF_FREQUENCY_UP_THRESHOLD (80) 19 #define DEF_FREQUENCY_DOWN_THRESHOLD (20) 20 #define DEF_FREQUENCY_STEP (5) 21 #define DEF_SAMPLING_DOWN_FACTOR (1) 22 #define MAX_SAMPLING_DOWN_FACTOR (10) 23 24 static DEFINE_PER_CPU(struct cs_cpu_dbs_info_s, cs_cpu_dbs_info); 25 26 static inline unsigned int get_freq_target(struct cs_dbs_tuners *cs_tuners, 27 struct cpufreq_policy *policy) 28 { 29 unsigned int freq_target = (cs_tuners->freq_step * policy->max) / 100; 30 31 /* max freq cannot be less than 100. But who knows... */ 32 if (unlikely(freq_target == 0)) 33 freq_target = DEF_FREQUENCY_STEP; 34 35 return freq_target; 36 } 37 38 /* 39 * Every sampling_rate, we check, if current idle time is less than 20% 40 * (default), then we try to increase frequency. Every sampling_rate * 41 * sampling_down_factor, we check, if current idle time is more than 80% 42 * (default), then we try to decrease frequency 43 * 44 * Any frequency increase takes it to the maximum frequency. Frequency reduction 45 * happens at minimum steps of 5% (default) of maximum frequency 46 */ 47 static void cs_check_cpu(int cpu, unsigned int load) 48 { 49 struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, cpu); 50 struct cpufreq_policy *policy = dbs_info->cdbs.policy_dbs->policy; 51 struct policy_dbs_info *policy_dbs = policy->governor_data; 52 struct dbs_data *dbs_data = policy_dbs->dbs_data; 53 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 54 55 /* 56 * break out if we 'cannot' reduce the speed as the user might 57 * want freq_step to be zero 58 */ 59 if (cs_tuners->freq_step == 0) 60 return; 61 62 /* Check for frequency increase */ 63 if (load > dbs_data->up_threshold) { 64 dbs_info->down_skip = 0; 65 66 /* if we are already at full speed then break out early */ 67 if (dbs_info->requested_freq == policy->max) 68 return; 69 70 dbs_info->requested_freq += get_freq_target(cs_tuners, policy); 71 72 if (dbs_info->requested_freq > policy->max) 73 dbs_info->requested_freq = policy->max; 74 75 __cpufreq_driver_target(policy, dbs_info->requested_freq, 76 CPUFREQ_RELATION_H); 77 return; 78 } 79 80 /* if sampling_down_factor is active break out early */ 81 if (++dbs_info->down_skip < dbs_data->sampling_down_factor) 82 return; 83 dbs_info->down_skip = 0; 84 85 /* Check for frequency decrease */ 86 if (load < cs_tuners->down_threshold) { 87 unsigned int freq_target; 88 /* 89 * if we cannot reduce the frequency anymore, break out early 90 */ 91 if (policy->cur == policy->min) 92 return; 93 94 freq_target = get_freq_target(cs_tuners, policy); 95 if (dbs_info->requested_freq > freq_target) 96 dbs_info->requested_freq -= freq_target; 97 else 98 dbs_info->requested_freq = policy->min; 99 100 __cpufreq_driver_target(policy, dbs_info->requested_freq, 101 CPUFREQ_RELATION_L); 102 return; 103 } 104 } 105 106 static unsigned int cs_dbs_timer(struct cpufreq_policy *policy) 107 { 108 struct policy_dbs_info *policy_dbs = policy->governor_data; 109 struct dbs_data *dbs_data = policy_dbs->dbs_data; 110 111 dbs_check_cpu(policy); 112 return delay_for_sampling_rate(dbs_data->sampling_rate); 113 } 114 115 static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, 116 void *data); 117 118 static struct notifier_block cs_cpufreq_notifier_block = { 119 .notifier_call = dbs_cpufreq_notifier, 120 }; 121 122 /************************** sysfs interface ************************/ 123 static struct dbs_governor cs_dbs_gov; 124 125 static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data, 126 const char *buf, size_t count) 127 { 128 unsigned int input; 129 int ret; 130 ret = sscanf(buf, "%u", &input); 131 132 if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) 133 return -EINVAL; 134 135 dbs_data->sampling_down_factor = input; 136 return count; 137 } 138 139 static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf, 140 size_t count) 141 { 142 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 143 unsigned int input; 144 int ret; 145 ret = sscanf(buf, "%u", &input); 146 147 if (ret != 1 || input > 100 || input <= cs_tuners->down_threshold) 148 return -EINVAL; 149 150 dbs_data->up_threshold = input; 151 return count; 152 } 153 154 static ssize_t store_down_threshold(struct dbs_data *dbs_data, const char *buf, 155 size_t count) 156 { 157 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 158 unsigned int input; 159 int ret; 160 ret = sscanf(buf, "%u", &input); 161 162 /* cannot be lower than 11 otherwise freq will not fall */ 163 if (ret != 1 || input < 11 || input > 100 || 164 input >= dbs_data->up_threshold) 165 return -EINVAL; 166 167 cs_tuners->down_threshold = input; 168 return count; 169 } 170 171 static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data, 172 const char *buf, size_t count) 173 { 174 unsigned int input, j; 175 int ret; 176 177 ret = sscanf(buf, "%u", &input); 178 if (ret != 1) 179 return -EINVAL; 180 181 if (input > 1) 182 input = 1; 183 184 if (input == dbs_data->ignore_nice_load) /* nothing to do */ 185 return count; 186 187 dbs_data->ignore_nice_load = input; 188 189 /* we need to re-evaluate prev_cpu_idle */ 190 for_each_online_cpu(j) { 191 struct cs_cpu_dbs_info_s *dbs_info; 192 dbs_info = &per_cpu(cs_cpu_dbs_info, j); 193 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, 194 &dbs_info->cdbs.prev_cpu_wall, 0); 195 if (dbs_data->ignore_nice_load) 196 dbs_info->cdbs.prev_cpu_nice = 197 kcpustat_cpu(j).cpustat[CPUTIME_NICE]; 198 } 199 return count; 200 } 201 202 static ssize_t store_freq_step(struct dbs_data *dbs_data, const char *buf, 203 size_t count) 204 { 205 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 206 unsigned int input; 207 int ret; 208 ret = sscanf(buf, "%u", &input); 209 210 if (ret != 1) 211 return -EINVAL; 212 213 if (input > 100) 214 input = 100; 215 216 /* 217 * no need to test here if freq_step is zero as the user might actually 218 * want this, they would be crazy though :) 219 */ 220 cs_tuners->freq_step = input; 221 return count; 222 } 223 224 gov_show_one_common(sampling_rate); 225 gov_show_one_common(sampling_down_factor); 226 gov_show_one_common(up_threshold); 227 gov_show_one_common(ignore_nice_load); 228 gov_show_one_common(min_sampling_rate); 229 gov_show_one(cs, down_threshold); 230 gov_show_one(cs, freq_step); 231 232 gov_attr_rw(sampling_rate); 233 gov_attr_rw(sampling_down_factor); 234 gov_attr_rw(up_threshold); 235 gov_attr_rw(ignore_nice_load); 236 gov_attr_ro(min_sampling_rate); 237 gov_attr_rw(down_threshold); 238 gov_attr_rw(freq_step); 239 240 static struct attribute *cs_attributes[] = { 241 &min_sampling_rate.attr, 242 &sampling_rate.attr, 243 &sampling_down_factor.attr, 244 &up_threshold.attr, 245 &down_threshold.attr, 246 &ignore_nice_load.attr, 247 &freq_step.attr, 248 NULL 249 }; 250 251 /************************** sysfs end ************************/ 252 253 static int cs_init(struct dbs_data *dbs_data, bool notify) 254 { 255 struct cs_dbs_tuners *tuners; 256 257 tuners = kzalloc(sizeof(*tuners), GFP_KERNEL); 258 if (!tuners) { 259 pr_err("%s: kzalloc failed\n", __func__); 260 return -ENOMEM; 261 } 262 263 tuners->down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD; 264 tuners->freq_step = DEF_FREQUENCY_STEP; 265 dbs_data->up_threshold = DEF_FREQUENCY_UP_THRESHOLD; 266 dbs_data->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR; 267 dbs_data->ignore_nice_load = 0; 268 269 dbs_data->tuners = tuners; 270 dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO * 271 jiffies_to_usecs(10); 272 273 if (notify) 274 cpufreq_register_notifier(&cs_cpufreq_notifier_block, 275 CPUFREQ_TRANSITION_NOTIFIER); 276 277 return 0; 278 } 279 280 static void cs_exit(struct dbs_data *dbs_data, bool notify) 281 { 282 if (notify) 283 cpufreq_unregister_notifier(&cs_cpufreq_notifier_block, 284 CPUFREQ_TRANSITION_NOTIFIER); 285 286 kfree(dbs_data->tuners); 287 } 288 289 define_get_cpu_dbs_routines(cs_cpu_dbs_info); 290 291 static struct dbs_governor cs_dbs_gov = { 292 .gov = { 293 .name = "conservative", 294 .governor = cpufreq_governor_dbs, 295 .max_transition_latency = TRANSITION_LATENCY_LIMIT, 296 .owner = THIS_MODULE, 297 }, 298 .governor = GOV_CONSERVATIVE, 299 .kobj_type = { .default_attrs = cs_attributes }, 300 .get_cpu_cdbs = get_cpu_cdbs, 301 .get_cpu_dbs_info_s = get_cpu_dbs_info_s, 302 .gov_dbs_timer = cs_dbs_timer, 303 .gov_check_cpu = cs_check_cpu, 304 .init = cs_init, 305 .exit = cs_exit, 306 }; 307 308 #define CPU_FREQ_GOV_CONSERVATIVE (&cs_dbs_gov.gov) 309 310 static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, 311 void *data) 312 { 313 struct cpufreq_freqs *freq = data; 314 struct cs_cpu_dbs_info_s *dbs_info = 315 &per_cpu(cs_cpu_dbs_info, freq->cpu); 316 struct cpufreq_policy *policy = cpufreq_cpu_get_raw(freq->cpu); 317 318 if (!policy) 319 return 0; 320 321 /* policy isn't governed by conservative governor */ 322 if (policy->governor != CPU_FREQ_GOV_CONSERVATIVE) 323 return 0; 324 325 /* 326 * we only care if our internally tracked freq moves outside the 'valid' 327 * ranges of frequency available to us otherwise we do not change it 328 */ 329 if (dbs_info->requested_freq > policy->max 330 || dbs_info->requested_freq < policy->min) 331 dbs_info->requested_freq = freq->new; 332 333 return 0; 334 } 335 336 static int __init cpufreq_gov_dbs_init(void) 337 { 338 return cpufreq_register_governor(CPU_FREQ_GOV_CONSERVATIVE); 339 } 340 341 static void __exit cpufreq_gov_dbs_exit(void) 342 { 343 cpufreq_unregister_governor(CPU_FREQ_GOV_CONSERVATIVE); 344 } 345 346 MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>"); 347 MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for " 348 "Low Latency Frequency Transition capable processors " 349 "optimised for use in a battery environment"); 350 MODULE_LICENSE("GPL"); 351 352 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE 353 struct cpufreq_governor *cpufreq_default_governor(void) 354 { 355 return CPU_FREQ_GOV_CONSERVATIVE; 356 } 357 358 fs_initcall(cpufreq_gov_dbs_init); 359 #else 360 module_init(cpufreq_gov_dbs_init); 361 #endif 362 module_exit(cpufreq_gov_dbs_exit); 363