Skip to contentSkip to conversation

Register an Energy Model for Arm reference platforms

PATCH Superseded Quentin Perret 3 participants 13 messages Jan 30, 2019 – Jan 31, 2019

Subsystems (4)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover Register an Energy Model for Arm reference platforms

The Energy Model (EM) framework feeds interested subsystems (the scheduler/EAS as of now) with power costs provided by drivers. Yet, no driver is actually doing that upstream yet. This series updates a set of CPUFreq drivers in order to register power costs in the EM framework for some of the Arm reference platforms for EAS: Hikey960, Juno and TC2.

The series is split as follows:
- Patch 01 introduces in PM_OPP a helper function which estimates the CPU power using the P=CV²f equation also used by IPA. It should be noted that this introduces duplicate code with IPA, which will eventually be fixed by migrating IPA to using PM_EM. The ideal plan would be to do so later, in a separate patch series. I would indeed prefer to keep the thermal and CPUFreq discussion separate at this stage, if deemed acceptable.
- Patches 02-04 make use of that PM_OPP helper function from the following CPUFreq drivers: cpufreq-dt, scpi-cpufreq and arm_big_little.
- Patch 05 modifies the SCMI cpufreq driver to pass the power costs obtained from firmware to PM_EM. This patch is independent from the rest of the series.

Changes since v1 ([email protected]):
- Dropped the DT patches that have been queued by Sudeep
- Introduced dev_pm_opp_of_register_em() helper to check the presence of the DT coeff before calling PM_EM (Viresh, Matthias)
- Coding-style improvements (Viresh, Matthias)

Thanks,
Quentin

Dietmar Eggemann (1):
cpufreq: arm_big_little: Register an Energy Model

Quentin Perret (4):
PM / OPP: Introduce a power estimation helper
cpufreq: dt: Register an Energy Model
cpufreq: scpi: Register an Energy Model
cpufreq: scmi: Register an Energy Model

 drivers/cpufreq/arm_big_little.c |  8 +++
 drivers/cpufreq/cpufreq-dt.c     |  8 +--
 drivers/cpufreq/scmi-cpufreq.c   | 39 ++++++++++++--
 drivers/cpufreq/scpi-cpufreq.c   |  9 ++--
 drivers/opp/of.c                 | 88 ++++++++++++++++++++++++++++++++
 include/linux/pm_opp.h           |  6 +++
 6 files changed, 149 insertions(+), 9 deletions(-)
Signature · 1 line
2.20.1
#1 lore raw

PATCH v2 1/5 PM / OPP: Introduce a power estimation helper

The Energy Model (EM) framework provides an API to let drivers register the active power of CPUs. The drivers are expected to provide a callback method which estimates the power consumed by a CPU at each available performance levels. How exactly this should be implemented, however, depends on the platform.

On some systems, PM_OPP knows the voltage and frequency at which CPUs can run. When coupled with the CPU 'capacitance' (as provided by the 'dynamic-power-coefficient' devicetree binding), it is possible to estimate the dynamic power consumption of a CPU as P = C * V^2 * f, with C its capacitance and V and f respectively the voltage and frequency of the OPP. The Intelligent Power Allocator (IPA) thermal governor already implements that estimation method, in the thermal framework.

However, this power estimation method can be applied to any platform where all the parameters are known (C, V and f), and not only those suffering thermal issues. As such, the code implementing this feature can be re-used to also populate the EM framework now used by EAS.

As a first step, introduce in PM_OPP a helper function which CPUFreq drivers can use to register into the EM framework. This duplicates the power estimation done in IPA until it can be migrated to using the EM framework. This will be done later, once the EM framework has support for at least all platforms currently supported by IPA.

---

Matthias: Given this patch changed a bit I dropped your Reviewed-by and Tested-by, but let me know if you think they still hold.

---
 drivers/opp/of.c       | 88 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/pm_opp.h |  6 +++
 2 files changed, 94 insertions(+)
drivers/opp/of.c +88 -0
index 06f0f632ec47..4c8bf172e9ed 100644
@@ -20,6 +20,7 @@
 #include <linux/pm_domain.h>
 #include <linux/slab.h>
 #include <linux/export.h>
+#include <linux/energy_model.h>
 
 #include "opp.h"
 
