2 * drivers/cpufreq/cpufreq_conservative.c
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>
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.
14 #include <linux/slab.h>
15 #include "cpufreq_governor.h"
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)
24 static DEFINE_PER_CPU(struct cs_cpu_dbs_info_s, cs_cpu_dbs_info);
26 static inline unsigned int get_freq_target(struct cs_dbs_tuners *cs_tuners,
27 struct cpufreq_policy *policy)
29 unsigned int freq_target = (cs_tuners->freq_step * policy->max) / 100;
31 /* max freq cannot be less than 100. But who knows... */
32 if (unlikely(freq_target == 0))
33 freq_target = DEF_FREQUENCY_STEP;
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
44 * Any frequency increase takes it to the maximum frequency. Frequency reduction
45 * happens at minimum steps of 5% (default) of maximum frequency
47 static unsigned int cs_dbs_timer(struct cpufreq_policy *policy)
49 struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, policy->cpu);
50 struct policy_dbs_info *policy_dbs = policy->governor_data;
51 struct dbs_data *dbs_data = policy_dbs->dbs_data;
52 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
53 unsigned int load = dbs_update(policy);
56 * break out if we 'cannot' reduce the speed as the user might
57 * want freq_step to be zero
59 if (cs_tuners->freq_step == 0)
62 /* Check for frequency increase */
63 if (load > dbs_data->up_threshold) {
64 dbs_info->down_skip = 0;
66 /* if we are already at full speed then break out early */
67 if (dbs_info->requested_freq == policy->max)
70 dbs_info->requested_freq += get_freq_target(cs_tuners, policy);
72 if (dbs_info->requested_freq > policy->max)
73 dbs_info->requested_freq = policy->max;
75 __cpufreq_driver_target(policy, dbs_info->requested_freq,
80 /* if sampling_down_factor is active break out early */
81 if (++dbs_info->down_skip < dbs_data->sampling_down_factor)
83 dbs_info->down_skip = 0;
85 /* Check for frequency decrease */
86 if (load < cs_tuners->down_threshold) {
87 unsigned int freq_target;
89 * if we cannot reduce the frequency anymore, break out early
91 if (policy->cur == policy->min)
94 freq_target = get_freq_target(cs_tuners, policy);
95 if (dbs_info->requested_freq > freq_target)
96 dbs_info->requested_freq -= freq_target;
98 dbs_info->requested_freq = policy->min;
100 __cpufreq_driver_target(policy, dbs_info->requested_freq,
105 return dbs_data->sampling_rate;
108 static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
111 static struct notifier_block cs_cpufreq_notifier_block = {
112 .notifier_call = dbs_cpufreq_notifier,
115 /************************** sysfs interface ************************/
116 static struct dbs_governor cs_dbs_gov;
118 static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data,
119 const char *buf, size_t count)
123 ret = sscanf(buf, "%u", &input);
125 if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1)
128 dbs_data->sampling_down_factor = input;
132 static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf,
135 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
138 ret = sscanf(buf, "%u", &input);
140 if (ret != 1 || input > 100 || input <= cs_tuners->down_threshold)
143 dbs_data->up_threshold = input;
147 static ssize_t store_down_threshold(struct dbs_data *dbs_data, const char *buf,
150 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
153 ret = sscanf(buf, "%u", &input);
155 /* cannot be lower than 11 otherwise freq will not fall */
156 if (ret != 1 || input < 11 || input > 100 ||
157 input >= dbs_data->up_threshold)
160 cs_tuners->down_threshold = input;
164 static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data,
165 const char *buf, size_t count)
167 unsigned int input, j;
170 ret = sscanf(buf, "%u", &input);
177 if (input == dbs_data->ignore_nice_load) /* nothing to do */
180 dbs_data->ignore_nice_load = input;
182 /* we need to re-evaluate prev_cpu_idle */
183 for_each_online_cpu(j) {
184 struct cs_cpu_dbs_info_s *dbs_info;
185 dbs_info = &per_cpu(cs_cpu_dbs_info, j);
186 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j,
187 &dbs_info->cdbs.prev_cpu_wall, 0);
188 if (dbs_data->ignore_nice_load)
189 dbs_info->cdbs.prev_cpu_nice =
190 kcpustat_cpu(j).cpustat[CPUTIME_NICE];
195 static ssize_t store_freq_step(struct dbs_data *dbs_data, const char *buf,
198 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
201 ret = sscanf(buf, "%u", &input);
210 * no need to test here if freq_step is zero as the user might actually
211 * want this, they would be crazy though :)
213 cs_tuners->freq_step = input;
217 gov_show_one_common(sampling_rate);
218 gov_show_one_common(sampling_down_factor);
219 gov_show_one_common(up_threshold);
220 gov_show_one_common(ignore_nice_load);
221 gov_show_one_common(min_sampling_rate);
222 gov_show_one(cs, down_threshold);
223 gov_show_one(cs, freq_step);
225 gov_attr_rw(sampling_rate);
226 gov_attr_rw(sampling_down_factor);
227 gov_attr_rw(up_threshold);
228 gov_attr_rw(ignore_nice_load);
229 gov_attr_ro(min_sampling_rate);
230 gov_attr_rw(down_threshold);
231 gov_attr_rw(freq_step);
233 static struct attribute *cs_attributes[] = {
234 &min_sampling_rate.attr,
236 &sampling_down_factor.attr,
238 &down_threshold.attr,
239 &ignore_nice_load.attr,
244 /************************** sysfs end ************************/
246 static int cs_init(struct dbs_data *dbs_data, bool notify)
248 struct cs_dbs_tuners *tuners;
250 tuners = kzalloc(sizeof(*tuners), GFP_KERNEL);
252 pr_err("%s: kzalloc failed\n", __func__);
256 tuners->down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD;
257 tuners->freq_step = DEF_FREQUENCY_STEP;
258 dbs_data->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
259 dbs_data->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;
260 dbs_data->ignore_nice_load = 0;
262 dbs_data->tuners = tuners;
263 dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
264 jiffies_to_usecs(10);
267 cpufreq_register_notifier(&cs_cpufreq_notifier_block,
268 CPUFREQ_TRANSITION_NOTIFIER);
273 static void cs_exit(struct dbs_data *dbs_data, bool notify)
276 cpufreq_unregister_notifier(&cs_cpufreq_notifier_block,
277 CPUFREQ_TRANSITION_NOTIFIER);
279 kfree(dbs_data->tuners);
282 static void cs_start(struct cpufreq_policy *policy)
284 struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, policy->cpu);
286 dbs_info->down_skip = 0;
287 dbs_info->requested_freq = policy->cur;
290 define_get_cpu_dbs_routines(cs_cpu_dbs_info);
292 static struct dbs_governor cs_dbs_gov = {
294 .name = "conservative",
295 .governor = cpufreq_governor_dbs,
296 .max_transition_latency = TRANSITION_LATENCY_LIMIT,
297 .owner = THIS_MODULE,
299 .kobj_type = { .default_attrs = cs_attributes },
300 .get_cpu_cdbs = get_cpu_cdbs,
301 .gov_dbs_timer = cs_dbs_timer,
307 #define CPU_FREQ_GOV_CONSERVATIVE (&cs_dbs_gov.gov)
309 static int dbs_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
312 struct cpufreq_freqs *freq = data;
313 struct cs_cpu_dbs_info_s *dbs_info =
314 &per_cpu(cs_cpu_dbs_info, freq->cpu);
315 struct cpufreq_policy *policy = cpufreq_cpu_get_raw(freq->cpu);
320 /* policy isn't governed by conservative governor */
321 if (policy->governor != CPU_FREQ_GOV_CONSERVATIVE)
325 * we only care if our internally tracked freq moves outside the 'valid'
326 * ranges of frequency available to us otherwise we do not change it
328 if (dbs_info->requested_freq > policy->max
329 || dbs_info->requested_freq < policy->min)
330 dbs_info->requested_freq = freq->new;
335 static int __init cpufreq_gov_dbs_init(void)
337 return cpufreq_register_governor(CPU_FREQ_GOV_CONSERVATIVE);
340 static void __exit cpufreq_gov_dbs_exit(void)
342 cpufreq_unregister_governor(CPU_FREQ_GOV_CONSERVATIVE);
345 MODULE_AUTHOR("Alexander Clouter <alex@digriz.org.uk>");
346 MODULE_DESCRIPTION("'cpufreq_conservative' - A dynamic cpufreq governor for "
347 "Low Latency Frequency Transition capable processors "
348 "optimised for use in a battery environment");
349 MODULE_LICENSE("GPL");
351 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE
352 struct cpufreq_governor *cpufreq_default_governor(void)
354 return CPU_FREQ_GOV_CONSERVATIVE;
357 fs_initcall(cpufreq_gov_dbs_init);
359 module_init(cpufreq_gov_dbs_init);
361 module_exit(cpufreq_gov_dbs_exit);