Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/drivers/cpufreq/cpufreq.c
4 : : *
5 : : * Copyright (C) 2001 Russell King
6 : : * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
7 : : * (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
8 : : *
9 : : * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
10 : : * Added handling for CPU hotplug
11 : : * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
12 : : * Fix handling for CPU hotplug -- affected CPUs
13 : : */
14 : :
15 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 : :
17 : : #include <linux/cpu.h>
18 : : #include <linux/cpufreq.h>
19 : : #include <linux/cpu_cooling.h>
20 : : #include <linux/delay.h>
21 : : #include <linux/device.h>
22 : : #include <linux/init.h>
23 : : #include <linux/kernel_stat.h>
24 : : #include <linux/module.h>
25 : : #include <linux/mutex.h>
26 : : #include <linux/pm_qos.h>
27 : : #include <linux/slab.h>
28 : : #include <linux/suspend.h>
29 : : #include <linux/syscore_ops.h>
30 : : #include <linux/tick.h>
31 : : #include <trace/events/power.h>
32 : :
33 : : static LIST_HEAD(cpufreq_policy_list);
34 : :
35 : : /* Macros to iterate over CPU policies */
36 : : #define for_each_suitable_policy(__policy, __active) \
37 : : list_for_each_entry(__policy, &cpufreq_policy_list, policy_list) \
38 : : if ((__active) == !policy_is_inactive(__policy))
39 : :
40 : : #define for_each_active_policy(__policy) \
41 : : for_each_suitable_policy(__policy, true)
42 : : #define for_each_inactive_policy(__policy) \
43 : : for_each_suitable_policy(__policy, false)
44 : :
45 : : #define for_each_policy(__policy) \
46 : : list_for_each_entry(__policy, &cpufreq_policy_list, policy_list)
47 : :
48 : : /* Iterate over governors */
49 : : static LIST_HEAD(cpufreq_governor_list);
50 : : #define for_each_governor(__governor) \
51 : : list_for_each_entry(__governor, &cpufreq_governor_list, governor_list)
52 : :
53 : : /**
54 : : * The "cpufreq driver" - the arch- or hardware-dependent low
55 : : * level driver of CPUFreq support, and its spinlock. This lock
56 : : * also protects the cpufreq_cpu_data array.
57 : : */
58 : : static struct cpufreq_driver *cpufreq_driver;
59 : : static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
60 : : static DEFINE_RWLOCK(cpufreq_driver_lock);
61 : :
62 : : /* Flag to suspend/resume CPUFreq governors */
63 : : static bool cpufreq_suspended;
64 : :
65 : : static inline bool has_target(void)
66 : : {
67 [ # # # # : 1035 : return cpufreq_driver->target_index || cpufreq_driver->target;
# # # # #
# # # # #
# # # # #
# - + # #
# # # # #
# # # # #
# # # # #
# - + # #
- + # # #
# # # # #
# # - + #
# # # #
# ]
68 : : }
69 : :
70 : : /* internal prototypes */
71 : : static unsigned int __cpufreq_get(struct cpufreq_policy *policy);
72 : : static int cpufreq_init_governor(struct cpufreq_policy *policy);
73 : : static void cpufreq_exit_governor(struct cpufreq_policy *policy);
74 : : static int cpufreq_start_governor(struct cpufreq_policy *policy);
75 : : static void cpufreq_stop_governor(struct cpufreq_policy *policy);
76 : : static void cpufreq_governor_limits(struct cpufreq_policy *policy);
77 : : static int cpufreq_set_policy(struct cpufreq_policy *policy,
78 : : struct cpufreq_governor *new_gov,
79 : : unsigned int new_pol);
80 : :
81 : : /**
82 : : * Two notifier lists: the "policy" list is involved in the
83 : : * validation process for a new CPU frequency policy; the
84 : : * "transition" list for kernel code that needs to handle
85 : : * changes to devices when the CPU clock speed changes.
86 : : * The mutex locks both lists.
87 : : */
88 : : static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
89 : : SRCU_NOTIFIER_HEAD_STATIC(cpufreq_transition_notifier_list);
90 : :
91 : : static int off __read_mostly;
92 : : static int cpufreq_disabled(void)
93 : : {
94 : 145778 : return off;
95 : : }
96 : 0 : void disable_cpufreq(void)
97 : : {
98 : 0 : off = 1;
99 : 0 : }
100 : : static DEFINE_MUTEX(cpufreq_governor_mutex);
101 : :
102 : 207 : bool have_governor_per_policy(void)
103 : : {
104 : 414 : return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
105 : : }
106 : : EXPORT_SYMBOL_GPL(have_governor_per_policy);
107 : :
108 : 207 : struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
109 : : {
110 [ - + ]: 207 : if (have_governor_per_policy())
111 : 0 : return &policy->kobj;
112 : : else
113 : 207 : return cpufreq_global_kobject;
114 : : }
115 : : EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
116 : :
117 : 0 : static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
118 : : {
119 : : u64 idle_time;
120 : : u64 cur_wall_time;
121 : : u64 busy_time;
122 : :
123 : 0 : cur_wall_time = jiffies64_to_nsecs(get_jiffies_64());
124 : :
125 : 0 : busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
126 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
127 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
128 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
129 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
130 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
131 : :
132 : 0 : idle_time = cur_wall_time - busy_time;
133 [ # # ]: 0 : if (wall)
134 : 0 : *wall = div_u64(cur_wall_time, NSEC_PER_USEC);
135 : :
136 : 0 : return div_u64(idle_time, NSEC_PER_USEC);
137 : : }
138 : :
139 : 444236 : u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
140 : : {
141 [ - + ]: 444236 : u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
142 : :
143 [ - + ]: 444236 : if (idle_time == -1ULL)
144 : 0 : return get_cpu_idle_time_jiffy(cpu, wall);
145 [ + - ]: 444236 : else if (!io_busy)
146 : 444236 : idle_time += get_cpu_iowait_time_us(cpu, wall);
147 : :
148 : 444236 : return idle_time;
149 : : }
150 : : EXPORT_SYMBOL_GPL(get_cpu_idle_time);
151 : :
152 : 0 : __weak void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
153 : : unsigned long max_freq)
154 : : {
155 : 0 : }
156 : : EXPORT_SYMBOL_GPL(arch_set_freq_scale);
157 : :
158 : : /*
159 : : * This is a generic cpufreq init() routine which can be used by cpufreq
160 : : * drivers of SMP systems. It will do following:
161 : : * - validate & show freq table passed
162 : : * - set policies transition latency
163 : : * - policy->cpus with all possible CPUs
164 : : */
165 : 0 : void cpufreq_generic_init(struct cpufreq_policy *policy,
166 : : struct cpufreq_frequency_table *table,
167 : : unsigned int transition_latency)
168 : : {
169 : 0 : policy->freq_table = table;
170 : 0 : policy->cpuinfo.transition_latency = transition_latency;
171 : :
172 : : /*
173 : : * The driver only supports the SMP configuration where all processors
174 : : * share the clock and voltage and clock.
175 : : */
176 : : cpumask_setall(policy->cpus);
177 : 0 : }
178 : : EXPORT_SYMBOL_GPL(cpufreq_generic_init);
179 : :
180 : 0 : struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
181 : : {
182 : 621 : struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
183 : :
184 [ # # # # : 1242 : return policy && cpumask_test_cpu(cpu, policy->cpus) ? policy : NULL;
# # # # +
- + - # #
# # ]
185 : : }
186 : : EXPORT_SYMBOL_GPL(cpufreq_cpu_get_raw);
187 : :
188 : 621 : unsigned int cpufreq_generic_get(unsigned int cpu)
189 : : {
190 : : struct cpufreq_policy *policy = cpufreq_cpu_get_raw(cpu);
191 : :
192 [ + - - + ]: 1242 : if (!policy || IS_ERR(policy->clk)) {
193 [ # # ]: 0 : pr_err("%s: No %s associated to cpu: %d\n",
194 : : __func__, policy ? "clk" : "policy", cpu);
195 : 0 : return 0;
196 : : }
197 : :
198 : 621 : return clk_get_rate(policy->clk) / 1000;
199 : : }
200 : : EXPORT_SYMBOL_GPL(cpufreq_generic_get);
201 : :
202 : : /**
203 : : * cpufreq_cpu_get - Return policy for a CPU and mark it as busy.
204 : : * @cpu: CPU to find the policy for.
205 : : *
206 : : * Call cpufreq_cpu_get_raw() to obtain a cpufreq policy for @cpu and increment
207 : : * the kobject reference counter of that policy. Return a valid policy on
208 : : * success or NULL on failure.
209 : : *
210 : : * The policy returned by this function has to be released with the help of
211 : : * cpufreq_cpu_put() to balance its kobject reference counter properly.
212 : : */
213 : 0 : struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
214 : : {
215 : : struct cpufreq_policy *policy = NULL;
216 : : unsigned long flags;
217 : :
218 [ # # # # ]: 0 : if (WARN_ON(cpu >= nr_cpu_ids))
219 : : return NULL;
220 : :
221 : : /* get the cpufreq driver */
222 : 0 : read_lock_irqsave(&cpufreq_driver_lock, flags);
223 : :
224 [ # # ]: 0 : if (cpufreq_driver) {
225 : : /* get the CPU */
226 : : policy = cpufreq_cpu_get_raw(cpu);
227 [ # # ]: 0 : if (policy)
228 : 0 : kobject_get(&policy->kobj);
229 : : }
230 : :
231 : 0 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
232 : :
233 : 0 : return policy;
234 : : }
235 : : EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
236 : :
237 : : /**
238 : : * cpufreq_cpu_put - Decrement kobject usage counter for cpufreq policy.
239 : : * @policy: cpufreq policy returned by cpufreq_cpu_get().
240 : : */
241 : 0 : void cpufreq_cpu_put(struct cpufreq_policy *policy)
242 : : {
243 : 0 : kobject_put(&policy->kobj);
244 : 0 : }
245 : : EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
246 : :
247 : : /**
248 : : * cpufreq_cpu_release - Unlock a policy and decrement its usage counter.
249 : : * @policy: cpufreq policy returned by cpufreq_cpu_acquire().
250 : : */
251 : 0 : void cpufreq_cpu_release(struct cpufreq_policy *policy)
252 : : {
253 [ # # # # ]: 0 : if (WARN_ON(!policy))
254 : 0 : return;
255 : :
256 : : lockdep_assert_held(&policy->rwsem);
257 : :
258 : 0 : up_write(&policy->rwsem);
259 : :
260 : : cpufreq_cpu_put(policy);
261 : : }
262 : :
263 : : /**
264 : : * cpufreq_cpu_acquire - Find policy for a CPU, mark it as busy and lock it.
265 : : * @cpu: CPU to find the policy for.
266 : : *
267 : : * Call cpufreq_cpu_get() to get a reference on the cpufreq policy for @cpu and
268 : : * if the policy returned by it is not NULL, acquire its rwsem for writing.
269 : : * Return the policy if it is active or release it and return NULL otherwise.
270 : : *
271 : : * The policy returned by this function has to be released with the help of
272 : : * cpufreq_cpu_release() in order to release its rwsem and balance its usage
273 : : * counter properly.
274 : : */
275 : 0 : struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu)
276 : : {
277 : 0 : struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
278 : :
279 [ # # ]: 0 : if (!policy)
280 : : return NULL;
281 : :
282 : 0 : down_write(&policy->rwsem);
283 : :
284 [ # # ]: 0 : if (policy_is_inactive(policy)) {
285 : 0 : cpufreq_cpu_release(policy);
286 : 0 : return NULL;
287 : : }
288 : :
289 : : return policy;
290 : : }
291 : :
292 : : /*********************************************************************
293 : : * EXTERNALLY AFFECTING FREQUENCY CHANGES *
294 : : *********************************************************************/
295 : :
296 : : /**
297 : : * adjust_jiffies - adjust the system "loops_per_jiffy"
298 : : *
299 : : * This function alters the system "loops_per_jiffy" for the clock
300 : : * speed change. Note that loops_per_jiffy cannot be updated on SMP
301 : : * systems as each CPU might be scaled differently. So, use the arch
302 : : * per-CPU loops_per_jiffy value wherever possible.
303 : : */
304 : : static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
305 : : {
306 : : #ifndef CONFIG_SMP
307 : : static unsigned long l_p_j_ref;
308 : : static unsigned int l_p_j_ref_freq;
309 : :
310 : : if (ci->flags & CPUFREQ_CONST_LOOPS)
311 : : return;
312 : :
313 : : if (!l_p_j_ref_freq) {
314 : : l_p_j_ref = loops_per_jiffy;
315 : : l_p_j_ref_freq = ci->old;
316 : : pr_debug("saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n",
317 : : l_p_j_ref, l_p_j_ref_freq);
318 : : }
319 : : if (val == CPUFREQ_POSTCHANGE && ci->old != ci->new) {
320 : : loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
321 : : ci->new);
322 : : pr_debug("scaling loops_per_jiffy to %lu for frequency %u kHz\n",
323 : : loops_per_jiffy, ci->new);
324 : : }
325 : : #endif
326 : : }
327 : :
328 : : /**
329 : : * cpufreq_notify_transition - Notify frequency transition and adjust_jiffies.
330 : : * @policy: cpufreq policy to enable fast frequency switching for.
331 : : * @freqs: contain details of the frequency update.
332 : : * @state: set to CPUFREQ_PRECHANGE or CPUFREQ_POSTCHANGE.
333 : : *
334 : : * This function calls the transition notifiers and the "adjust_jiffies"
335 : : * function. It is called twice on all CPU frequency changes that have
336 : : * external effects.
337 : : */
338 : 36148 : static void cpufreq_notify_transition(struct cpufreq_policy *policy,
339 : : struct cpufreq_freqs *freqs,
340 : : unsigned int state)
341 : : {
342 : : int cpu;
343 : :
344 [ - + ]: 36148 : BUG_ON(irqs_disabled());
345 : :
346 [ + - ]: 36148 : if (cpufreq_disabled())
347 : 36148 : return;
348 : :
349 : 36148 : freqs->policy = policy;
350 : 36148 : freqs->flags = cpufreq_driver->flags;
351 : : pr_debug("notification %u of frequency transition to %u kHz\n",
352 : : state, freqs->new);
353 : :
354 [ + + - ]: 36148 : switch (state) {
355 : : case CPUFREQ_PRECHANGE:
356 : : /*
357 : : * Detect if the driver reported a value as "old frequency"
358 : : * which is not equal to what the cpufreq core thinks is
359 : : * "old frequency".
360 : : */
361 [ + - - + ]: 18074 : if (policy->cur && policy->cur != freqs->old) {
362 : : pr_debug("Warning: CPU frequency is %u, cpufreq assumed %u kHz\n",
363 : : freqs->old, policy->cur);
364 : 0 : freqs->old = policy->cur;
365 : : }
366 : :
367 : 18074 : srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
368 : : CPUFREQ_PRECHANGE, freqs);
369 : :
370 : : adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
371 : : break;
372 : :
373 : : case CPUFREQ_POSTCHANGE:
374 : : adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
375 : : pr_debug("FREQ: %u - CPUs: %*pbl\n", freqs->new,
376 : : cpumask_pr_args(policy->cpus));
377 : :
378 [ + + ]: 90370 : for_each_cpu(cpu, policy->cpus)
379 : 72296 : trace_cpu_frequency(freqs->new, cpu);
380 : :
381 : 18074 : srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
382 : : CPUFREQ_POSTCHANGE, freqs);
383 : :
384 : 18074 : cpufreq_stats_record_transition(policy, freqs->new);
385 : 18074 : policy->cur = freqs->new;
386 : : }
387 : : }
388 : :
389 : : /* Do post notifications when there are chances that transition has failed */
390 : 18074 : static void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
391 : : struct cpufreq_freqs *freqs, int transition_failed)
392 : : {
393 : 18074 : cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
394 [ - + ]: 18074 : if (!transition_failed)
395 : 18074 : return;
396 : :
397 : 0 : swap(freqs->old, freqs->new);
398 : 0 : cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
399 : 0 : cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
400 : : }
401 : :
402 : 18074 : void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
403 : : struct cpufreq_freqs *freqs)
404 : : {
405 : :
406 : : /*
407 : : * Catch double invocations of _begin() which lead to self-deadlock.
408 : : * ASYNC_NOTIFICATION drivers are left out because the cpufreq core
409 : : * doesn't invoke _begin() on their behalf, and hence the chances of
410 : : * double invocations are very low. Moreover, there are scenarios
411 : : * where these checks can emit false-positive warnings in these
412 : : * drivers; so we avoid that by skipping them altogether.
413 : : */
414 [ + - + - : 36148 : WARN_ON(!(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION)
- + ]
415 : : && current == policy->transition_task);
416 : :
417 : : wait:
418 [ - + # # ]: 18074 : wait_event(policy->transition_wait, !policy->transition_ongoing);
419 : :
420 : : spin_lock(&policy->transition_lock);
421 : :
422 [ - + ]: 18074 : if (unlikely(policy->transition_ongoing)) {
423 : : spin_unlock(&policy->transition_lock);
424 : : goto wait;
425 : : }
426 : :
427 : 18074 : policy->transition_ongoing = true;
428 : 18074 : policy->transition_task = current;
429 : :
430 : : spin_unlock(&policy->transition_lock);
431 : :
432 : 18074 : cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
433 : 18074 : }
434 : : EXPORT_SYMBOL_GPL(cpufreq_freq_transition_begin);
435 : :
436 : 18074 : void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
437 : : struct cpufreq_freqs *freqs, int transition_failed)
438 : : {
439 [ - + + - ]: 18074 : if (WARN_ON(!policy->transition_ongoing))
440 : 18074 : return;
441 : :
442 : 18074 : cpufreq_notify_post_transition(policy, freqs, transition_failed);
443 : :
444 : 18074 : policy->transition_ongoing = false;
445 : 18074 : policy->transition_task = NULL;
446 : :
447 : 18074 : wake_up(&policy->transition_wait);
448 : : }
449 : : EXPORT_SYMBOL_GPL(cpufreq_freq_transition_end);
450 : :
451 : : /*
452 : : * Fast frequency switching status count. Positive means "enabled", negative
453 : : * means "disabled" and 0 means "not decided yet".
454 : : */
455 : : static int cpufreq_fast_switch_count;
456 : : static DEFINE_MUTEX(cpufreq_fast_switch_lock);
457 : :
458 : 0 : static void cpufreq_list_transition_notifiers(void)
459 : : {
460 : : struct notifier_block *nb;
461 : :
462 : 0 : pr_info("Registered transition notifiers:\n");
463 : :
464 : 0 : mutex_lock(&cpufreq_transition_notifier_list.mutex);
465 : :
466 [ # # ]: 0 : for (nb = cpufreq_transition_notifier_list.head; nb; nb = nb->next)
467 : 0 : pr_info("%pS\n", nb->notifier_call);
468 : :
469 : 0 : mutex_unlock(&cpufreq_transition_notifier_list.mutex);
470 : 0 : }
471 : :
472 : : /**
473 : : * cpufreq_enable_fast_switch - Enable fast frequency switching for policy.
474 : : * @policy: cpufreq policy to enable fast frequency switching for.
475 : : *
476 : : * Try to enable fast frequency switching for @policy.
477 : : *
478 : : * The attempt will fail if there is at least one transition notifier registered
479 : : * at this point, as fast frequency switching is quite fundamentally at odds
480 : : * with transition notifiers. Thus if successful, it will make registration of
481 : : * transition notifiers fail going forward.
482 : : */
483 : 0 : void cpufreq_enable_fast_switch(struct cpufreq_policy *policy)
484 : : {
485 : : lockdep_assert_held(&policy->rwsem);
486 : :
487 [ # # ]: 0 : if (!policy->fast_switch_possible)
488 : 0 : return;
489 : :
490 : 0 : mutex_lock(&cpufreq_fast_switch_lock);
491 [ # # ]: 0 : if (cpufreq_fast_switch_count >= 0) {
492 : 0 : cpufreq_fast_switch_count++;
493 : 0 : policy->fast_switch_enabled = true;
494 : : } else {
495 : 0 : pr_warn("CPU%u: Fast frequency switching not enabled\n",
496 : : policy->cpu);
497 : 0 : cpufreq_list_transition_notifiers();
498 : : }
499 : 0 : mutex_unlock(&cpufreq_fast_switch_lock);
500 : : }
501 : : EXPORT_SYMBOL_GPL(cpufreq_enable_fast_switch);
502 : :
503 : : /**
504 : : * cpufreq_disable_fast_switch - Disable fast frequency switching for policy.
505 : : * @policy: cpufreq policy to disable fast frequency switching for.
506 : : */
507 : 0 : void cpufreq_disable_fast_switch(struct cpufreq_policy *policy)
508 : : {
509 : 0 : mutex_lock(&cpufreq_fast_switch_lock);
510 [ # # ]: 0 : if (policy->fast_switch_enabled) {
511 : 0 : policy->fast_switch_enabled = false;
512 [ # # # # ]: 0 : if (!WARN_ON(cpufreq_fast_switch_count <= 0))
513 : 0 : cpufreq_fast_switch_count--;
514 : : }
515 : 0 : mutex_unlock(&cpufreq_fast_switch_lock);
516 : 0 : }
517 : : EXPORT_SYMBOL_GPL(cpufreq_disable_fast_switch);
518 : :
519 : : /**
520 : : * cpufreq_driver_resolve_freq - Map a target frequency to a driver-supported
521 : : * one.
522 : : * @target_freq: target frequency to resolve.
523 : : *
524 : : * The target to driver frequency mapping is cached in the policy.
525 : : *
526 : : * Return: Lowest driver-supported frequency greater than or equal to the
527 : : * given target_freq, subject to policy (min/max) and driver limitations.
528 : : */
529 : 0 : unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
530 : : unsigned int target_freq)
531 : : {
532 : 0 : target_freq = clamp_val(target_freq, policy->min, policy->max);
533 : 0 : policy->cached_target_freq = target_freq;
534 : :
535 [ # # ]: 0 : if (cpufreq_driver->target_index) {
536 : : int idx;
537 : :
538 : 0 : idx = cpufreq_frequency_table_target(policy, target_freq,
539 : : CPUFREQ_RELATION_L);
540 : 0 : policy->cached_resolved_idx = idx;
541 : 0 : return policy->freq_table[idx].frequency;
542 : : }
543 : :
544 [ # # ]: 0 : if (cpufreq_driver->resolve_freq)
545 : 0 : return cpufreq_driver->resolve_freq(policy, target_freq);
546 : :
547 : : return target_freq;
548 : : }
549 : : EXPORT_SYMBOL_GPL(cpufreq_driver_resolve_freq);
550 : :
551 : 207 : unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy)
552 : : {
553 : : unsigned int latency;
554 : :
555 [ + - ]: 207 : if (policy->transition_delay_us)
556 : : return policy->transition_delay_us;
557 : :
558 : 207 : latency = policy->cpuinfo.transition_latency / NSEC_PER_USEC;
559 [ + - ]: 207 : if (latency) {
560 : : /*
561 : : * For platforms that can change the frequency very fast (< 10
562 : : * us), the above formula gives a decent transition delay. But
563 : : * for platforms where transition_latency is in milliseconds, it
564 : : * ends up giving unrealistic values.
565 : : *
566 : : * Cap the default transition delay to 10 ms, which seems to be
567 : : * a reasonable amount of time after which we should reevaluate
568 : : * the frequency.
569 : : */
570 : 207 : return min(latency * LATENCY_MULTIPLIER, (unsigned int)10000);
571 : : }
572 : :
573 : : return LATENCY_MULTIPLIER;
574 : : }
575 : : EXPORT_SYMBOL_GPL(cpufreq_policy_transition_delay_us);
576 : :
577 : : /*********************************************************************
578 : : * SYSFS INTERFACE *
579 : : *********************************************************************/
580 : 0 : static ssize_t show_boost(struct kobject *kobj,
581 : : struct kobj_attribute *attr, char *buf)
582 : : {
583 : 0 : return sprintf(buf, "%d\n", cpufreq_driver->boost_enabled);
584 : : }
585 : :
586 : 0 : static ssize_t store_boost(struct kobject *kobj, struct kobj_attribute *attr,
587 : : const char *buf, size_t count)
588 : : {
589 : : int ret, enable;
590 : :
591 : 0 : ret = sscanf(buf, "%d", &enable);
592 [ # # # # : 0 : if (ret != 1 || enable < 0 || enable > 1)
# # ]
593 : : return -EINVAL;
594 : :
595 [ # # ]: 0 : if (cpufreq_boost_trigger_state(enable)) {
596 [ # # ]: 0 : pr_err("%s: Cannot %s BOOST!\n",
597 : : __func__, enable ? "enable" : "disable");
598 : 0 : return -EINVAL;
599 : : }
600 : :
601 : : pr_debug("%s: cpufreq BOOST %s\n",
602 : : __func__, enable ? "enabled" : "disabled");
603 : :
604 : 0 : return count;
605 : : }
606 : : define_one_global_rw(boost);
607 : :
608 : 1656 : static struct cpufreq_governor *find_governor(const char *str_governor)
609 : : {
610 : : struct cpufreq_governor *t;
611 : :
612 [ + + ]: 6210 : for_each_governor(t)
613 [ + + ]: 4761 : if (!strncasecmp(str_governor, t->name, CPUFREQ_NAME_LEN))
614 : 207 : return t;
615 : :
616 : : return NULL;
617 : : }
618 : :
619 : 414 : static struct cpufreq_governor *get_governor(const char *str_governor)
620 : : {
621 : : struct cpufreq_governor *t;
622 : :
623 : 414 : mutex_lock(&cpufreq_governor_mutex);
624 : 414 : t = find_governor(str_governor);
625 [ + + ]: 414 : if (!t)
626 : : goto unlock;
627 : :
628 [ - + ]: 207 : if (!try_module_get(t->owner))
629 : : t = NULL;
630 : :
631 : : unlock:
632 : 414 : mutex_unlock(&cpufreq_governor_mutex);
633 : :
634 : 414 : return t;
635 : : }
636 : :
637 : 0 : static unsigned int cpufreq_parse_policy(char *str_governor)
638 : : {
639 [ # # ]: 0 : if (!strncasecmp(str_governor, "performance", CPUFREQ_NAME_LEN))
640 : : return CPUFREQ_POLICY_PERFORMANCE;
641 : :
642 [ # # ]: 0 : if (!strncasecmp(str_governor, "powersave", CPUFREQ_NAME_LEN))
643 : : return CPUFREQ_POLICY_POWERSAVE;
644 : :
645 : 0 : return CPUFREQ_POLICY_UNKNOWN;
646 : : }
647 : :
648 : : /**
649 : : * cpufreq_parse_governor - parse a governor string only for has_target()
650 : : * @str_governor: Governor name.
651 : : */
652 : 207 : static struct cpufreq_governor *cpufreq_parse_governor(char *str_governor)
653 : : {
654 : : struct cpufreq_governor *t;
655 : :
656 : 207 : t = get_governor(str_governor);
657 [ - + ]: 207 : if (t)
658 : : return t;
659 : :
660 [ # # ]: 0 : if (request_module("cpufreq_%s", str_governor))
661 : : return NULL;
662 : :
663 : 0 : return get_governor(str_governor);
664 : : }
665 : :
666 : : /**
667 : : * cpufreq_per_cpu_attr_read() / show_##file_name() -
668 : : * print out cpufreq information
669 : : *
670 : : * Write out information from cpufreq_driver->policy[cpu]; object must be
671 : : * "unsigned int".
672 : : */
673 : :
674 : : #define show_one(file_name, object) \
675 : : static ssize_t show_##file_name \
676 : : (struct cpufreq_policy *policy, char *buf) \
677 : : { \
678 : : return sprintf(buf, "%u\n", policy->object); \
679 : : }
680 : :
681 : 0 : show_one(cpuinfo_min_freq, cpuinfo.min_freq);
682 : 0 : show_one(cpuinfo_max_freq, cpuinfo.max_freq);
683 : 0 : show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
684 : 0 : show_one(scaling_min_freq, min);
685 : 0 : show_one(scaling_max_freq, max);
686 : :
687 : 0 : __weak unsigned int arch_freq_get_on_cpu(int cpu)
688 : : {
689 : 0 : return 0;
690 : : }
691 : :
692 : 0 : static ssize_t show_scaling_cur_freq(struct cpufreq_policy *policy, char *buf)
693 : : {
694 : : ssize_t ret;
695 : : unsigned int freq;
696 : :
697 : 0 : freq = arch_freq_get_on_cpu(policy->cpu);
698 [ # # ]: 0 : if (freq)
699 : 0 : ret = sprintf(buf, "%u\n", freq);
700 [ # # # # : 0 : else if (cpufreq_driver && cpufreq_driver->setpolicy &&
# # ]
701 : 0 : cpufreq_driver->get)
702 : 0 : ret = sprintf(buf, "%u\n", cpufreq_driver->get(policy->cpu));
703 : : else
704 : 0 : ret = sprintf(buf, "%u\n", policy->cur);
705 : 0 : return ret;
706 : : }
707 : :
708 : : /**
709 : : * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
710 : : */
711 : : #define store_one(file_name, object) \
712 : : static ssize_t store_##file_name \
713 : : (struct cpufreq_policy *policy, const char *buf, size_t count) \
714 : : { \
715 : : unsigned long val; \
716 : : int ret; \
717 : : \
718 : : ret = sscanf(buf, "%lu", &val); \
719 : : if (ret != 1) \
720 : : return -EINVAL; \
721 : : \
722 : : ret = freq_qos_update_request(policy->object##_freq_req, val);\
723 : : return ret >= 0 ? count : ret; \
724 : : }
725 : :
726 [ # # # # ]: 0 : store_one(scaling_min_freq, min);
727 [ # # # # ]: 0 : store_one(scaling_max_freq, max);
728 : :
729 : : /**
730 : : * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
731 : : */
732 : 0 : static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
733 : : char *buf)
734 : : {
735 : 0 : unsigned int cur_freq = __cpufreq_get(policy);
736 : :
737 [ # # ]: 0 : if (cur_freq)
738 : 0 : return sprintf(buf, "%u\n", cur_freq);
739 : :
740 : 0 : return sprintf(buf, "<unknown>\n");
741 : : }
742 : :
743 : : /**
744 : : * show_scaling_governor - show the current policy for the specified CPU
745 : : */
746 : 0 : static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
747 : : {
748 [ # # ]: 0 : if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
749 : 0 : return sprintf(buf, "powersave\n");
750 [ # # ]: 0 : else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
751 : 0 : return sprintf(buf, "performance\n");
752 [ # # ]: 0 : else if (policy->governor)
753 : 0 : return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
754 : 0 : policy->governor->name);
755 : : return -EINVAL;
756 : : }
757 : :
758 : : /**
759 : : * store_scaling_governor - store policy for the specified CPU
760 : : */
761 : 207 : static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
762 : : const char *buf, size_t count)
763 : : {
764 : : char str_governor[16];
765 : : int ret;
766 : :
767 : 207 : ret = sscanf(buf, "%15s", str_governor);
768 [ + - ]: 207 : if (ret != 1)
769 : : return -EINVAL;
770 : :
771 [ - + ]: 207 : if (cpufreq_driver->setpolicy) {
772 : : unsigned int new_pol;
773 : :
774 : 0 : new_pol = cpufreq_parse_policy(str_governor);
775 [ # # ]: 0 : if (!new_pol)
776 : : return -EINVAL;
777 : :
778 : 0 : ret = cpufreq_set_policy(policy, NULL, new_pol);
779 : : } else {
780 : : struct cpufreq_governor *new_gov;
781 : :
782 : 207 : new_gov = cpufreq_parse_governor(str_governor);
783 [ + - ]: 207 : if (!new_gov)
784 : : return -EINVAL;
785 : :
786 : 207 : ret = cpufreq_set_policy(policy, new_gov,
787 : : CPUFREQ_POLICY_UNKNOWN);
788 : :
789 : 207 : module_put(new_gov->owner);
790 : : }
791 : :
792 [ + - ]: 207 : return ret ? ret : count;
793 : : }
794 : :
795 : : /**
796 : : * show_scaling_driver - show the cpufreq driver currently loaded
797 : : */
798 : 0 : static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
799 : : {
800 : 0 : return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
801 : : }
802 : :
803 : : /**
804 : : * show_scaling_available_governors - show the available CPUfreq governors
805 : : */
806 : 0 : static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
807 : : char *buf)
808 : : {
809 : : ssize_t i = 0;
810 : : struct cpufreq_governor *t;
811 : :
812 [ # # ]: 0 : if (!has_target()) {
813 : 0 : i += sprintf(buf, "performance powersave");
814 : 0 : goto out;
815 : : }
816 : :
817 : 0 : mutex_lock(&cpufreq_governor_mutex);
818 [ # # ]: 0 : for_each_governor(t) {
819 [ # # ]: 0 : if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
820 : : - (CPUFREQ_NAME_LEN + 2)))
821 : : break;
822 : 0 : i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
823 : : }
824 : 0 : mutex_unlock(&cpufreq_governor_mutex);
825 : : out:
826 : 0 : i += sprintf(&buf[i], "\n");
827 : 0 : return i;
828 : : }
829 : :
830 : 0 : ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
831 : : {
832 : : ssize_t i = 0;
833 : : unsigned int cpu;
834 : :
835 [ # # ]: 0 : for_each_cpu(cpu, mask) {
836 [ # # ]: 0 : if (i)
837 : 0 : i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
838 : 0 : i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
839 [ # # ]: 0 : if (i >= (PAGE_SIZE - 5))
840 : : break;
841 : : }
842 : 0 : i += sprintf(&buf[i], "\n");
843 : 0 : return i;
844 : : }
845 : : EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
846 : :
847 : : /**
848 : : * show_related_cpus - show the CPUs affected by each transition even if
849 : : * hw coordination is in use
850 : : */
851 : 0 : static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
852 : : {
853 : 0 : return cpufreq_show_cpus(policy->related_cpus, buf);
854 : : }
855 : :
856 : : /**
857 : : * show_affected_cpus - show the CPUs affected by each transition
858 : : */
859 : 0 : static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
860 : : {
861 : 0 : return cpufreq_show_cpus(policy->cpus, buf);
862 : : }
863 : :
864 : 0 : static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
865 : : const char *buf, size_t count)
866 : : {
867 : 0 : unsigned int freq = 0;
868 : : unsigned int ret;
869 : :
870 [ # # # # ]: 0 : if (!policy->governor || !policy->governor->store_setspeed)
871 : : return -EINVAL;
872 : :
873 : 0 : ret = sscanf(buf, "%u", &freq);
874 [ # # ]: 0 : if (ret != 1)
875 : : return -EINVAL;
876 : :
877 : 0 : policy->governor->store_setspeed(policy, freq);
878 : :
879 : 0 : return count;
880 : : }
881 : :
882 : 0 : static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
883 : : {
884 [ # # # # ]: 0 : if (!policy->governor || !policy->governor->show_setspeed)
885 : 0 : return sprintf(buf, "<unsupported>\n");
886 : :
887 : 0 : return policy->governor->show_setspeed(policy, buf);
888 : : }
889 : :
890 : : /**
891 : : * show_bios_limit - show the current cpufreq HW/BIOS limitation
892 : : */
893 : 0 : static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
894 : : {
895 : : unsigned int limit;
896 : : int ret;
897 : 0 : ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
898 [ # # ]: 0 : if (!ret)
899 : 0 : return sprintf(buf, "%u\n", limit);
900 : 0 : return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
901 : : }
902 : :
903 : : cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
904 : : cpufreq_freq_attr_ro(cpuinfo_min_freq);
905 : : cpufreq_freq_attr_ro(cpuinfo_max_freq);
906 : : cpufreq_freq_attr_ro(cpuinfo_transition_latency);
907 : : cpufreq_freq_attr_ro(scaling_available_governors);
908 : : cpufreq_freq_attr_ro(scaling_driver);
909 : : cpufreq_freq_attr_ro(scaling_cur_freq);
910 : : cpufreq_freq_attr_ro(bios_limit);
911 : : cpufreq_freq_attr_ro(related_cpus);
912 : : cpufreq_freq_attr_ro(affected_cpus);
913 : : cpufreq_freq_attr_rw(scaling_min_freq);
914 : : cpufreq_freq_attr_rw(scaling_max_freq);
915 : : cpufreq_freq_attr_rw(scaling_governor);
916 : : cpufreq_freq_attr_rw(scaling_setspeed);
917 : :
918 : : static struct attribute *default_attrs[] = {
919 : : &cpuinfo_min_freq.attr,
920 : : &cpuinfo_max_freq.attr,
921 : : &cpuinfo_transition_latency.attr,
922 : : &scaling_min_freq.attr,
923 : : &scaling_max_freq.attr,
924 : : &affected_cpus.attr,
925 : : &related_cpus.attr,
926 : : &scaling_governor.attr,
927 : : &scaling_driver.attr,
928 : : &scaling_available_governors.attr,
929 : : &scaling_setspeed.attr,
930 : : NULL
931 : : };
932 : :
933 : : #define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
934 : : #define to_attr(a) container_of(a, struct freq_attr, attr)
935 : :
936 : 0 : static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
937 : : {
938 : 0 : struct cpufreq_policy *policy = to_policy(kobj);
939 : : struct freq_attr *fattr = to_attr(attr);
940 : : ssize_t ret;
941 : :
942 [ # # ]: 0 : if (!fattr->show)
943 : : return -EIO;
944 : :
945 : 0 : down_read(&policy->rwsem);
946 : 0 : ret = fattr->show(policy, buf);
947 : 0 : up_read(&policy->rwsem);
948 : :
949 : 0 : return ret;
950 : : }
951 : :
952 : 207 : static ssize_t store(struct kobject *kobj, struct attribute *attr,
953 : : const char *buf, size_t count)
954 : : {
955 : 207 : struct cpufreq_policy *policy = to_policy(kobj);
956 : : struct freq_attr *fattr = to_attr(attr);
957 : : ssize_t ret = -EINVAL;
958 : :
959 [ + - ]: 207 : if (!fattr->store)
960 : : return -EIO;
961 : :
962 : : /*
963 : : * cpus_read_trylock() is used here to work around a circular lock
964 : : * dependency problem with respect to the cpufreq_register_driver().
965 : : */
966 : : if (!cpus_read_trylock())
967 : : return -EBUSY;
968 : :
969 [ + - ]: 414 : if (cpu_online(policy->cpu)) {
970 : 207 : down_write(&policy->rwsem);
971 : 207 : ret = fattr->store(policy, buf, count);
972 : 207 : up_write(&policy->rwsem);
973 : : }
974 : :
975 : : cpus_read_unlock();
976 : :
977 : 207 : return ret;
978 : : }
979 : :
980 : 0 : static void cpufreq_sysfs_release(struct kobject *kobj)
981 : : {
982 : : struct cpufreq_policy *policy = to_policy(kobj);
983 : : pr_debug("last reference is dropped\n");
984 : 0 : complete(&policy->kobj_unregister);
985 : 0 : }
986 : :
987 : : static const struct sysfs_ops sysfs_ops = {
988 : : .show = show,
989 : : .store = store,
990 : : };
991 : :
992 : : static struct kobj_type ktype_cpufreq = {
993 : : .sysfs_ops = &sysfs_ops,
994 : : .default_attrs = default_attrs,
995 : : .release = cpufreq_sysfs_release,
996 : : };
997 : :
998 : 1656 : static void add_cpu_dev_symlink(struct cpufreq_policy *policy, unsigned int cpu)
999 : : {
1000 : 1656 : struct device *dev = get_cpu_device(cpu);
1001 : :
1002 [ + - ]: 1656 : if (unlikely(!dev))
1003 : : return;
1004 : :
1005 [ + + ]: 3312 : if (cpumask_test_and_set_cpu(cpu, policy->real_cpus))
1006 : : return;
1007 : :
1008 : : dev_dbg(dev, "%s: Adding symlink\n", __func__);
1009 [ - + ]: 828 : if (sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq"))
1010 : 0 : dev_err(dev, "cpufreq symlink creation failed\n");
1011 : : }
1012 : :
1013 : : static void remove_cpu_dev_symlink(struct cpufreq_policy *policy,
1014 : : struct device *dev)
1015 : : {
1016 : : dev_dbg(dev, "%s: Removing symlink\n", __func__);
1017 : 0 : sysfs_remove_link(&dev->kobj, "cpufreq");
1018 : : }
1019 : :
1020 : 207 : static int cpufreq_add_dev_interface(struct cpufreq_policy *policy)
1021 : : {
1022 : : struct freq_attr **drv_attr;
1023 : : int ret = 0;
1024 : :
1025 : : /* set up files for this cpu device */
1026 : 207 : drv_attr = cpufreq_driver->attr;
1027 [ + - + + ]: 621 : while (drv_attr && *drv_attr) {
1028 : 207 : ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
1029 [ - + ]: 207 : if (ret)
1030 : 0 : return ret;
1031 : 207 : drv_attr++;
1032 : : }
1033 [ + - ]: 207 : if (cpufreq_driver->get) {
1034 : 207 : ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
1035 [ + - ]: 207 : if (ret)
1036 : : return ret;
1037 : : }
1038 : :
1039 : 207 : ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
1040 [ + - ]: 207 : if (ret)
1041 : : return ret;
1042 : :
1043 [ - + ]: 207 : if (cpufreq_driver->bios_limit) {
1044 : : ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
1045 [ # # ]: 0 : if (ret)
1046 : 0 : return ret;
1047 : : }
1048 : :
1049 : : return 0;
1050 : : }
1051 : :
1052 : 0 : __weak struct cpufreq_governor *cpufreq_default_governor(void)
1053 : : {
1054 : 0 : return NULL;
1055 : : }
1056 : :
1057 : 207 : static int cpufreq_init_policy(struct cpufreq_policy *policy)
1058 : : {
1059 : 207 : struct cpufreq_governor *def_gov = cpufreq_default_governor();
1060 : : struct cpufreq_governor *gov = NULL;
1061 : : unsigned int pol = CPUFREQ_POLICY_UNKNOWN;
1062 : : int ret;
1063 : :
1064 [ + - ]: 207 : if (has_target()) {
1065 : : /* Update policy governor to the one used before hotplug. */
1066 : 207 : gov = get_governor(policy->last_governor);
1067 [ + - ]: 207 : if (gov) {
1068 : : pr_debug("Restoring governor %s for cpu %d\n",
1069 : : policy->governor->name, policy->cpu);
1070 [ + - ]: 207 : } else if (def_gov) {
1071 : : gov = def_gov;
1072 : 207 : __module_get(gov->owner);
1073 : : } else {
1074 : : return -ENODATA;
1075 : : }
1076 : : } else {
1077 : : /* Use the default policy if there is no last_policy. */
1078 [ # # ]: 0 : if (policy->last_policy) {
1079 : : pol = policy->last_policy;
1080 [ # # ]: 0 : } else if (def_gov) {
1081 : 0 : pol = cpufreq_parse_policy(def_gov->name);
1082 : : /*
1083 : : * In case the default governor is neiter "performance"
1084 : : * nor "powersave", fall back to the initial policy
1085 : : * value set by the driver.
1086 : : */
1087 [ # # ]: 0 : if (pol == CPUFREQ_POLICY_UNKNOWN)
1088 : 0 : pol = policy->policy;
1089 : : }
1090 [ # # ]: 0 : if (pol != CPUFREQ_POLICY_PERFORMANCE &&
1091 : : pol != CPUFREQ_POLICY_POWERSAVE)
1092 : : return -ENODATA;
1093 : : }
1094 : :
1095 : 207 : ret = cpufreq_set_policy(policy, gov, pol);
1096 [ + - ]: 207 : if (gov)
1097 : 207 : module_put(gov->owner);
1098 : :
1099 : 207 : return ret;
1100 : : }
1101 : :
1102 : 621 : static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
1103 : : {
1104 : : int ret = 0;
1105 : :
1106 : : /* Has this CPU been taken care of already? */
1107 [ - + ]: 1242 : if (cpumask_test_cpu(cpu, policy->cpus))
1108 : : return 0;
1109 : :
1110 : 0 : down_write(&policy->rwsem);
1111 [ # # ]: 0 : if (has_target())
1112 : : cpufreq_stop_governor(policy);
1113 : :
1114 : : cpumask_set_cpu(cpu, policy->cpus);
1115 : :
1116 [ # # ]: 0 : if (has_target()) {
1117 : 0 : ret = cpufreq_start_governor(policy);
1118 [ # # ]: 0 : if (ret)
1119 : 0 : pr_err("%s: Failed to start governor\n", __func__);
1120 : : }
1121 : 0 : up_write(&policy->rwsem);
1122 : 0 : return ret;
1123 : : }
1124 : :
1125 : 414 : void refresh_frequency_limits(struct cpufreq_policy *policy)
1126 : : {
1127 [ + - ]: 414 : if (!policy_is_inactive(policy)) {
1128 : : pr_debug("updating policy for CPU %u\n", policy->cpu);
1129 : :
1130 : 414 : cpufreq_set_policy(policy, policy->governor, policy->policy);
1131 : : }
1132 : 414 : }
1133 : : EXPORT_SYMBOL(refresh_frequency_limits);
1134 : :
1135 : 414 : static void handle_update(struct work_struct *work)
1136 : : {
1137 : : struct cpufreq_policy *policy =
1138 : 414 : container_of(work, struct cpufreq_policy, update);
1139 : :
1140 : : pr_debug("handle_update for cpu %u called\n", policy->cpu);
1141 : 414 : down_write(&policy->rwsem);
1142 : 414 : refresh_frequency_limits(policy);
1143 : 414 : up_write(&policy->rwsem);
1144 : 414 : }
1145 : :
1146 : 207 : static int cpufreq_notifier_min(struct notifier_block *nb, unsigned long freq,
1147 : : void *data)
1148 : : {
1149 : : struct cpufreq_policy *policy = container_of(nb, struct cpufreq_policy, nb_min);
1150 : :
1151 : 207 : schedule_work(&policy->update);
1152 : 207 : return 0;
1153 : : }
1154 : :
1155 : 207 : static int cpufreq_notifier_max(struct notifier_block *nb, unsigned long freq,
1156 : : void *data)
1157 : : {
1158 : : struct cpufreq_policy *policy = container_of(nb, struct cpufreq_policy, nb_max);
1159 : :
1160 : 207 : schedule_work(&policy->update);
1161 : 207 : return 0;
1162 : : }
1163 : :
1164 : 0 : static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy)
1165 : : {
1166 : : struct kobject *kobj;
1167 : : struct completion *cmp;
1168 : :
1169 : 0 : down_write(&policy->rwsem);
1170 : 0 : cpufreq_stats_free_table(policy);
1171 : 0 : kobj = &policy->kobj;
1172 : 0 : cmp = &policy->kobj_unregister;
1173 : 0 : up_write(&policy->rwsem);
1174 : 0 : kobject_put(kobj);
1175 : :
1176 : : /*
1177 : : * We need to make sure that the underlying kobj is
1178 : : * actually not referenced anymore by anybody before we
1179 : : * proceed with unloading.
1180 : : */
1181 : : pr_debug("waiting for dropping of refcount\n");
1182 : 0 : wait_for_completion(cmp);
1183 : : pr_debug("wait complete\n");
1184 : 0 : }
1185 : :
1186 : 207 : static struct cpufreq_policy *cpufreq_policy_alloc(unsigned int cpu)
1187 : : {
1188 : : struct cpufreq_policy *policy;
1189 : 207 : struct device *dev = get_cpu_device(cpu);
1190 : : int ret;
1191 : :
1192 [ + - ]: 207 : if (!dev)
1193 : : return NULL;
1194 : :
1195 : 207 : policy = kzalloc(sizeof(*policy), GFP_KERNEL);
1196 [ + - ]: 207 : if (!policy)
1197 : : return NULL;
1198 : :
1199 : : if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
1200 : : goto err_free_policy;
1201 : :
1202 : : if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
1203 : : goto err_free_cpumask;
1204 : :
1205 : : if (!zalloc_cpumask_var(&policy->real_cpus, GFP_KERNEL))
1206 : : goto err_free_rcpumask;
1207 : :
1208 : 207 : ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
1209 : : cpufreq_global_kobject, "policy%u", cpu);
1210 [ - + ]: 207 : if (ret) {
1211 : 0 : dev_err(dev, "%s: failed to init policy->kobj: %d\n", __func__, ret);
1212 : : /*
1213 : : * The entire policy object will be freed below, but the extra
1214 : : * memory allocated for the kobject name needs to be freed by
1215 : : * releasing the kobject.
1216 : : */
1217 : 0 : kobject_put(&policy->kobj);
1218 : 0 : goto err_free_real_cpus;
1219 : : }
1220 : :
1221 : 207 : freq_constraints_init(&policy->constraints);
1222 : :
1223 : 207 : policy->nb_min.notifier_call = cpufreq_notifier_min;
1224 : 207 : policy->nb_max.notifier_call = cpufreq_notifier_max;
1225 : :
1226 : 207 : ret = freq_qos_add_notifier(&policy->constraints, FREQ_QOS_MIN,
1227 : : &policy->nb_min);
1228 [ - + ]: 207 : if (ret) {
1229 : 0 : dev_err(dev, "Failed to register MIN QoS notifier: %d (%*pbl)\n",
1230 : : ret, cpumask_pr_args(policy->cpus));
1231 : 0 : goto err_kobj_remove;
1232 : : }
1233 : :
1234 : 207 : ret = freq_qos_add_notifier(&policy->constraints, FREQ_QOS_MAX,
1235 : : &policy->nb_max);
1236 [ - + ]: 207 : if (ret) {
1237 : 0 : dev_err(dev, "Failed to register MAX QoS notifier: %d (%*pbl)\n",
1238 : : ret, cpumask_pr_args(policy->cpus));
1239 : : goto err_min_qos_notifier;
1240 : : }
1241 : :
1242 : 207 : INIT_LIST_HEAD(&policy->policy_list);
1243 : 207 : init_rwsem(&policy->rwsem);
1244 : 207 : spin_lock_init(&policy->transition_lock);
1245 : 207 : init_waitqueue_head(&policy->transition_wait);
1246 : : init_completion(&policy->kobj_unregister);
1247 : 414 : INIT_WORK(&policy->update, handle_update);
1248 : :
1249 : 207 : policy->cpu = cpu;
1250 : 207 : return policy;
1251 : :
1252 : : err_min_qos_notifier:
1253 : 0 : freq_qos_remove_notifier(&policy->constraints, FREQ_QOS_MIN,
1254 : : &policy->nb_min);
1255 : : err_kobj_remove:
1256 : 0 : cpufreq_policy_put_kobj(policy);
1257 : : err_free_real_cpus:
1258 : : free_cpumask_var(policy->real_cpus);
1259 : : err_free_rcpumask:
1260 : : free_cpumask_var(policy->related_cpus);
1261 : : err_free_cpumask:
1262 : : free_cpumask_var(policy->cpus);
1263 : : err_free_policy:
1264 : 0 : kfree(policy);
1265 : :
1266 : 0 : return NULL;
1267 : : }
1268 : :
1269 : 0 : static void cpufreq_policy_free(struct cpufreq_policy *policy)
1270 : : {
1271 : : unsigned long flags;
1272 : : int cpu;
1273 : :
1274 : : /* Remove policy from list */
1275 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1276 : : list_del(&policy->policy_list);
1277 : :
1278 [ # # ]: 0 : for_each_cpu(cpu, policy->related_cpus)
1279 : 0 : per_cpu(cpufreq_cpu_data, cpu) = NULL;
1280 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1281 : :
1282 : 0 : freq_qos_remove_notifier(&policy->constraints, FREQ_QOS_MAX,
1283 : : &policy->nb_max);
1284 : 0 : freq_qos_remove_notifier(&policy->constraints, FREQ_QOS_MIN,
1285 : : &policy->nb_min);
1286 : :
1287 : : /* Cancel any pending policy->update work before freeing the policy. */
1288 : 0 : cancel_work_sync(&policy->update);
1289 : :
1290 [ # # ]: 0 : if (policy->max_freq_req) {
1291 : : /*
1292 : : * CPUFREQ_CREATE_POLICY notification is sent only after
1293 : : * successfully adding max_freq_req request.
1294 : : */
1295 : 0 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1296 : : CPUFREQ_REMOVE_POLICY, policy);
1297 : 0 : freq_qos_remove_request(policy->max_freq_req);
1298 : : }
1299 : :
1300 : 0 : freq_qos_remove_request(policy->min_freq_req);
1301 : 0 : kfree(policy->min_freq_req);
1302 : :
1303 : 0 : cpufreq_policy_put_kobj(policy);
1304 : : free_cpumask_var(policy->real_cpus);
1305 : : free_cpumask_var(policy->related_cpus);
1306 : : free_cpumask_var(policy->cpus);
1307 : 0 : kfree(policy);
1308 : 0 : }
1309 : :
1310 : 828 : static int cpufreq_online(unsigned int cpu)
1311 : : {
1312 : : struct cpufreq_policy *policy;
1313 : : bool new_policy;
1314 : : unsigned long flags;
1315 : : unsigned int j;
1316 : : int ret;
1317 : :
1318 : : pr_debug("%s: bringing CPU%u online\n", __func__, cpu);
1319 : :
1320 : : /* Check if this CPU already has a policy to manage it */
1321 : 828 : policy = per_cpu(cpufreq_cpu_data, cpu);
1322 [ + + ]: 828 : if (policy) {
1323 [ - + ]: 1242 : WARN_ON(!cpumask_test_cpu(cpu, policy->related_cpus));
1324 [ + - ]: 621 : if (!policy_is_inactive(policy))
1325 : 621 : return cpufreq_add_policy_cpu(policy, cpu);
1326 : :
1327 : : /* This is the only online CPU for the policy. Start over. */
1328 : : new_policy = false;
1329 : 0 : down_write(&policy->rwsem);
1330 : 0 : policy->cpu = cpu;
1331 : 0 : policy->governor = NULL;
1332 : 0 : up_write(&policy->rwsem);
1333 : : } else {
1334 : : new_policy = true;
1335 : 207 : policy = cpufreq_policy_alloc(cpu);
1336 [ + - ]: 207 : if (!policy)
1337 : : return -ENOMEM;
1338 : : }
1339 : :
1340 [ - + # # ]: 207 : if (!new_policy && cpufreq_driver->online) {
1341 : 0 : ret = cpufreq_driver->online(policy);
1342 [ # # ]: 0 : if (ret) {
1343 : : pr_debug("%s: %d: initialization failed\n", __func__,
1344 : : __LINE__);
1345 : : goto out_exit_policy;
1346 : : }
1347 : :
1348 : : /* Recover policy->cpus using related_cpus */
1349 : : cpumask_copy(policy->cpus, policy->related_cpus);
1350 : : } else {
1351 : : cpumask_copy(policy->cpus, cpumask_of(cpu));
1352 : :
1353 : : /*
1354 : : * Call driver. From then on the cpufreq must be able
1355 : : * to accept all calls to ->verify and ->setpolicy for this CPU.
1356 : : */
1357 : 207 : ret = cpufreq_driver->init(policy);
1358 [ + - ]: 207 : if (ret) {
1359 : : pr_debug("%s: %d: initialization failed\n", __func__,
1360 : : __LINE__);
1361 : : goto out_free_policy;
1362 : : }
1363 : :
1364 : 207 : ret = cpufreq_table_validate_and_sort(policy);
1365 [ + - ]: 207 : if (ret)
1366 : : goto out_exit_policy;
1367 : :
1368 : : /* related_cpus should at least include policy->cpus. */
1369 : : cpumask_copy(policy->related_cpus, policy->cpus);
1370 : : }
1371 : :
1372 : 207 : down_write(&policy->rwsem);
1373 : : /*
1374 : : * affected cpus must always be the one, which are online. We aren't
1375 : : * managing offline cpus here.
1376 : : */
1377 : : cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1378 : :
1379 [ + - ]: 207 : if (new_policy) {
1380 [ + + ]: 1035 : for_each_cpu(j, policy->related_cpus) {
1381 : 828 : per_cpu(cpufreq_cpu_data, j) = policy;
1382 : 828 : add_cpu_dev_symlink(policy, j);
1383 : : }
1384 : :
1385 : 207 : policy->min_freq_req = kzalloc(2 * sizeof(*policy->min_freq_req),
1386 : : GFP_KERNEL);
1387 [ + - ]: 207 : if (!policy->min_freq_req)
1388 : : goto out_destroy_policy;
1389 : :
1390 : 414 : ret = freq_qos_add_request(&policy->constraints,
1391 : : policy->min_freq_req, FREQ_QOS_MIN,
1392 : 207 : policy->min);
1393 [ - + ]: 207 : if (ret < 0) {
1394 : : /*
1395 : : * So we don't call freq_qos_remove_request() for an
1396 : : * uninitialized request.
1397 : : */
1398 : 0 : kfree(policy->min_freq_req);
1399 : 0 : policy->min_freq_req = NULL;
1400 : 0 : goto out_destroy_policy;
1401 : : }
1402 : :
1403 : : /*
1404 : : * This must be initialized right here to avoid calling
1405 : : * freq_qos_remove_request() on uninitialized request in case
1406 : : * of errors.
1407 : : */
1408 : 207 : policy->max_freq_req = policy->min_freq_req + 1;
1409 : :
1410 : 207 : ret = freq_qos_add_request(&policy->constraints,
1411 : : policy->max_freq_req, FREQ_QOS_MAX,
1412 : 207 : policy->max);
1413 [ - + ]: 207 : if (ret < 0) {
1414 : 0 : policy->max_freq_req = NULL;
1415 : 0 : goto out_destroy_policy;
1416 : : }
1417 : :
1418 : 207 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1419 : : CPUFREQ_CREATE_POLICY, policy);
1420 : : }
1421 : :
1422 [ + - + - ]: 414 : if (cpufreq_driver->get && has_target()) {
1423 : 207 : policy->cur = cpufreq_driver->get(policy->cpu);
1424 [ - + ]: 207 : if (!policy->cur) {
1425 : 0 : pr_err("%s: ->get() failed\n", __func__);
1426 : 0 : goto out_destroy_policy;
1427 : : }
1428 : : }
1429 : :
1430 : : /*
1431 : : * Sometimes boot loaders set CPU frequency to a value outside of
1432 : : * frequency table present with cpufreq core. In such cases CPU might be
1433 : : * unstable if it has to run on that frequency for long duration of time
1434 : : * and so its better to set it to a frequency which is specified in
1435 : : * freq-table. This also makes cpufreq stats inconsistent as
1436 : : * cpufreq-stats would fail to register because current frequency of CPU
1437 : : * isn't found in freq-table.
1438 : : *
1439 : : * Because we don't want this change to effect boot process badly, we go
1440 : : * for the next freq which is >= policy->cur ('cur' must be set by now,
1441 : : * otherwise we will end up setting freq to lowest of the table as 'cur'
1442 : : * is initialized to zero).
1443 : : *
1444 : : * We are passing target-freq as "policy->cur - 1" otherwise
1445 : : * __cpufreq_driver_target() would simply fail, as policy->cur will be
1446 : : * equal to target-freq.
1447 : : */
1448 [ + - ]: 207 : if ((cpufreq_driver->flags & CPUFREQ_NEED_INITIAL_FREQ_CHECK)
1449 [ + - ]: 207 : && has_target()) {
1450 : : /* Are we running at unknown frequency ? */
1451 : 207 : ret = cpufreq_frequency_table_get_index(policy, policy->cur);
1452 [ - + ]: 207 : if (ret == -EINVAL) {
1453 : : /* Warn user and fix it */
1454 : 0 : pr_warn("%s: CPU%d: Running at unlisted freq: %u KHz\n",
1455 : : __func__, policy->cpu, policy->cur);
1456 : 0 : ret = __cpufreq_driver_target(policy, policy->cur - 1,
1457 : : CPUFREQ_RELATION_L);
1458 : :
1459 : : /*
1460 : : * Reaching here after boot in a few seconds may not
1461 : : * mean that system will remain stable at "unknown"
1462 : : * frequency for longer duration. Hence, a BUG_ON().
1463 : : */
1464 [ # # ]: 0 : BUG_ON(ret);
1465 : 0 : pr_warn("%s: CPU%d: Unlisted initial frequency changed to: %u KHz\n",
1466 : : __func__, policy->cpu, policy->cur);
1467 : : }
1468 : : }
1469 : :
1470 [ + - ]: 207 : if (new_policy) {
1471 : 207 : ret = cpufreq_add_dev_interface(policy);
1472 [ + - ]: 207 : if (ret)
1473 : : goto out_destroy_policy;
1474 : :
1475 : 207 : cpufreq_stats_create_table(policy);
1476 : :
1477 : 207 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1478 : 207 : list_add(&policy->policy_list, &cpufreq_policy_list);
1479 : 207 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1480 : : }
1481 : :
1482 : 207 : ret = cpufreq_init_policy(policy);
1483 [ - + ]: 207 : if (ret) {
1484 : 0 : pr_err("%s: Failed to initialize policy for cpu: %d (%d)\n",
1485 : : __func__, cpu, ret);
1486 : 0 : goto out_destroy_policy;
1487 : : }
1488 : :
1489 : 207 : up_write(&policy->rwsem);
1490 : :
1491 : 207 : kobject_uevent(&policy->kobj, KOBJ_ADD);
1492 : :
1493 : : /* Callback for handling stuff after policy is ready */
1494 [ - + ]: 207 : if (cpufreq_driver->ready)
1495 : 0 : cpufreq_driver->ready(policy);
1496 : :
1497 : : if (cpufreq_thermal_control_enabled(cpufreq_driver))
1498 : : policy->cdev = of_cpufreq_cooling_register(policy);
1499 : :
1500 : : pr_debug("initialization complete\n");
1501 : :
1502 : : return 0;
1503 : :
1504 : : out_destroy_policy:
1505 [ # # ]: 0 : for_each_cpu(j, policy->real_cpus)
1506 : 0 : remove_cpu_dev_symlink(policy, get_cpu_device(j));
1507 : :
1508 : 0 : up_write(&policy->rwsem);
1509 : :
1510 : : out_exit_policy:
1511 [ # # ]: 0 : if (cpufreq_driver->exit)
1512 : 0 : cpufreq_driver->exit(policy);
1513 : :
1514 : : out_free_policy:
1515 : 0 : cpufreq_policy_free(policy);
1516 : 0 : return ret;
1517 : : }
1518 : :
1519 : : /**
1520 : : * cpufreq_add_dev - the cpufreq interface for a CPU device.
1521 : : * @dev: CPU device.
1522 : : * @sif: Subsystem interface structure pointer (not used)
1523 : : */
1524 : 828 : static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1525 : : {
1526 : : struct cpufreq_policy *policy;
1527 : 828 : unsigned cpu = dev->id;
1528 : : int ret;
1529 : :
1530 : : dev_dbg(dev, "%s: adding CPU%u\n", __func__, cpu);
1531 : :
1532 [ + - ]: 1656 : if (cpu_online(cpu)) {
1533 : 828 : ret = cpufreq_online(cpu);
1534 [ + - ]: 828 : if (ret)
1535 : : return ret;
1536 : : }
1537 : :
1538 : : /* Create sysfs link on CPU registration */
1539 : 828 : policy = per_cpu(cpufreq_cpu_data, cpu);
1540 [ + - ]: 828 : if (policy)
1541 : 828 : add_cpu_dev_symlink(policy, cpu);
1542 : :
1543 : : return 0;
1544 : : }
1545 : :
1546 : 0 : static int cpufreq_offline(unsigned int cpu)
1547 : : {
1548 : : struct cpufreq_policy *policy;
1549 : : int ret;
1550 : :
1551 : : pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1552 : :
1553 : : policy = cpufreq_cpu_get_raw(cpu);
1554 [ # # ]: 0 : if (!policy) {
1555 : : pr_debug("%s: No cpu_data found\n", __func__);
1556 : : return 0;
1557 : : }
1558 : :
1559 : 0 : down_write(&policy->rwsem);
1560 [ # # ]: 0 : if (has_target())
1561 : : cpufreq_stop_governor(policy);
1562 : :
1563 : 0 : cpumask_clear_cpu(cpu, policy->cpus);
1564 : :
1565 [ # # ]: 0 : if (policy_is_inactive(policy)) {
1566 [ # # ]: 0 : if (has_target())
1567 : 0 : strncpy(policy->last_governor, policy->governor->name,
1568 : : CPUFREQ_NAME_LEN);
1569 : : else
1570 : 0 : policy->last_policy = policy->policy;
1571 [ # # ]: 0 : } else if (cpu == policy->cpu) {
1572 : : /* Nominate new CPU */
1573 : 0 : policy->cpu = cpumask_any(policy->cpus);
1574 : : }
1575 : :
1576 : : /* Start governor again for active policy */
1577 [ # # ]: 0 : if (!policy_is_inactive(policy)) {
1578 [ # # ]: 0 : if (has_target()) {
1579 : 0 : ret = cpufreq_start_governor(policy);
1580 [ # # ]: 0 : if (ret)
1581 : 0 : pr_err("%s: Failed to start governor\n", __func__);
1582 : : }
1583 : :
1584 : : goto unlock;
1585 : : }
1586 : :
1587 : : if (cpufreq_thermal_control_enabled(cpufreq_driver)) {
1588 : : cpufreq_cooling_unregister(policy->cdev);
1589 : : policy->cdev = NULL;
1590 : : }
1591 : :
1592 [ # # ]: 0 : if (cpufreq_driver->stop_cpu)
1593 : 0 : cpufreq_driver->stop_cpu(policy);
1594 : :
1595 [ # # ]: 0 : if (has_target())
1596 : 0 : cpufreq_exit_governor(policy);
1597 : :
1598 : : /*
1599 : : * Perform the ->offline() during light-weight tear-down, as
1600 : : * that allows fast recovery when the CPU comes back.
1601 : : */
1602 [ # # ]: 0 : if (cpufreq_driver->offline) {
1603 : 0 : cpufreq_driver->offline(policy);
1604 [ # # ]: 0 : } else if (cpufreq_driver->exit) {
1605 : 0 : cpufreq_driver->exit(policy);
1606 : 0 : policy->freq_table = NULL;
1607 : : }
1608 : :
1609 : : unlock:
1610 : 0 : up_write(&policy->rwsem);
1611 : 0 : return 0;
1612 : : }
1613 : :
1614 : : /**
1615 : : * cpufreq_remove_dev - remove a CPU device
1616 : : *
1617 : : * Removes the cpufreq interface for a CPU device.
1618 : : */
1619 : 0 : static void cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1620 : : {
1621 : 0 : unsigned int cpu = dev->id;
1622 : 0 : struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1623 : :
1624 [ # # ]: 0 : if (!policy)
1625 : 0 : return;
1626 : :
1627 [ # # ]: 0 : if (cpu_online(cpu))
1628 : 0 : cpufreq_offline(cpu);
1629 : :
1630 : : cpumask_clear_cpu(cpu, policy->real_cpus);
1631 : : remove_cpu_dev_symlink(policy, dev);
1632 : :
1633 [ # # ]: 0 : if (cpumask_empty(policy->real_cpus)) {
1634 : : /* We did light-weight exit earlier, do full tear down now */
1635 [ # # ]: 0 : if (cpufreq_driver->offline)
1636 : 0 : cpufreq_driver->exit(policy);
1637 : :
1638 : 0 : cpufreq_policy_free(policy);
1639 : : }
1640 : : }
1641 : :
1642 : : /**
1643 : : * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're
1644 : : * in deep trouble.
1645 : : * @policy: policy managing CPUs
1646 : : * @new_freq: CPU frequency the CPU actually runs at
1647 : : *
1648 : : * We adjust to current frequency first, and need to clean up later.
1649 : : * So either call to cpufreq_update_policy() or schedule handle_update()).
1650 : : */
1651 : 0 : static void cpufreq_out_of_sync(struct cpufreq_policy *policy,
1652 : : unsigned int new_freq)
1653 : : {
1654 : : struct cpufreq_freqs freqs;
1655 : :
1656 : : pr_debug("Warning: CPU frequency out of sync: cpufreq and timing core thinks of %u, is %u kHz\n",
1657 : : policy->cur, new_freq);
1658 : :
1659 : 0 : freqs.old = policy->cur;
1660 : 0 : freqs.new = new_freq;
1661 : :
1662 : 0 : cpufreq_freq_transition_begin(policy, &freqs);
1663 : 0 : cpufreq_freq_transition_end(policy, &freqs, 0);
1664 : 0 : }
1665 : :
1666 : 414 : static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, bool update)
1667 : : {
1668 : : unsigned int new_freq;
1669 : :
1670 : 414 : new_freq = cpufreq_driver->get(policy->cpu);
1671 [ + - ]: 414 : if (!new_freq)
1672 : : return 0;
1673 : :
1674 : : /*
1675 : : * If fast frequency switching is used with the given policy, the check
1676 : : * against policy->cur is pointless, so skip it in that case.
1677 : : */
1678 [ + - + - ]: 828 : if (policy->fast_switch_enabled || !has_target())
1679 : : return new_freq;
1680 : :
1681 [ - + ]: 414 : if (policy->cur != new_freq) {
1682 : 0 : cpufreq_out_of_sync(policy, new_freq);
1683 [ # # ]: 0 : if (update)
1684 : 0 : schedule_work(&policy->update);
1685 : : }
1686 : :
1687 : 414 : return new_freq;
1688 : : }
1689 : :
1690 : : /**
1691 : : * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1692 : : * @cpu: CPU number
1693 : : *
1694 : : * This is the last known freq, without actually getting it from the driver.
1695 : : * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1696 : : */
1697 : 0 : unsigned int cpufreq_quick_get(unsigned int cpu)
1698 : : {
1699 : : struct cpufreq_policy *policy;
1700 : : unsigned int ret_freq = 0;
1701 : : unsigned long flags;
1702 : :
1703 : 0 : read_lock_irqsave(&cpufreq_driver_lock, flags);
1704 : :
1705 [ # # # # : 0 : if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get) {
# # ]
1706 : 0 : ret_freq = cpufreq_driver->get(cpu);
1707 : 0 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1708 : 0 : return ret_freq;
1709 : : }
1710 : :
1711 : 0 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1712 : :
1713 : 0 : policy = cpufreq_cpu_get(cpu);
1714 [ # # ]: 0 : if (policy) {
1715 : 0 : ret_freq = policy->cur;
1716 : : cpufreq_cpu_put(policy);
1717 : : }
1718 : :
1719 : 0 : return ret_freq;
1720 : : }
1721 : : EXPORT_SYMBOL(cpufreq_quick_get);
1722 : :
1723 : : /**
1724 : : * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1725 : : * @cpu: CPU number
1726 : : *
1727 : : * Just return the max possible frequency for a given CPU.
1728 : : */
1729 : 0 : unsigned int cpufreq_quick_get_max(unsigned int cpu)
1730 : : {
1731 : 0 : struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1732 : : unsigned int ret_freq = 0;
1733 : :
1734 [ # # ]: 0 : if (policy) {
1735 : 0 : ret_freq = policy->max;
1736 : : cpufreq_cpu_put(policy);
1737 : : }
1738 : :
1739 : 0 : return ret_freq;
1740 : : }
1741 : : EXPORT_SYMBOL(cpufreq_quick_get_max);
1742 : :
1743 : 0 : static unsigned int __cpufreq_get(struct cpufreq_policy *policy)
1744 : : {
1745 [ # # ]: 0 : if (unlikely(policy_is_inactive(policy)))
1746 : : return 0;
1747 : :
1748 : 0 : return cpufreq_verify_current_freq(policy, true);
1749 : : }
1750 : :
1751 : : /**
1752 : : * cpufreq_get - get the current CPU frequency (in kHz)
1753 : : * @cpu: CPU number
1754 : : *
1755 : : * Get the CPU current (static) CPU frequency
1756 : : */
1757 : 0 : unsigned int cpufreq_get(unsigned int cpu)
1758 : : {
1759 : 0 : struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1760 : : unsigned int ret_freq = 0;
1761 : :
1762 [ # # ]: 0 : if (policy) {
1763 : 0 : down_read(&policy->rwsem);
1764 [ # # ]: 0 : if (cpufreq_driver->get)
1765 : 0 : ret_freq = __cpufreq_get(policy);
1766 : 0 : up_read(&policy->rwsem);
1767 : :
1768 : : cpufreq_cpu_put(policy);
1769 : : }
1770 : :
1771 : 0 : return ret_freq;
1772 : : }
1773 : : EXPORT_SYMBOL(cpufreq_get);
1774 : :
1775 : : static struct subsys_interface cpufreq_interface = {
1776 : : .name = "cpufreq",
1777 : : .subsys = &cpu_subsys,
1778 : : .add_dev = cpufreq_add_dev,
1779 : : .remove_dev = cpufreq_remove_dev,
1780 : : };
1781 : :
1782 : : /*
1783 : : * In case platform wants some specific frequency to be configured
1784 : : * during suspend..
1785 : : */
1786 : 0 : int cpufreq_generic_suspend(struct cpufreq_policy *policy)
1787 : : {
1788 : : int ret;
1789 : :
1790 [ # # ]: 0 : if (!policy->suspend_freq) {
1791 : : pr_debug("%s: suspend_freq not defined\n", __func__);
1792 : : return 0;
1793 : : }
1794 : :
1795 : : pr_debug("%s: Setting suspend-freq: %u\n", __func__,
1796 : : policy->suspend_freq);
1797 : :
1798 : 0 : ret = __cpufreq_driver_target(policy, policy->suspend_freq,
1799 : : CPUFREQ_RELATION_H);
1800 [ # # ]: 0 : if (ret)
1801 : 0 : pr_err("%s: unable to set suspend-freq: %u. err: %d\n",
1802 : : __func__, policy->suspend_freq, ret);
1803 : :
1804 : 0 : return ret;
1805 : : }
1806 : : EXPORT_SYMBOL(cpufreq_generic_suspend);
1807 : :
1808 : : /**
1809 : : * cpufreq_suspend() - Suspend CPUFreq governors
1810 : : *
1811 : : * Called during system wide Suspend/Hibernate cycles for suspending governors
1812 : : * as some platforms can't change frequency after this point in suspend cycle.
1813 : : * Because some of the devices (like: i2c, regulators, etc) they use for
1814 : : * changing frequency are suspended quickly after this point.
1815 : : */
1816 : 0 : void cpufreq_suspend(void)
1817 : : {
1818 : : struct cpufreq_policy *policy;
1819 : :
1820 [ # # ]: 0 : if (!cpufreq_driver)
1821 : 0 : return;
1822 : :
1823 [ # # # # ]: 0 : if (!has_target() && !cpufreq_driver->suspend)
1824 : : goto suspend;
1825 : :
1826 : : pr_debug("%s: Suspending Governors\n", __func__);
1827 : :
1828 [ # # # # ]: 0 : for_each_active_policy(policy) {
1829 [ # # ]: 0 : if (has_target()) {
1830 : 0 : down_write(&policy->rwsem);
1831 : : cpufreq_stop_governor(policy);
1832 : 0 : up_write(&policy->rwsem);
1833 : : }
1834 : :
1835 [ # # # # ]: 0 : if (cpufreq_driver->suspend && cpufreq_driver->suspend(policy))
1836 : 0 : pr_err("%s: Failed to suspend driver: %s\n", __func__,
1837 : : cpufreq_driver->name);
1838 : : }
1839 : :
1840 : : suspend:
1841 : 0 : cpufreq_suspended = true;
1842 : : }
1843 : :
1844 : : /**
1845 : : * cpufreq_resume() - Resume CPUFreq governors
1846 : : *
1847 : : * Called during system wide Suspend/Hibernate cycle for resuming governors that
1848 : : * are suspended with cpufreq_suspend().
1849 : : */
1850 : 0 : void cpufreq_resume(void)
1851 : : {
1852 : : struct cpufreq_policy *policy;
1853 : : int ret;
1854 : :
1855 [ # # ]: 0 : if (!cpufreq_driver)
1856 : : return;
1857 : :
1858 [ # # ]: 0 : if (unlikely(!cpufreq_suspended))
1859 : : return;
1860 : :
1861 : 0 : cpufreq_suspended = false;
1862 : :
1863 [ # # # # ]: 0 : if (!has_target() && !cpufreq_driver->resume)
1864 : : return;
1865 : :
1866 : : pr_debug("%s: Resuming Governors\n", __func__);
1867 : :
1868 [ # # # # ]: 0 : for_each_active_policy(policy) {
1869 [ # # # # ]: 0 : if (cpufreq_driver->resume && cpufreq_driver->resume(policy)) {
1870 : 0 : pr_err("%s: Failed to resume driver: %p\n", __func__,
1871 : : policy);
1872 [ # # ]: 0 : } else if (has_target()) {
1873 : 0 : down_write(&policy->rwsem);
1874 : 0 : ret = cpufreq_start_governor(policy);
1875 : 0 : up_write(&policy->rwsem);
1876 : :
1877 [ # # ]: 0 : if (ret)
1878 : 0 : pr_err("%s: Failed to start governor for policy: %p\n",
1879 : : __func__, policy);
1880 : : }
1881 : : }
1882 : : }
1883 : :
1884 : : /**
1885 : : * cpufreq_get_current_driver - return current driver's name
1886 : : *
1887 : : * Return the name string of the currently loaded cpufreq driver
1888 : : * or NULL, if none.
1889 : : */
1890 : 0 : const char *cpufreq_get_current_driver(void)
1891 : : {
1892 [ # # ]: 0 : if (cpufreq_driver)
1893 : 0 : return cpufreq_driver->name;
1894 : :
1895 : : return NULL;
1896 : : }
1897 : : EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1898 : :
1899 : : /**
1900 : : * cpufreq_get_driver_data - return current driver data
1901 : : *
1902 : : * Return the private data of the currently loaded cpufreq
1903 : : * driver, or NULL if no cpufreq driver is loaded.
1904 : : */
1905 : 0 : void *cpufreq_get_driver_data(void)
1906 : : {
1907 [ # # ]: 0 : if (cpufreq_driver)
1908 : 0 : return cpufreq_driver->driver_data;
1909 : :
1910 : : return NULL;
1911 : : }
1912 : : EXPORT_SYMBOL_GPL(cpufreq_get_driver_data);
1913 : :
1914 : : /*********************************************************************
1915 : : * NOTIFIER LISTS INTERFACE *
1916 : : *********************************************************************/
1917 : :
1918 : : /**
1919 : : * cpufreq_register_notifier - register a driver with cpufreq
1920 : : * @nb: notifier function to register
1921 : : * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1922 : : *
1923 : : * Add a driver to one of two lists: either a list of drivers that
1924 : : * are notified about clock rate changes (once before and once after
1925 : : * the transition), or a list of drivers that are notified about
1926 : : * changes in cpufreq policy.
1927 : : *
1928 : : * This function may sleep, and has the same return conditions as
1929 : : * blocking_notifier_chain_register.
1930 : : */
1931 : 207 : int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1932 : : {
1933 : : int ret;
1934 : :
1935 [ + - ]: 207 : if (cpufreq_disabled())
1936 : : return -EINVAL;
1937 : :
1938 [ + - - ]: 207 : switch (list) {
1939 : : case CPUFREQ_TRANSITION_NOTIFIER:
1940 : 207 : mutex_lock(&cpufreq_fast_switch_lock);
1941 : :
1942 [ - + ]: 207 : if (cpufreq_fast_switch_count > 0) {
1943 : 0 : mutex_unlock(&cpufreq_fast_switch_lock);
1944 : 0 : return -EBUSY;
1945 : : }
1946 : 207 : ret = srcu_notifier_chain_register(
1947 : : &cpufreq_transition_notifier_list, nb);
1948 [ + - ]: 207 : if (!ret)
1949 : 207 : cpufreq_fast_switch_count--;
1950 : :
1951 : 207 : mutex_unlock(&cpufreq_fast_switch_lock);
1952 : 207 : break;
1953 : : case CPUFREQ_POLICY_NOTIFIER:
1954 : 0 : ret = blocking_notifier_chain_register(
1955 : : &cpufreq_policy_notifier_list, nb);
1956 : 0 : break;
1957 : : default:
1958 : : ret = -EINVAL;
1959 : : }
1960 : :
1961 : 207 : return ret;
1962 : : }
1963 : : EXPORT_SYMBOL(cpufreq_register_notifier);
1964 : :
1965 : : /**
1966 : : * cpufreq_unregister_notifier - unregister a driver with cpufreq
1967 : : * @nb: notifier block to be unregistered
1968 : : * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1969 : : *
1970 : : * Remove a driver from the CPU frequency notifier list.
1971 : : *
1972 : : * This function may sleep, and has the same return conditions as
1973 : : * blocking_notifier_chain_unregister.
1974 : : */
1975 : 0 : int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1976 : : {
1977 : : int ret;
1978 : :
1979 [ # # ]: 0 : if (cpufreq_disabled())
1980 : : return -EINVAL;
1981 : :
1982 [ # # # ]: 0 : switch (list) {
1983 : : case CPUFREQ_TRANSITION_NOTIFIER:
1984 : 0 : mutex_lock(&cpufreq_fast_switch_lock);
1985 : :
1986 : 0 : ret = srcu_notifier_chain_unregister(
1987 : : &cpufreq_transition_notifier_list, nb);
1988 [ # # # # : 0 : if (!ret && !WARN_ON(cpufreq_fast_switch_count >= 0))
# # ]
1989 : 0 : cpufreq_fast_switch_count++;
1990 : :
1991 : 0 : mutex_unlock(&cpufreq_fast_switch_lock);
1992 : 0 : break;
1993 : : case CPUFREQ_POLICY_NOTIFIER:
1994 : 0 : ret = blocking_notifier_chain_unregister(
1995 : : &cpufreq_policy_notifier_list, nb);
1996 : 0 : break;
1997 : : default:
1998 : : ret = -EINVAL;
1999 : : }
2000 : :
2001 : 0 : return ret;
2002 : : }
2003 : : EXPORT_SYMBOL(cpufreq_unregister_notifier);
2004 : :
2005 : :
2006 : : /*********************************************************************
2007 : : * GOVERNORS *
2008 : : *********************************************************************/
2009 : :
2010 : : /**
2011 : : * cpufreq_driver_fast_switch - Carry out a fast CPU frequency switch.
2012 : : * @policy: cpufreq policy to switch the frequency for.
2013 : : * @target_freq: New frequency to set (may be approximate).
2014 : : *
2015 : : * Carry out a fast frequency switch without sleeping.
2016 : : *
2017 : : * The driver's ->fast_switch() callback invoked by this function must be
2018 : : * suitable for being called from within RCU-sched read-side critical sections
2019 : : * and it is expected to select the minimum available frequency greater than or
2020 : : * equal to @target_freq (CPUFREQ_RELATION_L).
2021 : : *
2022 : : * This function must not be called if policy->fast_switch_enabled is unset.
2023 : : *
2024 : : * Governors calling this function must guarantee that it will never be invoked
2025 : : * twice in parallel for the same policy and that it will never be called in
2026 : : * parallel with either ->target() or ->target_index() for the same policy.
2027 : : *
2028 : : * Returns the actual frequency set for the CPU.
2029 : : *
2030 : : * If 0 is returned by the driver's ->fast_switch() callback to indicate an
2031 : : * error condition, the hardware configuration must be preserved.
2032 : : */
2033 : 0 : unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
2034 : : unsigned int target_freq)
2035 : : {
2036 : 0 : target_freq = clamp_val(target_freq, policy->min, policy->max);
2037 : :
2038 : 0 : return cpufreq_driver->fast_switch(policy, target_freq);
2039 : : }
2040 : : EXPORT_SYMBOL_GPL(cpufreq_driver_fast_switch);
2041 : :
2042 : : /* Must set freqs->new to intermediate frequency */
2043 : 0 : static int __target_intermediate(struct cpufreq_policy *policy,
2044 : : struct cpufreq_freqs *freqs, int index)
2045 : : {
2046 : : int ret;
2047 : :
2048 : 0 : freqs->new = cpufreq_driver->get_intermediate(policy, index);
2049 : :
2050 : : /* We don't need to switch to intermediate freq */
2051 [ # # ]: 0 : if (!freqs->new)
2052 : : return 0;
2053 : :
2054 : : pr_debug("%s: cpu: %d, switching to intermediate freq: oldfreq: %u, intermediate freq: %u\n",
2055 : : __func__, policy->cpu, freqs->old, freqs->new);
2056 : :
2057 : 0 : cpufreq_freq_transition_begin(policy, freqs);
2058 : 0 : ret = cpufreq_driver->target_intermediate(policy, index);
2059 : 0 : cpufreq_freq_transition_end(policy, freqs, ret);
2060 : :
2061 [ # # ]: 0 : if (ret)
2062 : 0 : pr_err("%s: Failed to change to intermediate frequency: %d\n",
2063 : : __func__, ret);
2064 : :
2065 : 0 : return ret;
2066 : : }
2067 : :
2068 : 107145 : static int __target_index(struct cpufreq_policy *policy, int index)
2069 : : {
2070 : 107145 : struct cpufreq_freqs freqs = {.old = policy->cur, .flags = 0};
2071 : : unsigned int intermediate_freq = 0;
2072 : 107145 : unsigned int newfreq = policy->freq_table[index].frequency;
2073 : : int retval = -EINVAL;
2074 : : bool notify;
2075 : :
2076 [ + + ]: 107145 : if (newfreq == policy->cur)
2077 : : return 0;
2078 : :
2079 : 18074 : notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
2080 [ + - ]: 18074 : if (notify) {
2081 : : /* Handle switching to intermediate frequency */
2082 [ - + ]: 18074 : if (cpufreq_driver->get_intermediate) {
2083 : 0 : retval = __target_intermediate(policy, &freqs, index);
2084 [ # # ]: 0 : if (retval)
2085 : : return retval;
2086 : :
2087 : 0 : intermediate_freq = freqs.new;
2088 : : /* Set old freq to intermediate */
2089 [ # # ]: 0 : if (intermediate_freq)
2090 : 0 : freqs.old = freqs.new;
2091 : : }
2092 : :
2093 : 18074 : freqs.new = newfreq;
2094 : : pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
2095 : : __func__, policy->cpu, freqs.old, freqs.new);
2096 : :
2097 : 18074 : cpufreq_freq_transition_begin(policy, &freqs);
2098 : : }
2099 : :
2100 : 18074 : retval = cpufreq_driver->target_index(policy, index);
2101 [ - + ]: 18074 : if (retval)
2102 : 0 : pr_err("%s: Failed to change cpu frequency: %d\n", __func__,
2103 : : retval);
2104 : :
2105 [ + - ]: 18074 : if (notify) {
2106 : 18074 : cpufreq_freq_transition_end(policy, &freqs, retval);
2107 : :
2108 : : /*
2109 : : * Failed after setting to intermediate freq? Driver should have
2110 : : * reverted back to initial frequency and so should we. Check
2111 : : * here for intermediate_freq instead of get_intermediate, in
2112 : : * case we haven't switched to intermediate freq at all.
2113 : : */
2114 [ - + ]: 18074 : if (unlikely(retval && intermediate_freq)) {
2115 : 0 : freqs.old = intermediate_freq;
2116 : 0 : freqs.new = policy->restore_freq;
2117 : 0 : cpufreq_freq_transition_begin(policy, &freqs);
2118 : 0 : cpufreq_freq_transition_end(policy, &freqs, 0);
2119 : : }
2120 : : }
2121 : :
2122 : 18074 : return retval;
2123 : : }
2124 : :
2125 : 107767 : int __cpufreq_driver_target(struct cpufreq_policy *policy,
2126 : : unsigned int target_freq,
2127 : : unsigned int relation)
2128 : : {
2129 : : unsigned int old_target_freq = target_freq;
2130 : : int index;
2131 : :
2132 [ + - ]: 107767 : if (cpufreq_disabled())
2133 : : return -ENODEV;
2134 : :
2135 : : /* Make sure that target_freq is within supported range */
2136 : 107767 : target_freq = clamp_val(target_freq, policy->min, policy->max);
2137 : :
2138 : : pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
2139 : : policy->cpu, target_freq, relation, old_target_freq);
2140 : :
2141 : : /*
2142 : : * This might look like a redundant call as we are checking it again
2143 : : * after finding index. But it is left intentionally for cases where
2144 : : * exactly same freq is called again and so we can save on few function
2145 : : * calls.
2146 : : */
2147 [ + + ]: 107767 : if (target_freq == policy->cur)
2148 : : return 0;
2149 : :
2150 : : /* Save last value to restore later on errors */
2151 : 107145 : policy->restore_freq = policy->cur;
2152 : :
2153 [ - + ]: 107145 : if (cpufreq_driver->target)
2154 : 0 : return cpufreq_driver->target(policy, target_freq, relation);
2155 : :
2156 [ + - ]: 107145 : if (!cpufreq_driver->target_index)
2157 : : return -EINVAL;
2158 : :
2159 : 107145 : index = cpufreq_frequency_table_target(policy, target_freq, relation);
2160 : :
2161 : 107145 : return __target_index(policy, index);
2162 : : }
2163 : : EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
2164 : :
2165 : 0 : int cpufreq_driver_target(struct cpufreq_policy *policy,
2166 : : unsigned int target_freq,
2167 : : unsigned int relation)
2168 : : {
2169 : : int ret;
2170 : :
2171 : 0 : down_write(&policy->rwsem);
2172 : :
2173 : 0 : ret = __cpufreq_driver_target(policy, target_freq, relation);
2174 : :
2175 : 0 : up_write(&policy->rwsem);
2176 : :
2177 : 0 : return ret;
2178 : : }
2179 : : EXPORT_SYMBOL_GPL(cpufreq_driver_target);
2180 : :
2181 : 0 : __weak struct cpufreq_governor *cpufreq_fallback_governor(void)
2182 : : {
2183 : 0 : return NULL;
2184 : : }
2185 : :
2186 : 414 : static int cpufreq_init_governor(struct cpufreq_policy *policy)
2187 : : {
2188 : : int ret;
2189 : :
2190 : : /* Don't start any governor operations if we are entering suspend */
2191 [ + - ]: 414 : if (cpufreq_suspended)
2192 : : return 0;
2193 : : /*
2194 : : * Governor might not be initiated here if ACPI _PPC changed
2195 : : * notification happened, so check it.
2196 : : */
2197 [ + - ]: 414 : if (!policy->governor)
2198 : : return -EINVAL;
2199 : :
2200 : : /* Platform doesn't want dynamic frequency switching ? */
2201 [ + + - + ]: 621 : if (policy->governor->dynamic_switching &&
2202 : 207 : cpufreq_driver->flags & CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING) {
2203 : 0 : struct cpufreq_governor *gov = cpufreq_fallback_governor();
2204 : :
2205 [ # # ]: 0 : if (gov) {
2206 : 0 : pr_warn("Can't use %s governor as dynamic switching is disallowed. Fallback to %s governor\n",
2207 : : policy->governor->name, gov->name);
2208 : 0 : policy->governor = gov;
2209 : : } else {
2210 : : return -EINVAL;
2211 : : }
2212 : : }
2213 : :
2214 [ + - ]: 414 : if (!try_module_get(policy->governor->owner))
2215 : : return -EINVAL;
2216 : :
2217 : : pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
2218 : :
2219 [ + + ]: 414 : if (policy->governor->init) {
2220 : 207 : ret = policy->governor->init(policy);
2221 [ - + ]: 207 : if (ret) {
2222 : 0 : module_put(policy->governor->owner);
2223 : 0 : return ret;
2224 : : }
2225 : : }
2226 : :
2227 : : return 0;
2228 : : }
2229 : :
2230 : 207 : static void cpufreq_exit_governor(struct cpufreq_policy *policy)
2231 : : {
2232 [ + - + - ]: 207 : if (cpufreq_suspended || !policy->governor)
2233 : 207 : return;
2234 : :
2235 : : pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
2236 : :
2237 [ - + ]: 207 : if (policy->governor->exit)
2238 : 0 : policy->governor->exit(policy);
2239 : :
2240 : 207 : module_put(policy->governor->owner);
2241 : : }
2242 : :
2243 : 414 : static int cpufreq_start_governor(struct cpufreq_policy *policy)
2244 : : {
2245 : : int ret;
2246 : :
2247 [ + - ]: 414 : if (cpufreq_suspended)
2248 : : return 0;
2249 : :
2250 [ + - ]: 414 : if (!policy->governor)
2251 : : return -EINVAL;
2252 : :
2253 : : pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
2254 : :
2255 [ + - ]: 414 : if (cpufreq_driver->get)
2256 : 414 : cpufreq_verify_current_freq(policy, false);
2257 : :
2258 [ + + ]: 414 : if (policy->governor->start) {
2259 : 207 : ret = policy->governor->start(policy);
2260 [ + - ]: 207 : if (ret)
2261 : : return ret;
2262 : : }
2263 : :
2264 [ + - ]: 414 : if (policy->governor->limits)
2265 : 414 : policy->governor->limits(policy);
2266 : :
2267 : : return 0;
2268 : : }
2269 : :
2270 : : static void cpufreq_stop_governor(struct cpufreq_policy *policy)
2271 : : {
2272 [ + - + - : 207 : if (cpufreq_suspended || !policy->governor)
# # # # #
# # # # #
# # ]
2273 : : return;
2274 : :
2275 : : pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
2276 : :
2277 [ - + # # : 207 : if (policy->governor->stop)
# # # # ]
2278 : 0 : policy->governor->stop(policy);
2279 : : }
2280 : :
2281 : : static void cpufreq_governor_limits(struct cpufreq_policy *policy)
2282 : : {
2283 [ + - + - ]: 414 : if (cpufreq_suspended || !policy->governor)
2284 : : return;
2285 : :
2286 : : pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
2287 : :
2288 [ + - ]: 414 : if (policy->governor->limits)
2289 : 414 : policy->governor->limits(policy);
2290 : : }
2291 : :
2292 : 1242 : int cpufreq_register_governor(struct cpufreq_governor *governor)
2293 : : {
2294 : : int err;
2295 : :
2296 [ + - ]: 1242 : if (!governor)
2297 : : return -EINVAL;
2298 : :
2299 [ + - ]: 1242 : if (cpufreq_disabled())
2300 : : return -ENODEV;
2301 : :
2302 : 1242 : mutex_lock(&cpufreq_governor_mutex);
2303 : :
2304 : : err = -EBUSY;
2305 [ + - ]: 1242 : if (!find_governor(governor->name)) {
2306 : : err = 0;
2307 : 1242 : list_add(&governor->governor_list, &cpufreq_governor_list);
2308 : : }
2309 : :
2310 : 1242 : mutex_unlock(&cpufreq_governor_mutex);
2311 : 1242 : return err;
2312 : : }
2313 : : EXPORT_SYMBOL_GPL(cpufreq_register_governor);
2314 : :
2315 : 0 : void cpufreq_unregister_governor(struct cpufreq_governor *governor)
2316 : : {
2317 : : struct cpufreq_policy *policy;
2318 : : unsigned long flags;
2319 : :
2320 [ # # ]: 0 : if (!governor)
2321 : : return;
2322 : :
2323 [ # # ]: 0 : if (cpufreq_disabled())
2324 : : return;
2325 : :
2326 : : /* clear last_governor for all inactive policies */
2327 : 0 : read_lock_irqsave(&cpufreq_driver_lock, flags);
2328 [ # # # # ]: 0 : for_each_inactive_policy(policy) {
2329 [ # # ]: 0 : if (!strcmp(policy->last_governor, governor->name)) {
2330 : 0 : policy->governor = NULL;
2331 : 0 : strcpy(policy->last_governor, "\0");
2332 : : }
2333 : : }
2334 : 0 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
2335 : :
2336 : 0 : mutex_lock(&cpufreq_governor_mutex);
2337 : : list_del(&governor->governor_list);
2338 : 0 : mutex_unlock(&cpufreq_governor_mutex);
2339 : : }
2340 : : EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
2341 : :
2342 : :
2343 : : /*********************************************************************
2344 : : * POLICY INTERFACE *
2345 : : *********************************************************************/
2346 : :
2347 : : /**
2348 : : * cpufreq_get_policy - get the current cpufreq_policy
2349 : : * @policy: struct cpufreq_policy into which the current cpufreq_policy
2350 : : * is written
2351 : : *
2352 : : * Reads the current cpufreq policy.
2353 : : */
2354 : 0 : int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
2355 : : {
2356 : : struct cpufreq_policy *cpu_policy;
2357 [ # # ]: 0 : if (!policy)
2358 : : return -EINVAL;
2359 : :
2360 : 0 : cpu_policy = cpufreq_cpu_get(cpu);
2361 [ # # ]: 0 : if (!cpu_policy)
2362 : : return -EINVAL;
2363 : :
2364 : 0 : memcpy(policy, cpu_policy, sizeof(*policy));
2365 : :
2366 : : cpufreq_cpu_put(cpu_policy);
2367 : 0 : return 0;
2368 : : }
2369 : : EXPORT_SYMBOL(cpufreq_get_policy);
2370 : :
2371 : : /**
2372 : : * cpufreq_set_policy - Modify cpufreq policy parameters.
2373 : : * @policy: Policy object to modify.
2374 : : * @new_gov: Policy governor pointer.
2375 : : * @new_pol: Policy value (for drivers with built-in governors).
2376 : : *
2377 : : * Invoke the cpufreq driver's ->verify() callback to sanity-check the frequency
2378 : : * limits to be set for the policy, update @policy with the verified limits
2379 : : * values and either invoke the driver's ->setpolicy() callback (if present) or
2380 : : * carry out a governor update for @policy. That is, run the current governor's
2381 : : * ->limits() callback (if @new_gov points to the same object as the one in
2382 : : * @policy) or replace the governor for @policy with @new_gov.
2383 : : *
2384 : : * The cpuinfo part of @policy is not updated by this function.
2385 : : */
2386 : 828 : static int cpufreq_set_policy(struct cpufreq_policy *policy,
2387 : : struct cpufreq_governor *new_gov,
2388 : : unsigned int new_pol)
2389 : : {
2390 : : struct cpufreq_policy_data new_data;
2391 : : struct cpufreq_governor *old_gov;
2392 : : int ret;
2393 : :
2394 : 828 : memcpy(&new_data.cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
2395 : 828 : new_data.freq_table = policy->freq_table;
2396 : 828 : new_data.cpu = policy->cpu;
2397 : : /*
2398 : : * PM QoS framework collects all the requests from users and provide us
2399 : : * the final aggregated value here.
2400 : : */
2401 : 828 : new_data.min = freq_qos_read_value(&policy->constraints, FREQ_QOS_MIN);
2402 : 828 : new_data.max = freq_qos_read_value(&policy->constraints, FREQ_QOS_MAX);
2403 : :
2404 : : pr_debug("setting new policy for CPU %u: %u - %u kHz\n",
2405 : : new_data.cpu, new_data.min, new_data.max);
2406 : :
2407 : : /* verify the cpu speed can be set within this limit */
2408 : 828 : ret = cpufreq_driver->verify(&new_data);
2409 [ + - ]: 828 : if (ret)
2410 : : return ret;
2411 : :
2412 : 828 : policy->min = new_data.min;
2413 : 828 : policy->max = new_data.max;
2414 : 828 : trace_cpu_frequency_limits(policy);
2415 : :
2416 : 828 : policy->cached_target_freq = UINT_MAX;
2417 : :
2418 : : pr_debug("new min and max freqs are %u - %u kHz\n",
2419 : : policy->min, policy->max);
2420 : :
2421 [ - + ]: 828 : if (cpufreq_driver->setpolicy) {
2422 : 0 : policy->policy = new_pol;
2423 : : pr_debug("setting range\n");
2424 : 0 : return cpufreq_driver->setpolicy(policy);
2425 : : }
2426 : :
2427 [ + + ]: 828 : if (new_gov == policy->governor) {
2428 : : pr_debug("governor limits update\n");
2429 : : cpufreq_governor_limits(policy);
2430 : : return 0;
2431 : : }
2432 : :
2433 : : pr_debug("governor switch\n");
2434 : :
2435 : : /* save old, working values */
2436 : : old_gov = policy->governor;
2437 : : /* end old governor */
2438 [ + + ]: 414 : if (old_gov) {
2439 : : cpufreq_stop_governor(policy);
2440 : 207 : cpufreq_exit_governor(policy);
2441 : : }
2442 : :
2443 : : /* start new governor */
2444 : 414 : policy->governor = new_gov;
2445 : 414 : ret = cpufreq_init_governor(policy);
2446 [ + - ]: 414 : if (!ret) {
2447 : 414 : ret = cpufreq_start_governor(policy);
2448 [ - + ]: 414 : if (!ret) {
2449 : : pr_debug("governor change\n");
2450 : : sched_cpufreq_governor_change(policy, old_gov);
2451 : : return 0;
2452 : : }
2453 : 0 : cpufreq_exit_governor(policy);
2454 : : }
2455 : :
2456 : : /* new governor failed, so re-start old one */
2457 : : pr_debug("starting governor %s failed\n", policy->governor->name);
2458 [ # # ]: 0 : if (old_gov) {
2459 : 0 : policy->governor = old_gov;
2460 [ # # ]: 0 : if (cpufreq_init_governor(policy))
2461 : 0 : policy->governor = NULL;
2462 : : else
2463 : 0 : cpufreq_start_governor(policy);
2464 : : }
2465 : :
2466 : 0 : return ret;
2467 : : }
2468 : :
2469 : : /**
2470 : : * cpufreq_update_policy - Re-evaluate an existing cpufreq policy.
2471 : : * @cpu: CPU to re-evaluate the policy for.
2472 : : *
2473 : : * Update the current frequency for the cpufreq policy of @cpu and use
2474 : : * cpufreq_set_policy() to re-apply the min and max limits, which triggers the
2475 : : * evaluation of policy notifiers and the cpufreq driver's ->verify() callback
2476 : : * for the policy in question, among other things.
2477 : : */
2478 : 0 : void cpufreq_update_policy(unsigned int cpu)
2479 : : {
2480 : 0 : struct cpufreq_policy *policy = cpufreq_cpu_acquire(cpu);
2481 : :
2482 [ # # ]: 0 : if (!policy)
2483 : 0 : return;
2484 : :
2485 : : /*
2486 : : * BIOS might change freq behind our back
2487 : : * -> ask driver for current freq and notify governors about a change
2488 : : */
2489 [ # # # # : 0 : if (cpufreq_driver->get && has_target() &&
# # ]
2490 [ # # # # ]: 0 : (cpufreq_suspended || WARN_ON(!cpufreq_verify_current_freq(policy, false))))
2491 : : goto unlock;
2492 : :
2493 : 0 : refresh_frequency_limits(policy);
2494 : :
2495 : : unlock:
2496 : 0 : cpufreq_cpu_release(policy);
2497 : : }
2498 : : EXPORT_SYMBOL(cpufreq_update_policy);
2499 : :
2500 : : /**
2501 : : * cpufreq_update_limits - Update policy limits for a given CPU.
2502 : : * @cpu: CPU to update the policy limits for.
2503 : : *
2504 : : * Invoke the driver's ->update_limits callback if present or call
2505 : : * cpufreq_update_policy() for @cpu.
2506 : : */
2507 : 0 : void cpufreq_update_limits(unsigned int cpu)
2508 : : {
2509 [ # # ]: 0 : if (cpufreq_driver->update_limits)
2510 : 0 : cpufreq_driver->update_limits(cpu);
2511 : : else
2512 : 0 : cpufreq_update_policy(cpu);
2513 : 0 : }
2514 : : EXPORT_SYMBOL_GPL(cpufreq_update_limits);
2515 : :
2516 : : /*********************************************************************
2517 : : * BOOST *
2518 : : *********************************************************************/
2519 : 0 : static int cpufreq_boost_set_sw(int state)
2520 : : {
2521 : : struct cpufreq_policy *policy;
2522 : :
2523 [ # # # # ]: 0 : for_each_active_policy(policy) {
2524 : : int ret;
2525 : :
2526 [ # # ]: 0 : if (!policy->freq_table)
2527 : : return -ENXIO;
2528 : :
2529 : 0 : ret = cpufreq_frequency_table_cpuinfo(policy,
2530 : : policy->freq_table);
2531 [ # # ]: 0 : if (ret) {
2532 : 0 : pr_err("%s: Policy frequency update failed\n",
2533 : : __func__);
2534 : 0 : return ret;
2535 : : }
2536 : :
2537 : 0 : ret = freq_qos_update_request(policy->max_freq_req, policy->max);
2538 [ # # ]: 0 : if (ret < 0)
2539 : 0 : return ret;
2540 : : }
2541 : :
2542 : : return 0;
2543 : : }
2544 : :
2545 : 0 : int cpufreq_boost_trigger_state(int state)
2546 : : {
2547 : : unsigned long flags;
2548 : : int ret = 0;
2549 : :
2550 [ # # ]: 0 : if (cpufreq_driver->boost_enabled == state)
2551 : : return 0;
2552 : :
2553 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2554 : 0 : cpufreq_driver->boost_enabled = state;
2555 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2556 : :
2557 : 0 : ret = cpufreq_driver->set_boost(state);
2558 [ # # ]: 0 : if (ret) {
2559 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2560 : 0 : cpufreq_driver->boost_enabled = !state;
2561 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2562 : :
2563 [ # # ]: 0 : pr_err("%s: Cannot %s BOOST\n",
2564 : : __func__, state ? "enable" : "disable");
2565 : : }
2566 : :
2567 : 0 : return ret;
2568 : : }
2569 : :
2570 : : static bool cpufreq_boost_supported(void)
2571 : : {
2572 : 207 : return cpufreq_driver->set_boost;
2573 : : }
2574 : :
2575 : 0 : static int create_boost_sysfs_file(void)
2576 : : {
2577 : : int ret;
2578 : :
2579 : 0 : ret = sysfs_create_file(cpufreq_global_kobject, &boost.attr);
2580 [ # # ]: 0 : if (ret)
2581 : 0 : pr_err("%s: cannot register global BOOST sysfs file\n",
2582 : : __func__);
2583 : :
2584 : 0 : return ret;
2585 : : }
2586 : :
2587 : 0 : static void remove_boost_sysfs_file(void)
2588 : : {
2589 [ # # ]: 0 : if (cpufreq_boost_supported())
2590 : 0 : sysfs_remove_file(cpufreq_global_kobject, &boost.attr);
2591 : 0 : }
2592 : :
2593 : 0 : int cpufreq_enable_boost_support(void)
2594 : : {
2595 [ # # ]: 0 : if (!cpufreq_driver)
2596 : : return -EINVAL;
2597 : :
2598 [ # # ]: 0 : if (cpufreq_boost_supported())
2599 : : return 0;
2600 : :
2601 : 0 : cpufreq_driver->set_boost = cpufreq_boost_set_sw;
2602 : :
2603 : : /* This will get removed on driver unregister */
2604 : 0 : return create_boost_sysfs_file();
2605 : : }
2606 : : EXPORT_SYMBOL_GPL(cpufreq_enable_boost_support);
2607 : :
2608 : 828 : int cpufreq_boost_enabled(void)
2609 : : {
2610 : 828 : return cpufreq_driver->boost_enabled;
2611 : : }
2612 : : EXPORT_SYMBOL_GPL(cpufreq_boost_enabled);
2613 : :
2614 : : /*********************************************************************
2615 : : * REGISTER / UNREGISTER CPUFREQ DRIVER *
2616 : : *********************************************************************/
2617 : : static enum cpuhp_state hp_online;
2618 : :
2619 : 0 : static int cpuhp_cpufreq_online(unsigned int cpu)
2620 : : {
2621 : 0 : cpufreq_online(cpu);
2622 : :
2623 : 0 : return 0;
2624 : : }
2625 : :
2626 : 0 : static int cpuhp_cpufreq_offline(unsigned int cpu)
2627 : : {
2628 : 0 : cpufreq_offline(cpu);
2629 : :
2630 : 0 : return 0;
2631 : : }
2632 : :
2633 : : /**
2634 : : * cpufreq_register_driver - register a CPU Frequency driver
2635 : : * @driver_data: A struct cpufreq_driver containing the values#
2636 : : * submitted by the CPU Frequency driver.
2637 : : *
2638 : : * Registers a CPU Frequency driver to this core code. This code
2639 : : * returns zero on success, -EEXIST when another driver got here first
2640 : : * (and isn't unregistered in the meantime).
2641 : : *
2642 : : */
2643 : 207 : int cpufreq_register_driver(struct cpufreq_driver *driver_data)
2644 : : {
2645 : : unsigned long flags;
2646 : : int ret;
2647 : :
2648 [ + - ]: 207 : if (cpufreq_disabled())
2649 : : return -ENODEV;
2650 : :
2651 : : /*
2652 : : * The cpufreq core depends heavily on the availability of device
2653 : : * structure, make sure they are available before proceeding further.
2654 : : */
2655 [ + - ]: 207 : if (!get_cpu_device(0))
2656 : : return -EPROBE_DEFER;
2657 : :
2658 [ + - + - : 414 : if (!driver_data || !driver_data->verify || !driver_data->init ||
+ - + - ]
2659 [ - + # # ]: 414 : !(driver_data->setpolicy || driver_data->target_index ||
2660 [ - + ]: 207 : driver_data->target) ||
2661 [ # # # # ]: 0 : (driver_data->setpolicy && (driver_data->target_index ||
2662 [ + - ]: 207 : driver_data->target)) ||
2663 [ + - ]: 414 : (!driver_data->get_intermediate != !driver_data->target_intermediate) ||
2664 : 207 : (!driver_data->online != !driver_data->offline))
2665 : : return -EINVAL;
2666 : :
2667 : : pr_debug("trying to register driver %s\n", driver_data->name);
2668 : :
2669 : : /* Protect against concurrent CPU online/offline. */
2670 : : cpus_read_lock();
2671 : :
2672 : 207 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2673 [ - + ]: 207 : if (cpufreq_driver) {
2674 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2675 : : ret = -EEXIST;
2676 : 0 : goto out;
2677 : : }
2678 : 207 : cpufreq_driver = driver_data;
2679 : 207 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2680 : :
2681 [ - + ]: 207 : if (driver_data->setpolicy)
2682 : 0 : driver_data->flags |= CPUFREQ_CONST_LOOPS;
2683 : :
2684 [ - + ]: 207 : if (cpufreq_boost_supported()) {
2685 : 0 : ret = create_boost_sysfs_file();
2686 [ # # ]: 0 : if (ret)
2687 : : goto err_null_driver;
2688 : : }
2689 : :
2690 : 207 : ret = subsys_interface_register(&cpufreq_interface);
2691 [ + - ]: 207 : if (ret)
2692 : : goto err_boost_unreg;
2693 : :
2694 [ - + # # ]: 207 : if (!(cpufreq_driver->flags & CPUFREQ_STICKY) &&
2695 : : list_empty(&cpufreq_policy_list)) {
2696 : : /* if all ->init() calls failed, unregister */
2697 : : ret = -ENODEV;
2698 : : pr_debug("%s: No CPU initialized for driver %s\n", __func__,
2699 : : driver_data->name);
2700 : : goto err_if_unreg;
2701 : : }
2702 : :
2703 : : ret = cpuhp_setup_state_nocalls_cpuslocked(CPUHP_AP_ONLINE_DYN,
2704 : : "cpufreq:online",
2705 : : cpuhp_cpufreq_online,
2706 : : cpuhp_cpufreq_offline);
2707 [ + - ]: 207 : if (ret < 0)
2708 : : goto err_if_unreg;
2709 : 207 : hp_online = ret;
2710 : : ret = 0;
2711 : :
2712 : : pr_debug("driver %s up and running\n", driver_data->name);
2713 : 207 : goto out;
2714 : :
2715 : : err_if_unreg:
2716 : 0 : subsys_interface_unregister(&cpufreq_interface);
2717 : : err_boost_unreg:
2718 : 0 : remove_boost_sysfs_file();
2719 : : err_null_driver:
2720 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2721 : 0 : cpufreq_driver = NULL;
2722 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2723 : : out:
2724 : : cpus_read_unlock();
2725 : 207 : return ret;
2726 : : }
2727 : : EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2728 : :
2729 : : /**
2730 : : * cpufreq_unregister_driver - unregister the current CPUFreq driver
2731 : : *
2732 : : * Unregister the current CPUFreq driver. Only call this if you have
2733 : : * the right to do so, i.e. if you have succeeded in initialising before!
2734 : : * Returns zero if successful, and -EINVAL if the cpufreq_driver is
2735 : : * currently not initialised.
2736 : : */
2737 : 0 : int cpufreq_unregister_driver(struct cpufreq_driver *driver)
2738 : : {
2739 : : unsigned long flags;
2740 : :
2741 [ # # # # ]: 0 : if (!cpufreq_driver || (driver != cpufreq_driver))
2742 : : return -EINVAL;
2743 : :
2744 : : pr_debug("unregistering driver %s\n", driver->name);
2745 : :
2746 : : /* Protect against concurrent cpu hotplug */
2747 : : cpus_read_lock();
2748 : 0 : subsys_interface_unregister(&cpufreq_interface);
2749 : 0 : remove_boost_sysfs_file();
2750 : 0 : cpuhp_remove_state_nocalls_cpuslocked(hp_online);
2751 : :
2752 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2753 : :
2754 : 0 : cpufreq_driver = NULL;
2755 : :
2756 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2757 : : cpus_read_unlock();
2758 : :
2759 : 0 : return 0;
2760 : : }
2761 : : EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2762 : :
2763 : : struct kobject *cpufreq_global_kobject;
2764 : : EXPORT_SYMBOL(cpufreq_global_kobject);
2765 : :
2766 : 207 : static int __init cpufreq_core_init(void)
2767 : : {
2768 [ + - ]: 207 : if (cpufreq_disabled())
2769 : : return -ENODEV;
2770 : :
2771 : 207 : cpufreq_global_kobject = kobject_create_and_add("cpufreq", &cpu_subsys.dev_root->kobj);
2772 [ - + ]: 207 : BUG_ON(!cpufreq_global_kobject);
2773 : :
2774 : : return 0;
2775 : : }
2776 : : module_param(off, int, 0444);
2777 : : core_initcall(cpufreq_core_init);
|