@@ -1047,3 +1048,90 @@ struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 	return of_node_get(opp->np);
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
+
+/*
+ * Callback function provided to the Energy Model framework upon registration.
+ * This computes the power estimated by @CPU at the first OPP above @kHz (ceil),
+ * and updates @kHz and @mW accordingly. The power is estimated as
+ * P = C * V^2 * f with C being the CPU's capacitance and V and f respectively
+ * the voltage and frequency of the OPP.
+ *
+ * Returns -ENODEV if the CPU device cannot be found, -EINVAL if the power
+ * calculation failed because of missing parameters, 0 otherwise.
+ */
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)
+{
+	struct device *cpu_dev;
+	struct dev_pm_opp *opp;
+	struct device_node *np;
+	unsigned long mV, Hz;
+	u32 cap;
+	u64 tmp;
+	int ret;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return -ENODEV;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return -EINVAL;
+
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret)
+		return -EINVAL;
+
+	Hz = *kHz * 1000;
+	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz);
+	if (IS_ERR(opp))
+		return -EINVAL;
+
+	mV = dev_pm_opp_get_voltage(opp) / 1000;
+	dev_pm_opp_put(opp);
+	if (!mV)
+		return -EINVAL;
+
+	tmp = (u64)cap * mV * mV * (Hz / 1000000);
+	do_div(tmp, 1000000000);
+
+	*mW = (unsigned long)tmp;
+	*kHz = Hz / 1000;
+
+	return 0;
+}
+
+/**
+ * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
+ * @cpus	: CPUs for which an Energy Model has to be registered
+ * @nr_opp	: Number of OPPs to register in the Energy Model
+ *
+ * This checks whether the "dynamic-power-coefficient" devicetree binding has
+ * been specified, and tries to register an Energy Model with it if it has.
+ */
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
+{
+	struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power);
+	int ret, cpu = cpumask_first(cpus);
+	struct device *cpu_dev;
+	struct device_node *np;
+	u32 cap;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return;
+
+	/* Don't register an EM without the right DT binding */
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret || !cap)
+		return;
+
+	em_register_perf_domain(cpus, nr_opp, &em_cb);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);
include/linux/pm_opp.h +6 -0
index b895f4e79868..58ae08b024bd 100644
@@ -327,6 +327,7 @@ int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpuma
 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev);
 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp);
 int of_get_required_opp_performance_state(struct device_node *np, int index);
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp);
 #else
 static inline int dev_pm_opp_of_add_table(struct device *dev)
 {
@@ -365,6 +366,11 @@ static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 {
 	return NULL;
 }
+
+static inline void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
+{
+}
+
 static inline int of_get_required_opp_performance_state(struct device_node *np, int index)
 {
 	return -ENOTSUPP;
Signature · 1 line
2.20.1
Tested-by on v2 1/5
#2 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

Hi Quentin,

Quoted 41 lines · Quentin Perret

The Energy Model (EM) framework provides an API to let drivers register the active power of CPUs. The drivers are expected to provide a callback method which estimates the power consumed by a CPU at each available performance levels. How exactly this should be implemented, however, depends on the platform.

On some systems, PM_OPP knows the voltage and frequency at which CPUs can run. When coupled with the CPU 'capacitance' (as provided by the 'dynamic-power-coefficient' devicetree binding), it is possible to estimate the dynamic power consumption of a CPU as P = C * V^2 * f, with C its capacitance and V and f respectively the voltage and frequency of the OPP. The Intelligent Power Allocator (IPA) thermal governor already implements that estimation method, in the thermal framework.

However, this power estimation method can be applied to any platform where all the parameters are known (C, V and f), and not only those suffering thermal issues. As such, the code implementing this feature can be re-used to also populate the EM framework now used by EAS.

As a first step, introduce in PM_OPP a helper function which CPUFreq drivers can use to register into the EM framework. This duplicates the power estimation done in IPA until it can be migrated to using the EM framework. This will be done later, once the EM framework has support for at least all platforms currently supported by IPA.

---

Matthias: Given this patch changed a bit I dropped your Reviewed-by and Tested-by, but let me know if you think they still hold.

---
 drivers/opp/of.c       | 88 ++++++++++++++++++++++++++++++++++++++++++
 include/linux/pm_opp.h |  6 +++
 2 files changed, 94 insertions(+)
drivers/opp/of.c +0 -0
index 06f0f632ec47..4c8bf172e9ed 100644

drivers/opp/of.c line 23

Quoted 4 lines
drivers/opp/of.c +1 -0
@@ -20,6 +20,7 @@
 #include <linux/pm_domain.h>
 #include <linux/slab.h>
 #include <linux/export.h>
+#include <linux/energy_model.h>

nit: AFAIK typically alphabetical order is used for includes, though this file doesn't exactly adhere to it.

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1054

Quoted 10 lines
drivers/opp/of.c +4 -0
 #include "opp.h"
 
@@ -1047,3 +1048,90 @@ struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 	return of_node_get(opp->np);
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
+
+/*
+ * Callback function provided to the Energy Model framework upon registration.
+ * This computes the power estimated by @CPU at the first OPP above @kHz (ceil),

that's not entirely correct, it could be the OPP at @kHz.

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1063

Quoted 9 lines
drivers/opp/of.c +9 -0
+ * and updates @kHz and @mW accordingly. The power is estimated as
+ * P = C * V^2 * f with C being the CPU's capacitance and V and f respectively
+ * the voltage and frequency of the OPP.
+ *
+ * Returns -ENODEV if the CPU device cannot be found, -EINVAL if the power
+ * calculation failed because of missing parameters, 0 otherwise.
+ */
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)

why __maybe_unused?

Quoted 37 lines
drivers/opp/of.c +37 -0
+{
+	struct device *cpu_dev;
+	struct dev_pm_opp *opp;
+	struct device_node *np;
+	unsigned long mV, Hz;
+	u32 cap;
+	u64 tmp;
+	int ret;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return -ENODEV;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return -EINVAL;
+
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret)
+		return -EINVAL;
+
+	Hz = *kHz * 1000;
+	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz);
+	if (IS_ERR(opp))
+		return -EINVAL;
+
+	mV = dev_pm_opp_get_voltage(opp) / 1000;
+	dev_pm_opp_put(opp);
+	if (!mV)
+		return -EINVAL;
+
+	tmp = (u64)cap * mV * mV * (Hz / 1000000);
+	do_div(tmp, 1000000000);
+
+	*mW = (unsigned long)tmp;
+	*kHz = Hz / 1000;

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1110

