Skip to contentSkip to conversation

thermal/drivers/Kconfig: Convert the CPU cooling device to a choice

PATCH Superseded Daniel Lezcano 3 participants 10 messages Dec 3, 2019 – Dec 4, 2019

Subsystems (4)

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/4 thermal/drivers/Kconfig: Convert the CPU cooling device to a choice

The next changes will add a new way to cool down a CPU by injecting idle cycles. With the current configuration, a CPU cooling device is the cpufreq cooling device. As we want to add a new CPU cooling device, let's convert the CPU cooling to a choice giving a list of CPU cooling devices. At this point, there is obviously only one CPU cooling device.

There is no functional changes.

---
V2:
- Default CPU_FREQ_COOLING when CPU_THERMAL is set (Viresh Kumar)

---
 drivers/thermal/Kconfig     | 14 ++++++++++++--
 drivers/thermal/Makefile    |  2 +-
 include/linux/cpu_cooling.h |  6 +++---
 3 files changed, 16 insertions(+), 6 deletions(-)
drivers/thermal/Kconfig +12 -2
index 001a21abcc28..4e3ee036938b 100644
@@ -150,8 +150,18 @@ config THERMAL_GOV_POWER_ALLOCATOR
 
 config CPU_THERMAL
 	bool "Generic cpu cooling support"
-	depends on CPU_FREQ
 	depends on THERMAL_OF
+	help
+	  Enable the CPU cooling features. If the system has no active
+	  cooling device available, this option allows to use the CPU
+	  as a cooling device.
+
+if CPU_THERMAL
+
+config CPU_FREQ_THERMAL
+	bool "CPU frequency cooling device"
+	depends on CPU_FREQ
+	default y
 	help
 	  This implements the generic cpu cooling mechanism through frequency
 	  reduction. An ACPI version of this already exists
@@ -159,7 +169,7 @@ config CPU_THERMAL
 	  This will be useful for platforms using the generic thermal interface
 	  and not the ACPI interface.
 
-	  If you want this support, you should say Y here.
+endif
 
 config CLOCK_THERMAL
 	bool "Generic clock cooling support"
drivers/thermal/Makefile +1 -1
index 74a37c7f847a..d3b01cc96981 100644
@@ -19,7 +19,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE)	+= user_space.o
 thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR)	+= power_allocator.o
 
 # cpufreq cooling
-thermal_sys-$(CONFIG_CPU_THERMAL)	+= cpu_cooling.o
+thermal_sys-$(CONFIG_CPU_FREQ_THERMAL)	+= cpu_cooling.o
 
 # clock cooling
 thermal_sys-$(CONFIG_CLOCK_THERMAL)	+= clock_cooling.o
include/linux/cpu_cooling.h +3 -3
index b74732535e4b..3cdd85f987d7 100644
@@ -19,7 +19,7 @@
 
 struct cpufreq_policy;
 
