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