Quoted 10 lines
drivers/opp/of.c +10 -0
+
+	return 0;
+}
+
+/**
+ * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
+ * @cpus	: CPUs for which an Energy Model has to be registered
+ * @nr_opp	: Number of OPPs to register in the Energy Model
+ *
+ * This checks whether the "dynamic-power-coefficient" devicetree binding has

s/binding/property/ ?

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1113

Quoted 3 lines
drivers/opp/of.c +3 -0
+ * been specified, and tries to register an Energy Model with it if it has.
+ */
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)

Is the nr_opp parameter really needed? The function looks up the CPU device and hence could determine the OPP count itself with dev_pm_opp_get_opp_count(). I see most cpufreq drivers call dev_pm_opp_get_opp_count() anyway, so passing the count as parameter can be considered a small optimization, not sure how relevant it is though, since dev_pm_opp_of_register_em() isn't called frequently.

Quoted 38 lines
drivers/opp/of.c +24 -0
+{
+	struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power);
+	int ret, cpu = cpumask_first(cpus);
+	struct device *cpu_dev;
+	struct device_node *np;
+	u32 cap;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return;
+
+	/* Don't register an EM without the right DT binding */
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret || !cap)
+		return;
+
+	em_register_perf_domain(cpus, nr_opp, &em_cb);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);
include/linux/pm_opp.h +1 -0
index b895f4e79868..58ae08b024bd 100644
@@ -327,6 +327,7 @@ int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpuma
 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev);
 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp);
 int of_get_required_opp_performance_state(struct device_node *np, int index);
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp);
 #else
 static inline int dev_pm_opp_of_add_table(struct device *dev)
 {
@@ -365,6 +366,11 @@ static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 {

include/linux/pm_opp.h static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 376

Quoted 10 lines
include/linux/pm_opp.h +5 -0
 	return NULL;
 }
+
+static inline void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
+{
+}
+
 static inline int of_get_required_opp_performance_state(struct device_node *np, int index)
 {
 	return -ENOTSUPP;
maintainer
#3 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

Quoted 5 lines · Matthias Kaehlcke

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1063

Quoted 2 lines · Quentin Perret
drivers/opp/of.c +2 -0
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)

why __maybe_unused?

Yeah, it isn't required I think. He probably added it for the case where CONFIG_ENERGY_MODEL=n, but even then an inline routine is defined which will accept it as argument and wouldn't do anything with it. Had it been a macro, we would have required __maybe_unused but not now.

Signature · 1 line
viresh
#4 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

Quoted 7 lines · Viresh Kumar
Quoted 5 lines · Matthias Kaehlcke

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1063

Quoted 2 lines · Quentin Perret
drivers/opp/of.c +2 -0
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)

why __maybe_unused?

