thermal/core: Introduce user trip points
Subsystems (2)
PATCH 1/1 thermal/core: Introduce user trip points
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.
--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)
Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1 -0
@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driver
drivers/thermal/thermal_core.c +8 -0
@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ; +/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ; +/* lower default 0, upper default max_state */ lower = lower ==THERMAL_NO_LIMIT ?0 : lower;
drivers/thermal/thermal_of.c +1 -0
@@ -60,6 +60,7 @@ static const char * const trip_types[] = { [THERMAL_TRIP_PASSIVE] = "passive", [THERMAL_TRIP_HOT] = "hot", [THERMAL_TRIP_CRITICAL] = "critical", + [THERMAL_TRIP_USER] = "user", };/**
drivers/thermal/thermal_trace.h +3 -1
@@ -15,13 +15,15 @@ TRACE_DEFINE_ENUM(THERMAL_TRIP_CRITICAL);TRACE_DEFINE_ENUM (THERMAL_TRIP_HOT );TRACE_DEFINE_ENUM (THERMAL_TRIP_PASSIVE );TRACE_DEFINE_ENUM (THERMAL_TRIP_ACTIVE ); +TRACE_DEFINE_ENUM (THERMAL_TRIP_USER );#define show_tzt_type (type) \ __print_symbolic(type, \ { THERMAL_TRIP_CRITICAL, "CRITICAL"}, \ { THERMAL_TRIP_HOT, "HOT"}, \ { THERMAL_TRIP_PASSIVE, "PASSIVE"}, \ - { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + { THERMAL_TRIP_ACTIVE, "ACTIVE"}), \ + { THERMAL_TRIP_USER, "USER"}) TRACE_EVENT(thermal_temperature,
drivers/thermal/thermal_trip.c +1 -0
@@ -10,6 +10,7 @@#include "thermal_core.h" static const char *trip_type_names[] = { + [THERMAL_TRIP_USER ] ="user" , [THERMAL_TRIP_ACTIVE ] ="active" , [THERMAL_TRIP_PASSIVE ] ="passive" , [THERMAL_TRIP_HOT ] ="hot" ,
include/uapi/linux/thermal.h +1 -0
@@ -14,6 +14,7 @@ enum thermal_trip_type {THERMAL_TRIP_PASSIVE ,THERMAL_TRIP_HOT ,THERMAL_TRIP_CRITICAL , + THERMAL_TRIP_USER, };/* Adding event notification support elements */
Signature · 1 line
2.43.0
Rafael J. Wysocki
maintainerQuoted 72 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1
-0@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driverdrivers/thermal/thermal_core.c +0
-0
drivers/thermal/thermal_core.c int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz, · line 743
Quoted 10 lines
drivers/thermal/thermal_core.c +7
-0@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ; +/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ;
Maybe print a debug message when bailing out here?
A check for "user" trips would need to be added to thermal_governor_trip_crossed() and to the .manage() callbacks in the power allocator, step-wise and fair-share governors, if I'm not mistaken. Especially fair-share and power allocator should not take them into account IMV.
Quoted 64 lines
drivers/thermal/thermal_core.c +1
-0+/* lower default 0, upper default max_state */ lower = lower ==THERMAL_NO_LIMIT ?0 : lower;drivers/thermal/thermal_of.c +1
-0@@ -60,6 +60,7 @@ static const char * const trip_types[] = { [THERMAL_TRIP_PASSIVE] = "passive", [THERMAL_TRIP_HOT] = "hot", [THERMAL_TRIP_CRITICAL] = "critical", + [THERMAL_TRIP_USER] = "user", };/** drivers/thermal/thermal_trace.h +3
-1@@ -15,13 +15,15 @@ TRACE_DEFINE_ENUM(THERMAL_TRIP_CRITICAL);TRACE_DEFINE_ENUM (THERMAL_TRIP_HOT );TRACE_DEFINE_ENUM (THERMAL_TRIP_PASSIVE );TRACE_DEFINE_ENUM (THERMAL_TRIP_ACTIVE ); +TRACE_DEFINE_ENUM (THERMAL_TRIP_USER );#define show_tzt_type (type) \ __print_symbolic(type, \ { THERMAL_TRIP_CRITICAL, "CRITICAL"}, \ { THERMAL_TRIP_HOT, "HOT"}, \ { THERMAL_TRIP_PASSIVE, "PASSIVE"}, \ - { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + { THERMAL_TRIP_ACTIVE, "ACTIVE"}), \ + { THERMAL_TRIP_USER, "USER"}) TRACE_EVENT(thermal_temperature,drivers/thermal/thermal_trip.c +1
-0@@ -10,6 +10,7 @@#include "thermal_core.h" static const char *trip_type_names[] = { + [THERMAL_TRIP_USER ] ="user" , [THERMAL_TRIP_ACTIVE ] ="active" , [THERMAL_TRIP_PASSIVE ] ="passive" , [THERMAL_TRIP_HOT ] ="hot" ,include/uapi/linux/thermal.h +1
-1@@ -14,6 +14,7 @@ enum thermal_trip_type {THERMAL_TRIP_PASSIVE ,THERMAL_TRIP_HOT ,THERMAL_TRIP_CRITICAL , + THERMAL_TRIP_USER, };/* Adding event notification support elements */ --2.43.0
Quoted 87 lines · Rafael J. Wysocki
Quoted 72 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1
-0@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driverdrivers/thermal/thermal_core.c +0
-0drivers/thermal/thermal_core.c int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz, · line 743
Quoted 10 lines
drivers/thermal/thermal_core.c +7
-0@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ; +/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ;Maybe print a debug message when bailing out here?
Quoted 5 lines
A check for "user" trips would need to be added to
thermal_governor_trip_crossed()and to the .manage() callbacks in the power allocator, step-wise and fair-share governors, if I'm not mistaken. Especially fair-share and power allocator should not take them into account IMV.
I'm not sure the power_allocator needs to change anything. The trip point used is switch_on which is only derived from passive or active trip point, so it is not possible to have a user trip point used in the manage callback.
Did I miss something ?
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
Rafael J. Wysocki
maintainerQuoted 95 lines · Daniel Lezcano
Quoted 87 lines · Rafael J. Wysocki
Quoted 72 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1
-0@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driverdrivers/thermal/thermal_core.c +0
-0drivers/thermal/thermal_core.c int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz, · line 743
Quoted 10 lines
drivers/thermal/thermal_core.c +7
-0@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ; +/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ;Maybe print a debug message when bailing out here?
Quoted 5 lines
A check for "user" trips would need to be added to
thermal_governor_trip_crossed()and to the .manage() callbacks in the power allocator, step-wise and fair-share governors, if I'm not mistaken. Especially fair-share and power allocator should not take them into account IMV.
Quoted 4 lines
I'm not sure the
power_allocatorneeds to change anything. The trip point used isswitch_onwhich is only derived from passive or active trip point, so it is not possible to have a user trip point used in the manage callback.
OK, it checks for "active" specifically.
Quoted 1 line
Did I miss something ?
No, I don't think so.
Quoted 77 lines · Rafael J. Wysocki
Quoted 75 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1
-0@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driverdrivers/thermal/thermal_core.c +0
-0@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ;
Quoted 9 lines
drivers/thermal/thermal_core.c int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz, · line 743
Quoted 7 lines
drivers/thermal/thermal_core.c +7
-0+/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ;Maybe print a debug message when bailing out here?
After thinking a bit about the message, it sounds to me that is a really an error in the firmware if we end up binding an 'user' trip point.
What about the following message:
dev_err(tz->device, "Trying to bind the cooling device '%s' with an 'user' trip point id=%d", cdev->type, trip->id);
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
Rafael J. Wysocki
maintainerQuoted 89 lines · Daniel Lezcano
Quoted 77 lines · Rafael J. Wysocki
Quoted 75 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1
-0@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driverdrivers/thermal/thermal_core.c +0
-0@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ;Quoted 9 lines
drivers/thermal/thermal_core.c int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz, · line 743
Quoted 7 lines
drivers/thermal/thermal_core.c +7
-0+/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ;Maybe print a debug message when bailing out here?
Quoted 7 lines
After thinking a bit about the message, it sounds to me that is a really an error in the firmware if we end up binding an 'user' trip point.
What about the following message:
dev_err(tz->device, "Trying to bind the cooling device '%s' with an 'user' trip point id=%d",
cdev->type,trip->id);
s/an// I think.
Also I wouldn't use dev_err() as it indicates a kernel issue. Maybe dev_info(tz->device, FW_BUG ...)?
Quoted 95 lines · Rafael J. Wysocki
Quoted 94 lines · Daniel Lezcano
Quoted 77 lines · Rafael J. Wysocki
Quoted 75 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 + drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)Documentation/devicetree/bindings/thermal/thermal-zones.yaml +1
-0@@ -153,6 +153,7 @@ patternProperties: type: $ref: /schemas/types.yaml#/definitions/string enum: + - user # enable user notification - active # enable active cooling e.g. fans - passive # enable passive cooling e.g. throttling cpu - hot # send notification to driverdrivers/thermal/thermal_core.c +0
-0@@ -734,6 +734,14 @@ int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz,if (tz != pos1 || cdev != pos2)return -EINVAL ;Quoted 9 lines
drivers/thermal/thermal_core.c int thermal_bind_cdev_to_trip(struct thermal_zone_device *tz, · line 743
Quoted 7 lines
drivers/thermal/thermal_core.c +7
-0+/* +* It is not allowed to bind a cooling device with a trip +* point user type because no mitigation should happen from +* the kernel with these trip points +*/ +if (trip->type ==THERMAL_TRIP_USER ) +return -EINVAL ;Maybe print a debug message when bailing out here?
After thinking a bit about the message, it sounds to me that is a really an error in the firmware if we end up binding an 'user' trip point.
What about the following message:
Quoted 7 lines
Quoted 2 lines
dev_err(tz->device, "Trying to bind the cooling device '%s' with an 'user' trip point id=%d",
cdev->type,trip->id);s/an// I think.
Also I wouldn't use
dev_err()as it indicates a kernel issue. Maybedev_info(tz->device, FW_BUG ...)?
Right, thanks
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
Rob Herring
maintainerQuoted 40 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
Quoted 3 lines
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.
Sounds like OS behavior/policy though I guess the existing ones kind are too. Maybe we should have defined *what* action to take and then the OS could decide whether what actions to handle vs. pass it up a level.
Why can't userspace just ask to be notified at a trip point it defines?
If we keep this in DT, perhaps 'notice' would be a better name that doesn't encode the OS architecture details.
BTW, can we decide what to do about 'trips' node being required or not? That's nearly the only DT warning left for some platforms.
Quoted 4 lines
Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 +
Please make bindings a separate patch.
Quoted 6 lines
drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)
Quoted 41 lines · Rob Herring
Quoted 40 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
Quoted 7 lines
Quoted 3 lines
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Sounds like OS behavior/policy though I guess the existing ones kind are too. Maybe we should have defined *what* action to take and then the OS could decide whether what actions to handle vs. pass it up a level.
Right
Quoted 2 lines
Why can't userspace just ask to be notified at a trip point it defines?
Yes I think it is possible to create a netlink message to create a trip point which will return a trip id.
Rafael what do you think ?
Quoted 2 lines
If we keep this in DT, perhaps 'notice' would be a better name that doesn't encode the OS architecture details.
[ ... ]
Quoted 2 lines
BTW, can we decide what to do about 'trips' node being required or not? That's nearly the only DT warning left for some platforms.
A thermal zone is a combination of a sensor, a mitigation logic (user or kernel), hardware limits with trip points to activate the logic. Without trip points, this logic can not operate, consequently the thermal zone description is incomplete.
I guess those thermal zones are set to have the sensor exported in /sys/class/thermal, so the userspace can access the temperature.
However, existing thermal zone description should have at least a 'hot' trip point and a 'critical' trip point.
On the other hand, now that we are introducing the 'user' trip point, those thermal zone can exist without trip points because we can create them at any time from userspace.
So at the first glance, I would say we can drop the "required" constraint for the trip points in the thermal zone description.
Quoted 13 lines
Quoted 3 lines
Signed-off-by Daniel Lezcano <[email protected]>--- .../devicetree/bindings/thermal/thermal-zones.yaml | 1 +Please make bindings a separate patch.
Quoted 6 lines
drivers/thermal/thermal_core.c | 8 ++++++++ drivers/thermal/thermal_of.c | 1 + drivers/thermal/thermal_trace.h | 4 +++- drivers/thermal/thermal_trip.c | 1 + include/uapi/linux/thermal.h | 1 + 6 files changed, 15 insertions(+), 1 deletion(-)
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
Rafael J. Wysocki
maintainerQuoted 53 lines · Daniel Lezcano
Quoted 41 lines · Rob Herring
Quoted 40 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
Quoted 7 lines
Quoted 3 lines
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Sounds like OS behavior/policy though I guess the existing ones kind are too. Maybe we should have defined *what* action to take and then the OS could decide whether what actions to handle vs. pass it up a level.
Right
Quoted 7 lines
Quoted 2 lines
Why can't userspace just ask to be notified at a trip point it defines?
Yes I think it is possible to create a netlink message to create a trip point which will return a trip id.
Rafael what do you think ?
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 5 lines
Quoted 2 lines
If we keep this in DT, perhaps 'notice' would be a better name that doesn't encode the OS architecture details.
[ ... ]
Quoted 7 lines
Quoted 2 lines
BTW, can we decide what to do about 'trips' node being required or not? That's nearly the only DT warning left for some platforms.
A thermal zone is a combination of a sensor, a mitigation logic (user or kernel), hardware limits with trip points to activate the logic. Without trip points, this logic can not operate, consequently the thermal zone description is incomplete.
Well, there is a concept of a tripless thermal zone which simply represents a sensor.
Quoted 2 lines
I guess those thermal zones are set to have the sensor exported in
/sys/class/thermal, so the userspace can access the temperature.
I think so.
Quoted 6 lines
However, existing thermal zone description should have at least a 'hot' trip point and a 'critical' trip point.
On the other hand, now that we are introducing the 'user' trip point, those thermal zone can exist without trip points because we can create them at any time from userspace.
No, they cannot be created at any time.
Quoted 2 lines
So at the first glance, I would say we can drop the "required" constraint for the trip points in the thermal zone description.
That's correct, but for other reasons.
Quoted 61 lines · Rafael J. Wysocki
Quoted 59 lines · Daniel Lezcano
Quoted 41 lines · Rob Herring
Quoted 40 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
Quoted 7 lines
Quoted 3 lines
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Sounds like OS behavior/policy though I guess the existing ones kind are too. Maybe we should have defined *what* action to take and then the OS could decide whether what actions to handle vs. pass it up a level.
Right
Quoted 2 lines
Why can't userspace just ask to be notified at a trip point it defines?
Yes I think it is possible to create a netlink message to create a trip point which will return a trip id.
Quoted 7 lines
Quoted 1 line
Rafael what do you think ?
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
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
Rafael J. Wysocki
maintainerQuoted 71 lines · Daniel Lezcano
Quoted 61 lines · Rafael J. Wysocki
Quoted 59 lines · Daniel Lezcano
Quoted 41 lines · Rob Herring
Quoted 40 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
Quoted 7 lines
Quoted 3 lines
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Sounds like OS behavior/policy though I guess the existing ones kind are too. Maybe we should have defined *what* action to take and then the OS could decide whether what actions to handle vs. pass it up a level.
Right
Quoted 2 lines
Why can't userspace just ask to be notified at a trip point it defines?
Yes I think it is possible to create a netlink message to create a trip point which will return a trip id.
Quoted 7 lines
Quoted 1 line
Rafael what do you think ?
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 6 lines
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
A different data structure to store them (essentially, a list instead of an array).
I doubt it's worth the hassle.
What's wrong with the current approach mentioned above? It will need to be supported going forward anyway.
Rafael J. Wysocki
maintainerQuoted 81 lines · Rafael J. Wysocki
Quoted 71 lines · Daniel Lezcano
Quoted 61 lines · Rafael J. Wysocki
Quoted 59 lines · Daniel Lezcano
Quoted 41 lines · Rob Herring
Quoted 40 lines · Daniel Lezcano
Currently the thermal framework has 4 trip point types:
- active : basically for fans (or anything requiring energy to cool down)
- passive : a performance limiter
- hot : for a last action before reaching critical
- critical : a without return threshold leading to a system shutdown
A thermal zone monitors the temperature regarding these trip points. The old way to do that is actively polling the temperature which is very bad for embedded systems, especially mobile and it is even worse today as we can have more than fifty thermal zones. The modern way is to rely on the driver to send an interrupt when the trip points are crossed, so the system can sleep while the temperature monitoring is offloaded to a dedicated hardware.
However, the thermal aspect is also managed from userspace to protect the user, especially tracking down the skin temperature sensor. The logic is more complex than what we found in the kernel because it needs multiple sources indicating the thermal situation of the entire system.
For this reason it needs to setup trip points at different levels in order to get informed about what is going on with some thermal zones when running some specific application.
For instance, the skin temperature must be limited to 43°C on a long run but can go to 48°C for 10 minutes, or 60°C for 1 minute.
The thermal engine must then rely on trip points to monitor those temperatures. Unfortunately, today there is only 'active' and 'passive' trip points which has a specific meaning for the kernel, not the userspace. That leads to hacks in different platforms for mobile and embedded systems where 'active' trip points are used to send notification to the userspace. This is obviously not right because these trip are handled by the kernel.
Quoted 7 lines
Quoted 3 lines
This patch introduces the 'user' trip point type where its semantic is
simple: do nothing at the kernel level, just send a notification to the user space.Sounds like OS behavior/policy though I guess the existing ones kind are too. Maybe we should have defined *what* action to take and then the OS could decide whether what actions to handle vs. pass it up a level.
Right
Quoted 2 lines
Why can't userspace just ask to be notified at a trip point it defines?
Yes I think it is possible to create a netlink message to create a trip point which will return a trip id.
Quoted 7 lines
Quoted 1 line
Rafael what do you think ?
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 6 lines
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
Quoted 7 lines
A different data structure to store them (essentially, a list instead of an array).
I doubt it's worth the hassle.
What's wrong with the current approach mentioned above? It will need to be supported going forward anyway.
BTW, there are two different concepts that seem to be mixed here.
One of them is a "trigger" that will cause a netlink message to be sent to user space when a given temperature level is crossed (either way) and nothing more. This in principle can be added to any thermal zone (even tripless) and should be possible to implement as a separate mechanism independent of trip points.
The other one is a pair of trip points that can be set "around" the current zone temperature so that the .set_trips() callback uses them to program interrupts to trigger when one of them is crossed. This at least requires the thermal zone to provide a .set_trips() callback, so it depends on the driver registering the thermal zone. Arguably, the driver in question can reserve a pair of "trip slots" in the trip table passed to the zone registration function.
On 02/07/2024 13:03, Rafael J. Wysocki wrote:
[ ... ]
Quoted 13 lines
Quoted 6 lines
Quoted 5 lines
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 6 lines
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
Quoted 7 lines
A different data structure to store them (essentially, a list instead of an array).
I doubt it's worth the hassle.
What's wrong with the current approach mentioned above? It will need to be supported going forward anyway.
So when the "user trip point" option will be set, a thermal zone will have ~ten(?) user trip points initialized to an invalid temperature ?
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
Rafael J. Wysocki
maintainerQuoted 21 lines · Daniel Lezcano
On 02/07/2024 13:03, Rafael J. Wysocki wrote:
[ ... ]
Quoted 16 lines
Quoted 6 lines
Quoted 5 lines
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 6 lines
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
A different data structure to store them (essentially, a list instead of an array).
Quoted 7 lines
Quoted 4 lines
I doubt it's worth the hassle.
What's wrong with the current approach mentioned above? It will need to be supported going forward anyway.
So when the "user trip point" option will be set, a thermal zone will have ~ten(?) user trip points initialized to an invalid temperature ?
If a thermal zone is registered with 10 invalid trip points, htat can happen already today.
Let's talk about the usage model, though.
IIUC, this would be something like "triggers" I mentioned before: If a certain temperature level is reached, a notification is sent to user space, and there are multiple (possibly many) levels like this. They can be added and deleted at any time.
There can be an interface for this, as simple as a pair of sysfs attributes under a thermal zone: add_trigger and remove_trigger. If root (or equivalent) writes a (valid) temperature value to add_trigger, a new trigger is added (up to a limit and provided that enough memory can be allocated). Conversely, if a temperature value is written to remove_trigger and there is a trigger with that temperature, it will be deleted.
Internally, the triggers can be stored in a sorted list (with some optimizations, so it need not be walked every time the zone temperature changes) or a tree, independent of the trips table (if any). Every time the zone temperature changes, the triggers list is consulted (in addition to the trips table) and if any of them have been crossed, notifications are sent to user space.
If polling is used, this would just work, but without polling the driver needs to support setting a pair (at least) of temperature levels causing an interrupt to occur. If a specific callback, say .set_triggers(), is provided by the driver, it can be used for setting those temperature levels to the triggers right above and right below the current zone temperature, in analogy with .set_trips().
Does this reflect what you are after?
Quoted 24 lines · Rafael J. Wysocki
Quoted 23 lines · Daniel Lezcano
On 02/07/2024 13:03, Rafael J. Wysocki wrote:
[ ... ]
Quoted 18 lines
Quoted 6 lines
Quoted 5 lines
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 6 lines
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
A different data structure to store them (essentially, a list instead of an array).
I doubt it's worth the hassle.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
What's wrong with the current approach mentioned above? It will need to be supported going forward anyway.
So when the "user trip point" option will be set, a thermal zone will have ~ten(?) user trip points initialized to an invalid temperature ?
If a thermal zone is registered with 10 invalid trip points, htat can happen already today.
IINW, this is the case for a particular driver (int340x_thermal_zone?), may be for a thermal zone. But in the general case where we can have more the 50 thermal zones it is not adequate as we will end up with more than 500 trip points overall.
Assuming it is the int340x_thermal_zone driver, it is active trip points, so that assumes the associated cooling device will be active. TBH, it is fuzzy regarding a notification mechanism
Quoted 1 line
Let's talk about the usage model, though.
Sure
Quoted 4 lines
IIUC, this would be something like "triggers" I mentioned before: If a certain temperature level is reached, a notification is sent to user space, and there are multiple (possibly many) levels like this. They can be added and deleted at any time.
Yes, except I don't think the usage will be to often creating trip points. More likely, depending on the kind of sensors and the associated logic, a number of trip points will created for a specific profile and then modified on the fly.
Quoted 7 lines
There can be an interface for this, as simple as a pair of sysfs attributes under a thermal zone:
add_triggerandremove_trigger. If root (or equivalent) writes a (valid) temperature value toadd_trigger, a new trigger is added (up to a limit and provided that enough memory can be allocated). Conversely, if a temperature value is written toremove_triggerand there is a trigger with that temperature, it will be deleted.
A hysteresis would be needed too. IMO, netlinks are more adequate for this purpose.
Quoted 6 lines
Internally, the triggers can be stored in a sorted list (with some optimizations, so it need not be walked every time the zone temperature changes) or a tree, independent of the trips table (if any). Every time the zone temperature changes, the triggers list is consulted (in addition to the trips table) and if any of them have been crossed, notifications are sent to user space.
So basically, thermal_zone_device_update() will browse two lists, triggers + trip points, right ?
Quoted 3 lines
If polling is used, this would just work, but without polling the driver needs to support setting a pair (at least) of temperature levels causing an interrupt to occur.
I'm missing this point, can you elaborate ?
Quoted 6 lines
If a specific callback, say
.set_triggers(), is provided by the driver, it can be used for setting those temperature levels to the triggers right above and right below the current zone temperature, in analogy with .set_trips().Does this reflect what you are after?
At the first glance I would say yes, but I don't get why it is more complicate to just add 'triggers' with the trip points (formerly 'user' trip points)
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
Rafael J. Wysocki
maintainerQuoted 35 lines · Daniel Lezcano
Quoted 24 lines · Rafael J. Wysocki
Quoted 23 lines · Daniel Lezcano
On 02/07/2024 13:03, Rafael J. Wysocki wrote:
[ ... ]
Quoted 18 lines
Quoted 6 lines
Quoted 5 lines
Trips cannot be created on the fly ATM.
What can be done is to create trips that are invalid to start with and then set their temperature via sysfs. This has been done already for quite a while AFAICS.
Quoted 6 lines
Yes, I remember that.
I would like to avoid introducing more weirdness in the thermal framework which deserve a clear ABI.
What is missing to create new trip points on the fly ?
A different data structure to store them (essentially, a list instead of an array).
I doubt it's worth the hassle.
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
What's wrong with the current approach mentioned above? It will need to be supported going forward anyway.
So when the "user trip point" option will be set, a thermal zone will have ~ten(?) user trip points initialized to an invalid temperature ?
If a thermal zone is registered with 10 invalid trip points, htat can happen already today.
Quoted 8 lines
IINW, this is the case for a particular driver (
int340x_thermal_zone?), may be for a thermal zone. But in the general case where we can have more the 50 thermal zones it is not adequate as we will end up with more than 500 trip points overall.Assuming it is the
int340x_thermal_zonedriver, it is active trip points, so that assumes the associated cooling device will be active. TBH, it is fuzzy regarding a notification mechanism
The trip points that are invalid to start with are passive IIRC, but the point I wanted to make was that the number of trip points, their type and whether or not they were invalid to start with depended on the driver registering a thermal zone. Drivers put whatever they like into the trips table today.
Quoted 9 lines
Quoted 1 line
Let's talk about the usage model, though.
Sure
Quoted 4 lines
IIUC, this would be something like "triggers" I mentioned before: If a certain temperature level is reached, a notification is sent to user space, and there are multiple (possibly many) levels like this. They can be added and deleted at any time.
Quoted 4 lines
Yes, except I don't think the usage will be to often creating trip points. More likely, depending on the kind of sensors and the associated logic, a number of trip points will created for a specific profile and then modified on the fly.
So I gather that you'd like the initial set to come from DT.
Quoted 10 lines
Quoted 7 lines
There can be an interface for this, as simple as a pair of sysfs attributes under a thermal zone:
add_triggerandremove_trigger. If root (or equivalent) writes a (valid) temperature value toadd_trigger, a new trigger is added (up to a limit and provided that enough memory can be allocated). Conversely, if a temperature value is written toremove_triggerand there is a trigger with that temperature, it will be deleted.A hysteresis would be needed too. IMO, netlinks are more adequate for this purpose.
That depends.
One way to implement hysteresis is to add a new trigger when an existing one is crossed, either below (on the way up) or above (on the way down) it, and remove it. Then you don't need an additional hysteresis value.
Quoted 9 lines
Quoted 6 lines
Internally, the triggers can be stored in a sorted list (with some optimizations, so it need not be walked every time the zone temperature changes) or a tree, independent of the trips table (if any). Every time the zone temperature changes, the triggers list is consulted (in addition to the trips table) and if any of them have been crossed, notifications are sent to user space.
So basically,
thermal_zone_device_update()will browse two lists, triggers + trip points, right ?
Right.
Quoted 5 lines
Quoted 3 lines
If polling is used, this would just work, but without polling the driver needs to support setting a pair (at least) of temperature levels causing an interrupt to occur.
I'm missing this point, can you elaborate ?
Polling guarantees that __thermal_zone_device_update() will be executed periodically and so it guarantees detection of crossing trip points (or trigger temperature levels).
If there is no polling, interrupts (or equivalent) need to be used to invoke __thermal_zone_device_update() when trips are crossed. Basically, if any of them is crossed, you need an interrupt.
Usually, however, hardware supports a limited number of temperature levels that can trigger interrupts and I wanted to make the point that it was sufficient for it to support two of them for the usage model in question.
Quoted 10 lines
Quoted 6 lines
If a specific callback, say
.set_triggers(), is provided by the driver, it can be used for setting those temperature levels to the triggers right above and right below the current zone temperature, in analogy with .set_trips().Does this reflect what you are after?
At the first glance I would say yes, but I don't get why it is more complicate to just add 'triggers' with the trip points (formerly 'user' trip points)
The most problematic part is the requirement to be able to add and remove "triggers" on the fly from user space. This requires two
things: (a) a user space interface for that and (b) a data structure suitable for adding and removing entries (ideally, a sorted one). None of these things exist for trip points today and the trip points in use today don't require any of them either. Adding more complexity to the already complex trip point implementation doesn't look particularly attractive to me.