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