Skip to contentSkip to conversation

hwmon: scmi: Scale values to target desired HWMON units

PATCH In review Florian Fainelli 3 participants 10 messages May 8, 2019 – May 14, 2019

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

v5 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 v5:
- overflow check would not work, so check specifically for an absolute scale being greater than 19 to avoid returning an incorrect power of 10 factor
- fixed incorrect value argument passed to scmi_hwmon_scale().
- Added Guenter's Reviewed-by tag on the first patch

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          | 45 +++++++++++++++++++++++++++++
 include/linux/scmi_protocol.h       |  1 +
 3 files changed, 52 insertions(+)
Signature · 1 line
2.17.1
#1 lore raw

PATCH v5 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
index b53d5cc9c9f6..21353470a740 100644
@@ -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
index 3105055c00a7..9ff2e9357e9a 100644
@@ -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
#2 lore raw

PATCH v5 2/2 hwmon: scmi: Scale values to target desired HWMON units

In reply to 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.

---
 drivers/hwmon/scmi-hwmon.c | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
drivers/hwmon/scmi-hwmon.c +45 -0
index a80183a488c5..2c7b87edf5aa 100644
@@ -18,6 +18,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;
+	}
+
+	if (abs(scale) > 19)
+		return -E2BIG;
+
+	f = __pow10(abs(scale));
+	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 +70,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
maintainer Reviewed-by on v5 2/2
#3 lore raw
Quoted 5 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.

Question is which tree this series should go through. I am fine with arm.

Thanks,
Guenter

Quoted 70 lines
---
 drivers/hwmon/scmi-hwmon.c | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
drivers/hwmon/scmi-hwmon.c +45 -0
index a80183a488c5..2c7b87edf5aa 100644
@@ -18,6 +18,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;
+	}
+
+	if (abs(scale) > 19)
+		return -E2BIG;
+
+	f = __pow10(abs(scale));
+	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 +70,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
#4 lore raw
Quoted 10 lines · Guenter Roeck
Quoted 5 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.

Question is which tree this series should go through. I am fine with arm.

Fine with me as well, Sudeep are you picking up these patches or should they go through HWMON and Guenter?

Signature · 1 line
Florian
#5 lore raw
Quoted 6 lines · Florian Fainelli
Quoted 5 lines · Guenter Roeck
Quoted 4 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.

Quoted 8 lines
Quoted 5 lines
Quoted 1 line

Question is which tree this series should go through. I am fine with arm.

Fine with me as well, Sudeep are you picking up these patches or should they go through HWMON and Guenter?

Sure I can pick and send it to arm-soc for v5.3

--
Regards,
Sudeep

#6 lore raw
In reply to Florian Fainelli
Quoted 36 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.

---
 drivers/hwmon/scmi-hwmon.c | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
drivers/hwmon/scmi-hwmon.c +19 -0
index a80183a488c5..2c7b87edf5aa 100644
@@ -18,6 +18,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:

drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 49

Quoted 10 lines
drivers/hwmon/scmi-hwmon.c +10 -0
+		scale += 3;
+		break;
+	case POWER:
+	case ENERGY:
+		scale += 6;
+		break;
+	default:
+		break;
+	}
+

I was applying this and wanted to check if we can add a check for scale=0 here and return early here to above the below check and __pow10(0) ?

Let me know if you agree. I can fix up. Also I will try to test it on Juno if firmware behaves correctly :)

--
Regards,
Sudeep

#7 lore raw
Quoted 42 lines · Sudeep Holla
Quoted 41 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.

---
 drivers/hwmon/scmi-hwmon.c | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
drivers/hwmon/scmi-hwmon.c +24 -0
index a80183a488c5..2c7b87edf5aa 100644
@@ -18,6 +18,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;
Quoted 8 lines

drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 49

Quoted 5 lines
drivers/hwmon/scmi-hwmon.c +5 -0
+		break;
+	default:
+		break;
+	}
+

I was applying this and wanted to check if we can add a check for scale=0 here and return early here to above the below check and __pow10(0) ?

Doing an early check for scale == 0 sounds like a good idea,good catch! Feel free to amend the patch directly when you apply it.

Quoted 3 lines

Let me know if you agree. I can fix up. Also I will try to test it on Juno if firmware behaves correctly :)

Great, thanks.

Signature · 1 line
Florian
maintainer
#8 lore raw
Quoted 52 lines · Florian Fainelli
Quoted 42 lines · Sudeep Holla
Quoted 41 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.

---
 drivers/hwmon/scmi-hwmon.c | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
drivers/hwmon/scmi-hwmon.c +24 -0
index a80183a488c5..2c7b87edf5aa 100644
@@ -18,6 +18,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;
Quoted 8 lines

drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 49

Quoted 5 lines
drivers/hwmon/scmi-hwmon.c +5 -0
+		break;
+	default:
+		break;
+	}
+

I was applying this and wanted to check if we can add a check for scale=0 here and return early here to above the below check and __pow10(0) ?

Quoted 3 lines

Doing an early check for scale == 0 sounds like a good idea,good catch! Feel free to amend the patch directly when you apply it.

Ok with me. Just make it == 0 :-).

Guenter

Quoted 7 lines
Quoted 3 lines

Let me know if you agree. I can fix up. Also I will try to test it on Juno if firmware behaves correctly :)

Great, thanks.

Signature · 1 line
Florian
#9 lore raw
Quoted 53 lines · Guenter Roeck
Quoted 52 lines · Florian Fainelli
Quoted 50 lines · Sudeep Holla
Quoted 36 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.

---
 drivers/hwmon/scmi-hwmon.c | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
drivers/hwmon/scmi-hwmon.c +19 -0
index a80183a488c5..2c7b87edf5aa 100644
@@ -18,6 +18,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:

drivers/hwmon/scmi-hwmon.c struct scmi_sensors { · line 49

Quoted 10 lines
drivers/hwmon/scmi-hwmon.c +10 -0
+		scale += 3;
+		break;
+	case POWER:
+	case ENERGY:
+		scale += 6;
+		break;
+	default:
+		break;
+	}
+

I was applying this and wanted to check if we can add a check for scale=0 here and return early here to above the below check and __pow10(0) ?

Quoted 6 lines
Quoted 3 lines

Doing an early check for scale == 0 sounds like a good idea,good catch! Feel free to amend the patch directly when you apply it.

Ok with me. Just make it == 0 :-).

Thanks Guenter and Florian for quick response, done now.

--
Regards,
Sudeep