Merge tag 'dmaengine-4.8-rc1' of git://git.infradead.org/users/vkoul/slave-dma

[deliverable/linux.git] / drivers / cpufreq / cpufreq_ondemand.c

diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index acd80272ded67b46ad651cb0eceb92bdf71e26d7..3a1f49f5f4c68ae4d360e686773cafc2d49b8745 100644 (file)
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -65,34 +65,30 @@ static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy,
 {
        unsigned int freq_req, freq_reduc, freq_avg;
        unsigned int freq_hi, freq_lo;
-       unsigned int index = 0;
+       unsigned int index;
        unsigned int delay_hi_us;
        struct policy_dbs_info *policy_dbs = policy->governor_data;
        struct od_policy_dbs_info *dbs_info = to_dbs_info(policy_dbs);
        struct dbs_data *dbs_data = policy_dbs->dbs_data;
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
+       struct cpufreq_frequency_table *freq_table = policy->freq_table;
 
-       if (!dbs_info->freq_table) {
+       if (!freq_table) {
                dbs_info->freq_lo = 0;
                dbs_info->freq_lo_delay_us = 0;
                return freq_next;
        }
 
-       cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_next,
-                       relation, &index);
-       freq_req = dbs_info->freq_table[index].frequency;
+       index = cpufreq_frequency_table_target(policy, freq_next, relation);
+       freq_req = freq_table[index].frequency;
        freq_reduc = freq_req * od_tuners->powersave_bias / 1000;
        freq_avg = freq_req - freq_reduc;
 
        /* Find freq bounds for freq_avg in freq_table */
-       index = 0;
-       cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
-                       CPUFREQ_RELATION_H, &index);
-       freq_lo = dbs_info->freq_table[index].frequency;
-       index = 0;
-       cpufreq_frequency_table_target(policy, dbs_info->freq_table, freq_avg,
-                       CPUFREQ_RELATION_L, &index);
-       freq_hi = dbs_info->freq_table[index].frequency;
+       index = cpufreq_table_find_index_h(policy, freq_avg);
+       freq_lo = freq_table[index].frequency;
+       index = cpufreq_table_find_index_l(policy, freq_avg);
+       freq_hi = freq_table[index].frequency;
 
        /* Find out how long we have to be in hi and lo freqs */
        if (freq_hi == freq_lo) {
@@ -113,7 +109,6 @@ static void ondemand_powersave_bias_init(struct cpufreq_policy *policy)
 {
        struct od_policy_dbs_info *dbs_info = to_dbs_info(policy->governor_data);
 
-       dbs_info->freq_table = cpufreq_frequency_get_table(policy->cpu);
        dbs_info->freq_lo = 0;
 }
 
@@ -207,9 +202,10 @@ static unsigned int od_dbs_timer(struct cpufreq_policy *policy)
 /************************** sysfs interface ************************/
 static struct dbs_governor od_dbs_gov;
 
-static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf,
-               size_t count)
+static ssize_t store_io_is_busy(struct gov_attr_set *attr_set, const char *buf,
+                               size_t count)
 {
+       struct dbs_data *dbs_data = to_dbs_data(attr_set);
        unsigned int input;
        int ret;
 
@@ -224,9 +220,10 @@ static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf,
        return count;
 }
 
-static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf,
-               size_t count)
+static ssize_t store_up_threshold(struct gov_attr_set *attr_set,
+                                 const char *buf, size_t count)
 {
+       struct dbs_data *dbs_data = to_dbs_data(attr_set);
        unsigned int input;
        int ret;
        ret = sscanf(buf, "%u", &input);
@@ -240,9 +237,10 @@ static ssize_t store_up_threshold(struct dbs_data *dbs_data, const char *buf,
        return count;
 }
 
-static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data,
-               const char *buf, size_t count)
+static ssize_t store_sampling_down_factor(struct gov_attr_set *attr_set,
+                                         const char *buf, size_t count)
 {
+       struct dbs_data *dbs_data = to_dbs_data(attr_set);
        struct policy_dbs_info *policy_dbs;
        unsigned int input;
        int ret;
@@ -254,7 +252,7 @@ static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data,
        dbs_data->sampling_down_factor = input;
 
        /* Reset down sampling multiplier in case it was active */
-       list_for_each_entry(policy_dbs, &dbs_data->policy_dbs_list, list) {
+       list_for_each_entry(policy_dbs, &attr_set->policy_list, list) {
                /*
                 * Doing this without locking might lead to using different
                 * rate_mult values in od_update() and od_dbs_timer().
@@ -267,9 +265,10 @@ static ssize_t store_sampling_down_factor(struct dbs_data *dbs_data,
        return count;
 }
 
-static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data,
-               const char *buf, size_t count)
+static ssize_t store_ignore_nice_load(struct gov_attr_set *attr_set,
+                                     const char *buf, size_t count)
 {
+       struct dbs_data *dbs_data = to_dbs_data(attr_set);
        unsigned int input;
        int ret;
 
@@ -291,9 +290,10 @@ static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data,
        return count;
 }
 
-static ssize_t store_powersave_bias(struct dbs_data *dbs_data, const char *buf,
-               size_t count)
+static ssize_t store_powersave_bias(struct gov_attr_set *attr_set,
+                                   const char *buf, size_t count)
 {
+       struct dbs_data *dbs_data = to_dbs_data(attr_set);
        struct od_dbs_tuners *od_tuners = dbs_data->tuners;
        struct policy_dbs_info *policy_dbs;
        unsigned int input;
@@ -308,7 +308,7 @@ static ssize_t store_powersave_bias(struct dbs_data *dbs_data, const char *buf,
 
        od_tuners->powersave_bias = input;
 
-       list_for_each_entry(policy_dbs, &dbs_data->policy_dbs_list, list)
+       list_for_each_entry(policy_dbs, &attr_set->policy_list, list)
                ondemand_powersave_bias_init(policy_dbs->policy);
 
        return count;
@@ -356,17 +356,15 @@ static void od_free(struct policy_dbs_info *policy_dbs)
        kfree(to_dbs_info(policy_dbs));
 }
 
-static int od_init(struct dbs_data *dbs_data, bool notify)
+static int od_init(struct dbs_data *dbs_data)
 {
        struct od_dbs_tuners *tuners;
        u64 idle_time;
        int cpu;
 
        tuners = kzalloc(sizeof(*tuners), GFP_KERNEL);
-       if (!tuners) {
-               pr_err("%s: kzalloc failed\n", __func__);
+       if (!tuners)
                return -ENOMEM;
-       }
 
        cpu = get_cpu();
        idle_time = get_cpu_idle_time_us(cpu, NULL);
@@ -397,7 +395,7 @@ static int od_init(struct dbs_data *dbs_data, bool notify)
        return 0;
 }
 
-static void od_exit(struct dbs_data *dbs_data, bool notify)
+static void od_exit(struct dbs_data *dbs_data)
 {
        kfree(dbs_data->tuners);
 }
@@ -415,12 +413,7 @@ static struct od_ops od_ops = {
 };
 
 static struct dbs_governor od_dbs_gov = {
-       .gov = {
-               .name = "ondemand",
-               .governor = cpufreq_governor_dbs,
-               .max_transition_latency = TRANSITION_LATENCY_LIMIT,
-               .owner = THIS_MODULE,
-       },
+       .gov = CPUFREQ_DBS_GOVERNOR_INITIALIZER("ondemand"),
        .kobj_type = { .default_attrs = od_attributes },
        .gov_dbs_timer = od_dbs_timer,
        .alloc = od_alloc,