-#ifdef CONFIG_CPU_THERMAL
+#ifdef CONFIG_CPU_FREQ_THERMAL
 /**
  * cpufreq_cooling_register - function to create cpufreq cooling device.
  * @policy: cpufreq policy.
@@ -40,7 +40,7 @@ void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev);
 struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct cpufreq_policy *policy);
 
-#else /* !CONFIG_CPU_THERMAL */
+#else /* !CONFIG_CPU_FREQ_THERMAL */
 static inline struct thermal_cooling_device *
 cpufreq_cooling_register(struct cpufreq_policy *policy)
 {
@@ -58,6 +58,6 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 {
 	return NULL;
 }
-#endif /* CONFIG_CPU_THERMAL */
+#endif /* CONFIG_CPU_FREQ_THERMAL */
 
 #endif /* __CPU_COOLING_H__ */
Signature · 1 line
2.17.1
#1 lore raw

PATCH v3 2/4 thermal/drivers/cpu_cooling: Add idle cooling device documentation

Provide some documentation for the idle injection cooling effect in order to let people to understand the rational of the approach for the idle injection CPU cooling device.

---
 .../driver-api/thermal/cpu-idle-cooling.rst   | 166 ++++++++++++++++++
 1 file changed, 166 insertions(+)
 create mode 100644 Documentation/driver-api/thermal/cpu-idle-cooling.rst
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +166 -0
new file mode 100644
index 000000000000..457cd9979ddb
@@ -0,0 +1,166 @@
+
+Situation:
+----------
+
+Under certain circumstances a SoC can reach the maximum temperature
+limit or is unable to stabilize the temperature around a temperature
+control. When the SoC has to stabilize the temperature, the kernel can
+act on a cooling device to mitigate the dissipated power. When the
+maximum temperature is reached and to prevent a reboot or a shutdown,
+a decision must be taken to reduce the temperature under the critical
+threshold, that impacts the performance.
+
+Another situation is when the silicon reaches a certain temperature
+which continues to increase even if the dynamic leakage is reduced to
+its minimum by clock gating the component. The runaway phenomena will
+continue with the static leakage and only powering down the component,
+thus dropping the dynamic and static leakage will allow the component
+to cool down.
+
+Last but not least, the system can ask for a specific power budget but
+because of the OPP density, we can only choose an OPP with a power
+budget lower than the requested one and underuse the CPU, thus losing
+performances. In other words, one OPP under uses the CPU with a power
+lesser than the power budget and the next OPP exceed the power budget,
+an intermediate OPP could have been used if it were present.
+
+Solutions:
+----------
+
+If we can remove the static and the dynamic leakage for a specific
+duration in a controlled period, the SoC temperature will
+decrease. Acting at the idle state duration or the idle cycle
+injection period, we can mitigate the temperature by modulating the
+power budget.
+
+The Operating Performance Point (OPP) density has a great influence on
+the control precision of cpufreq, however different vendors have a
+plethora of OPP density, and some have large power gap between OPPs,
+that will result in loss of performance during thermal control and
+loss of power in other scenes.
+
+At a specific OPP, we can assume injecting idle cycle on all CPUs,
+belonging to the same cluster, with a duration greater than the
+cluster idle state target residency, we drop the static and the
+dynamic leakage for this period (modulo the energy needed to enter
+this state). So the sustainable power with idle cycles has a linear
+relation with the OPP’s sustainable power and can be computed with a
+coefficient similar to:
+
+	    Power(IdleCycle) = Coef x Power(OPP)
+
+Idle Injection:
+---------------
+
+The base concept of the idle injection is to force the CPU to go to an
+idle state for a specified time each control cycle, it provides
+another way to control CPU power and heat in addition to
+cpufreq. Ideally, if all CPUs belonging to the same cluster, inject
+their idle cycle synchronously, the cluster can reach its power down
+state with a minimum power consumption and static leakage
+drop. However, these idle cycles injection will add extra latencies as
+the CPUs will have to wakeup from a deep sleep state.
+
+     ^
+     |
+     |
+     |-------       -------       -------
+     |_______|_____|_______|_____|_______|___________
+
+      <----->
+       idle  <---->
+              running
+
+With the fixed idle injection duration, we can give a value which is
+an acceptable performance drop off or latency when we reach a specific
+temperature and we begin to mitigate by varying the Idle injection
+period.
+
+The mitigation begins with a maximum period value which decrease when
+more cooling effect is requested. When the period duration is equal to
+the idle duration, then we are in a situation the platform can’t
+dissipate the heat enough and the mitigation fails. In this case the
+situation is considered critical and there is nothing to do. The idle
+injection duration must be changed by configuration and until we reach
+the cooling effect, otherwise an additionnal cooling device must be
+used or ultimately decrease the SoC performance by dropping the
+highest OPP point of the SoC.
+
+The idle injection duration value must comply with the constraints:
+
+- It is lesser or equal to the latency we tolerate when the mitigation
+  begins. It is platform dependent and will depend on the user
+  experience, reactivity vs performance trade off we want. This value
+  should be specified.
+
+- It is greater than the idle state’s target residency we want to go
+  for thermal mitigation, otherwise we end up consuming more energy.
+
+Minimum period
+--------------
+
+The idle injection duration being fixed, it is obvious the minimum
+period can’t be lesser than that, otherwise we will be scheduling the
+idle injection task right before the idle injection duration is
+complete, so waking up the CPU to put it asleep again.
+
+Maximum period
+--------------
+
+The maximum period is the initial period when the mitigation
+begins. Theoretically when we reach the thermal trip point, we have to
+sustain a specified power for specific temperature but at this time we
+consume:
+
+ Power = Capacitance x Voltage^2 x Frequency x Utilisation
+
+... which is more than the sustainable power (or there is something
+wrong on the system setup). The ‘Capacitance’ and ‘Utilisation’ are a
+fixed value, ‘Voltage’ and the ‘Frequency’ are fixed artificially
+because we don’t want to change the OPP. We can group the
+‘Capacitance’ and the ‘Utilisation’ into a single term which is the
+‘Dynamic Power Coefficient (Cdyn)’ Simplifying the above, we have:
+
+ Pdyn = Cdyn x Voltage^2 x Frequency
+
+The IPA will ask us somehow to reduce our power in order to target the
+sustainable power defined in the device tree. So with the idle
+injection mechanism, we want an average power (Ptarget) resulting on
+an amount of time running at full power on a specific OPP and idle
+another amount of time. That could be put in a equation:
+
+ P(opp)target = ((trunning x (P(opp)running) + (tidle P(opp)idle)) /
+			(trunning + tidle)
+  ...
+
+ tidle = trunning x ((P(opp)running / P(opp)target) - 1)
+
+At this point if we know the running period for the CPU, that gives us
+the idle injection, we need. Alternatively if we have the idle
+injection duration, we can compute the running duration with:
+
+ trunning = tidle / ((P(opp)running / P(opp)target) - 1)
+
+Practically, if the running power is lesses than the targeted power,
+we end up with a negative time value, so obviously the equation usage
+is bound to a power reduction, hence a higher OPP is needed to have
+the running power greater than the targeted power.
+
+However, in this demonstration we ignore three aspects:
+
+ * The static leakage is not defined here, we can introduce it in the
+   equation but assuming it will be zero most of the time as it is
+   difficult to get the values from the SoC vendors
+
+ * The idle state wake up latency (or entry + exit latency) is not
+   taken into account, it must be added in the equation in order to
+   rigorously compute the idle injection
+
+ * The injected idle duration must be greater than the idle state
+   target residency, otherwise we end up consuming more energy and
+   potentially invert the mitigation effect
+
+So the final equation is:
+
+ trunning = (tidle - twakeup ) x
+		(((P(opp)dyn + P(opp)static ) - P(opp)target) / P(opp)target )
Signature · 1 line
2.17.1
#2 lore raw

Re: [PATCH V3 2/4] thermal/drivers/cpu_cooling: Add idle cooling device documentation

Quoted 3 lines · Daniel Lezcano

Provide some documentation for the idle injection cooling effect in order to let people to understand the rational of the approach for the

s/rational/rationale

Quoted 15 lines

idle injection CPU cooling device.

---
 .../driver-api/thermal/cpu-idle-cooling.rst   | 166 ++++++++++++++++++
 1 file changed, 166 insertions(+)
 create mode 100644 Documentation/driver-api/thermal/cpu-idle-cooling.rst
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +0 -0
new file mode 100644
index 000000000000..457cd9979ddb

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 6

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
@@ -0,0 +1,166 @@
+
+Situation:
+----------
+
+Under certain circumstances a SoC can reach the maximum temperature
+limit or is unable to stabilize the temperature around a temperature

s/the maximum/a critical/

s/or/and/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 11

Quoted 5 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +5 -0
+control. When the SoC has to stabilize the temperature, the kernel can
+act on a cooling device to mitigate the dissipated power. When the
+maximum temperature is reached and to prevent a reboot or a shutdown,
+a decision must be taken to reduce the temperature under the critical
+threshold, that impacts the performance.

Consider replacing above paragraph with:

When the critical temperature is reached, a decision must be taken to reduce the temperature, that, in turn impacts performance.

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 15

Quoted 4 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +4 -0
+
+Another situation is when the silicon reaches a certain temperature
+which continues to increase even if the dynamic leakage is reduced to
+its minimum by clock gating the component. The runaway phenomena will

s/phenomena/phenomenon/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 19

Quoted 4 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +4 -0
+continue with the static leakage and only powering down the component,
+thus dropping the dynamic and static leakage will allow the component
+to cool down.
+

Consider rephrasing as,

Another situation is when the silicon temperature continues to increase even after the dynamic leakage is reduced to its minimum by clock gating the component. This runaway phenomenon can continue due to the static leakage. The only solution is to power down the component, thus dropping the dynamic and static leakage that will allow the component to cool down.

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 23

Quoted 4 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +4 -0
+Last but not least, the system can ask for a specific power budget but
+because of the OPP density, we can only choose an OPP with a power
+budget lower than the requested one and underuse the CPU, thus losing
+performances. In other words, one OPP under uses the CPU with a power

s/performances/performance.

s/underuse/under-utlilize/
s/under use/under-utlilizes/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 24

Quoted 1 line
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +1 -0
+lesser than the power budget and the next OPP exceed the power budget,

s/lesser than the/less than the requested/
s/exceed/exceeds/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 25

Quoted 1 line
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +1 -0
+an intermediate OPP could have been used if it were present.

Make this a new sentence.

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 32

Quoted 7 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +7 -0
+
+Solutions:
+----------
+
+If we can remove the static and the dynamic leakage for a specific
+duration in a controlled period, the SoC temperature will
+decrease. Acting at the idle state duration or the idle cycle

s/at/for/ ?

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 40

Quoted 8 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +8 -0
+injection period, we can mitigate the temperature by modulating the
+power budget.
+
+The Operating Performance Point (OPP) density has a great influence on
+the control precision of cpufreq, however different vendors have a
+plethora of OPP density, and some have large power gap between OPPs,
+that will result in loss of performance during thermal control and
+loss of power in other scenes.

s/scenes/scenarios/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 43

Quoted 3 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +3 -0
+
+At a specific OPP, we can assume injecting idle cycle on all CPUs,
+belonging to the same cluster, with a duration greater than the

Change to "we can assume that injecting idle cycles on all CPUs belong to the same cluster"

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 44

Quoted 1 line
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +1 -0
+cluster idle state target residency, we drop the static and the

s/we drop/will lead to dropping/

Quoted 5 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +5 -0
+dynamic leakage for this period (modulo the energy needed to enter
+this state). So the sustainable power with idle cycles has a linear
+relation with the OPP’s sustainable power and can be computed with a
+coefficient similar to:
+

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 59

Quoted 10 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +10 -0
+           Power(IdleCycle) = Coef x Power(OPP)
+
+Idle Injection:
+---------------
+
+The base concept of the idle injection is to force the CPU to go to an
+idle state for a specified time each control cycle, it provides
+another way to control CPU power and heat in addition to
+cpufreq. Ideally, if all CPUs belonging to the same cluster, inject
+their idle cycle synchronously, the cluster can reach its power down

cycles

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 61

Quoted 2 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +2 -0
+state with a minimum power consumption and static leakage
+drop. However, these idle cycles injection will add extra latencies as

s/static leakage drop/reduce static leakage to (almost) zero/

Quoted 7 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +7 -0
+the CPUs will have to wakeup from a deep sleep state.
+
+     ^
+     |
+     |
+     |-------       -------       -------
+     |_______|_____|_______|_____|_______|___________

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 78

Quoted 10 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +10 -0
+
+      <----->
+       idle  <---->
+              running
+
+With the fixed idle injection duration, we can give a value which is
+an acceptable performance drop off or latency when we reach a specific
+temperature and we begin to mitigate by varying the Idle injection
+period.
+

I'm not sure what it the purpose of this statement. You've described how the period value starts at a maximum and is adjusted dynamically below.

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 79

Quoted 1 line
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +1 -0
+The mitigation begins with a maximum period value which decrease when

Shouldn't the idle injection period increase to get more cooling effect?

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 85

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+more cooling effect is requested. When the period duration is equal to
+the idle duration, then we are in a situation the platform can’t
+dissipate the heat enough and the mitigation fails. In this case the
+situation is considered critical and there is nothing to do. The idle
+injection duration must be changed by configuration and until we reach
+the cooling effect, otherwise an additionnal cooling device must be

typo: additional

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 91

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+used or ultimately decrease the SoC performance by dropping the
+highest OPP point of the SoC.
+
+The idle injection duration value must comply with the constraints:
+
+- It is lesser or equal to the latency we tolerate when the mitigation

s/lesser/less than/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 102

Quoted 11 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +11 -0
+  begins. It is platform dependent and will depend on the user
+  experience, reactivity vs performance trade off we want. This value
+  should be specified.
+
+- It is greater than the idle state’s target residency we want to go
+  for thermal mitigation, otherwise we end up consuming more energy.
+
+Minimum period
+--------------
+
+The idle injection duration being fixed, it is obvious the minimum

Change to:
When the idle injection duration is fixed,

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+period can’t be lesser than that, otherwise we will be scheduling the
+idle injection task right before the idle injection duration is
+complete, so waking up the CPU to put it asleep again.
+
+Maximum period
+--------------

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 118

Quoted 10 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +10 -0
+
+The maximum period is the initial period when the mitigation
+begins. Theoretically when we reach the thermal trip point, we have to
+sustain a specified power for specific temperature but at this time we
+consume:
+
+ Power = Capacitance x Voltage^2 x Frequency x Utilisation
+
+... which is more than the sustainable power (or there is something
+wrong on the system setup). The ‘Capacitance’ and ‘Utilisation’ are a

s/on/in/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 126

Quoted 8 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +8 -0
+fixed value, ‘Voltage’ and the ‘Frequency’ are fixed artificially
+because we don’t want to change the OPP. We can group the
+‘Capacitance’ and the ‘Utilisation’ into a single term which is the
+‘Dynamic Power Coefficient (Cdyn)’ Simplifying the above, we have:
+
+ Pdyn = Cdyn x Voltage^2 x Frequency
+
+The IPA will ask us somehow to reduce our power in order to target the

s/IPA/power allocator governor/

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 128

Quoted 2 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +2 -0
+sustainable power defined in the device tree. So with the idle
+injection mechanism, we want an average power (Ptarget) resulting on

s/on/in

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 132

Quoted 4 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +4 -0
+an amount of time running at full power on a specific OPP and idle
+another amount of time. That could be put in a equation:
+
+ P(opp)target = ((trunning x (P(opp)running) + (tidle P(opp)idle)) /

missed a 'x' after tidle.

Suggest using capital T for time everwhere to make it easier to read.

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 139

Quoted 7 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +7 -0
+                       (trunning + tidle)
+  ...
+
+ tidle = trunning x ((P(opp)running / P(opp)target) - 1)
+
+At this point if we know the running period for the CPU, that gives us
+the idle injection, we need. Alternatively if we have the idle

Lose the comma.

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 144

Quoted 5 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +5 -0
+injection duration, we can compute the running duration with:
+
+ trunning = tidle / ((P(opp)running / P(opp)target) - 1)
+
+Practically, if the running power is lesses than the targeted power,

s/lesses/less/

Quoted 25 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +22 -1
+we end up with a negative time value, so obviously the equation usage
+is bound to a power reduction, hence a higher OPP is needed to have
+the running power greater than the targeted power.
+
+However, in this demonstration we ignore three aspects:
+
+ * The static leakage is not defined here, we can introduce it in the
+   equation but assuming it will be zero most of the time as it is
+   difficult to get the values from the SoC vendors
+
+ * The idle state wake up latency (or entry + exit latency) is not
+   taken into account, it must be added in the equation in order to
+   rigorously compute the idle injection
+
+ * The injected idle duration must be greater than the idle state
+   target residency, otherwise we end up consuming more energy and
+   potentially invert the mitigation effect
+
+So the final equation is:
+
+ trunning = (tidle - twakeup ) x
+               (((P(opp)dyn + P(opp)static ) - P(opp)target) / P(opp)target )
--

2.17.1

#3 lore raw

Re: [PATCH V3 2/4] thermal/drivers/cpu_cooling: Add idle cooling device documentation

Hi Amit,

thanks for the review.

On 04/12/2019 05:24, Amit Kucheria wrote:

[ ... ]

Quoted 13 lines
Quoted 13 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +13 -0
+the CPUs will have to wakeup from a deep sleep state.
+
+     ^
+     |
+     |
+     |-------       -------       -------
+     |_______|_____|_______|_____|_______|___________
+
+      <----->
+       idle  <---->
+              running
+
+With the fixed idle injection duration, we can give a value which is
Quoted 8 lines

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 78

Quoted 4 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +4 -0
+an acceptable performance drop off or latency when we reach a specific
+temperature and we begin to mitigate by varying the Idle injection
+period.
+

I'm not sure what it the purpose of this statement. You've described how the period value starts at a maximum and is adjusted dynamically below.

We can have different way to inject idle periods. We can increase the idle duration and/or keep this duration constant but make a variation of the period. This statement clarify the method which is the latter because we want to have a constant latency per period easier to deal with.

Quoted 3 lines
Quoted 1 line

+The mitigation begins with a maximum period value which decrease when

Shouldn't the idle injection period increase to get more cooling effect?

The period is the opposite of the frequency. The highest the period, the lowest the frequency, thus less idle cycles and lesser cooling effect.

Quoted 18 lines

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 85

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+more cooling effect is requested. When the period duration is equal to
+the idle duration, then we are in a situation the platform can’t
+dissipate the heat enough and the mitigation fails. In this case the
+situation is considered critical and there is nothing to do. The idle
+injection duration must be changed by configuration and until we reach
+the cooling effect, otherwise an additionnal cooling device must be

typo: additional

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 91

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+used or ultimately decrease the SoC performance by dropping the
+highest OPP point of the SoC.
+
+The idle injection duration value must comply with the constraints:
+
+- It is lesser or equal to the latency we tolerate when the mitigation

s/lesser/less than/

Quoted 15 lines

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 102

Quoted 11 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +11 -0
+  begins. It is platform dependent and will depend on the user
+  experience, reactivity vs performance trade off we want. This value
+  should be specified.
+
+- It is greater than the idle state’s target residency we want to go
+  for thermal mitigation, otherwise we end up consuming more energy.
+
+Minimum period
+--------------
+
+The idle injection duration being fixed, it is obvious the minimum

Change to:
When the idle injection duration is fixed,

The idle duration is always fixed in the cpuidle cooling device, why do you want to add the sentence above?

Signature · 5 lines
 <http://www.linaro.org/> Linaro.org │ Open source software for ARM SoCs

Follow Linaro:  <http://www.facebook.com/pages/Linaro> Facebook |
<http://twitter.com/#!/linaroorg> Twitter |
<http://www.linaro.org/linaro-blog/> Blog
#4 lore raw

Re: [PATCH V3 2/4] thermal/drivers/cpu_cooling: Add idle cooling device documentation

Quoted 33 lines · Daniel Lezcano

Hi Amit,

thanks for the review.

On 04/12/2019 05:24, Amit Kucheria wrote:

[ ... ]

Quoted 13 lines
Quoted 13 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +13 -0
+the CPUs will have to wakeup from a deep sleep state.
+
+     ^
+     |
+     |
+     |-------       -------       -------
+     |_______|_____|_______|_____|_______|___________
+
+      <----->
+       idle  <---->
+              running
+
+With the fixed idle injection duration, we can give a value which is
Quoted 8 lines

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 78

Quoted 4 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +4 -0
+an acceptable performance drop off or latency when we reach a specific
+temperature and we begin to mitigate by varying the Idle injection
+period.
+

I'm not sure what it the purpose of this statement. You've described how the period value starts at a maximum and is adjusted dynamically below.

Quoted 4 lines

We can have different way to inject idle periods. We can increase the idle duration and/or keep this duration constant but make a variation of the period. This statement clarify the method which is the latter because we want to have a constant latency per period easier to deal with.

I think I read period as duration leading to confusion. I suggest using duty-cycle instead of period throughout this series. I think it will improve the explanation.

The above paragraph could be rewritten as:

"We use a fixed duration of idle injection that gives an acceptable performance penalty and a fixed latency. Mitigation can be increased or decreased by modulating the duty cycle of the idle injection."

Perhaps you could also enhance your ascii art above to show fixed duration idles and different duty cyles to drive home the point.

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

+The mitigation begins with a maximum period value which decrease when

Shouldn't the idle injection period increase to get more cooling effect?

The period is the opposite of the frequency. The highest the period, the lowest the frequency, thus less idle cycles and lesser cooling effect.

Yeah, I definitely confused period with duration :-)

Quoted 34 lines
Quoted 18 lines

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 85

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+more cooling effect is requested. When the period duration is equal to
+the idle duration, then we are in a situation the platform can’t
+dissipate the heat enough and the mitigation fails. In this case the
+situation is considered critical and there is nothing to do. The idle
+injection duration must be changed by configuration and until we reach
+the cooling effect, otherwise an additionnal cooling device must be

typo: additional

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 91

Quoted 6 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +6 -0
+used or ultimately decrease the SoC performance by dropping the
+highest OPP point of the SoC.
+
+The idle injection duration value must comply with the constraints:
+
+- It is lesser or equal to the latency we tolerate when the mitigation

s/lesser/less than/

Quoted 15 lines

Documentation/driver-api/thermal/cpu-idle-cooling.rst line 102

Quoted 11 lines
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +11 -0
+  begins. It is platform dependent and will depend on the user
+  experience, reactivity vs performance trade off we want. This value
+  should be specified.
+
+- It is greater than the idle state’s target residency we want to go
+  for thermal mitigation, otherwise we end up consuming more energy.
+
+Minimum period
+--------------
+
+The idle injection duration being fixed, it is obvious the minimum

Change to:
When the idle injection duration is fixed,

Quoted 2 lines

The idle duration is always fixed in the cpuidle cooling device, why do you want to add the sentence above?

Ignore for now.

Regards,
Amit

#5 lore raw

PATCH v3 3/4 thermal/drivers/cpu_cooling: Introduce the cpu idle cooling driver

In reply to Daniel Lezcano

The cpu idle cooling device offers a new method to cool down a CPU by injecting idle cycles at runtime.

It has some similarities with the intel power clamp driver but it is actually designed to be more generic and relying on the idle injection powercap framework.

The idle injection cycle is fixed while the running cycle is variable. That allows to have control on the device reactivity for the user experience.

An idle state powering down the CPU or the cluster will allow to drop the static leakage, thus restoring the heat capacity of the SoC. It can be set with a trip point between the hot and the critical points, giving the opportunity to prevent a hard reset of the system when the cpufreq cooling fails to cool down the CPU.

With more sophisticated boards having a per core sensor, the idle cooling device allows to cool down a single core without throttling the compute capacity of several cpus belonging to the same clock line, so it could be used in collaboration with the cpufreq cooling device.

---
V3:
- Add missing parameter documentation (Viresh Kumar)
- Fixed function description (Viresh Kumar)
- Add entry in MAINTAINER file
V2:
- Remove idle_duration_us field and use idle_inject API instead (Viresh Kumar)
- Fixed function definition wheh CPU_IDLE_COOLING is not set
- Inverted the initialization in the init function (Viresh Kumar)

---
 MAINTAINERS                       |   3 +
 drivers/thermal/Kconfig           |   7 +
 drivers/thermal/Makefile          |   1 +
 drivers/thermal/cpuidle_cooling.c | 234 ++++++++++++++++++++++++++++++
 include/linux/cpu_cooling.h       |  22 +++
 5 files changed, 267 insertions(+)
 create mode 100644 drivers/thermal/cpuidle_cooling.c
MAINTAINERS +3 -0
index c570f0204b48..d2e92a0360f2 100644
@@ -16187,12 +16187,15 @@ F:	Documentation/devicetree/bindings/thermal/
 
 THERMAL/CPU_COOLING
 M:	Amit Daniel Kachhap <[email protected]>
+M:	Daniel Lezcano <[email protected]>
 M:	Viresh Kumar <[email protected]>
 M:	Javi Merino <[email protected]>
 L:	[email protected]
 S:	Supported
 F:	Documentation/driver-api/thermal/cpu-cooling-api.rst
+F:	Documentation/driver-api/thermal/cpu-idle-cooling.rst
 F:	drivers/thermal/cpu_cooling.c
+F:	drivers/thermal/cpuidle_cooling.c
 F:	include/linux/cpu_cooling.h
 
 THINKPAD ACPI EXTRAS DRIVER
drivers/thermal/Kconfig +7 -0
index 4e3ee036938b..4ee9953ba5ce 100644
@@ -169,6 +169,13 @@ config CPU_FREQ_THERMAL
 	  This will be useful for platforms using the generic thermal interface
 	  and not the ACPI interface.
 
+config CPU_IDLE_THERMAL
+	bool "CPU idle cooling device"
+	depends on IDLE_INJECT
+	help
+	  This implements the CPU cooling mechanism through
+	  idle injection. This will throttle the CPU by injecting
+	  idle cycle.
 endif
 
 config CLOCK_THERMAL
drivers/thermal/Makefile +1 -0
index d3b01cc96981..9c8aa2d4bd28 100644
@@ -20,6 +20,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR)	+= power_allocator.o
 
 # cpufreq cooling
 thermal_sys-$(CONFIG_CPU_FREQ_THERMAL)	+= cpu_cooling.o
+thermal_sys-$(CONFIG_CPU_IDLE_THERMAL)	+= cpuidle_cooling.o
 
 # clock cooling
 thermal_sys-$(CONFIG_CLOCK_THERMAL)	+= clock_cooling.o
drivers/thermal/cpuidle_cooling.c new file +234 -0

234 lines not on this page · raw message

include/linux/cpu_cooling.h +22 -0
index 3cdd85f987d7..da0970183d1f 100644
@@ -60,4 +60,26 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 }
 #endif /* CONFIG_CPU_FREQ_THERMAL */
 
