cpufreq: governor: Rearrange governor data structures

The struct policy_dbs_info objects representing per-policy governor
data are not accessible directly from the corresponding policy
objects.  To access them, one has to get a pointer to the
struct cpu_dbs_info of policy->cpu and use the policy_dbs field of
that which isn't really straightforward.

To address that rearrange the governor data structures so the
governor_data pointer in struct cpufreq_policy will point to
struct policy_dbs_info (instead of struct dbs_data) and that will
contain a pointer to struct dbs_data.

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 6395a5f0ff251d83be254118a7020670c36db6e8..82ae1002def1889ceedf2e17dc1f4628b929fea5 100644 (file)
--- a/drivers/cpufreq/amd_freq_sensitivity.c
+++ b/drivers/cpufreq/amd_freq_sensitivity.c
@@ -45,7 +45,8 @@ static unsigned int amd_powersave_bias_target(struct cpufreq_policy *policy,
        long d_actual, d_reference;
        struct msr actual, reference;
        struct cpu_data_t *data = &per_cpu(cpu_data, policy->cpu);
-       struct dbs_data *od_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *od_data = policy_dbs->dbs_data;
        struct od_dbs_tuners *od_tuners = od_data->tuners;
        struct od_cpu_dbs_info_s *od_info =
                dbs_governor_of(policy)->get_cpu_dbs_info_s(policy->cpu);

diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index b8054e53a37e9e3907fd62c429e6f6e49c03dd1b..1a899bb7d1a4de828dcd7cd59a4077a750a019ab 100644 (file)
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -48,7 +48,8 @@ static void cs_check_cpu(int cpu, unsigned int load)
 {
        struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, cpu);
        struct cpufreq_policy *policy = dbs_info->cdbs.policy_dbs->policy;
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
 
        /*
@@ -104,7 +105,8 @@ static void cs_check_cpu(int cpu, unsigned int load)
 
 static unsigned int cs_dbs_timer(struct cpufreq_policy *policy)
 {
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
 
        dbs_check_cpu(policy);

diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c
index ff247a7ac774215d1b3ff166aff2d0d6c0490d9b..82e50dcf9febade3b2f8c0a14321be51b90cd607 100644 (file)
--- a/drivers/cpufreq/cpufreq_governor.c
+++ b/drivers/cpufreq/cpufreq_governor.c
@@ -35,8 +35,8 @@ void dbs_check_cpu(struct cpufreq_policy *policy)
 {
        int cpu = policy->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 policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
        struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
        unsigned int sampling_rate;
@@ -95,6 +95,7 @@ void dbs_check_cpu(struct cpufreq_policy *policy)
                j_cdbs->prev_cpu_idle = cur_idle_time;
 
                if (ignore_nice) {
+                       struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
                        u64 cur_nice;
                        unsigned long cur_nice_jiffies;
 
@@ -292,8 +293,8 @@ static void set_sampling_rate(struct dbs_data *dbs_data,
        }
 }
 
-static int alloc_policy_dbs_info(struct cpufreq_policy *policy,
-                                struct dbs_governor *gov)
+static struct policy_dbs_info *alloc_policy_dbs_info(struct cpufreq_policy *policy,
+                                                    struct dbs_governor *gov)
 {
        struct policy_dbs_info *policy_dbs;
        int j;
@@ -301,7 +302,7 @@ static int alloc_policy_dbs_info(struct cpufreq_policy *policy,
        /* Allocate memory for the common information for policy->cpus */
        policy_dbs = kzalloc(sizeof(*policy_dbs), GFP_KERNEL);
        if (!policy_dbs)
-               return -ENOMEM;
+               return NULL;
 
        /* Set policy_dbs for all CPUs, online+offline */
        for_each_cpu(j, policy->related_cpus)
@@ -311,7 +312,7 @@ static int alloc_policy_dbs_info(struct cpufreq_policy *policy,
        atomic_set(&policy_dbs->skip_work, 0);
        init_irq_work(&policy_dbs->irq_work, dbs_irq_work);
        INIT_WORK(&policy_dbs->work, dbs_work_handler);
-       return 0;
+       return policy_dbs;
 }
 
 static void free_policy_dbs_info(struct cpufreq_policy *policy,
@@ -333,6 +334,7 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
 {
        struct dbs_governor *gov = dbs_governor_of(policy);
        struct dbs_data *dbs_data = gov->gdbs_data;
+       struct policy_dbs_info *policy_dbs;
        unsigned int latency;
        int ret;
 
@@ -340,26 +342,26 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
        if (policy->governor_data)
                return -EBUSY;
 
-       if (dbs_data) {
-               if (WARN_ON(have_governor_per_policy()))
-                       return -EINVAL;
-
-               ret = alloc_policy_dbs_info(policy, gov);
-               if (ret)
-                       return ret;
+       policy_dbs = alloc_policy_dbs_info(policy, gov);
+       if (!policy_dbs)
+               return -ENOMEM;
 
+       if (dbs_data) {
+               if (WARN_ON(have_governor_per_policy())) {
+                       ret = -EINVAL;
+                       goto free_policy_dbs_info;
+               }
                dbs_data->usage_count++;
-               policy->governor_data = dbs_data;
+               policy_dbs->dbs_data = dbs_data;
+               policy->governor_data = policy_dbs;
                return 0;
        }
 
        dbs_data = kzalloc(sizeof(*dbs_data), GFP_KERNEL);
-       if (!dbs_data)
-               return -ENOMEM;
-
-       ret = alloc_policy_dbs_info(policy, gov);
-       if (ret)
-               goto free_dbs_data;
+       if (!dbs_data) {
+               ret = -ENOMEM;
+               goto free_policy_dbs_info;
+       }
 
        dbs_data->usage_count = 1;
 
@@ -381,7 +383,8 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
        if (!have_governor_per_policy())
                gov->gdbs_data = dbs_data;
 
-       policy->governor_data = dbs_data;
+       policy_dbs->dbs_data = dbs_data;
+       policy->governor_data = policy_dbs;
 
        ret = sysfs_create_group(get_governor_parent_kobj(policy),
                                 get_sysfs_attr(gov));
@@ -396,21 +399,21 @@ reset_gdbs_data:
        if (!have_governor_per_policy())
                gov->gdbs_data = NULL;
        gov->exit(dbs_data, !policy->governor->initialized);
+       kfree(dbs_data);
+
 free_policy_dbs_info:
        free_policy_dbs_info(policy, gov);
-free_dbs_data:
-       kfree(dbs_data);
        return ret;
 }
 
 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 cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
 
        /* State should be equivalent to INIT */
-       if (!cdbs->policy_dbs || cdbs->policy_dbs->policy)
+       if (policy_dbs->policy)
                return -EBUSY;
 
        if (!--dbs_data->usage_count) {
@@ -435,17 +438,16 @@ 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 policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        unsigned int sampling_rate, ignore_nice, j, cpu = policy->cpu;
-       struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
-       struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;
        int io_busy = 0;
 
        if (!policy->cur)
                return -EINVAL;
 
        /* State should be equivalent to INIT */
-       if (!policy_dbs || policy_dbs->policy)
+       if (policy_dbs->policy)
                return -EBUSY;
 
        if (gov->governor == GOV_CONSERVATIVE) {
@@ -501,12 +503,10 @@ static int cpufreq_governor_start(struct cpufreq_policy *policy)
 
 static int cpufreq_governor_stop(struct cpufreq_policy *policy)
 {
-       struct dbs_governor *gov = dbs_governor_of(policy);
-       struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
-       struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
 
        /* State should be equivalent to START */
-       if (!policy_dbs || !policy_dbs->policy)
+       if (!policy_dbs->policy)
                return -EBUSY;
 
        gov_cancel_work(policy_dbs);
@@ -517,12 +517,10 @@ static int cpufreq_governor_stop(struct cpufreq_policy *policy)
 
 static int cpufreq_governor_limits(struct cpufreq_policy *policy)
 {
-       struct dbs_governor *gov = dbs_governor_of(policy);
-       struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
-       struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
 
        /* State should be equivalent to START */
-       if (!policy_dbs || !policy_dbs->policy)
+       if (!policy_dbs->policy)
                return -EBUSY;
 
        mutex_lock(&policy_dbs->timer_mutex);

diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h
index 63868d7f14f586ca40d662bd8a728d928f8abee9..95e6834d36a831c8a43701aa84c023e3b79a2c1b 100644 (file)
--- a/drivers/cpufreq/cpufreq_governor.h
+++ b/drivers/cpufreq/cpufreq_governor.h
@@ -85,7 +85,8 @@ static ssize_t show_##file_name##_gov_sys                             \
 static ssize_t show_##file_name##_gov_pol                              \
 (struct cpufreq_policy *policy, char *buf)                             \
 {                                                                      \
-       struct dbs_data *dbs_data = policy->governor_data;              \
+       struct policy_dbs_info *policy_dbs = policy->governor_data;     \
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;               \
        struct _gov##_dbs_tuners *tuners = dbs_data->tuners;            \
        return sprintf(buf, "%u\n", tuners->file_name);                 \
 }
@@ -101,8 +102,8 @@ static ssize_t store_##file_name##_gov_sys                          \
 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 store_##file_name(dbs_data, buf, count);                 \
+       struct policy_dbs_info *policy_dbs = policy->governor_data;     \
+       return store_##file_name(policy_dbs->dbs_data, buf, count);                     \
 }
 
 #define show_store_one(_gov, file_name)                                        \
@@ -130,6 +131,13 @@ static void *get_cpu_dbs_info_s(int cpu)                           \
  * cs_*: Conservative governor
  */
 
+/* Governor demand based switching data (per-policy or global). */
+struct dbs_data {
+       unsigned int min_sampling_rate;
+       int usage_count;
+       void *tuners;
+};
+
 /* Common to all CPUs of a policy */
 struct policy_dbs_info {
        struct cpufreq_policy *policy;
@@ -144,6 +152,8 @@ struct policy_dbs_info {
        atomic_t skip_work;
        struct irq_work irq_work;
        struct work_struct work;
+       /* dbs_data may be shared between multiple policy objects */
+       struct dbs_data *dbs_data;
 };
 
 static inline void gov_update_sample_delay(struct policy_dbs_info *policy_dbs,
@@ -204,7 +214,6 @@ struct cs_dbs_tuners {
 };
 
 /* Common Governor data across policies */
-struct dbs_data;
 struct dbs_governor {
        struct cpufreq_governor gov;
 
@@ -236,13 +245,6 @@ 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 {
-       unsigned int min_sampling_rate;
-       int usage_count;
-       void *tuners;
-};
-
 /* Governor specific ops, will be passed to dbs_data->gov_ops */
 struct od_ops {
        void (*powersave_bias_init_cpu)(int cpu);
@@ -273,7 +275,8 @@ static ssize_t show_sampling_rate_min_gov_sys                               \
 static ssize_t show_sampling_rate_min_gov_pol                          \
 (struct cpufreq_policy *policy, char *buf)                             \
 {                                                                      \
-       struct dbs_data *dbs_data = policy->governor_data;              \
+       struct policy_dbs_info *policy_dbs = policy->governor_data;     \
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;               \
        return sprintf(buf, "%u\n", dbs_data->min_sampling_rate);       \
 }
 

diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 9ef4402644c7c8f69b170190e937fe9ce80f57fc..b7ef2e7f4d4a4e497ff8039738b32266fa10cb31 100644 (file)
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -78,7 +78,8 @@ static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy,
        unsigned int jiffies_total, jiffies_hi, jiffies_lo;
        struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info,
                                                   policy->cpu);
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 
        if (!dbs_info->freq_table) {
@@ -130,7 +131,8 @@ static void ondemand_powersave_bias_init(void)
 
 static void dbs_freq_increase(struct cpufreq_policy *policy, unsigned int freq)
 {
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 
        if (od_tuners->powersave_bias)
@@ -151,8 +153,9 @@ static void dbs_freq_increase(struct cpufreq_policy *policy, unsigned int freq)
 static void od_check_cpu(int cpu, unsigned int load)
 {
        struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu);
-       struct cpufreq_policy *policy = dbs_info->cdbs.policy_dbs->policy;
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = dbs_info->cdbs.policy_dbs;
+       struct cpufreq_policy *policy = policy_dbs->policy;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 
        dbs_info->freq_lo = 0;
@@ -189,7 +192,8 @@ static void od_check_cpu(int cpu, unsigned int load)
 
 static unsigned int od_dbs_timer(struct cpufreq_policy *policy)
 {
-       struct dbs_data *dbs_data = policy->governor_data;
+       struct policy_dbs_info *policy_dbs = policy->governor_data;
+       struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu);
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
        int delay = 0, sample_type = dbs_info->sample_type;
@@ -277,7 +281,7 @@ static void update_sampling_rate(struct dbs_data *dbs_data,
                 * policy will be governed by dbs_data, otherwise there can be
                 * multiple policies that are governed by the same dbs_data.
                 */
-               if (dbs_data == policy->governor_data) {
+               if (dbs_data == policy_dbs->dbs_data) {
                        mutex_lock(&policy_dbs->timer_mutex);
                        /*
                         * On 32-bit architectures this may race with the
@@ -586,7 +590,7 @@ static void od_set_powersave_bias(unsigned int powersave_bias)
                if (policy->governor != CPU_FREQ_GOV_ONDEMAND)
                        continue;
 
-               dbs_data = policy->governor_data;
+               dbs_data = policy_dbs->dbs_data;
                od_tuners = dbs_data->tuners;
                od_tuners->powersave_bias = default_powersave_bias;
        }