Quoted 5 lines

Yeah, it isn't required I think. He probably added it for the case where CONFIG_ENERGY_MODEL=n, but even then an inline routine is defined which will accept it as argument and wouldn't do anything with it. Had it been a macro, we would have required __maybe_unused but not now.

The thing is, the EM_DATA_CB() macro _is_ stubbed for CONFIG_ENERGY_MODEL=n:

https://elixir.bootlin.com/linux/v5.0-rc4/source/include/linux/energy_model.h#L165

So, without __maybe_unused you get do get a compiler warning.

Thanks,
Quentin

Quoted 3 lines
Signature · 2 lines
-- 
viresh
maintainer
#5 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

Quoted 14 lines · Quentin Perret
Quoted 7 lines · Viresh Kumar
Quoted 5 lines · Matthias Kaehlcke

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1063

Quoted 2 lines · Quentin Perret
drivers/opp/of.c +2 -0
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)

why __maybe_unused?

Quoted 5 lines

Yeah, it isn't required I think. He probably added it for the case where CONFIG_ENERGY_MODEL=n, but even then an inline routine is defined which will accept it as argument and wouldn't do anything with it. Had it been a macro, we would have required __maybe_unused but not now.

Quoted 6 lines

The thing is, the EM_DATA_CB() macro _is_ stubbed for CONFIG_ENERGY_MODEL=n:

https://elixir.bootlin.com/linux/v5.0-rc4/source/include/linux/energy_model.h#L165

So, without __maybe_unused you get do get a compiler warning.

Yeah, I almost got to it and still missed it :)

Signature · 1 line
viresh
#6 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

In reply to Matthias Kaehlcke

Hi Matthias,

Quoted 4 lines · Matthias Kaehlcke
Quoted 4 lines
drivers/opp/of.c +0 -0
index 06f0f632ec47..4c8bf172e9ed 100644
Quoted 8 lines

drivers/opp/of.c line 23

Quoted 5 lines
drivers/opp/of.c +1 -0
@@ -20,6 +20,7 @@
 #include <linux/pm_domain.h>
 #include <linux/slab.h>
 #include <linux/export.h>
+#include <linux/energy_model.h>

nit: AFAIK typically alphabetical order is used for includes, though this file doesn't exactly adhere to it.

Yeah that's what I was thinking too. Since nothing is in order here I figured there wasn't a best place to put it so I just stick it there. I happy to re-order all of them if necessary.

Quoted 13 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1054

Quoted 11 lines
drivers/opp/of.c +4 -0
 #include "opp.h"
 
@@ -1047,3 +1048,90 @@ struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 	return of_node_get(opp->np);
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
+
+/*
+ * Callback function provided to the Energy Model framework upon registration.
+ * This computes the power estimated by @CPU at the first OPP above @kHz (ceil),

that's not entirely correct, it could be the OPP at @kHz.

Right, I'll update that.

Quoted 12 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1063

Quoted 10 lines
drivers/opp/of.c +9 -0
+ * and updates @kHz and @mW accordingly. The power is estimated as
+ * P = C * V^2 * f with C being the CPU's capacitance and V and f respectively
+ * the voltage and frequency of the OPP.
+ *
+ * Returns -ENODEV if the CPU device cannot be found, -EINVAL if the power
+ * calculation failed because of missing parameters, 0 otherwise.
+ */
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)

why __maybe_unused?

To avoid compiler warnings with CONFIG_ENERGY_MODEL=n, see my other email ;-)

Quoted 41 lines
Quoted 41 lines
drivers/opp/of.c +41 -0
+{
+	struct device *cpu_dev;
+	struct dev_pm_opp *opp;
+	struct device_node *np;
+	unsigned long mV, Hz;
+	u32 cap;
+	u64 tmp;
+	int ret;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return -ENODEV;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return -EINVAL;
+
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret)
+		return -EINVAL;
+
+	Hz = *kHz * 1000;
+	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz);
+	if (IS_ERR(opp))
+		return -EINVAL;
+
+	mV = dev_pm_opp_get_voltage(opp) / 1000;
+	dev_pm_opp_put(opp);
+	if (!mV)
+		return -EINVAL;
+
+	tmp = (u64)cap * mV * mV * (Hz / 1000000);
+	do_div(tmp, 1000000000);
+
+	*mW = (unsigned long)tmp;
+	*kHz = Hz / 1000;
+
+	return 0;
+}
+
Quoted 8 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1110

