Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-only */
2 : : /*
3 : : * linux/include/linux/cpufreq.h
4 : : *
5 : : * Copyright (C) 2001 Russell King
6 : : * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
7 : : */
8 : : #ifndef _LINUX_CPUFREQ_H
9 : : #define _LINUX_CPUFREQ_H
10 : :
11 : : #include <linux/clk.h>
12 : : #include <linux/cpumask.h>
13 : : #include <linux/completion.h>
14 : : #include <linux/kobject.h>
15 : : #include <linux/notifier.h>
16 : : #include <linux/pm_qos.h>
17 : : #include <linux/spinlock.h>
18 : : #include <linux/sysfs.h>
19 : :
20 : : /*********************************************************************
21 : : * CPUFREQ INTERFACE *
22 : : *********************************************************************/
23 : : /*
24 : : * Frequency values here are CPU kHz
25 : : *
26 : : * Maximum transition latency is in nanoseconds - if it's unknown,
27 : : * CPUFREQ_ETERNAL shall be used.
28 : : */
29 : :
30 : : #define CPUFREQ_ETERNAL (-1)
31 : : #define CPUFREQ_NAME_LEN 16
32 : : /* Print length for names. Extra 1 space for accommodating '\n' in prints */
33 : : #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
34 : :
35 : : struct cpufreq_governor;
36 : :
37 : : enum cpufreq_table_sorting {
38 : : CPUFREQ_TABLE_UNSORTED,
39 : : CPUFREQ_TABLE_SORTED_ASCENDING,
40 : : CPUFREQ_TABLE_SORTED_DESCENDING
41 : : };
42 : :
43 : : struct cpufreq_cpuinfo {
44 : : unsigned int max_freq;
45 : : unsigned int min_freq;
46 : :
47 : : /* in 10^(-9) s = nanoseconds */
48 : : unsigned int transition_latency;
49 : : };
50 : :
51 : : struct cpufreq_policy {
52 : : /* CPUs sharing clock, require sw coordination */
53 : : cpumask_var_t cpus; /* Online CPUs only */
54 : : cpumask_var_t related_cpus; /* Online + Offline CPUs */
55 : : cpumask_var_t real_cpus; /* Related and present */
56 : :
57 : : unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs
58 : : should set cpufreq */
59 : : unsigned int cpu; /* cpu managing this policy, must be online */
60 : :
61 : : struct clk *clk;
62 : : struct cpufreq_cpuinfo cpuinfo;/* see above */
63 : :
64 : : unsigned int min; /* in kHz */
65 : : unsigned int max; /* in kHz */
66 : : unsigned int cur; /* in kHz, only needed if cpufreq
67 : : * governors are used */
68 : : unsigned int restore_freq; /* = policy->cur before transition */
69 : : unsigned int suspend_freq; /* freq to set during suspend */
70 : :
71 : : unsigned int policy; /* see above */
72 : : unsigned int last_policy; /* policy before unplug */
73 : : struct cpufreq_governor *governor; /* see below */
74 : : void *governor_data;
75 : : char last_governor[CPUFREQ_NAME_LEN]; /* last governor used */
76 : :
77 : : struct work_struct update; /* if update_policy() needs to be
78 : : * called, but you're in IRQ context */
79 : :
80 : : struct freq_constraints constraints;
81 : : struct freq_qos_request *min_freq_req;
82 : : struct freq_qos_request *max_freq_req;
83 : :
84 : : struct cpufreq_frequency_table *freq_table;
85 : : enum cpufreq_table_sorting freq_table_sorted;
86 : :
87 : : struct list_head policy_list;
88 : : struct kobject kobj;
89 : : struct completion kobj_unregister;
90 : :
91 : : /*
92 : : * The rules for this semaphore:
93 : : * - Any routine that wants to read from the policy structure will
94 : : * do a down_read on this semaphore.
95 : : * - Any routine that will write to the policy structure and/or may take away
96 : : * the policy altogether (eg. CPU hotplug), will hold this lock in write
97 : : * mode before doing so.
98 : : */
99 : : struct rw_semaphore rwsem;
100 : :
101 : : /*
102 : : * Fast switch flags:
103 : : * - fast_switch_possible should be set by the driver if it can
104 : : * guarantee that frequency can be changed on any CPU sharing the
105 : : * policy and that the change will affect all of the policy CPUs then.
106 : : * - fast_switch_enabled is to be set by governors that support fast
107 : : * frequency switching with the help of cpufreq_enable_fast_switch().
108 : : */
109 : : bool fast_switch_possible;
110 : : bool fast_switch_enabled;
111 : :
112 : : /*
113 : : * Preferred average time interval between consecutive invocations of
114 : : * the driver to set the frequency for this policy. To be set by the
115 : : * scaling driver (0, which is the default, means no preference).
116 : : */
117 : : unsigned int transition_delay_us;
118 : :
119 : : /*
120 : : * Remote DVFS flag (Not added to the driver structure as we don't want
121 : : * to access another structure from scheduler hotpath).
122 : : *
123 : : * Should be set if CPUs can do DVFS on behalf of other CPUs from
124 : : * different cpufreq policies.
125 : : */
126 : : bool dvfs_possible_from_any_cpu;
127 : :
128 : : /* Cached frequency lookup from cpufreq_driver_resolve_freq. */
129 : : unsigned int cached_target_freq;
130 : : int cached_resolved_idx;
131 : :
132 : : /* Synchronization for frequency transitions */
133 : : bool transition_ongoing; /* Tracks transition status */
134 : : spinlock_t transition_lock;
135 : : wait_queue_head_t transition_wait;
136 : : struct task_struct *transition_task; /* Task which is doing the transition */
137 : :
138 : : /* cpufreq-stats */
139 : : struct cpufreq_stats *stats;
140 : :
141 : : /* For cpufreq driver's internal use */
142 : : void *driver_data;
143 : :
144 : : /* Pointer to the cooling device if used for thermal mitigation */
145 : : struct thermal_cooling_device *cdev;
146 : :
147 : : struct notifier_block nb_min;
148 : : struct notifier_block nb_max;
149 : : };
150 : :
151 : : /*
152 : : * Used for passing new cpufreq policy data to the cpufreq driver's ->verify()
153 : : * callback for sanitization. That callback is only expected to modify the min
154 : : * and max values, if necessary, and specifically it must not update the
155 : : * frequency table.
156 : : */
157 : : struct cpufreq_policy_data {
158 : : struct cpufreq_cpuinfo cpuinfo;
159 : : struct cpufreq_frequency_table *freq_table;
160 : : unsigned int cpu;
161 : : unsigned int min; /* in kHz */
162 : : unsigned int max; /* in kHz */
163 : : };
164 : :
165 : : struct cpufreq_freqs {
166 : : struct cpufreq_policy *policy;
167 : : unsigned int old;
168 : : unsigned int new;
169 : : u8 flags; /* flags of cpufreq_driver, see below. */
170 : : };
171 : :
172 : : /* Only for ACPI */
173 : : #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
174 : : #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */
175 : : #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */
176 : : #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/
177 : :
178 : : #ifdef CONFIG_CPU_FREQ
179 : : struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu);
180 : : struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
181 : : void cpufreq_cpu_put(struct cpufreq_policy *policy);
182 : : #else
183 : : static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu)
184 : : {
185 : : return NULL;
186 : : }
187 : : static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
188 : : {
189 : : return NULL;
190 : : }
191 : : static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
192 : : #endif
193 : :
194 : 0 : static inline bool policy_is_inactive(struct cpufreq_policy *policy)
195 : : {
196 [ # # # # : 0 : return cpumask_empty(policy->cpus);
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
197 : : }
198 : :
199 : 0 : static inline bool policy_is_shared(struct cpufreq_policy *policy)
200 : : {
201 [ # # # # ]: 0 : return cpumask_weight(policy->cpus) > 1;
202 : : }
203 : :
204 : : #ifdef CONFIG_CPU_FREQ
205 : : unsigned int cpufreq_get(unsigned int cpu);
206 : : unsigned int cpufreq_quick_get(unsigned int cpu);
207 : : unsigned int cpufreq_quick_get_max(unsigned int cpu);
208 : : void disable_cpufreq(void);
209 : :
210 : : u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
211 : :
212 : : struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu);
213 : : void cpufreq_cpu_release(struct cpufreq_policy *policy);
214 : : int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
215 : : void refresh_frequency_limits(struct cpufreq_policy *policy);
216 : : void cpufreq_update_policy(unsigned int cpu);
217 : : void cpufreq_update_limits(unsigned int cpu);
218 : : bool have_governor_per_policy(void);
219 : : struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
220 : : void cpufreq_enable_fast_switch(struct cpufreq_policy *policy);
221 : : void cpufreq_disable_fast_switch(struct cpufreq_policy *policy);
222 : : #else
223 : : static inline unsigned int cpufreq_get(unsigned int cpu)
224 : : {
225 : : return 0;
226 : : }
227 : : static inline unsigned int cpufreq_quick_get(unsigned int cpu)
228 : : {
229 : : return 0;
230 : : }
231 : : static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
232 : : {
233 : : return 0;
234 : : }
235 : : static inline void disable_cpufreq(void) { }
236 : : #endif
237 : :
238 : : #ifdef CONFIG_CPU_FREQ_STAT
239 : : void cpufreq_stats_create_table(struct cpufreq_policy *policy);
240 : : void cpufreq_stats_free_table(struct cpufreq_policy *policy);
241 : : void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
242 : : unsigned int new_freq);
243 : : #else
244 : 0 : static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { }
245 : 13 : static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { }
246 : 0 : static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
247 : 0 : unsigned int new_freq) { }
248 : : #endif /* CONFIG_CPU_FREQ_STAT */
249 : :
250 : : /*********************************************************************
251 : : * CPUFREQ DRIVER INTERFACE *
252 : : *********************************************************************/
253 : :
254 : : #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
255 : : #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
256 : : #define CPUFREQ_RELATION_C 2 /* closest frequency to target */
257 : :
258 : : struct freq_attr {
259 : : struct attribute attr;
260 : : ssize_t (*show)(struct cpufreq_policy *, char *);
261 : : ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
262 : : };
263 : :
264 : : #define cpufreq_freq_attr_ro(_name) \
265 : : static struct freq_attr _name = \
266 : : __ATTR(_name, 0444, show_##_name, NULL)
267 : :
268 : : #define cpufreq_freq_attr_ro_perm(_name, _perm) \
269 : : static struct freq_attr _name = \
270 : : __ATTR(_name, _perm, show_##_name, NULL)
271 : :
272 : : #define cpufreq_freq_attr_rw(_name) \
273 : : static struct freq_attr _name = \
274 : : __ATTR(_name, 0644, show_##_name, store_##_name)
275 : :
276 : : #define cpufreq_freq_attr_wo(_name) \
277 : : static struct freq_attr _name = \
278 : : __ATTR(_name, 0200, NULL, store_##_name)
279 : :
280 : : #define define_one_global_ro(_name) \
281 : : static struct kobj_attribute _name = \
282 : : __ATTR(_name, 0444, show_##_name, NULL)
283 : :
284 : : #define define_one_global_rw(_name) \
285 : : static struct kobj_attribute _name = \
286 : : __ATTR(_name, 0644, show_##_name, store_##_name)
287 : :
288 : :
289 : : struct cpufreq_driver {
290 : : char name[CPUFREQ_NAME_LEN];
291 : : u8 flags;
292 : : void *driver_data;
293 : :
294 : : /* needed by all drivers */
295 : : int (*init)(struct cpufreq_policy *policy);
296 : : int (*verify)(struct cpufreq_policy_data *policy);
297 : :
298 : : /* define one out of two */
299 : : int (*setpolicy)(struct cpufreq_policy *policy);
300 : :
301 : : /*
302 : : * On failure, should always restore frequency to policy->restore_freq
303 : : * (i.e. old freq).
304 : : */
305 : : int (*target)(struct cpufreq_policy *policy,
306 : : unsigned int target_freq,
307 : : unsigned int relation); /* Deprecated */
308 : : int (*target_index)(struct cpufreq_policy *policy,
309 : : unsigned int index);
310 : : unsigned int (*fast_switch)(struct cpufreq_policy *policy,
311 : : unsigned int target_freq);
312 : :
313 : : /*
314 : : * Caches and returns the lowest driver-supported frequency greater than
315 : : * or equal to the target frequency, subject to any driver limitations.
316 : : * Does not set the frequency. Only to be implemented for drivers with
317 : : * target().
318 : : */
319 : : unsigned int (*resolve_freq)(struct cpufreq_policy *policy,
320 : : unsigned int target_freq);
321 : :
322 : : /*
323 : : * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
324 : : * unset.
325 : : *
326 : : * get_intermediate should return a stable intermediate frequency
327 : : * platform wants to switch to and target_intermediate() should set CPU
328 : : * to to that frequency, before jumping to the frequency corresponding
329 : : * to 'index'. Core will take care of sending notifications and driver
330 : : * doesn't have to handle them in target_intermediate() or
331 : : * target_index().
332 : : *
333 : : * Drivers can return '0' from get_intermediate() in case they don't
334 : : * wish to switch to intermediate frequency for some target frequency.
335 : : * In that case core will directly call ->target_index().
336 : : */
337 : : unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
338 : : unsigned int index);
339 : : int (*target_intermediate)(struct cpufreq_policy *policy,
340 : : unsigned int index);
341 : :
342 : : /* should be defined, if possible */
343 : : unsigned int (*get)(unsigned int cpu);
344 : :
345 : : /* Called to update policy limits on firmware notifications. */
346 : : void (*update_limits)(unsigned int cpu);
347 : :
348 : : /* optional */
349 : : int (*bios_limit)(int cpu, unsigned int *limit);
350 : :
351 : : int (*online)(struct cpufreq_policy *policy);
352 : : int (*offline)(struct cpufreq_policy *policy);
353 : : int (*exit)(struct cpufreq_policy *policy);
354 : : void (*stop_cpu)(struct cpufreq_policy *policy);
355 : : int (*suspend)(struct cpufreq_policy *policy);
356 : : int (*resume)(struct cpufreq_policy *policy);
357 : :
358 : : /* Will be called after the driver is fully initialized */
359 : : void (*ready)(struct cpufreq_policy *policy);
360 : :
361 : : struct freq_attr **attr;
362 : :
363 : : /* platform specific boost support code */
364 : : bool boost_enabled;
365 : : int (*set_boost)(int state);
366 : : };
367 : :
368 : : /* flags */
369 : :
370 : : /* driver isn't removed even if all ->init() calls failed */
371 : : #define CPUFREQ_STICKY BIT(0)
372 : :
373 : : /* loops_per_jiffy or other kernel "constants" aren't affected by frequency transitions */
374 : : #define CPUFREQ_CONST_LOOPS BIT(1)
375 : :
376 : : /* don't warn on suspend/resume speed mismatches */
377 : : #define CPUFREQ_PM_NO_WARN BIT(2)
378 : :
379 : : /*
380 : : * This should be set by platforms having multiple clock-domains, i.e.
381 : : * supporting multiple policies. With this sysfs directories of governor would
382 : : * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
383 : : * governor with different tunables for different clusters.
384 : : */
385 : : #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY BIT(3)
386 : :
387 : : /*
388 : : * Driver will do POSTCHANGE notifications from outside of their ->target()
389 : : * routine and so must set cpufreq_driver->flags with this flag, so that core
390 : : * can handle them specially.
391 : : */
392 : : #define CPUFREQ_ASYNC_NOTIFICATION BIT(4)
393 : :
394 : : /*
395 : : * Set by drivers which want cpufreq core to check if CPU is running at a
396 : : * frequency present in freq-table exposed by the driver. For these drivers if
397 : : * CPU is found running at an out of table freq, we will try to set it to a freq
398 : : * from the table. And if that fails, we will stop further boot process by
399 : : * issuing a BUG_ON().
400 : : */
401 : : #define CPUFREQ_NEED_INITIAL_FREQ_CHECK BIT(5)
402 : :
403 : : /*
404 : : * Set by drivers to disallow use of governors with "dynamic_switching" flag
405 : : * set.
406 : : */
407 : : #define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING BIT(6)
408 : :
409 : : /*
410 : : * Set by drivers that want the core to automatically register the cpufreq
411 : : * driver as a thermal cooling device.
412 : : */
413 : : #define CPUFREQ_IS_COOLING_DEV BIT(7)
414 : :
415 : : int cpufreq_register_driver(struct cpufreq_driver *driver_data);
416 : : int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
417 : :
418 : : const char *cpufreq_get_current_driver(void);
419 : : void *cpufreq_get_driver_data(void);
420 : :
421 : 0 : static inline int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv)
422 : : {
423 [ # # ]: 0 : return IS_ENABLED(CONFIG_CPU_THERMAL) &&
424 : : (drv->flags & CPUFREQ_IS_COOLING_DEV);
425 : : }
426 : :
427 : 0 : static inline void cpufreq_verify_within_limits(struct cpufreq_policy_data *policy,
428 : : unsigned int min,
429 : : unsigned int max)
430 : : {
431 [ # # # # ]: 0 : if (policy->min < min)
432 : 0 : policy->min = min;
433 [ # # # # ]: 0 : if (policy->max < min)
434 : 0 : policy->max = min;
435 [ # # # # ]: 0 : if (policy->min > max)
436 : 0 : policy->min = max;
437 [ # # # # ]: 0 : if (policy->max > max)
438 : 0 : policy->max = max;
439 [ # # # # ]: 0 : if (policy->min > policy->max)
440 : 0 : policy->min = policy->max;
441 [ # # # # ]: 0 : return;
442 : : }
443 : :
444 : : static inline void
445 : 0 : cpufreq_verify_within_cpu_limits(struct cpufreq_policy_data *policy)
446 : : {
447 [ # # ]: 0 : cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
448 : : policy->cpuinfo.max_freq);
449 : 0 : }
450 : :
451 : : #ifdef CONFIG_CPU_FREQ
452 : : void cpufreq_suspend(void);
453 : : void cpufreq_resume(void);
454 : : int cpufreq_generic_suspend(struct cpufreq_policy *policy);
455 : : #else
456 : : static inline void cpufreq_suspend(void) {}
457 : : static inline void cpufreq_resume(void) {}
458 : : #endif
459 : :
460 : : /*********************************************************************
461 : : * CPUFREQ NOTIFIER INTERFACE *
462 : : *********************************************************************/
463 : :
464 : : #define CPUFREQ_TRANSITION_NOTIFIER (0)
465 : : #define CPUFREQ_POLICY_NOTIFIER (1)
466 : :
467 : : /* Transition notifiers */
468 : : #define CPUFREQ_PRECHANGE (0)
469 : : #define CPUFREQ_POSTCHANGE (1)
470 : :
471 : : /* Policy Notifiers */
472 : : #define CPUFREQ_CREATE_POLICY (0)
473 : : #define CPUFREQ_REMOVE_POLICY (1)
474 : :
475 : : #ifdef CONFIG_CPU_FREQ
476 : : int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
477 : : int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
478 : :
479 : : void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
480 : : struct cpufreq_freqs *freqs);
481 : : void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
482 : : struct cpufreq_freqs *freqs, int transition_failed);
483 : :
484 : : #else /* CONFIG_CPU_FREQ */
485 : : static inline int cpufreq_register_notifier(struct notifier_block *nb,
486 : : unsigned int list)
487 : : {
488 : : return 0;
489 : : }
490 : : static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
491 : : unsigned int list)
492 : : {
493 : : return 0;
494 : : }
495 : : #endif /* !CONFIG_CPU_FREQ */
496 : :
497 : : /**
498 : : * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
499 : : * safe)
500 : : * @old: old value
501 : : * @div: divisor
502 : : * @mult: multiplier
503 : : *
504 : : *
505 : : * new = old * mult / div
506 : : */
507 : 0 : static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
508 : : u_int mult)
509 : : {
510 : : #if BITS_PER_LONG == 32
511 : : u64 result = ((u64) old) * ((u64) mult);
512 : : do_div(result, div);
513 : : return (unsigned long) result;
514 : :
515 : : #elif BITS_PER_LONG == 64
516 : 0 : unsigned long result = old * ((u64) mult);
517 : 0 : result /= div;
518 [ # # ]: 0 : return result;
519 : : #endif
520 : : }
521 : :
522 : : /*********************************************************************
523 : : * CPUFREQ GOVERNORS *
524 : : *********************************************************************/
525 : :
526 : : #define CPUFREQ_POLICY_UNKNOWN (0)
527 : : /*
528 : : * If (cpufreq_driver->target) exists, the ->governor decides what frequency
529 : : * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
530 : : * two generic policies are available:
531 : : */
532 : : #define CPUFREQ_POLICY_POWERSAVE (1)
533 : : #define CPUFREQ_POLICY_PERFORMANCE (2)
534 : :
535 : : /*
536 : : * The polling frequency depends on the capability of the processor. Default
537 : : * polling frequency is 1000 times the transition latency of the processor. The
538 : : * ondemand governor will work on any processor with transition latency <= 10ms,
539 : : * using appropriate sampling rate.
540 : : */
541 : : #define LATENCY_MULTIPLIER (1000)
542 : :
543 : : struct cpufreq_governor {
544 : : char name[CPUFREQ_NAME_LEN];
545 : : int (*init)(struct cpufreq_policy *policy);
546 : : void (*exit)(struct cpufreq_policy *policy);
547 : : int (*start)(struct cpufreq_policy *policy);
548 : : void (*stop)(struct cpufreq_policy *policy);
549 : : void (*limits)(struct cpufreq_policy *policy);
550 : : ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
551 : : char *buf);
552 : : int (*store_setspeed) (struct cpufreq_policy *policy,
553 : : unsigned int freq);
554 : : /* For governors which change frequency dynamically by themselves */
555 : : bool dynamic_switching;
556 : : struct list_head governor_list;
557 : : struct module *owner;
558 : : };
559 : :
560 : : /* Pass a target to the cpufreq driver */
561 : : unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
562 : : unsigned int target_freq);
563 : : int cpufreq_driver_target(struct cpufreq_policy *policy,
564 : : unsigned int target_freq,
565 : : unsigned int relation);
566 : : int __cpufreq_driver_target(struct cpufreq_policy *policy,
567 : : unsigned int target_freq,
568 : : unsigned int relation);
569 : : unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
570 : : unsigned int target_freq);
571 : : unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy);
572 : : int cpufreq_register_governor(struct cpufreq_governor *governor);
573 : : void cpufreq_unregister_governor(struct cpufreq_governor *governor);
574 : :
575 : : struct cpufreq_governor *cpufreq_default_governor(void);
576 : : struct cpufreq_governor *cpufreq_fallback_governor(void);
577 : :
578 : 0 : static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy)
579 : : {
580 [ # # ]: 0 : if (policy->max < policy->cur)
581 : 0 : __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
582 [ # # ]: 0 : else if (policy->min > policy->cur)
583 : 0 : __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
584 : 0 : }
585 : :
586 : : /* Governor attribute set */
587 : : struct gov_attr_set {
588 : : struct kobject kobj;
589 : : struct list_head policy_list;
590 : : struct mutex update_lock;
591 : : int usage_count;
592 : : };
593 : :
594 : : /* sysfs ops for cpufreq governors */
595 : : extern const struct sysfs_ops governor_sysfs_ops;
596 : :
597 : : void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node);
598 : : void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node);
599 : : unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node);
600 : :
601 : : /* Governor sysfs attribute */
602 : : struct governor_attr {
603 : : struct attribute attr;
604 : : ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
605 : : ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
606 : : size_t count);
607 : : };
608 : :
609 : : /*********************************************************************
610 : : * FREQUENCY TABLE HELPERS *
611 : : *********************************************************************/
612 : :
613 : : /* Special Values of .frequency field */
614 : : #define CPUFREQ_ENTRY_INVALID ~0u
615 : : #define CPUFREQ_TABLE_END ~1u
616 : : /* Special Values of .flags field */
617 : : #define CPUFREQ_BOOST_FREQ (1 << 0)
618 : :
619 : : struct cpufreq_frequency_table {
620 : : unsigned int flags;
621 : : unsigned int driver_data; /* driver specific data, not used by core */
622 : : unsigned int frequency; /* kHz - doesn't need to be in ascending
623 : : * order */
624 : : };
625 : :
626 : : #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
627 : : int dev_pm_opp_init_cpufreq_table(struct device *dev,
628 : : struct cpufreq_frequency_table **table);
629 : : void dev_pm_opp_free_cpufreq_table(struct device *dev,
630 : : struct cpufreq_frequency_table **table);
631 : : #else
632 : : static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
633 : : struct cpufreq_frequency_table
634 : : **table)
635 : : {
636 : : return -EINVAL;
637 : : }
638 : :
639 : : static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
640 : : struct cpufreq_frequency_table
641 : : **table)
642 : : {
643 : : }
644 : : #endif
645 : :
646 : : /*
647 : : * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table
648 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
649 : : * @table: the cpufreq_frequency_table * to iterate over.
650 : : */
651 : :
652 : : #define cpufreq_for_each_entry(pos, table) \
653 : : for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
654 : :
655 : : /*
656 : : * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table
657 : : * with index
658 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
659 : : * @table: the cpufreq_frequency_table * to iterate over.
660 : : * @idx: the table entry currently being processed
661 : : */
662 : :
663 : : #define cpufreq_for_each_entry_idx(pos, table, idx) \
664 : : for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
665 : : pos++, idx++)
666 : :
667 : : /*
668 : : * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table
669 : : * excluding CPUFREQ_ENTRY_INVALID frequencies.
670 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
671 : : * @table: the cpufreq_frequency_table * to iterate over.
672 : : */
673 : :
674 : : #define cpufreq_for_each_valid_entry(pos, table) \
675 : : for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \
676 : : if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
677 : : continue; \
678 : : else
679 : :
680 : : /*
681 : : * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq
682 : : * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies.
683 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
684 : : * @table: the cpufreq_frequency_table * to iterate over.
685 : : * @idx: the table entry currently being processed
686 : : */
687 : :
688 : : #define cpufreq_for_each_valid_entry_idx(pos, table, idx) \
689 : : cpufreq_for_each_entry_idx(pos, table, idx) \
690 : : if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
691 : : continue; \
692 : : else
693 : :
694 : :
695 : : int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
696 : : struct cpufreq_frequency_table *table);
697 : :
698 : : int cpufreq_frequency_table_verify(struct cpufreq_policy_data *policy,
699 : : struct cpufreq_frequency_table *table);
700 : : int cpufreq_generic_frequency_table_verify(struct cpufreq_policy_data *policy);
701 : :
702 : : int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
703 : : unsigned int target_freq,
704 : : unsigned int relation);
705 : : int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
706 : : unsigned int freq);
707 : :
708 : : ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
709 : :
710 : : #ifdef CONFIG_CPU_FREQ
711 : : int cpufreq_boost_trigger_state(int state);
712 : : int cpufreq_boost_enabled(void);
713 : : int cpufreq_enable_boost_support(void);
714 : : bool policy_has_boost_freq(struct cpufreq_policy *policy);
715 : :
716 : : /* Find lowest freq at or above target in a table in ascending order */
717 : 0 : static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
718 : : unsigned int target_freq)
719 : : {
720 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
721 : 0 : struct cpufreq_frequency_table *pos;
722 : 0 : unsigned int freq;
723 : 0 : int idx, best = -1;
724 : :
725 [ # # # # ]: 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
726 : 0 : freq = pos->frequency;
727 : :
728 [ # # ]: 0 : if (freq >= target_freq)
729 : : return idx;
730 : :
731 : : best = idx;
732 : : }
733 : :
734 : : return best;
735 : : }
736 : :
737 : : /* Find lowest freq at or above target in a table in descending order */
738 : 0 : static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
739 : : unsigned int target_freq)
740 : : {
741 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
742 : 0 : struct cpufreq_frequency_table *pos;
743 : 0 : unsigned int freq;
744 : 0 : int idx, best = -1;
745 : :
746 [ # # # # ]: 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
747 : 0 : freq = pos->frequency;
748 : :
749 [ # # ]: 0 : if (freq == target_freq)
750 : : return idx;
751 : :
752 [ # # ]: 0 : if (freq > target_freq) {
753 : 0 : best = idx;
754 : 0 : continue;
755 : : }
756 : :
757 : : /* No freq found above target_freq */
758 [ # # ]: 0 : if (best == -1)
759 : : return idx;
760 : :
761 : 0 : return best;
762 : : }
763 : :
764 : : return best;
765 : : }
766 : :
767 : : /* Works only on sorted freq-tables */
768 : 0 : static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
769 : : unsigned int target_freq)
770 : : {
771 : 0 : target_freq = clamp_val(target_freq, policy->min, policy->max);
772 : :
773 [ # # ]: 0 : if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
774 : 0 : return cpufreq_table_find_index_al(policy, target_freq);
775 : : else
776 : 0 : return cpufreq_table_find_index_dl(policy, target_freq);
777 : : }
778 : :
779 : : /* Find highest freq at or below target in a table in ascending order */
780 : 0 : static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
781 : : unsigned int target_freq)
782 : : {
783 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
784 : 0 : struct cpufreq_frequency_table *pos;
785 : 0 : unsigned int freq;
786 : 0 : int idx, best = -1;
787 : :
788 [ # # # # ]: 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
789 : 0 : freq = pos->frequency;
790 : :
791 [ # # ]: 0 : if (freq == target_freq)
792 : : return idx;
793 : :
794 [ # # ]: 0 : if (freq < target_freq) {
795 : 0 : best = idx;
796 : 0 : continue;
797 : : }
798 : :
799 : : /* No freq found below target_freq */
800 [ # # ]: 0 : if (best == -1)
801 : : return idx;
802 : :
803 : 0 : return best;
804 : : }
805 : :
806 : : return best;
807 : : }
808 : :
809 : : /* Find highest freq at or below target in a table in descending order */
810 : 0 : static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
811 : : unsigned int target_freq)
812 : : {
813 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
814 : 0 : struct cpufreq_frequency_table *pos;
815 : 0 : unsigned int freq;
816 : 0 : int idx, best = -1;
817 : :
818 [ # # # # ]: 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
819 : 0 : freq = pos->frequency;
820 : :
821 [ # # ]: 0 : if (freq <= target_freq)
822 : : return idx;
823 : :
824 : : best = idx;
825 : : }
826 : :
827 : : return best;
828 : : }
829 : :
830 : : /* Works only on sorted freq-tables */
831 : 0 : static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
832 : : unsigned int target_freq)
833 : : {
834 : 0 : target_freq = clamp_val(target_freq, policy->min, policy->max);
835 : :
836 [ # # ]: 0 : if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
837 : 0 : return cpufreq_table_find_index_ah(policy, target_freq);
838 : : else
839 : 0 : return cpufreq_table_find_index_dh(policy, target_freq);
840 : : }
841 : :
842 : : /* Find closest freq to target in a table in ascending order */
843 : : static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
844 : : unsigned int target_freq)
845 : : {
846 : : struct cpufreq_frequency_table *table = policy->freq_table;
847 : : struct cpufreq_frequency_table *pos;
848 : : unsigned int freq;
849 : : int idx, best = -1;
850 : :
851 : : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
852 : : freq = pos->frequency;
853 : :
854 : : if (freq == target_freq)
855 : : return idx;
856 : :
857 : : if (freq < target_freq) {
858 : : best = idx;
859 : : continue;
860 : : }
861 : :
862 : : /* No freq found below target_freq */
863 : : if (best == -1)
864 : : return idx;
865 : :
866 : : /* Choose the closest freq */
867 : : if (target_freq - table[best].frequency > freq - target_freq)
868 : : return idx;
869 : :
870 : : return best;
871 : : }
872 : :
873 : : return best;
874 : : }
875 : :
876 : : /* Find closest freq to target in a table in descending order */
877 : : static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
878 : : unsigned int target_freq)
879 : : {
880 : : struct cpufreq_frequency_table *table = policy->freq_table;
881 : : struct cpufreq_frequency_table *pos;
882 : : unsigned int freq;
883 : : int idx, best = -1;
884 : :
885 : : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
886 : : freq = pos->frequency;
887 : :
888 : : if (freq == target_freq)
889 : : return idx;
890 : :
891 : : if (freq > target_freq) {
892 : : best = idx;
893 : : continue;
894 : : }
895 : :
896 : : /* No freq found above target_freq */
897 : : if (best == -1)
898 : : return idx;
899 : :
900 : : /* Choose the closest freq */
901 : : if (table[best].frequency - target_freq > target_freq - freq)
902 : : return idx;
903 : :
904 : : return best;
905 : : }
906 : :
907 : : return best;
908 : : }
909 : :
910 : : /* Works only on sorted freq-tables */
911 : 0 : static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
912 : : unsigned int target_freq)
913 : : {
914 : 0 : target_freq = clamp_val(target_freq, policy->min, policy->max);
915 : :
916 [ # # ]: 0 : if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
917 : 0 : return cpufreq_table_find_index_ac(policy, target_freq);
918 : : else
919 : 0 : return cpufreq_table_find_index_dc(policy, target_freq);
920 : : }
921 : :
922 : 0 : static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
923 : : unsigned int target_freq,
924 : : unsigned int relation)
925 : : {
926 [ # # ]: 0 : if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED))
927 : 0 : return cpufreq_table_index_unsorted(policy, target_freq,
928 : : relation);
929 : :
930 [ # # # # ]: 0 : switch (relation) {
931 : 0 : case CPUFREQ_RELATION_L:
932 : 0 : return cpufreq_table_find_index_l(policy, target_freq);
933 : 0 : case CPUFREQ_RELATION_H:
934 : 0 : return cpufreq_table_find_index_h(policy, target_freq);
935 : 0 : case CPUFREQ_RELATION_C:
936 : 0 : return cpufreq_table_find_index_c(policy, target_freq);
937 : 0 : default:
938 : 0 : pr_err("%s: Invalid relation: %d\n", __func__, relation);
939 : 0 : return -EINVAL;
940 : : }
941 : : }
942 : :
943 : : static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy)
944 : : {
945 : : struct cpufreq_frequency_table *pos;
946 : : int count = 0;
947 : :
948 : : if (unlikely(!policy->freq_table))
949 : : return 0;
950 : :
951 : : cpufreq_for_each_valid_entry(pos, policy->freq_table)
952 : : count++;
953 : :
954 : : return count;
955 : : }
956 : : #else
957 : : static inline int cpufreq_boost_trigger_state(int state)
958 : : {
959 : : return 0;
960 : : }
961 : : static inline int cpufreq_boost_enabled(void)
962 : : {
963 : : return 0;
964 : : }
965 : :
966 : : static inline int cpufreq_enable_boost_support(void)
967 : : {
968 : : return -EINVAL;
969 : : }
970 : :
971 : : static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
972 : : {
973 : : return false;
974 : : }
975 : : #endif
976 : :
977 : : #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
978 : : void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
979 : : struct cpufreq_governor *old_gov);
980 : : #else
981 : : static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
982 : : struct cpufreq_governor *old_gov) { }
983 : : #endif
984 : :
985 : : extern void arch_freq_prepare_all(void);
986 : : extern unsigned int arch_freq_get_on_cpu(int cpu);
987 : :
988 : : extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
989 : : unsigned long max_freq);
990 : :
991 : : /* the following are really really optional */
992 : : extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
993 : : extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
994 : : extern struct freq_attr *cpufreq_generic_attr[];
995 : : int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy);
996 : :
997 : : unsigned int cpufreq_generic_get(unsigned int cpu);
998 : : void cpufreq_generic_init(struct cpufreq_policy *policy,
999 : : struct cpufreq_frequency_table *table,
1000 : : unsigned int transition_latency);
1001 : : #endif /* _LINUX_CPUFREQ_H */
|