+struct cpuidle_driver;
+
+#ifdef CONFIG_CPU_IDLE_THERMAL
+extern struct thermal_cooling_device *
+__init cpuidle_cooling_register(struct cpuidle_driver *drv);
+extern struct thermal_cooling_device *
+__init cpuidle_of_cooling_register(struct device_node *np,
+				   struct cpuidle_driver *drv);
+#else /* CONFIG_CPU_IDLE_THERMAL */
+static inline struct thermal_cooling_device *
+__init cpuidle_cooling_register(struct cpuidle_driver *drv)
+{
+	return ERR_PTR(-EINVAL);
+}
+static inline struct thermal_cooling_device *
+__init cpuidle_of_cooling_register(struct device_node *np,
+				   struct cpuidle_driver *drv)
+{
+	return ERR_PTR(-EINVAL);
+}
+#endif /* CONFIG_CPU_IDLE_THERMAL */
+
 #endif /* __CPU_COOLING_H__ */
Signature · 1 line
2.17.1
#6 lore raw

Re: [PATCH V3 3/4] thermal/drivers/cpu_cooling: Introduce the cpu idle cooling driver

Quoted 10 lines · Daniel Lezcano

The cpu idle cooling device offers a new method to cool down a CPU by injecting idle cycles at runtime.