Quoted 6 lines
drivers/opp/of.c +6 -0
+/**
+ * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
+ * @cpus	: CPUs for which an Energy Model has to be registered
+ * @nr_opp	: Number of OPPs to register in the Energy Model
+ *
+ * This checks whether the "dynamic-power-coefficient" devicetree binding has

s/binding/property/ ?

Sounds good.

Quoted 11 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1113

Quoted 4 lines
drivers/opp/of.c +3 -0
+ * been specified, and tries to register an Energy Model with it if it has.
+ */
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)

Is the nr_opp parameter really needed? The function looks up the CPU device and hence could determine the OPP count itself with dev_pm_opp_get_opp_count(). I see most cpufreq drivers call dev_pm_opp_get_opp_count() anyway, so passing the count as parameter can be considered a small optimization, not sure how relevant it is though, since dev_pm_opp_of_register_em() isn't called frequently.

Yeah, I figured since most callers of dev_pm_opp_of_register_em() already counted the OPPs, I could as well use the data instead of counting again. I mean, dev_pm_opp_get_count() has to traverse the whole list every time, so there is no point in doing that twice. Not a huge deal I guess.

Quoted 43 lines
Quoted 43 lines
drivers/opp/of.c +24 -0
+{
+	struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power);
+	int ret, cpu = cpumask_first(cpus);
+	struct device *cpu_dev;
+	struct device_node *np;
+	u32 cap;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return;
+
+	/* Don't register an EM without the right DT binding */
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret || !cap)
+		return;
+
+	em_register_perf_domain(cpus, nr_opp, &em_cb);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);
include/linux/pm_opp.h +3 -0
index b895f4e79868..58ae08b024bd 100644
@@ -327,6 +327,7 @@ int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpuma
 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev);
 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp);
 int of_get_required_opp_performance_state(struct device_node *np, int index);
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp);
 #else
 static inline int dev_pm_opp_of_add_table(struct device *dev)
 {
@@ -365,6 +366,11 @@ static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 {
 	return NULL;
 }
+
+static inline void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
Quoted 8 lines

include/linux/pm_opp.h static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 376

Quoted 6 lines
include/linux/pm_opp.h +3 -0
+{
+}
+
 static inline int of_get_required_opp_performance_state(struct device_node *np, int index)
 {
 	return -ENOTSUPP;

Thank you very much !
Quentin

maintainer
#7 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

In reply to Quentin Perret
Quoted 20 lines · Quentin Perret
drivers/opp/of.c +20 -0
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)
+{
+	struct device *cpu_dev;
+	struct dev_pm_opp *opp;
+	struct device_node *np;
+	unsigned long mV, Hz;
+	u32 cap;
+	u64 tmp;
+	int ret;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return -ENODEV;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return -EINVAL;
+
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1091

Quoted 10 lines
drivers/opp/of.c +10 -0
+	of_node_put(np);
+	if (ret)
+		return -EINVAL;
+
+	Hz = *kHz * 1000;
+	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz);
+	if (IS_ERR(opp))
+		return -EINVAL;
+
+	mV = dev_pm_opp_get_voltage(opp) / 1000;

The voltage is also stored as triplet now a days and we must consider the higher value for these calculations. Also what about the case of multiple regulators here or performance-states ?

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1099

Quoted 8 lines
drivers/opp/of.c +8 -0
+	dev_pm_opp_put(opp);
+	if (!mV)
+		return -EINVAL;
+
+	tmp = (u64)cap * mV * mV * (Hz / 1000000);
+	do_div(tmp, 1000000000);
+
+	*mW = (unsigned long)tmp;

I was thinking will it be better if we just save this information in opp->power field during init, so we can just read a value here instead. But I am still not sure :(

Quoted 24 lines
drivers/opp/of.c +24 -0
+	*kHz = Hz / 1000;
+
+	return 0;
+}
+
+/**
+ * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
+ * @cpus	: CPUs for which an Energy Model has to be registered
+ * @nr_opp	: Number of OPPs to register in the Energy Model
+ *
+ * This checks whether the "dynamic-power-coefficient" devicetree binding has
+ * been specified, and tries to register an Energy Model with it if it has.
+ */
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
+{
+	struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power);
+	int ret, cpu = cpumask_first(cpus);
+	struct device *cpu_dev;
+	struct device_node *np;
+	u32 cap;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return;

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1133

Quoted 10 lines
drivers/opp/of.c +10 -0
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return;
+
+	/* Don't register an EM without the right DT binding */
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret || !cap)
+		return;

What if no voltage is supplied in DT ?

