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