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.shared->policy; 51 struct dbs_data *dbs_data = policy->governor_data; 52 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 53 54 /* 55 * break out if we 'cannot' reduce the speed as the user might 56 * want freq_step to be zero 57 */ 58 if (cs_tuners->freq_step == 0) 59 return; 60 61 /* Check for frequency increase */ 62 if (load > cs_tuners->up_threshold) { 63 dbs_info->down_skip = 0; 64 65 /* if we are already at full speed then break out early */ 66 if (dbs_info->requested_freq == policy->max) 67 return; 68 69 dbs_info->requested_freq += get_freq_target(cs_tuners, policy); 70 71 if (dbs_info->requested_freq > policy->max) 72 dbs_info->requested_freq = policy->max; 73 74 __cpufreq_driver_target(policy, dbs_info->requested_freq, 75 CPUFREQ_RELATION_H); 76 return; 77 } 78 79 /* if sampling_down_factor is active break out early */ 80 if (++dbs_info->down_skip < cs_tuners->sampling_down_factor) 81 return; 82 dbs_info->down_skip = 0; 83 84 /* Check for frequency decrease */ 85 if (load < cs_tuners->down_threshold) { 86 unsigned int freq_target; 87 /* 88 * if we cannot reduce the frequency anymore, break out early 89 */ 90 if (policy->cur == policy->min) 91 return; 92 93 freq_target = get_freq_target(cs_tuners, policy); 94 if (dbs_info->requested_freq > freq_target) 95 dbs_info->requested_freq -= freq_target; 96 else 97 dbs_info->requested_freq = policy->min; 98 99 __cpufreq_driver_target(policy, dbs_info->requested_freq, 100 CPUFREQ_RELATION_L); 101 return; 102 } 103 } 104 105 static unsigned int cs_dbs_timer(struct cpufreq_policy *policy) 106 { 107 struct dbs_data *dbs_data = policy->governor_data; 108 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 109 110 dbs_check_cpu(dbs_data, policy->cpu); 111 return delay_for_sampling_rate(cs_tuners->sampling_rate); 112 } 113 114 static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, 115 void *data); 116 117 static struct notifier_block cs_cpufreq_notifier_block = { 118 .notifier_call = dbs_cpufreq_notifier, 119 }; 120 121 /************************** sysfs interface ************************/ 122 static struct dbs_governor cs_dbs_gov; 123 124 static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data, 125 const char *buf, size_t count) 126 { 127 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 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 cs_tuners->sampling_down_factor = input; 136 return count; 137 } 138 139 static ssize_t store_sampling_rate(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) 148 return -EINVAL; 149 150 cs_tuners->sampling_rate = max(input, dbs_data->min_sampling_rate); 151 return count; 152 } 153 154 static ssize_t store_up_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 if (ret != 1 || input > 100 || input <= cs_tuners->down_threshold) 163 return -EINVAL; 164 165 cs_tuners->up_threshold = input; 166 return count; 167 } 168 169 static ssize_t store_down_threshold(struct dbs_data *dbs_data, const char *buf, 170 size_t count) 171 { 172 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 173 unsigned int input; 174 int ret; 175 ret = sscanf(buf, "%u", &input); 176 177 /* cannot be lower than 11 otherwise freq will not fall */ 178 if (ret != 1 || input < 11 || input > 100 || 179 input >= cs_tuners->up_threshold) 180 return -EINVAL; 181 182 cs_tuners->down_threshold = input; 183 return count; 184 } 185 186 static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data, 187 const char *buf, size_t count) 188 { 189 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 190 unsigned int input, j; 191 int ret; 192 193 ret = sscanf(buf, "%u", &input); 194 if (ret != 1) 195 return -EINVAL; 196 197 if (input > 1) 198 input = 1; 199 200 if (input == cs_tuners->ignore_nice_load) /* nothing to do */ 201 return count; 202 203 cs_tuners->ignore_nice_load = input; 204 205 /* we need to re-evaluate prev_cpu_idle */ 206 for_each_online_cpu(j) { 207 struct cs_cpu_dbs_info_s *dbs_info; 208 dbs_info = &per_cpu(cs_cpu_dbs_info, j); 209 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, 210 &dbs_info->cdbs.prev_cpu_wall, 0); 211 if (cs_tuners->ignore_nice_load) 212 dbs_info->cdbs.prev_cpu_nice = 213 kcpustat_cpu(j).cpustat[CPUTIME_NICE]; 214 } 215 return count; 216 } 217 218 static ssize_t store_freq_step(struct dbs_data *dbs_data, const char *buf, 219 size_t count) 220 { 221 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 222 unsigned int input; 223 int ret; 224 ret = sscanf(buf, "%u", &input); 225 226 if (ret != 1) 227 return -EINVAL; 228 229 if (input > 100) 230 input = 100; 231 232 /* 233 * no need to test here if freq_step is zero as the user might actually 234 * want this, they would be crazy though :) 235 */ 236 cs_tuners->freq_step = input; 237 return count; 238 } 239 240 show_store_one(cs, sampling_rate); 241 show_store_one(cs, sampling_down_factor); 242 show_store_one(cs, up_threshold); 243 show_store_one(cs, down_threshold); 244 show_store_one(cs, ignore_nice_load); 245 show_store_one(cs, freq_step); 246 declare_show_sampling_rate_min(cs); 247 248 gov_sys_pol_attr_rw(sampling_rate); 249 gov_sys_pol_attr_rw(sampling_down_factor); 250 gov_sys_pol_attr_rw(up_threshold); 251 gov_sys_pol_attr_rw(down_threshold); 252 gov_sys_pol_attr_rw(ignore_nice_load); 253 gov_sys_pol_attr_rw(freq_step); 254 gov_sys_pol_attr_ro(sampling_rate_min); 255 256 static struct attribute *dbs_attributes_gov_sys[] = { 257 &sampling_rate_min_gov_sys.attr, 258 &sampling_rate_gov_sys.attr, 259 &sampling_down_factor_gov_sys.attr, 260 &up_threshold_gov_sys.attr, 261 &down_threshold_gov_sys.attr, 262 &ignore_nice_load_gov_sys.attr, 263 &freq_step_gov_sys.attr, 264 NULL 265 }; 266 267 static struct attribute_group cs_attr_group_gov_sys = { 268 .attrs = dbs_attributes_gov_sys, 269 .name = "conservative", 270 }; 271 272 static struct attribute *dbs_attributes_gov_pol[] = { 273 &sampling_rate_min_gov_pol.attr, 274 &sampling_rate_gov_pol.attr, 275 &sampling_down_factor_gov_pol.attr, 276 &up_threshold_gov_pol.attr, 277 &down_threshold_gov_pol.attr, 278 &ignore_nice_load_gov_pol.attr, 279 &freq_step_gov_pol.attr, 280 NULL 281 }; 282 283 static struct attribute_group cs_attr_group_gov_pol = { 284 .attrs = dbs_attributes_gov_pol, 285 .name = "conservative", 286 }; 287 288 /************************** sysfs end ************************/ 289 290 static int cs_init(struct dbs_data *dbs_data, bool notify) 291 { 292 struct cs_dbs_tuners *tuners; 293 294 tuners = kzalloc(sizeof(*tuners), GFP_KERNEL); 295 if (!tuners) { 296 pr_err("%s: kzalloc failed\n", __func__); 297 return -ENOMEM; 298 } 299 300 tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD; 301 tuners->down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD; 302 tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR; 303 tuners->ignore_nice_load = 0; 304 tuners->freq_step = DEF_FREQUENCY_STEP; 305 306 dbs_data->tuners = tuners; 307 dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO * 308 jiffies_to_usecs(10); 309 310 if (notify) 311 cpufreq_register_notifier(&cs_cpufreq_notifier_block, 312 CPUFREQ_TRANSITION_NOTIFIER); 313 314 return 0; 315 } 316 317 static void cs_exit(struct dbs_data *dbs_data, bool notify) 318 { 319 if (notify) 320 cpufreq_unregister_notifier(&cs_cpufreq_notifier_block, 321 CPUFREQ_TRANSITION_NOTIFIER); 322 323 kfree(dbs_data->tuners); 324 } 325 326 define_get_cpu_dbs_routines(cs_cpu_dbs_info); 327 328 static int cs_cpufreq_governor_dbs(struct cpufreq_policy *policy, 329 unsigned int event); 330 331 static struct dbs_governor cs_dbs_gov = { 332 .gov = { 333 .name = "conservative", 334 .governor = cs_cpufreq_governor_dbs, 335 .max_transition_latency = TRANSITION_LATENCY_LIMIT, 336 .owner = THIS_MODULE, 337 }, 338 .governor = GOV_CONSERVATIVE, 339 .attr_group_gov_sys = &cs_attr_group_gov_sys, 340 .attr_group_gov_pol = &cs_attr_group_gov_pol, 341 .get_cpu_cdbs = get_cpu_cdbs, 342 .get_cpu_dbs_info_s = get_cpu_dbs_info_s, 343 .gov_dbs_timer = cs_dbs_timer, 344 .gov_check_cpu = cs_check_cpu, 345 .init = cs_init, 346 .exit = cs_exit, 347 }; 348 349 #define CPU_FREQ_GOV_CONSERVATIVE (&cs_dbs_gov.gov) 350 351 static int cs_cpufreq_governor_dbs(struct cpufreq_policy *policy, 352 unsigned int event) 353 { 354 return cpufreq_governor_dbs(policy, &cs_dbs_gov, event); 355 } 356 357 static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val, 358 void *data) 359 { 360 struct cpufreq_freqs *freq = data; 361 struct cs_cpu_dbs_info_s *dbs_info = 362 &per_cpu(cs_cpu_dbs_info, freq->cpu); 363 struct cpufreq_policy *policy = cpufreq_cpu_get_raw(freq->cpu); 364 365 if (!policy) 366 return 0; 367 368 /* policy isn't governed by conservative governor */ 369 if (policy->governor != CPU_FREQ_GOV_CONSERVATIVE) 370 return 0; 371 372 /* 373 * we only care if our internally tracked freq moves outside the 'valid' 374 * ranges of frequency available to us otherwise we do not change it 375 */ 376 if (dbs_info->requested_freq > policy->max 377 || dbs_info->requested_freq < policy->min) 378 dbs_info->requested_freq = freq->new; 379 380 return 0; 381 } 382 383 static int __init cpufreq_gov_dbs_init(void) 384 { 385 return cpufreq_register_governor(CPU_FREQ_GOV_CONSERVATIVE); 386 } 387 388 static void __exit cpufreq_gov_dbs_exit(void) 389 { 390 cpufreq_unregister_governor(CPU_FREQ_GOV_CONSERVATIVE); 391 } 392 393 MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>"); 394 MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for " 395 "Low Latency Frequency Transition capable processors " 396 "optimised for use in a battery environment"); 397 MODULE_LICENSE("GPL"); 398 399 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE 400 struct cpufreq_governor *cpufreq_default_governor(void) 401 { 402 return CPU_FREQ_GOV_CONSERVATIVE; 403 } 404 405 fs_initcall(cpufreq_gov_dbs_init); 406 #else 407 module_init(cpufreq_gov_dbs_init); 408 #endif 409 module_exit(cpufreq_gov_dbs_exit); 410