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