Quoted 30 lines
drivers/opp/of.c +4 -0
+
+	em_register_perf_domain(cpus, nr_opp, &em_cb);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);
include/linux/pm_opp.h +6 -0
index b895f4e79868..58ae08b024bd 100644
@@ -327,6 +327,7 @@ int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpuma
 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev);
 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp);
 int of_get_required_opp_performance_state(struct device_node *np, int index);
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp);
 #else
 static inline int dev_pm_opp_of_add_table(struct device *dev)
 {
@@ -365,6 +366,11 @@ static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 {
 	return NULL;
 }
+
+static inline void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
+{
+}
+
 static inline int of_get_required_opp_performance_state(struct device_node *np, int index)
 {
 	return -ENOTSUPP;
Signature · 1 line
2.20.1
Signature · 1 line
viresh
#8 lore raw

Re: [PATCH v2 1/5] PM / OPP: Introduce a power estimation helper

Quoted 27 lines · Viresh Kumar
Quoted 26 lines · Quentin Perret
drivers/opp/of.c +26 -0
+static int __maybe_unused _get_cpu_power(unsigned long *mW, unsigned long *kHz,
+					 int cpu)
+{
+	struct device *cpu_dev;
+	struct dev_pm_opp *opp;
+	struct device_node *np;
+	unsigned long mV, Hz;
+	u32 cap;
+	u64 tmp;
+	int ret;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return -ENODEV;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return -EINVAL;
+
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret)
+		return -EINVAL;
+
+	Hz = *kHz * 1000;
+	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &Hz);
Quoted 8 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1091

Quoted 4 lines
drivers/opp/of.c +4 -0
+	if (IS_ERR(opp))
+		return -EINVAL;
+
+	mV = dev_pm_opp_get_voltage(opp) / 1000;

The voltage is also stored as triplet now a days and we must consider the higher value for these calculations. Also what about the case of multiple regulators here or performance-states ?

Well at least this is not worst than what we already do for IPA :-)

https://elixir.bootlin.com/linux/latest/source/drivers/thermal/cpu_cooling.c#L245

In the case of multiple regulators, then maybe that should be dealt with at the dev_pm_op_get_voltage() ? Not sure.

Quoted 13 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1099

Quoted 9 lines
drivers/opp/of.c +8 -0
+	dev_pm_opp_put(opp);
+	if (!mV)
+		return -EINVAL;
+
+	tmp = (u64)cap * mV * mV * (Hz / 1000000);
+	do_div(tmp, 1000000000);
+
+	*mW = (unsigned long)tmp;

I was thinking will it be better if we just save this information in opp->power field during init, so we can just read a value here instead. But I am still not sure :(

Yeah, I had the exact same question. But, then I thought, we're only gonna use that once, so it's not clear we need to cache the value. And I don't think we want other subsystems to ask PM_OPP for power values directly. Those subsystems should ask the EM framework instead (which exists for that very reason). So we're probably not gonna expose a dev_pm_opp_get_power() accessor or so, I think.

That's why I went that way.

Quoted 29 lines
Quoted 29 lines
drivers/opp/of.c +28 -0
+	*kHz = Hz / 1000;
+
+	return 0;
+}
+
+/**
+ * dev_pm_opp_of_register_em() - Attempt to register an Energy Model
+ * @cpus	: CPUs for which an Energy Model has to be registered
+ * @nr_opp	: Number of OPPs to register in the Energy Model
+ *
+ * This checks whether the "dynamic-power-coefficient" devicetree binding has
+ * been specified, and tries to register an Energy Model with it if it has.
+ */
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
+{
+	struct em_data_callback em_cb = EM_DATA_CB(_get_cpu_power);
+	int ret, cpu = cpumask_first(cpus);
+	struct device *cpu_dev;
+	struct device_node *np;
+	u32 cap;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev)
+		return;
+
+	np = of_node_get(cpu_dev->of_node);
+	if (!np)
+		return;
Quoted 8 lines

drivers/opp/of.c struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp) · line 1133

Quoted 6 lines
drivers/opp/of.c +6 -0
+
+	/* Don't register an EM without the right DT binding */
+	ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap);
+	of_node_put(np);
+	if (ret || !cap)
+		return;

What if no voltage is supplied in DT ?

Then don't provide 'dynamic-power-coefficient' ? There is nothing you can do with that without voltages I think.

With this implementation you'll get an error message at some point, which is probably sane.

