cpufreq: governor: Drop the gov pointer from struct dbs_data

Since it is possible to obtain a pointer to struct dbs_governor
from a pointer to the struct governor embedded in it with the help
of container_of(), the additional gov pointer in struct dbs_data
isn't really necessary.

Drop that pointer and make the code using it reach the dbs_governor
object via policy->governor.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>

diff --git a/drivers/cpufreq/amd_freq_sensitivity.c b/drivers/cpufreq/amd_freq_sensitivity.c
index a7d237b386d34ff65f2f75f9c8966cb3de5d9ff2..6395a5f0ff251d83be254118a7020670c36db6e8 100644 (file)
--- a/drivers/cpufreq/amd_freq_sensitivity.c
+++ b/drivers/cpufreq/amd_freq_sensitivity.c
@@ -48,7 +48,7 @@ static unsigned int amd_powersave_bias_target(struct cpufreq_policy *policy,
        struct dbs_data *od_data = policy->governor_data;
        struct od_dbs_tuners *od_tuners = od_data->tuners;
        struct od_cpu_dbs_info_s *od_info =
-               od_data->gov->get_cpu_dbs_info_s(policy->cpu);
+               dbs_governor_of(policy)->get_cpu_dbs_info_s(policy->cpu);
 
        if (!od_info->freq_table)
                return freq_next;

diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 20c82913ef42d8c5c276f67cd164988b2ab9b7ea..7d5f181e1679c047aec7da3df4c35c34ac36b278 100644 (file)
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -107,7 +107,7 @@ static unsigned int cs_dbs_timer(struct cpufreq_policy *policy)
        struct dbs_data *dbs_data = policy->governor_data;
        struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
 
-       dbs_check_cpu(dbs_data, policy->cpu);
+       dbs_check_cpu(policy, policy->cpu);
        return delay_for_sampling_rate(cs_tuners->sampling_rate);
 }
 

diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c
index 73e157dcbedd87e49fbb8e58f2d968128ee9e2b6..61287c1660a2c29292960b6a79670fec1306e3fd 100644 (file)
--- a/drivers/cpufreq/cpufreq_governor.c
+++ b/drivers/cpufreq/cpufreq_governor.c
@@ -25,28 +25,27 @@
 DEFINE_MUTEX(dbs_data_mutex);
 EXPORT_SYMBOL_GPL(dbs_data_mutex);
 
-static struct attribute_group *get_sysfs_attr(struct dbs_data *dbs_data)
+static struct attribute_group *get_sysfs_attr(struct dbs_governor *gov)
 {
-       if (have_governor_per_policy())
-               return dbs_data->gov->attr_group_gov_pol;
-       else
-               return dbs_data->gov->attr_group_gov_sys;
+       return have_governor_per_policy() ?
+               gov->attr_group_gov_pol : gov->attr_group_gov_sys;
 }
 
-void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
+void dbs_check_cpu(struct cpufreq_policy *policy, int cpu)
 {
-       struct cpu_dbs_info *cdbs = dbs_data->gov->get_cpu_cdbs(cpu);
+       struct dbs_governor *gov = dbs_governor_of(policy);
+       struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
+       struct dbs_data *dbs_data = policy->governor_data;
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
        struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
-       struct cpufreq_policy *policy = cdbs->shared->policy;
        unsigned int sampling_rate;
        unsigned int max_load = 0;
        unsigned int ignore_nice;
        unsigned int j;
 
-       if (dbs_data->gov->governor == GOV_ONDEMAND) {
+       if (gov->governor == GOV_ONDEMAND) {
                struct od_cpu_dbs_info_s *od_dbs_info =
-                               dbs_data->gov->get_cpu_dbs_info_s(cpu);
+                               gov->get_cpu_dbs_info_s(cpu);
 
                /*
                 * Sometimes, the ondemand governor uses an additional
@@ -71,7 +70,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
                unsigned int load;
                int io_busy = 0;
 
-               j_cdbs = dbs_data->gov->get_cpu_cdbs(j);
+               j_cdbs = gov->get_cpu_cdbs(j);
 
                /*
                 * For the purpose of ondemand, waiting for disk IO is
@@ -79,7 +78,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
                 * not that the system is actually idle. So do not add
                 * the iowait time to the cpu idle time.
                 */
-               if (dbs_data->gov->governor == GOV_ONDEMAND)
+               if (gov->governor == GOV_ONDEMAND)
                        io_busy = od_tuners->io_is_busy;
                cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy);
 
@@ -160,7 +159,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
                        max_load = load;
        }
 
-       dbs_data->gov->gov_check_cpu(cpu, max_load);
+       gov->gov_check_cpu(cpu, max_load);
 }
 EXPORT_SYMBOL_GPL(dbs_check_cpu);
 
