The device profile up_threshold/down_differential only needs to be
initialized once when calling devm_devfreq_add_device. It's unnecessary
to put the data check logic in the hot path (.get_target_freq()) where it
will be called all the time during polling. Instead, we only check and
initialize it one time during DEVFREQ_GOV_START.

This also helps check data validability in advance during DEVFREQ_GOV_START
rather than checking it later when running .get_target_freq().

Signed-off-by: Dong Aisheng <[email protected]>
---
Change Log:
v1->v2:
 * rebase to devfreq-testing
---
 drivers/devfreq/devfreq.c                 | 24 +++++-------------
 drivers/devfreq/governor_simpleondemand.c | 31 +++++++++++++++--------
 2 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
index cacda7d1f858..270e51f5318f 100644
--- a/drivers/devfreq/devfreq.c
+++ b/drivers/devfreq/devfreq.c
@@ -1908,9 +1908,7 @@ static ssize_t up_threshold_show(struct device *dev,
        if (!df->profile)
                return -EINVAL;
 
-       return sprintf(buf, "%d\n", df->profile->up_threshold
-                                       ? df->profile->up_threshold
-                                       : DEVFREQ_UP_THRESHOLD);
+       return sprintf(buf, "%d\n", df->profile->up_threshold);
 }
 
 static ssize_t up_threshold_store(struct device *dev,
@@ -1934,9 +1932,7 @@ static ssize_t up_threshold_store(struct device *dev,
        if (value > 100)
                value = 100;
 
-       down_differential = df->profile->down_differential
-                               ? df->profile->down_differential
-                               : DEVFREQ_DOWN_DIFFERENCTIAL;
+       down_differential = df->profile->down_differential;
        if (value < down_differential)
                value = down_differential;
 
@@ -1961,9 +1957,7 @@ static ssize_t down_differential_show(struct device *dev,
        if (!df->profile)
                return -EINVAL;
 
-       return sprintf(buf, "%d\n", df->profile->down_differential
-                                       ? df->profile->down_differential
-                                       : DEVFREQ_DOWN_DIFFERENCTIAL);
+       return sprintf(buf, "%d\n", df->profile->down_differential);
 }
 
 static ssize_t down_differential_store(struct device *dev,
@@ -1984,9 +1978,7 @@ static ssize_t down_differential_store(struct device *dev,
        if (ret != 1)
                return -EINVAL;
 
-       up_threshold = df->profile->up_threshold
-                               ? df->profile->up_threshold
-                               : DEVFREQ_UP_THRESHOLD;
+       up_threshold = df->profile->up_threshold;
        if (value > up_threshold)
                value = up_threshold;
 
@@ -2113,16 +2105,12 @@ static int devfreq_summary_show(struct seq_file *s, 
void *data)
                        polling_ms = 0;
 
                if (IS_SUPPORTED_ATTR(devfreq->governor->attrs, UP_THRESHOLD))
-                       up_threshold = devfreq->profile->up_threshold
-                                       ? devfreq->profile->up_threshold
-                                       : DEVFREQ_UP_THRESHOLD;
+                       up_threshold = devfreq->profile->up_threshold;
                else
                        up_threshold = 0;
 
                if (IS_SUPPORTED_ATTR(devfreq->governor->attrs, DOWN_DIFF))
-                       down_differential = devfreq->profile->down_differential
-                                       ? devfreq->profile->down_differential
-                                       : DEVFREQ_DOWN_DIFFERENCTIAL;
+                       down_differential = devfreq->profile->down_differential;
                else
                        down_differential = 0;
                mutex_unlock(&devfreq->lock);
diff --git a/drivers/devfreq/governor_simpleondemand.c 
b/drivers/devfreq/governor_simpleondemand.c
index 93f6061667d9..3e195b46554a 100644
--- a/drivers/devfreq/governor_simpleondemand.c
+++ b/drivers/devfreq/governor_simpleondemand.c
@@ -18,8 +18,8 @@ static int devfreq_simple_ondemand_func(struct devfreq *df,
        int err;
        struct devfreq_dev_status *stat;
        unsigned long long a, b;
-       unsigned int dfso_upthreshold = DEVFREQ_UP_THRESHOLD;
-       unsigned int dfso_downdifferential = DEVFREQ_DOWN_DIFFERENCTIAL;
+       unsigned int dfso_upthreshold = df->profile->up_threshold;
+       unsigned int dfso_downdifferential = df->profile->down_differential;
 
        err = devfreq_update_stats(df);
        if (err)
@@ -27,15 +27,6 @@ static int devfreq_simple_ondemand_func(struct devfreq *df,
 
        stat = &df->last_status;
 
-       if (df->profile->up_threshold)
-               dfso_upthreshold = df->profile->up_threshold;
-       if (df->profile->down_differential)
-               dfso_downdifferential = df->profile->down_differential;
-
-       if (dfso_upthreshold > 100 ||
-           dfso_upthreshold < dfso_downdifferential)
-               return -EINVAL;
-
        /* Assume MAX if it is going to be divided by zero */
        if (stat->total_time == 0) {
                *freq = DEVFREQ_MAX_FREQ;
@@ -79,11 +70,29 @@ static int devfreq_simple_ondemand_func(struct devfreq *df,
        return 0;
 }
 
+static int devfreq_simple_ondemand_check_od(struct devfreq *df)
+{
+       if (!df->profile->up_threshold)
+               df->profile->up_threshold = DEVFREQ_UP_THRESHOLD;
+
+       if (!df->profile->down_differential)
+               df->profile->down_differential = DEVFREQ_DOWN_DIFFERENCTIAL;
+
+       if (df->profile->up_threshold > 100 ||
+           df->profile->up_threshold < df->profile->down_differential)
+               return -EINVAL;
+
+       return 0;
+}
+
 static int devfreq_simple_ondemand_handler(struct devfreq *devfreq,
                                unsigned int event, void *data)
 {
        switch (event) {
        case DEVFREQ_GOV_START:
+               if (devfreq_simple_ondemand_check_od(devfreq))
+                       return -EINVAL;
+
                devfreq_monitor_start(devfreq);
                break;
 
-- 
2.25.1

Reply via email to