2 * drivers/cpufreq/cpufreq_governor.h
4 * Header file for CPUFreq governors common code
6 * Copyright (C) 2001 Russell King
7 * (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
8 * (C) 2003 Jun Nakajima <jun.nakajima@intel.com>
9 * (C) 2009 Alexander Clouter <alex@digriz.org.uk>
10 * (c) 2012 Viresh Kumar <viresh.kumar@linaro.org>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
17 #ifndef _CPUFREQ_GOVERNOR_H
18 #define _CPUFREQ_GOVERNOR_H
20 #include <linux/cpufreq.h>
21 #include <linux/kobject.h>
22 #include <linux/mutex.h>
23 #include <linux/workqueue.h>
24 #include <linux/sysfs.h>
27 * The polling frequency depends on the capability of the processor. Default
28 * polling frequency is 1000 times the transition latency of the processor. The
29 * governor will work on any processor with transition latency <= 10mS, using
30 * appropriate sampling rate.
32 * For CPUs with transition latency > 10mS (mostly drivers with CPUFREQ_ETERNAL)
33 * this governor will not work. All times here are in uS.
35 #define MIN_SAMPLING_RATE_RATIO (2)
36 #define LATENCY_MULTIPLIER (1000)
37 #define MIN_LATENCY_MULTIPLIER (20)
38 #define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000)
40 /* Ondemand Sampling types */
41 enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};
44 * Macro for creating governors sysfs routines
46 * - gov_sys: One governor instance per whole system
47 * - gov_pol: One governor instance per policy
50 /* Create attributes */
51 #define gov_sys_attr_ro(_name) \
52 static struct global_attr _name##_gov_sys = \
53 __ATTR(_name, 0444, show_##_name##_gov_sys, NULL)
55 #define gov_sys_attr_rw(_name) \
56 static struct global_attr _name##_gov_sys = \
57 __ATTR(_name, 0644, show_##_name##_gov_sys, store_##_name##_gov_sys)
59 #define gov_pol_attr_ro(_name) \
60 static struct freq_attr _name##_gov_pol = \
61 __ATTR(_name, 0444, show_##_name##_gov_pol, NULL)
63 #define gov_pol_attr_rw(_name) \
64 static struct freq_attr _name##_gov_pol = \
65 __ATTR(_name, 0644, show_##_name##_gov_pol, store_##_name##_gov_pol)
67 #define gov_sys_pol_attr_rw(_name) \
68 gov_sys_attr_rw(_name); \
69 gov_pol_attr_rw(_name)
71 #define gov_sys_pol_attr_ro(_name) \
72 gov_sys_attr_ro(_name); \
73 gov_pol_attr_ro(_name)
75 /* Create show/store routines */
76 #define show_one(_gov, file_name) \
77 static ssize_t show_##file_name##_gov_sys \
78 (struct kobject *kobj, struct attribute *attr, char *buf) \
80 struct _gov##_dbs_tuners *tuners = _gov##_dbs_cdata.gdbs_data->tuners; \
81 if(tuners->file_name > 0) \
82 return sprintf(buf, "%u\n", tuners->file_name); \
84 return sprintf(buf, "%d\n", tuners->file_name); \
87 static ssize_t show_##file_name##_gov_pol \
88 (struct cpufreq_policy *policy, char *buf) \
90 struct dbs_data *dbs_data = policy->governor_data; \
91 struct _gov##_dbs_tuners *tuners = dbs_data->tuners; \
92 return sprintf(buf, "%u\n", tuners->file_name); \
95 #define store_one(_gov, file_name) \
96 static ssize_t store_##file_name##_gov_sys \
97 (struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) \
99 struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data; \
100 return store_##file_name(dbs_data, buf, count); \
103 static ssize_t store_##file_name##_gov_pol \
104 (struct cpufreq_policy *policy, const char *buf, size_t count) \
106 struct dbs_data *dbs_data = policy->governor_data; \
107 return store_##file_name(dbs_data, buf, count); \
110 #define show_store_one(_gov, file_name) \
111 show_one(_gov, file_name); \
112 store_one(_gov, file_name)
114 /* create helper routines */
115 #define define_get_cpu_dbs_routines(_dbs_info) \
116 static struct cpu_dbs_common_info *get_cpu_cdbs(int cpu) \
118 return &per_cpu(_dbs_info, cpu).cdbs; \
121 static void *get_cpu_dbs_info_s(int cpu) \
123 return &per_cpu(_dbs_info, cpu); \
128 * dbs: used as a shortform for demand based switching It helps to keep variable
129 * names smaller, simpler
131 * od_*: On-demand governor
132 * cs_*: Conservative governor
135 /* Per cpu structures */
136 struct cpu_dbs_common_info {
141 struct cpufreq_policy *cur_policy;
142 struct delayed_work work;
144 * percpu mutex that serializes governor limit change with gov_dbs_timer
145 * invocation. We do not want gov_dbs_timer to run when user is changing
146 * the governor or limits.
148 struct mutex timer_mutex;
152 struct od_cpu_dbs_info_s {
153 struct cpu_dbs_common_info cdbs;
154 struct cpufreq_frequency_table *freq_table;
155 unsigned int freq_lo;
156 unsigned int freq_lo_jiffies;
157 unsigned int freq_hi_jiffies;
158 unsigned int rate_mult;
159 unsigned int sample_type:1;
162 struct cs_cpu_dbs_info_s {
163 struct cpu_dbs_common_info cdbs;
164 unsigned int down_skip;
165 unsigned int requested_freq;
166 unsigned int enable:1;
169 /* Per policy Governers sysfs tunables */
170 struct od_dbs_tuners {
171 unsigned int ignore_nice_load;
172 unsigned int sampling_rate;
173 unsigned int sampling_down_factor;
174 unsigned int up_threshold;
175 unsigned int powersave_bias;
176 unsigned int io_is_busy;
179 struct cs_dbs_tuners {
180 unsigned int ignore_nice_load;
181 unsigned int sampling_rate;
182 unsigned int sampling_down_factor;
183 unsigned int up_threshold;
184 unsigned int down_threshold;
185 unsigned int freq_step;
188 struct sd_dbs_tuners {
189 unsigned int ignore_nice;
190 unsigned int sampling_rate;
191 unsigned int sampling_down_factor;
192 unsigned int up_threshold;
193 unsigned int adj_up_threshold;
194 unsigned int powersave_bias;
195 unsigned int io_is_busy;
197 unsigned int cpu_hotplug_disable;
198 unsigned int is_suspend;
199 unsigned int cpu_score_up_threshold;
200 unsigned int load_critical;
201 unsigned int load_hi;
202 unsigned int load_mid;
203 unsigned int load_light;
204 unsigned int load_lo;
205 int load_critical_score;
208 int load_light_score;
210 unsigned int cpu_down_threshold;
211 unsigned int cpu_down_count;
212 unsigned int cpu_num_limit;
213 unsigned int cpu_up_mid_threshold;
214 unsigned int cpu_up_high_threshold;
215 unsigned int cpu_down_mid_threshold;
216 unsigned int cpu_down_high_threshold;
217 unsigned int window_size;
220 /* Common Governer data across policies */
222 struct common_dbs_data {
223 /* Common across governors */
224 #define GOV_ONDEMAND 0
225 #define GOV_CONSERVATIVE 1
227 struct attribute_group *attr_group_gov_sys; /* one governor - system */
228 struct attribute_group *attr_group_gov_pol; /* one governor - policy */
230 /* Common data for platforms that don't set have_governor_per_policy */
231 struct dbs_data *gdbs_data;
233 struct cpu_dbs_common_info *(*get_cpu_cdbs)(int cpu);
234 void *(*get_cpu_dbs_info_s)(int cpu);
235 void (*gov_dbs_timer)(struct work_struct *work);
236 void (*gov_check_cpu)(int cpu, unsigned int load);
237 int (*init)(struct dbs_data *dbs_data);
238 void (*exit)(struct dbs_data *dbs_data);
240 /* Governor specific ops, see below */
244 /* Governer Per policy data */
246 struct common_dbs_data *cdata;
247 unsigned int min_sampling_rate;
251 /* dbs_mutex protects dbs_enable in governor start/stop */
255 /* Governor specific ops, will be passed to dbs_data->gov_ops */
257 void (*powersave_bias_init_cpu)(int cpu);
258 unsigned int (*powersave_bias_target)(struct cpufreq_policy *policy,
259 unsigned int freq_next, unsigned int relation);
260 void (*freq_increase)(struct cpufreq_policy *p, unsigned int freq);
264 struct notifier_block *notifier_block;
267 static inline int delay_for_sampling_rate(unsigned int sampling_rate)
269 int delay = usecs_to_jiffies(sampling_rate);
271 /* We want all CPUs to do sampling nearly on same jiffy */
272 if (num_online_cpus() > 1)
273 delay -= jiffies % delay;
278 #define declare_show_sampling_rate_min(_gov) \
279 static ssize_t show_sampling_rate_min_gov_sys \
280 (struct kobject *kobj, struct attribute *attr, char *buf) \
282 struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data; \
283 return sprintf(buf, "%u\n", dbs_data->min_sampling_rate); \
286 static ssize_t show_sampling_rate_min_gov_pol \
287 (struct cpufreq_policy *policy, char *buf) \
289 struct dbs_data *dbs_data = policy->governor_data; \
290 return sprintf(buf, "%u\n", dbs_data->min_sampling_rate); \
293 void dbs_check_cpu(struct dbs_data *dbs_data, int cpu);
294 bool need_load_eval(struct cpu_dbs_common_info *cdbs,
295 unsigned int sampling_rate);
296 int cpufreq_governor_dbs(struct cpufreq_policy *policy,
297 struct common_dbs_data *cdata, unsigned int event);
298 void gov_queue_work(struct dbs_data *dbs_data, struct cpufreq_policy *policy,
299 unsigned int delay, bool all_cpus);
300 void od_register_powersave_bias_handler(unsigned int (*f)
301 (struct cpufreq_policy *, unsigned int, unsigned int),
302 unsigned int powersave_bias);
303 void od_unregister_powersave_bias_handler(void);
304 #endif /* _CPUFREQ_GOVERNOR_H */