Quoted 23 lines
Quoted 23 lines
drivers/opp/of.c +4 -0
+
+	em_register_perf_domain(cpus, nr_opp, &em_cb);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);
include/linux/pm_opp.h +3 -0
index b895f4e79868..58ae08b024bd 100644
@@ -327,6 +327,7 @@ int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpuma
 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev);
 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp);
 int of_get_required_opp_performance_state(struct device_node *np, int index);
+void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp);
 #else
 static inline int dev_pm_opp_of_add_table(struct device *dev)
 {
@@ -365,6 +366,11 @@ static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 {
 	return NULL;
 }
+
+static inline void dev_pm_opp_of_register_em(struct cpumask *cpus, int nr_opp)
Quoted 11 lines
Quoted 8 lines
include/linux/pm_opp.h +3 -0
+{
+}
+
 static inline int of_get_required_opp_performance_state(struct device_node *np, int index)
 {
 	return -ENOTSUPP;
Signature · 1 line
2.20.1
Signature · 1 line
viresh

Thanks,
Quentin

#9 lore raw

PATCH v2 2/5 cpufreq: dt: Register an Energy Model

In reply to Quentin Perret

Now that PM_OPP provides a helper function to estimate the power consumed by CPUs, make sure to try and register an Energy Model (EM) from cpufreq-dt, hence ensuring interested subsystems (the task scheduler, for example) can make use of that information when available.

---
 drivers/cpufreq/cpufreq-dt.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
drivers/cpufreq/cpufreq-dt.c +5 -3
index e58bfcb1169e..1d4ad6f67408 100644
@@ -160,7 +160,7 @@ static int cpufreq_init(struct cpufreq_policy *policy)
 	unsigned int transition_latency;
 	bool fallback = false;
 	const char *name;
-	int ret;
+	int ret, nr_opp;
 
 	cpu_dev = get_cpu_device(policy->cpu);
 	if (!cpu_dev) {
@@ -231,8 +231,8 @@ static int cpufreq_init(struct cpufreq_policy *policy)
 	 * But we need OPP table to function so if it is not there let's
 	 * give platform code chance to provide it for us.
 	 */
-	ret = dev_pm_opp_get_opp_count(cpu_dev);
-	if (ret <= 0) {
+	nr_opp = dev_pm_opp_get_opp_count(cpu_dev);
+	if (nr_opp <= 0) {
 		dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
 		ret = -EPROBE_DEFER;
 		goto out_free_opp;
@@ -280,6 +280,8 @@ static int cpufreq_init(struct cpufreq_policy *policy)
 	policy->cpuinfo.transition_latency = transition_latency;
 	policy->dvfs_possible_from_any_cpu = true;
 
+	dev_pm_opp_of_register_em(policy->cpus, nr_opp);
+
 	return 0;
 
 out_free_cpufreq_table:
Signature · 1 line
2.20.1
#10 lore raw

PATCH v2 3/5 cpufreq: scpi: Register an Energy Model

In reply to Quentin Perret

Now that PM_OPP provides a helper function to estimate the power consumed by CPUs, make sure to try and register an Energy Model (EM) from scpi-cpufreq, hence ensuring interested subsystems (the task scheduler, for example) can make use of that information when available.

---
 drivers/cpufreq/scpi-cpufreq.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)
drivers/cpufreq/scpi-cpufreq.c +6 -3
index 99449738faa4..8e77a67a8d8c 100644
@@ -98,7 +98,7 @@ scpi_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask)
 
 static int scpi_cpufreq_init(struct cpufreq_policy *policy)
 {
-	int ret;
+	int ret, nr_opp;
 	unsigned int latency;
 	struct device *cpu_dev;
 	struct scpi_data *priv;
@@ -129,8 +129,8 @@ static int scpi_cpufreq_init(struct cpufreq_policy *policy)
 		return ret;
 	}
 
-	ret = dev_pm_opp_get_opp_count(cpu_dev);
-	if (ret <= 0) {
+	nr_opp = dev_pm_opp_get_opp_count(cpu_dev);
+	if (nr_opp <= 0) {
 		dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
 		ret = -EPROBE_DEFER;
 		goto out_free_opp;
@@ -170,6 +170,9 @@ static int scpi_cpufreq_init(struct cpufreq_policy *policy)
 	policy->cpuinfo.transition_latency = latency;
 
 	policy->fast_switch_possible = false;
+
+	dev_pm_opp_of_register_em(policy->cpus, nr_opp);
+
 	return 0;
 
 out_free_cpufreq_table:
Signature · 1 line
2.20.1
#11 lore raw

PATCH v2 4/5 cpufreq: arm_big_little: Register an Energy Model

In reply to Quentin Perret

From: Dietmar Eggemann <[email protected]>

Now that PM_OPP provides a helper function to estimate the power consumed by CPUs, make sure to try and register an Energy Model (EM) from the arm_big_little CPUFreq driver, hence ensuring interested subsystems (the task scheduler, for example) can make use of that information when available.

---
 drivers/cpufreq/arm_big_little.c | 8 ++++++++
 1 file changed, 8 insertions(+)
drivers/cpufreq/arm_big_little.c +8 -0
index cf62a1f64dd7..18b05bcb2614 100644
@@ -487,6 +487,14 @@ static int bL_cpufreq_init(struct cpufreq_policy *policy)
 	policy->cpuinfo.transition_latency =
 				arm_bL_ops->get_transition_latency(cpu_dev);
 
+	ret = dev_pm_opp_get_opp_count(cpu_dev);
+	if (ret <= 0) {
+		dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
+		return -EPROBE_DEFER;
+	}
+
+	dev_pm_opp_of_register_em(policy->cpus, ret);
+
 	if (is_bL_switching_enabled())
 		per_cpu(cpu_last_req_freq, policy->cpu) = clk_get_cpu_rate(policy->cpu);
 
Signature · 1 line
2.20.1
#12 lore raw

PATCH v2 5/5 cpufreq: scmi: Register an Energy Model

In reply to Quentin Perret

The Energy Model (EM) framework provides an API to register the active power of CPUs. Call this API from the scmi-cpufreq driver by using the power costs obtained from firmware. This is done to ensure interested subsystems (the task scheduler, for example) can make use of the EM when available.

---
 drivers/cpufreq/scmi-cpufreq.c | 39 +++++++++++++++++++++++++++++++---
 1 file changed, 36 insertions(+), 3 deletions(-)
drivers/cpufreq/scmi-cpufreq.c +36 -3
index 242c3370544e..0d87e1433296 100644
@@ -12,6 +12,7 @@
 #include <linux/cpufreq.h>
 #include <linux/cpumask.h>
 #include <linux/cpu_cooling.h>
+#include <linux/energy_model.h>
 #include <linux/export.h>
 #include <linux/module.h>
 #include <linux/pm_opp.h>
@@ -103,13 +104,42 @@ scmi_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask)
 	return 0;
 }
 
+static int __maybe_unused
+scmi_get_cpu_power(unsigned long *power, unsigned long *KHz, int cpu)
+{
+	struct device *cpu_dev = get_cpu_device(cpu);
+	unsigned long Hz;
+	int ret, domain;
+
+	if (!cpu_dev) {
+		pr_err("failed to get cpu%d device\n", cpu);
+		return -ENODEV;
+	}
+
+	domain = handle->perf_ops->device_domain_id(cpu_dev);
+	if (domain < 0)
+		return domain;
+
+	/* Get the power cost of the performance domain. */
+	Hz = *KHz * 1000;
+	ret = handle->perf_ops->est_power_get(handle, domain, &Hz, power);
+	if (ret)
+		return ret;
+
+	/* The EM framework specifies the frequency in KHz. */
+	*KHz = Hz / 1000;
+
+	return 0;
+}
+
 static int scmi_cpufreq_init(struct cpufreq_policy *policy)
 {
-	int ret;
+	int ret, nr_opp;
 	unsigned int latency;
 	struct device *cpu_dev;
 	struct scmi_data *priv;
 	struct cpufreq_frequency_table *freq_table;
+	struct em_data_callback em_cb = EM_DATA_CB(scmi_get_cpu_power);
 
 	cpu_dev = get_cpu_device(policy->cpu);
 	if (!cpu_dev) {
@@ -136,8 +166,8 @@ static int scmi_cpufreq_init(struct cpufreq_policy *policy)
 		return ret;
 	}
 
-	ret = dev_pm_opp_get_opp_count(cpu_dev);
-	if (ret <= 0) {
+	nr_opp = dev_pm_opp_get_opp_count(cpu_dev);
+	if (nr_opp <= 0) {
 		dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
 		ret = -EPROBE_DEFER;
 		goto out_free_opp;
@@ -171,6 +201,9 @@ static int scmi_cpufreq_init(struct cpufreq_policy *policy)
 	policy->cpuinfo.transition_latency = latency;
 
 	policy->fast_switch_possible = true;
+
+	em_register_perf_domain(policy->cpus, nr_opp, &em_cb);
+
 	return 0;
 
 out_free_priv:
Signature · 1 line
2.20.1