hwmon: scmi: Scale values to target desired HWMON units
Subsystems (2)
v4 cover hwmon: scmi: Scale values to target desired HWMON units
Hi Sudeep, Guenter,
This patch series adds support for scaling SCMI sensor values read from firmware. Sudeep, let me know if you think we should be treating scale == 0 as a special value to preserve some firmware compatibility (not that this would be desired).
Changes in v4:
- deal with overflow in the caller of __pow10() as suggested by Guenter which makes us rework a bit how the value argument/return value are passed
- don't harcode the latest power of 10 factor to be 18, just rely on overflowing the u64 value instead
Changes in v3:
- add a local __pow10 function to scmi-hwmon.c while a plan to provide a generic function is figured out.
- add check on power > 18 which would overflow a 64-bit unsigned integer
- use div64_u64() to properly divide a 64-bit quantity with an unsigned 64-bit quantity
Changes in v2:
- added a helper function in kernel.h: __pow10()
- made the scale in scmi_sensor_info an s8 type, added defines for checking the sign bit and sign extending with a mask
- simplify computations in hwmon driver
Florian Fainelli (2):
firmware: arm_scmi: Fetch and store sensor scale
hwmon: scmi: Scale values to target desired HWMON units
drivers/firmware/arm_scmi/sensors.c | 6 ++++ drivers/hwmon/scmi-hwmon.c | 46 +++++++++++++++++++++++++++++ include/linux/scmi_protocol.h | 1 + 3 files changed, 53 insertions(+)
Signature · 1 line
2.17.1
PATCH v4 1/2 firmware: arm_scmi: Fetch and store sensor scale
In preparation for dealing with scales within the SCMI HWMON driver, fetch and store the sensor unit scale into the scmi_sensor_info structure. In order to simplify computations for upper layer, take care of sign extending the scale to a full 8-bit signed value.
--- drivers/firmware/arm_scmi/sensors.c | 6 ++++++ include/linux/scmi_protocol.h | 1 + 2 files changed, 7 insertions(+)
drivers/firmware/arm_scmi/sensors.c +6 -0
@@ -34,6 +34,8 @@ struct scmi_msg_resp_sensor_description {__le32 attributes_high;#define SENSOR_TYPE (x) ((x) & 0xff)#define SENSOR_SCALE (x) (((x) >> 11) & 0x3f) +#define SENSOR_SCALE_SIGN BIT(5) +#define SENSOR_SCALE_EXTEND GENMASK(7, 6)#define SENSOR_UPDATE_SCALE (x) (((x) >> 22) & 0x1f)#define SENSOR_UPDATE_BASE (x) (((x) >> 27) & 0x1f)u8 name[SCMI_MAX_STR_SIZE ];
@@ -140,6 +142,10 @@ static int scmi_sensor_description_get(const struct scmi_handle *handle, s = &si->sensors[desc_index + cnt]; s->id =le32_to_cpu (buf->desc[cnt].id); s->type =SENSOR_TYPE (attrh); + s->scale =SENSOR_SCALE (attrh); +/* Sign extend to a full s8 */ +if (s->scale &SENSOR_SCALE_SIGN ) + s->scale |=SENSOR_SCALE_EXTEND ;strlcpy (s->name, buf->desc[cnt].name,SCMI_MAX_STR_SIZE ); }
include/linux/scmi_protocol.h +1 -0
@@ -144,6 +144,7 @@ struct scmi_power_ops {struct scmi_sensor_info {u32 id;u8 type; +s8 scale;char name[SCMI_MAX_STR_SIZE ]; };
Signature · 1 line
2.17.1
Re: [PATCH v4 1/2] firmware: arm_scmi: Fetch and store sensor scale
Quoted 6 lines · Florian Fainelli
In preparation for dealing with scales within the SCMI HWMON driver, fetch and store the sensor unit scale into the
scmi_sensor_infostructure. In order to simplify computations for upper layer, take care of sign extending the scale to a full 8-bit signed value.Signed-off-by Florian Fainelli <[email protected]>
Quoted 44 lines
--- drivers/firmware/arm_scmi/sensors.c | 6 ++++++ include/linux/scmi_protocol.h | 1 + 2 files changed, 7 insertions(+)drivers/firmware/arm_scmi/sensors.c +6
-0@@ -34,6 +34,8 @@ struct scmi_msg_resp_sensor_description {__le32 attributes_high;#define SENSOR_TYPE (x) ((x) & 0xff)#define SENSOR_SCALE (x) (((x) >> 11) & 0x3f) +#define SENSOR_SCALE_SIGN BIT(5) +#define SENSOR_SCALE_EXTEND GENMASK(7, 6)#define SENSOR_UPDATE_SCALE (x) (((x) >> 22) & 0x1f)#define SENSOR_UPDATE_BASE (x) (((x) >> 27) & 0x1f)u8 name[SCMI_MAX_STR_SIZE ];@@ -140,6 +142,10 @@ static int scmi_sensor_description_get(const struct scmi_handle *handle, s = &si->sensors[desc_index + cnt]; s->id =le32_to_cpu (buf->desc[cnt].id); s->type =SENSOR_TYPE (attrh); + s->scale =SENSOR_SCALE (attrh); +/* Sign extend to a full s8 */ +if (s->scale &SENSOR_SCALE_SIGN ) + s->scale |=SENSOR_SCALE_EXTEND ;strlcpy (s->name, buf->desc[cnt].name,SCMI_MAX_STR_SIZE ); }include/linux/scmi_protocol.h +1
-0@@ -144,6 +144,7 @@ struct scmi_power_ops {struct scmi_sensor_info {u32 id;u8 type; +s8 scale;char name[SCMI_MAX_STR_SIZE ]; };Signature · 1 line
2.17.1
PATCH v4 2/2 hwmon: scmi: Scale values to target desired HWMON units
In reply to Florian FainelliIf the SCMI firmware implementation is reporting values in a scale that is different from the HWMON units, we need to scale up or down the value according to how far appart they are.
--- drivers/hwmon/scmi-hwmon.c | 46 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+)
drivers/hwmon/scmi-hwmon.c +46 -0
@@ -7,6 +7,7 @@*/ #include <linux/hwmon.h> +#include <linux/limits.h> #include <linux/module.h> #include <linux/scmi_protocol.h> #include <linux/slab.h>
@@ -18,6 +19,47 @@ struct scmi_sensors {const struct scmi_sensor_info **info[hwmon_max]; }; +static inline u64 __pow10 (u8 x) +{ +u64 r =1 ; + +while (x--) + r *=10 ; + +return r; +} + +static int scmi_hwmon_scale (const struct scmi_sensor_info *sensor,u64 *value) +{ +s8 scale = sensor->scale; +u64 f; + +switch (sensor->type) { +case TEMPERATURE_C : +case VOLTAGE : +case CURRENT : + scale +=3 ; +break ; +case POWER : +case ENERGY : + scale +=6 ; +break ; +default : +break ; + } + + f =__pow10 (abs (scale)); +if (f ==U64_MAX ) +return -E2BIG ; + +if (scale >0 ) + *value *= f; +else + *value =div64_u64 (*value, f); + +return 0 ; +} +static int scmi_hwmon_read (struct device *dev,enum hwmon_sensor_types type,u32 attr,int channel,long *val) {
@@ -29,6 +71,10 @@ static int scmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type, sensor = *(scmi_sensors->info[type] + channel); ret = h->sensor_ops->reading_get (h, sensor->id, false, &value); +if (ret) +return ret; + + ret =scmi_hwmon_scale (sensor, value);if (!ret) *val = value;
Signature · 1 line
2.17.1
Guenter Roeck
maintainerHi Florian,
Quoted 47 lines · Florian Fainelli
If the SCMI firmware implementation is reporting values in a scale that is different from the HWMON units, we need to scale up or down the value according to how far appart they are.
Signed-off-by Florian Fainelli <[email protected]>--- drivers/hwmon/scmi-hwmon.c | 46 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+)drivers/hwmon/scmi-hwmon.c +23
-0@@ -7,6 +7,7 @@*/ #include <linux/hwmon.h> +#include <linux/limits.h> #include <linux/module.h> #include <linux/scmi_protocol.h> #include <linux/slab.h> @@ -18,6 +19,47 @@ struct scmi_sensors {const struct scmi_sensor_info **info[hwmon_max]; }; +static inline u64 __pow10 (u8 x) +{ +u64 r =1 ; + +while (x--) + r *=10 ; + +return r; +} + +static int scmi_hwmon_scale (const struct scmi_sensor_info *sensor,u64 *value) +{ +s8 scale = sensor->scale; +u64 f; + +switch (sensor->type) { +case TEMPERATURE_C : +case VOLTAGE : +case CURRENT : + scale +=3 ; +break ; +case POWER :
drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 53
Quoted 10 lines
drivers/hwmon/scmi-hwmon.c +10
-0+case ENERGY : + scale +=6 ; +break ; +default : +break ; + } + + f =__pow10 (abs (scale)); +if (f ==U64_MAX ) +return -E2BIG ;
Unfortunately that is not how integer overflows work.
A test program with increasing values of scale reports:
0: 1
...
18: 1000000000000000000
19: 10000000000000000000
20: 7766279631452241920
21: 3875820019684212736
22: 1864712049423024128
23: 200376420520689664
24: 2003764205206896640
...
61: 11529215046068469760
62: 4611686018427387904
63: 9223372036854775808
64: 0
...
You'll have to check for abs(scale) > 19 if you want to report overflows.
Guenter
Quoted 26 lines
drivers/hwmon/scmi-hwmon.c +13
-0+ +if (scale >0 ) + *value *= f; +else + *value =div64_u64 (*value, f); + +return 0 ; +} +static int scmi_hwmon_read (struct device *dev,enum hwmon_sensor_types type,u32 attr,int channel,long *val) {@@ -29,6 +71,10 @@ static int scmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type, sensor = *(scmi_sensors->info[type] + channel); ret = h->sensor_ops->reading_get (h, sensor->id, false, &value); +if (ret) +return ret; + + ret =scmi_hwmon_scale (sensor, value);if (!ret) *val = value;Signature · 1 line
2.17.1
Quoted 81 lines · Guenter Roeck
Hi Florian,
Quoted 47 lines · Florian Fainelli
If the SCMI firmware implementation is reporting values in a scale that is different from the HWMON units, we need to scale up or down the value according to how far appart they are.
Signed-off-by Florian Fainelli <[email protected]>--- drivers/hwmon/scmi-hwmon.c | 46 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+)drivers/hwmon/scmi-hwmon.c +23
-0@@ -7,6 +7,7 @@*/ #include <linux/hwmon.h> +#include <linux/limits.h> #include <linux/module.h> #include <linux/scmi_protocol.h> #include <linux/slab.h> @@ -18,6 +19,47 @@ struct scmi_sensors {const struct scmi_sensor_info **info[hwmon_max]; }; +static inline u64 __pow10 (u8 x) +{ +u64 r =1 ; + +while (x--) + r *=10 ; + +return r; +} + +static int scmi_hwmon_scale (const struct scmi_sensor_info *sensor,u64 *value) +{ +s8 scale = sensor->scale; +u64 f; + +switch (sensor->type) { +case TEMPERATURE_C : +case VOLTAGE : +case CURRENT : + scale +=3 ; +break ; +case POWER :drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 53
Quoted 10 lines
drivers/hwmon/scmi-hwmon.c +10
-0+case ENERGY : + scale +=6 ; +break ; +default : +break ; + } + + f =__pow10 (abs (scale)); +if (f ==U64_MAX ) +return -E2BIG ;Unfortunately that is not how integer overflows work.
A test program with increasing values of scale reports:
0: 1
...
18: 1000000000000000000
19: 10000000000000000000
20: 7766279631452241920
21: 3875820019684212736
22: 1864712049423024128
23: 200376420520689664
24: 2003764205206896640
...
61: 11529215046068469760
62: 4611686018427387904
63: 9223372036854775808
64: 0
...
Quoted 1 line
You'll have to check for abs(scale) > 19 if you want to report overflows.
Yes silly me, my test program was flawed, thanks for pointing out that. You are okay with returning E2BIG when we overflow?
Signature · 1 line
Florian
Guenter Roeck
maintainerQuoted 82 lines · Florian Fainelli
Quoted 81 lines · Guenter Roeck
Hi Florian,
Quoted 47 lines · Florian Fainelli
If the SCMI firmware implementation is reporting values in a scale that is different from the HWMON units, we need to scale up or down the value according to how far appart they are.
Signed-off-by Florian Fainelli <[email protected]>--- drivers/hwmon/scmi-hwmon.c | 46 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+)drivers/hwmon/scmi-hwmon.c +23
-0@@ -7,6 +7,7 @@*/ #include <linux/hwmon.h> +#include <linux/limits.h> #include <linux/module.h> #include <linux/scmi_protocol.h> #include <linux/slab.h> @@ -18,6 +19,47 @@ struct scmi_sensors {const struct scmi_sensor_info **info[hwmon_max]; }; +static inline u64 __pow10 (u8 x) +{ +u64 r =1 ; + +while (x--) + r *=10 ; + +return r; +} + +static int scmi_hwmon_scale (const struct scmi_sensor_info *sensor,u64 *value) +{ +s8 scale = sensor->scale; +u64 f; + +switch (sensor->type) { +case TEMPERATURE_C : +case VOLTAGE : +case CURRENT : + scale +=3 ; +break ; +case POWER :drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 53
Quoted 10 lines
drivers/hwmon/scmi-hwmon.c +10
-0+case ENERGY : + scale +=6 ; +break ; +default : +break ; + } + + f =__pow10 (abs (scale)); +if (f ==U64_MAX ) +return -E2BIG ;Unfortunately that is not how integer overflows work.
A test program with increasing values of scale reports:
0: 1
...
18: 1000000000000000000
19: 10000000000000000000
20: 7766279631452241920
21: 3875820019684212736
22: 1864712049423024128
23: 200376420520689664
24: 2003764205206896640
...
61: 11529215046068469760
62: 4611686018427387904
63: 9223372036854775808
64: 0
...
Quoted 4 lines
Quoted 1 line
You'll have to check for abs(scale) > 19 if you want to report overflows.
Yes silly me, my test program was flawed, thanks for pointing out that. You are okay with returning E2BIG when we overflow?
Yes.
Thanks,
Guenter