cpufreq: powernv: Replacing pstate_id with frequency table index

Refactoring code to use frequency table index instead of pstate_id.
This abstraction will make the code independent of the pstate values.

- No functional changes
- The highest frequency is at frequency table index 0 and the frequency
  decreases as the index increases.
- Macros pstates_to_idx() and idx_to_pstate() can be used for conversion
  between pstate_id and index.
- powernv_pstate_info now contains frequency table index to min, max and
  nominal frequency (instead of pstate_ids)
- global_pstate_info new stores index values instead pstate ids.
- variables renamed as *_idx which now store index instead of pstate

Signed-off-by: Akshay Adiga <akshay.adiga@linux.vnet.ibm.com>
Reviewed-by: Gautham R. Shenoy <ego@linux.vnet.ibm.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

diff --git a/drivers/cpufreq/powernv-cpufreq.c b/drivers/cpufreq/powernv-cpufreq.c
index 2a2920c..0f138b0 100644 (file)
--- a/drivers/cpufreq/powernv-cpufreq.c
+++ b/drivers/cpufreq/powernv-cpufreq.c
@@ -64,12 +64,14 @@
 /**
  * struct global_pstate_info - Per policy data structure to maintain history of
  *                             global pstates
- * @highest_lpstate:           The local pstate from which we are ramping down
+ * @highest_lpstate_idx:       The local pstate index from which we are
+ *                             ramping down
  * @elapsed_time:              Time in ms spent in ramping down from
- *                             highest_lpstate
+ *                             highest_lpstate_idx
  * @last_sampled_time:         Time from boot in ms when global pstates were
  *                             last set
- * @last_lpstate,last_gpstate: Last set values for local and global pstates
+ * @last_lpstate_idx,          Last set value of local pstate and global
+ * last_gpstate_idx            pstate in terms of cpufreq table index
  * @timer:                     Is used for ramping down if cpu goes idle for
  *                             a long time with global pstate held high
  * @gpstate_lock:              A spinlock to maintain synchronization between
@@ -77,11 +79,11 @@
  *                             governer's target_index calls
  */
 struct global_pstate_info {
-       int highest_lpstate;
+       int highest_lpstate_idx;
        unsigned int elapsed_time;
        unsigned int last_sampled_time;
-       int last_lpstate;
-       int last_gpstate;
+       int last_lpstate_idx;
+       int last_gpstate_idx;
        spinlock_t gpstate_lock;
        struct timer_list timer;
 };
@@ -124,29 +126,47 @@ static int nr_chips;
 static DEFINE_PER_CPU(struct chip *, chip_info);
 
 /*
- * Note: The set of pstates consists of contiguous integers, the
- * smallest of which is indicated by powernv_pstate_info.min, the
- * largest of which is indicated by powernv_pstate_info.max.
+ * Note:
+ * The set of pstates consists of contiguous integers.
+ * powernv_pstate_info stores the index of the frequency table for
+ * max, min and nominal frequencies. It also stores number of
+ * available frequencies.
  *
- * The nominal pstate is the highest non-turbo pstate in this
- * platform. This is indicated by powernv_pstate_info.nominal.
+ * powernv_pstate_info.nominal indicates the index to the highest
+ * non-turbo frequency.
  */
 static struct powernv_pstate_info {
-       int min;
-       int max;
-       int nominal;
-       int nr_pstates;
+       unsigned int min;
+       unsigned int max;
+       unsigned int nominal;
+       unsigned int nr_pstates;
 } powernv_pstate_info;
 
+/* Use following macros for conversions between pstate_id and index */
+static inline int idx_to_pstate(unsigned int i)
+{
+       return powernv_freqs[i].driver_data;
+}
+
+static inline unsigned int pstate_to_idx(int pstate)
+{
+       /*
+        * abs() is deliberately used so that is works with
+        * both monotonically increasing and decreasing
+        * pstate values
+        */
+       return abs(pstate - idx_to_pstate(powernv_pstate_info.max));
+}
+
 static inline void reset_gpstates(struct cpufreq_policy *policy)
 {
        struct global_pstate_info *gpstates = policy->driver_data;
 
-       gpstates->highest_lpstate = 0;
+       gpstates->highest_lpstate_idx = 0;
        gpstates->elapsed_time = 0;
        gpstates->last_sampled_time = 0;
-       gpstates->last_lpstate = 0;
-       gpstates->last_gpstate = 0;
+       gpstates->last_lpstate_idx = 0;
+       gpstates->last_gpstate_idx = 0;
 }
 
 /*
@@ -156,9 +176,10 @@ static inline void reset_gpstates(struct cpufreq_policy *policy)
 static int init_powernv_pstates(void)
 {
        struct device_node *power_mgt;
-       int i, pstate_min, pstate_max, pstate_nominal, nr_pstates = 0;
+       int i, nr_pstates = 0;
        const __be32 *pstate_ids, *pstate_freqs;
        u32 len_ids, len_freqs;
+       u32 pstate_min, pstate_max, pstate_nominal;
 
        power_mgt = of_find_node_by_path("/ibm,opal/power-mgt");
        if (!power_mgt) {
@@ -208,6 +229,7 @@ static int init_powernv_pstates(void)
                return -ENODEV;
        }
 
+       powernv_pstate_info.nr_pstates = nr_pstates;
        pr_debug("NR PStates %d\n", nr_pstates);
        for (i = 0; i < nr_pstates; i++) {
                u32 id = be32_to_cpu(pstate_ids[i]);
@@ -216,15 +238,17 @@ static int init_powernv_pstates(void)
                pr_debug("PState id %d freq %d MHz\n", id, freq);
                powernv_freqs[i].frequency = freq * 1000; /* kHz */
                powernv_freqs[i].driver_data = id;
+
+               if (id == pstate_max)
+                       powernv_pstate_info.max = i;
+               else if (id == pstate_nominal)
+                       powernv_pstate_info.nominal = i;
+               else if (id == pstate_min)
+                       powernv_pstate_info.min = i;
        }
+
        /* End of list marker entry */
        powernv_freqs[i].frequency = CPUFREQ_TABLE_END;
-
-       powernv_pstate_info.min = pstate_min;
-       powernv_pstate_info.max = pstate_max;
-       powernv_pstate_info.nominal = pstate_nominal;
-       powernv_pstate_info.nr_pstates = nr_pstates;
-
        return 0;
 }
 
@@ -233,12 +257,12 @@ static unsigned int pstate_id_to_freq(int pstate_id)
 {
        int i;
 
-       i = powernv_pstate_info.max - pstate_id;
+       i = pstate_to_idx(pstate_id);
        if (i >= powernv_pstate_info.nr_pstates || i < 0) {
                pr_warn("PState id %d outside of PState table, "
                        "reporting nominal id %d instead\n",
-                       pstate_id, powernv_pstate_info.nominal);
-               i = powernv_pstate_info.max - powernv_pstate_info.nominal;
+                       pstate_id, idx_to_pstate(powernv_pstate_info.nominal));
+               i = powernv_pstate_info.nominal;
        }
 
        return powernv_freqs[i].frequency;
@@ -252,7 +276,7 @@ static ssize_t cpuinfo_nominal_freq_show(struct cpufreq_policy *policy,
                                        char *buf)
 {
        return sprintf(buf, "%u\n",
-               pstate_id_to_freq(powernv_pstate_info.nominal));
+               powernv_freqs[powernv_pstate_info.nominal].frequency);
 }
 
 struct freq_attr cpufreq_freq_attr_cpuinfo_nominal_freq =
@@ -426,7 +450,7 @@ static void set_pstate(void *data)
  */
 static inline unsigned int get_nominal_index(void)
 {
-       return powernv_pstate_info.max - powernv_pstate_info.nominal;
+       return powernv_pstate_info.nominal;
 }
 
 static void powernv_cpufreq_throttle_check(void *data)
@@ -435,20 +459,22 @@ static void powernv_cpufreq_throttle_check(void *data)
        unsigned int cpu = smp_processor_id();
        unsigned long pmsr;
        int pmsr_pmax;
+       unsigned int pmsr_pmax_idx;
 
        pmsr = get_pmspr(SPRN_PMSR);
        chip = this_cpu_read(chip_info);
 
        /* Check for Pmax Capping */
        pmsr_pmax = (s8)PMSR_MAX(pmsr);
-       if (pmsr_pmax != powernv_pstate_info.max) {
+       pmsr_pmax_idx = pstate_to_idx(pmsr_pmax);
+       if (pmsr_pmax_idx != powernv_pstate_info.max) {
                if (chip->throttled)
                        goto next;
                chip->throttled = true;
-               if (pmsr_pmax < powernv_pstate_info.nominal) {
-                       pr_warn_once("CPU %d on Chip %u has Pmax reduced below nominal frequency (%d < %d)\n",
+               if (pmsr_pmax_idx > powernv_pstate_info.nominal) {
+                       pr_warn_once("CPU %d on Chip %u has Pmax(%d) reduced below nominal frequency(%d)\n",
                                     cpu, chip->id, pmsr_pmax,
-                                    powernv_pstate_info.nominal);
+                                    idx_to_pstate(powernv_pstate_info.nominal));
                        chip->throttle_sub_turbo++;
                } else {
                        chip->throttle_turbo++;
@@ -484,34 +510,35 @@ next:
 
 /**
  * calc_global_pstate - Calculate global pstate
- * @elapsed_time:      Elapsed time in milliseconds
- * @local_pstate:      New local pstate
- * @highest_lpstate:   pstate from which its ramping down
+ * @elapsed_time:              Elapsed time in milliseconds
+ * @local_pstate_idx:          New local pstate
+ * @highest_lpstate_idx:       pstate from which its ramping down
  *
  * Finds the appropriate global pstate based on the pstate from which its
  * ramping down and the time elapsed in ramping down. It follows a quadratic
  * equation which ensures that it reaches ramping down to pmin in 5sec.
  */
 static inline int calc_global_pstate(unsigned int elapsed_time,
-                                    int highest_lpstate, int local_pstate)
+                                    int highest_lpstate_idx,
+                                    int local_pstate_idx)
 {
-       int pstate_diff;
+       int index_diff;
 
        /*
         * Using ramp_down_percent we get the percentage of rampdown
         * that we are expecting to be dropping. Difference between
-        * highest_lpstate and powernv_pstate_info.min will give a absolute
+        * highest_lpstate_idx and powernv_pstate_info.min will give a absolute
         * number of how many pstates we will drop eventually by the end of
         * 5 seconds, then just scale it get the number pstates to be dropped.
         */
-       pstate_diff =  ((int)ramp_down_percent(elapsed_time) *
-                       (highest_lpstate - powernv_pstate_info.min)) / 100;
+       index_diff =  ((int)ramp_down_percent(elapsed_time) *
+                       (powernv_pstate_info.min - highest_lpstate_idx)) / 100;
 
        /* Ensure that global pstate is >= to local pstate */
-       if (highest_lpstate - pstate_diff < local_pstate)
-               return local_pstate;
+       if (highest_lpstate_idx + index_diff >= local_pstate_idx)
+               return local_pstate_idx;
        else
-               return highest_lpstate - pstate_diff;
+               return highest_lpstate_idx + index_diff;
 }
 
 static inline void  queue_gpstate_timer(struct global_pstate_info *gpstates)
@@ -547,7 +574,7 @@ void gpstate_timer_handler(unsigned long data)
 {
        struct cpufreq_policy *policy = (struct cpufreq_policy *)data;
        struct global_pstate_info *gpstates = policy->driver_data;
-       int gpstate_id;
+       int gpstate_idx;
        unsigned int time_diff = jiffies_to_msecs(jiffies)
                                        - gpstates->last_sampled_time;
        struct powernv_smp_call_data freq_data;
@@ -557,29 +584,29 @@ void gpstate_timer_handler(unsigned long data)
 
        gpstates->last_sampled_time += time_diff;
        gpstates->elapsed_time += time_diff;
-       freq_data.pstate_id = gpstates->last_lpstate;
+       freq_data.pstate_id = idx_to_pstate(gpstates->last_lpstate_idx);
 
-       if ((gpstates->last_gpstate == freq_data.pstate_id) ||
+       if ((gpstates->last_gpstate_idx == gpstates->last_lpstate_idx) ||
            (gpstates->elapsed_time > MAX_RAMP_DOWN_TIME)) {
-               gpstate_id = freq_data.pstate_id;
+               gpstate_idx = pstate_to_idx(freq_data.pstate_id);
                reset_gpstates(policy);
-               gpstates->highest_lpstate = freq_data.pstate_id;
+               gpstates->highest_lpstate_idx = gpstate_idx;
        } else {
-               gpstate_id = calc_global_pstate(gpstates->elapsed_time,
-                                               gpstates->highest_lpstate,
-                                               freq_data.pstate_id);
+               gpstate_idx = calc_global_pstate(gpstates->elapsed_time,
+                                                gpstates->highest_lpstate_idx,
+                                                freq_data.pstate_id);
        }
 
        /*
         * If local pstate is equal to global pstate, rampdown is over
         * So timer is not required to be queued.
         */
-       if (gpstate_id != freq_data.pstate_id)
+       if (gpstate_idx != gpstates->last_lpstate_idx)
                queue_gpstate_timer(gpstates);
 
-       freq_data.gpstate_id = gpstate_id;
-       gpstates->last_gpstate = freq_data.gpstate_id;
-       gpstates->last_lpstate = freq_data.pstate_id;
+       freq_data.gpstate_id = idx_to_pstate(gpstate_idx);
+       gpstates->last_gpstate_idx = pstate_to_idx(freq_data.gpstate_id);
+       gpstates->last_lpstate_idx = pstate_to_idx(freq_data.pstate_id);
 
        spin_unlock(&gpstates->gpstate_lock);
 
@@ -596,7 +623,7 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy,
                                        unsigned int new_index)
 {
        struct powernv_smp_call_data freq_data;
-       unsigned int cur_msec, gpstate_id;
+       unsigned int cur_msec, gpstate_idx;
        struct global_pstate_info *gpstates = policy->driver_data;
 
        if (unlikely(rebooting) && new_index != get_nominal_index())
@@ -608,15 +635,15 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy,
        cur_msec = jiffies_to_msecs(get_jiffies_64());
 
        spin_lock(&gpstates->gpstate_lock);
-       freq_data.pstate_id = powernv_freqs[new_index].driver_data;
+       freq_data.pstate_id = idx_to_pstate(new_index);
 
        if (!gpstates->last_sampled_time) {
-               gpstate_id = freq_data.pstate_id;
-               gpstates->highest_lpstate = freq_data.pstate_id;
+               gpstate_idx = new_index;
+               gpstates->highest_lpstate_idx = new_index;
                goto gpstates_done;
        }
 
-       if (gpstates->last_gpstate > freq_data.pstate_id) {
+       if (gpstates->last_gpstate_idx < new_index) {
                gpstates->elapsed_time += cur_msec -
                                                 gpstates->last_sampled_time;
 
@@ -627,34 +654,34 @@ static int powernv_cpufreq_target_index(struct cpufreq_policy *policy,
                 */
                if (gpstates->elapsed_time > MAX_RAMP_DOWN_TIME) {
                        reset_gpstates(policy);
-                       gpstates->highest_lpstate = freq_data.pstate_id;
-                       gpstate_id = freq_data.pstate_id;
+                       gpstates->highest_lpstate_idx = new_index;
+                       gpstate_idx = new_index;
                } else {
                /* Elaspsed_time is less than 5 seconds, continue to rampdown */
-                       gpstate_id = calc_global_pstate(gpstates->elapsed_time,
-                                                       gpstates->highest_lpstate,
-                                                       freq_data.pstate_id);
+                       gpstate_idx = calc_global_pstate(gpstates->elapsed_time,
+                                                        gpstates->highest_lpstate_idx,
+                                                        new_index);
                }
        } else {
                reset_gpstates(policy);
-               gpstates->highest_lpstate = freq_data.pstate_id;
-               gpstate_id = freq_data.pstate_id;
+               gpstates->highest_lpstate_idx = new_index;
+               gpstate_idx = new_index;
        }
 
        /*
         * If local pstate is equal to global pstate, rampdown is over
         * So timer is not required to be queued.
         */
-       if (gpstate_id != freq_data.pstate_id)
+       if (gpstate_idx != new_index)
                queue_gpstate_timer(gpstates);
        else
                del_timer_sync(&gpstates->timer);
 
 gpstates_done:
-       freq_data.gpstate_id = gpstate_id;
+       freq_data.gpstate_id = idx_to_pstate(gpstate_idx);
        gpstates->last_sampled_time = cur_msec;
-       gpstates->last_gpstate = freq_data.gpstate_id;
-       gpstates->last_lpstate = freq_data.pstate_id;
+       gpstates->last_gpstate_idx = gpstate_idx;
+       gpstates->last_lpstate_idx = new_index;
 
        spin_unlock(&gpstates->gpstate_lock);
 
@@ -846,8 +873,8 @@ static void powernv_cpufreq_stop_cpu(struct cpufreq_policy *policy)
        struct powernv_smp_call_data freq_data;
        struct global_pstate_info *gpstates = policy->driver_data;
 
-       freq_data.pstate_id = powernv_pstate_info.min;
-       freq_data.gpstate_id = powernv_pstate_info.min;
+       freq_data.pstate_id = idx_to_pstate(powernv_pstate_info.min);
+       freq_data.gpstate_id = idx_to_pstate(powernv_pstate_info.min);
        smp_call_function_single(policy->cpu, set_pstate, &freq_data, 1);
        del_timer_sync(&gpstates->timer);
 }