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
};
43 /* Hotplug Sampling types */
44 enum {HP_NORMAL_SAMPLE
, HP_SUB_SAMPLE
};
47 * Macro for creating governors sysfs routines
49 * - gov_sys: One governor instance per whole system
50 * - gov_pol: One governor instance per policy
53 /* Create attributes */
54 #define gov_sys_attr_ro(_name) \
55 static struct global_attr _name##_gov_sys = \
56 __ATTR(_name, 0444, show_##_name##_gov_sys, NULL)
58 #define gov_sys_attr_rw(_name) \
59 static struct global_attr _name##_gov_sys = \
60 __ATTR(_name, 0644, show_##_name##_gov_sys, store_##_name##_gov_sys)
62 #define gov_pol_attr_ro(_name) \
63 static struct freq_attr _name##_gov_pol = \
64 __ATTR(_name, 0444, show_##_name##_gov_pol, NULL)
66 #define gov_pol_attr_rw(_name) \
67 static struct freq_attr _name##_gov_pol = \
68 __ATTR(_name, 0644, show_##_name##_gov_pol, store_##_name##_gov_pol)
70 #define gov_sys_pol_attr_rw(_name) \
71 gov_sys_attr_rw(_name); \
72 gov_pol_attr_rw(_name)
74 #define gov_sys_pol_attr_ro(_name) \
75 gov_sys_attr_ro(_name); \
76 gov_pol_attr_ro(_name)
78 /* Create show/store routines */
79 #define show_one(_gov, file_name) \
80 static ssize_t show_##file_name##_gov_sys \
81 (struct kobject *kobj, struct attribute *attr, char *buf) \
83 struct _gov##_dbs_tuners *tuners = _gov##_dbs_cdata.gdbs_data->tuners; \
84 return sprintf(buf, "%u\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
133 * hp_*: Hotplug governor
136 /* Per cpu structures */
137 struct cpu_dbs_common_info
{
142 struct cpufreq_policy
*cur_policy
;
143 struct delayed_work work
;
145 * percpu mutex that serializes governor limit change with gov_dbs_timer
146 * invocation. We do not want gov_dbs_timer to run when user is changing
147 * the governor or limits.
149 struct mutex timer_mutex
;
153 struct od_cpu_dbs_info_s
{
154 struct cpu_dbs_common_info cdbs
;
155 struct cpufreq_frequency_table
*freq_table
;
156 unsigned int freq_lo
;
157 unsigned int freq_lo_jiffies
;
158 unsigned int freq_hi_jiffies
;
159 unsigned int rate_mult
;
160 unsigned int sample_type
:1;
163 struct cs_cpu_dbs_info_s
{
164 struct cpu_dbs_common_info cdbs
;
165 unsigned int down_skip
;
166 unsigned int requested_freq
;
167 unsigned int enable
:1;
170 struct hp_cpu_dbs_info_s
{
171 struct cpu_dbs_common_info cdbs
;
172 struct cpufreq_frequency_table
*freq_table
;
173 unsigned int freq_lo
;
174 unsigned int freq_lo_jiffies
;
175 unsigned int freq_hi_jiffies
;
176 unsigned int rate_mult
;
177 unsigned int sample_type
:1;
180 /* Per policy Governers sysfs tunables */
181 struct od_dbs_tuners
{
182 unsigned int ignore_nice_load
;
183 unsigned int sampling_rate
;
184 unsigned int sampling_down_factor
;
185 unsigned int up_threshold
;
186 unsigned int powersave_bias
;
187 unsigned int io_is_busy
;
190 struct cs_dbs_tuners
{
191 unsigned int ignore_nice_load
;
192 unsigned int sampling_rate
;
193 unsigned int sampling_down_factor
;
194 unsigned int up_threshold
;
195 unsigned int down_threshold
;
196 unsigned int freq_step
;
199 struct hp_dbs_tuners
{
200 unsigned int ignore_nice_load
;
201 unsigned int sampling_rate
;
202 unsigned int sampling_down_factor
;
203 unsigned int up_threshold
;
204 unsigned int adj_up_threshold
;
205 unsigned int powersave_bias
;
206 unsigned int io_is_busy
;
207 // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
208 unsigned int down_differential
;
209 unsigned int cpu_up_threshold
;
210 unsigned int cpu_down_differential
;
211 unsigned int cpu_up_avg_times
;
212 unsigned int cpu_down_avg_times
;
213 unsigned int cpu_num_limit
;
214 unsigned int cpu_num_base
;
215 unsigned int is_cpu_hotplug_disable
;
216 unsigned int cpu_input_boost_enable
;
217 unsigned int cpu_input_boost_num
;
218 unsigned int cpu_rush_boost_enable
;
219 unsigned int cpu_rush_boost_num
;
220 unsigned int cpu_rush_threshold
;
221 unsigned int cpu_rush_tlp_times
;
222 unsigned int cpu_rush_avg_times
;
223 // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
226 /* Common Governer data across policies */
228 struct common_dbs_data
{
229 /* Common across governors */
230 #define GOV_ONDEMAND 0
231 #define GOV_CONSERVATIVE 1
232 #define GOV_HOTPLUG 2
234 struct attribute_group
*attr_group_gov_sys
; /* one governor - system */
235 struct attribute_group
*attr_group_gov_pol
; /* one governor - policy */
237 /* Common data for platforms that don't set have_governor_per_policy */
238 struct dbs_data
*gdbs_data
;
240 struct cpu_dbs_common_info
*(*get_cpu_cdbs
)(int cpu
);
241 void *(*get_cpu_dbs_info_s
)(int cpu
);
242 void (*gov_dbs_timer
)(struct work_struct
*work
);
243 void (*gov_check_cpu
)(int cpu
, unsigned int load
);
244 int (*init
)(struct dbs_data
*dbs_data
);
245 void (*exit
)(struct dbs_data
*dbs_data
);
247 /* Governor specific ops, see below */
251 /* Governer Per policy data */
253 struct common_dbs_data
*cdata
;
254 unsigned int min_sampling_rate
;
258 /* dbs_mutex protects dbs_enable in governor start/stop */
262 /* Governor specific ops, will be passed to dbs_data->gov_ops */
264 void (*powersave_bias_init_cpu
)(int cpu
);
265 unsigned int (*powersave_bias_target
)(struct cpufreq_policy
*policy
,
266 unsigned int freq_next
, unsigned int relation
);
267 void (*freq_increase
)(struct cpufreq_policy
*p
, unsigned int freq
);
271 struct notifier_block
*notifier_block
;
275 void (*powersave_bias_init_cpu
)(int cpu
);
276 unsigned int (*powersave_bias_target
)(struct cpufreq_policy
*policy
,
277 unsigned int freq_next
, unsigned int relation
);
278 void (*freq_increase
)(struct cpufreq_policy
*p
, unsigned int freq
);
279 struct input_handler
*input_handler
; // <-XXX
282 static inline int delay_for_sampling_rate(unsigned int sampling_rate
)
284 int delay
= usecs_to_jiffies(sampling_rate
);
286 /* We want all CPUs to do sampling nearly on same jiffy */
287 if (num_online_cpus() > 1)
288 delay
-= jiffies
% delay
;
293 #define declare_show_sampling_rate_min(_gov) \
294 static ssize_t show_sampling_rate_min_gov_sys \
295 (struct kobject *kobj, struct attribute *attr, char *buf) \
297 struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data; \
298 return sprintf(buf, "%u\n", dbs_data->min_sampling_rate); \
301 static ssize_t show_sampling_rate_min_gov_pol \
302 (struct cpufreq_policy *policy, char *buf) \
304 struct dbs_data *dbs_data = policy->governor_data; \
305 return sprintf(buf, "%u\n", dbs_data->min_sampling_rate); \
308 void dbs_check_cpu(struct dbs_data
*dbs_data
, int cpu
);
309 bool need_load_eval(struct cpu_dbs_common_info
*cdbs
,
310 unsigned int sampling_rate
);
311 int cpufreq_governor_dbs(struct cpufreq_policy
*policy
,
312 struct common_dbs_data
*cdata
, unsigned int event
);
313 void gov_queue_work(struct dbs_data
*dbs_data
, struct cpufreq_policy
*policy
,
314 unsigned int delay
, bool all_cpus
);
315 void od_register_powersave_bias_handler(unsigned int (*f
)
316 (struct cpufreq_policy
*, unsigned int, unsigned int),
317 unsigned int powersave_bias
);
318 void od_unregister_powersave_bias_handler(void);
319 void hp_register_powersave_bias_handler(unsigned int (*f
)
320 (struct cpufreq_policy
*, unsigned int, unsigned int),
321 unsigned int powersave_bias
);
322 void hp_unregister_powersave_bias_handler(void);
323 #endif /* _CPUFREQ_GOVERNOR_H */