PageRenderTime 28ms CodeModel.GetById 14ms app.highlight 11ms RepoModel.GetById 0ms app.codeStats 0ms

/include/linux/cpufreq.h

https://bitbucket.org/thekraven/iscream_thunderc-2.6.35
C++ Header | 442 lines | 273 code | 92 blank | 77 comment | 7 complexity | 62ea9d1cd448da75fea51a9f8848f8e7 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  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
 36int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
 37int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
 38#else		/* CONFIG_CPU_FREQ */
 39static inline int cpufreq_register_notifier(struct notifier_block *nb,
 40						unsigned int list)
 41{
 42	return 0;
 43}
 44static 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
 66struct cpufreq_governor;
 67
 68/* /sys/devices/system/cpu/cpufreq: entry point for global variables */
 69extern struct kobject *cpufreq_global_kobject;
 70
 71#define CPUFREQ_ETERNAL			(-1)
 72struct cpufreq_cpuinfo {
 73	unsigned int		max_freq;
 74	unsigned int		min_freq;
 75	unsigned int		transition_latency; /* in 10^(-9) s = nanoseconds */
 76};
 77
 78struct cpufreq_real_policy {
 79	unsigned int		min;    /* in kHz */
 80	unsigned int		max;    /* in kHz */
 81        unsigned int		policy; /* see above */
 82	struct cpufreq_governor	*governor; /* see below */
 83};
 84
 85struct cpufreq_policy {
 86	cpumask_var_t		cpus;	/* CPUs requiring sw coordination */
 87	cpumask_var_t		related_cpus; /* CPUs with any coordination */
 88	unsigned int		shared_type; /* ANY or ALL affected CPUs
 89						should set cpufreq */
 90	unsigned int		cpu;    /* cpu nr of registered CPU */
 91	struct cpufreq_cpuinfo	cpuinfo;/* see above */
 92
 93	unsigned int		min;    /* in kHz */
 94	unsigned int		max;    /* in kHz */
 95	unsigned int		cur;    /* in kHz, only needed if cpufreq
 96					 * governors are used */
 97        unsigned int		policy; /* see above */
 98	struct cpufreq_governor	*governor; /* see below */
 99
100	struct work_struct	update; /* if update_policy() needs to be
101					 * called, but you're in IRQ context */
102
103	struct cpufreq_real_policy	user_policy;
104
105	struct kobject		kobj;
106	struct completion	kobj_unregister;
107};
108
109#define CPUFREQ_ADJUST		(0)
110#define CPUFREQ_INCOMPATIBLE	(1)
111#define CPUFREQ_NOTIFY		(2)
112#define CPUFREQ_START		(3)
113
114#define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
115#define CPUFREQ_SHARED_TYPE_HW	 (1) /* HW does needed coordination */
116#define CPUFREQ_SHARED_TYPE_ALL	 (2) /* All dependent CPUs should set freq */
117#define CPUFREQ_SHARED_TYPE_ANY	 (3) /* Freq can be set from any dependent CPU*/
118
119/******************** cpufreq transition notifiers *******************/
120
121#define CPUFREQ_PRECHANGE	(0)
122#define CPUFREQ_POSTCHANGE	(1)
123#define CPUFREQ_RESUMECHANGE	(8)
124#define CPUFREQ_SUSPENDCHANGE	(9)
125
126struct cpufreq_freqs {
127	unsigned int cpu;	/* cpu nr */
128	unsigned int old;
129	unsigned int new;
130	u8 flags;		/* flags of cpufreq_driver, see below. */
131};
132
133
134/**
135 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe)
136 * @old:   old value
137 * @div:   divisor
138 * @mult:  multiplier
139 *
140 *
141 *    new = old * mult / div
142 */
143static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult)
144{
145#if BITS_PER_LONG == 32
146
147	u64 result = ((u64) old) * ((u64) mult);
148	do_div(result, div);
149	return (unsigned long) result;
150
151#elif BITS_PER_LONG == 64
152
153	unsigned long result = old * ((u64) mult);
154	result /= div;
155	return result;
156
157#endif
158};
159
160/*********************************************************************
161 *                          CPUFREQ GOVERNORS                        *
162 *********************************************************************/
163
164#define CPUFREQ_GOV_START  1
165#define CPUFREQ_GOV_STOP   2
166#define CPUFREQ_GOV_LIMITS 3
167
168struct cpufreq_governor {
169	char	name[CPUFREQ_NAME_LEN];
170	int 	(*governor)	(struct cpufreq_policy *policy,
171				 unsigned int event);
172	ssize_t	(*show_setspeed)	(struct cpufreq_policy *policy,
173					 char *buf);
174	int 	(*store_setspeed)	(struct cpufreq_policy *policy,
175					 unsigned int freq);
176	unsigned int max_transition_latency; /* HW must be able to switch to
177			next freq faster than this value in nano secs or we
178			will fallback to performance governor */
179	struct list_head	governor_list;
180	struct module		*owner;
181};
182
183/* pass a target to the cpufreq driver 
184 */
185extern int cpufreq_driver_target(struct cpufreq_policy *policy,
186				 unsigned int target_freq,
187				 unsigned int relation);
188extern int __cpufreq_driver_target(struct cpufreq_policy *policy,
189				   unsigned int target_freq,
190				   unsigned int relation);
191
192
193extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy,
194				   unsigned int cpu);
195
196int cpufreq_register_governor(struct cpufreq_governor *governor);
197void cpufreq_unregister_governor(struct cpufreq_governor *governor);
198
199int lock_policy_rwsem_read(int cpu);
200int lock_policy_rwsem_write(int cpu);
201void unlock_policy_rwsem_read(int cpu);
202void unlock_policy_rwsem_write(int cpu);
203
204
205/*********************************************************************
206 *                      CPUFREQ DRIVER INTERFACE                     *
207 *********************************************************************/
208
209#define CPUFREQ_RELATION_L 0  /* lowest frequency at or above target */
210#define CPUFREQ_RELATION_H 1  /* highest frequency below or at target */
211
212struct freq_attr;
213
214struct cpufreq_driver {
215	struct module           *owner;
216	char			name[CPUFREQ_NAME_LEN];
217	u8			flags;
218
219	/* needed by all drivers */
220	int	(*init)		(struct cpufreq_policy *policy);
221	int	(*verify)	(struct cpufreq_policy *policy);
222
223	/* define one out of two */
224	int	(*setpolicy)	(struct cpufreq_policy *policy);
225	int	(*target)	(struct cpufreq_policy *policy,
226				 unsigned int target_freq,
227				 unsigned int relation);
228
229	/* should be defined, if possible */
230	unsigned int	(*get)	(unsigned int cpu);
231
232	/* optional */
233	unsigned int (*getavg)	(struct cpufreq_policy *policy,
234				 unsigned int cpu);
235	int	(*bios_limit)	(int cpu, unsigned int *limit);
236
237	int	(*exit)		(struct cpufreq_policy *policy);
238	int	(*suspend)	(struct cpufreq_policy *policy, pm_message_t pmsg);
239	int	(*resume)	(struct cpufreq_policy *policy);
240	struct freq_attr	**attr;
241};
242
243/* flags */
244
245#define CPUFREQ_STICKY		0x01	/* the driver isn't removed even if 
246					 * all ->init() calls failed */
247#define CPUFREQ_CONST_LOOPS 	0x02	/* loops_per_jiffy or other kernel
248					 * "constants" aren't affected by
249					 * frequency transitions */
250#define CPUFREQ_PM_NO_WARN	0x04	/* don't warn on suspend/resume speed
251					 * mismatches */
252
253int cpufreq_register_driver(struct cpufreq_driver *driver_data);
254int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
255
256
257void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state);
258
259
260static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 
261{
262	if (policy->min < min)
263		policy->min = min;
264	if (policy->max < min)
265		policy->max = min;
266	if (policy->min > max)
267		policy->min = max;
268	if (policy->max > max)
269		policy->max = max;
270	if (policy->min > policy->max)
271		policy->min = policy->max;
272	return;
273}
274
275struct freq_attr {
276	struct attribute attr;
277	ssize_t (*show)(struct cpufreq_policy *, char *);
278	ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
279};
280
281#define cpufreq_freq_attr_ro(_name)		\
282static struct freq_attr _name =			\
283__ATTR(_name, 0444, show_##_name, NULL)
284
285#define cpufreq_freq_attr_ro_perm(_name, _perm)	\
286static struct freq_attr _name =			\
287__ATTR(_name, _perm, show_##_name, NULL)
288
289#define cpufreq_freq_attr_ro_old(_name)		\
290static struct freq_attr _name##_old =		\
291__ATTR(_name, 0444, show_##_name##_old, NULL)
292
293#define cpufreq_freq_attr_rw(_name)		\
294static struct freq_attr _name =			\
295__ATTR(_name, 0644, show_##_name, store_##_name)
296
297#define cpufreq_freq_attr_rw_old(_name)		\
298static struct freq_attr _name##_old =		\
299__ATTR(_name, 0644, show_##_name##_old, store_##_name##_old)
300
301
302struct global_attr {
303	struct attribute attr;
304	ssize_t (*show)(struct kobject *kobj,
305			struct attribute *attr, char *buf);
306	ssize_t (*store)(struct kobject *a, struct attribute *b,
307			 const char *c, size_t count);
308};
309
310#define define_one_global_ro(_name)		\
311static struct global_attr _name =		\
312__ATTR(_name, 0444, show_##_name, NULL)
313
314#define define_one_global_rw(_name)		\
315static struct global_attr _name =		\
316__ATTR(_name, 0644, show_##_name, store_##_name)
317
318
319/*********************************************************************
320 *                        CPUFREQ 2.6. INTERFACE                     *
321 *********************************************************************/
322int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
323int cpufreq_update_policy(unsigned int cpu);
324
325#ifdef CONFIG_CPU_FREQ
326/* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */
327unsigned int cpufreq_get(unsigned int cpu);
328#else
329static inline unsigned int cpufreq_get(unsigned int cpu)
330{
331	return 0;
332}
333#endif
334
335/* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */
336#ifdef CONFIG_CPU_FREQ
337unsigned int cpufreq_quick_get(unsigned int cpu);
338#else
339static inline unsigned int cpufreq_quick_get(unsigned int cpu)
340{
341	return 0;
342}
343#endif
344
345
346/*********************************************************************
347 *                       CPUFREQ DEFAULT GOVERNOR                    *
348 *********************************************************************/
349
350
351/*
352  Performance governor is fallback governor if any other gov failed to
353  auto load due latency restrictions
354*/
355#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
356extern struct cpufreq_governor cpufreq_gov_performance;
357#endif
358#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
359#define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_performance)
360#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
361extern struct cpufreq_governor cpufreq_gov_powersave;
362#define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_powersave)
363#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
364extern struct cpufreq_governor cpufreq_gov_userspace;
365#define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_userspace)
366#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
367extern struct cpufreq_governor cpufreq_gov_ondemand;
368#define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_ondemand)
369#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
370extern struct cpufreq_governor cpufreq_gov_conservative;
371#define CPUFREQ_DEFAULT_GOVERNOR	(&cpufreq_gov_conservative)
372#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_INTERACTIVE)
373extern struct cpufreq_governor cpufreq_gov_interactive;
374#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_interactive)
375#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_SMARTASS2)
376extern struct cpufreq_governor cpufreq_gov_smartass2;
377#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_smartass2)
378#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_MSM7K)
379extern struct cpufreq_governor cpufreq_gov_msm7k;
380#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_msm7k)
381#endif
382
383
384/*********************************************************************
385 *                     FREQUENCY TABLE HELPERS                       *
386 *********************************************************************/
387
388#define CPUFREQ_ENTRY_INVALID ~0
389#define CPUFREQ_TABLE_END     ~1
390
391struct cpufreq_frequency_table {
392	unsigned int	index;     /* any */
393	unsigned int	frequency; /* kHz - doesn't need to be in ascending
394				    * order */
395};
396
397int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
398				    struct cpufreq_frequency_table *table);
399
400int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
401				   struct cpufreq_frequency_table *table);
402
403int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
404				   struct cpufreq_frequency_table *table,
405				   unsigned int target_freq,
406				   unsigned int relation,
407				   unsigned int *index);
408
409/* the following 3 funtions are for cpufreq core use only */
410struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
411struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
412void   cpufreq_cpu_put (struct cpufreq_policy *data);
413
414/* the following are really really optional */
415extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
416
417void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 
418				      unsigned int cpu);
419
420void cpufreq_frequency_table_put_attr(unsigned int cpu);
421
422
423/*********************************************************************
424 *                     UNIFIED DEBUG HELPERS                         *
425 *********************************************************************/
426
427#define CPUFREQ_DEBUG_CORE	1
428#define CPUFREQ_DEBUG_DRIVER	2
429#define CPUFREQ_DEBUG_GOVERNOR	4
430
431#ifdef CONFIG_CPU_FREQ_DEBUG
432
433extern void cpufreq_debug_printk(unsigned int type, const char *prefix, 
434				 const char *fmt, ...);
435
436#else
437
438#define cpufreq_debug_printk(msg...) do { } while(0)
439
440#endif /* CONFIG_CPU_FREQ_DEBUG */
441
442#endif /* _LINUX_CPUFREQ_H */