Merge branch 'pm-cpufreq'

* pm-cpufreq: (94 commits) intel_pstate: Do not skip samples partially intel_pstate: Remove freq calculation from intel_pstate_calc_busy() intel_pstate: Move intel_pstate_calc_busy() into get_target_pstate_use_performance() intel_pstate: Optimize calculation for max/min_perf_adj intel_pstate: Remove extra conversions in pid calculation cpufreq: Move scheduler-related code to the sched directory Revert "cpufreq: postfix policy directory with the first CPU in related_cpus" cpufreq: Reduce cpufreq_update_util() overhead a bit cpufreq: Select IRQ_WORK if CPU_FREQ_GOV_COMMON is set cpufreq: Remove 'policy->governor_enabled' cpufreq: Rename __cpufreq_governor() to cpufreq_governor() cpufreq: Relocate handle_update() to kill its declaration cpufreq: governor: Drop unnecessary checks from show() and store() cpufreq: governor: Fix race in dbs_update_util_handler() cpufreq: governor: Make gov_set_update_util() static cpufreq: governor: Narrow down the dbs_data_mutex coverage cpufreq: governor: Make dbs_data_mutex static cpufreq: governor: Relocate definitions of tuners structures cpufreq: governor: Move per-CPU data to the common code cpufreq: governor: Make governor private data per-policy ...
author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 2016-03-14 09:22:03 -0400
committer: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 2016-03-14 09:22:03 -0400
commit: 4ed39004271280d2b5fc6929b2782c0e330f6895 (patch)
tree: d0f3bc36dd0598bf6d9d7f7321992111f349bfb3 /drivers/cpufreq/cpufreq_governor.h
parent: b5d5fad9bed079a4f182e4d282ca29380e8c08f2 (diff)
parent: 4fec7ad5f637159525265a45f66482cf8817b45f (diff)
1 files changed, 84 insertions, 177 deletions
diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h
index 91e767a058a7..61ff82fe0613 100644
--- a/drivers/cpufreq/cpufreq_governor.h
+++ b/drivers/cpufreq/cpufreq_governor.h
@@ -18,6 +18,7 @@
 #define _CPUFREQ_GOVERNOR_H
 #include <linux/atomic.h>
+#include <linux/irq_work.h>
 #include <linux/cpufreq.h>
 #include <linux/kernel_stat.h>
 #include <linux/module.h>
@@ -41,96 +42,68 @@
 enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};
 /*
- * Macro for creating governors sysfs routines
+ * Abbreviations:
- *
+ * dbs: used as a shortform for demand based switching It helps to keep variable
- * - gov_sys: One governor instance per whole system
+ *      names smaller, simpler
- * - gov_pol: One governor instance per policy
+ * cdbs: common dbs
+ * od_*: On-demand governor
+ * cs_*: Conservative governor
 */