It has some similarities with the intel power clamp driver but it is actually designed to be more generic and relying on the idle injection powercap framework.

The idle injection cycle is fixed while the running cycle is variable. That allows to have control on the device reactivity for the user experience.

s/cycle/period/ ? Since you use that in your documentation.

Quoted 96 lines

An idle state powering down the CPU or the cluster will allow to drop the static leakage, thus restoring the heat capacity of the SoC. It can be set with a trip point between the hot and the critical points, giving the opportunity to prevent a hard reset of the system when the cpufreq cooling fails to cool down the CPU.

With more sophisticated boards having a per core sensor, the idle cooling device allows to cool down a single core without throttling the compute capacity of several cpus belonging to the same clock line, so it could be used in collaboration with the cpufreq cooling device.

---
V3:
- Add missing parameter documentation (Viresh Kumar)
- Fixed function description (Viresh Kumar)
- Add entry in MAINTAINER file
V2:
- Remove idle_duration_us field and use idle_inject API instead (Viresh Kumar)
- Fixed function definition wheh CPU_IDLE_COOLING is not set
- Inverted the initialization in the init function (Viresh Kumar)

---
 MAINTAINERS                       |   3 +
 drivers/thermal/Kconfig           |   7 +
 drivers/thermal/Makefile          |   1 +
 drivers/thermal/cpuidle_cooling.c | 234 ++++++++++++++++++++++++++++++
 include/linux/cpu_cooling.h       |  22 +++
 5 files changed, 267 insertions(+)
 create mode 100644 drivers/thermal/cpuidle_cooling.c
