2 files changed, 68 insertions, 15 deletions

diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index 3fffad3bc8a8..90128be27712 100644
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -13,6 +13,7 @@
 
 #include "sched.h"
 
+#include <linux/sched/cpufreq.h>
 #include <trace/events/power.h>
 
 struct sugov_tunables {
@@ -167,7 +168,7 @@ static unsigned int get_next_freq(struct sugov_policy *sg_policy,
         unsigned int freq = arch_scale_freq_invariant() ?
                                 policy->cpuinfo.max_freq : policy->cur;
 
-        freq = (freq + (freq >> 2)) * util / max;
+        freq = map_util_freq(util, freq, max);
 
         if (freq == sg_policy->cached_raw_freq && !sg_policy->need_freq_update)
                 return sg_policy->next_freq;
@@ -197,15 +198,13 @@ static unsigned int get_next_freq(struct sugov_policy *sg_policy,
  * based on the task model parameters and gives the minimal utilization
  * required to meet deadlines.
  */
-static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
+unsigned long schedutil_freq_util(int cpu, unsigned long util_cfs,
+                                  unsigned long max, enum schedutil_type type)
 {
-        struct rq *rq = cpu_rq(sg_cpu->cpu);
-        unsigned long util, irq, max;
+        unsigned long dl_util, util, irq;
+        struct rq *rq = cpu_rq(cpu);
 
-        sg_cpu->max = max = arch_scale_cpu_capacity(NULL, sg_cpu->cpu);
-        sg_cpu->bw_dl = cpu_bw_dl(rq);
-
-        if (rt_rq_is_runnable(&rq->rt))
+        if (type == FREQUENCY_UTIL && rt_rq_is_runnable(&rq->rt))
                 return max;
 
         /*
@@ -223,22 +222,31 @@ static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
          * utilization (PELT windows are synchronized) we can directly add them
          * to obtain the CPU's actual utilization.
          */
-        util = cpu_util_cfs(rq);
+        util = util_cfs;
         util += cpu_util_rt(rq);
 
+        dl_util = cpu_util_dl(rq);
+
         /*
-         * We do not make cpu_util_dl() a permanent part of this sum because we
-         * want to use cpu_bw_dl() later on, but we need to check if the
-         * CFS+RT+DL sum is saturated (ie. no idle time) such that we select
-         * f_max when there is no idle time.
+         * For frequency selection we do not make cpu_util_dl() a permanent part
+         * of this sum because we want to use cpu_bw_dl() later on, but we need
+         * to check if the CFS+RT+DL sum is saturated (ie. no idle time) such
+         * that we select f_max when there is no idle time.
          *
          * NOTE: numerical errors or stop class might cause us to not quite hit
          * saturation when we should -- something for later.
          */
-        if ((util + cpu_util_dl(rq)) >= max)
+        if (util + dl_util >= max)
                 return max;
 
         /*
+         * OTOH, for energy computation we need the estimated running time, so
+         * include util_dl and ignore dl_bw.
+         */
+        if (type == ENERGY_UTIL)
+                util += dl_util;
+
+        /*
          * There is still idle time; further improve the number by using the
          * irq metric. Because IRQ/steal time is hidden from the task clock we
          * need to scale the task numbers:
@@ -260,7 +268,22 @@ static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
          * bw_dl as requested freq. However, cpufreq is not yet ready for such
          * an interface. So, we only do the latter for now.
          */
-        return min(max, util + sg_cpu->bw_dl);
+        if (type == FREQUENCY_UTIL)
+                util += cpu_bw_dl(rq);
+
+        return min(max, util);
+}
+
+static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
+{
+        struct rq *rq = cpu_rq(sg_cpu->cpu);
+        unsigned long util = cpu_util_cfs(rq);
+        unsigned long max = arch_scale_cpu_capacity(NULL, sg_cpu->cpu);
+
+        sg_cpu->max = max;
+        sg_cpu->bw_dl = cpu_bw_dl(rq);
+
+        return schedutil_freq_util(sg_cpu->cpu, util, max, FREQUENCY_UTIL);
 }
 
 /**
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 66067152a831..2eafa228aebf 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -2191,6 +2191,31 @@ static inline void cpufreq_update_util(struct rq *rq, unsigned int flags) {}
 #endif
 
 #ifdef CONFIG_CPU_FREQ_GOV_SCHEDUTIL
+/**
+ * enum schedutil_type - CPU utilization type
+ * @FREQUENCY_UTIL:     Utilization used to select frequency
+ * @ENERGY_UTIL:        Utilization used during energy calculation
+ *
+ * The utilization signals of all scheduling classes (CFS/RT/DL) and IRQ time
+ * need to be aggregated differently depending on the usage made of them. This
+ * enum is used within schedutil_freq_util() to differentiate the types of
+ * utilization expected by the callers, and adjust the aggregation accordingly.
+ */
+enum schedutil_type {
+        FREQUENCY_UTIL,
+        ENERGY_UTIL,
+};
+
+unsigned long schedutil_freq_util(int cpu, unsigned long util_cfs,
+                                  unsigned long max, enum schedutil_type type);
+
+static inline unsigned long schedutil_energy_util(int cpu, unsigned long cfs)
+{
+        unsigned long max = arch_scale_cpu_capacity(NULL, cpu);
+
+        return schedutil_freq_util(cpu, cfs, max, ENERGY_UTIL);
+}
+
 static inline unsigned long cpu_bw_dl(struct rq *rq)
 {
         return (rq->dl.running_bw * SCHED_CAPACITY_SCALE) >> BW_SHIFT;
@@ -2217,6 +2242,11 @@ static inline unsigned long cpu_util_rt(struct rq *rq)
 {
         return READ_ONCE(rq->avg_rt.util_avg);
 }
+#else /* CONFIG_CPU_FREQ_GOV_SCHEDUTIL */
+static inline unsigned long schedutil_energy_util(int cpu, unsigned long cfs)
+{
+        return cfs;
+}
 #endif
 
 #ifdef CONFIG_HAVE_SCHED_AVG_IRQ