diff options
Diffstat (limited to 'drivers/cpufreq/cpufreq_ondemand.c')
-rw-r--r-- | drivers/cpufreq/cpufreq_ondemand.c | 731 |
1 files changed, 229 insertions, 502 deletions
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c index 396322f2a83f..7731f7c7e79a 100644 --- a/drivers/cpufreq/cpufreq_ondemand.c +++ b/drivers/cpufreq/cpufreq_ondemand.c | |||
@@ -10,24 +10,23 @@ | |||
10 | * published by the Free Software Foundation. | 10 | * published by the Free Software Foundation. |
11 | */ | 11 | */ |
12 | 12 | ||
13 | #include <linux/kernel.h> | 13 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
14 | #include <linux/module.h> | 14 | |
15 | #include <linux/init.h> | ||
16 | #include <linux/cpufreq.h> | 15 | #include <linux/cpufreq.h> |
17 | #include <linux/cpu.h> | 16 | #include <linux/init.h> |
18 | #include <linux/jiffies.h> | 17 | #include <linux/kernel.h> |
19 | #include <linux/kernel_stat.h> | 18 | #include <linux/kernel_stat.h> |
19 | #include <linux/kobject.h> | ||
20 | #include <linux/module.h> | ||
20 | #include <linux/mutex.h> | 21 | #include <linux/mutex.h> |
21 | #include <linux/hrtimer.h> | 22 | #include <linux/percpu-defs.h> |
23 | #include <linux/sysfs.h> | ||
22 | #include <linux/tick.h> | 24 | #include <linux/tick.h> |
23 | #include <linux/ktime.h> | 25 | #include <linux/types.h> |
24 | #include <linux/sched.h> | ||
25 | 26 | ||
26 | /* | 27 | #include "cpufreq_governor.h" |
27 | * dbs is used in this file as a shortform for demandbased switching | ||
28 | * It helps to keep variable names smaller, simpler | ||
29 | */ | ||
30 | 28 | ||
29 | /* On-demand governor macors */ | ||
31 | #define DEF_FREQUENCY_DOWN_DIFFERENTIAL (10) | 30 | #define DEF_FREQUENCY_DOWN_DIFFERENTIAL (10) |
32 | #define DEF_FREQUENCY_UP_THRESHOLD (80) | 31 | #define DEF_FREQUENCY_UP_THRESHOLD (80) |
33 | #define DEF_SAMPLING_DOWN_FACTOR (1) | 32 | #define DEF_SAMPLING_DOWN_FACTOR (1) |
@@ -38,80 +37,14 @@ | |||
38 | #define MIN_FREQUENCY_UP_THRESHOLD (11) | 37 | #define MIN_FREQUENCY_UP_THRESHOLD (11) |
39 | #define MAX_FREQUENCY_UP_THRESHOLD (100) | 38 | #define MAX_FREQUENCY_UP_THRESHOLD (100) |
40 | 39 | ||
41 | /* | 40 | static struct dbs_data od_dbs_data; |
42 | * The polling frequency of this governor depends on the capability of | 41 | static DEFINE_PER_CPU(struct od_cpu_dbs_info_s, od_cpu_dbs_info); |
43 | * the processor. Default polling frequency is 1000 times the transition | ||
44 | * latency of the processor. The governor will work on any processor with | ||
45 | * transition latency <= 10mS, using appropriate sampling | ||
46 | * rate. | ||
47 | * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL) | ||
48 | * this governor will not work. | ||
49 | * All times here are in uS. | ||
50 | */ | ||
51 | #define MIN_SAMPLING_RATE_RATIO (2) | ||
52 | |||
53 | static unsigned int min_sampling_rate; | ||
54 | |||
55 | #define LATENCY_MULTIPLIER (1000) | ||
56 | #define MIN_LATENCY_MULTIPLIER (100) | ||
57 | #define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000) | ||
58 | |||
59 | static void do_dbs_timer(struct work_struct *work); | ||
60 | static int cpufreq_governor_dbs(struct cpufreq_policy *policy, | ||
61 | unsigned int event); | ||
62 | 42 | ||
63 | #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND | 43 | #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND |
64 | static | 44 | static struct cpufreq_governor cpufreq_gov_ondemand; |
65 | #endif | 45 | #endif |
66 | struct cpufreq_governor cpufreq_gov_ondemand = { | ||
67 | .name = "ondemand", | ||
68 | .governor = cpufreq_governor_dbs, | ||
69 | .max_transition_latency = TRANSITION_LATENCY_LIMIT, | ||
70 | .owner = THIS_MODULE, | ||
71 | }; | ||
72 | 46 | ||
73 | /* Sampling types */ | 47 | static struct od_dbs_tuners od_tuners = { |
74 | enum {DBS_NORMAL_SAMPLE, DBS_SUB_SAMPLE}; | ||
75 | |||
76 | struct cpu_dbs_info_s { | ||
77 | cputime64_t prev_cpu_idle; | ||
78 | cputime64_t prev_cpu_iowait; | ||
79 | cputime64_t prev_cpu_wall; | ||
80 | cputime64_t prev_cpu_nice; | ||
81 | struct cpufreq_policy *cur_policy; | ||
82 | struct delayed_work work; | ||
83 | struct cpufreq_frequency_table *freq_table; | ||
84 | unsigned int freq_lo; | ||
85 | unsigned int freq_lo_jiffies; | ||
86 | unsigned int freq_hi_jiffies; | ||
87 | unsigned int rate_mult; | ||
88 | int cpu; | ||
89 | unsigned int sample_type:1; | ||
90 | /* | ||
91 | * percpu mutex that serializes governor limit change with | ||
92 | * do_dbs_timer invocation. We do not want do_dbs_timer to run | ||
93 | * when user is changing the governor or limits. | ||
94 | */ | ||
95 | struct mutex timer_mutex; | ||
96 | }; | ||
97 | static DEFINE_PER_CPU(struct cpu_dbs_info_s, od_cpu_dbs_info); | ||
98 | |||
99 | static unsigned int dbs_enable; /* number of CPUs using this policy */ | ||
100 | |||
101 | /* | ||
102 | * dbs_mutex protects dbs_enable in governor start/stop. | ||
103 | */ | ||
104 | static DEFINE_MUTEX(dbs_mutex); | ||
105 | |||
106 | static struct dbs_tuners { | ||
107 | unsigned int sampling_rate; | ||
108 | unsigned int up_threshold; | ||
109 | unsigned int down_differential; | ||
110 | unsigned int ignore_nice; | ||
111 | unsigned int sampling_down_factor; | ||
112 | unsigned int powersave_bias; | ||
113 | unsigned int io_is_busy; | ||
114 | } dbs_tuners_ins = { | ||
115 | .up_threshold = DEF_FREQUENCY_UP_THRESHOLD, | 48 | .up_threshold = DEF_FREQUENCY_UP_THRESHOLD, |
116 | .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR, | 49 | .sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR, |
117 | .down_differential = DEF_FREQUENCY_DOWN_DIFFERENTIAL, | 50 | .down_differential = DEF_FREQUENCY_DOWN_DIFFERENTIAL, |
@@ -119,48 +52,35 @@ static struct dbs_tuners { | |||
119 | .powersave_bias = 0, | 52 | .powersave_bias = 0, |
120 | }; | 53 | }; |
121 | 54 | ||
122 | static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall) | 55 | static void ondemand_powersave_bias_init_cpu(int cpu) |
123 | { | ||
124 | u64 idle_time; | ||
125 | u64 cur_wall_time; | ||
126 | u64 busy_time; | ||
127 | |||
128 | cur_wall_time = jiffies64_to_cputime64(get_jiffies_64()); | ||
129 | |||
130 | busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER]; | ||
131 | busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM]; | ||
132 | busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ]; | ||
133 | busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ]; | ||
134 | busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL]; | ||
135 | busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE]; | ||
136 | |||
137 | idle_time = cur_wall_time - busy_time; | ||
138 | if (wall) | ||
139 | *wall = jiffies_to_usecs(cur_wall_time); | ||
140 | |||
141 | return jiffies_to_usecs(idle_time); | ||
142 | } | ||
143 | |||
144 | static inline cputime64_t get_cpu_idle_time(unsigned int cpu, cputime64_t *wall) | ||
145 | { | 56 | { |
146 | u64 idle_time = get_cpu_idle_time_us(cpu, NULL); | 57 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu); |
147 | |||
148 | if (idle_time == -1ULL) | ||
149 | return get_cpu_idle_time_jiffy(cpu, wall); | ||
150 | else | ||
151 | idle_time += get_cpu_iowait_time_us(cpu, wall); | ||
152 | 58 | ||
153 | return idle_time; | 59 | dbs_info->freq_table = cpufreq_frequency_get_table(cpu); |
60 | dbs_info->freq_lo = 0; | ||
154 | } | 61 | } |
155 | 62 | ||
156 | static inline cputime64_t get_cpu_iowait_time(unsigned int cpu, cputime64_t *wall) | 63 | /* |
64 | * Not all CPUs want IO time to be accounted as busy; this depends on how | ||
65 | * efficient idling at a higher frequency/voltage is. | ||
66 | * Pavel Machek says this is not so for various generations of AMD and old | ||
67 | * Intel systems. | ||
68 | * Mike Chan (androidlcom) calis this is also not true for ARM. | ||
69 | * Because of this, whitelist specific known (series) of CPUs by default, and | ||
70 | * leave all others up to the user. | ||
71 | */ | ||
72 | static int should_io_be_busy(void) | ||
157 | { | 73 | { |
158 | u64 iowait_time = get_cpu_iowait_time_us(cpu, wall); | 74 | #if defined(CONFIG_X86) |
159 | 75 | /* | |
160 | if (iowait_time == -1ULL) | 76 | * For Intel, Core 2 (model 15) andl later have an efficient idle. |
161 | return 0; | 77 | */ |
162 | 78 | if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL && | |
163 | return iowait_time; | 79 | boot_cpu_data.x86 == 6 && |
80 | boot_cpu_data.x86_model >= 15) | ||
81 | return 1; | ||
82 | #endif | ||
83 | return 0; | ||
164 | } | 84 | } |
165 | 85 | ||
166 | /* | 86 | /* |
@@ -169,14 +89,13 @@ static inline cputime64_t get_cpu_iowait_time(unsigned int cpu, cputime64_t *wal | |||
169 | * freq_lo, and freq_lo_jiffies in percpu area for averaging freqs. | 89 | * freq_lo, and freq_lo_jiffies in percpu area for averaging freqs. |
170 | */ | 90 | */ |
171 | static unsigned int powersave_bias_target(struct cpufreq_policy *policy, | 91 | static unsigned int powersave_bias_target(struct cpufreq_policy *policy, |
172 | unsigned int freq_next, | 92 | unsigned int freq_next, unsigned int relation) |
173 | unsigned int relation) | ||
174 | { | 93 | { |
175 | unsigned int freq_req, freq_reduc, freq_avg; | 94 | unsigned int freq_req, freq_reduc, freq_avg; |
176 | unsigned int freq_hi, freq_lo; | 95 | unsigned int freq_hi, freq_lo; |
177 | unsigned int index = 0; | 96 | unsigned int index = 0; |
178 | unsigned int jiffies_total, jiffies_hi, jiffies_lo; | 97 | unsigned int jiffies_total, jiffies_hi, jiffies_lo; |
179 | struct cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, | 98 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, |
180 | policy->cpu); | 99 | policy->cpu); |
181 | 100 | ||
182 | if (!dbs_info->freq_table) { | 101 | if (!dbs_info->freq_table) { |
@@ -188,7 +107,7 @@ static unsigned int powersave_bias_target(struct cpufreq_policy *policy, | |||
188 | cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next, | 107 | cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next, |
189 | relation, &index); | 108 | relation, &index); |
190 | freq_req = dbs_info->freq_table[index].frequency; | 109 | freq_req = dbs_info->freq_table[index].frequency; |
191 | freq_reduc = freq_req * dbs_tuners_ins.powersave_bias / 1000; | 110 | freq_reduc = freq_req * od_tuners.powersave_bias / 1000; |
192 | freq_avg = freq_req - freq_reduc; | 111 | freq_avg = freq_req - freq_reduc; |
193 | 112 | ||
194 | /* Find freq bounds for freq_avg in freq_table */ | 113 | /* Find freq bounds for freq_avg in freq_table */ |
@@ -207,7 +126,7 @@ static unsigned int powersave_bias_target(struct cpufreq_policy *policy, | |||
207 | dbs_info->freq_lo_jiffies = 0; | 126 | dbs_info->freq_lo_jiffies = 0; |
208 | return freq_lo; | 127 | return freq_lo; |
209 | } | 128 | } |
210 | jiffies_total = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); | 129 | jiffies_total = usecs_to_jiffies(od_tuners.sampling_rate); |
211 | jiffies_hi = (freq_avg - freq_lo) * jiffies_total; | 130 | jiffies_hi = (freq_avg - freq_lo) * jiffies_total; |
212 | jiffies_hi += ((freq_hi - freq_lo) / 2); | 131 | jiffies_hi += ((freq_hi - freq_lo) / 2); |
213 | jiffies_hi /= (freq_hi - freq_lo); | 132 | jiffies_hi /= (freq_hi - freq_lo); |
@@ -218,13 +137,6 @@ static unsigned int powersave_bias_target(struct cpufreq_policy *policy, | |||
218 | return freq_hi; | 137 | return freq_hi; |
219 | } | 138 | } |
220 | 139 | ||
221 | static void ondemand_powersave_bias_init_cpu(int cpu) | ||
222 | { | ||
223 | struct cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu); | ||
224 | dbs_info->freq_table = cpufreq_frequency_get_table(cpu); | ||
225 | dbs_info->freq_lo = 0; | ||
226 | } | ||
227 | |||
228 | static void ondemand_powersave_bias_init(void) | 140 | static void ondemand_powersave_bias_init(void) |
229 | { | 141 | { |
230 | int i; | 142 | int i; |
@@ -233,83 +145,173 @@ static void ondemand_powersave_bias_init(void) | |||
233 | } | 145 | } |
234 | } | 146 | } |
235 | 147 | ||
236 | /************************** sysfs interface ************************/ | 148 | static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq) |
149 | { | ||
150 | if (od_tuners.powersave_bias) | ||
151 | freq = powersave_bias_target(p, freq, CPUFREQ_RELATION_H); | ||
152 | else if (p->cur == p->max) | ||
153 | return; | ||
237 | 154 | ||
238 | static ssize_t show_sampling_rate_min(struct kobject *kobj, | 155 | __cpufreq_driver_target(p, freq, od_tuners.powersave_bias ? |
239 | struct attribute *attr, char *buf) | 156 | CPUFREQ_RELATION_L : CPUFREQ_RELATION_H); |
157 | } | ||
158 | |||
159 | /* | ||
160 | * Every sampling_rate, we check, if current idle time is less than 20% | ||
161 | * (default), then we try to increase frequency Every sampling_rate, we look for | ||
162 | * a the lowest frequency which can sustain the load while keeping idle time | ||
163 | * over 30%. If such a frequency exist, we try to decrease to this frequency. | ||
164 | * | ||
165 | * Any frequency increase takes it to the maximum frequency. Frequency reduction | ||
166 | * happens at minimum steps of 5% (default) of current frequency | ||
167 | */ | ||
168 | static void od_check_cpu(int cpu, unsigned int load_freq) | ||
240 | { | 169 | { |
241 | return sprintf(buf, "%u\n", min_sampling_rate); | 170 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu); |
171 | struct cpufreq_policy *policy = dbs_info->cdbs.cur_policy; | ||
172 | |||
173 | dbs_info->freq_lo = 0; | ||
174 | |||
175 | /* Check for frequency increase */ | ||
176 | if (load_freq > od_tuners.up_threshold * policy->cur) { | ||
177 | /* If switching to max speed, apply sampling_down_factor */ | ||
178 | if (policy->cur < policy->max) | ||
179 | dbs_info->rate_mult = | ||
180 | od_tuners.sampling_down_factor; | ||
181 | dbs_freq_increase(policy, policy->max); | ||
182 | return; | ||
183 | } | ||
184 | |||
185 | /* Check for frequency decrease */ | ||
186 | /* if we cannot reduce the frequency anymore, break out early */ | ||
187 | if (policy->cur == policy->min) | ||
188 | return; | ||
189 | |||
190 | /* | ||
191 | * The optimal frequency is the frequency that is the lowest that can | ||
192 | * support the current CPU usage without triggering the up policy. To be | ||
193 | * safe, we focus 10 points under the threshold. | ||
194 | */ | ||
195 | if (load_freq < (od_tuners.up_threshold - od_tuners.down_differential) * | ||
196 | policy->cur) { | ||
197 | unsigned int freq_next; | ||
198 | freq_next = load_freq / (od_tuners.up_threshold - | ||
199 | od_tuners.down_differential); | ||
200 | |||
201 | /* No longer fully busy, reset rate_mult */ | ||
202 | dbs_info->rate_mult = 1; | ||
203 | |||
204 | if (freq_next < policy->min) | ||
205 | freq_next = policy->min; | ||
206 | |||
207 | if (!od_tuners.powersave_bias) { | ||
208 | __cpufreq_driver_target(policy, freq_next, | ||
209 | CPUFREQ_RELATION_L); | ||
210 | } else { | ||
211 | int freq = powersave_bias_target(policy, freq_next, | ||
212 | CPUFREQ_RELATION_L); | ||
213 | __cpufreq_driver_target(policy, freq, | ||
214 | CPUFREQ_RELATION_L); | ||
215 | } | ||
216 | } | ||
242 | } | 217 | } |
243 | 218 | ||
244 | define_one_global_ro(sampling_rate_min); | 219 | static void od_dbs_timer(struct work_struct *work) |
220 | { | ||
221 | struct od_cpu_dbs_info_s *dbs_info = | ||
222 | container_of(work, struct od_cpu_dbs_info_s, cdbs.work.work); | ||
223 | unsigned int cpu = dbs_info->cdbs.cpu; | ||
224 | int delay, sample_type = dbs_info->sample_type; | ||
225 | |||
226 | mutex_lock(&dbs_info->cdbs.timer_mutex); | ||
227 | |||
228 | /* Common NORMAL_SAMPLE setup */ | ||
229 | dbs_info->sample_type = OD_NORMAL_SAMPLE; | ||
230 | if (sample_type == OD_SUB_SAMPLE) { | ||
231 | delay = dbs_info->freq_lo_jiffies; | ||
232 | __cpufreq_driver_target(dbs_info->cdbs.cur_policy, | ||
233 | dbs_info->freq_lo, CPUFREQ_RELATION_H); | ||
234 | } else { | ||
235 | dbs_check_cpu(&od_dbs_data, cpu); | ||
236 | if (dbs_info->freq_lo) { | ||
237 | /* Setup timer for SUB_SAMPLE */ | ||
238 | dbs_info->sample_type = OD_SUB_SAMPLE; | ||
239 | delay = dbs_info->freq_hi_jiffies; | ||
240 | } else { | ||
241 | delay = delay_for_sampling_rate(od_tuners.sampling_rate | ||
242 | * dbs_info->rate_mult); | ||
243 | } | ||
244 | } | ||
245 | |||
246 | schedule_delayed_work_on(cpu, &dbs_info->cdbs.work, delay); | ||
247 | mutex_unlock(&dbs_info->cdbs.timer_mutex); | ||
248 | } | ||
249 | |||
250 | /************************** sysfs interface ************************/ | ||
245 | 251 | ||
246 | /* cpufreq_ondemand Governor Tunables */ | 252 | static ssize_t show_sampling_rate_min(struct kobject *kobj, |
247 | #define show_one(file_name, object) \ | 253 | struct attribute *attr, char *buf) |
248 | static ssize_t show_##file_name \ | 254 | { |
249 | (struct kobject *kobj, struct attribute *attr, char *buf) \ | 255 | return sprintf(buf, "%u\n", od_dbs_data.min_sampling_rate); |
250 | { \ | ||
251 | return sprintf(buf, "%u\n", dbs_tuners_ins.object); \ | ||
252 | } | 256 | } |
253 | show_one(sampling_rate, sampling_rate); | ||
254 | show_one(io_is_busy, io_is_busy); | ||
255 | show_one(up_threshold, up_threshold); | ||
256 | show_one(sampling_down_factor, sampling_down_factor); | ||
257 | show_one(ignore_nice_load, ignore_nice); | ||
258 | show_one(powersave_bias, powersave_bias); | ||
259 | 257 | ||
260 | /** | 258 | /** |
261 | * update_sampling_rate - update sampling rate effective immediately if needed. | 259 | * update_sampling_rate - update sampling rate effective immediately if needed. |
262 | * @new_rate: new sampling rate | 260 | * @new_rate: new sampling rate |
263 | * | 261 | * |
264 | * If new rate is smaller than the old, simply updaing | 262 | * If new rate is smaller than the old, simply updaing |
265 | * dbs_tuners_int.sampling_rate might not be appropriate. For example, | 263 | * dbs_tuners_int.sampling_rate might not be appropriate. For example, if the |
266 | * if the original sampling_rate was 1 second and the requested new sampling | 264 | * original sampling_rate was 1 second and the requested new sampling rate is 10 |
267 | * rate is 10 ms because the user needs immediate reaction from ondemand | 265 | * ms because the user needs immediate reaction from ondemand governor, but not |
268 | * governor, but not sure if higher frequency will be required or not, | 266 | * sure if higher frequency will be required or not, then, the governor may |
269 | * then, the governor may change the sampling rate too late; up to 1 second | 267 | * change the sampling rate too late; up to 1 second later. Thus, if we are |
270 | * later. Thus, if we are reducing the sampling rate, we need to make the | 268 | * reducing the sampling rate, we need to make the new value effective |
271 | * new value effective immediately. | 269 | * immediately. |
272 | */ | 270 | */ |
273 | static void update_sampling_rate(unsigned int new_rate) | 271 | static void update_sampling_rate(unsigned int new_rate) |
274 | { | 272 | { |
275 | int cpu; | 273 | int cpu; |
276 | 274 | ||
277 | dbs_tuners_ins.sampling_rate = new_rate | 275 | od_tuners.sampling_rate = new_rate = max(new_rate, |
278 | = max(new_rate, min_sampling_rate); | 276 | od_dbs_data.min_sampling_rate); |
279 | 277 | ||
280 | for_each_online_cpu(cpu) { | 278 | for_each_online_cpu(cpu) { |
281 | struct cpufreq_policy *policy; | 279 | struct cpufreq_policy *policy; |
282 | struct cpu_dbs_info_s *dbs_info; | 280 | struct od_cpu_dbs_info_s *dbs_info; |
283 | unsigned long next_sampling, appointed_at; | 281 | unsigned long next_sampling, appointed_at; |
284 | 282 | ||
285 | policy = cpufreq_cpu_get(cpu); | 283 | policy = cpufreq_cpu_get(cpu); |
286 | if (!policy) | 284 | if (!policy) |
287 | continue; | 285 | continue; |
286 | if (policy->governor != &cpufreq_gov_ondemand) { | ||
287 | cpufreq_cpu_put(policy); | ||
288 | continue; | ||
289 | } | ||
288 | dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu); | 290 | dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu); |
289 | cpufreq_cpu_put(policy); | 291 | cpufreq_cpu_put(policy); |
290 | 292 | ||
291 | mutex_lock(&dbs_info->timer_mutex); | 293 | mutex_lock(&dbs_info->cdbs.timer_mutex); |
292 | 294 | ||
293 | if (!delayed_work_pending(&dbs_info->work)) { | 295 | if (!delayed_work_pending(&dbs_info->cdbs.work)) { |
294 | mutex_unlock(&dbs_info->timer_mutex); | 296 | mutex_unlock(&dbs_info->cdbs.timer_mutex); |
295 | continue; | 297 | continue; |
296 | } | 298 | } |
297 | 299 | ||
298 | next_sampling = jiffies + usecs_to_jiffies(new_rate); | 300 | next_sampling = jiffies + usecs_to_jiffies(new_rate); |
299 | appointed_at = dbs_info->work.timer.expires; | 301 | appointed_at = dbs_info->cdbs.work.timer.expires; |
300 | |||
301 | 302 | ||
302 | if (time_before(next_sampling, appointed_at)) { | 303 | if (time_before(next_sampling, appointed_at)) { |
303 | 304 | ||
304 | mutex_unlock(&dbs_info->timer_mutex); | 305 | mutex_unlock(&dbs_info->cdbs.timer_mutex); |
305 | cancel_delayed_work_sync(&dbs_info->work); | 306 | cancel_delayed_work_sync(&dbs_info->cdbs.work); |
306 | mutex_lock(&dbs_info->timer_mutex); | 307 | mutex_lock(&dbs_info->cdbs.timer_mutex); |
307 | 308 | ||
308 | schedule_delayed_work_on(dbs_info->cpu, &dbs_info->work, | 309 | schedule_delayed_work_on(dbs_info->cdbs.cpu, |
309 | usecs_to_jiffies(new_rate)); | 310 | &dbs_info->cdbs.work, |
311 | usecs_to_jiffies(new_rate)); | ||
310 | 312 | ||
311 | } | 313 | } |
312 | mutex_unlock(&dbs_info->timer_mutex); | 314 | mutex_unlock(&dbs_info->cdbs.timer_mutex); |
313 | } | 315 | } |
314 | } | 316 | } |
315 | 317 | ||
@@ -334,7 +336,7 @@ static ssize_t store_io_is_busy(struct kobject *a, struct attribute *b, | |||
334 | ret = sscanf(buf, "%u", &input); | 336 | ret = sscanf(buf, "%u", &input); |
335 | if (ret != 1) | 337 | if (ret != 1) |
336 | return -EINVAL; | 338 | return -EINVAL; |
337 | dbs_tuners_ins.io_is_busy = !!input; | 339 | od_tuners.io_is_busy = !!input; |
338 | return count; | 340 | return count; |
339 | } | 341 | } |
340 | 342 | ||
@@ -349,7 +351,7 @@ static ssize_t store_up_threshold(struct kobject *a, struct attribute *b, | |||
349 | input < MIN_FREQUENCY_UP_THRESHOLD) { | 351 | input < MIN_FREQUENCY_UP_THRESHOLD) { |
350 | return -EINVAL; | 352 | return -EINVAL; |
351 | } | 353 | } |
352 | dbs_tuners_ins.up_threshold = input; | 354 | od_tuners.up_threshold = input; |
353 | return count; | 355 | return count; |
354 | } | 356 | } |
355 | 357 | ||
@@ -362,12 +364,12 @@ static ssize_t store_sampling_down_factor(struct kobject *a, | |||
362 | 364 | ||
363 | if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) | 365 | if (ret != 1 || input > MAX_SAMPLING_DOWN_FACTOR || input < 1) |
364 | return -EINVAL; | 366 | return -EINVAL; |
365 | dbs_tuners_ins.sampling_down_factor = input; | 367 | od_tuners.sampling_down_factor = input; |
366 | 368 | ||
367 | /* Reset down sampling multiplier in case it was active */ | 369 | /* Reset down sampling multiplier in case it was active */ |
368 | for_each_online_cpu(j) { | 370 | for_each_online_cpu(j) { |
369 | struct cpu_dbs_info_s *dbs_info; | 371 | struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, |
370 | dbs_info = &per_cpu(od_cpu_dbs_info, j); | 372 | j); |
371 | dbs_info->rate_mult = 1; | 373 | dbs_info->rate_mult = 1; |
372 | } | 374 | } |
373 | return count; | 375 | return count; |
@@ -388,19 +390,20 @@ static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b, | |||
388 | if (input > 1) | 390 | if (input > 1) |
389 | input = 1; | 391 | input = 1; |
390 | 392 | ||
391 | if (input == dbs_tuners_ins.ignore_nice) { /* nothing to do */ | 393 | if (input == od_tuners.ignore_nice) { /* nothing to do */ |
392 | return count; | 394 | return count; |
393 | } | 395 | } |
394 | dbs_tuners_ins.ignore_nice = input; | 396 | od_tuners.ignore_nice = input; |
395 | 397 | ||
396 | /* we need to re-evaluate prev_cpu_idle */ | 398 | /* we need to re-evaluate prev_cpu_idle */ |
397 | for_each_online_cpu(j) { | 399 | for_each_online_cpu(j) { |
398 | struct cpu_dbs_info_s *dbs_info; | 400 | struct od_cpu_dbs_info_s *dbs_info; |
399 | dbs_info = &per_cpu(od_cpu_dbs_info, j); | 401 | dbs_info = &per_cpu(od_cpu_dbs_info, j); |
400 | dbs_info->prev_cpu_idle = get_cpu_idle_time(j, | 402 | dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, |
401 | &dbs_info->prev_cpu_wall); | 403 | &dbs_info->cdbs.prev_cpu_wall); |
402 | if (dbs_tuners_ins.ignore_nice) | 404 | if (od_tuners.ignore_nice) |
403 | dbs_info->prev_cpu_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE]; | 405 | dbs_info->cdbs.prev_cpu_nice = |
406 | kcpustat_cpu(j).cpustat[CPUTIME_NICE]; | ||
404 | 407 | ||
405 | } | 408 | } |
406 | return count; | 409 | return count; |
@@ -419,17 +422,25 @@ static ssize_t store_powersave_bias(struct kobject *a, struct attribute *b, | |||
419 | if (input > 1000) | 422 | if (input > 1000) |
420 | input = 1000; | 423 | input = 1000; |
421 | 424 | ||
422 | dbs_tuners_ins.powersave_bias = input; | 425 | od_tuners.powersave_bias = input; |
423 | ondemand_powersave_bias_init(); | 426 | ondemand_powersave_bias_init(); |
424 | return count; | 427 | return count; |
425 | } | 428 | } |
426 | 429 | ||
430 | show_one(od, sampling_rate, sampling_rate); | ||
431 | show_one(od, io_is_busy, io_is_busy); | ||
432 | show_one(od, up_threshold, up_threshold); | ||
433 | show_one(od, sampling_down_factor, sampling_down_factor); | ||
434 | show_one(od, ignore_nice_load, ignore_nice); | ||
435 | show_one(od, powersave_bias, powersave_bias); | ||
436 | |||
427 | define_one_global_rw(sampling_rate); | 437 | define_one_global_rw(sampling_rate); |
428 | define_one_global_rw(io_is_busy); | 438 | define_one_global_rw(io_is_busy); |
429 | define_one_global_rw(up_threshold); | 439 | define_one_global_rw(up_threshold); |
430 | define_one_global_rw(sampling_down_factor); | 440 | define_one_global_rw(sampling_down_factor); |
431 | define_one_global_rw(ignore_nice_load); | 441 | define_one_global_rw(ignore_nice_load); |
432 | define_one_global_rw(powersave_bias); | 442 | define_one_global_rw(powersave_bias); |
443 | define_one_global_ro(sampling_rate_min); | ||
433 | 444 | ||
434 | static struct attribute *dbs_attributes[] = { | 445 | static struct attribute *dbs_attributes[] = { |
435 | &sampling_rate_min.attr, | 446 | &sampling_rate_min.attr, |
@@ -442,354 +453,71 @@ static struct attribute *dbs_attributes[] = { | |||
442 | NULL | 453 | NULL |
443 | }; | 454 | }; |
444 | 455 | ||
445 | static struct attribute_group dbs_attr_group = { | 456 | static struct attribute_group od_attr_group = { |
446 | .attrs = dbs_attributes, | 457 | .attrs = dbs_attributes, |
447 | .name = "ondemand", | 458 | .name = "ondemand", |
448 | }; | 459 | }; |
449 | 460 | ||
450 | /************************** sysfs end ************************/ | 461 | /************************** sysfs end ************************/ |
451 | 462 | ||
452 | static void dbs_freq_increase(struct cpufreq_policy *p, unsigned int freq) | 463 | define_get_cpu_dbs_routines(od_cpu_dbs_info); |
453 | { | ||
454 | if (dbs_tuners_ins.powersave_bias) | ||
455 | freq = powersave_bias_target(p, freq, CPUFREQ_RELATION_H); | ||
456 | else if (p->cur == p->max) | ||
457 | return; | ||
458 | |||
459 | __cpufreq_driver_target(p, freq, dbs_tuners_ins.powersave_bias ? | ||
460 | CPUFREQ_RELATION_L : CPUFREQ_RELATION_H); | ||
461 | } | ||
462 | |||
463 | static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info) | ||
464 | { | ||
465 | unsigned int max_load_freq; | ||
466 | |||
467 | struct cpufreq_policy *policy; | ||
468 | unsigned int j; | ||
469 | |||
470 | this_dbs_info->freq_lo = 0; | ||
471 | policy = this_dbs_info->cur_policy; | ||
472 | |||
473 | /* | ||
474 | * Every sampling_rate, we check, if current idle time is less | ||
475 | * than 20% (default), then we try to increase frequency | ||
476 | * Every sampling_rate, we look for a the lowest | ||
477 | * frequency which can sustain the load while keeping idle time over | ||
478 | * 30%. If such a frequency exist, we try to decrease to this frequency. | ||
479 | * | ||
480 | * Any frequency increase takes it to the maximum frequency. | ||
481 | * Frequency reduction happens at minimum steps of | ||
482 | * 5% (default) of current frequency | ||
483 | */ | ||
484 | |||
485 | /* Get Absolute Load - in terms of freq */ | ||
486 | max_load_freq = 0; | ||
487 | |||
488 | for_each_cpu(j, policy->cpus) { | ||
489 | struct cpu_dbs_info_s *j_dbs_info; | ||
490 | cputime64_t cur_wall_time, cur_idle_time, cur_iowait_time; | ||
491 | unsigned int idle_time, wall_time, iowait_time; | ||
492 | unsigned int load, load_freq; | ||
493 | int freq_avg; | ||
494 | |||
495 | j_dbs_info = &per_cpu(od_cpu_dbs_info, j); | ||
496 | |||
497 | cur_idle_time = get_cpu_idle_time(j, &cur_wall_time); | ||
498 | cur_iowait_time = get_cpu_iowait_time(j, &cur_wall_time); | ||
499 | |||
500 | wall_time = (unsigned int) | ||
501 | (cur_wall_time - j_dbs_info->prev_cpu_wall); | ||
502 | j_dbs_info->prev_cpu_wall = cur_wall_time; | ||
503 | |||
504 | idle_time = (unsigned int) | ||
505 | (cur_idle_time - j_dbs_info->prev_cpu_idle); | ||
506 | j_dbs_info->prev_cpu_idle = cur_idle_time; | ||
507 | |||
508 | iowait_time = (unsigned int) | ||
509 | (cur_iowait_time - j_dbs_info->prev_cpu_iowait); | ||
510 | j_dbs_info->prev_cpu_iowait = cur_iowait_time; | ||
511 | |||
512 | if (dbs_tuners_ins.ignore_nice) { | ||
513 | u64 cur_nice; | ||
514 | unsigned long cur_nice_jiffies; | ||
515 | |||
516 | cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE] - | ||
517 | j_dbs_info->prev_cpu_nice; | ||
518 | /* | ||
519 | * Assumption: nice time between sampling periods will | ||
520 | * be less than 2^32 jiffies for 32 bit sys | ||
521 | */ | ||
522 | cur_nice_jiffies = (unsigned long) | ||
523 | cputime64_to_jiffies64(cur_nice); | ||
524 | |||
525 | j_dbs_info->prev_cpu_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE]; | ||
526 | idle_time += jiffies_to_usecs(cur_nice_jiffies); | ||
527 | } | ||
528 | |||
529 | /* | ||
530 | * For the purpose of ondemand, waiting for disk IO is an | ||
531 | * indication that you're performance critical, and not that | ||
532 | * the system is actually idle. So subtract the iowait time | ||
533 | * from the cpu idle time. | ||
534 | */ | ||
535 | |||
536 | if (dbs_tuners_ins.io_is_busy && idle_time >= iowait_time) | ||
537 | idle_time -= iowait_time; | ||
538 | |||
539 | if (unlikely(!wall_time || wall_time < idle_time)) | ||
540 | continue; | ||
541 | |||
542 | load = 100 * (wall_time - idle_time) / wall_time; | ||
543 | |||
544 | freq_avg = __cpufreq_driver_getavg(policy, j); | ||
545 | if (freq_avg <= 0) | ||
546 | freq_avg = policy->cur; | ||
547 | |||
548 | load_freq = load * freq_avg; | ||
549 | if (load_freq > max_load_freq) | ||
550 | max_load_freq = load_freq; | ||
551 | } | ||
552 | 464 | ||
553 | /* Check for frequency increase */ | 465 | static struct od_ops od_ops = { |
554 | if (max_load_freq > dbs_tuners_ins.up_threshold * policy->cur) { | 466 | .io_busy = should_io_be_busy, |
555 | /* If switching to max speed, apply sampling_down_factor */ | 467 | .powersave_bias_init_cpu = ondemand_powersave_bias_init_cpu, |
556 | if (policy->cur < policy->max) | 468 | .powersave_bias_target = powersave_bias_target, |
557 | this_dbs_info->rate_mult = | 469 | .freq_increase = dbs_freq_increase, |
558 | dbs_tuners_ins.sampling_down_factor; | 470 | }; |
559 | dbs_freq_increase(policy, policy->max); | ||
560 | return; | ||
561 | } | ||
562 | |||
563 | /* Check for frequency decrease */ | ||
564 | /* if we cannot reduce the frequency anymore, break out early */ | ||
565 | if (policy->cur == policy->min) | ||
566 | return; | ||
567 | |||
568 | /* | ||
569 | * The optimal frequency is the frequency that is the lowest that | ||
570 | * can support the current CPU usage without triggering the up | ||
571 | * policy. To be safe, we focus 10 points under the threshold. | ||
572 | */ | ||
573 | if (max_load_freq < | ||
574 | (dbs_tuners_ins.up_threshold - dbs_tuners_ins.down_differential) * | ||
575 | policy->cur) { | ||
576 | unsigned int freq_next; | ||
577 | freq_next = max_load_freq / | ||
578 | (dbs_tuners_ins.up_threshold - | ||
579 | dbs_tuners_ins.down_differential); | ||
580 | |||
581 | /* No longer fully busy, reset rate_mult */ | ||
582 | this_dbs_info->rate_mult = 1; | ||
583 | |||
584 | if (freq_next < policy->min) | ||
585 | freq_next = policy->min; | ||
586 | |||
587 | if (!dbs_tuners_ins.powersave_bias) { | ||
588 | __cpufreq_driver_target(policy, freq_next, | ||
589 | CPUFREQ_RELATION_L); | ||
590 | } else { | ||
591 | int freq = powersave_bias_target(policy, freq_next, | ||
592 | CPUFREQ_RELATION_L); | ||
593 | __cpufreq_driver_target(policy, freq, | ||
594 | CPUFREQ_RELATION_L); | ||
595 | } | ||
596 | } | ||
597 | } | ||
598 | |||
599 | static void do_dbs_timer(struct work_struct *work) | ||
600 | { | ||
601 | struct cpu_dbs_info_s *dbs_info = | ||
602 | container_of(work, struct cpu_dbs_info_s, work.work); | ||
603 | unsigned int cpu = dbs_info->cpu; | ||
604 | int sample_type = dbs_info->sample_type; | ||
605 | |||
606 | int delay; | ||
607 | |||
608 | mutex_lock(&dbs_info->timer_mutex); | ||
609 | |||
610 | /* Common NORMAL_SAMPLE setup */ | ||
611 | dbs_info->sample_type = DBS_NORMAL_SAMPLE; | ||
612 | if (!dbs_tuners_ins.powersave_bias || | ||
613 | sample_type == DBS_NORMAL_SAMPLE) { | ||
614 | dbs_check_cpu(dbs_info); | ||
615 | if (dbs_info->freq_lo) { | ||
616 | /* Setup timer for SUB_SAMPLE */ | ||
617 | dbs_info->sample_type = DBS_SUB_SAMPLE; | ||
618 | delay = dbs_info->freq_hi_jiffies; | ||
619 | } else { | ||
620 | /* We want all CPUs to do sampling nearly on | ||
621 | * same jiffy | ||
622 | */ | ||
623 | delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate | ||
624 | * dbs_info->rate_mult); | ||
625 | |||
626 | if (num_online_cpus() > 1) | ||
627 | delay -= jiffies % delay; | ||
628 | } | ||
629 | } else { | ||
630 | __cpufreq_driver_target(dbs_info->cur_policy, | ||
631 | dbs_info->freq_lo, CPUFREQ_RELATION_H); | ||
632 | delay = dbs_info->freq_lo_jiffies; | ||
633 | } | ||
634 | schedule_delayed_work_on(cpu, &dbs_info->work, delay); | ||
635 | mutex_unlock(&dbs_info->timer_mutex); | ||
636 | } | ||
637 | |||
638 | static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) | ||
639 | { | ||
640 | /* We want all CPUs to do sampling nearly on same jiffy */ | ||
641 | int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); | ||
642 | |||
643 | if (num_online_cpus() > 1) | ||
644 | delay -= jiffies % delay; | ||
645 | 471 | ||
646 | dbs_info->sample_type = DBS_NORMAL_SAMPLE; | 472 | static struct dbs_data od_dbs_data = { |
647 | INIT_DEFERRABLE_WORK(&dbs_info->work, do_dbs_timer); | 473 | .governor = GOV_ONDEMAND, |
648 | schedule_delayed_work_on(dbs_info->cpu, &dbs_info->work, delay); | 474 | .attr_group = &od_attr_group, |
649 | } | 475 | .tuners = &od_tuners, |
476 | .get_cpu_cdbs = get_cpu_cdbs, | ||
477 | .get_cpu_dbs_info_s = get_cpu_dbs_info_s, | ||
478 | .gov_dbs_timer = od_dbs_timer, | ||
479 | .gov_check_cpu = od_check_cpu, | ||
480 | .gov_ops = &od_ops, | ||
481 | }; | ||
650 | 482 | ||
651 | static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info) | 483 | static int od_cpufreq_governor_dbs(struct cpufreq_policy *policy, |
484 | unsigned int event) | ||
652 | { | 485 | { |
653 | cancel_delayed_work_sync(&dbs_info->work); | 486 | return cpufreq_governor_dbs(&od_dbs_data, policy, event); |
654 | } | 487 | } |
655 | 488 | ||
656 | /* | 489 | #ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND |
657 | * Not all CPUs want IO time to be accounted as busy; this dependson how | 490 | static |
658 | * efficient idling at a higher frequency/voltage is. | ||
659 | * Pavel Machek says this is not so for various generations of AMD and old | ||
660 | * Intel systems. | ||
661 | * Mike Chan (androidlcom) calis this is also not true for ARM. | ||
662 | * Because of this, whitelist specific known (series) of CPUs by default, and | ||
663 | * leave all others up to the user. | ||
664 | */ | ||
665 | static int should_io_be_busy(void) | ||
666 | { | ||
667 | #if defined(CONFIG_X86) | ||
668 | /* | ||
669 | * For Intel, Core 2 (model 15) andl later have an efficient idle. | ||
670 | */ | ||
671 | if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL && | ||
672 | boot_cpu_data.x86 == 6 && | ||
673 | boot_cpu_data.x86_model >= 15) | ||
674 | return 1; | ||
675 | #endif | 491 | #endif |
676 | return 0; | 492 | struct cpufreq_governor cpufreq_gov_ondemand = { |
677 | } | 493 | .name = "ondemand", |
678 | 494 | .governor = od_cpufreq_governor_dbs, | |
679 | static int cpufreq_governor_dbs(struct cpufreq_policy *policy, | 495 | .max_transition_latency = TRANSITION_LATENCY_LIMIT, |
680 | unsigned int event) | 496 | .owner = THIS_MODULE, |
681 | { | 497 | }; |
682 | unsigned int cpu = policy->cpu; | ||
683 | struct cpu_dbs_info_s *this_dbs_info; | ||
684 | unsigned int j; | ||
685 | int rc; | ||
686 | |||
687 | this_dbs_info = &per_cpu(od_cpu_dbs_info, cpu); | ||
688 | |||
689 | switch (event) { | ||
690 | case CPUFREQ_GOV_START: | ||
691 | if ((!cpu_online(cpu)) || (!policy->cur)) | ||
692 | return -EINVAL; | ||
693 | |||
694 | mutex_lock(&dbs_mutex); | ||
695 | |||
696 | dbs_enable++; | ||
697 | for_each_cpu(j, policy->cpus) { | ||
698 | struct cpu_dbs_info_s *j_dbs_info; | ||
699 | j_dbs_info = &per_cpu(od_cpu_dbs_info, j); | ||
700 | j_dbs_info->cur_policy = policy; | ||
701 | |||
702 | j_dbs_info->prev_cpu_idle = get_cpu_idle_time(j, | ||
703 | &j_dbs_info->prev_cpu_wall); | ||
704 | if (dbs_tuners_ins.ignore_nice) | ||
705 | j_dbs_info->prev_cpu_nice = | ||
706 | kcpustat_cpu(j).cpustat[CPUTIME_NICE]; | ||
707 | } | ||
708 | this_dbs_info->cpu = cpu; | ||
709 | this_dbs_info->rate_mult = 1; | ||
710 | ondemand_powersave_bias_init_cpu(cpu); | ||
711 | /* | ||
712 | * Start the timerschedule work, when this governor | ||
713 | * is used for first time | ||
714 | */ | ||
715 | if (dbs_enable == 1) { | ||
716 | unsigned int latency; | ||
717 | |||
718 | rc = sysfs_create_group(cpufreq_global_kobject, | ||
719 | &dbs_attr_group); | ||
720 | if (rc) { | ||
721 | mutex_unlock(&dbs_mutex); | ||
722 | return rc; | ||
723 | } | ||
724 | |||
725 | /* policy latency is in nS. Convert it to uS first */ | ||
726 | latency = policy->cpuinfo.transition_latency / 1000; | ||
727 | if (latency == 0) | ||
728 | latency = 1; | ||
729 | /* Bring kernel and HW constraints together */ | ||
730 | min_sampling_rate = max(min_sampling_rate, | ||
731 | MIN_LATENCY_MULTIPLIER * latency); | ||
732 | dbs_tuners_ins.sampling_rate = | ||
733 | max(min_sampling_rate, | ||
734 | latency * LATENCY_MULTIPLIER); | ||
735 | dbs_tuners_ins.io_is_busy = should_io_be_busy(); | ||
736 | } | ||
737 | mutex_unlock(&dbs_mutex); | ||
738 | |||
739 | mutex_init(&this_dbs_info->timer_mutex); | ||
740 | dbs_timer_init(this_dbs_info); | ||
741 | break; | ||
742 | |||
743 | case CPUFREQ_GOV_STOP: | ||
744 | dbs_timer_exit(this_dbs_info); | ||
745 | |||
746 | mutex_lock(&dbs_mutex); | ||
747 | mutex_destroy(&this_dbs_info->timer_mutex); | ||
748 | dbs_enable--; | ||
749 | mutex_unlock(&dbs_mutex); | ||
750 | if (!dbs_enable) | ||
751 | sysfs_remove_group(cpufreq_global_kobject, | ||
752 | &dbs_attr_group); | ||
753 | |||
754 | break; | ||
755 | |||
756 | case CPUFREQ_GOV_LIMITS: | ||
757 | mutex_lock(&this_dbs_info->timer_mutex); | ||
758 | if (policy->max < this_dbs_info->cur_policy->cur) | ||
759 | __cpufreq_driver_target(this_dbs_info->cur_policy, | ||
760 | policy->max, CPUFREQ_RELATION_H); | ||
761 | else if (policy->min > this_dbs_info->cur_policy->cur) | ||
762 | __cpufreq_driver_target(this_dbs_info->cur_policy, | ||
763 | policy->min, CPUFREQ_RELATION_L); | ||
764 | dbs_check_cpu(this_dbs_info); | ||
765 | mutex_unlock(&this_dbs_info->timer_mutex); | ||
766 | break; | ||
767 | } | ||
768 | return 0; | ||
769 | } | ||
770 | 498 | ||
771 | static int __init cpufreq_gov_dbs_init(void) | 499 | static int __init cpufreq_gov_dbs_init(void) |
772 | { | 500 | { |
773 | u64 idle_time; | 501 | u64 idle_time; |
774 | int cpu = get_cpu(); | 502 | int cpu = get_cpu(); |
775 | 503 | ||
504 | mutex_init(&od_dbs_data.mutex); | ||
776 | idle_time = get_cpu_idle_time_us(cpu, NULL); | 505 | idle_time = get_cpu_idle_time_us(cpu, NULL); |
777 | put_cpu(); | 506 | put_cpu(); |
778 | if (idle_time != -1ULL) { | 507 | if (idle_time != -1ULL) { |
779 | /* Idle micro accounting is supported. Use finer thresholds */ | 508 | /* Idle micro accounting is supported. Use finer thresholds */ |
780 | dbs_tuners_ins.up_threshold = MICRO_FREQUENCY_UP_THRESHOLD; | 509 | od_tuners.up_threshold = MICRO_FREQUENCY_UP_THRESHOLD; |
781 | dbs_tuners_ins.down_differential = | 510 | od_tuners.down_differential = MICRO_FREQUENCY_DOWN_DIFFERENTIAL; |
782 | MICRO_FREQUENCY_DOWN_DIFFERENTIAL; | ||
783 | /* | 511 | /* |
784 | * In nohz/micro accounting case we set the minimum frequency | 512 | * In nohz/micro accounting case we set the minimum frequency |
785 | * not depending on HZ, but fixed (very low). The deferred | 513 | * not depending on HZ, but fixed (very low). The deferred |
786 | * timer might skip some samples if idle/sleeping as needed. | 514 | * timer might skip some samples if idle/sleeping as needed. |
787 | */ | 515 | */ |
788 | min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE; | 516 | od_dbs_data.min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE; |
789 | } else { | 517 | } else { |
790 | /* For correct statistics, we need 10 ticks for each measure */ | 518 | /* For correct statistics, we need 10 ticks for each measure */ |
791 | min_sampling_rate = | 519 | od_dbs_data.min_sampling_rate = MIN_SAMPLING_RATE_RATIO * |
792 | MIN_SAMPLING_RATE_RATIO * jiffies_to_usecs(10); | 520 | jiffies_to_usecs(10); |
793 | } | 521 | } |
794 | 522 | ||
795 | return cpufreq_register_governor(&cpufreq_gov_ondemand); | 523 | return cpufreq_register_governor(&cpufreq_gov_ondemand); |
@@ -800,7 +528,6 @@ static void __exit cpufreq_gov_dbs_exit(void) | |||
800 | cpufreq_unregister_governor(&cpufreq_gov_ondemand); | 528 | cpufreq_unregister_governor(&cpufreq_gov_ondemand); |
801 | } | 529 | } |
802 | 530 | ||
803 | |||
804 | MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>"); | 531 | MODULE_AUTHOR("Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>"); |
805 | MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>"); | 532 | MODULE_AUTHOR("Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>"); |
806 | MODULE_DESCRIPTION("'cpufreq_ondemand' - A dynamic cpufreq governor for " | 533 | MODULE_DESCRIPTION("'cpufreq_ondemand' - A dynamic cpufreq governor for " |