-/* Create attributes */
+/* Governor demand based switching data (per-policy or global). */
-#define gov_sys_attr_ro(_name)                                          \
+struct dbs_data {
-static struct global_attr _name##_gov_sys =                             \
+        int usage_count;
-__ATTR(_name, 0444, show_##_name##_gov_sys, NULL)
+        void *tuners;
+        unsigned int min_sampling_rate;
-#define gov_sys_attr_rw(_name)                                          \
+        unsigned int ignore_nice_load;
-static struct global_attr _name##_gov_sys =                             \
+        unsigned int sampling_rate;
-__ATTR(_name, 0644, show_##_name##_gov_sys, store_##_name##_gov_sys)
+        unsigned int sampling_down_factor;
+        unsigned int up_threshold;
-#define gov_pol_attr_ro(_name)                                          \
+        unsigned int io_is_busy;
-static struct freq_attr _name##_gov_pol =                               \
-__ATTR(_name, 0444, show_##_name##_gov_pol, NULL)
-#define gov_pol_attr_rw(_name)                                          \
-static struct freq_attr _name##_gov_pol =                               \
-__ATTR(_name, 0644, show_##_name##_gov_pol, store_##_name##_gov_pol)
-#define gov_sys_pol_attr_rw(_name)                                      \
+        struct kobject kobj;
-        gov_sys_attr_rw(_name);                                         \
+        struct list_head policy_dbs_list;
-        gov_pol_attr_rw(_name)
+        /*
+         * Protect concurrent updates to governor tunables from sysfs,
+         * policy_dbs_list and usage_count.
+         */
+        struct mutex mutex;
+};
-#define gov_sys_pol_attr_ro(_name)                                      \
+/* Governor's specific attributes */
-        gov_sys_attr_ro(_name);                                         \
+struct dbs_data;
-        gov_pol_attr_ro(_name)
+struct governor_attr {
+        struct attribute attr;
+        ssize_t (*show)(struct dbs_data *dbs_data, char *buf);
+        ssize_t (*store)(struct dbs_data *dbs_data, const char *buf,
+                         size_t count);
+};
-/* Create show/store routines */
+#define gov_show_one(_gov, file_name)                                   \
-#define show_one(_gov, file_name)                                       \
+static ssize_t show_##file_name                                         \
-static ssize_t show_##file_name##_gov_sys                               \
+(struct dbs_data *dbs_data, char *buf)                                  \
-(struct kobject *kobj, struct attribute *attr, char *buf)               \
 {                                                                       \
-        struct _gov##_dbs_tuners *tuners = _gov##_dbs_cdata.gdbs_data->tuners; \
-        return sprintf(buf, "%u\n", tuners->file_name);                 \
-}                                                                       \
-                                                                        \
-static ssize_t show_##file_name##_gov_pol                               \
-(struct cpufreq_policy *policy, char *buf)                              \
-{                                                                       \
-        struct dbs_data *dbs_data = policy->governor_data;              \
        struct _gov##_dbs_tuners *tuners = dbs_data->tuners;            \
        return sprintf(buf, "%u\n", tuners->file_name);                 \
 }
-#define store_one(_gov, file_name)                                      \
+#define gov_show_one_common(file_name)                                  \
-static ssize_t store_##file_name##_gov_sys                              \
+static ssize_t show_##file_name                                         \
-(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) \
+(struct dbs_data *dbs_data, char *buf)                                  \
-{                                                                       \
-        struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data;         \
-        return store_##file_name(dbs_data, buf, count);                 \
-}                                                                       \
-                                                                        \
-static ssize_t store_##file_name##_gov_pol                              \
-(struct cpufreq_policy *policy, const char *buf, size_t count)          \
 {                                                                       \
-        struct dbs_data *dbs_data = policy->governor_data;              \
+        return sprintf(buf, "%u\n", dbs_data->file_name);               \
-        return store_##file_name(dbs_data, buf, count);                 \
 }
-#define show_store_one(_gov, file_name)                                 \
+#define gov_attr_ro(_name)                                              \
-show_one(_gov, file_name);                                              \
+static struct governor_attr _name =                                     \
-store_one(_gov, file_name)
+__ATTR(_name, 0444, show_##_name, NULL)
-/* create helper routines */
+#define gov_attr_rw(_name)                                              \
-#define define_get_cpu_dbs_routines(_dbs_info)                          \
+static struct governor_attr _name =                                     \
-static struct cpu_dbs_info *get_cpu_cdbs(int cpu)                       \
+__ATTR(_name, 0644, show_##_name, store_##_name)
-{                                                                       \
-        return &per_cpu(_dbs_info, cpu).cdbs;                           \
-}                                                                       \
-                                                                        \
-static void *get_cpu_dbs_info_s(int cpu)                                \
-{                                                                       \
-        return &per_cpu(_dbs_info, cpu);                                \
-}
-/*
- * Abbreviations:
- * dbs: used as a shortform for demand based switching It helps to keep variable
- *      names smaller, simpler
- * cdbs: common dbs
- * od_*: On-demand governor
- * cs_*: Conservative governor
- */
 /* Common to all CPUs of a policy */
-struct cpu_common_dbs_info {
+struct policy_dbs_info {
        struct cpufreq_policy *policy;
        /*
         * Per policy mutex that serializes load evaluation from limit-change
@@ -138,11 +111,27 @@ struct cpu_common_dbs_info {
         */
        struct mutex timer_mutex;
-        ktime_t time_stamp;
+        u64 last_sample_time;
-        atomic_t skip_work;
+        s64 sample_delay_ns;
+        atomic_t work_count;
+        struct irq_work irq_work;
        struct work_struct work;
+        /* dbs_data may be shared between multiple policy objects */
+        struct dbs_data *dbs_data;
+        struct list_head list;
+        /* Multiplier for increasing sample delay temporarily. */
+        unsigned int rate_mult;
+        /* Status indicators */
+        bool is_shared;         /* This object is used by multiple CPUs */
+        bool work_in_progress;  /* Work is being queued up or in progress */
 };
+static inline void gov_update_sample_delay(struct policy_dbs_info *policy_dbs,
+                                           unsigned int delay_us)
+{
+        policy_dbs->sample_delay_ns = delay_us * NSEC_PER_USEC;
+}
 /* Per cpu structures */
 struct cpu_dbs_info {
        u64 prev_cpu_idle;
@@ -155,54 +144,14 @@ struct cpu_dbs_info {
         * wake-up from idle.
         */
        unsigned int prev_load;
-        struct timer_list timer;
+        struct update_util_data update_util;
-        struct cpu_common_dbs_info *shared;
+        struct policy_dbs_info *policy_dbs;
-};
-struct od_cpu_dbs_info_s {
-        struct cpu_dbs_info cdbs;
-        struct cpufreq_frequency_table *freq_table;
-        unsigned int freq_lo;
-        unsigned int freq_lo_jiffies;
-        unsigned int freq_hi_jiffies;
-        unsigned int rate_mult;
-        unsigned int sample_type:1;
-};
-struct cs_cpu_dbs_info_s {
-        struct cpu_dbs_info cdbs;
-        unsigned int down_skip;
-        unsigned int requested_freq;
-};
-/* Per policy Governors sysfs tunables */
-struct od_dbs_tuners {
-        unsigned int ignore_nice_load;
-        unsigned int sampling_rate;
-        unsigned int sampling_down_factor;
-        unsigned int up_threshold;
-        unsigned int powersave_bias;
-        unsigned int io_is_busy;
-};
-struct cs_dbs_tuners {
-        unsigned int ignore_nice_load;
-        unsigned int sampling_rate;
-        unsigned int sampling_down_factor;
-        unsigned int up_threshold;
-        unsigned int down_threshold;
-        unsigned int freq_step;
 };
 /* Common Governor data across policies */
-struct dbs_data;
+struct dbs_governor {
-struct common_dbs_data {
+        struct cpufreq_governor gov;
-        /* Common across governors */
+        struct kobj_type kobj_type;
-        #define GOV_ONDEMAND            0
-        #define GOV_CONSERVATIVE        1
-        int governor;
-        struct attribute_group *attr_group_gov_sys; /* one governor - system */
-        struct attribute_group *attr_group_gov_pol; /* one governor - policy */
        /*
         * Common data for platforms that don't set
@@ -210,74 +159,32 @@ struct common_dbs_data {
         */
        struct dbs_data *gdbs_data;
-        struct cpu_dbs_info *(*get_cpu_cdbs)(int cpu);
+        unsigned int (*gov_dbs_timer)(struct cpufreq_policy *policy);
-        void *(*get_cpu_dbs_info_s)(int cpu);
+        struct policy_dbs_info *(*alloc)(void);
-        unsigned int (*gov_dbs_timer)(struct cpufreq_policy *policy,
+        void (*free)(struct policy_dbs_info *policy_dbs);
-                                      bool modify_all);
-        void (*gov_check_cpu)(int cpu, unsigned int load);
        int (*init)(struct dbs_data *dbs_data, bool notify);
        void (*exit)(struct dbs_data *dbs_data, bool notify);
+        void (*start)(struct cpufreq_policy *policy);
-        /* Governor specific ops, see below */
-        void *gov_ops;
-        /*
-         * Protects governor's data (struct dbs_data and struct common_dbs_data)
-         */
-        struct mutex mutex;
 };
-/* Governor Per policy data */
+static inline struct dbs_governor *dbs_governor_of(struct cpufreq_policy *policy)
-struct dbs_data {
+{
-        struct common_dbs_data *cdata;
+        return container_of(policy->governor, struct dbs_governor, gov);
-        unsigned int min_sampling_rate;
+}
-        int usage_count;
-        void *tuners;
-};
-/* Governor specific ops, will be passed to dbs_data->gov_ops */
+/* Governor specific operations */
 struct od_ops {
-        void (*powersave_bias_init_cpu)(int cpu);
        unsigned int (*powersave_bias_target)(struct cpufreq_policy *policy,
                        unsigned int freq_next, unsigned int relation);
-        void (*freq_increase)(struct cpufreq_policy *policy, unsigned int freq);
 };
-static inline int delay_for_sampling_rate(unsigned int sampling_rate)
+unsigned int dbs_update(struct cpufreq_policy *policy);
-{
+int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event);
-        int delay = usecs_to_jiffies(sampling_rate);
-        /* We want all CPUs to do sampling nearly on same jiffy */
-        if (num_online_cpus() > 1)
-                delay -= jiffies % delay;
-        return delay;
-}
-#define declare_show_sampling_rate_min(_gov)                            \
-static ssize_t show_sampling_rate_min_gov_sys                           \
-(struct kobject *kobj, struct attribute *attr, char *buf)               \
-{                                                                       \
-        struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data;         \
-        return sprintf(buf, "%u\n", dbs_data->min_sampling_rate);       \
-}                                                                       \
-                                                                        \
-static ssize_t show_sampling_rate_min_gov_pol                           \
-(struct cpufreq_policy *policy, char *buf)                              \
-{                                                                       \
-        struct dbs_data *dbs_data = policy->governor_data;              \
-        return sprintf(buf, "%u\n", dbs_data->min_sampling_rate);       \
-}
-extern struct mutex cpufreq_governor_lock;
-void gov_add_timers(struct cpufreq_policy *policy, unsigned int delay);
-void gov_cancel_work(struct cpu_common_dbs_info *shared);
-void dbs_check_cpu(struct dbs_data *dbs_data, int cpu);
-int cpufreq_governor_dbs(struct cpufreq_policy *policy,
-                struct common_dbs_data *cdata, unsigned int event);
 void od_register_powersave_bias_handler(unsigned int (*f)
                (struct cpufreq_policy *, unsigned int, unsigned int),
                unsigned int powersave_bias);
 void od_unregister_powersave_bias_handler(void);
+ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf,
+                            size_t count);
+void gov_update_cpu_data(struct dbs_data *dbs_data);
 #endif /* _CPUFREQ_GOVERNOR_H */
author	Rafael J. Wysocki <rafael.j.wysocki@intel.com>	2016-03-14 09:22:03 -0400
committer	Rafael J. Wysocki <rafael.j.wysocki@intel.com>	2016-03-14 09:22:03 -0400
commit	4ed39004271280d2b5fc6929b2782c0e330f6895 (patch)
tree	d0f3bc36dd0598bf6d9d7f7321992111f349bfb3 /drivers/cpufreq/cpufreq_governor.h
parent	b5d5fad9bed079a4f182e4d282ca29380e8c08f2 (diff)
parent	4fec7ad5f637159525265a45f66482cf8817b45f (diff)

diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h index 91e767a058a7..61ff82fe0613 100644 --- a/drivers/cpufreq/cpufreq_governor.h +++ b/drivers/cpufreq/cpufreq_governor.h
@@ -18,6 +18,7 @@
18	#define _CPUFREQ_GOVERNOR_H	18	#define _CPUFREQ_GOVERNOR_H
19		19
20	#include <linux/atomic.h>	20	#include <linux/atomic.h>
		21	#include <linux/irq_work.h>
21	#include <linux/cpufreq.h>	22	#include <linux/cpufreq.h>
22	#include <linux/kernel_stat.h>	23	#include <linux/kernel_stat.h>
23	#include <linux/module.h>	24	#include <linux/module.h>
@@ -41,96 +42,68 @@
41	enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};	42	enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};
42		43
43	/*	44	/*
44	* Macro for creating governors sysfs routines	45	* Abbreviations:
45	*	46	* dbs: used as a shortform for demand based switching It helps to keep variable
46	* - gov_sys: One governor instance per whole system	47	* names smaller, simpler
47	* - gov_pol: One governor instance per policy	48	* cdbs: common dbs
		49	* od_*: On-demand governor
		50	* cs_*: Conservative governor
48	*/	51	*/
49		52
50	/* Create attributes */	53	/* Governor demand based switching data (per-policy or global). */
51	#define gov_sys_attr_ro(_name) \	54	struct dbs_data {
52	static struct global_attr _name##_gov_sys = \	55	int usage_count;
53	__ATTR(_name, 0444, show_##_name##_gov_sys, NULL)	56	void *tuners;
54		57	unsigned int min_sampling_rate;
55	#define gov_sys_attr_rw(_name) \	58	unsigned int ignore_nice_load;
56	static struct global_attr _name##_gov_sys = \	59	unsigned int sampling_rate;
57	__ATTR(_name, 0644, show_##_name##_gov_sys, store_##_name##_gov_sys)	60	unsigned int sampling_down_factor;
58		61	unsigned int up_threshold;
59	#define gov_pol_attr_ro(_name) \	62	unsigned int io_is_busy;
60	static struct freq_attr _name##_gov_pol = \
61	__ATTR(_name, 0444, show_##_name##_gov_pol, NULL)
62
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)
66		63
67	#define gov_sys_pol_attr_rw(_name) \	64	struct kobject kobj;
68	gov_sys_attr_rw(_name); \	65	struct list_head policy_dbs_list;
69	gov_pol_attr_rw(_name)	66	/*
		67	* Protect concurrent updates to governor tunables from sysfs,
		68	* policy_dbs_list and usage_count.
		69	*/
		70	struct mutex mutex;
		71	};
70		72
71	#define gov_sys_pol_attr_ro(_name) \	73	/* Governor's specific attributes */
72	gov_sys_attr_ro(_name); \	74	struct dbs_data;
73	gov_pol_attr_ro(_name)	75	struct governor_attr {
		76	struct attribute attr;
		77	ssize_t (show)(struct dbs_data dbs_data, char *buf);
		78	ssize_t (store)(struct dbs_data dbs_data, const char *buf,
		79	size_t count);
		80	};
74		81
75	/* Create show/store routines */	82	#define gov_show_one(_gov, file_name) \
76	#define show_one(_gov, file_name) \	83	static ssize_t show_##file_name \
77	static ssize_t show_##file_name##_gov_sys \	84	(struct dbs_data dbs_data, char buf) \
78	(struct kobject kobj, struct attribute attr, char *buf) \
79	{ \	85	{ \
80	struct _gov##_dbs_tuners *tuners = _gov##_dbs_cdata.gdbs_data->tuners; \
81	return sprintf(buf, "%u\n", tuners->file_name); \
82	} \
83	\
84	static ssize_t show_##file_name##_gov_pol \
85	(struct cpufreq_policy policy, char buf) \
86	{ \
87	struct dbs_data *dbs_data = policy->governor_data; \
88	struct _gov##_dbs_tuners *tuners = dbs_data->tuners; \	86	struct _gov##_dbs_tuners *tuners = dbs_data->tuners; \
89	return sprintf(buf, "%u\n", tuners->file_name); \	87	return sprintf(buf, "%u\n", tuners->file_name); \
90	}	88	}
91		89
92	#define store_one(_gov, file_name) \	90	#define gov_show_one_common(file_name) \
93	static ssize_t store_##file_name##_gov_sys \	91	static ssize_t show_##file_name \
94	(struct kobject kobj, struct attribute attr, const char *buf, size_t count) \	92	(struct dbs_data dbs_data, char buf) \
95	{ \
96	struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data; \
97	return store_##file_name(dbs_data, buf, count); \
98	} \
99	\
100	static ssize_t store_##file_name##_gov_pol \
101	(struct cpufreq_policy policy, const char buf, size_t count) \
102	{ \	93	{ \
103	struct dbs_data *dbs_data = policy->governor_data; \	94	return sprintf(buf, "%u\n", dbs_data->file_name); \
104	return store_##file_name(dbs_data, buf, count); \
105	}	95	}
106		96
107	#define show_store_one(_gov, file_name) \	97	#define gov_attr_ro(_name) \
108	show_one(_gov, file_name); \	98	static struct governor_attr _name = \
109	store_one(_gov, file_name)	99	__ATTR(_name, 0444, show_##_name, NULL)
110		100
111	/* create helper routines */	101	#define gov_attr_rw(_name) \
112	#define define_get_cpu_dbs_routines(_dbs_info) \	102	static struct governor_attr _name = \
113	static struct cpu_dbs_info *get_cpu_cdbs(int cpu) \	103	__ATTR(_name, 0644, show_##_name, store_##_name)
114	{ \
115	return &per_cpu(_dbs_info, cpu).cdbs; \
116	} \
117	\
118	static void *get_cpu_dbs_info_s(int cpu) \
119	{ \
120	return &per_cpu(_dbs_info, cpu); \
121	}
122
123	/*
124	* Abbreviations:
125	* dbs: used as a shortform for demand based switching It helps to keep variable
126	* names smaller, simpler
127	* cdbs: common dbs
128	* od_*: On-demand governor
129	* cs_*: Conservative governor
130	*/
131		104
132	/* Common to all CPUs of a policy */	105	/* Common to all CPUs of a policy */
133	struct cpu_common_dbs_info {	106	struct policy_dbs_info {
134	struct cpufreq_policy *policy;	107	struct cpufreq_policy *policy;
135	/*	108	/*
136	* Per policy mutex that serializes load evaluation from limit-change	109	* Per policy mutex that serializes load evaluation from limit-change
@@ -138,11 +111,27 @@ struct cpu_common_dbs_info {
138	*/	111	*/
139	struct mutex timer_mutex;	112	struct mutex timer_mutex;
140		113
141	ktime_t time_stamp;	114	u64 last_sample_time;
142	atomic_t skip_work;	115	s64 sample_delay_ns;
		116	atomic_t work_count;
		117	struct irq_work irq_work;
143	struct work_struct work;	118	struct work_struct work;
		119	/* dbs_data may be shared between multiple policy objects */
		120	struct dbs_data *dbs_data;
		121	struct list_head list;
		122	/* Multiplier for increasing sample delay temporarily. */
		123	unsigned int rate_mult;
		124	/* Status indicators */
		125	bool is_shared; /* This object is used by multiple CPUs */
		126	bool work_in_progress; /* Work is being queued up or in progress */
144	};	127	};
145		128
		129	static inline void gov_update_sample_delay(struct policy_dbs_info *policy_dbs,
		130	unsigned int delay_us)
		131	{
		132	policy_dbs->sample_delay_ns = delay_us * NSEC_PER_USEC;
		133	}
		134
146	/* Per cpu structures */	135	/* Per cpu structures */
147	struct cpu_dbs_info {	136	struct cpu_dbs_info {
148	u64 prev_cpu_idle;	137	u64 prev_cpu_idle;
@@ -155,54 +144,14 @@ struct cpu_dbs_info {
155	* wake-up from idle.	144	* wake-up from idle.
156	*/	145	*/
157	unsigned int prev_load;	146	unsigned int prev_load;
158	struct timer_list timer;	147	struct update_util_data update_util;
159	struct cpu_common_dbs_info *shared;	148	struct policy_dbs_info *policy_dbs;
160	};
161
162	struct od_cpu_dbs_info_s {
163	struct cpu_dbs_info cdbs;
164	struct cpufreq_frequency_table *freq_table;
165	unsigned int freq_lo;
166	unsigned int freq_lo_jiffies;
167	unsigned int freq_hi_jiffies;
168	unsigned int rate_mult;
169	unsigned int sample_type:1;
170	};
171
172	struct cs_cpu_dbs_info_s {
173	struct cpu_dbs_info cdbs;
174	unsigned int down_skip;
175	unsigned int requested_freq;
176	};
177
178	/* Per policy Governors sysfs tunables */
179	struct od_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 powersave_bias;
185	unsigned int io_is_busy;
186	};
187
188	struct cs_dbs_tuners {
189	unsigned int ignore_nice_load;
190	unsigned int sampling_rate;
191	unsigned int sampling_down_factor;
192	unsigned int up_threshold;
193	unsigned int down_threshold;
194	unsigned int freq_step;
195	};	149	};
196		150
197	/* Common Governor data across policies */	151	/* Common Governor data across policies */
198	struct dbs_data;	152	struct dbs_governor {
199	struct common_dbs_data {	153	struct cpufreq_governor gov;
200	/* Common across governors */	154	struct kobj_type kobj_type;
201	#define GOV_ONDEMAND 0
202	#define GOV_CONSERVATIVE 1
203	int governor;
204	struct attribute_group attr_group_gov_sys; / one governor - system */
205	struct attribute_group attr_group_gov_pol; / one governor - policy */
206		155
207	/*	156	/*
208	* Common data for platforms that don't set	157	* Common data for platforms that don't set
@@ -210,74 +159,32 @@ struct common_dbs_data {
210	*/	159	*/
211	struct dbs_data *gdbs_data;	160	struct dbs_data *gdbs_data;
212		161
213	struct cpu_dbs_info (get_cpu_cdbs)(int cpu);	162	unsigned int (gov_dbs_timer)(struct cpufreq_policy policy);
214	void (get_cpu_dbs_info_s)(int cpu);	163	struct policy_dbs_info (alloc)(void);
215	unsigned int (gov_dbs_timer)(struct cpufreq_policy policy,	164	void (free)(struct policy_dbs_info policy_dbs);
216	bool modify_all);
217	void (*gov_check_cpu)(int cpu, unsigned int load);
218	int (init)(struct dbs_data dbs_data, bool notify);	165	int (init)(struct dbs_data dbs_data, bool notify);
219	void (exit)(struct dbs_data dbs_data, bool notify);	166	void (exit)(struct dbs_data dbs_data, bool notify);
220		167	void (start)(struct cpufreq_policy policy);
221	/* Governor specific ops, see below */
222	void *gov_ops;
223
224	/*
225	* Protects governor's data (struct dbs_data and struct common_dbs_data)
226	*/
227	struct mutex mutex;
228	};	168	};
229		169
230	/* Governor Per policy data */	170	static inline struct dbs_governor dbs_governor_of(struct cpufreq_policy policy)
231	struct dbs_data {	171	{
232	struct common_dbs_data *cdata;	172	return container_of(policy->governor, struct dbs_governor, gov);
233	unsigned int min_sampling_rate;	173	}
234	int usage_count;
235	void *tuners;
236	};
237		174
238	/* Governor specific ops, will be passed to dbs_data->gov_ops */	175	/* Governor specific operations */
239	struct od_ops {	176	struct od_ops {
240	void (*powersave_bias_init_cpu)(int cpu);
241	unsigned int (powersave_bias_target)(struct cpufreq_policy policy,	177	unsigned int (powersave_bias_target)(struct cpufreq_policy policy,
242	unsigned int freq_next, unsigned int relation);	178	unsigned int freq_next, unsigned int relation);
243	void (freq_increase)(struct cpufreq_policy policy, unsigned int freq);
244	};	179	};
245		180
246	static inline int delay_for_sampling_rate(unsigned int sampling_rate)	181	unsigned int dbs_update(struct cpufreq_policy *policy);
247	{	182	int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event);
248	int delay = usecs_to_jiffies(sampling_rate);
249
250	/* We want all CPUs to do sampling nearly on same jiffy */
251	if (num_online_cpus() > 1)
252	delay -= jiffies % delay;
253
254	return delay;
255	}
256
257	#define declare_show_sampling_rate_min(_gov) \
258	static ssize_t show_sampling_rate_min_gov_sys \
259	(struct kobject kobj, struct attribute attr, char *buf) \
260	{ \
261	struct dbs_data *dbs_data = _gov##_dbs_cdata.gdbs_data; \
262	return sprintf(buf, "%u\n", dbs_data->min_sampling_rate); \
263	} \
264	\
265	static ssize_t show_sampling_rate_min_gov_pol \
266	(struct cpufreq_policy policy, char buf) \
267	{ \
268	struct dbs_data *dbs_data = policy->governor_data; \
269	return sprintf(buf, "%u\n", dbs_data->min_sampling_rate); \
270	}
271
272	extern struct mutex cpufreq_governor_lock;
273
274	void gov_add_timers(struct cpufreq_policy *policy, unsigned int delay);
275	void gov_cancel_work(struct cpu_common_dbs_info *shared);
276	void dbs_check_cpu(struct dbs_data *dbs_data, int cpu);
277	int cpufreq_governor_dbs(struct cpufreq_policy *policy,
278	struct common_dbs_data *cdata, unsigned int event);
279	void od_register_powersave_bias_handler(unsigned int (*f)	183	void od_register_powersave_bias_handler(unsigned int (*f)
280	(struct cpufreq_policy *, unsigned int, unsigned int),	184	(struct cpufreq_policy *, unsigned int, unsigned int),
281	unsigned int powersave_bias);	185	unsigned int powersave_bias);
282	void od_unregister_powersave_bias_handler(void);	186	void od_unregister_powersave_bias_handler(void);
		187	ssize_t store_sampling_rate(struct dbs_data dbs_data, const char buf,
		188	size_t count);
		189	void gov_update_cpu_data(struct dbs_data *dbs_data);
283	#endif /* _CPUFREQ_GOVERNOR_H */	190	#endif /* _CPUFREQ_GOVERNOR_H */