MAINTAINERS +3 -0
index c570f0204b48..d2e92a0360f2 100644
@@ -16187,12 +16187,15 @@ F:    Documentation/devicetree/bindings/thermal/
 
 THERMAL/CPU_COOLING
 M:     Amit Daniel Kachhap <[email protected]>
+M:     Daniel Lezcano <[email protected]>
 M:     Viresh Kumar <[email protected]>
 M:     Javi Merino <[email protected]>
 L:     [email protected]
 S:     Supported
 F:     Documentation/driver-api/thermal/cpu-cooling-api.rst
+F:     Documentation/driver-api/thermal/cpu-idle-cooling.rst
 F:     drivers/thermal/cpu_cooling.c
+F:     drivers/thermal/cpuidle_cooling.c
 F:     include/linux/cpu_cooling.h
 
 THINKPAD ACPI EXTRAS DRIVER
drivers/thermal/Kconfig +7 -0
index 4e3ee036938b..4ee9953ba5ce 100644
@@ -169,6 +169,13 @@ config CPU_FREQ_THERMAL
          This will be useful for platforms using the generic thermal interface
          and not the ACPI interface.
 
+config CPU_IDLE_THERMAL
+       bool "CPU idle cooling device"
+       depends on IDLE_INJECT
+       help
+         This implements the CPU cooling mechanism through
+         idle injection. This will throttle the CPU by injecting
+         idle cycle.
 endif
 
 config CLOCK_THERMAL
drivers/thermal/Makefile +1 -0
index d3b01cc96981..9c8aa2d4bd28 100644
@@ -20,6 +20,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR)     += power_allocator.o
 
 # cpufreq cooling
 thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpu_cooling.o
+thermal_sys-$(CONFIG_CPU_IDLE_THERMAL) += cpuidle_cooling.o
 
 # clock cooling
 thermal_sys-$(CONFIG_CLOCK_THERMAL)    += clock_cooling.o
drivers/thermal/cpuidle_cooling.c new file +9 -0
new file mode 100644
index 000000000000..7d91a1b298d4
@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *  Copyright (C) 2019 Linaro Limited.
+ *
+ *  Author: Daniel Lezcano <[email protected]>
+ *
+ */
+#include <linux/cpu_cooling.h>
+#include <linux/cpuidle.h>

drivers/thermal/cpuidle_cooling.c line 19

