mirror of
https://github.com/openwrt/openwrt.git
synced 2024-12-22 06:57:57 +00:00
670dedbbd7
Backport cpufreq changes from upstream so that the MediaTek MT7988 SoC
can be supported.
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
(cherry picked from commit e4555d69a1)
202 lines
6.8 KiB
Diff
202 lines
6.8 KiB
Diff
From 35832d9f9c5c1da01420d962dc56e7e61d104829 Mon Sep 17 00:00:00 2001
|
|
From: Rex-BC Chen <rex-bc.chen@mediatek.com>
|
|
Date: Fri, 22 Apr 2022 15:52:28 +0800
|
|
Subject: [PATCH 05/21] cpufreq: mediatek: Replace old_* with pre_*
|
|
|
|
To make driver more readable, replace old_* with pre_*.
|
|
|
|
Signed-off-by: Rex-BC Chen <rex-bc.chen@mediatek.com>
|
|
Reviewed-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
|
|
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
|
|
---
|
|
drivers/cpufreq/mediatek-cpufreq.c | 84 +++++++++++++++---------------
|
|
1 file changed, 42 insertions(+), 42 deletions(-)
|
|
|
|
--- a/drivers/cpufreq/mediatek-cpufreq.c
|
|
+++ b/drivers/cpufreq/mediatek-cpufreq.c
|
|
@@ -63,18 +63,18 @@ static int mtk_cpufreq_voltage_tracking(
|
|
{
|
|
struct regulator *proc_reg = info->proc_reg;
|
|
struct regulator *sram_reg = info->sram_reg;
|
|
- int old_vproc, old_vsram, new_vsram, vsram, vproc, ret;
|
|
+ int pre_vproc, pre_vsram, new_vsram, vsram, vproc, ret;
|
|
|
|
- old_vproc = regulator_get_voltage(proc_reg);
|
|
- if (old_vproc < 0) {
|
|
+ pre_vproc = regulator_get_voltage(proc_reg);
|
|
+ if (pre_vproc < 0) {
|
|
dev_err(info->cpu_dev,
|
|
- "invalid Vproc value: %d\n", old_vproc);
|
|
- return old_vproc;
|
|
+ "invalid Vproc value: %d\n", pre_vproc);
|
|
+ return pre_vproc;
|
|
}
|
|
/* Vsram should not exceed the maximum allowed voltage of SoC. */
|
|
new_vsram = min(new_vproc + MIN_VOLT_SHIFT, MAX_VOLT_LIMIT);
|
|
|
|
- if (old_vproc < new_vproc) {
|
|
+ if (pre_vproc < new_vproc) {
|
|
/*
|
|
* When scaling up voltages, Vsram and Vproc scale up step
|
|
* by step. At each step, set Vsram to (Vproc + 200mV) first,
|
|
@@ -82,20 +82,20 @@ static int mtk_cpufreq_voltage_tracking(
|
|
* Keep doing it until Vsram and Vproc hit target voltages.
|
|
*/
|
|
do {
|
|
- old_vsram = regulator_get_voltage(sram_reg);
|
|
- if (old_vsram < 0) {
|
|
+ pre_vsram = regulator_get_voltage(sram_reg);
|
|
+ if (pre_vsram < 0) {
|
|
dev_err(info->cpu_dev,
|
|
- "invalid Vsram value: %d\n", old_vsram);
|
|
- return old_vsram;
|
|
+ "invalid Vsram value: %d\n", pre_vsram);
|
|
+ return pre_vsram;
|
|
}
|
|
- old_vproc = regulator_get_voltage(proc_reg);
|
|
- if (old_vproc < 0) {
|
|
+ pre_vproc = regulator_get_voltage(proc_reg);
|
|
+ if (pre_vproc < 0) {
|
|
dev_err(info->cpu_dev,
|
|
- "invalid Vproc value: %d\n", old_vproc);
|
|
- return old_vproc;
|
|
+ "invalid Vproc value: %d\n", pre_vproc);
|
|
+ return pre_vproc;
|
|
}
|
|
|
|
- vsram = min(new_vsram, old_vproc + MAX_VOLT_SHIFT);
|
|
+ vsram = min(new_vsram, pre_vproc + MAX_VOLT_SHIFT);
|
|
|
|
if (vsram + VOLT_TOL >= MAX_VOLT_LIMIT) {
|
|
vsram = MAX_VOLT_LIMIT;
|
|
@@ -124,12 +124,12 @@ static int mtk_cpufreq_voltage_tracking(
|
|
ret = regulator_set_voltage(proc_reg, vproc,
|
|
vproc + VOLT_TOL);
|
|
if (ret) {
|
|
- regulator_set_voltage(sram_reg, old_vsram,
|
|
- old_vsram);
|
|
+ regulator_set_voltage(sram_reg, pre_vsram,
|
|
+ pre_vsram);
|
|
return ret;
|
|
}
|
|
} while (vproc < new_vproc || vsram < new_vsram);
|
|
- } else if (old_vproc > new_vproc) {
|
|
+ } else if (pre_vproc > new_vproc) {
|
|
/*
|
|
* When scaling down voltages, Vsram and Vproc scale down step
|
|
* by step. At each step, set Vproc to (Vsram - 200mV) first,
|
|
@@ -137,20 +137,20 @@ static int mtk_cpufreq_voltage_tracking(
|
|
* Keep doing it until Vsram and Vproc hit target voltages.
|
|
*/
|
|
do {
|
|
- old_vproc = regulator_get_voltage(proc_reg);
|
|
- if (old_vproc < 0) {
|
|
+ pre_vproc = regulator_get_voltage(proc_reg);
|
|
+ if (pre_vproc < 0) {
|
|
dev_err(info->cpu_dev,
|
|
- "invalid Vproc value: %d\n", old_vproc);
|
|
- return old_vproc;
|
|
+ "invalid Vproc value: %d\n", pre_vproc);
|
|
+ return pre_vproc;
|
|
}
|
|
- old_vsram = regulator_get_voltage(sram_reg);
|
|
- if (old_vsram < 0) {
|
|
+ pre_vsram = regulator_get_voltage(sram_reg);
|
|
+ if (pre_vsram < 0) {
|
|
dev_err(info->cpu_dev,
|
|
- "invalid Vsram value: %d\n", old_vsram);
|
|
- return old_vsram;
|
|
+ "invalid Vsram value: %d\n", pre_vsram);
|
|
+ return pre_vsram;
|
|
}
|
|
|
|
- vproc = max(new_vproc, old_vsram - MAX_VOLT_SHIFT);
|
|
+ vproc = max(new_vproc, pre_vsram - MAX_VOLT_SHIFT);
|
|
ret = regulator_set_voltage(proc_reg, vproc,
|
|
vproc + VOLT_TOL);
|
|
if (ret)
|
|
@@ -180,8 +180,8 @@ static int mtk_cpufreq_voltage_tracking(
|
|
}
|
|
|
|
if (ret) {
|
|
- regulator_set_voltage(proc_reg, old_vproc,
|
|
- old_vproc);
|
|
+ regulator_set_voltage(proc_reg, pre_vproc,
|
|
+ pre_vproc);
|
|
return ret;
|
|
}
|
|
} while (vproc > new_vproc + VOLT_TOL ||
|
|
@@ -209,16 +209,16 @@ static int mtk_cpufreq_set_target(struct
|
|
struct mtk_cpu_dvfs_info *info = policy->driver_data;
|
|
struct device *cpu_dev = info->cpu_dev;
|
|
struct dev_pm_opp *opp;
|
|
- long freq_hz, old_freq_hz;
|
|
- int vproc, old_vproc, inter_vproc, target_vproc, ret;
|
|
+ long freq_hz, pre_freq_hz;
|
|
+ int vproc, pre_vproc, inter_vproc, target_vproc, ret;
|
|
|
|
inter_vproc = info->intermediate_voltage;
|
|
|
|
- old_freq_hz = clk_get_rate(cpu_clk);
|
|
- old_vproc = regulator_get_voltage(info->proc_reg);
|
|
- if (old_vproc < 0) {
|
|
- dev_err(cpu_dev, "invalid Vproc value: %d\n", old_vproc);
|
|
- return old_vproc;
|
|
+ pre_freq_hz = clk_get_rate(cpu_clk);
|
|
+ pre_vproc = regulator_get_voltage(info->proc_reg);
|
|
+ if (pre_vproc < 0) {
|
|
+ dev_err(cpu_dev, "invalid Vproc value: %d\n", pre_vproc);
|
|
+ return pre_vproc;
|
|
}
|
|
|
|
freq_hz = freq_table[index].frequency * 1000;
|
|
@@ -237,12 +237,12 @@ static int mtk_cpufreq_set_target(struct
|
|
* current voltage, scale up voltage first.
|
|
*/
|
|
target_vproc = (inter_vproc > vproc) ? inter_vproc : vproc;
|
|
- if (old_vproc < target_vproc) {
|
|
+ if (pre_vproc < target_vproc) {
|
|
ret = mtk_cpufreq_set_voltage(info, target_vproc);
|
|
if (ret) {
|
|
dev_err(cpu_dev,
|
|
"cpu%d: failed to scale up voltage!\n", policy->cpu);
|
|
- mtk_cpufreq_set_voltage(info, old_vproc);
|
|
+ mtk_cpufreq_set_voltage(info, pre_vproc);
|
|
return ret;
|
|
}
|
|
}
|
|
@@ -252,7 +252,7 @@ static int mtk_cpufreq_set_target(struct
|
|
if (ret) {
|
|
dev_err(cpu_dev,
|
|
"cpu%d: failed to re-parent cpu clock!\n", policy->cpu);
|
|
- mtk_cpufreq_set_voltage(info, old_vproc);
|
|
+ mtk_cpufreq_set_voltage(info, pre_vproc);
|
|
WARN_ON(1);
|
|
return ret;
|
|
}
|
|
@@ -263,7 +263,7 @@ static int mtk_cpufreq_set_target(struct
|
|
dev_err(cpu_dev,
|
|
"cpu%d: failed to scale cpu clock rate!\n", policy->cpu);
|
|
clk_set_parent(cpu_clk, armpll);
|
|
- mtk_cpufreq_set_voltage(info, old_vproc);
|
|
+ mtk_cpufreq_set_voltage(info, pre_vproc);
|
|
return ret;
|
|
}
|
|
|
|
@@ -281,13 +281,13 @@ static int mtk_cpufreq_set_target(struct
|
|
* If the new voltage is lower than the intermediate voltage or the
|
|
* original voltage, scale down to the new voltage.
|
|
*/
|
|
- if (vproc < inter_vproc || vproc < old_vproc) {
|
|
+ if (vproc < inter_vproc || vproc < pre_vproc) {
|
|
ret = mtk_cpufreq_set_voltage(info, vproc);
|
|
if (ret) {
|
|
dev_err(cpu_dev,
|
|
"cpu%d: failed to scale down voltage!\n", policy->cpu);
|
|
clk_set_parent(cpu_clk, info->inter_clk);
|
|
- clk_set_rate(armpll, old_freq_hz);
|
|
+ clk_set_rate(armpll, pre_freq_hz);
|
|
clk_set_parent(cpu_clk, armpll);
|
|
return ret;
|
|
}
|