blob: ec4112d257bca140886bdadea4de5a8ef468c080 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Viresh Kumarbb176f72013-06-19 14:19:33 +05302 * linux/include/linux/cpufreq.h
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Viresh Kumarbb176f72013-06-19 14:19:33 +05304 * Copyright (C) 2001 Russell King
5 * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
Thiago Farina335dc332011-04-28 20:42:53 -03006 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * 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
Viresh Kumar652ed952014-01-09 20:38:43 +053014#include <linux/clk.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/cpumask.h>
Viresh Kumar5ff0a262013-08-06 22:53:03 +053016#include <linux/completion.h>
17#include <linux/kobject.h>
18#include <linux/notifier.h>
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +053019#include <linux/spinlock.h>
Viresh Kumar5ff0a262013-08-06 22:53:03 +053020#include <linux/sysfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Linus Torvalds1da177e2005-04-16 15:20:36 -070022/*********************************************************************
Viresh Kumar74aca952013-08-06 22:53:04 +053023 * CPUFREQ INTERFACE *
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 *********************************************************************/
Viresh Kumar74aca952013-08-06 22:53:04 +053025/*
26 * Frequency values here are CPU kHz
27 *
Dave Jonesb53cc6e2005-05-31 19:03:47 -070028 * Maximum transition latency is in nanoseconds - if it's unknown,
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 * CPUFREQ_ETERNAL shall be used.
30 */
31
Viresh Kumar74aca952013-08-06 22:53:04 +053032#define CPUFREQ_ETERNAL (-1)
33#define CPUFREQ_NAME_LEN 16
34/* Print length for names. Extra 1 space for accomodating '\n' in prints */
35#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037struct cpufreq_governor;
38
Viresh Kumar74aca952013-08-06 22:53:04 +053039struct cpufreq_freqs {
40 unsigned int cpu; /* cpu nr */
41 unsigned int old;
42 unsigned int new;
43 u8 flags; /* flags of cpufreq_driver, see below. */
44};
Thomas Renninger8aa84ad2009-07-24 15:25:05 +020045
Linus Torvalds1da177e2005-04-16 15:20:36 -070046struct cpufreq_cpuinfo {
47 unsigned int max_freq;
48 unsigned int min_freq;
Thiago Farina335dc332011-04-28 20:42:53 -030049
50 /* in 10^(-9) s = nanoseconds */
51 unsigned int transition_latency;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052};
53
54struct cpufreq_real_policy {
55 unsigned int min; /* in kHz */
56 unsigned int max; /* in kHz */
Thiago Farina335dc332011-04-28 20:42:53 -030057 unsigned int policy; /* see above */
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 struct cpufreq_governor *governor; /* see below */
59};
60
61struct cpufreq_policy {
Viresh Kumar951fc5f2013-01-31 02:03:53 +000062 /* CPUs sharing clock, require sw coordination */
63 cpumask_var_t cpus; /* Online CPUs only */
64 cpumask_var_t related_cpus; /* Online + Offline CPUs */
65
Viresh Kumar62b36cc2013-02-01 06:40:02 +000066 unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs
Venkatesh Pallipadi3b2d9942005-12-14 15:05:00 -050067 should set cpufreq */
Viresh Kumarb8eed8a2013-01-14 13:23:03 +000068 unsigned int cpu; /* cpu nr of CPU managing this policy */
69 unsigned int last_cpu; /* cpu nr of previous CPU that managed
70 * this policy */
Viresh Kumar652ed952014-01-09 20:38:43 +053071 struct clk *clk;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 struct cpufreq_cpuinfo cpuinfo;/* see above */
73
74 unsigned int min; /* in kHz */
75 unsigned int max; /* in kHz */
76 unsigned int cur; /* in kHz, only needed if cpufreq
77 * governors are used */
Viresh Kumar1c03a2d2014-06-02 22:49:28 +053078 unsigned int restore_freq; /* = policy->cur before transition */
Viresh Kumare28867e2014-03-04 11:00:27 +080079 unsigned int suspend_freq; /* freq to set during suspend */
80
Thiago Farina335dc332011-04-28 20:42:53 -030081 unsigned int policy; /* see above */
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 struct cpufreq_governor *governor; /* see below */
Viresh Kumar7bd353a2013-03-27 15:58:57 +000083 void *governor_data;
Xiaoguang Chen95731eb2013-06-19 15:00:07 +080084 bool governor_enabled; /* governor start/stop flag */
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 struct work_struct update; /* if update_policy() needs to be
87 * called, but you're in IRQ context */
88
89 struct cpufreq_real_policy user_policy;
Viresh Kumare0b31652014-03-10 14:53:33 +053090 struct cpufreq_frequency_table *freq_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Lukasz Majewskic88a1f82013-08-06 22:53:08 +053092 struct list_head policy_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 struct kobject kobj;
94 struct completion kobj_unregister;
viresh kumarad7722d2013-10-18 19:10:15 +053095
96 /*
97 * The rules for this semaphore:
98 * - Any routine that wants to read from the policy structure will
99 * do a down_read on this semaphore.
100 * - Any routine that will write to the policy structure and/or may take away
101 * the policy altogether (eg. CPU hotplug), will hold this lock in write
102 * mode before doing so.
103 *
104 * Additional rules:
105 * - Lock should not be held across
106 * __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
107 */
108 struct rw_semaphore rwsem;
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +0530109
110 /* Synchronization for frequency transitions */
111 bool transition_ongoing; /* Tracks transition status */
112 spinlock_t transition_lock;
113 wait_queue_head_t transition_wait;
Srivatsa S. Bhatca654dc2014-05-05 12:52:39 +0530114 struct task_struct *transition_task; /* Task which is doing the transition */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115};
116
Viresh Kumar62b36cc2013-02-01 06:40:02 +0000117/* Only for ACPI */
Venkatesh Pallipadi46f18e32006-06-26 00:34:43 -0400118#define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
119#define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */
120#define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */
121#define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
Daniel Vetterc75b5052013-10-08 10:56:11 +0200123#ifdef CONFIG_CPU_FREQ
Viresh Kumar74aca952013-08-06 22:53:04 +0530124struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
Viresh Kumar3a3e9e02013-08-06 22:53:05 +0530125void cpufreq_cpu_put(struct cpufreq_policy *policy);
Daniel Vetterc75b5052013-10-08 10:56:11 +0200126#else
127static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
128{
129 return NULL;
130}
131static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { }
132#endif
Viresh Kumar74aca952013-08-06 22:53:04 +0530133
Fabio Baltieri2624f902013-01-31 09:44:40 +0000134static inline bool policy_is_shared(struct cpufreq_policy *policy)
135{
136 return cpumask_weight(policy->cpus) > 1;
137}
138
Viresh Kumar74aca952013-08-06 22:53:04 +0530139/* /sys/devices/system/cpu/cpufreq: entry point for global variables */
140extern struct kobject *cpufreq_global_kobject;
141int cpufreq_get_global_kobject(void);
142void cpufreq_put_global_kobject(void);
143int cpufreq_sysfs_create_file(const struct attribute *attr);
144void cpufreq_sysfs_remove_file(const struct attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Viresh Kumar74aca952013-08-06 22:53:04 +0530146#ifdef CONFIG_CPU_FREQ
147unsigned int cpufreq_get(unsigned int cpu);
148unsigned int cpufreq_quick_get(unsigned int cpu);
149unsigned int cpufreq_quick_get_max(unsigned int cpu);
150void disable_cpufreq(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Viresh Kumar74aca952013-08-06 22:53:04 +0530152u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
153int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
154int cpufreq_update_policy(unsigned int cpu);
155bool have_governor_per_policy(void);
156struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
157#else
158static inline unsigned int cpufreq_get(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
Viresh Kumar74aca952013-08-06 22:53:04 +0530160 return 0;
161}
162static inline unsigned int cpufreq_quick_get(unsigned int cpu)
163{
164 return 0;
165}
166static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
167{
168 return 0;
169}
170static inline void disable_cpufreq(void) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/*********************************************************************
174 * CPUFREQ DRIVER INTERFACE *
175 *********************************************************************/
176
177#define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */
178#define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */
179
Viresh Kumar74aca952013-08-06 22:53:04 +0530180struct freq_attr {
181 struct attribute attr;
182 ssize_t (*show)(struct cpufreq_policy *, char *);
183 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
184};
185
186#define cpufreq_freq_attr_ro(_name) \
187static struct freq_attr _name = \
188__ATTR(_name, 0444, show_##_name, NULL)
189
190#define cpufreq_freq_attr_ro_perm(_name, _perm) \
191static struct freq_attr _name = \
192__ATTR(_name, _perm, show_##_name, NULL)
193
194#define cpufreq_freq_attr_rw(_name) \
195static struct freq_attr _name = \
196__ATTR(_name, 0644, show_##_name, store_##_name)
197
198struct global_attr {
199 struct attribute attr;
200 ssize_t (*show)(struct kobject *kobj,
201 struct attribute *attr, char *buf);
202 ssize_t (*store)(struct kobject *a, struct attribute *b,
203 const char *c, size_t count);
204};
205
206#define define_one_global_ro(_name) \
207static struct global_attr _name = \
208__ATTR(_name, 0444, show_##_name, NULL)
209
210#define define_one_global_rw(_name) \
211static struct global_attr _name = \
212__ATTR(_name, 0644, show_##_name, store_##_name)
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215struct cpufreq_driver {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 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);
Viresh Kumar1c03a2d2014-06-02 22:49:28 +0530225
226 /*
227 * On failure, should always restore frequency to policy->restore_freq
228 * (i.e. old freq).
229 */
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530230 int (*target) (struct cpufreq_policy *policy, /* Deprecated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 unsigned int target_freq,
232 unsigned int relation);
Viresh Kumar9c0ebcf2013-10-25 19:45:48 +0530233 int (*target_index) (struct cpufreq_policy *policy,
234 unsigned int index);
Viresh Kumar1c03a2d2014-06-02 22:49:28 +0530235 /*
236 * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
237 * unset.
238 *
239 * get_intermediate should return a stable intermediate frequency
240 * platform wants to switch to and target_intermediate() should set CPU
241 * to to that frequency, before jumping to the frequency corresponding
242 * to 'index'. Core will take care of sending notifications and driver
243 * doesn't have to handle them in target_intermediate() or
244 * target_index().
245 *
246 * Drivers can return '0' from get_intermediate() in case they don't
247 * wish to switch to intermediate frequency for some target frequency.
248 * In that case core will directly call ->target_index().
249 */
250 unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
251 unsigned int index);
252 int (*target_intermediate)(struct cpufreq_policy *policy,
253 unsigned int index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
255 /* should be defined, if possible */
256 unsigned int (*get) (unsigned int cpu);
257
258 /* optional */
Thomas Renningere2f74f32009-11-19 12:31:01 +0100259 int (*bios_limit) (int cpu, unsigned int *limit);
venkatesh.pallipadi@intel.combf0b90e2008-08-04 11:59:07 -0700260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 int (*exit) (struct cpufreq_policy *policy);
Dirk Brandewie367dc4a2014-03-19 08:45:53 -0700262 void (*stop_cpu) (struct cpufreq_policy *policy);
Rafael J. Wysocki7ca64e22011-03-10 21:13:05 +0100263 int (*suspend) (struct cpufreq_policy *policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 int (*resume) (struct cpufreq_policy *policy);
265 struct freq_attr **attr;
Lukasz Majewski6f19efc2013-12-20 15:24:49 +0100266
267 /* platform specific boost support code */
268 bool boost_supported;
269 bool boost_enabled;
270 int (*set_boost) (int state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271};
272
273/* flags */
Viresh Kumar6461f012013-10-02 14:13:17 +0530274#define CPUFREQ_STICKY (1 << 0) /* driver isn't removed even if
275 all ->init() calls failed */
276#define CPUFREQ_CONST_LOOPS (1 << 1) /* loops_per_jiffy or other
277 kernel "constants" aren't
278 affected by frequency
279 transitions */
280#define CPUFREQ_PM_NO_WARN (1 << 2) /* don't warn on suspend/resume
281 speed mismatches */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Viresh Kumar0b981e72013-10-02 14:13:18 +0530283/*
284 * This should be set by platforms having multiple clock-domains, i.e.
285 * supporting multiple policies. With this sysfs directories of governor would
286 * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same
287 * governor with different tunables for different clusters.
288 */
289#define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3)
290
Viresh Kumar7dbf6942013-10-29 18:56:06 +0530291/*
292 * Driver will do POSTCHANGE notifications from outside of their ->target()
293 * routine and so must set cpufreq_driver->flags with this flag, so that core
294 * can handle them specially.
295 */
296#define CPUFREQ_ASYNC_NOTIFICATION (1 << 4)
297
Viresh Kumarae6b4272013-12-03 11:20:45 +0530298/*
299 * Set by drivers which want cpufreq core to check if CPU is running at a
300 * frequency present in freq-table exposed by the driver. For these drivers if
301 * CPU is found running at an out of table freq, we will try to set it to a freq
302 * from the table. And if that fails, we will stop further boot process by
303 * issuing a BUG_ON().
304 */
305#define CPUFREQ_NEED_INITIAL_FREQ_CHECK (1 << 5)
306
Linus Torvalds221dee22007-02-26 14:55:48 -0800307int cpufreq_register_driver(struct cpufreq_driver *driver_data);
308int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309
Viresh Kumar74aca952013-08-06 22:53:04 +0530310const char *cpufreq_get_current_driver(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
Viresh Kumarbb176f72013-06-19 14:19:33 +0530312static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
313 unsigned int min, unsigned int max)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
315 if (policy->min < min)
316 policy->min = min;
317 if (policy->max < min)
318 policy->max = min;
319 if (policy->min > max)
320 policy->min = max;
321 if (policy->max > max)
322 policy->max = max;
323 if (policy->min > policy->max)
324 policy->min = policy->max;
325 return;
326}
327
Viresh Kumarbe49e342013-10-02 14:13:19 +0530328static inline void
329cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
330{
331 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
332 policy->cpuinfo.max_freq);
333}
334
Viresh Kumar2f0aea92014-03-04 11:00:26 +0800335#ifdef CONFIG_CPU_FREQ
336void cpufreq_suspend(void);
337void cpufreq_resume(void);
Viresh Kumare28867e2014-03-04 11:00:27 +0800338int cpufreq_generic_suspend(struct cpufreq_policy *policy);
Viresh Kumar2f0aea92014-03-04 11:00:26 +0800339#else
340static inline void cpufreq_suspend(void) {}
341static inline void cpufreq_resume(void) {}
342#endif
343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344/*********************************************************************
Viresh Kumar74aca952013-08-06 22:53:04 +0530345 * CPUFREQ NOTIFIER INTERFACE *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 *********************************************************************/
347
Viresh Kumar74aca952013-08-06 22:53:04 +0530348#define CPUFREQ_TRANSITION_NOTIFIER (0)
349#define CPUFREQ_POLICY_NOTIFIER (1)
350
351/* Transition notifiers */
352#define CPUFREQ_PRECHANGE (0)
353#define CPUFREQ_POSTCHANGE (1)
Viresh Kumar74aca952013-08-06 22:53:04 +0530354
355/* Policy Notifiers */
356#define CPUFREQ_ADJUST (0)
357#define CPUFREQ_INCOMPATIBLE (1)
358#define CPUFREQ_NOTIFY (2)
359#define CPUFREQ_START (3)
360#define CPUFREQ_UPDATE_POLICY_CPU (4)
Viresh Kumarfcd7af92014-01-07 07:10:10 +0530361#define CPUFREQ_CREATE_POLICY (5)
362#define CPUFREQ_REMOVE_POLICY (6)
Viresh Kumar74aca952013-08-06 22:53:04 +0530363
364#ifdef CONFIG_CPU_FREQ
365int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
366int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
367
Srivatsa S. Bhat12478cf2014-03-24 13:35:44 +0530368void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
369 struct cpufreq_freqs *freqs);
370void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
371 struct cpufreq_freqs *freqs, int transition_failed);
Viresh Kumar74aca952013-08-06 22:53:04 +0530372
373#else /* CONFIG_CPU_FREQ */
374static inline int cpufreq_register_notifier(struct notifier_block *nb,
375 unsigned int list)
376{
377 return 0;
378}
379static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
380 unsigned int list)
381{
382 return 0;
383}
384#endif /* !CONFIG_CPU_FREQ */
385
386/**
387 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch
388 * safe)
389 * @old: old value
390 * @div: divisor
391 * @mult: multiplier
392 *
393 *
394 * new = old * mult / div
395 */
396static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
397 u_int mult)
398{
399#if BITS_PER_LONG == 32
400 u64 result = ((u64) old) * ((u64) mult);
401 do_div(result, div);
402 return (unsigned long) result;
403
404#elif BITS_PER_LONG == 64
405 unsigned long result = old * ((u64) mult);
406 result /= div;
407 return result;
408#endif
409}
410
411/*********************************************************************
412 * CPUFREQ GOVERNORS *
413 *********************************************************************/
414
415/*
416 * If (cpufreq_driver->target) exists, the ->governor decides what frequency
417 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these
418 * two generic policies are available:
419 */
420#define CPUFREQ_POLICY_POWERSAVE (1)
421#define CPUFREQ_POLICY_PERFORMANCE (2)
422
423/* Governor Events */
424#define CPUFREQ_GOV_START 1
425#define CPUFREQ_GOV_STOP 2
426#define CPUFREQ_GOV_LIMITS 3
427#define CPUFREQ_GOV_POLICY_INIT 4
428#define CPUFREQ_GOV_POLICY_EXIT 5
429
430struct cpufreq_governor {
431 char name[CPUFREQ_NAME_LEN];
432 int initialized;
433 int (*governor) (struct cpufreq_policy *policy,
434 unsigned int event);
435 ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
436 char *buf);
437 int (*store_setspeed) (struct cpufreq_policy *policy,
438 unsigned int freq);
439 unsigned int max_transition_latency; /* HW must be able to switch to
440 next freq faster than this value in nano secs or we
441 will fallback to performance governor */
442 struct list_head governor_list;
443 struct module *owner;
444};
445
446/* Pass a target to the cpufreq driver */
447int cpufreq_driver_target(struct cpufreq_policy *policy,
448 unsigned int target_freq,
449 unsigned int relation);
450int __cpufreq_driver_target(struct cpufreq_policy *policy,
451 unsigned int target_freq,
452 unsigned int relation);
453int cpufreq_register_governor(struct cpufreq_governor *governor);
454void cpufreq_unregister_governor(struct cpufreq_governor *governor);
455
456/* CPUFREQ DEFAULT GOVERNOR */
Thomas Renninger1c256242007-10-02 13:28:12 -0700457/*
Viresh Kumarbb176f72013-06-19 14:19:33 +0530458 * Performance governor is fallback governor if any other gov failed to auto
459 * load due latency restrictions
460 */
Thomas Renninger6afde102007-10-02 13:28:13 -0700461#ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462extern struct cpufreq_governor cpufreq_gov_performance;
Thomas Renninger6afde102007-10-02 13:28:13 -0700463#endif
Thomas Renninger1c256242007-10-02 13:28:12 -0700464#ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE
465#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance)
Alessandro Guido30d221d2008-04-18 13:31:13 -0700466#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE)
467extern struct cpufreq_governor cpufreq_gov_powersave;
468#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE)
470extern struct cpufreq_governor cpufreq_gov_userspace;
Thomas Renninger1c256242007-10-02 13:28:12 -0700471#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace)
472#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND)
473extern struct cpufreq_governor cpufreq_gov_ondemand;
474#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand)
475#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
476extern struct cpufreq_governor cpufreq_gov_conservative;
477#define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478#endif
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480/*********************************************************************
481 * FREQUENCY TABLE HELPERS *
482 *********************************************************************/
483
Viresh Kumar7f4b0462014-03-28 19:11:47 +0530484/* Special Values of .frequency field */
485#define CPUFREQ_ENTRY_INVALID ~0
486#define CPUFREQ_TABLE_END ~1
487/* Special Values of .flags field */
488#define CPUFREQ_BOOST_FREQ (1 << 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490struct cpufreq_frequency_table {
Viresh Kumar7f4b0462014-03-28 19:11:47 +0530491 unsigned int flags;
Viresh Kumar50701582013-03-30 16:25:15 +0530492 unsigned int driver_data; /* driver specific data, not used by core */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 unsigned int frequency; /* kHz - doesn't need to be in ascending
494 * order */
495};
496
Nishanth Menona0dd7b72014-05-05 08:33:50 -0500497#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
498int dev_pm_opp_init_cpufreq_table(struct device *dev,
499 struct cpufreq_frequency_table **table);
500void dev_pm_opp_free_cpufreq_table(struct device *dev,
501 struct cpufreq_frequency_table **table);
502#else
503static inline int dev_pm_opp_init_cpufreq_table(struct device *dev,
504 struct cpufreq_frequency_table
505 **table)
506{
507 return -EINVAL;
508}
509
510static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
511 struct cpufreq_frequency_table
512 **table)
513{
514}
515#endif
516
Stratos Karafotis5eeaf1f2014-05-07 19:33:33 +0300517static inline bool cpufreq_next_valid(struct cpufreq_frequency_table **pos)
518{
519 while ((*pos)->frequency != CPUFREQ_TABLE_END)
520 if ((*pos)->frequency != CPUFREQ_ENTRY_INVALID)
521 return true;
522 else
523 (*pos)++;
524 return false;
525}
Stratos Karafotis27e289d2014-04-25 23:15:23 +0300526
527/*
528 * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table
529 * @pos: the cpufreq_frequency_table * to use as a loop cursor.
530 * @table: the cpufreq_frequency_table * to iterate over.
531 */
532
533#define cpufreq_for_each_entry(pos, table) \
534 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
535
536/*
537 * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table
538 * excluding CPUFREQ_ENTRY_INVALID frequencies.
539 * @pos: the cpufreq_frequency_table * to use as a loop cursor.
540 * @table: the cpufreq_frequency_table * to iterate over.
541 */
542
543#define cpufreq_for_each_valid_entry(pos, table) \
544 for (pos = table; cpufreq_next_valid(&pos); pos++)
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
547 struct cpufreq_frequency_table *table);
548
549int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
550 struct cpufreq_frequency_table *table);
Viresh Kumar18434512013-10-03 20:27:55 +0530551int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
553int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
554 struct cpufreq_frequency_table *table,
555 unsigned int target_freq,
556 unsigned int relation,
557 unsigned int *index);
Viresh Kumard3916692013-12-03 11:20:46 +0530558int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
559 unsigned int freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
Viresh Kumar74aca952013-08-06 22:53:04 +0530561ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
562
Lukasz Majewski6f19efc2013-12-20 15:24:49 +0100563#ifdef CONFIG_CPU_FREQ
564int cpufreq_boost_trigger_state(int state);
565int cpufreq_boost_supported(void);
566int cpufreq_boost_enabled(void);
567#else
568static inline int cpufreq_boost_trigger_state(int state)
569{
570 return 0;
571}
572static inline int cpufreq_boost_supported(void)
573{
574 return 0;
575}
576static inline int cpufreq_boost_enabled(void)
577{
578 return 0;
579}
580#endif
Viresh Kumar74aca952013-08-06 22:53:04 +0530581/* the following funtion is for cpufreq core use only */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584/* the following are really really optional */
585extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
Viresh Kumar18434512013-10-03 20:27:55 +0530586extern struct freq_attr *cpufreq_generic_attr[];
Viresh Kumar27047a62013-09-16 18:56:03 +0530587int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
588 struct cpufreq_frequency_table *table);
Lan Tianyuf4fd3792013-06-27 15:08:54 +0800589
Viresh Kumar652ed952014-01-09 20:38:43 +0530590unsigned int cpufreq_generic_get(unsigned int cpu);
Viresh Kumar70e9e772013-10-03 20:29:07 +0530591int cpufreq_generic_init(struct cpufreq_policy *policy,
592 struct cpufreq_frequency_table *table,
593 unsigned int transition_latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594#endif /* _LINUX_CPUFREQ_H */