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 : : static inline bool policy_is_inactive(struct cpufreq_policy *policy)
195 : : {
196 : : return cpumask_empty(policy->cpus);
197 : : }
198 : :
199 : : static inline bool policy_is_shared(struct cpufreq_policy *policy)
200 : : {
201 : 2 : return cpumask_weight(policy->cpus) > 1;
202 : : }
203 : :
204 : : /* /sys/devices/system/cpu/cpufreq: entry point for global variables */
205 : : extern struct kobject *cpufreq_global_kobject;
206 : :
207 : : #ifdef CONFIG_CPU_FREQ
208 : : unsigned int cpufreq_get(unsigned int cpu);
209 : : unsigned int cpufreq_quick_get(unsigned int cpu);
210 : : unsigned int cpufreq_quick_get_max(unsigned int cpu);
211 : : void disable_cpufreq(void);
212 : :
213 : : u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
214 : :
215 : : struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu);
216 : : void cpufreq_cpu_release(struct cpufreq_policy *policy);
217 : : int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
218 : : void refresh_frequency_limits(struct cpufreq_policy *policy);
219 : : void cpufreq_update_policy(unsigned int cpu);
220 : : void cpufreq_update_limits(unsigned int cpu);
221 : : bool have_governor_per_policy(void);
222 : : struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
223 : : void cpufreq_enable_fast_switch(struct cpufreq_policy *policy);
224 : : void cpufreq_disable_fast_switch(struct cpufreq_policy *policy);
225 : : #else
226 : : static inline unsigned int cpufreq_get(unsigned int cpu)
227 : : {
228 : : return 0;
229 : : }
230 : : static inline unsigned int cpufreq_quick_get(unsigned int cpu)
231 : : {
232 : : return 0;
233 : : }
234 : : static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
235 : : {
236 : : return 0;
237 : : }
238 : : static inline void disable_cpufreq(void) { }
239 : : #endif
240 : :
241 : : #ifdef CONFIG_CPU_FREQ_STAT
242 : : void cpufreq_stats_create_table(struct cpufreq_policy *policy);
243 : : void cpufreq_stats_free_table(struct cpufreq_policy *policy);
244 : : void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
245 : : unsigned int new_freq);
246 : : #else
247 : : static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { }
248 : : static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { }
249 : : static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
250 : : unsigned int new_freq) { }
251 : : #endif /* CONFIG_CPU_FREQ_STAT */
252 : :
253 : : /*********************************************************************
254 : : * CPUFREQ DRIVER INTERFACE *
255 : : *********************************************************************/
256 : :
257 : : #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
258 : : #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
259 : : #define CPUFREQ_RELATION_C 2 /* closest frequency to target */
260 : :
261 : : struct freq_attr {
262 : : struct attribute attr;
263 : : ssize_t (*show)(struct cpufreq_policy *, char *);
264 : : ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
265 : : };
266 : :
267 : : #define cpufreq_freq_attr_ro(_name) \
268 : : static struct freq_attr _name = \
269 : : __ATTR(_name, 0444, show_##_name, NULL)
270 : :
271 : : #define cpufreq_freq_attr_ro_perm(_name, _perm) \
272 : : static struct freq_attr _name = \
273 : : __ATTR(_name, _perm, show_##_name, NULL)
274 : :
275 : : #define cpufreq_freq_attr_rw(_name) \
276 : : static struct freq_attr _name = \
277 : : __ATTR(_name, 0644, show_##_name, store_##_name)
278 : :
279 : : #define cpufreq_freq_attr_wo(_name) \
280 : : static struct freq_attr _name = \
281 : : __ATTR(_name, 0200, NULL, store_##_name)
282 : :
283 : : #define define_one_global_ro(_name) \
284 : : static struct kobj_attribute _name = \
285 : : __ATTR(_name, 0444, show_##_name, NULL)
286 : :
287 : : #define define_one_global_rw(_name) \
288 : : static struct kobj_attribute _name = \
289 : : __ATTR(_name, 0644, show_##_name, store_##_name)
290 : :
291 : :
292 : : struct cpufreq_driver {
293 : : char name[CPUFREQ_NAME_LEN];
294 : : u8 flags;
295 : : void *driver_data;
296 : :
297 : : /* needed by all drivers */
298 : : int (*init)(struct cpufreq_policy *policy);
299 : : int (*verify)(struct cpufreq_policy_data *policy);
300 : :
301 : : /* define one out of two */
302 : : int (*setpolicy)(struct cpufreq_policy *policy);
303 : :
304 : : /*
305 : : * On failure, should always restore frequency to policy->restore_freq
306 : : * (i.e. old freq).
307 : : */
308 : : int (*target)(struct cpufreq_policy *policy,
309 : : unsigned int target_freq,
310 : : unsigned int relation); /* Deprecated */
311 : : int (*target_index)(struct cpufreq_policy *policy,
312 : : unsigned int index);
313 : : unsigned int (*fast_switch)(struct cpufreq_policy *policy,
314 : : unsigned int target_freq);
315 : :
316 : : /*
317 : : * Caches and returns the lowest driver-supported frequency greater than
318 : : * or equal to the target frequency, subject to any driver limitations.
319 : : * Does not set the frequency. Only to be implemented for drivers with
320 : : * target().
321 : : */
322 : : unsigned int (*resolve_freq)(struct cpufreq_policy *policy,
323 : : unsigned int target_freq);
324 : :
325 : : /*
326 : : * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
327 : : * unset.
328 : : *
329 : : * get_intermediate should return a stable intermediate frequency
330 : : * platform wants to switch to and target_intermediate() should set CPU
331 : : * to to that frequency, before jumping to the frequency corresponding
332 : : * to 'index'. Core will take care of sending notifications and driver
333 : : * doesn't have to handle them in target_intermediate() or
334 : : * target_index().
335 : : *
336 : : * Drivers can return '0' from get_intermediate() in case they don't
337 : : * wish to switch to intermediate frequency for some target frequency.
338 : : * In that case core will directly call ->target_index().
339 : : */
340 : : unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
341 : : unsigned int index);
342 : : int (*target_intermediate)(struct cpufreq_policy *policy,
343 : : unsigned int index);
344 : :
345 : : /* should be defined, if possible */
346 : : unsigned int (*get)(unsigned int cpu);
347 : :
348 : : /* Called to update policy limits on firmware notifications. */
349 : : void (*update_limits)(unsigned int cpu);
350 : :
351 : : /* optional */
352 : : int (*bios_limit)(int cpu, unsigned int *limit);
353 : :
354 : : int (*online)(struct cpufreq_policy *policy);
355 : : int (*offline)(struct cpufreq_policy *policy);
356 : : int (*exit)(struct cpufreq_policy *policy);
357 : : void (*stop_cpu)(struct cpufreq_policy *policy);
358 : : int (*suspend)(struct cpufreq_policy *policy);
359 : : int (*resume)(struct cpufreq_policy *policy);
360 : :
361 : : /* Will be called after the driver is fully initialized */
362 : : void (*ready)(struct cpufreq_policy *policy);
363 : :
364 : : struct freq_attr **attr;
365 : :
366 : : /* platform specific boost support code */
367 : : bool boost_enabled;
368 : : int (*set_boost)(int state);
369 : : };
370 : :
371 : : /* flags */
372 : :
373 : : /* driver isn't removed even if all ->init() calls failed */
374 : : #define CPUFREQ_STICKY BIT(0)
375 : :
376 : : /* loops_per_jiffy or other kernel "constants" aren't affected by frequency transitions */
377 : : #define CPUFREQ_CONST_LOOPS BIT(1)
378 : :
379 : : /* don't warn on suspend/resume speed mismatches */
380 : : #define CPUFREQ_PM_NO_WARN BIT(2)
381 : :
382 : : /*
383 : : * This should be set by platforms having multiple clock-domains, i.e.
384 : : * supporting multiple policies. With this sysfs directories of governor would
385 : : * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
386 : : * governor with different tunables for different clusters.
387 : : */
388 : : #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY BIT(3)
389 : :
390 : : /*
391 : : * Driver will do POSTCHANGE notifications from outside of their ->target()
392 : : * routine and so must set cpufreq_driver->flags with this flag, so that core
393 : : * can handle them specially.
394 : : */
395 : : #define CPUFREQ_ASYNC_NOTIFICATION BIT(4)
396 : :
397 : : /*
398 : : * Set by drivers which want cpufreq core to check if CPU is running at a
399 : : * frequency present in freq-table exposed by the driver. For these drivers if
400 : : * CPU is found running at an out of table freq, we will try to set it to a freq
401 : : * from the table. And if that fails, we will stop further boot process by
402 : : * issuing a BUG_ON().
403 : : */
404 : : #define CPUFREQ_NEED_INITIAL_FREQ_CHECK BIT(5)
405 : :
406 : : /*
407 : : * Set by drivers to disallow use of governors with "dynamic_switching" flag
408 : : * set.
409 : : */
410 : : #define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING BIT(6)
411 : :
412 : : /*
413 : : * Set by drivers that want the core to automatically register the cpufreq
414 : : * driver as a thermal cooling device.
415 : : */
416 : : #define CPUFREQ_IS_COOLING_DEV BIT(7)
417 : :
418 : : int cpufreq_register_driver(struct cpufreq_driver *driver_data);
419 : : int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
420 : :
421 : : const char *cpufreq_get_current_driver(void);
422 : : void *cpufreq_get_driver_data(void);
423 : :
424 : : static inline int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv)
425 : : {
426 : : return IS_ENABLED(CONFIG_CPU_THERMAL) &&
427 : : (drv->flags & CPUFREQ_IS_COOLING_DEV);
428 : : }
429 : :
430 : 2 : static inline void cpufreq_verify_within_limits(struct cpufreq_policy_data *policy,
431 : : unsigned int min,
432 : : unsigned int max)
433 : : {
434 : 2 : if (policy->min < min)
435 : 0 : policy->min = min;
436 : 2 : if (policy->max < min)
437 : 0 : policy->max = min;
438 : 2 : if (policy->min > max)
439 : 0 : policy->min = max;
440 : 2 : if (policy->max > max)
441 : 0 : policy->max = max;
442 : 2 : if (policy->min > policy->max)
443 : 0 : policy->min = policy->max;
444 : 2 : return;
445 : : }
446 : :
447 : : static inline void
448 : : cpufreq_verify_within_cpu_limits(struct cpufreq_policy_data *policy)
449 : : {
450 : 2 : cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
451 : : policy->cpuinfo.max_freq);
452 : : }
453 : :
454 : : #ifdef CONFIG_CPU_FREQ
455 : : void cpufreq_suspend(void);
456 : : void cpufreq_resume(void);
457 : : int cpufreq_generic_suspend(struct cpufreq_policy *policy);
458 : : #else
459 : : static inline void cpufreq_suspend(void) {}
460 : : static inline void cpufreq_resume(void) {}
461 : : #endif
462 : :
463 : : /*********************************************************************
464 : : * CPUFREQ NOTIFIER INTERFACE *
465 : : *********************************************************************/
466 : :
467 : : #define CPUFREQ_TRANSITION_NOTIFIER (0)
468 : : #define CPUFREQ_POLICY_NOTIFIER (1)
469 : :
470 : : /* Transition notifiers */
471 : : #define CPUFREQ_PRECHANGE (0)
472 : : #define CPUFREQ_POSTCHANGE (1)
473 : :
474 : : /* Policy Notifiers */
475 : : #define CPUFREQ_CREATE_POLICY (0)
476 : : #define CPUFREQ_REMOVE_POLICY (1)
477 : :
478 : : #ifdef CONFIG_CPU_FREQ
479 : : int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
480 : : int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
481 : :
482 : : void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
483 : : struct cpufreq_freqs *freqs);
484 : : void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
485 : : struct cpufreq_freqs *freqs, int transition_failed);
486 : :
487 : : #else /* CONFIG_CPU_FREQ */
488 : : static inline int cpufreq_register_notifier(struct notifier_block *nb,
489 : : unsigned int list)
490 : : {
491 : : return 0;
492 : : }
493 : : static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
494 : : unsigned int list)
495 : : {
496 : : return 0;
497 : : }
498 : : #endif /* !CONFIG_CPU_FREQ */
499 : :
500 : : /**
501 : : * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
502 : : * safe)
503 : : * @old: old value
504 : : * @div: divisor
505 : : * @mult: multiplier
506 : : *
507 : : *
508 : : * new = old * mult / div
509 : : */
510 : 2 : static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
511 : : u_int mult)
512 : : {
513 : : #if BITS_PER_LONG == 32
514 : 2 : u64 result = ((u64) old) * ((u64) mult);
515 : 2 : do_div(result, div);
516 : 2 : return (unsigned long) result;
517 : :
518 : : #elif BITS_PER_LONG == 64
519 : : unsigned long result = old * ((u64) mult);
520 : : result /= div;
521 : : return result;
522 : : #endif
523 : : }
524 : :
525 : : /*********************************************************************
526 : : * CPUFREQ GOVERNORS *
527 : : *********************************************************************/
528 : :
529 : : #define CPUFREQ_POLICY_UNKNOWN (0)
530 : : /*
531 : : * If (cpufreq_driver->target) exists, the ->governor decides what frequency
532 : : * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
533 : : * two generic policies are available:
534 : : */
535 : : #define CPUFREQ_POLICY_POWERSAVE (1)
536 : : #define CPUFREQ_POLICY_PERFORMANCE (2)
537 : :
538 : : /*
539 : : * The polling frequency depends on the capability of the processor. Default
540 : : * polling frequency is 1000 times the transition latency of the processor. The
541 : : * ondemand governor will work on any processor with transition latency <= 10ms,
542 : : * using appropriate sampling rate.
543 : : */
544 : : #define LATENCY_MULTIPLIER (1000)
545 : :
546 : : struct cpufreq_governor {
547 : : char name[CPUFREQ_NAME_LEN];
548 : : int (*init)(struct cpufreq_policy *policy);
549 : : void (*exit)(struct cpufreq_policy *policy);
550 : : int (*start)(struct cpufreq_policy *policy);
551 : : void (*stop)(struct cpufreq_policy *policy);
552 : : void (*limits)(struct cpufreq_policy *policy);
553 : : ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
554 : : char *buf);
555 : : int (*store_setspeed) (struct cpufreq_policy *policy,
556 : : unsigned int freq);
557 : : /* For governors which change frequency dynamically by themselves */
558 : : bool dynamic_switching;
559 : : struct list_head governor_list;
560 : : struct module *owner;
561 : : };
562 : :
563 : : /* Pass a target to the cpufreq driver */
564 : : unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
565 : : unsigned int target_freq);
566 : : int cpufreq_driver_target(struct cpufreq_policy *policy,
567 : : unsigned int target_freq,
568 : : unsigned int relation);
569 : : int __cpufreq_driver_target(struct cpufreq_policy *policy,
570 : : unsigned int target_freq,
571 : : unsigned int relation);
572 : : unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
573 : : unsigned int target_freq);
574 : : unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy);
575 : : int cpufreq_register_governor(struct cpufreq_governor *governor);
576 : : void cpufreq_unregister_governor(struct cpufreq_governor *governor);
577 : :
578 : : struct cpufreq_governor *cpufreq_default_governor(void);
579 : : struct cpufreq_governor *cpufreq_fallback_governor(void);
580 : :
581 : 2 : static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy)
582 : : {
583 : 2 : if (policy->max < policy->cur)
584 : 0 : __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
585 : 2 : else if (policy->min > policy->cur)
586 : 0 : __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
587 : 2 : }
588 : :
589 : : /* Governor attribute set */
590 : : struct gov_attr_set {
591 : : struct kobject kobj;
592 : : struct list_head policy_list;
593 : : struct mutex update_lock;
594 : : int usage_count;
595 : : };
596 : :
597 : : /* sysfs ops for cpufreq governors */
598 : : extern const struct sysfs_ops governor_sysfs_ops;
599 : :
600 : : void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node);
601 : : void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node);
602 : : unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node);
603 : :
604 : : /* Governor sysfs attribute */
605 : : struct governor_attr {
606 : : struct attribute attr;
607 : : ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
608 : : ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
609 : : size_t count);
610 : : };
611 : :
612 : : /*********************************************************************
613 : : * FREQUENCY TABLE HELPERS *
614 : : *********************************************************************/
615 : :
616 : : /* Special Values of .frequency field */
617 : : #define CPUFREQ_ENTRY_INVALID ~0u
618 : : #define CPUFREQ_TABLE_END ~1u
619 : : /* Special Values of .flags field */
620 : : #define CPUFREQ_BOOST_FREQ (1 << 0)
621 : :
622 : : struct cpufreq_frequency_table {
623 : : unsigned int flags;
624 : : unsigned int driver_data; /* driver specific data, not used by core */
625 : : unsigned int frequency; /* kHz - doesn't need to be in ascending
626 : : * order */
627 : : };
628 : :
629 : : #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
630 : : int dev_pm_opp_init_cpufreq_table(struct device *dev,
631 : : struct cpufreq_frequency_table **table);
632 : : void dev_pm_opp_free_cpufreq_table(struct device *dev,
633 : : struct cpufreq_frequency_table **table);
634 : : #else
635 : : static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
636 : : struct cpufreq_frequency_table
637 : : **table)
638 : : {
639 : : return -EINVAL;
640 : : }
641 : :
642 : : static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
643 : : struct cpufreq_frequency_table
644 : : **table)
645 : : {
646 : : }
647 : : #endif
648 : :
649 : : /*
650 : : * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table
651 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
652 : : * @table: the cpufreq_frequency_table * to iterate over.
653 : : */
654 : :
655 : : #define cpufreq_for_each_entry(pos, table) \
656 : : for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
657 : :
658 : : /*
659 : : * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table
660 : : * with index
661 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
662 : : * @table: the cpufreq_frequency_table * to iterate over.
663 : : * @idx: the table entry currently being processed
664 : : */
665 : :
666 : : #define cpufreq_for_each_entry_idx(pos, table, idx) \
667 : : for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
668 : : pos++, idx++)
669 : :
670 : : /*
671 : : * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table
672 : : * excluding CPUFREQ_ENTRY_INVALID frequencies.
673 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
674 : : * @table: the cpufreq_frequency_table * to iterate over.
675 : : */
676 : :
677 : : #define cpufreq_for_each_valid_entry(pos, table) \
678 : : for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \
679 : : if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
680 : : continue; \
681 : : else
682 : :
683 : : /*
684 : : * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq
685 : : * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies.
686 : : * @pos: the cpufreq_frequency_table * to use as a loop cursor.
687 : : * @table: the cpufreq_frequency_table * to iterate over.
688 : : * @idx: the table entry currently being processed
689 : : */
690 : :
691 : : #define cpufreq_for_each_valid_entry_idx(pos, table, idx) \
692 : : cpufreq_for_each_entry_idx(pos, table, idx) \
693 : : if (pos->frequency == CPUFREQ_ENTRY_INVALID) \
694 : : continue; \
695 : : else
696 : :
697 : :
698 : : int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
699 : : struct cpufreq_frequency_table *table);
700 : :
701 : : int cpufreq_frequency_table_verify(struct cpufreq_policy_data *policy,
702 : : struct cpufreq_frequency_table *table);
703 : : int cpufreq_generic_frequency_table_verify(struct cpufreq_policy_data *policy);
704 : :
705 : : int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
706 : : unsigned int target_freq,
707 : : unsigned int relation);
708 : : int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
709 : : unsigned int freq);
710 : :
711 : : ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
712 : :
713 : : #ifdef CONFIG_CPU_FREQ
714 : : int cpufreq_boost_trigger_state(int state);
715 : : int cpufreq_boost_enabled(void);
716 : : int cpufreq_enable_boost_support(void);
717 : : bool policy_has_boost_freq(struct cpufreq_policy *policy);
718 : :
719 : : /* Find lowest freq at or above target in a table in ascending order */
720 : : static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
721 : : unsigned int target_freq)
722 : : {
723 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
724 : : struct cpufreq_frequency_table *pos;
725 : : unsigned int freq;
726 : : int idx, best = -1;
727 : :
728 : 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
729 : : freq = pos->frequency;
730 : :
731 : 0 : if (freq >= target_freq)
732 : 0 : return idx;
733 : :
734 : : best = idx;
735 : : }
736 : :
737 : 0 : return best;
738 : : }
739 : :
740 : : /* Find lowest freq at or above target in a table in descending order */
741 : : static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
742 : : unsigned int target_freq)
743 : : {
744 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
745 : : struct cpufreq_frequency_table *pos;
746 : : unsigned int freq;
747 : : int idx, best = -1;
748 : :
749 : 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
750 : : freq = pos->frequency;
751 : :
752 : 0 : if (freq == target_freq)
753 : 0 : return idx;
754 : :
755 : 0 : if (freq > target_freq) {
756 : : best = idx;
757 : 0 : continue;
758 : : }
759 : :
760 : : /* No freq found above target_freq */
761 : 0 : if (best == -1)
762 : 0 : return idx;
763 : :
764 : 0 : return best;
765 : : }
766 : :
767 : 0 : return best;
768 : : }
769 : :
770 : : /* Works only on sorted freq-tables */
771 : 0 : static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
772 : : unsigned int target_freq)
773 : : {
774 : 0 : target_freq = clamp_val(target_freq, policy->min, policy->max);
775 : :
776 : 0 : if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
777 : 0 : return cpufreq_table_find_index_al(policy, target_freq);
778 : : else
779 : 0 : return cpufreq_table_find_index_dl(policy, target_freq);
780 : : }
781 : :
782 : : /* Find highest freq at or below target in a table in ascending order */
783 : : static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
784 : : unsigned int target_freq)
785 : : {
786 : 2 : struct cpufreq_frequency_table *table = policy->freq_table;
787 : : struct cpufreq_frequency_table *pos;
788 : : unsigned int freq;
789 : : int idx, best = -1;
790 : :
791 : 2 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
792 : : freq = pos->frequency;
793 : :
794 : 2 : if (freq == target_freq)
795 : 2 : return idx;
796 : :
797 : 2 : if (freq < target_freq) {
798 : : best = idx;
799 : 2 : continue;
800 : : }
801 : :
802 : : /* No freq found below target_freq */
803 : 0 : if (best == -1)
804 : 0 : return idx;
805 : :
806 : 0 : return best;
807 : : }
808 : :
809 : 0 : return best;
810 : : }
811 : :
812 : : /* Find highest freq at or below target in a table in descending order */
813 : : static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
814 : : unsigned int target_freq)
815 : : {
816 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
817 : : struct cpufreq_frequency_table *pos;
818 : : unsigned int freq;
819 : : int idx, best = -1;
820 : :
821 : 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
822 : : freq = pos->frequency;
823 : :
824 : 0 : if (freq <= target_freq)
825 : 0 : return idx;
826 : :
827 : : best = idx;
828 : : }
829 : :
830 : 0 : return best;
831 : : }
832 : :
833 : : /* Works only on sorted freq-tables */
834 : 2 : static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
835 : : unsigned int target_freq)
836 : : {
837 : 2 : target_freq = clamp_val(target_freq, policy->min, policy->max);
838 : :
839 : 2 : if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
840 : 2 : return cpufreq_table_find_index_ah(policy, target_freq);
841 : : else
842 : 0 : return cpufreq_table_find_index_dh(policy, target_freq);
843 : : }
844 : :
845 : : /* Find closest freq to target in a table in ascending order */
846 : 2 : static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
847 : : unsigned int target_freq)
848 : : {
849 : 2 : struct cpufreq_frequency_table *table = policy->freq_table;
850 : : struct cpufreq_frequency_table *pos;
851 : : unsigned int freq;
852 : : int idx, best = -1;
853 : :
854 : 2 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
855 : : freq = pos->frequency;
856 : :
857 : 2 : if (freq == target_freq)
858 : 0 : return idx;
859 : :
860 : 2 : if (freq < target_freq) {
861 : : best = idx;
862 : 2 : continue;
863 : : }
864 : :
865 : : /* No freq found below target_freq */
866 : 2 : if (best == -1)
867 : 0 : return idx;
868 : :
869 : : /* Choose the closest freq */
870 : 2 : if (target_freq - table[best].frequency > freq - target_freq)
871 : 2 : return idx;
872 : :
873 : 2 : return best;
874 : : }
875 : :
876 : 0 : return best;
877 : : }
878 : :
879 : : /* Find closest freq to target in a table in descending order */
880 : 0 : static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
881 : : unsigned int target_freq)
882 : : {
883 : 0 : struct cpufreq_frequency_table *table = policy->freq_table;
884 : : struct cpufreq_frequency_table *pos;
885 : : unsigned int freq;
886 : : int idx, best = -1;
887 : :
888 : 0 : cpufreq_for_each_valid_entry_idx(pos, table, idx) {
889 : : freq = pos->frequency;
890 : :
891 : 0 : if (freq == target_freq)
892 : 0 : return idx;
893 : :
894 : 0 : if (freq > target_freq) {
895 : : best = idx;
896 : 0 : continue;
897 : : }
898 : :
899 : : /* No freq found above target_freq */
900 : 0 : if (best == -1)
901 : 0 : return idx;
902 : :
903 : : /* Choose the closest freq */
904 : 0 : if (table[best].frequency - target_freq > target_freq - freq)
905 : 0 : return idx;
906 : :
907 : 0 : return best;
908 : : }
909 : :
910 : 0 : return best;
911 : : }
912 : :
913 : : /* Works only on sorted freq-tables */
914 : 2 : static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
915 : : unsigned int target_freq)
916 : : {
917 : 2 : target_freq = clamp_val(target_freq, policy->min, policy->max);
918 : :
919 : 2 : if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
920 : 2 : return cpufreq_table_find_index_ac(policy, target_freq);
921 : : else
922 : 0 : return cpufreq_table_find_index_dc(policy, target_freq);
923 : : }
924 : :
925 : 2 : static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
926 : : unsigned int target_freq,
927 : : unsigned int relation)
928 : : {
929 : 2 : if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED))
930 : 0 : return cpufreq_table_index_unsorted(policy, target_freq,
931 : : relation);
932 : :
933 : 2 : switch (relation) {
934 : : case CPUFREQ_RELATION_L:
935 : 0 : return cpufreq_table_find_index_l(policy, target_freq);
936 : : case CPUFREQ_RELATION_H:
937 : 2 : return cpufreq_table_find_index_h(policy, target_freq);
938 : : case CPUFREQ_RELATION_C:
939 : 2 : return cpufreq_table_find_index_c(policy, target_freq);
940 : : default:
941 : 0 : pr_err("%s: Invalid relation: %d\n", __func__, relation);
942 : 0 : return -EINVAL;
943 : : }
944 : : }
945 : :
946 : : static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy)
947 : : {
948 : : struct cpufreq_frequency_table *pos;
949 : : int count = 0;
950 : :
951 : 2 : if (unlikely(!policy->freq_table))
952 : : return 0;
953 : :
954 : 2 : cpufreq_for_each_valid_entry(pos, policy->freq_table)
955 : 2 : count++;
956 : :
957 : 2 : return count;
958 : : }
959 : : #else
960 : : static inline int cpufreq_boost_trigger_state(int state)
961 : : {
962 : : return 0;
963 : : }
964 : : static inline int cpufreq_boost_enabled(void)
965 : : {
966 : : return 0;
967 : : }
968 : :
969 : : static inline int cpufreq_enable_boost_support(void)
970 : : {
971 : : return -EINVAL;
972 : : }
973 : :
974 : : static inline bool policy_has_boost_freq(struct cpufreq_policy *policy)
975 : : {
976 : : return false;
977 : : }
978 : : #endif
979 : :
980 : : #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
981 : : void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
982 : : struct cpufreq_governor *old_gov);
983 : : #else
984 : : static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
985 : : struct cpufreq_governor *old_gov) { }
986 : : #endif
987 : :
988 : : extern void arch_freq_prepare_all(void);
989 : : extern unsigned int arch_freq_get_on_cpu(int cpu);
990 : :
991 : : extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq,
992 : : unsigned long max_freq);
993 : :
994 : : /* the following are really really optional */
995 : : extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
996 : : extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
997 : : extern struct freq_attr *cpufreq_generic_attr[];
998 : : int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy);
999 : :
1000 : : unsigned int cpufreq_generic_get(unsigned int cpu);
1001 : : void cpufreq_generic_init(struct cpufreq_policy *policy,
1002 : : struct cpufreq_frequency_table *table,
1003 : : unsigned int transition_latency);
1004 : : #endif /* _LINUX_CPUFREQ_H */
|