Quoted 10 lines
drivers/thermal/cpuidle_cooling.c new file +10 -0
+#include <linux/err.h>
+#include <linux/idle_inject.h>
+#include <linux/idr.h>
+#include <linux/slab.h>
+#include <linux/thermal.h>
+
+/**
+ * struct cpuidle_cooling_device - data for the idle cooling device
+ * @ii_dev: an atomic to keep track of the last task exiting the idle cycle
+ * @state: an normalized integer giving the state of the cooling device

s/an/a/

Quoted 5 lines
drivers/thermal/cpuidle_cooling.c new file +5 -0
+ */
+struct cpuidle_cooling_device {
+       struct idle_inject_device *ii_dev;
+       unsigned long state;
+};

drivers/thermal/cpuidle_cooling.c line 34

Quoted 10 lines
drivers/thermal/cpuidle_cooling.c new file +10 -0
+
+static DEFINE_IDA(cpuidle_ida);
+
+/**
+ * cpuidle_cooling_runtime - Running time computation
+ * @idle_duration_us: the idle cooling device
+ * @state: a percentile based number
+ *
+ * The running duration is computed from the idle injection duration
+ * which is fixed. If we reach 100% of idle injection ratio, that

How about using the term 'duty cycle' instead of ratio? It describes the on/off (running/idle) waveform better.

drivers/thermal/cpuidle_cooling.c line 39

Quoted 5 lines
drivers/thermal/cpuidle_cooling.c new file +5 -0
+ * means the running duration is zero. If we have a 50% ratio
+ * injection, that means we have equal duration for idle and for
+ * running duration.
+ *
+ * The formula is deduced as the following:

s/the following/follows/

drivers/thermal/cpuidle_cooling.c line 50

Quoted 11 lines
drivers/thermal/cpuidle_cooling.c new file +11 -0
+ *
+ *  running = idle x ((100 / ratio) - 1)
+ *
+ * For precision purpose for integer math, we use the following:
+ *
+ *  running = (idle x 100) / ratio - idle
+ *
+ * For example, if we have an injected duration of 50%, then we end up
+ * with 10ms of idle injection and 10ms of running duration.
+ *
+ * Returns an unsigned int for an usec based runtime duration.

s/an/a/ since usec is actually a shortform for microseconds.

Quoted 6 lines
drivers/thermal/cpuidle_cooling.c new file +6 -0
+ */
+static unsigned int cpuidle_cooling_runtime(unsigned int idle_duration_us,
+                                           unsigned long state)
+{
+       if (!state)
+               return 0;

drivers/thermal/cpuidle_cooling.c line 66

Quoted 10 lines
drivers/thermal/cpuidle_cooling.c new file +10 -0
+
+       return ((idle_duration_us * 100) / state) - idle_duration_us;
+}
+
+/**
+ * cpuidle_cooling_get_max_state - Get the maximum state
+ * @cdev  : the thermal cooling device
+ * @state : a pointer to the state variable to be filled
+ *
+ * The function always gives 100 as the injection ratio is percentile

s/gives/returns/

Split the sentence after ratio.

drivers/thermal/cpuidle_cooling.c line 67

Quoted 1 line
drivers/thermal/cpuidle_cooling.c new file +1 -0
+ * based for consistency accros different platforms.

Typo: across

drivers/thermal/cpuidle_cooling.c line 76

Quoted 9 lines
drivers/thermal/cpuidle_cooling.c new file +9 -0
+ *
+ * The function can not fail, it always returns zero.
+ */
+static int cpuidle_cooling_get_max_state(struct thermal_cooling_device *cdev,
+                                        unsigned long *state)
+{
+       /*
+        * Depending on the configuration or the hardware, the running
+        * cycle and the idle cycle could be different. We want unify

s/want/want to/

Quoted 9 lines
drivers/thermal/cpuidle_cooling.c new file +9 -0
+        * that to an 0..100 interval, so the set state interface will
+        * be the same whatever the platform is.
+        *
+        * The state 100% will make the cluster 100% ... idle. A 0%
+        * injection ratio means no idle injection at all and 50%
+        * means for 10ms of idle injection, we have 10ms of running
+        * time.
+        */
+       *state = 100;

drivers/thermal/cpuidle_cooling.c line 95

Quoted 10 lines
drivers/thermal/cpuidle_cooling.c new file +10 -0
+
+       return 0;
+}
+
+/**
+ * cpuidle_cooling_get_cur_state - Get the current cooling state
+ * @cdev: the thermal cooling device
+ * @state: a pointer to the state
+ *
+ * The function just copy the state value from the private thermal

s/copy/copies/

drivers/thermal/cpuidle_cooling.c line 98

Quoted 3 lines
drivers/thermal/cpuidle_cooling.c new file +3 -0
+ * cooling device structure, the mapping is 1 <-> 1.
+ *
+ * The function can not fail, it always returns zero.

Add the Return keyword at the beginning to conform to kernel-doc. And all other function return values in this file.

Quoted 170 lines
drivers/thermal/cpuidle_cooling.c new file +136 -0
+ */
+static int cpuidle_cooling_get_cur_state(struct thermal_cooling_device *cdev,
+                                        unsigned long *state)
+{
+       struct cpuidle_cooling_device *idle_cdev = cdev->devdata;
+
+       *state = idle_cdev->state;
+
+       return 0;
+}
+
+/**
+ * cpuidle_cooling_set_cur_state - Set the current cooling state
+ * @cdev: the thermal cooling device
+ * @state: the target state
+ *
+ * The function checks first if we are initiating the mitigation which
+ * in turn wakes up all the idle injection tasks belonging to the idle
+ * cooling device. In any case, it updates the internal state for the
+ * cooling device.
+ *
+ * The function can not fail, it always returns zero.
+ */
+static int cpuidle_cooling_set_cur_state(struct thermal_cooling_device *cdev,
+                                        unsigned long state)
+{
+       struct cpuidle_cooling_device *idle_cdev = cdev->devdata;
+       struct idle_inject_device *ii_dev = idle_cdev->ii_dev;
+       unsigned long current_state = idle_cdev->state;
+       unsigned int runtime_us, idle_duration_us;
+
+       idle_cdev->state = state;
+
+       idle_inject_get_duration(ii_dev, &runtime_us, &idle_duration_us);
+
+       runtime_us = cpuidle_cooling_runtime(idle_duration_us, state);
+
+       idle_inject_set_duration(ii_dev, runtime_us, idle_duration_us);
+
+       if (current_state == 0 && state > 0) {
+               idle_inject_start(ii_dev);
+       } else if (current_state > 0 && !state)  {
+               idle_inject_stop(ii_dev);
+       }
+
+       return 0;
+}
+
+/**
+ * cpuidle_cooling_ops - thermal cooling device ops
+ */
+static struct thermal_cooling_device_ops cpuidle_cooling_ops = {
+       .get_max_state = cpuidle_cooling_get_max_state,
+       .get_cur_state = cpuidle_cooling_get_cur_state,
+       .set_cur_state = cpuidle_cooling_set_cur_state,
+};
+
+/**
+ * cpuidle_of_cooling_register - Idle cooling device initialization function
+ * @drv: a cpuidle driver structure pointer
+ * @np: a node pointer to a device tree cooling device node
+ *
+ * This function is in charge of creating a cooling device per cpuidle
+ * driver and register it to thermal framework.
+ *
+ * Returns a valid pointer to a thermal cooling device or a PTR_ERR
+ * corresponding to the error detected in the underlying subsystems.
+ */
+struct thermal_cooling_device *
+__init cpuidle_of_cooling_register(struct device_node *np,
+                                  struct cpuidle_driver *drv)
+{
+       struct idle_inject_device *ii_dev;
+       struct cpuidle_cooling_device *idle_cdev;
+       struct thermal_cooling_device *cdev;
+       char dev_name[THERMAL_NAME_LENGTH];
+       int id, ret;
+
+       idle_cdev = kzalloc(sizeof(*idle_cdev), GFP_KERNEL);
+       if (!idle_cdev) {
+               ret = -ENOMEM;
+               goto out;
+       }
+
+       id = ida_simple_get(&cpuidle_ida, 0, 0, GFP_KERNEL);
+       if (id < 0) {
+               ret = id;
+               goto out_kfree;
+       }
+
+       ii_dev = idle_inject_register(drv->cpumask);
+       if (IS_ERR(ii_dev)) {
+               ret = PTR_ERR(ii_dev);
+               goto out_id;
+       }
+
+       idle_inject_set_duration(ii_dev, 0, TICK_USEC);
+
+       idle_cdev->ii_dev = ii_dev;
+
+       snprintf(dev_name, sizeof(dev_name), "thermal-idle-%d", id);
+
+       cdev = thermal_of_cooling_device_register(np, dev_name, idle_cdev,
+                                                 &cpuidle_cooling_ops);
+       if (IS_ERR(cdev)) {
+               ret = PTR_ERR(cdev);
+               goto out_unregister;
+       }
+
+       return cdev;
+
+out_unregister:
+       idle_inject_unregister(ii_dev);
+out_id:
+       ida_simple_remove(&cpuidle_ida, id);
+out_kfree:
+       kfree(idle_cdev);
+out:
+       return ERR_PTR(ret);
+}
+
+/**
+ * cpuidle_cooling_register - Idle cooling device initialization function
+ * @drv: a cpuidle driver structure pointer
+ *
+ * This function is in charge of creating a cooling device per cpuidle
+ * driver and register it to thermal framework.
+ *
+ * Returns a valid pointer to a thermal cooling device, a PTR_ERR
+ * corresponding to the error detected in the underlying subsystems.
+ */
+struct thermal_cooling_device *
+__init cpuidle_cooling_register(struct cpuidle_driver *drv)
+{
+       return cpuidle_of_cooling_register(NULL, drv);
+}
include/linux/cpu_cooling.h +22 -1
index 3cdd85f987d7..da0970183d1f 100644
@@ -60,4 +60,26 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 }
 #endif /* CONFIG_CPU_FREQ_THERMAL */
 
