~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/cpufreq.h

Version: ~ [ linux-5.15-rc7 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * linux/include/linux/cpufreq.h
  3  *
  4  * Copyright (C) 2001 Russell King
  5  *           (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  */
 11 #ifndef _LINUX_CPUFREQ_H
 12 #define _LINUX_CPUFREQ_H
 13 
 14 #include <linux/clk.h>
 15 #include <linux/cpumask.h>
 16 #include <linux/completion.h>
 17 #include <linux/kobject.h>
 18 #include <linux/notifier.h>
 19 #include <linux/sysfs.h>
 20 
 21 /*********************************************************************
 22  *                        CPUFREQ INTERFACE                          *
 23  *********************************************************************/
 24 /*
 25  * Frequency values here are CPU kHz
 26  *
 27  * Maximum transition latency is in nanoseconds - if it's unknown,
 28  * CPUFREQ_ETERNAL shall be used.
 29  */
 30 
 31 #define CPUFREQ_ETERNAL                 (-1)
 32 #define CPUFREQ_NAME_LEN                16
 33 /* Print length for names. Extra 1 space for accomodating '\n' in prints */
 34 #define CPUFREQ_NAME_PLEN               (CPUFREQ_NAME_LEN + 1)
 35 
 36 struct cpufreq_governor;
 37 
 38 struct cpufreq_freqs {
 39         unsigned int cpu;       /* cpu nr */
 40         unsigned int old;
 41         unsigned int new;
 42         u8 flags;               /* flags of cpufreq_driver, see below. */
 43 };
 44 
 45 struct cpufreq_cpuinfo {
 46         unsigned int            max_freq;
 47         unsigned int            min_freq;
 48 
 49         /* in 10^(-9) s = nanoseconds */
 50         unsigned int            transition_latency;
 51 };
 52 
 53 struct cpufreq_real_policy {
 54         unsigned int            min;    /* in kHz */
 55         unsigned int            max;    /* in kHz */
 56         unsigned int            policy; /* see above */
 57         struct cpufreq_governor *governor; /* see below */
 58 };
 59 
 60 struct cpufreq_policy {
 61         /* CPUs sharing clock, require sw coordination */
 62         cpumask_var_t           cpus;   /* Online CPUs only */
 63         cpumask_var_t           related_cpus; /* Online + Offline CPUs */
 64 
 65         unsigned int            shared_type; /* ACPI: ANY or ALL affected CPUs
 66                                                 should set cpufreq */
 67         unsigned int            cpu;    /* cpu nr of CPU managing this policy */
 68         unsigned int            last_cpu; /* cpu nr of previous CPU that managed
 69                                            * this policy */
 70         struct clk              *clk;
 71         struct cpufreq_cpuinfo  cpuinfo;/* see above */
 72 
 73         unsigned int            min;    /* in kHz */
 74         unsigned int            max;    /* in kHz */
 75         unsigned int            cur;    /* in kHz, only needed if cpufreq
 76                                          * governors are used */
 77         unsigned int            policy; /* see above */
 78         struct cpufreq_governor *governor; /* see below */
 79         void                    *governor_data;
 80         bool                    governor_enabled; /* governor start/stop flag */
 81 
 82         struct work_struct      update; /* if update_policy() needs to be
 83                                          * called, but you're in IRQ context */
 84 
 85         struct cpufreq_real_policy      user_policy;
 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          * Additional rules:
100          * - Lock should not be held across
101          *     __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
102          */
103         struct rw_semaphore     rwsem;
104 };
105 
106 /* Only for ACPI */
107 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
108 #define CPUFREQ_SHARED_TYPE_HW   (1) /* HW does needed coordination */
109 #define CPUFREQ_SHARED_TYPE_ALL  (2) /* All dependent CPUs should set freq */
110 #define CPUFREQ_SHARED_TYPE_ANY  (3) /* Freq can be set from any dependent CPU*/
111 
112 #ifdef CONFIG_CPU_FREQ
113 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
114 void cpufreq_cpu_put(struct cpufreq_policy *policy);
115 #else
116 static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
117 {
118         return NULL;
119 }
120 static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
121 #endif
122 
123 static inline bool policy_is_shared(struct cpufreq_policy *policy)
124 {
125         return cpumask_weight(policy->cpus) > 1;
126 }
127 
128 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */
129 extern struct kobject *cpufreq_global_kobject;
130 int cpufreq_get_global_kobject(void);
131 void cpufreq_put_global_kobject(void);
132 int cpufreq_sysfs_create_file(const struct attribute *attr);
133 void cpufreq_sysfs_remove_file(const struct attribute *attr);
134 
135 #ifdef CONFIG_CPU_FREQ
136 unsigned int cpufreq_get(unsigned int cpu);
137 unsigned int cpufreq_quick_get(unsigned int cpu);
138 unsigned int cpufreq_quick_get_max(unsigned int cpu);
139 void disable_cpufreq(void);
140 
141 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
142 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
143 int cpufreq_update_policy(unsigned int cpu);
144 bool have_governor_per_policy(void);
145 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
146 #else
147 static inline unsigned int cpufreq_get(unsigned int cpu)
148 {
149         return 0;
150 }
151 static inline unsigned int cpufreq_quick_get(unsigned int cpu)
152 {
153         return 0;
154 }
155 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
156 {
157         return 0;
158 }
159 static inline void disable_cpufreq(void) { }
160 #endif
161 
162 /*********************************************************************
163  *                      CPUFREQ DRIVER INTERFACE                     *
164  *********************************************************************/
165 
166 #define CPUFREQ_RELATION_L 0  /* lowest frequency at or above target */
167 #define CPUFREQ_RELATION_H 1  /* highest frequency below or at target */
168 
169 struct freq_attr {
170         struct attribute attr;
171         ssize_t (*show)(struct cpufreq_policy *, char *);
172         ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
173 };
174 
175 #define cpufreq_freq_attr_ro(_name)             \
176 static struct freq_attr _name =                 \
177 __ATTR(_name, 0444, show_##_name, NULL)
178 
179 #define cpufreq_freq_attr_ro_perm(_name, _perm) \
180 static struct freq_attr _name =                 \
181 __ATTR(_name, _perm, show_##_name, NULL)
182 
183 #define cpufreq_freq_attr_rw(_name)             \
184 static struct freq_attr _name =                 \
185 __ATTR(_name, 0644, show_##_name, store_##_name)
186 
187 struct global_attr {
188         struct attribute attr;
189         ssize_t (*show)(struct kobject *kobj,
190                         struct attribute *attr, char *buf);
191         ssize_t (*store)(struct kobject *a, struct attribute *b,
192                          const char *c, size_t count);
193 };
194 
195 #define define_one_global_ro(_name)             \
196 static struct global_attr _name =               \
197 __ATTR(_name, 0444, show_##_name, NULL)
198 
199 #define define_one_global_rw(_name)             \
200 static struct global_attr _name =               \
201 __ATTR(_name, 0644, show_##_name, store_##_name)
202 
203 
204 struct cpufreq_driver {
205         char                    name[CPUFREQ_NAME_LEN];
206         u8                      flags;
207 
208         /* needed by all drivers */
209         int     (*init)         (struct cpufreq_policy *policy);
210         int     (*verify)       (struct cpufreq_policy *policy);
211 
212         /* define one out of two */
213         int     (*setpolicy)    (struct cpufreq_policy *policy);
214         int     (*target)       (struct cpufreq_policy *policy, /* Deprecated */
215                                  unsigned int target_freq,
216                                  unsigned int relation);
217         int     (*target_index) (struct cpufreq_policy *policy,
218                                  unsigned int index);
219 
220         /* should be defined, if possible */
221         unsigned int    (*get)  (unsigned int cpu);
222 
223         /* optional */
224         int     (*bios_limit)   (int cpu, unsigned int *limit);
225 
226         int     (*exit)         (struct cpufreq_policy *policy);
227         int     (*suspend)      (struct cpufreq_policy *policy);
228         int     (*resume)       (struct cpufreq_policy *policy);
229         struct freq_attr        **attr;
230 
231         /* platform specific boost support code */
232         bool                    boost_supported;
233         bool                    boost_enabled;
234         int     (*set_boost)    (int state);
235 };
236 
237 /* flags */
238 #define CPUFREQ_STICKY          (1 << 0)        /* driver isn't removed even if
239                                                    all ->init() calls failed */
240 #define CPUFREQ_CONST_LOOPS     (1 << 1)        /* loops_per_jiffy or other
241                                                    kernel "constants" aren't
242                                                    affected by frequency
243                                                    transitions */
244 #define CPUFREQ_PM_NO_WARN      (1 << 2)        /* don't warn on suspend/resume
245                                                    speed mismatches */
246 
247 /*
248  * This should be set by platforms having multiple clock-domains, i.e.
249  * supporting multiple policies. With this sysfs directories of governor would
250  * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
251  * governor with different tunables for different clusters.
252  */
253 #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3)
254 
255 /*
256  * Driver will do POSTCHANGE notifications from outside of their ->target()
257  * routine and so must set cpufreq_driver->flags with this flag, so that core
258  * can handle them specially.
259  */
260 #define CPUFREQ_ASYNC_NOTIFICATION  (1 << 4)
261 
262 /*
263  * Set by drivers which want cpufreq core to check if CPU is running at a
264  * frequency present in freq-table exposed by the driver. For these drivers if
265  * CPU is found running at an out of table freq, we will try to set it to a freq
266  * from the table. And if that fails, we will stop further boot process by
267  * issuing a BUG_ON().
268  */
269 #define CPUFREQ_NEED_INITIAL_FREQ_CHECK (1 << 5)
270 
271 int cpufreq_register_driver(struct cpufreq_driver *driver_data);
272 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
273 
274 const char *cpufreq_get_current_driver(void);
275 
276 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
277                 unsigned int min, unsigned int max)
278 {
279         if (policy->min < min)
280                 policy->min = min;
281         if (policy->max < min)
282                 policy->max = min;
283         if (policy->min > max)
284                 policy->min = max;
285         if (policy->max > max)
286                 policy->max = max;
287         if (policy->min > policy->max)
288                 policy->min = policy->max;
289         return;
290 }
291 
292 static inline void
293 cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
294 {
295         cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
296                         policy->cpuinfo.max_freq);
297 }
298 
299 /*********************************************************************
300  *                     CPUFREQ NOTIFIER INTERFACE                    *
301  *********************************************************************/
302 
303 #define CPUFREQ_TRANSITION_NOTIFIER     (0)
304 #define CPUFREQ_POLICY_NOTIFIER         (1)
305 
306 /* Transition notifiers */
307 #define CPUFREQ_PRECHANGE               (0)
308 #define CPUFREQ_POSTCHANGE              (1)
309 #define CPUFREQ_RESUMECHANGE            (8)
310 #define CPUFREQ_SUSPENDCHANGE           (9)
311 
312 /* Policy Notifiers  */
313 #define CPUFREQ_ADJUST                  (0)
314 #define CPUFREQ_INCOMPATIBLE            (1)
315 #define CPUFREQ_NOTIFY                  (2)
316 #define CPUFREQ_START                   (3)
317 #define CPUFREQ_UPDATE_POLICY_CPU       (4)
318 #define CPUFREQ_CREATE_POLICY           (5)
319 #define CPUFREQ_REMOVE_POLICY           (6)
320 
321 #ifdef CONFIG_CPU_FREQ
322 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
323 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
324 
325 void cpufreq_notify_transition(struct cpufreq_policy *policy,
326                 struct cpufreq_freqs *freqs, unsigned int state);
327 void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
328                 struct cpufreq_freqs *freqs, int transition_failed);
329 
330 #else /* CONFIG_CPU_FREQ */
331 static inline int cpufreq_register_notifier(struct notifier_block *nb,
332                                                 unsigned int list)
333 {
334         return 0;
335 }
336 static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
337                                                 unsigned int list)
338 {
339         return 0;
340 }
341 #endif /* !CONFIG_CPU_FREQ */
342 
343 /**
344  * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
345  * safe)
346  * @old:   old value
347  * @div:   divisor
348  * @mult:  multiplier
349  *
350  *
351  * new = old * mult / div
352  */
353 static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
354                 u_int mult)
355 {
356 #if BITS_PER_LONG == 32
357         u64 result = ((u64) old) * ((u64) mult);
358         do_div(result, div);
359         return (unsigned long) result;
360 
361 #elif BITS_PER_LONG == 64
362         unsigned long result = old * ((u64) mult);
363         result /= div;
364         return result;
365 #endif
366 }
367 
368 /*********************************************************************
369  *                          CPUFREQ GOVERNORS                        *
370  *********************************************************************/
371 
372 /*
373  * If (cpufreq_driver->target) exists, the ->governor decides what frequency
374  * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
375  * two generic policies are available:
376  */
377 #define CPUFREQ_POLICY_POWERSAVE        (1)
378 #define CPUFREQ_POLICY_PERFORMANCE      (2)
379 
380 /* Governor Events */
381 #define CPUFREQ_GOV_START       1
382 #define CPUFREQ_GOV_STOP        2
383 #define CPUFREQ_GOV_LIMITS      3
384 #define CPUFREQ_GOV_POLICY_INIT 4
385 #define CPUFREQ_GOV_POLICY_EXIT 5
386 
387 struct cpufreq_governor {
388         char    name[CPUFREQ_NAME_LEN];
389         int     initialized;
390         int     (*governor)     (struct cpufreq_policy *policy,
391                                  unsigned int event);
392         ssize_t (*show_setspeed)        (struct cpufreq_policy *policy,
393                                          char *buf);
394         int     (*store_setspeed)       (struct cpufreq_policy *policy,
395                                          unsigned int freq);
396         unsigned int max_transition_latency; /* HW must be able to switch to
397                         next freq faster than this value in nano secs or we
398                         will fallback to performance governor */
399         struct list_head        governor_list;
400         struct module           *owner;
401 };
402 
403 /* Pass a target to the cpufreq driver */
404 int cpufreq_driver_target(struct cpufreq_policy *policy,
405                                  unsigned int target_freq,
406                                  unsigned int relation);
407 int __cpufreq_driver_target(struct cpufreq_policy *policy,
408                                    unsigned int target_freq,
409                                    unsigned int relation);
410 int cpufreq_register_governor(struct cpufreq_governor *governor);
411 void cpufreq_unregister_governor(struct cpufreq_governor *governor);
412 
413 /* CPUFREQ DEFAULT GOVERNOR */
414 /*
415  * Performance governor is fallback governor if any other gov failed to auto
416  * load due latency restrictions
417  */
418 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
419 extern struct cpufreq_governor cpufreq_gov_performance;
420 #endif
421 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
422 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_performance)
423 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
424 extern struct cpufreq_governor cpufreq_gov_powersave;
425 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_powersave)
426 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
427 extern struct cpufreq_governor cpufreq_gov_userspace;
428 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_userspace)
429 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
430 extern struct cpufreq_governor cpufreq_gov_ondemand;
431 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_ondemand)
432 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
433 extern struct cpufreq_governor cpufreq_gov_conservative;
434 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_conservative)
435 #endif
436 
437 /*********************************************************************
438  *                     FREQUENCY TABLE HELPERS                       *
439  *********************************************************************/
440 
441 #define CPUFREQ_ENTRY_INVALID ~0
442 #define CPUFREQ_TABLE_END     ~1
443 #define CPUFREQ_BOOST_FREQ    ~2
444 
445 struct cpufreq_frequency_table {
446         unsigned int    driver_data; /* driver specific data, not used by core */
447         unsigned int    frequency; /* kHz - doesn't need to be in ascending
448                                     * order */
449 };
450 
451 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
452                                     struct cpufreq_frequency_table *table);
453 
454 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
455                                    struct cpufreq_frequency_table *table);
456 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
457 
458 int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
459                                    struct cpufreq_frequency_table *table,
460                                    unsigned int target_freq,
461                                    unsigned int relation,
462                                    unsigned int *index);
463 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
464                 unsigned int freq);
465 
466 void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy);
467 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
468 
469 #ifdef CONFIG_CPU_FREQ
470 int cpufreq_boost_trigger_state(int state);
471 int cpufreq_boost_supported(void);
472 int cpufreq_boost_enabled(void);
473 #else
474 static inline int cpufreq_boost_trigger_state(int state)
475 {
476         return 0;
477 }
478 static inline int cpufreq_boost_supported(void)
479 {
480         return 0;
481 }
482 static inline int cpufreq_boost_enabled(void)
483 {
484         return 0;
485 }
486 #endif
487 /* the following funtion is for cpufreq core use only */
488 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
489 
490 /* the following are really really optional */
491 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
492 extern struct freq_attr *cpufreq_generic_attr[];
493 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
494                                       unsigned int cpu);
495 void cpufreq_frequency_table_put_attr(unsigned int cpu);
496 int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
497                                       struct cpufreq_frequency_table *table);
498 
499 unsigned int cpufreq_generic_get(unsigned int cpu);
500 int cpufreq_generic_init(struct cpufreq_policy *policy,
501                 struct cpufreq_frequency_table *table,
502                 unsigned int transition_latency);
503 static inline int cpufreq_generic_exit(struct cpufreq_policy *policy)
504 {
505         cpufreq_frequency_table_put_attr(policy->cpu);
506         return 0;
507 }
508 
509 #endif /* _LINUX_CPUFREQ_H */
510 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp