target/linux/mediatek/patches-5.15/350-05-cpufreq-mediatek-Replace-old_-with-pre_.patch

   1 From 35832d9f9c5c1da01420d962dc56e7e61d104829 Mon Sep 17 00:00:00 2001
   2 From: Rex-BC Chen <rex-bc.chen@mediatek.com>
   3 Date: Fri, 22 Apr 2022 15:52:28 +0800
   4 Subject: [PATCH 05/21] cpufreq: mediatek: Replace old_* with pre_*
   5
   6 To make driver more readable, replace old_* with pre_*.
   7
   8 Signed-off-by: Rex-BC Chen <rex-bc.chen@mediatek.com>
   9 Reviewed-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
  10 Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
  11 ---
  12  drivers/cpufreq/mediatek-cpufreq.c | 84 +++++++++++++++---------------
  13  1 file changed, 42 insertions(+), 42 deletions(-)
  14
  15 --- a/drivers/cpufreq/mediatek-cpufreq.c
  16 +++ b/drivers/cpufreq/mediatek-cpufreq.c
  17 @@ -63,18 +63,18 @@ static int mtk_cpufreq_voltage_tracking(
  18  {
  19         struct regulator *proc_reg = info->proc_reg;
  20         struct regulator *sram_reg = info->sram_reg;
  21 -       int old_vproc, old_vsram, new_vsram, vsram, vproc, ret;
  22 +       int pre_vproc, pre_vsram, new_vsram, vsram, vproc, ret;
  23
  24 -       old_vproc = regulator_get_voltage(proc_reg);
  25 -       if (old_vproc < 0) {
  26 +       pre_vproc = regulator_get_voltage(proc_reg);
  27 +       if (pre_vproc < 0) {
  28                 dev_err(info->cpu_dev,
  29 -                       "invalid Vproc value: %d\n", old_vproc);
  30 -               return old_vproc;
  31 +                       "invalid Vproc value: %d\n", pre_vproc);
  32 +               return pre_vproc;
  33         }
  34         /* Vsram should not exceed the maximum allowed voltage of SoC. */
  35         new_vsram = min(new_vproc + MIN_VOLT_SHIFT, MAX_VOLT_LIMIT);
  36
  37 -       if (old_vproc < new_vproc) {
  38 +       if (pre_vproc < new_vproc) {
  39                 /*
  40                  * When scaling up voltages, Vsram and Vproc scale up step
  41                  * by step. At each step, set Vsram to (Vproc + 200mV) first,
  42 @@ -82,20 +82,20 @@ static int mtk_cpufreq_voltage_tracking(
  43                  * Keep doing it until Vsram and Vproc hit target voltages.
  44                  */
  45                 do {
  46 -                       old_vsram = regulator_get_voltage(sram_reg);
  47 -                       if (old_vsram < 0) {
  48 +                       pre_vsram = regulator_get_voltage(sram_reg);
  49 +                       if (pre_vsram < 0) {
  50                                 dev_err(info->cpu_dev,
  51 -                                       "invalid Vsram value: %d\n", old_vsram);
  52 -                               return old_vsram;
  53 +                                       "invalid Vsram value: %d\n", pre_vsram);
  54 +                               return pre_vsram;
  55                         }
  56 -                       old_vproc = regulator_get_voltage(proc_reg);
  57 -                       if (old_vproc < 0) {
  58 +                       pre_vproc = regulator_get_voltage(proc_reg);
  59 +                       if (pre_vproc < 0) {
  60                                 dev_err(info->cpu_dev,
  61 -                                       "invalid Vproc value: %d\n", old_vproc);
  62 -                               return old_vproc;
  63 +                                       "invalid Vproc value: %d\n", pre_vproc);
  64 +                               return pre_vproc;
  65                         }
  66
  67 -                       vsram = min(new_vsram, old_vproc + MAX_VOLT_SHIFT);
  68 +                       vsram = min(new_vsram, pre_vproc + MAX_VOLT_SHIFT);
  69
  70                         if (vsram + VOLT_TOL >= MAX_VOLT_LIMIT) {
  71                                 vsram = MAX_VOLT_LIMIT;
  72 @@ -124,12 +124,12 @@ static int mtk_cpufreq_voltage_tracking(
  73                         ret = regulator_set_voltage(proc_reg, vproc,
  74                                                     vproc + VOLT_TOL);
  75                         if (ret) {
  76 -                               regulator_set_voltage(sram_reg, old_vsram,
  77 -                                                     old_vsram);
  78 +                               regulator_set_voltage(sram_reg, pre_vsram,
  79 +                                                     pre_vsram);
  80                                 return ret;
  81                         }
  82                 } while (vproc < new_vproc || vsram < new_vsram);
  83 -       } else if (old_vproc > new_vproc) {
  84 +       } else if (pre_vproc > new_vproc) {
  85                 /*
  86                  * When scaling down voltages, Vsram and Vproc scale down step
  87                  * by step. At each step, set Vproc to (Vsram - 200mV) first,
  88 @@ -137,20 +137,20 @@ static int mtk_cpufreq_voltage_tracking(
  89                  * Keep doing it until Vsram and Vproc hit target voltages.
  90                  */
  91                 do {
  92 -                       old_vproc = regulator_get_voltage(proc_reg);
  93 -                       if (old_vproc < 0) {
  94 +                       pre_vproc = regulator_get_voltage(proc_reg);
  95 +                       if (pre_vproc < 0) {
  96                                 dev_err(info->cpu_dev,
  97 -                                       "invalid Vproc value: %d\n", old_vproc);
  98 -                               return old_vproc;
  99 +                                       "invalid Vproc value: %d\n", pre_vproc);
 100 +                               return pre_vproc;
 101                         }
 102 -                       old_vsram = regulator_get_voltage(sram_reg);
 103 -                       if (old_vsram < 0) {
 104 +                       pre_vsram = regulator_get_voltage(sram_reg);
 105 +                       if (pre_vsram < 0) {
 106                                 dev_err(info->cpu_dev,
 107 -                                       "invalid Vsram value: %d\n", old_vsram);
 108 -                               return old_vsram;
 109 +                                       "invalid Vsram value: %d\n", pre_vsram);
 110 +                               return pre_vsram;
 111                         }
 112
 113 -                       vproc = max(new_vproc, old_vsram - MAX_VOLT_SHIFT);
 114 +                       vproc = max(new_vproc, pre_vsram - MAX_VOLT_SHIFT);
 115                         ret = regulator_set_voltage(proc_reg, vproc,
 116                                                     vproc + VOLT_TOL);
 117                         if (ret)
 118 @@ -180,8 +180,8 @@ static int mtk_cpufreq_voltage_tracking(
 119                         }
 120
 121                         if (ret) {
 122 -                               regulator_set_voltage(proc_reg, old_vproc,
 123 -                                                     old_vproc);
 124 +                               regulator_set_voltage(proc_reg, pre_vproc,
 125 +                                                     pre_vproc);
 126                                 return ret;
 127                         }
 128                 } while (vproc > new_vproc + VOLT_TOL ||
 129 @@ -209,16 +209,16 @@ static int mtk_cpufreq_set_target(struct
 130         struct mtk_cpu_dvfs_info *info = policy->driver_data;
 131         struct device *cpu_dev = info->cpu_dev;
 132         struct dev_pm_opp *opp;
 133 -       long freq_hz, old_freq_hz;
 134 -       int vproc, old_vproc, inter_vproc, target_vproc, ret;
 135 +       long freq_hz, pre_freq_hz;
 136 +       int vproc, pre_vproc, inter_vproc, target_vproc, ret;
 137
 138         inter_vproc = info->intermediate_voltage;
 139
 140 -       old_freq_hz = clk_get_rate(cpu_clk);
 141 -       old_vproc = regulator_get_voltage(info->proc_reg);
 142 -       if (old_vproc < 0) {
 143 -               dev_err(cpu_dev, "invalid Vproc value: %d\n", old_vproc);
 144 -               return old_vproc;
 145 +       pre_freq_hz = clk_get_rate(cpu_clk);
 146 +       pre_vproc = regulator_get_voltage(info->proc_reg);
 147 +       if (pre_vproc < 0) {
 148 +               dev_err(cpu_dev, "invalid Vproc value: %d\n", pre_vproc);
 149 +               return pre_vproc;
 150         }
 151
 152         freq_hz = freq_table[index].frequency * 1000;
 153 @@ -237,12 +237,12 @@ static int mtk_cpufreq_set_target(struct
 154          * current voltage, scale up voltage first.
 155          */
 156         target_vproc = (inter_vproc > vproc) ? inter_vproc : vproc;
 157 -       if (old_vproc < target_vproc) {
 158 +       if (pre_vproc < target_vproc) {
 159                 ret = mtk_cpufreq_set_voltage(info, target_vproc);
 160                 if (ret) {
 161                         dev_err(cpu_dev,
 162                                 "cpu%d: failed to scale up voltage!\n", policy->cpu);
 163 -                       mtk_cpufreq_set_voltage(info, old_vproc);
 164 +                       mtk_cpufreq_set_voltage(info, pre_vproc);
 165                         return ret;
 166                 }
 167         }
 168 @@ -252,7 +252,7 @@ static int mtk_cpufreq_set_target(struct
 169         if (ret) {
 170                 dev_err(cpu_dev,
 171                         "cpu%d: failed to re-parent cpu clock!\n", policy->cpu);
 172 -               mtk_cpufreq_set_voltage(info, old_vproc);
 173 +               mtk_cpufreq_set_voltage(info, pre_vproc);
 174                 WARN_ON(1);
 175                 return ret;
 176         }
 177 @@ -263,7 +263,7 @@ static int mtk_cpufreq_set_target(struct
 178                 dev_err(cpu_dev,
 179                         "cpu%d: failed to scale cpu clock rate!\n", policy->cpu);
 180                 clk_set_parent(cpu_clk, armpll);
 181 -               mtk_cpufreq_set_voltage(info, old_vproc);
 182 +               mtk_cpufreq_set_voltage(info, pre_vproc);
 183                 return ret;
 184         }
 185
 186 @@ -281,13 +281,13 @@ static int mtk_cpufreq_set_target(struct
 187          * If the new voltage is lower than the intermediate voltage or the
 188          * original voltage, scale down to the new voltage.
 189          */
 190 -       if (vproc < inter_vproc || vproc < old_vproc) {
 191 +       if (vproc < inter_vproc || vproc < pre_vproc) {
 192                 ret = mtk_cpufreq_set_voltage(info, vproc);
 193                 if (ret) {
 194                         dev_err(cpu_dev,
 195                                 "cpu%d: failed to scale down voltage!\n", policy->cpu);
 196                         clk_set_parent(cpu_clk, info->inter_clk);
 197 -                       clk_set_rate(armpll, old_freq_hz);
 198 +                       clk_set_rate(armpll, pre_freq_hz);
 199                         clk_set_parent(cpu_clk, armpll);
 200                         return ret;
 201                 }