+struct cpuidle_driver;
+
+#ifdef CONFIG_CPU_IDLE_THERMAL
+extern struct thermal_cooling_device *
+__init cpuidle_cooling_register(struct cpuidle_driver *drv);
+extern struct thermal_cooling_device *
+__init cpuidle_of_cooling_register(struct device_node *np,
+                                  struct cpuidle_driver *drv);
+#else /* CONFIG_CPU_IDLE_THERMAL */
+static inline struct thermal_cooling_device *
+__init cpuidle_cooling_register(struct cpuidle_driver *drv)
+{
+       return ERR_PTR(-EINVAL);
+}
+static inline struct thermal_cooling_device *
+__init cpuidle_of_cooling_register(struct device_node *np,
+                                  struct cpuidle_driver *drv)
+{
+       return ERR_PTR(-EINVAL);
+}
+#endif /* CONFIG_CPU_IDLE_THERMAL */
+
 #endif /* __CPU_COOLING_H__ */
--

2.17.1

#7 lore raw

PATCH v3 4/4 thermal/drivers/cpu_cooling: Rename to cpufreq_cooling

In reply to Daniel Lezcano

As we introduced the idle injection cooling device called cpuidle_cooling, let's be consistent and rename the cpu_cooling to cpufreq_cooling as this one mitigates with OPPs changes.

---
V3:
- Fix missing name conversion (Viresh Kumar)

---
 Documentation/driver-api/thermal/exynos_thermal.rst  | 2 +-
 MAINTAINERS                                          | 2 +-
 drivers/thermal/Makefile                             | 2 +-
 drivers/thermal/clock_cooling.c                      | 2 +-
 drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} | 6 +++---
 include/linux/clock_cooling.h                        | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)
 rename drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} (99%)
Documentation/driver-api/thermal/exynos_thermal.rst +1 -1
index 5bd556566c70..d4e4a5b75805 100644
@@ -67,7 +67,7 @@ TMU driver description:
 The exynos thermal driver is structured as::
 
 					Kernel Core thermal framework
-				(thermal_core.c, step_wise.c, cpu_cooling.c)
+				(thermal_core.c, step_wise.c, cpufreq_cooling.c)
 								^
 								|
 								|
MAINTAINERS +1 -1
index d2e92a0360f2..26e4be914765 100644
@@ -16194,7 +16194,7 @@ L:	[email protected]
 S:	Supported
 F:	Documentation/driver-api/thermal/cpu-cooling-api.rst
 F:	Documentation/driver-api/thermal/cpu-idle-cooling.rst
-F:	drivers/thermal/cpu_cooling.c
+F:	drivers/thermal/cpufreq_cooling.c
 F:	drivers/thermal/cpuidle_cooling.c
 F:	include/linux/cpu_cooling.h
 
drivers/thermal/Makefile +1 -1
index 9c8aa2d4bd28..5c98472ffd8b 100644
@@ -19,7 +19,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE)	+= user_space.o
 thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR)	+= power_allocator.o
 
 # cpufreq cooling
-thermal_sys-$(CONFIG_CPU_FREQ_THERMAL)	+= cpu_cooling.o
+thermal_sys-$(CONFIG_CPU_FREQ_THERMAL)	+= cpufreq_cooling.o
 thermal_sys-$(CONFIG_CPU_IDLE_THERMAL)	+= cpuidle_cooling.o
 
 # clock cooling
drivers/thermal/clock_cooling.c +1 -1
index 3ad3256c48fd..7cb3ae4b44ee 100644
@@ -7,7 +7,7 @@
  *  Copyright (C) 2013	Texas Instruments Inc.
  *  Contact:  Eduardo Valentin <[email protected]>
  *
