|
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/mutex.h> |
|
15 #include <linux/notifier.h> |
|
16 #include <linux/threads.h> |
|
17 #include <linux/device.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> |
|
24 |
|
25 #define CPUFREQ_NAME_LEN 16 |
|
26 |
|
27 |
|
28 /********************************************************************* |
|
29 * CPUFREQ NOTIFIER INTERFACE * |
|
30 *********************************************************************/ |
|
31 |
|
32 #define CPUFREQ_TRANSITION_NOTIFIER (0) |
|
33 #define CPUFREQ_POLICY_NOTIFIER (1) |
|
34 |
|
35 #ifdef CONFIG_CPU_FREQ |
|
36 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); |
|
37 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); |
|
38 #else /* CONFIG_CPU_FREQ */ |
|
39 static inline int cpufreq_register_notifier(struct notifier_block *nb, |
|
40 unsigned int list) |
|
41 { |
|
42 return 0; |
|
43 } |
|
44 static inline int cpufreq_unregister_notifier(struct notifier_block *nb, |
|
45 unsigned int list) |
|
46 { |
|
47 return 0; |
|
48 } |
|
49 #endif /* CONFIG_CPU_FREQ */ |
|
50 |
|
51 /* if (cpufreq_driver->target) exists, the ->governor decides what frequency |
|
52 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these |
|
53 * two generic policies are available: |
|
54 */ |
|
55 |
|
56 #define CPUFREQ_POLICY_POWERSAVE (1) |
|
57 #define CPUFREQ_POLICY_PERFORMANCE (2) |
|
58 |
|
59 /* Frequency values here are CPU kHz so that hardware which doesn't run |
|
60 * with some frequencies can complain without having to guess what per |
|
61 * cent / per mille means. |
|
62 * Maximum transition latency is in nanoseconds - if it's unknown, |
|
63 * CPUFREQ_ETERNAL shall be used. |
|
64 */ |
|
65 |
|
66 struct cpufreq_governor; |
|
67 |
|
68 #define CPUFREQ_ETERNAL (-1) |
|
69 struct cpufreq_cpuinfo { |
|
70 unsigned int max_freq; |
|
71 unsigned int min_freq; |
|
72 unsigned int transition_latency; /* in 10^(-9) s = nanoseconds */ |
|
73 }; |
|
74 |
|
75 struct cpufreq_real_policy { |
|
76 unsigned int min; /* in kHz */ |
|
77 unsigned int max; /* in kHz */ |
|
78 unsigned int policy; /* see above */ |
|
79 struct cpufreq_governor *governor; /* see below */ |
|
80 }; |
|
81 |
|
82 struct cpufreq_policy { |
|
83 cpumask_t cpus; /* CPUs requiring sw coordination */ |
|
84 cpumask_t related_cpus; /* CPUs with any coordination */ |
|
85 unsigned int shared_type; /* ANY or ALL affected CPUs |
|
86 should set cpufreq */ |
|
87 unsigned int cpu; /* cpu nr of registered CPU */ |
|
88 struct cpufreq_cpuinfo cpuinfo;/* see above */ |
|
89 |
|
90 unsigned int min; /* in kHz */ |
|
91 unsigned int max; /* in kHz */ |
|
92 unsigned int cur; /* in kHz, only needed if cpufreq |
|
93 * governors are used */ |
|
94 unsigned int policy; /* see above */ |
|
95 struct cpufreq_governor *governor; /* see below */ |
|
96 |
|
97 struct work_struct update; /* if update_policy() needs to be |
|
98 * called, but you're in IRQ context */ |
|
99 |
|
100 struct cpufreq_real_policy user_policy; |
|
101 |
|
102 struct kobject kobj; |
|
103 struct completion kobj_unregister; |
|
104 }; |
|
105 |
|
106 #define CPUFREQ_ADJUST (0) |
|
107 #define CPUFREQ_INCOMPATIBLE (1) |
|
108 #define CPUFREQ_NOTIFY (2) |
|
109 #define CPUFREQ_START (3) |
|
110 |
|
111 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ |
|
112 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ |
|
113 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ |
|
114 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ |
|
115 |
|
116 /******************** cpufreq transition notifiers *******************/ |
|
117 |
|
118 #define CPUFREQ_PRECHANGE (0) |
|
119 #define CPUFREQ_POSTCHANGE (1) |
|
120 #define CPUFREQ_RESUMECHANGE (8) |
|
121 #define CPUFREQ_SUSPENDCHANGE (9) |
|
122 |
|
123 struct cpufreq_freqs { |
|
124 unsigned int cpu; /* cpu nr */ |
|
125 unsigned int old; |
|
126 unsigned int new; |
|
127 u8 flags; /* flags of cpufreq_driver, see below. */ |
|
128 }; |
|
129 |
|
130 |
|
131 /** |
|
132 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe) |
|
133 * @old: old value |
|
134 * @div: divisor |
|
135 * @mult: multiplier |
|
136 * |
|
137 * |
|
138 * new = old * mult / div |
|
139 */ |
|
140 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult) |
|
141 { |
|
142 #if BITS_PER_LONG == 32 |
|
143 |
|
144 u64 result = ((u64) old) * ((u64) mult); |
|
145 do_div(result, div); |
|
146 return (unsigned long) result; |
|
147 |
|
148 #elif BITS_PER_LONG == 64 |
|
149 |
|
150 unsigned long result = old * ((u64) mult); |
|
151 result /= div; |
|
152 return result; |
|
153 |
|
154 #endif |
|
155 }; |
|
156 |
|
157 /********************************************************************* |
|
158 * CPUFREQ GOVERNORS * |
|
159 *********************************************************************/ |
|
160 |
|
161 #define CPUFREQ_GOV_START 1 |
|
162 #define CPUFREQ_GOV_STOP 2 |
|
163 #define CPUFREQ_GOV_LIMITS 3 |
|
164 |
|
165 struct cpufreq_governor { |
|
166 char name[CPUFREQ_NAME_LEN]; |
|
167 int (*governor) (struct cpufreq_policy *policy, |
|
168 unsigned int event); |
|
169 ssize_t (*show_setspeed) (struct cpufreq_policy *policy, |
|
170 char *buf); |
|
171 int (*store_setspeed) (struct cpufreq_policy *policy, |
|
172 unsigned int freq); |
|
173 unsigned int max_transition_latency; /* HW must be able to switch to |
|
174 next freq faster than this value in nano secs or we |
|
175 will fallback to performance governor */ |
|
176 struct list_head governor_list; |
|
177 struct module *owner; |
|
178 }; |
|
179 |
|
180 /* pass a target to the cpufreq driver |
|
181 */ |
|
182 extern int cpufreq_driver_target(struct cpufreq_policy *policy, |
|
183 unsigned int target_freq, |
|
184 unsigned int relation); |
|
185 extern int __cpufreq_driver_target(struct cpufreq_policy *policy, |
|
186 unsigned int target_freq, |
|
187 unsigned int relation); |
|
188 |
|
189 |
|
190 extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy, |
|
191 unsigned int cpu); |
|
192 |
|
193 int cpufreq_register_governor(struct cpufreq_governor *governor); |
|
194 void cpufreq_unregister_governor(struct cpufreq_governor *governor); |
|
195 |
|
196 int lock_policy_rwsem_read(int cpu); |
|
197 int lock_policy_rwsem_write(int cpu); |
|
198 void unlock_policy_rwsem_read(int cpu); |
|
199 void unlock_policy_rwsem_write(int cpu); |
|
200 |
|
201 |
|
202 /********************************************************************* |
|
203 * CPUFREQ DRIVER INTERFACE * |
|
204 *********************************************************************/ |
|
205 |
|
206 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ |
|
207 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ |
|
208 |
|
209 struct freq_attr; |
|
210 |
|
211 struct cpufreq_driver { |
|
212 struct module *owner; |
|
213 char name[CPUFREQ_NAME_LEN]; |
|
214 u8 flags; |
|
215 |
|
216 /* needed by all drivers */ |
|
217 int (*init) (struct cpufreq_policy *policy); |
|
218 int (*verify) (struct cpufreq_policy *policy); |
|
219 |
|
220 /* define one out of two */ |
|
221 int (*setpolicy) (struct cpufreq_policy *policy); |
|
222 int (*target) (struct cpufreq_policy *policy, |
|
223 unsigned int target_freq, |
|
224 unsigned int relation); |
|
225 |
|
226 /* should be defined, if possible */ |
|
227 unsigned int (*get) (unsigned int cpu); |
|
228 |
|
229 /* optional */ |
|
230 unsigned int (*getavg) (struct cpufreq_policy *policy, |
|
231 unsigned int cpu); |
|
232 |
|
233 int (*exit) (struct cpufreq_policy *policy); |
|
234 int (*suspend) (struct cpufreq_policy *policy, pm_message_t pmsg); |
|
235 int (*resume) (struct cpufreq_policy *policy); |
|
236 struct freq_attr **attr; |
|
237 }; |
|
238 |
|
239 /* flags */ |
|
240 |
|
241 #define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if |
|
242 * all ->init() calls failed */ |
|
243 #define CPUFREQ_CONST_LOOPS 0x02 /* loops_per_jiffy or other kernel |
|
244 * "constants" aren't affected by |
|
245 * frequency transitions */ |
|
246 #define CPUFREQ_PM_NO_WARN 0x04 /* don't warn on suspend/resume speed |
|
247 * mismatches */ |
|
248 |
|
249 int cpufreq_register_driver(struct cpufreq_driver *driver_data); |
|
250 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data); |
|
251 |
|
252 |
|
253 void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state); |
|
254 |
|
255 |
|
256 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) |
|
257 { |
|
258 if (policy->min < min) |
|
259 policy->min = min; |
|
260 if (policy->max < min) |
|
261 policy->max = min; |
|
262 if (policy->min > max) |
|
263 policy->min = max; |
|
264 if (policy->max > max) |
|
265 policy->max = max; |
|
266 if (policy->min > policy->max) |
|
267 policy->min = policy->max; |
|
268 return; |
|
269 } |
|
270 |
|
271 struct freq_attr { |
|
272 struct attribute attr; |
|
273 ssize_t (*show)(struct cpufreq_policy *, char *); |
|
274 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); |
|
275 }; |
|
276 |
|
277 |
|
278 /********************************************************************* |
|
279 * CPUFREQ 2.6. INTERFACE * |
|
280 *********************************************************************/ |
|
281 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); |
|
282 int cpufreq_update_policy(unsigned int cpu); |
|
283 |
|
284 /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */ |
|
285 unsigned int cpufreq_get(unsigned int cpu); |
|
286 |
|
287 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */ |
|
288 #ifdef CONFIG_CPU_FREQ |
|
289 unsigned int cpufreq_quick_get(unsigned int cpu); |
|
290 #else |
|
291 static inline unsigned int cpufreq_quick_get(unsigned int cpu) |
|
292 { |
|
293 return 0; |
|
294 } |
|
295 #endif |
|
296 |
|
297 |
|
298 /********************************************************************* |
|
299 * CPUFREQ DEFAULT GOVERNOR * |
|
300 *********************************************************************/ |
|
301 |
|
302 |
|
303 /* |
|
304 Performance governor is fallback governor if any other gov failed to |
|
305 auto load due latency restrictions |
|
306 */ |
|
307 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE |
|
308 extern struct cpufreq_governor cpufreq_gov_performance; |
|
309 #endif |
|
310 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE |
|
311 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance) |
|
312 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE) |
|
313 extern struct cpufreq_governor cpufreq_gov_powersave; |
|
314 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave) |
|
315 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE) |
|
316 extern struct cpufreq_governor cpufreq_gov_userspace; |
|
317 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace) |
|
318 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND) |
|
319 extern struct cpufreq_governor cpufreq_gov_ondemand; |
|
320 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand) |
|
321 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE) |
|
322 extern struct cpufreq_governor cpufreq_gov_conservative; |
|
323 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative) |
|
324 #endif |
|
325 |
|
326 |
|
327 /********************************************************************* |
|
328 * FREQUENCY TABLE HELPERS * |
|
329 *********************************************************************/ |
|
330 |
|
331 #define CPUFREQ_ENTRY_INVALID ~0 |
|
332 #define CPUFREQ_TABLE_END ~1 |
|
333 |
|
334 struct cpufreq_frequency_table { |
|
335 unsigned int index; /* any */ |
|
336 unsigned int frequency; /* kHz - doesn't need to be in ascending |
|
337 * order */ |
|
338 }; |
|
339 |
|
340 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, |
|
341 struct cpufreq_frequency_table *table); |
|
342 |
|
343 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, |
|
344 struct cpufreq_frequency_table *table); |
|
345 |
|
346 int cpufreq_frequency_table_target(struct cpufreq_policy *policy, |
|
347 struct cpufreq_frequency_table *table, |
|
348 unsigned int target_freq, |
|
349 unsigned int relation, |
|
350 unsigned int *index); |
|
351 |
|
352 /* the following 3 funtions are for cpufreq core use only */ |
|
353 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu); |
|
354 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); |
|
355 void cpufreq_cpu_put (struct cpufreq_policy *data); |
|
356 |
|
357 /* the following are really really optional */ |
|
358 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; |
|
359 |
|
360 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, |
|
361 unsigned int cpu); |
|
362 |
|
363 void cpufreq_frequency_table_put_attr(unsigned int cpu); |
|
364 |
|
365 |
|
366 /********************************************************************* |
|
367 * UNIFIED DEBUG HELPERS * |
|
368 *********************************************************************/ |
|
369 |
|
370 #define CPUFREQ_DEBUG_CORE 1 |
|
371 #define CPUFREQ_DEBUG_DRIVER 2 |
|
372 #define CPUFREQ_DEBUG_GOVERNOR 4 |
|
373 |
|
374 #ifdef CONFIG_CPU_FREQ_DEBUG |
|
375 |
|
376 extern void cpufreq_debug_printk(unsigned int type, const char *prefix, |
|
377 const char *fmt, ...); |
|
378 |
|
379 #else |
|
380 |
|
381 #define cpufreq_debug_printk(msg...) do { } while(0) |
|
382 |
|
383 #endif /* CONFIG_CPU_FREQ_DEBUG */ |
|
384 |
|
385 #endif /* _LINUX_CPUFREQ_H */ |