Branch data Line data Source code
1 : : /*
2 : : * drivers/cpufreq/cpufreq_governor.c
3 : : *
4 : : * CPUFREQ governors common code
5 : : *
6 : : * Copyright (C) 2001 Russell King
7 : : * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
8 : : * (C) 2003 Jun Nakajima <jun.nakajima@intel.com>
9 : : * (C) 2009 Alexander Clouter <alex@digriz.org.uk>
10 : : * (c) 2012 Viresh Kumar <viresh.kumar@linaro.org>
11 : : *
12 : : * This program is free software; you can redistribute it and/or modify
13 : : * it under the terms of the GNU General Public License version 2 as
14 : : * published by the Free Software Foundation.
15 : : */
16 : :
17 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 : :
19 : : #include <linux/export.h>
20 : : #include <linux/kernel_stat.h>
21 : : #include <linux/slab.h>
22 : :
23 : : #include "cpufreq_governor.h"
24 : :
25 : : static struct attribute_group *get_sysfs_attr(struct dbs_data *dbs_data)
26 : : {
27 [ + - + - ]: 3 : if (have_governor_per_policy())
28 : 3 : return dbs_data->cdata->attr_group_gov_pol;
29 : : else
30 : 0 : return dbs_data->cdata->attr_group_gov_sys;
31 : : }
32 : :
33 : 0 : void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
34 : : {
35 : 33042 : struct cpu_dbs_common_info *cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
36 : 33042 : struct od_dbs_tuners *od_tuners = dbs_data->tuners;
37 : : struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
38 : : struct cpufreq_policy *policy;
39 : : unsigned int max_load = 0;
40 : : unsigned int ignore_nice;
41 : : unsigned int j;
42 : :
43 [ + - ]: 33042 : if (dbs_data->cdata->governor == GOV_ONDEMAND)
44 : 33042 : ignore_nice = od_tuners->ignore_nice_load;
45 : : else
46 : 0 : ignore_nice = cs_tuners->ignore_nice_load;
47 : :
48 : 33042 : policy = cdbs->cur_policy;
49 : :
50 : : /* Get Absolute Load */
51 [ + + ]: 164272 : for_each_cpu(j, policy->cpus) {
52 : : struct cpu_dbs_common_info *j_cdbs;
53 : : u64 cur_wall_time, cur_idle_time;
54 : : unsigned int idle_time, wall_time;
55 : : unsigned int load;
56 : : int io_busy = 0;
57 : :
58 : 98188 : j_cdbs = dbs_data->cdata->get_cpu_cdbs(j);
59 : :
60 : : /*
61 : : * For the purpose of ondemand, waiting for disk IO is
62 : : * an indication that you're performance critical, and
63 : : * not that the system is actually idle. So do not add
64 : : * the iowait time to the cpu idle time.
65 : : */
66 [ + - ]: 98188 : if (dbs_data->cdata->governor == GOV_ONDEMAND)
67 : 98188 : io_busy = od_tuners->io_is_busy;
68 : 98188 : cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy);
69 : :
70 : 196376 : wall_time = (unsigned int)
71 : 98188 : (cur_wall_time - j_cdbs->prev_cpu_wall);
72 : 98188 : j_cdbs->prev_cpu_wall = cur_wall_time;
73 : :
74 : 196376 : idle_time = (unsigned int)
75 : 98188 : (cur_idle_time - j_cdbs->prev_cpu_idle);
76 : 98188 : j_cdbs->prev_cpu_idle = cur_idle_time;
77 : :
78 [ - + ]: 131230 : if (ignore_nice) {
79 : : u64 cur_nice;
80 : : unsigned long cur_nice_jiffies;
81 : :
82 : 0 : cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE] -
83 : 0 : cdbs->prev_cpu_nice;
84 : : /*
85 : : * Assumption: nice time between sampling periods will
86 : : * be less than 2^32 jiffies for 32 bit sys
87 : : */
88 : 0 : cur_nice_jiffies = (unsigned long)
89 : : cputime64_to_jiffies64(cur_nice);
90 : :
91 : 0 : cdbs->prev_cpu_nice =
92 : 0 : kcpustat_cpu(j).cpustat[CPUTIME_NICE];
93 : 0 : idle_time += jiffies_to_usecs(cur_nice_jiffies);
94 : : }
95 : :
96 [ + + ]: 98188 : if (unlikely(!wall_time || wall_time < idle_time))
97 : 42 : continue;
98 : :
99 : 98146 : load = 100 * (wall_time - idle_time) / wall_time;
100 : :
101 [ + + ]: 98188 : if (load > max_load)
102 : : max_load = load;
103 : : }
104 : :
105 : 33042 : dbs_data->cdata->gov_check_cpu(cpu, max_load);
106 : 33042 : }
107 : : EXPORT_SYMBOL_GPL(dbs_check_cpu);
108 : :
109 : : static inline void __gov_queue_work(int cpu, struct dbs_data *dbs_data,
110 : : unsigned int delay)
111 : : {
112 : 100017 : struct cpu_dbs_common_info *cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
113 : :
114 : 100017 : mod_delayed_work_on(cpu, system_wq, &cdbs->work, delay);
115 : : }
116 : :
117 : 0 : void gov_queue_work(struct dbs_data *dbs_data, struct cpufreq_policy *policy,
118 : : unsigned int delay, bool all_cpus)
119 : : {
120 : : int i;
121 : :
122 : 34938 : mutex_lock(&cpufreq_governor_lock);
123 [ + - ]: 34938 : if (!policy->governor_enabled)
124 : : goto out_unlock;
125 : :
126 [ + + ]: 34938 : if (!all_cpus) {
127 : : /*
128 : : * Use raw_smp_processor_id() to avoid preemptible warnings.
129 : : * We know that this is only called with all_cpus == false from
130 : : * works that have been queued with *_work_on() functions and
131 : : * those works are canceled during CPU_DOWN_PREPARE so they
132 : : * can't possibly run on any other CPU.
133 : : */
134 : 1930 : __gov_queue_work(raw_smp_processor_id(), dbs_data, delay);
135 : : } else {
136 [ + + ]: 131095 : for_each_cpu(i, policy->cpus)
137 : : __gov_queue_work(i, dbs_data, delay);
138 : : }
139 : :
140 : : out_unlock:
141 : 34938 : mutex_unlock(&cpufreq_governor_lock);
142 : 34938 : }
143 : : EXPORT_SYMBOL_GPL(gov_queue_work);
144 : :
145 : : static inline void gov_cancel_work(struct dbs_data *dbs_data,
146 : : struct cpufreq_policy *policy)
147 : : {
148 : : struct cpu_dbs_common_info *cdbs;
149 : : int i;
150 : :
151 [ + + ]: 240 : for_each_cpu(i, policy->cpus) {
152 : 170 : cdbs = dbs_data->cdata->get_cpu_cdbs(i);
153 : 170 : cancel_delayed_work_sync(&cdbs->work);
154 : : }
155 : : }
156 : :
157 : : /* Will return if we need to evaluate cpu load again or not */
158 : 0 : bool need_load_eval(struct cpu_dbs_common_info *cdbs,
159 : : unsigned int sampling_rate)
160 : : {
161 [ + + ]: 34869 : if (policy_is_shared(cdbs->cur_policy)) {
162 : 34479 : ktime_t time_now = ktime_get();
163 : : s64 delta_us = ktime_us_delta(time_now, cdbs->time_stamp);
164 : :
165 : : /* Do nothing if we recently have sampled */
166 [ + + ]: 69348 : if (delta_us < (s64)(sampling_rate / 2))
167 : 1930 : return false;
168 : : else
169 : 32549 : cdbs->time_stamp = time_now;
170 : : }
171 : :
172 : : return true;
173 : : }
174 : : EXPORT_SYMBOL_GPL(need_load_eval);
175 : :
176 : : static void set_sampling_rate(struct dbs_data *dbs_data,
177 : : unsigned int sampling_rate)
178 : : {
179 [ - + ]: 1 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
180 : : struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
181 : 0 : cs_tuners->sampling_rate = sampling_rate;
182 : : } else {
183 : : struct od_dbs_tuners *od_tuners = dbs_data->tuners;
184 : 1 : od_tuners->sampling_rate = sampling_rate;
185 : : }
186 : : }
187 : :
188 : 0 : int cpufreq_governor_dbs(struct cpufreq_policy *policy,
189 : : struct common_dbs_data *cdata, unsigned int event)
190 : : {
191 : 1 : struct dbs_data *dbs_data;
192 : : struct od_cpu_dbs_info_s *od_dbs_info = NULL;
193 : : struct cs_cpu_dbs_info_s *cs_dbs_info = NULL;
194 : : struct od_ops *od_ops = NULL;
195 : : struct od_dbs_tuners *od_tuners = NULL;
196 : : struct cs_dbs_tuners *cs_tuners = NULL;
197 : : struct cpu_dbs_common_info *cpu_cdbs;
198 : 245 : unsigned int sampling_rate, latency, ignore_nice, j, cpu = policy->cpu;
199 : : int io_busy = 0;
200 : : int rc;
201 : :
202 [ + - ]: 245 : if (have_governor_per_policy())
203 : 245 : dbs_data = policy->governor_data;
204 : : else
205 : 0 : dbs_data = cdata->gdbs_data;
206 : :
207 [ - + ]: 245 : WARN_ON(!dbs_data && (event != CPUFREQ_GOV_POLICY_INIT));
208 : :
209 [ + + + ]: 245 : switch (event) {
210 : : case CPUFREQ_GOV_POLICY_INIT:
211 [ + - ]: 1 : if (have_governor_per_policy()) {
212 [ - + ]: 1 : WARN_ON(dbs_data);
213 [ # # ]: 0 : } else if (dbs_data) {
214 : 0 : dbs_data->usage_count++;
215 : 0 : policy->governor_data = dbs_data;
216 : 0 : return 0;
217 : : }
218 : :
219 : : dbs_data = kzalloc(sizeof(*dbs_data), GFP_KERNEL);
220 [ - + ]: 1 : if (!dbs_data) {
221 : 0 : pr_err("%s: POLICY_INIT: kzalloc failed\n", __func__);
222 : 0 : return -ENOMEM;
223 : : }
224 : :
225 : 1 : dbs_data->cdata = cdata;
226 : 1 : dbs_data->usage_count = 1;
227 : 1 : rc = cdata->init(dbs_data);
228 [ - + ]: 1 : if (rc) {
229 : 0 : pr_err("%s: POLICY_INIT: init() failed\n", __func__);
230 : 0 : kfree(dbs_data);
231 : 0 : return rc;
232 : : }
233 : :
234 [ - + ]: 1 : if (!have_governor_per_policy())
235 [ # # ]: 0 : WARN_ON(cpufreq_get_global_kobject());
236 : :
237 : 2 : rc = sysfs_create_group(get_governor_parent_kobj(policy),
238 : : get_sysfs_attr(dbs_data));
239 [ - + ]: 246 : if (rc) {
240 : 0 : cdata->exit(dbs_data);
241 : 0 : kfree(dbs_data);
242 : 0 : return rc;
243 : : }
244 : :
245 : 1 : policy->governor_data = dbs_data;
246 : :
247 : : /* policy latency is in ns. Convert it to us first */
248 : 1 : latency = policy->cpuinfo.transition_latency / 1000;
249 [ - + ]: 1 : if (latency == 0)
250 : : latency = 1;
251 : :
252 : : /* Bring kernel and HW constraints together */
253 : 1 : dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
254 : : MIN_LATENCY_MULTIPLIER * latency);
255 : 1 : set_sampling_rate(dbs_data, max(dbs_data->min_sampling_rate,
256 : : latency * LATENCY_MULTIPLIER));
257 : :
258 [ - + ][ # # ]: 1 : if ((cdata->governor == GOV_CONSERVATIVE) &&
259 : 0 : (!policy->governor->initialized)) {
260 : 0 : struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
261 : :
262 : 0 : cpufreq_register_notifier(cs_ops->notifier_block,
263 : : CPUFREQ_TRANSITION_NOTIFIER);
264 : : }
265 : :
266 [ - + ]: 1 : if (!have_governor_per_policy())
267 : 0 : cdata->gdbs_data = dbs_data;
268 : :
269 : : return 0;
270 : : case CPUFREQ_GOV_POLICY_EXIT:
271 [ + - ]: 2 : if (!--dbs_data->usage_count) {
272 : 4 : sysfs_remove_group(get_governor_parent_kobj(policy),
273 : : get_sysfs_attr(dbs_data));
274 : :
275 [ - + ]: 2 : if (!have_governor_per_policy())
276 : 0 : cpufreq_put_global_kobject();
277 : :
278 [ - + ][ # # ]: 2 : if ((dbs_data->cdata->governor == GOV_CONSERVATIVE) &&
279 : 0 : (policy->governor->initialized == 1)) {
280 : 0 : struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
281 : :
282 : 0 : cpufreq_unregister_notifier(cs_ops->notifier_block,
283 : : CPUFREQ_TRANSITION_NOTIFIER);
284 : : }
285 : :
286 : 2 : cdata->exit(dbs_data);
287 : 2 : kfree(dbs_data);
288 : 2 : cdata->gdbs_data = NULL;
289 : : }
290 : :
291 : 2 : policy->governor_data = NULL;
292 : 2 : return 0;
293 : : }
294 : :
295 : 242 : cpu_cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
296 : :
297 [ - + ]: 242 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
298 : 0 : cs_tuners = dbs_data->tuners;
299 : 0 : cs_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu);
300 : 0 : sampling_rate = cs_tuners->sampling_rate;
301 : 0 : ignore_nice = cs_tuners->ignore_nice_load;
302 : : } else {
303 : 242 : od_tuners = dbs_data->tuners;
304 : 242 : od_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu);
305 : 242 : sampling_rate = od_tuners->sampling_rate;
306 : 242 : ignore_nice = od_tuners->ignore_nice_load;
307 : 242 : od_ops = dbs_data->cdata->gov_ops;
308 : 242 : io_busy = od_tuners->io_is_busy;
309 : : }
310 : :
311 [ + + + - ]: 242 : switch (event) {
312 : : case CPUFREQ_GOV_START:
313 [ + - ]: 69 : if (!policy->cur)
314 : : return -EINVAL;
315 : :
316 : 69 : mutex_lock(&dbs_data->mutex);
317 : :
318 [ + + ]: 309 : for_each_cpu(j, policy->cpus) {
319 : 171 : struct cpu_dbs_common_info *j_cdbs =
320 : 171 : dbs_data->cdata->get_cpu_cdbs(j);
321 : :
322 : 171 : j_cdbs->cpu = j;
323 : 171 : j_cdbs->cur_policy = policy;
324 : 171 : j_cdbs->prev_cpu_idle = get_cpu_idle_time(j,
325 : : &j_cdbs->prev_cpu_wall, io_busy);
326 [ - + ]: 171 : if (ignore_nice)
327 : 0 : j_cdbs->prev_cpu_nice =
328 : 0 : kcpustat_cpu(j).cpustat[CPUTIME_NICE];
329 : :
330 : 171 : mutex_init(&j_cdbs->timer_mutex);
331 : 171 : INIT_DEFERRABLE_WORK(&j_cdbs->work,
332 : : dbs_data->cdata->gov_dbs_timer);
333 : : }
334 : :
335 [ - + ]: 69 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
336 : 0 : cs_dbs_info->down_skip = 0;
337 : 0 : cs_dbs_info->enable = 1;
338 : 0 : cs_dbs_info->requested_freq = policy->cur;
339 : : } else {
340 : 69 : od_dbs_info->rate_mult = 1;
341 : 69 : od_dbs_info->sample_type = OD_NORMAL_SAMPLE;
342 : 69 : od_ops->powersave_bias_init_cpu(cpu);
343 : : }
344 : :
345 : 69 : mutex_unlock(&dbs_data->mutex);
346 : :
347 : : /* Initiate timer time stamp */
348 : 69 : cpu_cdbs->time_stamp = ktime_get();
349 : :
350 : 69 : gov_queue_work(dbs_data, policy,
351 : : delay_for_sampling_rate(sampling_rate), true);
352 : 69 : break;
353 : :
354 : : case CPUFREQ_GOV_STOP:
355 [ - + ]: 70 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE)
356 : 70 : cs_dbs_info->enable = 0;
357 : :
358 : : gov_cancel_work(dbs_data, policy);
359 : :
360 : 70 : mutex_lock(&dbs_data->mutex);
361 : : mutex_destroy(&cpu_cdbs->timer_mutex);
362 : 70 : cpu_cdbs->cur_policy = NULL;
363 : :
364 : 70 : mutex_unlock(&dbs_data->mutex);
365 : :
366 : 70 : break;
367 : :
368 : : case CPUFREQ_GOV_LIMITS:
369 : 103 : mutex_lock(&cpu_cdbs->timer_mutex);
370 [ + + ]: 103 : if (policy->max < cpu_cdbs->cur_policy->cur)
371 : 15 : __cpufreq_driver_target(cpu_cdbs->cur_policy,
372 : : policy->max, CPUFREQ_RELATION_H);
373 [ - + ]: 88 : else if (policy->min > cpu_cdbs->cur_policy->cur)
374 : 0 : __cpufreq_driver_target(cpu_cdbs->cur_policy,
375 : : policy->min, CPUFREQ_RELATION_L);
376 : 103 : dbs_check_cpu(dbs_data, cpu);
377 : 103 : mutex_unlock(&cpu_cdbs->timer_mutex);
378 : 103 : break;
379 : : }
380 : : return 0;
381 : : }
382 : : EXPORT_SYMBOL_GPL(cpufreq_governor_dbs);
|
