1
2
3
4
5
6
7
8
9
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/spinlock.h>
20#include <linux/sysfs.h>
21
22
23
24
25
26
27
28
29
30
31
32#define CPUFREQ_ETERNAL (-1)
33#define CPUFREQ_NAME_LEN 16
34
35#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
36
37struct cpufreq_governor;
38
39struct cpufreq_freqs {
40 unsigned int cpu;
41 unsigned int old;
42 unsigned int new;
43 u8 flags;
44};
45
46struct cpufreq_cpuinfo {
47 unsigned int max_freq;
48 unsigned int min_freq;
49
50
51 unsigned int transition_latency;
52};
53
54struct cpufreq_real_policy {
55 unsigned int min;
56 unsigned int max;
57 unsigned int policy;
58 struct cpufreq_governor *governor;
59};
60
61struct cpufreq_policy {
62
63 cpumask_var_t cpus;
64 cpumask_var_t related_cpus;
65
66 unsigned int shared_type;
67
68 unsigned int cpu;
69 struct clk *clk;
70 struct cpufreq_cpuinfo cpuinfo;
71
72 unsigned int min;
73 unsigned int max;
74 unsigned int cur;
75
76 unsigned int restore_freq;
77 unsigned int suspend_freq;
78
79 unsigned int policy;
80 struct cpufreq_governor *governor;
81 void *governor_data;
82 bool governor_enabled;
83
84 struct work_struct update;
85
86
87 struct cpufreq_real_policy user_policy;
88 struct cpufreq_frequency_table *freq_table;
89
90 struct list_head policy_list;
91 struct kobject kobj;
92 struct completion kobj_unregister;
93
94
95
96
97
98
99
100
101
102
103
104
105
106 struct rw_semaphore rwsem;
107
108
109 bool transition_ongoing;
110 spinlock_t transition_lock;
111 wait_queue_head_t transition_wait;
112 struct task_struct *transition_task;
113
114
115 struct cpufreq_stats *stats;
116
117
118 void *driver_data;
119};
120
121
122#define CPUFREQ_SHARED_TYPE_NONE (0)
123#define CPUFREQ_SHARED_TYPE_HW (1)
124#define CPUFREQ_SHARED_TYPE_ALL (2)
125#define CPUFREQ_SHARED_TYPE_ANY (3)
126
127#ifdef CONFIG_CPU_FREQ
128struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
129void cpufreq_cpu_put(struct cpufreq_policy *policy);
130#else
131static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
132{
133 return NULL;
134}
135static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
136#endif
137
138static inline bool policy_is_shared(struct cpufreq_policy *policy)
139{
140 return cpumask_weight(policy->cpus) > 1;
141}
142
143
144extern struct kobject *cpufreq_global_kobject;
145int cpufreq_get_global_kobject(void);
146void cpufreq_put_global_kobject(void);
147int cpufreq_sysfs_create_file(const struct attribute *attr);
148void cpufreq_sysfs_remove_file(const struct attribute *attr);
149
150#ifdef CONFIG_CPU_FREQ
151unsigned int cpufreq_get(unsigned int cpu);
152unsigned int cpufreq_quick_get(unsigned int cpu);
153unsigned int cpufreq_quick_get_max(unsigned int cpu);
154void disable_cpufreq(void);
155
156u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
157int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
158int cpufreq_update_policy(unsigned int cpu);
159bool have_governor_per_policy(void);
160struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
161#else
162static inline unsigned int cpufreq_get(unsigned int cpu)
163{
164 return 0;
165}
166static inline unsigned int cpufreq_quick_get(unsigned int cpu)
167{
168 return 0;
169}
170static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
171{
172 return 0;
173}
174static inline void disable_cpufreq(void) { }
175#endif
176
177
178
179
180
181#define CPUFREQ_RELATION_L 0
182#define CPUFREQ_RELATION_H 1
183#define CPUFREQ_RELATION_C 2
184
185struct freq_attr {
186 struct attribute attr;
187 ssize_t (*show)(struct cpufreq_policy *, char *);
188 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
189};
190
191#define cpufreq_freq_attr_ro(_name) \
192static struct freq_attr _name = \
193__ATTR(_name, 0444, show_##_name, NULL)
194
195#define cpufreq_freq_attr_ro_perm(_name, _perm) \
196static struct freq_attr _name = \
197__ATTR(_name, _perm, show_##_name, NULL)
198
199#define cpufreq_freq_attr_rw(_name) \
200static struct freq_attr _name = \
201__ATTR(_name, 0644, show_##_name, store_##_name)
202
203struct global_attr {
204 struct attribute attr;
205 ssize_t (*show)(struct kobject *kobj,
206 struct attribute *attr, char *buf);
207 ssize_t (*store)(struct kobject *a, struct attribute *b,
208 const char *c, size_t count);
209};
210
211#define define_one_global_ro(_name) \
212static struct global_attr _name = \
213__ATTR(_name, 0444, show_##_name, NULL)
214
215#define define_one_global_rw(_name) \
216static struct global_attr _name = \
217__ATTR(_name, 0644, show_##_name, store_##_name)
218
219
220struct cpufreq_driver {
221 char name[CPUFREQ_NAME_LEN];
222 u8 flags;
223 void *driver_data;
224
225
226 int (*init)(struct cpufreq_policy *policy);
227 int (*verify)(struct cpufreq_policy *policy);
228
229
230 int (*setpolicy)(struct cpufreq_policy *policy);
231
232
233
234
235
236 int (*target)(struct cpufreq_policy *policy,
237 unsigned int target_freq,
238 unsigned int relation);
239 int (*target_index)(struct cpufreq_policy *policy,
240 unsigned int index);
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256 unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
257 unsigned int index);
258 int (*target_intermediate)(struct cpufreq_policy *policy,
259 unsigned int index);
260
261
262 unsigned int (*get)(unsigned int cpu);
263
264
265 int (*bios_limit)(int cpu, unsigned int *limit);
266
267 int (*exit)(struct cpufreq_policy *policy);
268 void (*stop_cpu)(struct cpufreq_policy *policy);
269 int (*suspend)(struct cpufreq_policy *policy);
270 int (*resume)(struct cpufreq_policy *policy);
271
272
273 void (*ready)(struct cpufreq_policy *policy);
274
275 struct freq_attr **attr;
276
277
278 bool boost_supported;
279 bool boost_enabled;
280 int (*set_boost)(int state);
281};
282
283
284#define CPUFREQ_STICKY (1 << 0)
285
286#define CPUFREQ_CONST_LOOPS (1 << 1)
287
288
289
290#define CPUFREQ_PM_NO_WARN (1 << 2)
291
292
293
294
295
296
297
298
299#define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3)
300
301
302
303
304
305
306#define CPUFREQ_ASYNC_NOTIFICATION (1 << 4)
307
308
309
310
311
312
313
314
315#define CPUFREQ_NEED_INITIAL_FREQ_CHECK (1 << 5)
316
317int cpufreq_register_driver(struct cpufreq_driver *driver_data);
318int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
319
320const char *cpufreq_get_current_driver(void);
321void *cpufreq_get_driver_data(void);
322
323static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
324 unsigned int min, unsigned int max)
325{
326 if (policy->min < min)
327 policy->min = min;
328 if (policy->max < min)
329 policy->max = min;
330 if (policy->min > max)
331 policy->min = max;
332 if (policy->max > max)
333 policy->max = max;
334 if (policy->min > policy->max)
335 policy->min = policy->max;
336 return;
337}
338
339static inline void
340cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
341{
342 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
343 policy->cpuinfo.max_freq);
344}
345
346#ifdef CONFIG_CPU_FREQ
347void cpufreq_suspend(void);
348void cpufreq_resume(void);
349int cpufreq_generic_suspend(struct cpufreq_policy *policy);
350#else
351static inline void cpufreq_suspend(void) {}
352static inline void cpufreq_resume(void) {}
353#endif
354
355
356
357
358
359#define CPUFREQ_TRANSITION_NOTIFIER (0)
360#define CPUFREQ_POLICY_NOTIFIER (1)
361
362
363#define CPUFREQ_PRECHANGE (0)
364#define CPUFREQ_POSTCHANGE (1)
365
366
367#define CPUFREQ_ADJUST (0)
368#define CPUFREQ_INCOMPATIBLE (1)
369#define CPUFREQ_NOTIFY (2)
370#define CPUFREQ_START (3)
371#define CPUFREQ_CREATE_POLICY (4)
372#define CPUFREQ_REMOVE_POLICY (5)
373
374#ifdef CONFIG_CPU_FREQ
375int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
376int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
377
378void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
379 struct cpufreq_freqs *freqs);
380void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
381 struct cpufreq_freqs *freqs, int transition_failed);
382
383#else
384static inline int cpufreq_register_notifier(struct notifier_block *nb,
385 unsigned int list)
386{
387 return 0;
388}
389static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
390 unsigned int list)
391{
392 return 0;
393}
394#endif
395
396
397
398
399
400
401
402
403
404
405
406static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
407 u_int mult)
408{
409#if BITS_PER_LONG == 32
410 u64 result = ((u64) old) * ((u64) mult);
411 do_div(result, div);
412 return (unsigned long) result;
413
414#elif BITS_PER_LONG == 64
415 unsigned long result = old * ((u64) mult);
416 result /= div;
417 return result;
418#endif
419}
420
421
422
423
424
425
426
427
428
429
430#define CPUFREQ_POLICY_POWERSAVE (1)
431#define CPUFREQ_POLICY_PERFORMANCE (2)
432
433
434#define CPUFREQ_GOV_START 1
435#define CPUFREQ_GOV_STOP 2
436#define CPUFREQ_GOV_LIMITS 3
437#define CPUFREQ_GOV_POLICY_INIT 4
438#define CPUFREQ_GOV_POLICY_EXIT 5
439
440struct cpufreq_governor {
441 char name[CPUFREQ_NAME_LEN];
442 int initialized;
443 int (*governor) (struct cpufreq_policy *policy,
444 unsigned int event);
445 ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
446 char *buf);
447 int (*store_setspeed) (struct cpufreq_policy *policy,
448 unsigned int freq);
449 unsigned int max_transition_latency;
450
451
452 struct list_head governor_list;
453 struct module *owner;
454};
455
456
457int cpufreq_driver_target(struct cpufreq_policy *policy,
458 unsigned int target_freq,
459 unsigned int relation);
460int __cpufreq_driver_target(struct cpufreq_policy *policy,
461 unsigned int target_freq,
462 unsigned int relation);
463int cpufreq_register_governor(struct cpufreq_governor *governor);
464void cpufreq_unregister_governor(struct cpufreq_governor *governor);
465
466
467
468
469
470
471#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
472extern struct cpufreq_governor cpufreq_gov_performance;
473#endif
474#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
475#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance)
476#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
477extern struct cpufreq_governor cpufreq_gov_powersave;
478#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave)
479#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
480extern struct cpufreq_governor cpufreq_gov_userspace;
481#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace)
482#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
483extern struct cpufreq_governor cpufreq_gov_ondemand;
484#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand)
485#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
486extern struct cpufreq_governor cpufreq_gov_conservative;
487#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative)
488#endif
489
490
491
492
493
494
495#define CPUFREQ_ENTRY_INVALID ~0u
496#define CPUFREQ_TABLE_END ~1u
497
498#define CPUFREQ_BOOST_FREQ (1 << 0)
499
500struct cpufreq_frequency_table {
501 unsigned int flags;
502 unsigned int driver_data;
503 unsigned int frequency;
504
505};
506
507#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
508int dev_pm_opp_init_cpufreq_table(struct device *dev,
509 struct cpufreq_frequency_table **table);
510void dev_pm_opp_free_cpufreq_table(struct device *dev,
511 struct cpufreq_frequency_table **table);
512#else
513static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
514 struct cpufreq_frequency_table
515 **table)
516{
517 return -EINVAL;
518}
519
520static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
521 struct cpufreq_frequency_table
522 **table)
523{
524}
525#endif
526
527static inline bool cpufreq_next_valid(struct cpufreq_frequency_table **pos)
528{
529 while ((*pos)->frequency != CPUFREQ_TABLE_END)
530 if ((*pos)->frequency != CPUFREQ_ENTRY_INVALID)
531 return true;
532 else
533 (*pos)++;
534 return false;
535}
536
537
538
539
540
541
542
543#define cpufreq_for_each_entry(pos, table) \
544 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
545
546
547
548
549
550
551
552
553#define cpufreq_for_each_valid_entry(pos, table) \
554 for (pos = table; cpufreq_next_valid(&pos); pos++)
555
556int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
557 struct cpufreq_frequency_table *table);
558
559int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
560 struct cpufreq_frequency_table *table);
561int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
562
563int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
564 struct cpufreq_frequency_table *table,
565 unsigned int target_freq,
566 unsigned int relation,
567 unsigned int *index);
568int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
569 unsigned int freq);
570
571ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
572
573#ifdef CONFIG_CPU_FREQ
574int cpufreq_boost_trigger_state(int state);
575int cpufreq_boost_supported(void);
576int cpufreq_boost_enabled(void);
577#else
578static inline int cpufreq_boost_trigger_state(int state)
579{
580 return 0;
581}
582static inline int cpufreq_boost_supported(void)
583{
584 return 0;
585}
586static inline int cpufreq_boost_enabled(void)
587{
588 return 0;
589}
590#endif
591
592struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
593
594
595extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
596extern struct freq_attr *cpufreq_generic_attr[];
597int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
598 struct cpufreq_frequency_table *table);
599
600unsigned int cpufreq_generic_get(unsigned int cpu);
601int cpufreq_generic_init(struct cpufreq_policy *policy,
602 struct cpufreq_frequency_table *table,
603 unsigned int transition_latency);
604#endif
605