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