- *  Highly based on cpu_cooling.c.
+ *  Highly based on cpufreq_cooling.c.
  *  Copyright (C) 2012	Samsung Electronics Co., Ltd(http://www.samsung.com)
  *  Copyright (C) 2012  Amit Daniel <[email protected]>
  */
drivers/thermal/cpufreq_cooling.c renamed from drivers/thermal/cpu_cooling.c +3 -3
similarity index 99%
rename from drivers/thermal/cpu_cooling.c
rename to drivers/thermal/cpufreq_cooling.c
index 6b9865c786ba..3a3f9cf94b6d 100644
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- *  linux/drivers/thermal/cpu_cooling.c
+ *  linux/drivers/thermal/cpufreq_cooling.c
  *
  *  Copyright (C) 2012	Samsung Electronics Co., Ltd(http://www.samsung.com)
  *
@@ -694,7 +694,7 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 	u32 capacitance = 0;
 
 	if (!np) {
-		pr_err("cpu_cooling: OF node not available for cpu%d\n",
+		pr_err("cpufreq_cooling: OF node not available for cpu%d\n",
 		       policy->cpu);
 		return NULL;
 	}
@@ -705,7 +705,7 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 
 		cdev = __cpufreq_cooling_register(np, policy, capacitance);
 		if (IS_ERR(cdev)) {
-			pr_err("cpu_cooling: cpu%d failed to register as cooling device: %ld\n",
+			pr_err("cpufreq_cooling: cpu%d failed to register as cooling device: %ld\n",
 			       policy->cpu, PTR_ERR(cdev));
 			cdev = NULL;
 		}
include/linux/clock_cooling.h +1 -1
index b5cebf766e02..4b0a69863656 100644
@@ -7,7 +7,7 @@
  *  Copyright (C) 2013	Texas Instruments Inc.
  *  Contact:  Eduardo Valentin <[email protected]>
  *
- *  Highly based on cpu_cooling.c.
+ *  Highly based on cpufreq_cooling.c.
  *  Copyright (C) 2012	Samsung Electronics Co., Ltd(http://www.samsung.com)
  *  Copyright (C) 2012  Amit Daniel <[email protected]>
  */
Signature · 1 line
2.17.1
maintainer Acked-by on v3 4/4
#8 lore raw

Re: [PATCH V3 4/4] thermal/drivers/cpu_cooling: Rename to cpufreq_cooling

Quoted 8 lines · Daniel Lezcano

As we introduced the idle injection cooling device called cpuidle_cooling, let's be consistent and rename the cpu_cooling to cpufreq_cooling as this one mitigates with OPPs changes.

---
V3:
- Fix missing name conversion (Viresh Kumar)

Quoted 9 lines
---
 Documentation/driver-api/thermal/exynos_thermal.rst  | 2 +-
 MAINTAINERS                                          | 2 +-
 drivers/thermal/Makefile                             | 2 +-
 drivers/thermal/clock_cooling.c                      | 2 +-
 drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} | 6 +++---
 include/linux/clock_cooling.h                        | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)
 rename drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} (99%)
Signature · 1 line
viresh
Reviewed-by on v3 4/4
#9 lore raw

Re: [PATCH V3 4/4] thermal/drivers/cpu_cooling: Rename to cpufreq_cooling

In reply to Daniel Lezcano
Quoted 6 lines · Daniel Lezcano

As we introduced the idle injection cooling device called cpuidle_cooling, let's be consistent and rename the cpu_cooling to cpufreq_cooling as this one mitigates with OPPs changes.

Quoted 114 lines

---
V3:
- Fix missing name conversion (Viresh Kumar)

---
 Documentation/driver-api/thermal/exynos_thermal.rst  | 2 +-
 MAINTAINERS                                          | 2 +-
 drivers/thermal/Makefile                             | 2 +-
 drivers/thermal/clock_cooling.c                      | 2 +-
 drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} | 6 +++---
 include/linux/clock_cooling.h                        | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)
 rename drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} (99%)
Documentation/driver-api/thermal/exynos_thermal.rst +1 -1
index 5bd556566c70..d4e4a5b75805 100644
@@ -67,7 +67,7 @@ TMU driver description:
 The exynos thermal driver is structured as::
 
                                        Kernel Core thermal framework
-                               (thermal_core.c, step_wise.c, cpu_cooling.c)
+                               (thermal_core.c, step_wise.c, cpufreq_cooling.c)
                                                                ^
                                                                |
                                                                |
MAINTAINERS +1 -1
index d2e92a0360f2..26e4be914765 100644
@@ -16194,7 +16194,7 @@ L:      [email protected]
 S:     Supported
 F:     Documentation/driver-api/thermal/cpu-cooling-api.rst
 F:     Documentation/driver-api/thermal/cpu-idle-cooling.rst
-F:     drivers/thermal/cpu_cooling.c
+F:     drivers/thermal/cpufreq_cooling.c
 F:     drivers/thermal/cpuidle_cooling.c
 F:     include/linux/cpu_cooling.h
 
drivers/thermal/Makefile +1 -1
index 9c8aa2d4bd28..5c98472ffd8b 100644
@@ -19,7 +19,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE)  += user_space.o
 thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR)      += power_allocator.o
 
 # cpufreq cooling
-thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpu_cooling.o
+thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpufreq_cooling.o
 thermal_sys-$(CONFIG_CPU_IDLE_THERMAL) += cpuidle_cooling.o
 
 # clock cooling
drivers/thermal/clock_cooling.c +1 -1
index 3ad3256c48fd..7cb3ae4b44ee 100644
@@ -7,7 +7,7 @@
  *  Copyright (C) 2013 Texas Instruments Inc.
  *  Contact:  Eduardo Valentin <[email protected]>
  *
- *  Highly based on cpu_cooling.c.
+ *  Highly based on cpufreq_cooling.c.
  *  Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
  *  Copyright (C) 2012  Amit Daniel <[email protected]>
  */
drivers/thermal/cpufreq_cooling.c renamed from drivers/thermal/cpu_cooling.c +3 -3
similarity index 99%
rename from drivers/thermal/cpu_cooling.c
rename to drivers/thermal/cpufreq_cooling.c
index 6b9865c786ba..3a3f9cf94b6d 100644
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- *  linux/drivers/thermal/cpu_cooling.c
+ *  linux/drivers/thermal/cpufreq_cooling.c
  *
  *  Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
  *
@@ -694,7 +694,7 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
        u32 capacitance = 0;
 
        if (!np) {
-               pr_err("cpu_cooling: OF node not available for cpu%d\n",
+               pr_err("cpufreq_cooling: OF node not available for cpu%d\n",
                       policy->cpu);
                return NULL;
        }
@@ -705,7 +705,7 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 
                cdev = __cpufreq_cooling_register(np, policy, capacitance);
                if (IS_ERR(cdev)) {
-                       pr_err("cpu_cooling: cpu%d failed to register as cooling device: %ld\n",
+                       pr_err("cpufreq_cooling: cpu%d failed to register as cooling device: %ld\n",
                               policy->cpu, PTR_ERR(cdev));
                        cdev = NULL;
                }
include/linux/clock_cooling.h +1 -2
index b5cebf766e02..4b0a69863656 100644
@@ -7,7 +7,7 @@
  *  Copyright (C) 2013 Texas Instruments Inc.
  *  Contact:  Eduardo Valentin <[email protected]>
  *
- *  Highly based on cpu_cooling.c.
+ *  Highly based on cpufreq_cooling.c.
  *  Copyright (C) 2012 Samsung Electronics Co., Ltd(http://www.samsung.com)
  *  Copyright (C) 2012  Amit Daniel <[email protected]>
  */
--

2.17.1