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