@@ -168,14 +167,14 @@ void gov_set_update_util(struct cpu_common_dbs_info *shared,
                         unsigned int delay_us)
 {
        struct cpufreq_policy *policy = shared->policy;
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct dbs_governor *gov = dbs_governor_of(policy);
        int cpu;
 
        gov_update_sample_delay(shared, delay_us);
        shared->last_sample_time = 0;
 
        for_each_cpu(cpu, policy->cpus) {
-               struct cpu_dbs_info *cdbs = dbs_data->gov->get_cpu_cdbs(cpu);
+               struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
 
                cpufreq_set_update_util_data(cpu, &cdbs->update_util);
        }
@@ -212,18 +211,18 @@ static void dbs_work_handler(struct work_struct *work)
        struct cpu_common_dbs_info *shared = container_of(work, struct
                                        cpu_common_dbs_info, work);
        struct cpufreq_policy *policy;
-       struct dbs_data *dbs_data;
+       struct dbs_governor *gov;
        unsigned int delay;
 
        policy = shared->policy;
-       dbs_data = policy->governor_data;
+       gov = dbs_governor_of(policy);
 
        /*
         * Make sure cpufreq_governor_limits() isn't evaluating load or the
         * ondemand governor isn't updating the sampling rate in parallel.
         */
        mutex_lock(&shared->timer_mutex);
-       delay = dbs_data->gov->gov_dbs_timer(policy);
+       delay = gov->gov_dbs_timer(policy);
        shared->sample_delay_ns = jiffies_to_nsecs(delay);
        mutex_unlock(&shared->timer_mutex);
 
@@ -279,9 +278,10 @@ static void dbs_update_util_handler(struct update_util_data *data, u64 time,
 }
 
 static void set_sampling_rate(struct dbs_data *dbs_data,
-               unsigned int sampling_rate)
+                             struct dbs_governor *gov,
+                             unsigned int sampling_rate)
 {
-       if (dbs_data->gov->governor == GOV_CONSERVATIVE) {
+       if (gov->governor == GOV_CONSERVATIVE) {
                struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
                cs_tuners->sampling_rate = sampling_rate;
        } else {
@@ -329,8 +329,7 @@ static void free_common_dbs_info(struct cpufreq_policy *policy,
 
 static int cpufreq_governor_init(struct cpufreq_policy *policy)
 {
-       struct dbs_governor *gov = container_of(policy->governor,
-                                               struct dbs_governor, gov);
+       struct dbs_governor *gov = dbs_governor_of(policy);
        struct dbs_data *dbs_data = gov->gdbs_data;
        unsigned int latency;
        int ret;
@@ -360,7 +359,6 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
        if (ret)
                goto free_dbs_data;
 
-       dbs_data->gov = gov;
        dbs_data->usage_count = 1;
 
        ret = gov->init(dbs_data, !policy->governor->initialized);
@@ -375,7 +373,7 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
        /* Bring kernel and HW constraints together */
        dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
                                          MIN_LATENCY_MULTIPLIER * latency);
-       set_sampling_rate(dbs_data, max(dbs_data->min_sampling_rate,
+       set_sampling_rate(dbs_data, gov, max(dbs_data->min_sampling_rate,
                                        latency * LATENCY_MULTIPLIER));
 
        if (!have_governor_per_policy())
@@ -384,7 +382,7 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
        policy->governor_data = dbs_data;
 
        ret = sysfs_create_group(get_governor_parent_kobj(policy),
-                                get_sysfs_attr(dbs_data));
+                                get_sysfs_attr(gov));
        if (ret)
                goto reset_gdbs_data;
 
@@ -405,8 +403,8 @@ free_dbs_data:
 
 static int cpufreq_governor_exit(struct cpufreq_policy *policy)
 {
+       struct dbs_governor *gov = dbs_governor_of(policy);
        struct dbs_data *dbs_data = policy->governor_data;
-       struct dbs_governor *gov = dbs_data->gov;
        struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
 
        /* State should be equivalent to INIT */
@@ -415,7 +413,7 @@ static int cpufreq_governor_exit(struct cpufreq_policy *policy)
 
        if (!--dbs_data->usage_count) {
                sysfs_remove_group(get_governor_parent_kobj(policy),
-                                  get_sysfs_attr(dbs_data));
+                                  get_sysfs_attr(gov));
 
                policy->governor_data = NULL;
 
@@ -434,8 +432,8 @@ static int cpufreq_governor_exit(struct cpufreq_policy *policy)
 
 static int cpufreq_governor_start(struct cpufreq_policy *policy)
 {
+       struct dbs_governor *gov = dbs_governor_of(policy);
        struct dbs_data *dbs_data = policy->governor_data;
-       struct dbs_governor *gov = dbs_data->gov;
        unsigned int sampling_rate, ignore_nice, j, cpu = policy->cpu;
        struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
        struct cpu_common_dbs_info *shared = cdbs->shared;
@@ -501,8 +499,8 @@ static int cpufreq_governor_start(struct cpufreq_policy *policy)
 
 static int cpufreq_governor_stop(struct cpufreq_policy *policy)
 {
-       struct dbs_data *dbs_data = policy->governor_data;
-       struct cpu_dbs_info *cdbs = dbs_data->gov->get_cpu_cdbs(policy->cpu);
+       struct dbs_governor *gov = dbs_governor_of(policy);
+       struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
        struct cpu_common_dbs_info *shared = cdbs->shared;
 
        /* State should be equivalent to START */
@@ -517,8 +515,7 @@ static int cpufreq_governor_stop(struct cpufreq_policy *policy)
 
 static int cpufreq_governor_limits(struct cpufreq_policy *policy)
 {
-       struct dbs_data *dbs_data = policy->governor_data;
-       struct dbs_governor *gov = dbs_data->gov;
+       struct dbs_governor *gov = dbs_governor_of(policy);
        unsigned int cpu = policy->cpu;
        struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
 
@@ -533,7 +530,7 @@ static int cpufreq_governor_limits(struct cpufreq_policy *policy)
        else if (policy->min > cdbs->shared->policy->cur)
                __cpufreq_driver_target(cdbs->shared->policy, policy->min,
                                        CPUFREQ_RELATION_L);
-       dbs_check_cpu(dbs_data, cpu);
+       dbs_check_cpu(policy, cpu);
        mutex_unlock(&cdbs->shared->timer_mutex);
 
        return 0;

diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h
index 8e280b8c446a2533c53ebd4d74a8370122a98886..c8b7ec22871cd9df6cb681c52d9e827aea56250d 100644 (file)
--- a/drivers/cpufreq/cpufreq_governor.h
+++ b/drivers/cpufreq/cpufreq_governor.h
@@ -231,9 +231,13 @@ struct dbs_governor {
        void *gov_ops;
 };
 
+static inline struct dbs_governor *dbs_governor_of(struct cpufreq_policy *policy)
+{
+       return container_of(policy->governor, struct dbs_governor, gov);
+}
+
 /* Governor Per policy data */
 struct dbs_data {
-       struct dbs_governor *gov;
        unsigned int min_sampling_rate;
        int usage_count;
        void *tuners;
@@ -275,7 +279,7 @@ static ssize_t show_sampling_rate_min_gov_pol                               \
 
 extern struct mutex dbs_data_mutex;
 extern struct mutex cpufreq_governor_lock;
-void dbs_check_cpu(struct dbs_data *dbs_data, int cpu);
+void dbs_check_cpu(struct cpufreq_policy *policy, int cpu);
 int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event);
 void od_register_powersave_bias_handler(unsigned int (*f)
                (struct cpufreq_policy *, unsigned int, unsigned int),

diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index dcbcbf441ac15020f6653ccf2063a0670ef8218d..65ad39d95e39c953ddc1693f3b2ddb455cfc20ae 100644 (file)
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -203,7 +203,7 @@ static unsigned int od_dbs_timer(struct cpufreq_policy *policy)
                __cpufreq_driver_target(policy, dbs_info->freq_lo,
                                        CPUFREQ_RELATION_H);
        } else {
-               dbs_check_cpu(dbs_data, cpu);
+               dbs_check_cpu(policy, cpu);
                if (dbs_info->freq_lo) {
                        /* Setup timer for SUB_SAMPLE */
                        dbs_info->sample_type = OD_SUB_SAMPLE;