2 * linux/include/linux/cpufreq.h
4 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
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.
11 #ifndef _LINUX_CPUFREQ_H
12 #define _LINUX_CPUFREQ_H
14 #include <asm/cputime.h>
15 #include <linux/mutex.h>
16 #include <linux/notifier.h>
17 #include <linux/threads.h>
18 #include <linux/kobject.h>
19 #include <linux/sysfs.h>
20 #include <linux/completion.h>
21 #include <linux/workqueue.h>
22 #include <linux/cpumask.h>
23 #include <asm/div64.h>
25 #define CPUFREQ_NAME_LEN 16
26 /* Print length for names. Extra 1 space for accomodating '\n' in prints */
27 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
29 /*********************************************************************
30 * CPUFREQ NOTIFIER INTERFACE *
31 *********************************************************************/
33 #define CPUFREQ_TRANSITION_NOTIFIER (0)
34 #define CPUFREQ_POLICY_NOTIFIER (1)
36 #ifdef CONFIG_CPU_FREQ
37 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
38 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
39 extern void disable_cpufreq(void);
40 #else /* CONFIG_CPU_FREQ */
41 static inline int cpufreq_register_notifier(struct notifier_block *nb,
46 static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
51 static inline void disable_cpufreq(void) { }
52 #endif /* CONFIG_CPU_FREQ */
54 /* if (cpufreq_driver->target) exists, the ->governor decides what frequency
55 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
56 * two generic policies are available:
59 #define CPUFREQ_POLICY_POWERSAVE (1)
60 #define CPUFREQ_POLICY_PERFORMANCE (2)
62 /* Frequency values here are CPU kHz so that hardware which doesn't run
63 * with some frequencies can complain without having to guess what per
64 * cent / per mille means.
65 * Maximum transition latency is in nanoseconds - if it's unknown,
66 * CPUFREQ_ETERNAL shall be used.
69 struct cpufreq_governor;
71 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */
72 extern struct kobject *cpufreq_global_kobject;
73 int cpufreq_get_global_kobject(void);
74 void cpufreq_put_global_kobject(void);
75 int cpufreq_sysfs_create_file(const struct attribute *attr);
76 void cpufreq_sysfs_remove_file(const struct attribute *attr);
78 #define CPUFREQ_ETERNAL (-1)
79 struct cpufreq_cpuinfo {
80 unsigned int max_freq;
81 unsigned int min_freq;
83 /* in 10^(-9) s = nanoseconds */
84 unsigned int transition_latency;
87 struct cpufreq_real_policy {
88 unsigned int min; /* in kHz */
89 unsigned int max; /* in kHz */
90 unsigned int policy; /* see above */
91 struct cpufreq_governor *governor; /* see below */
94 struct cpufreq_policy {
95 /* CPUs sharing clock, require sw coordination */
96 cpumask_var_t cpus; /* Online CPUs only */
97 cpumask_var_t related_cpus; /* Online + Offline CPUs */
99 unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs
100 should set cpufreq */
101 unsigned int cpu; /* cpu nr of CPU managing this policy */
102 unsigned int last_cpu; /* cpu nr of previous CPU that managed
104 struct cpufreq_cpuinfo cpuinfo;/* see above */
106 unsigned int min; /* in kHz */
107 unsigned int max; /* in kHz */
108 unsigned int cur; /* in kHz, only needed if cpufreq
109 * governors are used */
110 unsigned int policy; /* see above */
111 struct cpufreq_governor *governor; /* see below */
113 bool governor_enabled; /* governor start/stop flag */
115 struct work_struct update; /* if update_policy() needs to be
116 * called, but you're in IRQ context */
118 struct cpufreq_real_policy user_policy;
121 struct completion kobj_unregister;
122 int transition_ongoing; /* Tracks transition status */
125 #define CPUFREQ_ADJUST (0)
126 #define CPUFREQ_INCOMPATIBLE (1)
127 #define CPUFREQ_NOTIFY (2)
128 #define CPUFREQ_START (3)
129 #define CPUFREQ_UPDATE_POLICY_CPU (4)
132 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
133 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */
134 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */
135 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/
137 static inline bool policy_is_shared(struct cpufreq_policy *policy)
139 return cpumask_weight(policy->cpus) > 1;
142 /******************** cpufreq transition notifiers *******************/
144 #define CPUFREQ_PRECHANGE (0)
145 #define CPUFREQ_POSTCHANGE (1)
146 #define CPUFREQ_RESUMECHANGE (8)
147 #define CPUFREQ_SUSPENDCHANGE (9)
149 struct cpufreq_freqs {
150 unsigned int cpu; /* cpu nr */
153 u8 flags; /* flags of cpufreq_driver, see below. */
157 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
164 * new = old * mult / div
166 static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
169 #if BITS_PER_LONG == 32
171 u64 result = ((u64) old) * ((u64) mult);
173 return (unsigned long) result;
175 #elif BITS_PER_LONG == 64
177 unsigned long result = old * ((u64) mult);
184 /*********************************************************************
185 * CPUFREQ GOVERNORS *
186 *********************************************************************/
188 #define CPUFREQ_GOV_START 1
189 #define CPUFREQ_GOV_STOP 2
190 #define CPUFREQ_GOV_LIMITS 3
191 #define CPUFREQ_GOV_POLICY_INIT 4
192 #define CPUFREQ_GOV_POLICY_EXIT 5
194 struct cpufreq_governor {
195 char name[CPUFREQ_NAME_LEN];
197 int (*governor) (struct cpufreq_policy *policy,
199 ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
201 int (*store_setspeed) (struct cpufreq_policy *policy,
203 unsigned int max_transition_latency; /* HW must be able to switch to
204 next freq faster than this value in nano secs or we
205 will fallback to performance governor */
206 struct list_head governor_list;
207 struct module *owner;
211 * Pass a target to the cpufreq driver.
213 extern int cpufreq_driver_target(struct cpufreq_policy *policy,
214 unsigned int target_freq,
215 unsigned int relation);
216 extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
217 unsigned int target_freq,
218 unsigned int relation);
219 int cpufreq_register_governor(struct cpufreq_governor *governor);
220 void cpufreq_unregister_governor(struct cpufreq_governor *governor);
222 /*********************************************************************
223 * CPUFREQ DRIVER INTERFACE *
224 *********************************************************************/
226 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
227 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
231 struct cpufreq_driver {
232 struct module *owner;
233 char name[CPUFREQ_NAME_LEN];
236 * This should be set by platforms having multiple clock-domains, i.e.
237 * supporting multiple policies. With this sysfs directories of governor
238 * would be created in cpu/cpu<num>/cpufreq/ directory and so they can
239 * use the same governor with different tunables for different clusters.
241 bool have_governor_per_policy;
243 /* needed by all drivers */
244 int (*init) (struct cpufreq_policy *policy);
245 int (*verify) (struct cpufreq_policy *policy);
247 /* define one out of two */
248 int (*setpolicy) (struct cpufreq_policy *policy);
249 int (*target) (struct cpufreq_policy *policy,
250 unsigned int target_freq,
251 unsigned int relation);
253 /* should be defined, if possible */
254 unsigned int (*get) (unsigned int cpu);
257 int (*bios_limit) (int cpu, unsigned int *limit);
259 int (*exit) (struct cpufreq_policy *policy);
260 int (*suspend) (struct cpufreq_policy *policy);
261 int (*resume) (struct cpufreq_policy *policy);
262 struct freq_attr **attr;
267 #define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if
268 * all ->init() calls failed */
269 #define CPUFREQ_CONST_LOOPS 0x02 /* loops_per_jiffy or other kernel
270 * "constants" aren't affected by
271 * frequency transitions */
272 #define CPUFREQ_PM_NO_WARN 0x04 /* don't warn on suspend/resume speed
275 int cpufreq_register_driver(struct cpufreq_driver *driver_data);
276 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
278 void cpufreq_notify_transition(struct cpufreq_policy *policy,
279 struct cpufreq_freqs *freqs, unsigned int state);
281 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
282 unsigned int min, unsigned int max)
284 if (policy->min < min)
286 if (policy->max < min)
288 if (policy->min > max)
290 if (policy->max > max)
292 if (policy->min > policy->max)
293 policy->min = policy->max;
298 struct attribute attr;
299 ssize_t (*show)(struct cpufreq_policy *, char *);
300 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
303 #define cpufreq_freq_attr_ro(_name) \
304 static struct freq_attr _name = \
305 __ATTR(_name, 0444, show_##_name, NULL)
307 #define cpufreq_freq_attr_ro_perm(_name, _perm) \
308 static struct freq_attr _name = \
309 __ATTR(_name, _perm, show_##_name, NULL)
311 #define cpufreq_freq_attr_rw(_name) \
312 static struct freq_attr _name = \
313 __ATTR(_name, 0644, show_##_name, store_##_name)
316 struct attribute attr;
317 ssize_t (*show)(struct kobject *kobj,
318 struct attribute *attr, char *buf);
319 ssize_t (*store)(struct kobject *a, struct attribute *b,
320 const char *c, size_t count);
323 #define define_one_global_ro(_name) \
324 static struct global_attr _name = \
325 __ATTR(_name, 0444, show_##_name, NULL)
327 #define define_one_global_rw(_name) \
328 static struct global_attr _name = \
329 __ATTR(_name, 0644, show_##_name, store_##_name)
331 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
332 void cpufreq_cpu_put(struct cpufreq_policy *data);
333 const char *cpufreq_get_current_driver(void);
335 /*********************************************************************
336 * CPUFREQ 2.6. INTERFACE *
337 *********************************************************************/
338 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
339 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
340 int cpufreq_update_policy(unsigned int cpu);
341 bool have_governor_per_policy(void);
342 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
344 #ifdef CONFIG_CPU_FREQ
346 * query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it
348 unsigned int cpufreq_get(unsigned int cpu);
350 static inline unsigned int cpufreq_get(unsigned int cpu)
357 * query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it
359 #ifdef CONFIG_CPU_FREQ
360 unsigned int cpufreq_quick_get(unsigned int cpu);
361 unsigned int cpufreq_quick_get_max(unsigned int cpu);
363 static inline unsigned int cpufreq_quick_get(unsigned int cpu)
367 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
373 /*********************************************************************
374 * CPUFREQ DEFAULT GOVERNOR *
375 *********************************************************************/
378 * Performance governor is fallback governor if any other gov failed to auto
379 * load due latency restrictions
381 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
382 extern struct cpufreq_governor cpufreq_gov_performance;
384 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
385 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance)
386 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
387 extern struct cpufreq_governor cpufreq_gov_powersave;
388 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave)
389 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
390 extern struct cpufreq_governor cpufreq_gov_userspace;
391 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace)
392 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
393 extern struct cpufreq_governor cpufreq_gov_ondemand;
394 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand)
395 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
396 extern struct cpufreq_governor cpufreq_gov_conservative;
397 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative)
400 /*********************************************************************
401 * FREQUENCY TABLE HELPERS *
402 *********************************************************************/
404 #define CPUFREQ_ENTRY_INVALID ~0
405 #define CPUFREQ_TABLE_END ~1
407 struct cpufreq_frequency_table {
408 unsigned int driver_data; /* driver specific data, not used by core */
409 unsigned int frequency; /* kHz - doesn't need to be in ascending
413 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
414 struct cpufreq_frequency_table *table);
416 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
417 struct cpufreq_frequency_table *table);
419 int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
420 struct cpufreq_frequency_table *table,
421 unsigned int target_freq,
422 unsigned int relation,
423 unsigned int *index);
425 /* the following 3 funtions are for cpufreq core use only */
426 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
428 /* the following are really really optional */
429 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
431 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
433 void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy);
435 void cpufreq_frequency_table_put_attr(unsigned int cpu);
437 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
439 #endif /* _LINUX_CPUFREQ_H */