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 [ # # # # ]: 0 : if (have_governor_per_policy())
28 : 0 : 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 : 160419 : struct cpu_dbs_common_info *cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
36 : 160404 : 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 [ + - ]: 160404 : if (dbs_data->cdata->governor == GOV_ONDEMAND)
44 : 160404 : ignore_nice = od_tuners->ignore_nice_load;
45 : : else
46 : 0 : ignore_nice = cs_tuners->ignore_nice_load;
47 : :
48 : 160404 : policy = cdbs->cur_policy;
49 : :
50 : : /* Get Absolute Load */
51 [ + + ]: 481223 : 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 : 160417 : 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 [ + - ]: 160408 : if (dbs_data->cdata->governor == GOV_ONDEMAND)
67 : 160408 : io_busy = od_tuners->io_is_busy;
68 : 160408 : cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy);
69 : :
70 : 320808 : wall_time = (unsigned int)
71 : 160404 : (cur_wall_time - j_cdbs->prev_cpu_wall);
72 : 160404 : j_cdbs->prev_cpu_wall = cur_wall_time;
73 : :
74 : 320808 : idle_time = (unsigned int)
75 : 160404 : (cur_idle_time - j_cdbs->prev_cpu_idle);
76 : 160404 : j_cdbs->prev_cpu_idle = cur_idle_time;
77 : :
78 [ - + ]: 320823 : 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 [ + ]: 160404 : if (unlikely(!wall_time || wall_time < idle_time))
97 : 0 : continue;
98 : :
99 : 160407 : load = 100 * (wall_time - idle_time) / wall_time;
100 : :
101 [ + + ]: 160404 : if (load > max_load)
102 : : max_load = load;
103 : : }
104 : :
105 : 160402 : dbs_data->cdata->gov_check_cpu(cpu, max_load);
106 : 160415 : }
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 : 160391 : struct cpu_dbs_common_info *cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
113 : :
114 : 160307 : 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 [ + + ]: 160347 : if (!policy->governor_enabled)
123 : 53 : return;
124 : :
125 [ + - ]: 160338 : if (!all_cpus) {
126 : : /*
127 : : * Use raw_smp_processor_id() to avoid preemptible warnings.
128 : : * We know that this is only called with all_cpus == false from
129 : : * works that have been queued with *_work_on() functions and
130 : : * those works are canceled during CPU_DOWN_PREPARE so they
131 : : * can't possibly run on any other CPU.
132 : : */
133 : 0 : __gov_queue_work(raw_smp_processor_id(), dbs_data, delay);
134 : : } else {
135 [ + + ]: 320782 : for_each_cpu(i, policy->cpus)
136 : : __gov_queue_work(i, dbs_data, delay);
137 : : }
138 : : }
139 : : EXPORT_SYMBOL_GPL(gov_queue_work);
140 : :
141 : : static inline void gov_cancel_work(struct dbs_data *dbs_data,
142 : : struct cpufreq_policy *policy)
143 : : {
144 : : struct cpu_dbs_common_info *cdbs;
145 : : int i;
146 : :
147 [ # # ]: 0 : for_each_cpu(i, policy->cpus) {
148 : 0 : cdbs = dbs_data->cdata->get_cpu_cdbs(i);
149 : 0 : cancel_delayed_work_sync(&cdbs->work);
150 : : }
151 : : }
152 : :
153 : : /* Will return if we need to evaluate cpu load again or not */
154 : 0 : bool need_load_eval(struct cpu_dbs_common_info *cdbs,
155 : : unsigned int sampling_rate)
156 : : {
157 [ - + ]: 160402 : if (policy_is_shared(cdbs->cur_policy)) {
158 : 0 : ktime_t time_now = ktime_get();
159 : : s64 delta_us = ktime_us_delta(time_now, cdbs->time_stamp);
160 : :
161 : : /* Do nothing if we recently have sampled */
162 [ # # ]: 160419 : if (delta_us < (s64)(sampling_rate / 2))
163 : 0 : return false;
164 : : else
165 : 0 : cdbs->time_stamp = time_now;
166 : : }
167 : :
168 : : return true;
169 : : }
170 : : EXPORT_SYMBOL_GPL(need_load_eval);
171 : :
172 : : static void set_sampling_rate(struct dbs_data *dbs_data,
173 : : unsigned int sampling_rate)
174 : : {
175 [ # # ]: 0 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
176 : : struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
177 : 0 : cs_tuners->sampling_rate = sampling_rate;
178 : : } else {
179 : : struct od_dbs_tuners *od_tuners = dbs_data->tuners;
180 : 0 : od_tuners->sampling_rate = sampling_rate;
181 : : }
182 : : }
183 : :
184 : 0 : int cpufreq_governor_dbs(struct cpufreq_policy *policy,
185 : : struct common_dbs_data *cdata, unsigned int event)
186 : : {
187 : 0 : struct dbs_data *dbs_data;
188 : : struct od_cpu_dbs_info_s *od_dbs_info = NULL;
189 : : struct cs_cpu_dbs_info_s *cs_dbs_info = NULL;
190 : : struct od_ops *od_ops = NULL;
191 : : struct od_dbs_tuners *od_tuners = NULL;
192 : : struct cs_dbs_tuners *cs_tuners = NULL;
193 : : struct cpu_dbs_common_info *cpu_cdbs;
194 : 0 : unsigned int sampling_rate, latency, ignore_nice, j, cpu = policy->cpu;
195 : : int io_busy = 0;
196 : : int rc;
197 : :
198 [ # # ]: 0 : if (have_governor_per_policy())
199 : 0 : dbs_data = policy->governor_data;
200 : : else
201 : 0 : dbs_data = cdata->gdbs_data;
202 : :
203 [ # # ]: 0 : WARN_ON(!dbs_data && (event != CPUFREQ_GOV_POLICY_INIT));
204 : :
205 [ # # # ]: 0 : switch (event) {
206 : : case CPUFREQ_GOV_POLICY_INIT:
207 [ # # ]: 0 : if (have_governor_per_policy()) {
208 [ # # ]: 0 : WARN_ON(dbs_data);
209 [ # # ]: 0 : } else if (dbs_data) {
210 : 0 : dbs_data->usage_count++;
211 : 0 : policy->governor_data = dbs_data;
212 : 0 : return 0;
213 : : }
214 : :
215 : : dbs_data = kzalloc(sizeof(*dbs_data), GFP_KERNEL);
216 [ # # ]: 0 : if (!dbs_data) {
217 : 0 : pr_err("%s: POLICY_INIT: kzalloc failed\n", __func__);
218 : 0 : return -ENOMEM;
219 : : }
220 : :
221 : 0 : dbs_data->cdata = cdata;
222 : 0 : dbs_data->usage_count = 1;
223 : 0 : rc = cdata->init(dbs_data);
224 [ # # ]: 0 : if (rc) {
225 : 0 : pr_err("%s: POLICY_INIT: init() failed\n", __func__);
226 : 0 : kfree(dbs_data);
227 : 0 : return rc;
228 : : }
229 : :
230 [ # # ]: 0 : if (!have_governor_per_policy())
231 [ # # ]: 0 : WARN_ON(cpufreq_get_global_kobject());
232 : :
233 : 0 : rc = sysfs_create_group(get_governor_parent_kobj(policy),
234 : : get_sysfs_attr(dbs_data));
235 [ # # ]: 0 : if (rc) {
236 : 0 : cdata->exit(dbs_data);
237 : 0 : kfree(dbs_data);
238 : 0 : return rc;
239 : : }
240 : :
241 : 0 : policy->governor_data = dbs_data;
242 : :
243 : : /* policy latency is in ns. Convert it to us first */
244 : 0 : latency = policy->cpuinfo.transition_latency / 1000;
245 [ # # ]: 0 : if (latency == 0)
246 : : latency = 1;
247 : :
248 : : /* Bring kernel and HW constraints together */
249 : 0 : dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
250 : : MIN_LATENCY_MULTIPLIER * latency);
251 : 0 : set_sampling_rate(dbs_data, max(dbs_data->min_sampling_rate,
252 : : latency * LATENCY_MULTIPLIER));
253 : :
254 [ # # ][ # # ]: 0 : if ((cdata->governor == GOV_CONSERVATIVE) &&
255 : 0 : (!policy->governor->initialized)) {
256 : 0 : struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
257 : :
258 : 0 : cpufreq_register_notifier(cs_ops->notifier_block,
259 : : CPUFREQ_TRANSITION_NOTIFIER);
260 : : }
261 : :
262 [ # # ]: 0 : if (!have_governor_per_policy())
263 : 0 : cdata->gdbs_data = dbs_data;
264 : :
265 : : return 0;
266 : : case CPUFREQ_GOV_POLICY_EXIT:
267 [ # # ]: 0 : if (!--dbs_data->usage_count) {
268 : 0 : sysfs_remove_group(get_governor_parent_kobj(policy),
269 : : get_sysfs_attr(dbs_data));
270 : :
271 [ # # ]: 0 : if (!have_governor_per_policy())
272 : 0 : cpufreq_put_global_kobject();
273 : :
274 [ # # ][ # # ]: 0 : if ((dbs_data->cdata->governor == GOV_CONSERVATIVE) &&
275 : 0 : (policy->governor->initialized == 1)) {
276 : 0 : struct cs_ops *cs_ops = dbs_data->cdata->gov_ops;
277 : :
278 : 0 : cpufreq_unregister_notifier(cs_ops->notifier_block,
279 : : CPUFREQ_TRANSITION_NOTIFIER);
280 : : }
281 : :
282 : 0 : cdata->exit(dbs_data);
283 : 0 : kfree(dbs_data);
284 : 0 : cdata->gdbs_data = NULL;
285 : : }
286 : :
287 : 0 : policy->governor_data = NULL;
288 : 0 : return 0;
289 : : }
290 : :
291 : 0 : cpu_cdbs = dbs_data->cdata->get_cpu_cdbs(cpu);
292 : :
293 [ # # ]: 0 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
294 : 0 : cs_tuners = dbs_data->tuners;
295 : 0 : cs_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu);
296 : 0 : sampling_rate = cs_tuners->sampling_rate;
297 : 0 : ignore_nice = cs_tuners->ignore_nice_load;
298 : : } else {
299 : 0 : od_tuners = dbs_data->tuners;
300 : 0 : od_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu);
301 : 0 : sampling_rate = od_tuners->sampling_rate;
302 : 0 : ignore_nice = od_tuners->ignore_nice_load;
303 : 0 : od_ops = dbs_data->cdata->gov_ops;
304 : 0 : io_busy = od_tuners->io_is_busy;
305 : : }
306 : :
307 [ # # # # ]: 0 : switch (event) {
308 : : case CPUFREQ_GOV_START:
309 [ # # ]: 0 : if (!policy->cur)
310 : : return -EINVAL;
311 : :
312 : 0 : mutex_lock(&dbs_data->mutex);
313 : :
314 [ # # ]: 0 : for_each_cpu(j, policy->cpus) {
315 : 0 : struct cpu_dbs_common_info *j_cdbs =
316 : 0 : dbs_data->cdata->get_cpu_cdbs(j);
317 : :
318 : 0 : j_cdbs->cpu = j;
319 : 0 : j_cdbs->cur_policy = policy;
320 : 0 : j_cdbs->prev_cpu_idle = get_cpu_idle_time(j,
321 : : &j_cdbs->prev_cpu_wall, io_busy);
322 [ # # ]: 0 : if (ignore_nice)
323 : 0 : j_cdbs->prev_cpu_nice =
324 : 0 : kcpustat_cpu(j).cpustat[CPUTIME_NICE];
325 : :
326 : 0 : mutex_init(&j_cdbs->timer_mutex);
327 : 0 : INIT_DEFERRABLE_WORK(&j_cdbs->work,
328 : : dbs_data->cdata->gov_dbs_timer);
329 : : }
330 : :
331 [ # # ]: 0 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE) {
332 : 0 : cs_dbs_info->down_skip = 0;
333 : 0 : cs_dbs_info->enable = 1;
334 : 0 : cs_dbs_info->requested_freq = policy->cur;
335 : : } else {
336 : 0 : od_dbs_info->rate_mult = 1;
337 : 0 : od_dbs_info->sample_type = OD_NORMAL_SAMPLE;
338 : 0 : od_ops->powersave_bias_init_cpu(cpu);
339 : : }
340 : :
341 : 0 : mutex_unlock(&dbs_data->mutex);
342 : :
343 : : /* Initiate timer time stamp */
344 : 0 : cpu_cdbs->time_stamp = ktime_get();
345 : :
346 : 0 : gov_queue_work(dbs_data, policy,
347 : : delay_for_sampling_rate(sampling_rate), true);
348 : 0 : break;
349 : :
350 : : case CPUFREQ_GOV_STOP:
351 [ # # ]: 0 : if (dbs_data->cdata->governor == GOV_CONSERVATIVE)
352 : 0 : cs_dbs_info->enable = 0;
353 : :
354 : : gov_cancel_work(dbs_data, policy);
355 : :
356 : 0 : mutex_lock(&dbs_data->mutex);
357 : : mutex_destroy(&cpu_cdbs->timer_mutex);
358 : 0 : cpu_cdbs->cur_policy = NULL;
359 : :
360 : 0 : mutex_unlock(&dbs_data->mutex);
361 : :
362 : 0 : break;
363 : :
364 : : case CPUFREQ_GOV_LIMITS:
365 : 0 : mutex_lock(&cpu_cdbs->timer_mutex);
366 [ # # ]: 0 : if (policy->max < cpu_cdbs->cur_policy->cur)
367 : 0 : __cpufreq_driver_target(cpu_cdbs->cur_policy,
368 : : policy->max, CPUFREQ_RELATION_H);
369 [ # # ]: 0 : else if (policy->min > cpu_cdbs->cur_policy->cur)
370 : 0 : __cpufreq_driver_target(cpu_cdbs->cur_policy,
371 : : policy->min, CPUFREQ_RELATION_L);
372 : 0 : dbs_check_cpu(dbs_data, cpu);
373 : 0 : mutex_unlock(&cpu_cdbs->timer_mutex);
374 : 0 : break;
375 : : }
376 : : return 0;
377 : : }
378 : : EXPORT_SYMBOL_GPL(cpufreq_governor_dbs);
|
