Branch data Line data Source code
1 : : /*
2 : : * linux/drivers/cpufreq/cpufreq.c
3 : : *
4 : : * Copyright (C) 2001 Russell King
5 : : * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
6 : : * (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
7 : : *
8 : : * Oct 2005 - Ashok Raj <ashok.raj@intel.com>
9 : : * Added handling for CPU hotplug
10 : : * Feb 2006 - Jacob Shin <jacob.shin@amd.com>
11 : : * Fix handling for CPU hotplug -- affected CPUs
12 : : *
13 : : * This program is free software; you can redistribute it and/or modify
14 : : * it under the terms of the GNU General Public License version 2 as
15 : : * published by the Free Software Foundation.
16 : : */
17 : :
18 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 : :
20 : : #include <linux/cpu.h>
21 : : #include <linux/cpufreq.h>
22 : : #include <linux/delay.h>
23 : : #include <linux/device.h>
24 : : #include <linux/init.h>
25 : : #include <linux/kernel_stat.h>
26 : : #include <linux/module.h>
27 : : #include <linux/mutex.h>
28 : : #include <linux/slab.h>
29 : : #include <linux/syscore_ops.h>
30 : : #include <linux/tick.h>
31 : : #include <trace/events/power.h>
32 : :
33 : : /**
34 : : * The "cpufreq driver" - the arch- or hardware-dependent low
35 : : * level driver of CPUFreq support, and its spinlock. This lock
36 : : * also protects the cpufreq_cpu_data array.
37 : : */
38 : : static struct cpufreq_driver *cpufreq_driver;
39 : : static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
40 : : static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data_fallback);
41 : : static DEFINE_RWLOCK(cpufreq_driver_lock);
42 : : DEFINE_MUTEX(cpufreq_governor_lock);
43 : : static LIST_HEAD(cpufreq_policy_list);
44 : :
45 : : #ifdef CONFIG_HOTPLUG_CPU
46 : : /* This one keeps track of the previously set governor of a removed CPU */
47 : : static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
48 : : #endif
49 : :
50 : : static inline bool has_target(void)
51 : : {
52 [ - + ][ # # ]: 338 : return cpufreq_driver->target_index || cpufreq_driver->target;
[ - + ][ # # ]
[ - + ][ # # ]
[ - + ][ # # ]
[ - + ][ # # ]
[ - + ][ # # ]
[ - + ][ # # ]
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
53 : : }
54 : :
55 : : /*
56 : : * rwsem to guarantee that cpufreq driver module doesn't unload during critical
57 : : * sections
58 : : */
59 : : static DECLARE_RWSEM(cpufreq_rwsem);
60 : :
61 : : /* internal prototypes */
62 : : static int __cpufreq_governor(struct cpufreq_policy *policy,
63 : : unsigned int event);
64 : : static unsigned int __cpufreq_get(unsigned int cpu);
65 : : static void handle_update(struct work_struct *work);
66 : :
67 : : /**
68 : : * Two notifier lists: the "policy" list is involved in the
69 : : * validation process for a new CPU frequency policy; the
70 : : * "transition" list for kernel code that needs to handle
71 : : * changes to devices when the CPU clock speed changes.
72 : : * The mutex locks both lists.
73 : : */
74 : : static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
75 : : static struct srcu_notifier_head cpufreq_transition_notifier_list;
76 : :
77 : : static bool init_cpufreq_transition_notifier_list_called;
78 : 0 : static int __init init_cpufreq_transition_notifier_list(void)
79 : : {
80 : 0 : srcu_init_notifier_head(&cpufreq_transition_notifier_list);
81 : 0 : init_cpufreq_transition_notifier_list_called = true;
82 : 0 : return 0;
83 : : }
84 : : pure_initcall(init_cpufreq_transition_notifier_list);
85 : :
86 : : static int off __read_mostly;
87 : : static int cpufreq_disabled(void)
88 : : {
89 : 45211 : return off;
90 : : }
91 : 0 : void disable_cpufreq(void)
92 : : {
93 : 0 : off = 1;
94 : 0 : }
95 : : static LIST_HEAD(cpufreq_governor_list);
96 : : static DEFINE_MUTEX(cpufreq_governor_mutex);
97 : :
98 : 0 : bool have_governor_per_policy(void)
99 : : {
100 : 256 : return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
101 : : }
102 : : EXPORT_SYMBOL_GPL(have_governor_per_policy);
103 : :
104 : 0 : struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
105 : : {
106 [ + - ]: 3 : if (have_governor_per_policy())
107 : 3 : return &policy->kobj;
108 : : else
109 : 0 : return cpufreq_global_kobject;
110 : : }
111 : : EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
112 : :
113 : : static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
114 : : {
115 : : u64 idle_time;
116 : : u64 cur_wall_time;
117 : : u64 busy_time;
118 : :
119 : 0 : cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
120 : :
121 : 0 : busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
122 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
123 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
124 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
125 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
126 : 0 : busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
127 : :
128 : 0 : idle_time = cur_wall_time - busy_time;
129 [ # # ]: 0 : if (wall)
130 : 0 : *wall = cputime_to_usecs(cur_wall_time);
131 : :
132 : 0 : return cputime_to_usecs(idle_time);
133 : : }
134 : :
135 : 0 : u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
136 : : {
137 [ - + ]: 98359 : u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
138 : :
139 [ - + ]: 196718 : if (idle_time == -1ULL)
140 : 0 : return get_cpu_idle_time_jiffy(cpu, wall);
141 [ + - ]: 98359 : else if (!io_busy)
142 : 98359 : idle_time += get_cpu_iowait_time_us(cpu, wall);
143 : :
144 : 98359 : return idle_time;
145 : : }
146 : : EXPORT_SYMBOL_GPL(get_cpu_idle_time);
147 : :
148 : : /*
149 : : * This is a generic cpufreq init() routine which can be used by cpufreq
150 : : * drivers of SMP systems. It will do following:
151 : : * - validate & show freq table passed
152 : : * - set policies transition latency
153 : : * - policy->cpus with all possible CPUs
154 : : */
155 : 0 : int cpufreq_generic_init(struct cpufreq_policy *policy,
156 : : struct cpufreq_frequency_table *table,
157 : : unsigned int transition_latency)
158 : : {
159 : : int ret;
160 : :
161 : 0 : ret = cpufreq_table_validate_and_show(policy, table);
162 [ # # ]: 0 : if (ret) {
163 : 0 : pr_err("%s: invalid frequency table: %d\n", __func__, ret);
164 : 0 : return ret;
165 : : }
166 : :
167 : 0 : policy->cpuinfo.transition_latency = transition_latency;
168 : :
169 : : /*
170 : : * The driver only supports the SMP configuartion where all processors
171 : : * share the clock and voltage and clock.
172 : : */
173 : : cpumask_setall(policy->cpus);
174 : :
175 : 0 : return 0;
176 : : }
177 : : EXPORT_SYMBOL_GPL(cpufreq_generic_init);
178 : :
179 : 0 : unsigned int cpufreq_generic_get(unsigned int cpu)
180 : : {
181 : 0 : struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
182 : :
183 [ # # ][ # # ]: 0 : if (!policy || IS_ERR(policy->clk)) {
184 [ # # ]: 0 : pr_err("%s: No %s associated to cpu: %d\n", __func__,
185 : : policy ? "clk" : "policy", cpu);
186 : 0 : return 0;
187 : : }
188 : :
189 : 0 : return clk_get_rate(policy->clk) / 1000;
190 : : }
191 : : EXPORT_SYMBOL_GPL(cpufreq_generic_get);
192 : :
193 : 0 : struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
194 : : {
195 : : struct cpufreq_policy *policy = NULL;
196 : : unsigned long flags;
197 : :
198 [ + - ][ + - ]: 164 : if (cpufreq_disabled() || (cpu >= nr_cpu_ids))
199 : : return NULL;
200 : :
201 [ + - ]: 164 : if (!down_read_trylock(&cpufreq_rwsem))
202 : : return NULL;
203 : :
204 : : /* get the cpufreq driver */
205 : 164 : read_lock_irqsave(&cpufreq_driver_lock, flags);
206 : :
207 [ + - ]: 164 : if (cpufreq_driver) {
208 : : /* get the CPU */
209 : 164 : policy = per_cpu(cpufreq_cpu_data, cpu);
210 [ + + ]: 164 : if (policy)
211 : 84 : kobject_get(&policy->kobj);
212 : : }
213 : :
214 : 164 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
215 : :
216 [ + + ]: 164 : if (!policy)
217 : 80 : up_read(&cpufreq_rwsem);
218 : :
219 : 164 : return policy;
220 : : }
221 : : EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
222 : :
223 : 0 : void cpufreq_cpu_put(struct cpufreq_policy *policy)
224 : : {
225 [ + - ]: 84 : if (cpufreq_disabled())
226 : 0 : return;
227 : :
228 : 84 : kobject_put(&policy->kobj);
229 : 84 : up_read(&cpufreq_rwsem);
230 : : }
231 : : EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
232 : :
233 : : /*********************************************************************
234 : : * EXTERNALLY AFFECTING FREQUENCY CHANGES *
235 : : *********************************************************************/
236 : :
237 : : /**
238 : : * adjust_jiffies - adjust the system "loops_per_jiffy"
239 : : *
240 : : * This function alters the system "loops_per_jiffy" for the clock
241 : : * speed change. Note that loops_per_jiffy cannot be updated on SMP
242 : : * systems as each CPU might be scaled differently. So, use the arch
243 : : * per-CPU loops_per_jiffy value wherever possible.
244 : : */
245 : : #ifndef CONFIG_SMP
246 : : static unsigned long l_p_j_ref;
247 : : static unsigned int l_p_j_ref_freq;
248 : :
249 : : static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
250 : : {
251 : : if (ci->flags & CPUFREQ_CONST_LOOPS)
252 : : return;
253 : :
254 : : if (!l_p_j_ref_freq) {
255 : : l_p_j_ref = loops_per_jiffy;
256 : : l_p_j_ref_freq = ci->old;
257 : : pr_debug("saving %lu as reference value for loops_per_jiffy; "
258 : : "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
259 : : }
260 : : if ((val == CPUFREQ_POSTCHANGE && ci->old != ci->new) ||
261 : : (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
262 : : loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
263 : : ci->new);
264 : : pr_debug("scaling loops_per_jiffy to %lu "
265 : : "for frequency %u kHz\n", loops_per_jiffy, ci->new);
266 : : }
267 : : }
268 : : #else
269 : : static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
270 : : {
271 : : return;
272 : : }
273 : : #endif
274 : :
275 : 0 : static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
276 : : struct cpufreq_freqs *freqs, unsigned int state)
277 : : {
278 [ - + ]: 12358 : BUG_ON(irqs_disabled());
279 : :
280 [ + - ]: 12358 : if (cpufreq_disabled())
281 : 12358 : return;
282 : :
283 : 12358 : freqs->flags = cpufreq_driver->flags;
284 : : pr_debug("notification %u of frequency transition to %u kHz\n",
285 : : state, freqs->new);
286 : :
287 [ + + - ]: 12358 : switch (state) {
288 : :
289 : : case CPUFREQ_PRECHANGE:
290 : : /* detect if the driver reported a value as "old frequency"
291 : : * which is not equal to what the cpufreq core thinks is
292 : : * "old frequency".
293 : : */
294 [ + - ]: 6179 : if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
295 [ + - ][ + + ]: 6179 : if ((policy) && (policy->cpu == freqs->cpu) &&
[ + - ]
296 [ - + ]: 2091 : (policy->cur) && (policy->cur != freqs->old)) {
297 : : pr_debug("Warning: CPU frequency is"
298 : : " %u, cpufreq assumed %u kHz.\n",
299 : : freqs->old, policy->cur);
300 : 0 : freqs->old = policy->cur;
301 : : }
302 : : }
303 : 6179 : srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
304 : : CPUFREQ_PRECHANGE, freqs);
305 : : adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
306 : : break;
307 : :
308 : : case CPUFREQ_POSTCHANGE:
309 : : adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
310 : : pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
311 : : (unsigned long)freqs->cpu);
312 : 6179 : trace_cpu_frequency(freqs->new, freqs->cpu);
313 : 6179 : srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
314 : : CPUFREQ_POSTCHANGE, freqs);
315 [ + - ][ + + ]: 6179 : if (likely(policy) && likely(policy->cpu == freqs->cpu))
316 : 2091 : policy->cur = freqs->new;
317 : : break;
318 : : }
319 : : }
320 : :
321 : : /**
322 : : * cpufreq_notify_transition - call notifier chain and adjust_jiffies
323 : : * on frequency transition.
324 : : *
325 : : * This function calls the transition notifiers and the "adjust_jiffies"
326 : : * function. It is called twice on all CPU frequency changes that have
327 : : * external effects.
328 : : */
329 : 0 : void cpufreq_notify_transition(struct cpufreq_policy *policy,
330 : : struct cpufreq_freqs *freqs, unsigned int state)
331 : : {
332 [ + + ]: 20722 : for_each_cpu(freqs->cpu, policy->cpus)
333 : 12358 : __cpufreq_notify_transition(policy, freqs, state);
334 : 4182 : }
335 : : EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
336 : :
337 : : /* Do post notifications when there are chances that transition has failed */
338 : 0 : void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
339 : : struct cpufreq_freqs *freqs, int transition_failed)
340 : : {
341 : 2076 : cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
342 [ - + ]: 2076 : if (!transition_failed)
343 : 0 : return;
344 : :
345 : 0 : swap(freqs->old, freqs->new);
346 : 0 : cpufreq_notify_transition(policy, freqs, CPUFREQ_PRECHANGE);
347 : 0 : cpufreq_notify_transition(policy, freqs, CPUFREQ_POSTCHANGE);
348 : : }
349 : : EXPORT_SYMBOL_GPL(cpufreq_notify_post_transition);
350 : :
351 : :
352 : : /*********************************************************************
353 : : * SYSFS INTERFACE *
354 : : *********************************************************************/
355 : 0 : ssize_t show_boost(struct kobject *kobj,
356 : : struct attribute *attr, char *buf)
357 : : {
358 : 0 : return sprintf(buf, "%d\n", cpufreq_driver->boost_enabled);
359 : : }
360 : :
361 : 0 : static ssize_t store_boost(struct kobject *kobj, struct attribute *attr,
362 : : const char *buf, size_t count)
363 : : {
364 : : int ret, enable;
365 : :
366 : 0 : ret = sscanf(buf, "%d", &enable);
367 [ # # ][ # # ]: 0 : if (ret != 1 || enable < 0 || enable > 1)
[ # # ]
368 : : return -EINVAL;
369 : :
370 [ # # ]: 0 : if (cpufreq_boost_trigger_state(enable)) {
371 [ # # ]: 0 : pr_err("%s: Cannot %s BOOST!\n", __func__,
372 : : enable ? "enable" : "disable");
373 : 0 : return -EINVAL;
374 : : }
375 : :
376 : : pr_debug("%s: cpufreq BOOST %s\n", __func__,
377 : : enable ? "enabled" : "disabled");
378 : :
379 : 0 : return count;
380 : : }
381 : : define_one_global_rw(boost);
382 : :
383 : 0 : static struct cpufreq_governor *__find_governor(const char *str_governor)
384 : : {
385 : : struct cpufreq_governor *t;
386 : :
387 [ + - ]: 7 : list_for_each_entry(t, &cpufreq_governor_list, governor_list)
388 [ + + ]: 7 : if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
389 : : return t;
390 : :
391 : : return NULL;
392 : : }
393 : :
394 : : /**
395 : : * cpufreq_parse_governor - parse a governor string
396 : : */
397 : 0 : static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
398 : : struct cpufreq_governor **governor)
399 : : {
400 : : int err = -EINVAL;
401 : :
402 [ # # ]: 0 : if (!cpufreq_driver)
403 : : goto out;
404 : :
405 [ # # ]: 0 : if (cpufreq_driver->setpolicy) {
406 [ # # ]: 0 : if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
407 : 0 : *policy = CPUFREQ_POLICY_PERFORMANCE;
408 : : err = 0;
409 [ # # ]: 0 : } else if (!strnicmp(str_governor, "powersave",
410 : : CPUFREQ_NAME_LEN)) {
411 : 0 : *policy = CPUFREQ_POLICY_POWERSAVE;
412 : : err = 0;
413 : : }
414 [ # # ]: 0 : } else if (has_target()) {
415 : : struct cpufreq_governor *t;
416 : :
417 : 0 : mutex_lock(&cpufreq_governor_mutex);
418 : :
419 : 0 : t = __find_governor(str_governor);
420 : :
421 [ # # ]: 0 : if (t == NULL) {
422 : : int ret;
423 : :
424 : 0 : mutex_unlock(&cpufreq_governor_mutex);
425 : 0 : ret = request_module("cpufreq_%s", str_governor);
426 : 0 : mutex_lock(&cpufreq_governor_mutex);
427 : :
428 [ # # ]: 0 : if (ret == 0)
429 : 0 : t = __find_governor(str_governor);
430 : : }
431 : :
432 [ # # ]: 0 : if (t != NULL) {
433 : 0 : *governor = t;
434 : : err = 0;
435 : : }
436 : :
437 : 0 : mutex_unlock(&cpufreq_governor_mutex);
438 : : }
439 : : out:
440 : 0 : return err;
441 : : }
442 : :
443 : : /**
444 : : * cpufreq_per_cpu_attr_read() / show_##file_name() -
445 : : * print out cpufreq information
446 : : *
447 : : * Write out information from cpufreq_driver->policy[cpu]; object must be
448 : : * "unsigned int".
449 : : */
450 : :
451 : : #define show_one(file_name, object) \
452 : : static ssize_t show_##file_name \
453 : : (struct cpufreq_policy *policy, char *buf) \
454 : : { \
455 : : return sprintf(buf, "%u\n", policy->object); \
456 : : }
457 : :
458 : 0 : show_one(cpuinfo_min_freq, cpuinfo.min_freq);
459 : 0 : show_one(cpuinfo_max_freq, cpuinfo.max_freq);
460 : 0 : show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
461 : 0 : show_one(scaling_min_freq, min);
462 : 0 : show_one(scaling_max_freq, max);
463 : 0 : show_one(scaling_cur_freq, cur);
464 : :
465 : : static int cpufreq_set_policy(struct cpufreq_policy *policy,
466 : : struct cpufreq_policy *new_policy);
467 : :
468 : : /**
469 : : * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
470 : : */
471 : : #define store_one(file_name, object) \
472 : : static ssize_t store_##file_name \
473 : : (struct cpufreq_policy *policy, const char *buf, size_t count) \
474 : : { \
475 : : int ret; \
476 : : struct cpufreq_policy new_policy; \
477 : : \
478 : : ret = cpufreq_get_policy(&new_policy, policy->cpu); \
479 : : if (ret) \
480 : : return -EINVAL; \
481 : : \
482 : : ret = sscanf(buf, "%u", &new_policy.object); \
483 : : if (ret != 1) \
484 : : return -EINVAL; \
485 : : \
486 : : ret = cpufreq_set_policy(policy, &new_policy); \
487 : : policy->user_policy.object = policy->object; \
488 : : \
489 : : return ret ? ret : count; \
490 : : }
491 : :
492 [ # # ][ # # ]: 0 : store_one(scaling_min_freq, min);
[ # # ]
493 [ # # ][ # # ]: 0 : store_one(scaling_max_freq, max);
[ # # ]
494 : :
495 : : /**
496 : : * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
497 : : */
498 : 0 : static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
499 : : char *buf)
500 : : {
501 : 0 : unsigned int cur_freq = __cpufreq_get(policy->cpu);
502 [ # # ]: 0 : if (!cur_freq)
503 : 0 : return sprintf(buf, "<unknown>");
504 : 0 : return sprintf(buf, "%u\n", cur_freq);
505 : : }
506 : :
507 : : /**
508 : : * show_scaling_governor - show the current policy for the specified CPU
509 : : */
510 : 0 : static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
511 : : {
512 [ # # ]: 0 : if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
513 : 0 : return sprintf(buf, "powersave\n");
514 [ # # ]: 0 : else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
515 : 0 : return sprintf(buf, "performance\n");
516 [ # # ]: 0 : else if (policy->governor)
517 : 0 : return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
518 : 0 : policy->governor->name);
519 : : return -EINVAL;
520 : : }
521 : :
522 : : /**
523 : : * store_scaling_governor - store policy for the specified CPU
524 : : */
525 : 0 : static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
526 : : const char *buf, size_t count)
527 : : {
528 : : int ret;
529 : : char str_governor[16];
530 : : struct cpufreq_policy new_policy;
531 : :
532 : 0 : ret = cpufreq_get_policy(&new_policy, policy->cpu);
533 [ # # ]: 0 : if (ret)
534 : : return ret;
535 : :
536 : 0 : ret = sscanf(buf, "%15s", str_governor);
537 [ # # ]: 0 : if (ret != 1)
538 : : return -EINVAL;
539 : :
540 [ # # ]: 0 : if (cpufreq_parse_governor(str_governor, &new_policy.policy,
541 : : &new_policy.governor))
542 : : return -EINVAL;
543 : :
544 : 0 : ret = cpufreq_set_policy(policy, &new_policy);
545 : :
546 : 0 : policy->user_policy.policy = policy->policy;
547 : 0 : policy->user_policy.governor = policy->governor;
548 : :
549 [ # # ]: 0 : if (ret)
550 : : return ret;
551 : : else
552 : 0 : return count;
553 : : }
554 : :
555 : : /**
556 : : * show_scaling_driver - show the cpufreq driver currently loaded
557 : : */
558 : 0 : static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
559 : : {
560 : 0 : return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
561 : : }
562 : :
563 : : /**
564 : : * show_scaling_available_governors - show the available CPUfreq governors
565 : : */
566 : 0 : static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
567 : : char *buf)
568 : : {
569 : : ssize_t i = 0;
570 : : struct cpufreq_governor *t;
571 : :
572 [ # # ]: 0 : if (!has_target()) {
573 : 0 : i += sprintf(buf, "performance powersave");
574 : 0 : goto out;
575 : : }
576 : :
577 [ # # ]: 0 : list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
578 [ # # ]: 0 : if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
579 : : - (CPUFREQ_NAME_LEN + 2)))
580 : : goto out;
581 : 0 : i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
582 : : }
583 : : out:
584 : 0 : i += sprintf(&buf[i], "\n");
585 : 0 : return i;
586 : : }
587 : :
588 : 0 : ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
589 : : {
590 : : ssize_t i = 0;
591 : : unsigned int cpu;
592 : :
593 [ # # ]: 0 : for_each_cpu(cpu, mask) {
594 [ # # ]: 0 : if (i)
595 : 0 : i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
596 : 0 : i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
597 [ # # ]: 0 : if (i >= (PAGE_SIZE - 5))
598 : : break;
599 : : }
600 : 0 : i += sprintf(&buf[i], "\n");
601 : 0 : return i;
602 : : }
603 : : EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
604 : :
605 : : /**
606 : : * show_related_cpus - show the CPUs affected by each transition even if
607 : : * hw coordination is in use
608 : : */
609 : 0 : static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
610 : : {
611 : 0 : return cpufreq_show_cpus(policy->related_cpus, buf);
612 : : }
613 : :
614 : : /**
615 : : * show_affected_cpus - show the CPUs affected by each transition
616 : : */
617 : 0 : static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
618 : : {
619 : 0 : return cpufreq_show_cpus(policy->cpus, buf);
620 : : }
621 : :
622 : 0 : static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
623 : : const char *buf, size_t count)
624 : : {
625 : 0 : unsigned int freq = 0;
626 : : unsigned int ret;
627 : :
628 [ # # ][ # # ]: 0 : if (!policy->governor || !policy->governor->store_setspeed)
629 : : return -EINVAL;
630 : :
631 : 0 : ret = sscanf(buf, "%u", &freq);
632 [ # # ]: 0 : if (ret != 1)
633 : : return -EINVAL;
634 : :
635 : 0 : policy->governor->store_setspeed(policy, freq);
636 : :
637 : 0 : return count;
638 : : }
639 : :
640 : 0 : static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
641 : : {
642 [ # # ][ # # ]: 0 : if (!policy->governor || !policy->governor->show_setspeed)
643 : 0 : return sprintf(buf, "<unsupported>\n");
644 : :
645 : 0 : return policy->governor->show_setspeed(policy, buf);
646 : : }
647 : :
648 : : /**
649 : : * show_bios_limit - show the current cpufreq HW/BIOS limitation
650 : : */
651 : 0 : static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
652 : : {
653 : : unsigned int limit;
654 : : int ret;
655 [ # # ]: 0 : if (cpufreq_driver->bios_limit) {
656 : 0 : ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
657 [ # # ]: 0 : if (!ret)
658 : 0 : return sprintf(buf, "%u\n", limit);
659 : : }
660 : 0 : return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
661 : : }
662 : :
663 : : cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
664 : : cpufreq_freq_attr_ro(cpuinfo_min_freq);
665 : : cpufreq_freq_attr_ro(cpuinfo_max_freq);
666 : : cpufreq_freq_attr_ro(cpuinfo_transition_latency);
667 : : cpufreq_freq_attr_ro(scaling_available_governors);
668 : : cpufreq_freq_attr_ro(scaling_driver);
669 : : cpufreq_freq_attr_ro(scaling_cur_freq);
670 : : cpufreq_freq_attr_ro(bios_limit);
671 : : cpufreq_freq_attr_ro(related_cpus);
672 : : cpufreq_freq_attr_ro(affected_cpus);
673 : : cpufreq_freq_attr_rw(scaling_min_freq);
674 : : cpufreq_freq_attr_rw(scaling_max_freq);
675 : : cpufreq_freq_attr_rw(scaling_governor);
676 : : cpufreq_freq_attr_rw(scaling_setspeed);
677 : :
678 : : static struct attribute *default_attrs[] = {
679 : : &cpuinfo_min_freq.attr,
680 : : &cpuinfo_max_freq.attr,
681 : : &cpuinfo_transition_latency.attr,
682 : : &scaling_min_freq.attr,
683 : : &scaling_max_freq.attr,
684 : : &affected_cpus.attr,
685 : : &related_cpus.attr,
686 : : &scaling_governor.attr,
687 : : &scaling_driver.attr,
688 : : &scaling_available_governors.attr,
689 : : &scaling_setspeed.attr,
690 : : NULL
691 : : };
692 : :
693 : : #define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
694 : : #define to_attr(a) container_of(a, struct freq_attr, attr)
695 : :
696 : 0 : static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
697 : : {
698 : 0 : struct cpufreq_policy *policy = to_policy(kobj);
699 : : struct freq_attr *fattr = to_attr(attr);
700 : : ssize_t ret;
701 : :
702 [ # # ]: 0 : if (!down_read_trylock(&cpufreq_rwsem))
703 : : return -EINVAL;
704 : :
705 : 0 : down_read(&policy->rwsem);
706 : :
707 [ # # ]: 0 : if (fattr->show)
708 : 0 : ret = fattr->show(policy, buf);
709 : : else
710 : : ret = -EIO;
711 : :
712 : 0 : up_read(&policy->rwsem);
713 : 0 : up_read(&cpufreq_rwsem);
714 : :
715 : 0 : return ret;
716 : : }
717 : :
718 : 0 : static ssize_t store(struct kobject *kobj, struct attribute *attr,
719 : : const char *buf, size_t count)
720 : : {
721 : 0 : struct cpufreq_policy *policy = to_policy(kobj);
722 : : struct freq_attr *fattr = to_attr(attr);
723 : : ssize_t ret = -EINVAL;
724 : :
725 : 0 : get_online_cpus();
726 : :
727 [ # # ]: 0 : if (!cpu_online(policy->cpu))
728 : : goto unlock;
729 : :
730 [ # # ]: 0 : if (!down_read_trylock(&cpufreq_rwsem))
731 : : goto unlock;
732 : :
733 : 0 : down_write(&policy->rwsem);
734 : :
735 [ # # ]: 0 : if (fattr->store)
736 : 0 : ret = fattr->store(policy, buf, count);
737 : : else
738 : : ret = -EIO;
739 : :
740 : 0 : up_write(&policy->rwsem);
741 : :
742 : 0 : up_read(&cpufreq_rwsem);
743 : : unlock:
744 : 0 : put_online_cpus();
745 : :
746 : 0 : return ret;
747 : : }
748 : :
749 : 0 : static void cpufreq_sysfs_release(struct kobject *kobj)
750 : : {
751 : : struct cpufreq_policy *policy = to_policy(kobj);
752 : : pr_debug("last reference is dropped\n");
753 : 3 : complete(&policy->kobj_unregister);
754 : 3 : }
755 : :
756 : : static const struct sysfs_ops sysfs_ops = {
757 : : .show = show,
758 : : .store = store,
759 : : };
760 : :
761 : : static struct kobj_type ktype_cpufreq = {
762 : : .sysfs_ops = &sysfs_ops,
763 : : .default_attrs = default_attrs,
764 : : .release = cpufreq_sysfs_release,
765 : : };
766 : :
767 : : struct kobject *cpufreq_global_kobject;
768 : : EXPORT_SYMBOL(cpufreq_global_kobject);
769 : :
770 : : static int cpufreq_global_kobject_usage;
771 : :
772 : 0 : int cpufreq_get_global_kobject(void)
773 : : {
774 [ # # ]: 0 : if (!cpufreq_global_kobject_usage++)
775 : 0 : return kobject_add(cpufreq_global_kobject,
776 : 0 : &cpu_subsys.dev_root->kobj, "%s", "cpufreq");
777 : :
778 : : return 0;
779 : : }
780 : : EXPORT_SYMBOL(cpufreq_get_global_kobject);
781 : :
782 : 0 : void cpufreq_put_global_kobject(void)
783 : : {
784 [ # # ]: 0 : if (!--cpufreq_global_kobject_usage)
785 : 0 : kobject_del(cpufreq_global_kobject);
786 : 0 : }
787 : : EXPORT_SYMBOL(cpufreq_put_global_kobject);
788 : :
789 : 0 : int cpufreq_sysfs_create_file(const struct attribute *attr)
790 : : {
791 : 0 : int ret = cpufreq_get_global_kobject();
792 : :
793 [ # # ]: 0 : if (!ret) {
794 : 0 : ret = sysfs_create_file(cpufreq_global_kobject, attr);
795 [ # # ]: 0 : if (ret)
796 : 0 : cpufreq_put_global_kobject();
797 : : }
798 : :
799 : 0 : return ret;
800 : : }
801 : : EXPORT_SYMBOL(cpufreq_sysfs_create_file);
802 : :
803 : 0 : void cpufreq_sysfs_remove_file(const struct attribute *attr)
804 : : {
805 : 0 : sysfs_remove_file(cpufreq_global_kobject, attr);
806 : 0 : cpufreq_put_global_kobject();
807 : 0 : }
808 : : EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
809 : :
810 : : /* symlink affected CPUs */
811 : 0 : static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
812 : : {
813 : : unsigned int j;
814 : : int ret = 0;
815 : :
816 [ + + ]: 12 : for_each_cpu(j, policy->cpus) {
817 : : struct device *cpu_dev;
818 : :
819 [ + + ]: 6 : if (j == policy->cpu)
820 : 3 : continue;
821 : :
822 : : pr_debug("Adding link for CPU: %u\n", j);
823 : 3 : cpu_dev = get_cpu_device(j);
824 : 3 : ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
825 : : "cpufreq");
826 [ + - ]: 6 : if (ret)
827 : : break;
828 : : }
829 : 3 : return ret;
830 : : }
831 : :
832 : 0 : static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
833 : : struct device *dev)
834 : : {
835 : : struct freq_attr **drv_attr;
836 : : int ret = 0;
837 : :
838 : : /* prepare interface data */
839 : 3 : ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
840 : : &dev->kobj, "cpufreq");
841 [ + - ]: 3 : if (ret)
842 : : return ret;
843 : :
844 : : /* set up files for this cpu device */
845 : 3 : drv_attr = cpufreq_driver->attr;
846 [ + - ][ + + ]: 6 : while ((drv_attr) && (*drv_attr)) {
847 : 3 : ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
848 [ + - ]: 3 : if (ret)
849 : : goto err_out_kobj_put;
850 : 3 : drv_attr++;
851 : : }
852 [ + - ]: 3 : if (cpufreq_driver->get) {
853 : : ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
854 [ + ]: 3 : if (ret)
855 : : goto err_out_kobj_put;
856 : : }
857 [ + - ]: 3 : if (has_target()) {
858 : : ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
859 [ + - ]: 3 : if (ret)
860 : : goto err_out_kobj_put;
861 : : }
862 [ - + ]: 3 : if (cpufreq_driver->bios_limit) {
863 : : ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
864 [ # # ]: 0 : if (ret)
865 : : goto err_out_kobj_put;
866 : : }
867 : :
868 : 3 : ret = cpufreq_add_dev_symlink(policy);
869 [ - + ]: 3 : if (ret)
870 : : goto err_out_kobj_put;
871 : :
872 : : return ret;
873 : :
874 : : err_out_kobj_put:
875 : 0 : kobject_put(&policy->kobj);
876 : 0 : wait_for_completion(&policy->kobj_unregister);
877 : 0 : return ret;
878 : : }
879 : :
880 : 0 : static void cpufreq_init_policy(struct cpufreq_policy *policy)
881 : : {
882 : : struct cpufreq_policy new_policy;
883 : : int ret = 0;
884 : :
885 : 3 : memcpy(&new_policy, policy, sizeof(*policy));
886 : :
887 : : /* Use the default policy if its valid. */
888 [ - + ]: 3 : if (cpufreq_driver->setpolicy)
889 : 0 : cpufreq_parse_governor(policy->governor->name,
890 : : &new_policy.policy, NULL);
891 : :
892 : : /* assure that the starting sequence is run in cpufreq_set_policy */
893 : 3 : policy->governor = NULL;
894 : :
895 : : /* set default policy */
896 : 3 : ret = cpufreq_set_policy(policy, &new_policy);
897 [ - + ]: 3 : if (ret) {
898 : : pr_debug("setting policy failed\n");
899 [ # # ]: 0 : if (cpufreq_driver->exit)
900 : 0 : cpufreq_driver->exit(policy);
901 : : }
902 : 3 : }
903 : :
904 : : #ifdef CONFIG_HOTPLUG_CPU
905 : 0 : static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
906 : : unsigned int cpu, struct device *dev)
907 : : {
908 : : int ret = 0;
909 : : unsigned long flags;
910 : :
911 [ + - ]: 77 : if (has_target()) {
912 : 77 : ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
913 [ - + ]: 77 : if (ret) {
914 : 0 : pr_err("%s: Failed to stop governor\n", __func__);
915 : 0 : return ret;
916 : : }
917 : : }
918 : :
919 : 77 : down_write(&policy->rwsem);
920 : :
921 : 77 : write_lock_irqsave(&cpufreq_driver_lock, flags);
922 : :
923 : : cpumask_set_cpu(cpu, policy->cpus);
924 : 77 : per_cpu(cpufreq_cpu_data, cpu) = policy;
925 : 77 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
926 : :
927 : 77 : up_write(&policy->rwsem);
928 : :
929 [ + - ]: 77 : if (has_target()) {
930 [ + - ][ - + ]: 77 : if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
931 : : (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
932 : 0 : pr_err("%s: Failed to start governor\n", __func__);
933 : 0 : return ret;
934 : : }
935 : : }
936 : :
937 : 77 : return sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
938 : : }
939 : : #endif
940 : :
941 : 0 : static struct cpufreq_policy *cpufreq_policy_restore(unsigned int cpu)
942 : : {
943 : : struct cpufreq_policy *policy;
944 : : unsigned long flags;
945 : :
946 : 0 : read_lock_irqsave(&cpufreq_driver_lock, flags);
947 : :
948 : 0 : policy = per_cpu(cpufreq_cpu_data_fallback, cpu);
949 : :
950 : 0 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
951 : :
952 : 0 : return policy;
953 : : }
954 : :
955 : 0 : static struct cpufreq_policy *cpufreq_policy_alloc(void)
956 : : {
957 : : struct cpufreq_policy *policy;
958 : :
959 : : policy = kzalloc(sizeof(*policy), GFP_KERNEL);
960 [ + - ]: 3 : if (!policy)
961 : : return NULL;
962 : :
963 : : if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
964 : : goto err_free_policy;
965 : :
966 : : if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
967 : : goto err_free_cpumask;
968 : :
969 : 3 : INIT_LIST_HEAD(&policy->policy_list);
970 : 3 : init_rwsem(&policy->rwsem);
971 : :
972 : 3 : return policy;
973 : :
974 : : err_free_cpumask:
975 : : free_cpumask_var(policy->cpus);
976 : : err_free_policy:
977 : : kfree(policy);
978 : :
979 : : return NULL;
980 : : }
981 : :
982 : 0 : static void cpufreq_policy_put_kobj(struct cpufreq_policy *policy)
983 : : {
984 : : struct kobject *kobj;
985 : : struct completion *cmp;
986 : :
987 : 3 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
988 : : CPUFREQ_REMOVE_POLICY, policy);
989 : :
990 : 3 : down_read(&policy->rwsem);
991 : 3 : kobj = &policy->kobj;
992 : 3 : cmp = &policy->kobj_unregister;
993 : 3 : up_read(&policy->rwsem);
994 : 3 : kobject_put(kobj);
995 : :
996 : : /*
997 : : * We need to make sure that the underlying kobj is
998 : : * actually not referenced anymore by anybody before we
999 : : * proceed with unloading.
1000 : : */
1001 : : pr_debug("waiting for dropping of refcount\n");
1002 : 3 : wait_for_completion(cmp);
1003 : : pr_debug("wait complete\n");
1004 : 3 : }
1005 : :
1006 : : static void cpufreq_policy_free(struct cpufreq_policy *policy)
1007 : : {
1008 : : free_cpumask_var(policy->related_cpus);
1009 : : free_cpumask_var(policy->cpus);
1010 : 3 : kfree(policy);
1011 : : }
1012 : :
1013 : 0 : static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
1014 : : {
1015 [ - + ][ + - ]: 29 : if (WARN_ON(cpu == policy->cpu))
1016 : 29 : return;
1017 : :
1018 : 29 : down_write(&policy->rwsem);
1019 : :
1020 : 29 : policy->last_cpu = policy->cpu;
1021 : 29 : policy->cpu = cpu;
1022 : :
1023 : 29 : up_write(&policy->rwsem);
1024 : :
1025 : 29 : cpufreq_frequency_table_update_policy_cpu(policy);
1026 : 29 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1027 : : CPUFREQ_UPDATE_POLICY_CPU, policy);
1028 : : }
1029 : :
1030 : 0 : static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
1031 : : bool frozen)
1032 : : {
1033 : 83 : unsigned int j, cpu = dev->id;
1034 : : int ret = -ENOMEM;
1035 : : struct cpufreq_policy *policy;
1036 : : unsigned long flags;
1037 : : #ifdef CONFIG_HOTPLUG_CPU
1038 : : struct cpufreq_policy *tpolicy;
1039 : : struct cpufreq_governor *gov;
1040 : : #endif
1041 : :
1042 [ + - ]: 83 : if (cpu_is_offline(cpu))
1043 : : return 0;
1044 : :
1045 : : pr_debug("adding CPU %u\n", cpu);
1046 : :
1047 : : #ifdef CONFIG_SMP
1048 : : /* check whether a different CPU already registered this
1049 : : * CPU because it is in the same boat. */
1050 : 83 : policy = cpufreq_cpu_get(cpu);
1051 [ + + ]: 83 : if (unlikely(policy)) {
1052 : 3 : cpufreq_cpu_put(policy);
1053 : : return 0;
1054 : : }
1055 : : #endif
1056 : :
1057 [ + - ]: 80 : if (!down_read_trylock(&cpufreq_rwsem))
1058 : : return 0;
1059 : :
1060 : : #ifdef CONFIG_HOTPLUG_CPU
1061 : : /* Check if this cpu was hot-unplugged earlier and has siblings */
1062 : 80 : read_lock_irqsave(&cpufreq_driver_lock, flags);
1063 [ + + ]: 114 : list_for_each_entry(tpolicy, &cpufreq_policy_list, policy_list) {
1064 [ + + ]: 111 : if (cpumask_test_cpu(cpu, tpolicy->related_cpus)) {
1065 : 77 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1066 : 77 : ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev);
1067 : 77 : up_read(&cpufreq_rwsem);
1068 : : return ret;
1069 : : }
1070 : : }
1071 : 3 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1072 : : #endif
1073 : :
1074 : : /*
1075 : : * Restore the saved policy when doing light-weight init and fall back
1076 : : * to the full init if that fails.
1077 : : */
1078 [ - + ]: 3 : policy = frozen ? cpufreq_policy_restore(cpu) : NULL;
1079 [ + - ]: 3 : if (!policy) {
1080 : : frozen = false;
1081 : 3 : policy = cpufreq_policy_alloc();
1082 [ + - ]: 3 : if (!policy)
1083 : : goto nomem_out;
1084 : : }
1085 : :
1086 : : /*
1087 : : * In the resume path, since we restore a saved policy, the assignment
1088 : : * to policy->cpu is like an update of the existing policy, rather than
1089 : : * the creation of a brand new one. So we need to perform this update
1090 : : * by invoking update_policy_cpu().
1091 : : */
1092 [ - + ][ # # ]: 3 : if (frozen && cpu != policy->cpu)
1093 : 0 : update_policy_cpu(policy, cpu);
1094 : : else
1095 : 3 : policy->cpu = cpu;
1096 : :
1097 : 3 : policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
1098 : : cpumask_copy(policy->cpus, cpumask_of(cpu));
1099 : :
1100 : : init_completion(&policy->kobj_unregister);
1101 : 6 : INIT_WORK(&policy->update, handle_update);
1102 : :
1103 : : /* call driver. From then on the cpufreq must be able
1104 : : * to accept all calls to ->verify and ->setpolicy for this CPU
1105 : : */
1106 : 3 : ret = cpufreq_driver->init(policy);
1107 [ + - ]: 3 : if (ret) {
1108 : : pr_debug("initialization failed\n");
1109 : : goto err_set_policy_cpu;
1110 : : }
1111 : :
1112 : : /* related cpus should atleast have policy->cpus */
1113 : : cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
1114 : :
1115 : : /*
1116 : : * affected cpus must always be the one, which are online. We aren't
1117 : : * managing offline cpus here.
1118 : : */
1119 : : cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1120 : :
1121 [ + - ]: 3 : if (!frozen) {
1122 : 3 : policy->user_policy.min = policy->min;
1123 : 3 : policy->user_policy.max = policy->max;
1124 : : }
1125 : :
1126 : 3 : down_write(&policy->rwsem);
1127 : 3 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1128 [ + + ]: 9 : for_each_cpu(j, policy->cpus)
1129 : 6 : per_cpu(cpufreq_cpu_data, j) = policy;
1130 : 3 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1131 : :
1132 [ + - ][ + - ]: 3 : if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
1133 : 3 : policy->cur = cpufreq_driver->get(policy->cpu);
1134 [ - + ]: 3 : if (!policy->cur) {
1135 : 0 : pr_err("%s: ->get() failed\n", __func__);
1136 : : goto err_get_freq;
1137 : : }
1138 : : }
1139 : :
1140 : : /*
1141 : : * Sometimes boot loaders set CPU frequency to a value outside of
1142 : : * frequency table present with cpufreq core. In such cases CPU might be
1143 : : * unstable if it has to run on that frequency for long duration of time
1144 : : * and so its better to set it to a frequency which is specified in
1145 : : * freq-table. This also makes cpufreq stats inconsistent as
1146 : : * cpufreq-stats would fail to register because current frequency of CPU
1147 : : * isn't found in freq-table.
1148 : : *
1149 : : * Because we don't want this change to effect boot process badly, we go
1150 : : * for the next freq which is >= policy->cur ('cur' must be set by now,
1151 : : * otherwise we will end up setting freq to lowest of the table as 'cur'
1152 : : * is initialized to zero).
1153 : : *
1154 : : * We are passing target-freq as "policy->cur - 1" otherwise
1155 : : * __cpufreq_driver_target() would simply fail, as policy->cur will be
1156 : : * equal to target-freq.
1157 : : */
1158 [ + - ]: 3 : if ((cpufreq_driver->flags & CPUFREQ_NEED_INITIAL_FREQ_CHECK)
1159 [ + - ]: 3 : && has_target()) {
1160 : : /* Are we running at unknown frequency ? */
1161 : 3 : ret = cpufreq_frequency_table_get_index(policy, policy->cur);
1162 [ - + ]: 3 : if (ret == -EINVAL) {
1163 : : /* Warn user and fix it */
1164 : 0 : pr_warn("%s: CPU%d: Running at unlisted freq: %u KHz\n",
1165 : : __func__, policy->cpu, policy->cur);
1166 : 0 : ret = __cpufreq_driver_target(policy, policy->cur - 1,
1167 : : CPUFREQ_RELATION_L);
1168 : :
1169 : : /*
1170 : : * Reaching here after boot in a few seconds may not
1171 : : * mean that system will remain stable at "unknown"
1172 : : * frequency for longer duration. Hence, a BUG_ON().
1173 : : */
1174 [ # # ]: 0 : BUG_ON(ret);
1175 : 0 : pr_warn("%s: CPU%d: Unlisted initial frequency changed to: %u KHz\n",
1176 : : __func__, policy->cpu, policy->cur);
1177 : : }
1178 : : }
1179 : :
1180 : 3 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1181 : : CPUFREQ_START, policy);
1182 : :
1183 : : #ifdef CONFIG_HOTPLUG_CPU
1184 : 3 : gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
1185 [ + - ]: 3 : if (gov) {
1186 : 3 : policy->governor = gov;
1187 : : pr_debug("Restoring governor %s for cpu %d\n",
1188 : : policy->governor->name, cpu);
1189 : : }
1190 : : #endif
1191 : :
1192 [ + - ]: 3 : if (!frozen) {
1193 : 3 : ret = cpufreq_add_dev_interface(policy, dev);
1194 [ + - ]: 3 : if (ret)
1195 : : goto err_out_unregister;
1196 : 3 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1197 : : CPUFREQ_CREATE_POLICY, policy);
1198 : : }
1199 : :
1200 : 3 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1201 : 3 : list_add(&policy->policy_list, &cpufreq_policy_list);
1202 : 3 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1203 : :
1204 : 3 : cpufreq_init_policy(policy);
1205 : :
1206 [ + - ]: 3 : if (!frozen) {
1207 : 3 : policy->user_policy.policy = policy->policy;
1208 : 3 : policy->user_policy.governor = policy->governor;
1209 : : }
1210 : 3 : up_write(&policy->rwsem);
1211 : :
1212 : 3 : kobject_uevent(&policy->kobj, KOBJ_ADD);
1213 : 3 : up_read(&cpufreq_rwsem);
1214 : :
1215 : : pr_debug("initialization complete\n");
1216 : :
1217 : : return 0;
1218 : :
1219 : : err_out_unregister:
1220 : : err_get_freq:
1221 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1222 [ # # ]: 0 : for_each_cpu(j, policy->cpus)
1223 : 0 : per_cpu(cpufreq_cpu_data, j) = NULL;
1224 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1225 : :
1226 [ # # ]: 0 : if (cpufreq_driver->exit)
1227 : 0 : cpufreq_driver->exit(policy);
1228 : : err_set_policy_cpu:
1229 [ # # ]: 0 : if (frozen) {
1230 : : /* Do not leave stale fallback data behind. */
1231 : 0 : per_cpu(cpufreq_cpu_data_fallback, cpu) = NULL;
1232 : 0 : cpufreq_policy_put_kobj(policy);
1233 : : }
1234 : : cpufreq_policy_free(policy);
1235 : :
1236 : : nomem_out:
1237 : 0 : up_read(&cpufreq_rwsem);
1238 : :
1239 : : return ret;
1240 : : }
1241 : :
1242 : : /**
1243 : : * cpufreq_add_dev - add a CPU device
1244 : : *
1245 : : * Adds the cpufreq interface for a CPU device.
1246 : : *
1247 : : * The Oracle says: try running cpufreq registration/unregistration concurrently
1248 : : * with with cpu hotplugging and all hell will break loose. Tried to clean this
1249 : : * mess up, but more thorough testing is needed. - Mathieu
1250 : : */
1251 : 0 : static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1252 : : {
1253 : 5 : return __cpufreq_add_dev(dev, sif, false);
1254 : : }
1255 : :
1256 : 0 : static int cpufreq_nominate_new_policy_cpu(struct cpufreq_policy *policy,
1257 : : unsigned int old_cpu)
1258 : : {
1259 : : struct device *cpu_dev;
1260 : : int ret;
1261 : :
1262 : : /* first sibling now owns the new sysfs dir */
1263 : 29 : cpu_dev = get_cpu_device(cpumask_any_but(policy->cpus, old_cpu));
1264 : :
1265 : 29 : sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1266 : 29 : ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
1267 [ - + ]: 58 : if (ret) {
1268 : 0 : pr_err("%s: Failed to move kobj: %d", __func__, ret);
1269 : :
1270 : 0 : down_write(&policy->rwsem);
1271 : : cpumask_set_cpu(old_cpu, policy->cpus);
1272 : 0 : up_write(&policy->rwsem);
1273 : :
1274 : 0 : ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
1275 : : "cpufreq");
1276 : :
1277 : 0 : return -EINVAL;
1278 : : }
1279 : :
1280 : 29 : return cpu_dev->id;
1281 : : }
1282 : :
1283 : 0 : static int __cpufreq_remove_dev_prepare(struct device *dev,
1284 : : struct subsys_interface *sif,
1285 : : bool frozen)
1286 : : {
1287 : 80 : unsigned int cpu = dev->id, cpus;
1288 : : int new_cpu, ret;
1289 : : unsigned long flags;
1290 : : struct cpufreq_policy *policy;
1291 : :
1292 : : pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1293 : :
1294 : 80 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1295 : :
1296 : 80 : policy = per_cpu(cpufreq_cpu_data, cpu);
1297 : :
1298 : : /* Save the policy somewhere when doing a light-weight tear-down */
1299 [ - + ]: 80 : if (frozen)
1300 : 0 : per_cpu(cpufreq_cpu_data_fallback, cpu) = policy;
1301 : :
1302 : 80 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1303 : :
1304 [ + - ]: 80 : if (!policy) {
1305 : : pr_debug("%s: No cpu_data found\n", __func__);
1306 : : return -EINVAL;
1307 : : }
1308 : :
1309 [ + - ]: 80 : if (has_target()) {
1310 : 80 : ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1311 [ - + ]: 80 : if (ret) {
1312 : 0 : pr_err("%s: Failed to stop governor\n", __func__);
1313 : : return ret;
1314 : : }
1315 : : }
1316 : :
1317 : : #ifdef CONFIG_HOTPLUG_CPU
1318 [ + - ]: 80 : if (!cpufreq_driver->setpolicy)
1319 : 80 : strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1320 : 80 : policy->governor->name, CPUFREQ_NAME_LEN);
1321 : : #endif
1322 : :
1323 : 80 : down_read(&policy->rwsem);
1324 : : cpus = cpumask_weight(policy->cpus);
1325 : 80 : up_read(&policy->rwsem);
1326 : :
1327 [ + + ]: 80 : if (cpu != policy->cpu) {
1328 : 48 : sysfs_remove_link(&dev->kobj, "cpufreq");
1329 [ + + ]: 32 : } else if (cpus > 1) {
1330 : 29 : new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu);
1331 [ + - ]: 29 : if (new_cpu >= 0) {
1332 : 29 : update_policy_cpu(policy, new_cpu);
1333 : :
1334 : : if (!frozen) {
1335 : : pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
1336 : : __func__, new_cpu, cpu);
1337 : : }
1338 : : }
1339 : : }
1340 : :
1341 : : return 0;
1342 : : }
1343 : :
1344 : 0 : static int __cpufreq_remove_dev_finish(struct device *dev,
1345 : : struct subsys_interface *sif,
1346 : : bool frozen)
1347 : : {
1348 : 80 : unsigned int cpu = dev->id, cpus;
1349 : : int ret;
1350 : : unsigned long flags;
1351 : : struct cpufreq_policy *policy;
1352 : :
1353 : 80 : read_lock_irqsave(&cpufreq_driver_lock, flags);
1354 : 80 : policy = per_cpu(cpufreq_cpu_data, cpu);
1355 : 80 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1356 : :
1357 [ + - ]: 80 : if (!policy) {
1358 : : pr_debug("%s: No cpu_data found\n", __func__);
1359 : : return -EINVAL;
1360 : : }
1361 : :
1362 : 80 : down_write(&policy->rwsem);
1363 : : cpus = cpumask_weight(policy->cpus);
1364 : :
1365 [ + + ]: 80 : if (cpus > 1)
1366 : 77 : cpumask_clear_cpu(cpu, policy->cpus);
1367 : 80 : up_write(&policy->rwsem);
1368 : :
1369 : : /* If cpu is last user of policy, free policy */
1370 [ + + ]: 80 : if (cpus == 1) {
1371 [ + - ]: 3 : if (has_target()) {
1372 : 3 : ret = __cpufreq_governor(policy,
1373 : : CPUFREQ_GOV_POLICY_EXIT);
1374 [ - + ]: 3 : if (ret) {
1375 : 0 : pr_err("%s: Failed to exit governor\n",
1376 : : __func__);
1377 : : return ret;
1378 : : }
1379 : : }
1380 : :
1381 [ + ]: 3 : if (!frozen)
1382 : 3 : cpufreq_policy_put_kobj(policy);
1383 : :
1384 : : /*
1385 : : * Perform the ->exit() even during light-weight tear-down,
1386 : : * since this is a core component, and is essential for the
1387 : : * subsequent light-weight ->init() to succeed.
1388 : : */
1389 [ + - ]: 3 : if (cpufreq_driver->exit)
1390 : 3 : cpufreq_driver->exit(policy);
1391 : :
1392 : : /* Remove policy from list of active policies */
1393 : 3 : write_lock_irqsave(&cpufreq_driver_lock, flags);
1394 : : list_del(&policy->policy_list);
1395 : 3 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1396 : :
1397 [ + - ]: 3 : if (!frozen)
1398 : : cpufreq_policy_free(policy);
1399 : : } else {
1400 [ + - ]: 77 : if (has_target()) {
1401 [ + - ][ - + ]: 77 : if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
1402 : : (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
1403 : 0 : pr_err("%s: Failed to start governor\n",
1404 : : __func__);
1405 : : return ret;
1406 : : }
1407 : : }
1408 : : }
1409 : :
1410 : 80 : per_cpu(cpufreq_cpu_data, cpu) = NULL;
1411 : : return 0;
1412 : : }
1413 : :
1414 : : /**
1415 : : * cpufreq_remove_dev - remove a CPU device
1416 : : *
1417 : : * Removes the cpufreq interface for a CPU device.
1418 : : */
1419 : 0 : static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1420 : : {
1421 : 5 : unsigned int cpu = dev->id;
1422 : : int ret;
1423 : :
1424 [ + + ]: 5 : if (cpu_is_offline(cpu))
1425 : : return 0;
1426 : :
1427 : 2 : ret = __cpufreq_remove_dev_prepare(dev, sif, false);
1428 : :
1429 [ + - ]: 2 : if (!ret)
1430 : 2 : ret = __cpufreq_remove_dev_finish(dev, sif, false);
1431 : :
1432 : 2 : return ret;
1433 : : }
1434 : :
1435 : 0 : static void handle_update(struct work_struct *work)
1436 : : {
1437 : : struct cpufreq_policy *policy =
1438 : : container_of(work, struct cpufreq_policy, update);
1439 : 0 : unsigned int cpu = policy->cpu;
1440 : : pr_debug("handle_update for cpu %u called\n", cpu);
1441 : 0 : cpufreq_update_policy(cpu);
1442 : 0 : }
1443 : :
1444 : : /**
1445 : : * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're
1446 : : * in deep trouble.
1447 : : * @cpu: cpu number
1448 : : * @old_freq: CPU frequency the kernel thinks the CPU runs at
1449 : : * @new_freq: CPU frequency the CPU actually runs at
1450 : : *
1451 : : * We adjust to current frequency first, and need to clean up later.
1452 : : * So either call to cpufreq_update_policy() or schedule handle_update()).
1453 : : */
1454 : 0 : static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1455 : : unsigned int new_freq)
1456 : : {
1457 : : struct cpufreq_policy *policy;
1458 : : struct cpufreq_freqs freqs;
1459 : : unsigned long flags;
1460 : :
1461 : : pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
1462 : : "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1463 : :
1464 : 15 : freqs.old = old_freq;
1465 : 15 : freqs.new = new_freq;
1466 : :
1467 : 15 : read_lock_irqsave(&cpufreq_driver_lock, flags);
1468 : 15 : policy = per_cpu(cpufreq_cpu_data, cpu);
1469 : 15 : read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1470 : :
1471 : 15 : cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
1472 : 15 : cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
1473 : 15 : }
1474 : :
1475 : : /**
1476 : : * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1477 : : * @cpu: CPU number
1478 : : *
1479 : : * This is the last known freq, without actually getting it from the driver.
1480 : : * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1481 : : */
1482 : 0 : unsigned int cpufreq_quick_get(unsigned int cpu)
1483 : : {
1484 : : struct cpufreq_policy *policy;
1485 : : unsigned int ret_freq = 0;
1486 : :
1487 [ # # ][ # # ]: 0 : if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
[ # # ]
1488 : 0 : return cpufreq_driver->get(cpu);
1489 : :
1490 : 0 : policy = cpufreq_cpu_get(cpu);
1491 [ # # ]: 0 : if (policy) {
1492 : 0 : ret_freq = policy->cur;
1493 : 0 : cpufreq_cpu_put(policy);
1494 : : }
1495 : :
1496 : 0 : return ret_freq;
1497 : : }
1498 : : EXPORT_SYMBOL(cpufreq_quick_get);
1499 : :
1500 : : /**
1501 : : * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1502 : : * @cpu: CPU number
1503 : : *
1504 : : * Just return the max possible frequency for a given CPU.
1505 : : */
1506 : 0 : unsigned int cpufreq_quick_get_max(unsigned int cpu)
1507 : : {
1508 : 0 : struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1509 : : unsigned int ret_freq = 0;
1510 : :
1511 [ # # ]: 0 : if (policy) {
1512 : 0 : ret_freq = policy->max;
1513 : 0 : cpufreq_cpu_put(policy);
1514 : : }
1515 : :
1516 : 0 : return ret_freq;
1517 : : }
1518 : : EXPORT_SYMBOL(cpufreq_quick_get_max);
1519 : :
1520 : 0 : static unsigned int __cpufreq_get(unsigned int cpu)
1521 : : {
1522 : 0 : struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1523 : : unsigned int ret_freq = 0;
1524 : :
1525 [ # # ]: 0 : if (!cpufreq_driver->get)
1526 : : return ret_freq;
1527 : :
1528 : 0 : ret_freq = cpufreq_driver->get(cpu);
1529 : :
1530 [ # # ][ # # ]: 0 : if (ret_freq && policy->cur &&
[ # # ]
1531 : 0 : !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1532 : : /* verify no discrepancy between actual and
1533 : : saved value exists */
1534 [ # # ]: 0 : if (unlikely(ret_freq != policy->cur)) {
1535 : 0 : cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1536 : 0 : schedule_work(&policy->update);
1537 : : }
1538 : : }
1539 : :
1540 : 0 : return ret_freq;
1541 : : }
1542 : :
1543 : : /**
1544 : : * cpufreq_get - get the current CPU frequency (in kHz)
1545 : : * @cpu: CPU number
1546 : : *
1547 : : * Get the CPU current (static) CPU frequency
1548 : : */
1549 : 0 : unsigned int cpufreq_get(unsigned int cpu)
1550 : : {
1551 : 0 : struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1552 : : unsigned int ret_freq = 0;
1553 : :
1554 [ # # ]: 0 : if (policy) {
1555 : 0 : down_read(&policy->rwsem);
1556 : 0 : ret_freq = __cpufreq_get(cpu);
1557 : 0 : up_read(&policy->rwsem);
1558 : :
1559 : 0 : cpufreq_cpu_put(policy);
1560 : : }
1561 : :
1562 : 0 : return ret_freq;
1563 : : }
1564 : : EXPORT_SYMBOL(cpufreq_get);
1565 : :
1566 : : static struct subsys_interface cpufreq_interface = {
1567 : : .name = "cpufreq",
1568 : : .subsys = &cpu_subsys,
1569 : : .add_dev = cpufreq_add_dev,
1570 : : .remove_dev = cpufreq_remove_dev,
1571 : : };
1572 : :
1573 : : /**
1574 : : * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
1575 : : *
1576 : : * This function is only executed for the boot processor. The other CPUs
1577 : : * have been put offline by means of CPU hotplug.
1578 : : */
1579 : 0 : static int cpufreq_bp_suspend(void)
1580 : : {
1581 : : int ret = 0;
1582 : :
1583 : 0 : int cpu = smp_processor_id();
1584 : : struct cpufreq_policy *policy;
1585 : :
1586 : : pr_debug("suspending cpu %u\n", cpu);
1587 : :
1588 : : /* If there's no policy for the boot CPU, we have nothing to do. */
1589 : 0 : policy = cpufreq_cpu_get(cpu);
1590 [ # # ]: 0 : if (!policy)
1591 : : return 0;
1592 : :
1593 [ # # ]: 0 : if (cpufreq_driver->suspend) {
1594 : 0 : ret = cpufreq_driver->suspend(policy);
1595 [ # # ]: 0 : if (ret)
1596 : 0 : printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1597 : : "step on CPU %u\n", policy->cpu);
1598 : : }
1599 : :
1600 : 0 : cpufreq_cpu_put(policy);
1601 : 0 : return ret;
1602 : : }
1603 : :
1604 : : /**
1605 : : * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
1606 : : *
1607 : : * 1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1608 : : * 2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1609 : : * restored. It will verify that the current freq is in sync with
1610 : : * what we believe it to be. This is a bit later than when it
1611 : : * should be, but nonethteless it's better than calling
1612 : : * cpufreq_driver->get() here which might re-enable interrupts...
1613 : : *
1614 : : * This function is only executed for the boot CPU. The other CPUs have not
1615 : : * been turned on yet.
1616 : : */
1617 : 0 : static void cpufreq_bp_resume(void)
1618 : : {
1619 : : int ret = 0;
1620 : :
1621 : 0 : int cpu = smp_processor_id();
1622 : : struct cpufreq_policy *policy;
1623 : :
1624 : : pr_debug("resuming cpu %u\n", cpu);
1625 : :
1626 : : /* If there's no policy for the boot CPU, we have nothing to do. */
1627 : 0 : policy = cpufreq_cpu_get(cpu);
1628 [ # # ]: 0 : if (!policy)
1629 : 0 : return;
1630 : :
1631 [ # # ]: 0 : if (cpufreq_driver->resume) {
1632 : 0 : ret = cpufreq_driver->resume(policy);
1633 [ # # ]: 0 : if (ret) {
1634 : 0 : printk(KERN_ERR "cpufreq: resume failed in ->resume "
1635 : : "step on CPU %u\n", policy->cpu);
1636 : 0 : goto fail;
1637 : : }
1638 : : }
1639 : :
1640 : 0 : schedule_work(&policy->update);
1641 : :
1642 : : fail:
1643 : 0 : cpufreq_cpu_put(policy);
1644 : : }
1645 : :
1646 : : static struct syscore_ops cpufreq_syscore_ops = {
1647 : : .suspend = cpufreq_bp_suspend,
1648 : : .resume = cpufreq_bp_resume,
1649 : : };
1650 : :
1651 : : /**
1652 : : * cpufreq_get_current_driver - return current driver's name
1653 : : *
1654 : : * Return the name string of the currently loaded cpufreq driver
1655 : : * or NULL, if none.
1656 : : */
1657 : 0 : const char *cpufreq_get_current_driver(void)
1658 : : {
1659 [ # # ]: 0 : if (cpufreq_driver)
1660 : 0 : return cpufreq_driver->name;
1661 : :
1662 : : return NULL;
1663 : : }
1664 : : EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1665 : :
1666 : : /*********************************************************************
1667 : : * NOTIFIER LISTS INTERFACE *
1668 : : *********************************************************************/
1669 : :
1670 : : /**
1671 : : * cpufreq_register_notifier - register a driver with cpufreq
1672 : : * @nb: notifier function to register
1673 : : * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1674 : : *
1675 : : * Add a driver to one of two lists: either a list of drivers that
1676 : : * are notified about clock rate changes (once before and once after
1677 : : * the transition), or a list of drivers that are notified about
1678 : : * changes in cpufreq policy.
1679 : : *
1680 : : * This function may sleep, and has the same return conditions as
1681 : : * blocking_notifier_chain_register.
1682 : : */
1683 : 0 : int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1684 : : {
1685 : : int ret;
1686 : :
1687 [ # # ]: 0 : if (cpufreq_disabled())
1688 : : return -EINVAL;
1689 : :
1690 [ # # ]: 0 : WARN_ON(!init_cpufreq_transition_notifier_list_called);
1691 : :
1692 [ # # # ]: 0 : switch (list) {
1693 : : case CPUFREQ_TRANSITION_NOTIFIER:
1694 : 0 : ret = srcu_notifier_chain_register(
1695 : : &cpufreq_transition_notifier_list, nb);
1696 : 0 : break;
1697 : : case CPUFREQ_POLICY_NOTIFIER:
1698 : 0 : ret = blocking_notifier_chain_register(
1699 : : &cpufreq_policy_notifier_list, nb);
1700 : 0 : break;
1701 : : default:
1702 : : ret = -EINVAL;
1703 : : }
1704 : :
1705 : 0 : return ret;
1706 : : }
1707 : : EXPORT_SYMBOL(cpufreq_register_notifier);
1708 : :
1709 : : /**
1710 : : * cpufreq_unregister_notifier - unregister a driver with cpufreq
1711 : : * @nb: notifier block to be unregistered
1712 : : * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1713 : : *
1714 : : * Remove a driver from the CPU frequency notifier list.
1715 : : *
1716 : : * This function may sleep, and has the same return conditions as
1717 : : * blocking_notifier_chain_unregister.
1718 : : */
1719 : 0 : int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1720 : : {
1721 : : int ret;
1722 : :
1723 [ # # ]: 0 : if (cpufreq_disabled())
1724 : : return -EINVAL;
1725 : :
1726 [ # # # ]: 0 : switch (list) {
1727 : : case CPUFREQ_TRANSITION_NOTIFIER:
1728 : 0 : ret = srcu_notifier_chain_unregister(
1729 : : &cpufreq_transition_notifier_list, nb);
1730 : 0 : break;
1731 : : case CPUFREQ_POLICY_NOTIFIER:
1732 : 0 : ret = blocking_notifier_chain_unregister(
1733 : : &cpufreq_policy_notifier_list, nb);
1734 : 0 : break;
1735 : : default:
1736 : : ret = -EINVAL;
1737 : : }
1738 : :
1739 : 0 : return ret;
1740 : : }
1741 : : EXPORT_SYMBOL(cpufreq_unregister_notifier);
1742 : :
1743 : :
1744 : : /*********************************************************************
1745 : : * GOVERNORS *
1746 : : *********************************************************************/
1747 : :
1748 : 0 : int __cpufreq_driver_target(struct cpufreq_policy *policy,
1749 : : unsigned int target_freq,
1750 : : unsigned int relation)
1751 : : {
1752 : : int retval = -EINVAL;
1753 : : unsigned int old_target_freq = target_freq;
1754 : :
1755 [ + - ]: 32604 : if (cpufreq_disabled())
1756 : : return -ENODEV;
1757 : :
1758 : : /* Make sure that target_freq is within supported range */
1759 [ - + ]: 32604 : if (target_freq > policy->max)
1760 : : target_freq = policy->max;
1761 [ + + ]: 32604 : if (target_freq < policy->min)
1762 : : target_freq = policy->min;
1763 : :
1764 : : pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1765 : : policy->cpu, target_freq, relation, old_target_freq);
1766 : :
1767 : : /*
1768 : : * This might look like a redundant call as we are checking it again
1769 : : * after finding index. But it is left intentionally for cases where
1770 : : * exactly same freq is called again and so we can save on few function
1771 : : * calls.
1772 : : */
1773 [ + + ]: 32604 : if (target_freq == policy->cur)
1774 : : return 0;
1775 : :
1776 [ - + ]: 2768 : if (cpufreq_driver->target)
1777 : 0 : retval = cpufreq_driver->target(policy, target_freq, relation);
1778 [ + - ]: 2768 : else if (cpufreq_driver->target_index) {
1779 : : struct cpufreq_frequency_table *freq_table;
1780 : : struct cpufreq_freqs freqs;
1781 : : bool notify;
1782 : : int index;
1783 : :
1784 : 2768 : freq_table = cpufreq_frequency_get_table(policy->cpu);
1785 [ - + ]: 2768 : if (unlikely(!freq_table)) {
1786 : 0 : pr_err("%s: Unable to find freq_table\n", __func__);
1787 : 692 : goto out;
1788 : : }
1789 : :
1790 : 2768 : retval = cpufreq_frequency_table_target(policy, freq_table,
1791 : : target_freq, relation, &index);
1792 [ - + ]: 2768 : if (unlikely(retval)) {
1793 : 0 : pr_err("%s: Unable to find matching freq\n", __func__);
1794 : 0 : goto out;
1795 : : }
1796 : :
1797 [ + + ]: 2768 : if (freq_table[index].frequency == policy->cur) {
1798 : : retval = 0;
1799 : : goto out;
1800 : : }
1801 : :
1802 : 2076 : notify = !(cpufreq_driver->flags & CPUFREQ_ASYNC_NOTIFICATION);
1803 : :
1804 [ + - ]: 2076 : if (notify) {
1805 : 2076 : freqs.old = policy->cur;
1806 : 2076 : freqs.new = freq_table[index].frequency;
1807 : 2076 : freqs.flags = 0;
1808 : :
1809 : : pr_debug("%s: cpu: %d, oldfreq: %u, new freq: %u\n",
1810 : : __func__, policy->cpu, freqs.old,
1811 : : freqs.new);
1812 : :
1813 : 2076 : cpufreq_notify_transition(policy, &freqs,
1814 : : CPUFREQ_PRECHANGE);
1815 : : }
1816 : :
1817 : 2076 : retval = cpufreq_driver->target_index(policy, index);
1818 [ - + ]: 2076 : if (retval)
1819 : 0 : pr_err("%s: Failed to change cpu frequency: %d\n",
1820 : : __func__, retval);
1821 : :
1822 [ + - ]: 2076 : if (notify)
1823 : 2076 : cpufreq_notify_post_transition(policy, &freqs, retval);
1824 : : }
1825 : :
1826 : : out:
1827 : 2768 : return retval;
1828 : : }
1829 : : EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1830 : :
1831 : 0 : int cpufreq_driver_target(struct cpufreq_policy *policy,
1832 : : unsigned int target_freq,
1833 : : unsigned int relation)
1834 : : {
1835 : : int ret = -EINVAL;
1836 : :
1837 : 0 : down_write(&policy->rwsem);
1838 : :
1839 : 0 : ret = __cpufreq_driver_target(policy, target_freq, relation);
1840 : :
1841 : 0 : up_write(&policy->rwsem);
1842 : :
1843 : 0 : return ret;
1844 : : }
1845 : : EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1846 : :
1847 : : /*
1848 : : * when "event" is CPUFREQ_GOV_LIMITS
1849 : : */
1850 : :
1851 : 0 : static int __cpufreq_governor(struct cpufreq_policy *policy,
1852 : : unsigned int event)
1853 : : {
1854 : : int ret;
1855 : :
1856 : : /* Only must be defined when default governor is known to have latency
1857 : : restrictions, like e.g. conservative or ondemand.
1858 : : That this is the case is already ensured in Kconfig
1859 : : */
1860 : : #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1861 : : struct cpufreq_governor *gov = &cpufreq_gov_performance;
1862 : : #else
1863 : : struct cpufreq_governor *gov = NULL;
1864 : : #endif
1865 : :
1866 [ + + ][ - + ]: 555 : if (policy->governor->max_transition_latency &&
1867 : 245 : policy->cpuinfo.transition_latency >
1868 : : policy->governor->max_transition_latency) {
1869 [ # # ]: 0 : if (!gov)
1870 : : return -EINVAL;
1871 : : else {
1872 : 0 : printk(KERN_WARNING "%s governor failed, too long"
1873 : : " transition latency of HW, fallback"
1874 : : " to %s governor\n",
1875 : 0 : policy->governor->name,
1876 : : gov->name);
1877 : 0 : policy->governor = gov;
1878 : : }
1879 : : }
1880 : :
1881 [ + + ]: 555 : if (event == CPUFREQ_GOV_POLICY_INIT)
1882 [ + - ]: 3 : if (!try_module_get(policy->governor->owner))
1883 : : return -EINVAL;
1884 : :
1885 : : pr_debug("__cpufreq_governor for CPU %u, event %u\n",
1886 : : policy->cpu, event);
1887 : :
1888 : 555 : mutex_lock(&cpufreq_governor_lock);
1889 [ + + ][ + - ]: 555 : if ((policy->governor_enabled && event == CPUFREQ_GOV_START)
1890 [ + + ]: 555 : || (!policy->governor_enabled
1891 [ - + ]: 163 : && (event == CPUFREQ_GOV_LIMITS || event == CPUFREQ_GOV_STOP))) {
1892 : 0 : mutex_unlock(&cpufreq_governor_lock);
1893 : 0 : return -EBUSY;
1894 : : }
1895 : :
1896 [ + + ]: 555 : if (event == CPUFREQ_GOV_STOP)
1897 : 157 : policy->governor_enabled = false;
1898 [ + + ]: 398 : else if (event == CPUFREQ_GOV_START)
1899 : 157 : policy->governor_enabled = true;
1900 : :
1901 : 555 : mutex_unlock(&cpufreq_governor_lock);
1902 : :
1903 : 555 : ret = policy->governor->governor(policy, event);
1904 : :
1905 [ + - ]: 555 : if (!ret) {
1906 [ + + ]: 555 : if (event == CPUFREQ_GOV_POLICY_INIT)
1907 : 3 : policy->governor->initialized++;
1908 [ + + ]: 552 : else if (event == CPUFREQ_GOV_POLICY_EXIT)
1909 : 3 : policy->governor->initialized--;
1910 : : } else {
1911 : : /* Restore original values */
1912 : 0 : mutex_lock(&cpufreq_governor_lock);
1913 [ # # ]: 0 : if (event == CPUFREQ_GOV_STOP)
1914 : 0 : policy->governor_enabled = true;
1915 [ # # ]: 0 : else if (event == CPUFREQ_GOV_START)
1916 : 0 : policy->governor_enabled = false;
1917 : 0 : mutex_unlock(&cpufreq_governor_lock);
1918 : : }
1919 : :
1920 [ + - ][ + + ]: 555 : if (((event == CPUFREQ_GOV_POLICY_INIT) && ret) ||
1921 : 555 : ((event == CPUFREQ_GOV_POLICY_EXIT) && !ret))
1922 : 3 : module_put(policy->governor->owner);
1923 : :
1924 : 555 : return ret;
1925 : : }
1926 : :
1927 : 0 : int cpufreq_register_governor(struct cpufreq_governor *governor)
1928 : : {
1929 : : int err;
1930 : :
1931 [ # # ]: 0 : if (!governor)
1932 : : return -EINVAL;
1933 : :
1934 [ # # ]: 0 : if (cpufreq_disabled())
1935 : : return -ENODEV;
1936 : :
1937 : 0 : mutex_lock(&cpufreq_governor_mutex);
1938 : :
1939 : 0 : governor->initialized = 0;
1940 : : err = -EBUSY;
1941 [ # # ]: 0 : if (__find_governor(governor->name) == NULL) {
1942 : : err = 0;
1943 : 0 : list_add(&governor->governor_list, &cpufreq_governor_list);
1944 : : }
1945 : :
1946 : 0 : mutex_unlock(&cpufreq_governor_mutex);
1947 : 0 : return err;
1948 : : }
1949 : : EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1950 : :
1951 : 0 : void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1952 : : {
1953 : : #ifdef CONFIG_HOTPLUG_CPU
1954 : : int cpu;
1955 : : #endif
1956 : :
1957 [ # # ]: 0 : if (!governor)
1958 : : return;
1959 : :
1960 [ # # ]: 0 : if (cpufreq_disabled())
1961 : : return;
1962 : :
1963 : : #ifdef CONFIG_HOTPLUG_CPU
1964 [ # # ]: 0 : for_each_present_cpu(cpu) {
1965 [ # # ]: 0 : if (cpu_online(cpu))
1966 : 0 : continue;
1967 [ # # ]: 0 : if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1968 : 0 : strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1969 : : }
1970 : : #endif
1971 : :
1972 : 0 : mutex_lock(&cpufreq_governor_mutex);
1973 : : list_del(&governor->governor_list);
1974 : 0 : mutex_unlock(&cpufreq_governor_mutex);
1975 : 0 : return;
1976 : : }
1977 : : EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1978 : :
1979 : :
1980 : : /*********************************************************************
1981 : : * POLICY INTERFACE *
1982 : : *********************************************************************/
1983 : :
1984 : : /**
1985 : : * cpufreq_get_policy - get the current cpufreq_policy
1986 : : * @policy: struct cpufreq_policy into which the current cpufreq_policy
1987 : : * is written
1988 : : *
1989 : : * Reads the current cpufreq policy.
1990 : : */
1991 : 0 : int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1992 : : {
1993 : : struct cpufreq_policy *cpu_policy;
1994 [ # # ]: 0 : if (!policy)
1995 : : return -EINVAL;
1996 : :
1997 : 0 : cpu_policy = cpufreq_cpu_get(cpu);
1998 [ # # ]: 0 : if (!cpu_policy)
1999 : : return -EINVAL;
2000 : :
2001 : 0 : memcpy(policy, cpu_policy, sizeof(*policy));
2002 : :
2003 : 0 : cpufreq_cpu_put(cpu_policy);
2004 : 0 : return 0;
2005 : : }
2006 : : EXPORT_SYMBOL(cpufreq_get_policy);
2007 : :
2008 : : /*
2009 : : * policy : current policy.
2010 : : * new_policy: policy to be set.
2011 : : */
2012 : 0 : static int cpufreq_set_policy(struct cpufreq_policy *policy,
2013 : : struct cpufreq_policy *new_policy)
2014 : : {
2015 : : int ret = 0, failed = 1;
2016 : :
2017 : : pr_debug("setting new policy for CPU %u: %u - %u kHz\n", new_policy->cpu,
2018 : : new_policy->min, new_policy->max);
2019 : :
2020 : 81 : memcpy(&new_policy->cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
2021 : :
2022 [ + - ][ + - ]: 81 : if (new_policy->min > policy->max || new_policy->max < policy->min) {
2023 : : ret = -EINVAL;
2024 : : goto error_out;
2025 : : }
2026 : :
2027 : : /* verify the cpu speed can be set within this limit */
2028 : 81 : ret = cpufreq_driver->verify(new_policy);
2029 [ + - ]: 81 : if (ret)
2030 : : goto error_out;
2031 : :
2032 : : /* adjust if necessary - all reasons */
2033 : 81 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
2034 : : CPUFREQ_ADJUST, new_policy);
2035 : :
2036 : : /* adjust if necessary - hardware incompatibility*/
2037 : 81 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
2038 : : CPUFREQ_INCOMPATIBLE, new_policy);
2039 : :
2040 : : /*
2041 : : * verify the cpu speed can be set within this limit, which might be
2042 : : * different to the first one
2043 : : */
2044 : 81 : ret = cpufreq_driver->verify(new_policy);
2045 [ + - ]: 81 : if (ret)
2046 : : goto error_out;
2047 : :
2048 : : /* notification of the new policy */
2049 : 81 : blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
2050 : : CPUFREQ_NOTIFY, new_policy);
2051 : :
2052 : 81 : policy->min = new_policy->min;
2053 : 81 : policy->max = new_policy->max;
2054 : :
2055 : : pr_debug("new min and max freqs are %u - %u kHz\n",
2056 : : policy->min, policy->max);
2057 : :
2058 [ - + ]: 81 : if (cpufreq_driver->setpolicy) {
2059 : 0 : policy->policy = new_policy->policy;
2060 : : pr_debug("setting range\n");
2061 : 0 : ret = cpufreq_driver->setpolicy(new_policy);
2062 : : } else {
2063 [ + + ]: 81 : if (new_policy->governor != policy->governor) {
2064 : : /* save old, working values */
2065 : : struct cpufreq_governor *old_gov = policy->governor;
2066 : :
2067 : : pr_debug("governor switch\n");
2068 : :
2069 : : /* end old governor */
2070 [ - + ]: 3 : if (policy->governor) {
2071 : 0 : __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
2072 : 0 : up_write(&policy->rwsem);
2073 : 0 : __cpufreq_governor(policy,
2074 : : CPUFREQ_GOV_POLICY_EXIT);
2075 : 0 : down_write(&policy->rwsem);
2076 : : }
2077 : :
2078 : : /* start new governor */
2079 : 3 : policy->governor = new_policy->governor;
2080 [ + - ]: 3 : if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
2081 [ - + ]: 3 : if (!__cpufreq_governor(policy, CPUFREQ_GOV_START)) {
2082 : : failed = 0;
2083 : : } else {
2084 : 0 : up_write(&policy->rwsem);
2085 : 0 : __cpufreq_governor(policy,
2086 : : CPUFREQ_GOV_POLICY_EXIT);
2087 : 0 : down_write(&policy->rwsem);
2088 : : }
2089 : : }
2090 : :
2091 [ - + ]: 3 : if (failed) {
2092 : : /* new governor failed, so re-start old one */
2093 : : pr_debug("starting governor %s failed\n",
2094 : : policy->governor->name);
2095 [ # # ]: 0 : if (old_gov) {
2096 : 0 : policy->governor = old_gov;
2097 : 0 : __cpufreq_governor(policy,
2098 : : CPUFREQ_GOV_POLICY_INIT);
2099 : 0 : __cpufreq_governor(policy,
2100 : : CPUFREQ_GOV_START);
2101 : : }
2102 : : ret = -EINVAL;
2103 : : goto error_out;
2104 : : }
2105 : : /* might be a policy change, too, so fall through */
2106 : : }
2107 : : pr_debug("governor: change or update limits\n");
2108 : 81 : ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
2109 : : }
2110 : :
2111 : : error_out:
2112 : 81 : return ret;
2113 : : }
2114 : :
2115 : : /**
2116 : : * cpufreq_update_policy - re-evaluate an existing cpufreq policy
2117 : : * @cpu: CPU which shall be re-evaluated
2118 : : *
2119 : : * Useful for policy notifiers which have different necessities
2120 : : * at different times.
2121 : : */
2122 : 0 : int cpufreq_update_policy(unsigned int cpu)
2123 : : {
2124 : 78 : struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
2125 : : struct cpufreq_policy new_policy;
2126 : : int ret;
2127 : :
2128 [ + - ]: 78 : if (!policy) {
2129 : : ret = -ENODEV;
2130 : : goto no_policy;
2131 : : }
2132 : :
2133 : 78 : down_write(&policy->rwsem);
2134 : :
2135 : : pr_debug("updating policy for CPU %u\n", cpu);
2136 : 78 : memcpy(&new_policy, policy, sizeof(*policy));
2137 : 78 : new_policy.min = policy->user_policy.min;
2138 : 78 : new_policy.max = policy->user_policy.max;
2139 : 78 : new_policy.policy = policy->user_policy.policy;
2140 : 78 : new_policy.governor = policy->user_policy.governor;
2141 : :
2142 : : /*
2143 : : * BIOS might change freq behind our back
2144 : : * -> ask driver for current freq and notify governors about a change
2145 : : */
2146 [ + - ][ + - ]: 78 : if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
2147 : 78 : new_policy.cur = cpufreq_driver->get(cpu);
2148 [ - + ]: 78 : if (!policy->cur) {
2149 : : pr_debug("Driver did not initialize current freq");
2150 : 0 : policy->cur = new_policy.cur;
2151 : : } else {
2152 [ + + ][ + - ]: 93 : if (policy->cur != new_policy.cur && has_target())
2153 : 15 : cpufreq_out_of_sync(cpu, policy->cur,
2154 : : new_policy.cur);
2155 : : }
2156 : : }
2157 : :
2158 : 78 : ret = cpufreq_set_policy(policy, &new_policy);
2159 : :
2160 : 78 : up_write(&policy->rwsem);
2161 : :
2162 : 78 : cpufreq_cpu_put(policy);
2163 : : no_policy:
2164 : 78 : return ret;
2165 : : }
2166 : : EXPORT_SYMBOL(cpufreq_update_policy);
2167 : :
2168 : 0 : static int cpufreq_cpu_callback(struct notifier_block *nfb,
2169 : : unsigned long action, void *hcpu)
2170 : : {
2171 : 546 : unsigned int cpu = (unsigned long)hcpu;
2172 : 78 : struct device *dev;
2173 : : bool frozen = false;
2174 : :
2175 : 546 : dev = get_cpu_device(cpu);
2176 [ + - ]: 546 : if (dev) {
2177 : :
2178 [ - + ]: 546 : if (action & CPU_TASKS_FROZEN)
2179 : : frozen = true;
2180 : :
2181 [ + + + - : 546 : switch (action & ~CPU_TASKS_FROZEN) {
+ ]
2182 : : case CPU_ONLINE:
2183 : 78 : __cpufreq_add_dev(dev, NULL, frozen);
2184 : 78 : cpufreq_update_policy(cpu);
2185 : 78 : break;
2186 : :
2187 : : case CPU_DOWN_PREPARE:
2188 : 78 : __cpufreq_remove_dev_prepare(dev, NULL, frozen);
2189 : 78 : break;
2190 : :
2191 : : case CPU_POST_DEAD:
2192 : 78 : __cpufreq_remove_dev_finish(dev, NULL, frozen);
2193 : 78 : break;
2194 : :
2195 : : case CPU_DOWN_FAILED:
2196 : 0 : __cpufreq_add_dev(dev, NULL, frozen);
2197 : 0 : break;
2198 : : }
2199 : : }
2200 : 0 : return NOTIFY_OK;
2201 : : }
2202 : :
2203 : : static struct notifier_block __refdata cpufreq_cpu_notifier = {
2204 : : .notifier_call = cpufreq_cpu_callback,
2205 : : };
2206 : :
2207 : : /*********************************************************************
2208 : : * BOOST *
2209 : : *********************************************************************/
2210 : 0 : static int cpufreq_boost_set_sw(int state)
2211 : : {
2212 : : struct cpufreq_frequency_table *freq_table;
2213 : : struct cpufreq_policy *policy;
2214 : : int ret = -EINVAL;
2215 : :
2216 [ # # ]: 0 : list_for_each_entry(policy, &cpufreq_policy_list, policy_list) {
2217 : 0 : freq_table = cpufreq_frequency_get_table(policy->cpu);
2218 [ # # ]: 0 : if (freq_table) {
2219 : 0 : ret = cpufreq_frequency_table_cpuinfo(policy,
2220 : : freq_table);
2221 [ # # ]: 0 : if (ret) {
2222 : 0 : pr_err("%s: Policy frequency update failed\n",
2223 : : __func__);
2224 : 0 : break;
2225 : : }
2226 : 0 : policy->user_policy.max = policy->max;
2227 : 0 : __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
2228 : : }
2229 : : }
2230 : :
2231 : 0 : return ret;
2232 : : }
2233 : :
2234 : 0 : int cpufreq_boost_trigger_state(int state)
2235 : : {
2236 : : unsigned long flags;
2237 : : int ret = 0;
2238 : :
2239 [ # # ]: 0 : if (cpufreq_driver->boost_enabled == state)
2240 : : return 0;
2241 : :
2242 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2243 : 0 : cpufreq_driver->boost_enabled = state;
2244 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2245 : :
2246 : 0 : ret = cpufreq_driver->set_boost(state);
2247 [ # # ]: 0 : if (ret) {
2248 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2249 : 0 : cpufreq_driver->boost_enabled = !state;
2250 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2251 : :
2252 [ # # ]: 0 : pr_err("%s: Cannot %s BOOST\n", __func__,
2253 : : state ? "enable" : "disable");
2254 : : }
2255 : :
2256 : 0 : return ret;
2257 : : }
2258 : :
2259 : 0 : int cpufreq_boost_supported(void)
2260 : : {
2261 [ + - + - ]: 2 : if (likely(cpufreq_driver))
[ # # ][ # # ]
2262 : 2 : return cpufreq_driver->boost_supported;
2263 : :
2264 : : return 0;
2265 : : }
2266 : : EXPORT_SYMBOL_GPL(cpufreq_boost_supported);
2267 : :
2268 : 0 : int cpufreq_boost_enabled(void)
2269 : : {
2270 : 24 : return cpufreq_driver->boost_enabled;
2271 : : }
2272 : : EXPORT_SYMBOL_GPL(cpufreq_boost_enabled);
2273 : :
2274 : : /*********************************************************************
2275 : : * REGISTER / UNREGISTER CPUFREQ DRIVER *
2276 : : *********************************************************************/
2277 : :
2278 : : /**
2279 : : * cpufreq_register_driver - register a CPU Frequency driver
2280 : : * @driver_data: A struct cpufreq_driver containing the values#
2281 : : * submitted by the CPU Frequency driver.
2282 : : *
2283 : : * Registers a CPU Frequency driver to this core code. This code
2284 : : * returns zero on success, -EBUSY when another driver got here first
2285 : : * (and isn't unregistered in the meantime).
2286 : : *
2287 : : */
2288 : 0 : int cpufreq_register_driver(struct cpufreq_driver *driver_data)
2289 : : {
2290 : : unsigned long flags;
2291 : : int ret;
2292 : :
2293 [ + - ]: 1 : if (cpufreq_disabled())
2294 : : return -ENODEV;
2295 : :
2296 [ + - ][ + - ]: 1 : if (!driver_data || !driver_data->verify || !driver_data->init ||
[ + - ][ + - ]
2297 [ - + ][ # # ]: 1 : !(driver_data->setpolicy || driver_data->target_index ||
2298 : 0 : driver_data->target))
2299 : : return -EINVAL;
2300 : :
2301 : : pr_debug("trying to register driver %s\n", driver_data->name);
2302 : :
2303 [ - + ]: 1 : if (driver_data->setpolicy)
2304 : 0 : driver_data->flags |= CPUFREQ_CONST_LOOPS;
2305 : :
2306 : 1 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2307 [ - + ]: 1 : if (cpufreq_driver) {
2308 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2309 : 0 : return -EEXIST;
2310 : : }
2311 : 1 : cpufreq_driver = driver_data;
2312 : 1 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2313 : :
2314 [ - + ]: 1 : if (cpufreq_boost_supported()) {
2315 : : /*
2316 : : * Check if driver provides function to enable boost -
2317 : : * if not, use cpufreq_boost_set_sw as default
2318 : : */
2319 [ # # ]: 0 : if (!cpufreq_driver->set_boost)
2320 : 0 : cpufreq_driver->set_boost = cpufreq_boost_set_sw;
2321 : :
2322 : 0 : ret = cpufreq_sysfs_create_file(&boost.attr);
2323 [ # # ]: 0 : if (ret) {
2324 : 0 : pr_err("%s: cannot register global BOOST sysfs file\n",
2325 : : __func__);
2326 : 0 : goto err_null_driver;
2327 : : }
2328 : : }
2329 : :
2330 : 1 : ret = subsys_interface_register(&cpufreq_interface);
2331 [ + - ]: 1 : if (ret)
2332 : : goto err_boost_unreg;
2333 : :
2334 [ - + ]: 1 : if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
2335 : : int i;
2336 : : ret = -ENODEV;
2337 : :
2338 : : /* check for at least one working CPU */
2339 [ # # ]: 0 : for (i = 0; i < nr_cpu_ids; i++)
2340 [ # # ][ # # ]: 0 : if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
2341 : : ret = 0;
2342 : : break;
2343 : : }
2344 : :
2345 : : /* if all ->init() calls failed, unregister */
2346 [ # # ]: 0 : if (ret) {
2347 : : pr_debug("no CPU initialized for driver %s\n",
2348 : : driver_data->name);
2349 : : goto err_if_unreg;
2350 : : }
2351 : : }
2352 : :
2353 : 1 : register_hotcpu_notifier(&cpufreq_cpu_notifier);
2354 : : pr_debug("driver %s up and running\n", driver_data->name);
2355 : :
2356 : 1 : return 0;
2357 : : err_if_unreg:
2358 : 0 : subsys_interface_unregister(&cpufreq_interface);
2359 : : err_boost_unreg:
2360 [ # # ]: 0 : if (cpufreq_boost_supported())
2361 : 0 : cpufreq_sysfs_remove_file(&boost.attr);
2362 : : err_null_driver:
2363 : 0 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2364 : 0 : cpufreq_driver = NULL;
2365 : 0 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2366 : 0 : return ret;
2367 : : }
2368 : : EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2369 : :
2370 : : /**
2371 : : * cpufreq_unregister_driver - unregister the current CPUFreq driver
2372 : : *
2373 : : * Unregister the current CPUFreq driver. Only call this if you have
2374 : : * the right to do so, i.e. if you have succeeded in initialising before!
2375 : : * Returns zero if successful, and -EINVAL if the cpufreq_driver is
2376 : : * currently not initialised.
2377 : : */
2378 : 0 : int cpufreq_unregister_driver(struct cpufreq_driver *driver)
2379 : : {
2380 : : unsigned long flags;
2381 : :
2382 [ + - ][ + - ]: 1 : if (!cpufreq_driver || (driver != cpufreq_driver))
2383 : : return -EINVAL;
2384 : :
2385 : : pr_debug("unregistering driver %s\n", driver->name);
2386 : :
2387 : 1 : subsys_interface_unregister(&cpufreq_interface);
2388 [ - + ]: 1 : if (cpufreq_boost_supported())
2389 : 0 : cpufreq_sysfs_remove_file(&boost.attr);
2390 : :
2391 : 1 : unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
2392 : :
2393 : 1 : down_write(&cpufreq_rwsem);
2394 : 1 : write_lock_irqsave(&cpufreq_driver_lock, flags);
2395 : :
2396 : 1 : cpufreq_driver = NULL;
2397 : :
2398 : 1 : write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2399 : 1 : up_write(&cpufreq_rwsem);
2400 : :
2401 : 1 : return 0;
2402 : : }
2403 : : EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2404 : :
2405 : 0 : static int __init cpufreq_core_init(void)
2406 : : {
2407 [ # # ]: 0 : if (cpufreq_disabled())
2408 : : return -ENODEV;
2409 : :
2410 : 0 : cpufreq_global_kobject = kobject_create();
2411 [ # # ]: 0 : BUG_ON(!cpufreq_global_kobject);
2412 : 0 : register_syscore_ops(&cpufreq_syscore_ops);
2413 : :
2414 : 0 : return 0;
2415 : : }
2416 : : core_initcall(cpufreq_core_init);
|
