All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH 0/1] hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver
@ 2026-11-16 16:32 Benedikt Niedermayr
  2026-11-16 16:32 ` [PATCH 1/1] " Benedikt Niedermayr
  0 siblings, 1 reply; 4+ messages in thread
From: Benedikt Niedermayr @ 2026-11-16 16:32 UTC (permalink / raw)
  To: benedikt.niedermayr, linux; +Cc: linux-hwmon, linux-kernel

Hi,

this patch adds a hardware monitoring driver for the embedded controller on
Siemens SIMATIC IPC BX-54A systems.

The driver loads directly via ACPI "_HID" which is reserved for Siemens.
See commit for more information.

I'm not the original author of this driver but I reviewed it as carefully as
possible and I would step in as maintainer for it.

This patch does not enable the hardware platform on which this controller is
present.
Instead I just routed the enablement through the i2c tree, which is currently
in review [1].
I wasn't expecting the review to take that long, so it's maybe better to route
the platform enablements through this tree instead... I dont know...

[1] https://patchwork.ozlabs.org/project/linux-i2c/patch/20261116142351.1228943-4-benedikt.niedermayr@siemens.com/

Best regards,
Benedikt

Benedikt Niedermayr (1):
  hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver

 MAINTAINERS                            |   6 +
 drivers/hwmon/Kconfig                  |  11 +
 drivers/hwmon/Makefile                 |   1 +
 drivers/hwmon/simatic-ipc-ec-sensors.c | 568 +++++++++++++++++++++++++
 4 files changed, 586 insertions(+)
 create mode 100644 drivers/hwmon/simatic-ipc-ec-sensors.c

--
2.43.0

^ permalink raw reply	[flat|nested] 4+ messages in thread

* [PATCH 1/1] hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver
  2026-11-16 16:32 [PATCH 0/1] hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver Benedikt Niedermayr
@ 2026-11-16 16:32 ` Benedikt Niedermayr
  2026-11-16 16:50   ` sashiko-bot
  0 siblings, 1 reply; 4+ messages in thread
From: Benedikt Niedermayr @ 2026-11-16 16:32 UTC (permalink / raw)
  To: benedikt.niedermayr, linux; +Cc: linux-hwmon, linux-kernel

Add a hardware monitoring driver for the embedded controller on
Siemens SIMATIC IPC BX-54A systems.

The driver binds to ACPI devices with HID prefix "110A" which is
currently a registered PCI ID for Siemens [1].

Looking at Dell, HP, Lenovo and ASUS this seems to be a common pattern
where vendors define custom ACPI tables for platform-specific features
that are not covered by standard ACPI tables (used by the ACPI EC
driver at drivers/acpi/ec.c).

[1] https://admin.pci-ids.ucw.cz/read/PC/110a

Signed-off-by: Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
---
 MAINTAINERS                            |   6 +
 drivers/hwmon/Kconfig                  |  11 +
 drivers/hwmon/Makefile                 |   1 +
 drivers/hwmon/simatic-ipc-ec-sensors.c | 568 +++++++++++++++++++++++++
 4 files changed, 586 insertions(+)
 create mode 100644 drivers/hwmon/simatic-ipc-ec-sensors.c

diff --git a/MAINTAINERS b/MAINTAINERS
index e70b2621ddb8..d54fc6b8c60e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -25908,6 +25908,12 @@ F:	drivers/media/mmc/siano/
 F:	drivers/media/usb/siano/
 F:	drivers/media/usb/siano/
 
+SIEMENS IPC EC SENSORS DRIVER
+M:	Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
+L:	linux-hwmon@vger.kernel.org
+S:	Maintained
+F:	drivers/hwmon/simatic-ipc-ec-sensors.c
+
 SIEMENS IPC LED DRIVERS
 M:	Bao Cheng Su <baocheng.su@siemens.com>
 M:	Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 576ddbfec7ab..6a319c963cd3 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -2931,6 +2931,17 @@ config SENSORS_HP_WMI
 	  This driver can also be built as a module. If so, the module
 	  will be called hp_wmi_sensors.
 
+config SENSORS_SIMATIC_IPC_EC
+	tristate "Siemens SIMATIC IPC EC Sensors"
+	depends on X86
+	depends on ACPI_EC
+	help
+	  If you say yes here you get support for the Embedded Controller (EC)
+	  sensors and fan control on Siemens SIMATIC IPCs (e.g. BX54-A).
+
+	  This driver can also be built as a module. If so, the module
+	  will be called simatic-ipc-ec-sensors.
+
 endif # ACPI
 
 endif # HWMON
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 3ee099699f6f..e3faffbde6e3 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
 obj-$(CONFIG_SENSORS_HONOR_FMI)	+= honor-fmi.o
 obj-$(CONFIG_SENSORS_HP_WMI)	+= hp-wmi-sensors.o
+obj-$(CONFIG_SENSORS_SIMATIC_IPC_EC) += simatic-ipc-ec-sensors.o
 
 # Native drivers
 # asb100, then w83781d go first, as they can override other drivers' addresses.
diff --git a/drivers/hwmon/simatic-ipc-ec-sensors.c b/drivers/hwmon/simatic-ipc-ec-sensors.c
new file mode 100644
index 000000000000..690da5dde2bf
--- /dev/null
+++ b/drivers/hwmon/simatic-ipc-ec-sensors.c
@@ -0,0 +1,568 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Driver for sensors and fan control on Siemens SIMATIC IPC embedded controllers.
+ *
+ * Due to historical reasons the ACPI description for the ec doesn't
+ * follow the standard ACPI descriptions for fans and hwmon sensors (using
+ * the generic drviers/acpi/ec.c driver).
+ *
+ * This driver binds to Siemens SIMATIC IPC embedded controller sensor devices.
+ *
+ * Copyright (c) Siemens AG, 2025-2026
+ *
+ * Authors:
+ *  Gao Nian <nian.gao@siemens.com>
+ *  Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
+ */
+#include <linux/acpi.h>
+#include <linux/ctype.h>
+#include <linux/err.h>
+#include <linux/hwmon.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+
+/*
+ * The ACPI ID domain "110A" belongs to Siemens
+ * https://admin.pci-ids.ucw.cz/read/PC/110a
+ */
+#define SIEMENS_FAN_HID		"110A5002"
+#define SIEMENS_HWMON_HID	"110A5004"
+
+#define CHIP_NAME_MAX_LEN	64
+
+/*
+ * All temperature sensors are located in an ACPI device with SIEMENS_HWMON_HID.
+ */
+#define TEMP_REG_CTR_STATUS		0	/* u8 */
+#define TEMP_REG_VALUE			1	/* char */
+#define TEMP_REG_ALARM_LOWLIMIT		2	/* char */
+#define TEMP_REG_ALARM_HIGHLIMIT	3	/* char */
+#define TEMP_REG_CRITICAL		4	/* char */
+
+#define SIZE_OF_TEMP_REG		5
+
+#define CRITICAL_SUPPORT		BIT(5)
+#define ALARM_SUPPORT			BIT(4)
+
+/*
+ * Each fan device is a separate ACPI device with the same SIEMENS_FAN_HID.
+ */
+#define FAN_REG_CTR_STATUS		0	/* u8 */
+#define FAN_REG_SPEED			1	/* u16 */
+#define FAN_REG_MODE			3	/* u8 */
+#define FAN_REG_DUTY_LEVEL		4	/* u8 */
+
+/*
+ * CONTROL MODE:
+ * 0: Full speed
+ * 1: Manual fan speed control enabled
+ * 2: Automatic fan speed control enabled
+ */
+#define CONTROL_MODE_MASK		(BIT(1) | BIT(0))
+#define CONTROL_MODE_GET(mode)		((mode) & CONTROL_MODE_MASK)
+
+struct simatic_ipc_ec_temp {
+	u8 base;
+	u8 count;
+};
+
+struct simatic_ipc_ec_fan {
+	u8 base;
+	const char *label;
+	char chip_name[CHIP_NAME_MAX_LEN];
+};
+
+struct simatic_ipc_ec_sensor {
+	struct simatic_ipc_ec_temp *temp;	/* Optional */
+	struct simatic_ipc_ec_fan *fan;	/* Optional */
+};
+
+static inline u8 temp_reg(u8 base, u8 ch, u8 offset)
+{
+	return base + ch * SIZE_OF_TEMP_REG + offset;
+}
+
+static inline u8 fan_reg(u8 base, u8 offset)
+{
+	return base + offset;
+}
+
+static umode_t simatic_ipc_ec_temp_is_visible(const struct simatic_ipc_ec_temp *temp,
+					      u32 attr, int channel)
+{
+	switch (attr) {
+	case hwmon_temp_input:
+		return 0444;
+	case hwmon_temp_max_alarm:
+	case hwmon_temp_min_alarm:
+	case hwmon_temp_crit:
+		return 0644;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static int simatic_ipc_ec_temp_read(const struct simatic_ipc_ec_temp *temp, u32 attr,
+				    int channel, long *val)
+{
+	s8 value;
+	int ret;
+	u8 reg;
+
+	switch (attr) {
+	case hwmon_temp_input:
+		reg = temp_reg(temp->base, channel, TEMP_REG_VALUE);
+		break;
+	case hwmon_temp_max_alarm:
+		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_HIGHLIMIT);
+		break;
+	case hwmon_temp_min_alarm:
+		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_LOWLIMIT);
+		break;
+	case hwmon_temp_crit:
+		reg = temp_reg(temp->base, channel, TEMP_REG_CRITICAL);
+		break;
+	default:
+		return -EOPNOTSUPP;
+	}
+
+	ret = ec_read(reg, &value);
+
+	/* Degree Celsius to millidegree Celsius */
+	*val = value * 1000;
+
+	return ret;
+}
+
+static int simatic_ipc_ec_temp_write(const struct simatic_ipc_ec_temp *temp, u32 attr,
+				     int channel, long val)
+{
+	/*
+	 * Millidegree Celsius to degree Celsius
+	 */
+	s8 value = (s8)clamp((s8)DIV_ROUND_CLOSEST(val, 1000), (s8)-128, (s8)127);
+	u8 reg;
+
+	switch (attr) {
+	case hwmon_temp_max_alarm:
+		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_HIGHLIMIT);
+		break;
+	case hwmon_temp_min_alarm:
+		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_LOWLIMIT);
+		break;
+	case hwmon_temp_crit:
+		reg = temp_reg(temp->base, channel, TEMP_REG_CRITICAL);
+		break;
+	default:
+		return -EOPNOTSUPP;
+	}
+
+	return ec_write(reg, value);
+}
+
+static umode_t simatic_ipc_ec_fan_is_visible(const struct simatic_ipc_ec_fan *fan,
+					     enum hwmon_sensor_types type, u32 attr,
+					     int channel)
+{
+	switch (type) {
+	case hwmon_fan:
+		switch (attr) {
+		case hwmon_fan_input:
+		case hwmon_fan_label:
+			return 0444;
+		default:
+			break;
+		}
+		break;
+	case hwmon_pwm:
+		switch (attr) {
+		case hwmon_pwm_input:
+		case hwmon_pwm_enable:
+			return 0644;
+		default:
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static int simatic_ipc_ec_read_block(u8 addr, void *buf, u8 n)
+{
+	int ret;
+	u8 i;
+
+	for (i = 0; i < n; i++) {
+		ret = ec_read(addr + i, &((u8 *)buf)[i]);
+		if (ret < 0)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int simatic_ipc_ec_fan_read(struct simatic_ipc_ec_fan *fan, enum hwmon_sensor_types type,
+				   u32 attr, int channel, long *val)
+{
+	u16 value_u16;
+	u8 value_u8;
+	int ret;
+	u8 reg;
+
+	switch (type) {
+	case hwmon_fan:
+		switch (attr) {
+		case hwmon_fan_input:
+			reg = fan_reg(fan->base, FAN_REG_SPEED);
+			ret = simatic_ipc_ec_read_block(reg, &value_u16, sizeof(value_u16));
+			*val = value_u16;
+			return ret;
+		default:
+			break;
+		}
+		break;
+	case hwmon_pwm:
+		switch (attr) {
+		case hwmon_pwm_input:
+			reg = fan_reg(fan->base, FAN_REG_DUTY_LEVEL);
+			ret = ec_read(reg, &value_u8);
+			*val = value_u8;
+			return ret;
+		case hwmon_pwm_enable:
+			reg = fan_reg(fan->base, FAN_REG_MODE);
+			ret = ec_read(reg, &value_u8);
+			*val = CONTROL_MODE_GET(value_u8);
+			return ret;
+		default:
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+
+	return -EOPNOTSUPP;
+}
+
+static int simatic_ipc_ec_fan_read_string(struct simatic_ipc_ec_fan *fan, u32 attr,
+					 const char **str)
+{
+	switch (attr) {
+	case hwmon_fan_label:
+		*str = fan->label;
+		return 0;
+	default:
+		break;
+	}
+
+	return -EOPNOTSUPP;
+}
+
+static int simatic_ipc_ec_fan_set_control_mode(struct simatic_ipc_ec_fan *fan, u8 ctrl_mode)
+{
+	int ret;
+	u8 mode;
+
+	/* 0: full speed, 1: mannual control, 2: auto-control */
+	if (ctrl_mode > 2)
+		return -EINVAL;
+
+	ret = ec_read(fan_reg(fan->base, FAN_REG_MODE), &mode);
+	if (ret < 0)
+		return ret;
+
+	mode &= ~CONTROL_MODE_MASK;
+	mode |= ctrl_mode;
+
+	ret = ec_write(fan_reg(fan->base, FAN_REG_MODE), mode);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int simatic_ipc_ec_fan_write(struct simatic_ipc_ec_fan *fan, u32 attr, int channel,
+				    long val)
+{
+	switch (attr) {
+	case hwmon_pwm_input:
+		if (val < 0 || val > 0xFF)
+			return -EINVAL;
+		return ec_write(fan_reg(fan->base, FAN_REG_DUTY_LEVEL), (u8)val);
+	case hwmon_pwm_enable:
+		return simatic_ipc_ec_fan_set_control_mode(fan, (u8)val);
+	default:
+		break;
+	}
+
+	return -EOPNOTSUPP;
+}
+
+static umode_t simatic_ipc_ec_is_visible(const void *drvdata, enum hwmon_sensor_types type,
+					u32 attr, int channel)
+{
+	const struct simatic_ipc_ec_sensor *data = drvdata;
+	umode_t ret = 0;
+
+	switch (type) {
+	case hwmon_temp:
+		if (data->temp)
+			ret = simatic_ipc_ec_temp_is_visible(data->temp, attr, channel);
+		break;
+	case hwmon_fan:
+	case hwmon_pwm:
+		if (data->fan)
+			ret = simatic_ipc_ec_fan_is_visible(data->fan, type, attr, channel);
+		break;
+	default:
+		break;
+	}
+
+	return ret;
+}
+
+static int simatic_ipc_ec_read(struct device *dev, enum hwmon_sensor_types type,
+			       u32 attr, int channel, long *val)
+{
+	struct simatic_ipc_ec_sensor *data = dev_get_drvdata(dev);
+
+	switch (type) {
+	case hwmon_temp:
+		return simatic_ipc_ec_temp_read(data->temp, attr, channel, val);
+	case hwmon_fan:
+	case hwmon_pwm:
+		return simatic_ipc_ec_fan_read(data->fan, type, attr, channel, val);
+	default:
+		break;
+	}
+
+	return -EOPNOTSUPP;
+}
+
+static int simatic_ipc_ec_read_string(struct device *dev, enum hwmon_sensor_types type,
+				     u32 attr, int channel, const char **str)
+{
+	struct simatic_ipc_ec_sensor *data = dev_get_drvdata(dev);
+
+	switch (type) {
+	case hwmon_fan:
+	case hwmon_pwm:
+		return simatic_ipc_ec_fan_read_string(data->fan, attr, str);
+	default:
+		break;
+	}
+
+	return -EOPNOTSUPP;
+}
+
+static int simatic_ipc_ec_write(struct device *dev, enum hwmon_sensor_types type,
+			       u32 attr, int channel, long val)
+{
+	struct simatic_ipc_ec_sensor *data = dev_get_drvdata(dev);
+
+	switch (type) {
+	case hwmon_temp:
+		return simatic_ipc_ec_temp_write(data->temp, attr, channel, val);
+	case hwmon_fan:
+	case hwmon_pwm:
+		return simatic_ipc_ec_fan_write(data->fan, attr, channel, val);
+	default:
+		break;
+	}
+
+	return -EOPNOTSUPP;
+}
+
+static const struct hwmon_ops simatic_ipc_ec_ops = {
+	.is_visible = simatic_ipc_ec_is_visible,
+	.read = simatic_ipc_ec_read,
+	.read_string = simatic_ipc_ec_read_string,
+	.write = simatic_ipc_ec_write,
+};
+
+/*
+ * The number of temperature sensor's channels comes from ACPI as it may be different for
+ * different projects.
+ */
+static struct hwmon_channel_info simatic_ipc_ec_temp_ch_info = {
+	.type = hwmon_temp,
+	.config = NULL
+};
+
+static const struct hwmon_channel_info *simatic_ipc_ec_hwmon_ch_info[] = {
+	&simatic_ipc_ec_temp_ch_info,
+	NULL
+};
+
+static const struct hwmon_channel_info *simatic_ipc_ec_fan_ch_info[] = {
+	HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_LABEL),
+	HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
+	NULL
+};
+
+static const struct hwmon_chip_info simatic_ipc_ec_hwmon_info = {
+	.ops = &simatic_ipc_ec_ops,
+	.info = simatic_ipc_ec_hwmon_ch_info,
+};
+
+static const struct hwmon_chip_info simatic_ipc_ec_fan_info = {
+	.ops = &simatic_ipc_ec_ops,
+	.info = simatic_ipc_ec_fan_ch_info,
+};
+
+static int simatic_ipc_ec_hwmon_probe(struct device *dev, struct simatic_ipc_ec_sensor *data)
+{
+	struct simatic_ipc_ec_temp *temp;
+	struct device *hwmon_dev;
+	u32 *temp_config;
+	u8 temp_count;
+	u8 temp_base;
+	u8 value;
+	int ret;
+	u8 ch;
+
+	ret = device_property_read_u8(dev, "TempRegOffset", &temp_base);
+	if (ret < 0)
+		return ret;
+
+	ret = device_property_read_u8(dev, "TempCount", &temp_count);
+	if (ret < 0)
+		return ret;
+
+	temp = devm_kzalloc(dev, sizeof(*temp), GFP_KERNEL);
+	if (!temp)
+		return -ENOMEM;
+
+	temp_config = devm_kzalloc(dev, (temp_count + 1) * sizeof(u32), GFP_KERNEL);
+	if (!temp_config)
+		return -ENOMEM;
+
+	simatic_ipc_ec_temp_ch_info.config = temp_config;
+
+	temp->base = temp_base;
+	temp->count = temp_count;
+
+	data->temp = temp;
+
+	/* Dynamically create temperature sensor channels */
+	for (ch = 0; ch < temp_count; ch++) {
+		ret = ec_read(temp_reg(temp_base, ch, TEMP_REG_CTR_STATUS), &value);
+		if (ret < 0)
+			return ret;
+
+		temp_config[ch] |= HWMON_T_INPUT;
+
+		if (value & ALARM_SUPPORT)
+			temp_config[ch] |= HWMON_T_MIN_ALARM | HWMON_T_MAX_ALARM;
+
+		if (value & CRITICAL_SUPPORT)
+			temp_config[ch] |= HWMON_T_CRIT;
+	}
+
+	hwmon_dev = devm_hwmon_device_register_with_info(dev, "simatic_ipc_ec_hwmon",
+							 data, &simatic_ipc_ec_hwmon_info,
+							 NULL);
+
+	return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+
+static int simatic_ipc_ec_fan_probe(struct device *dev, struct simatic_ipc_ec_sensor *data)
+{
+	struct device *hwmon_dev;
+	struct simatic_ipc_ec_fan *fan;
+	const char *label, *fan_name = NULL;
+	u8 fan_base;
+	int ret;
+
+	ret = device_property_read_u8(dev, "RegOffset", &fan_base);
+	if (ret < 0)
+		return ret;
+
+	ret = device_property_read_string(dev, "Label", &label);
+	if (ret < 0)
+		return ret;
+
+	device_property_read_string(dev, "FanName", &fan_name);
+
+	fan = devm_kzalloc(dev, sizeof(*fan), GFP_KERNEL);
+	if (!fan)
+		return -ENOMEM;
+
+	fan->base = fan_base;
+	fan->label = fan_name ? fan_name : label;
+
+	if (fan_name) {
+		char *p;
+
+		snprintf(fan->chip_name, CHIP_NAME_MAX_LEN, "simatic_ipc_ec_%s", fan_name);
+		for (p = fan->chip_name; *p; p++)
+			*p = tolower(*p);
+	} else {
+		snprintf(fan->chip_name, CHIP_NAME_MAX_LEN, "simatic_ipc_ec_%s", label);
+	}
+
+	data->fan = fan;
+
+	hwmon_dev = devm_hwmon_device_register_with_info(dev, fan->chip_name, data,
+							 &simatic_ipc_ec_fan_info,
+							 NULL);
+
+	return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+
+static int simatic_ipc_ec_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct simatic_ipc_ec_sensor *data;
+	const char *hid;
+	int ret;
+
+	/* The same HID sensor device may not be on the EC. */
+	ret = device_property_match_string(dev, "ChipType", "ec");
+	if (ret < 0)
+		return -ENODEV;
+
+	hid = acpi_device_hid(to_acpi_device_node(dev->fwnode));
+
+	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	if (!strcmp(hid, SIEMENS_HWMON_HID))
+		ret = simatic_ipc_ec_hwmon_probe(dev, data);
+	else if (!strcmp(hid, SIEMENS_FAN_HID))
+		ret = simatic_ipc_ec_fan_probe(dev, data);
+	else
+		ret = -EINVAL;
+
+	return ret;
+}
+
+static const struct acpi_device_id simatic_ipc_ec_sensors_ids[] = {
+	{SIEMENS_HWMON_HID},
+	{SIEMENS_FAN_HID},
+	{}
+};
+
+MODULE_DEVICE_TABLE(acpi, simatic_ipc_ec_sensors_ids);
+
+static struct platform_driver simatic_ipc_ec_sensors_driver = {
+	.probe = simatic_ipc_ec_probe,
+	.driver = {
+		.name = KBUILD_MODNAME,
+		.acpi_match_table = simatic_ipc_ec_sensors_ids
+	},
+};
+
+module_platform_driver(simatic_ipc_ec_sensors_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Gao Nian <nian.gao@siemens.com>");
+MODULE_DESCRIPTION("Siemens SIMATIC IPC embedded controller sensors driver");
-- 
2.43.0


^ permalink raw reply related	[flat|nested] 4+ messages in thread

* Re: [PATCH 1/1] hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver
  2026-11-16 16:32 ` [PATCH 1/1] " Benedikt Niedermayr
@ 2026-11-16 16:50   ` sashiko-bot
  2026-11-16 20:38     ` Guenter Roeck
  0 siblings, 1 reply; 4+ messages in thread
From: sashiko-bot @ 2026-11-16 16:50 UTC (permalink / raw)
  To: Benedikt Niedermayr; +Cc: linux-hwmon

Thank you for your contribution! Sashiko AI review found 8 potential
issues to consider:
- [High] hwmon: simatic-ipc-ec-sensors: temp limits exposed as *_alarm
  attributes
- [High] hwmon: pointer-sign mismatch passing s8 * to ec_read() in temp
  read callback
- [Medium] hwmon: premature s8 cast before clamp() in
  simatic_ipc_ec_temp_write()
- [Medium] hwmon: u8 truncation in simatic_ipc_ec_fan_write() bypasses
  range check
- [Medium] hwmon: uninitialized reads on ec_read() error in temp and fan
  read callbacks
- [Medium] hwmon: devm buffer stored in global struct in
  simatic_ipc_ec_hwmon_probe()
- [Low] hwmon: unsanitized and unlowercased chip_name in
  simatic_ipc_ec_fan_probe()
- [Low] hwmon: simatic-ipc-ec-sensors: missing Documentation/hwmon/
  driver doc
--

commit 830c0088242b1976cce59ca2195a3aaabae749d2
Author: Benedikt Niedermayr <benedikt.niedermayr@siemens.com>

hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver

This commit adds a hardware monitoring driver for temperature sensors and
fan control on the embedded controller of Siemens SIMATIC IPC BX-54A
systems.

> diff --git a/MAINTAINERS b/MAINTAINERS
> index ccbcdc0799b9f..8e567b60f6487 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -25763,6 +25763,12 @@ F:	drivers/media/mmc/siano/
>  F:	drivers/media/usb/siano/
>  F:	drivers/media/usb/siano/
>  
> +SIEMENS IPC EC SENSORS DRIVER
> +M:	Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
> +L:	linux-hwmon@vger.kernel.org
> +S:	Maintained
> +F:	drivers/hwmon/simatic-ipc-ec-sensors.c

[Severity: Low]
New hwmon drivers require a documentation file under
Documentation/hwmon/simatic-ipc-ec-sensors.rst per
Documentation/hwmon/submitting-patches.rst.

[ ... ]

> diff --git a/drivers/hwmon/simatic-ipc-ec-sensors.c b/drivers/hwmon/simatic-ipc-ec-sensors.c
> new file mode 100644
> index 0000000000000..690da5dde2bf8
> --- /dev/null
> +++ b/drivers/hwmon/simatic-ipc-ec-sensors.c
> @@ -0,0 +1,568 @@

[ ... ]

> +static umode_t simatic_ipc_ec_temp_is_visible(const struct simatic_ipc_ec_temp *temp,
> +					      u32 attr, int channel)
> +{
> +	switch (attr) {
> +	case hwmon_temp_input:
> +		return 0444;
> +	case hwmon_temp_max_alarm:
> +	case hwmon_temp_min_alarm:
> +	case hwmon_temp_crit:
> +		return 0644;
> +	default:
> +		break;
> +	}
> +
> +	return 0;
> +}
> +
> +static int simatic_ipc_ec_temp_read(const struct simatic_ipc_ec_temp *temp, u32 attr,
> +				    int channel, long *val)
> +{
> +	s8 value;
> +	int ret;
> +	u8 reg;
> +
> +	switch (attr) {
> +	case hwmon_temp_input:
> +		reg = temp_reg(temp->base, channel, TEMP_REG_VALUE);
> +		break;
> +	case hwmon_temp_max_alarm:
> +		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_HIGHLIMIT);
> +		break;
> +	case hwmon_temp_min_alarm:
> +		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_LOWLIMIT);
> +		break;
> +	case hwmon_temp_crit:
> +		reg = temp_reg(temp->base, channel, TEMP_REG_CRITICAL);
> +		break;
> +	default:
> +		return -EOPNOTSUPP;
> +	}

[Severity: High]
Should the low and high temperature thresholds use hwmon_temp_min and
hwmon_temp_max (with HWMON_T_MIN and HWMON_T_MAX in
simatic_ipc_ec_hwmon_probe()) instead of hwmon_temp_min_alarm and
hwmon_temp_max_alarm?

Under the hwmon ABI, tempX_min_alarm and tempX_max_alarm are read-only
boolean flags (0 or 1), so exposing writable millidegree Celsius limits
there causes tools like libsensors to treat any non-zero limit as an
active alarm while missing the min and max thresholds.

> +
> +	ret = ec_read(reg, &value);

[Severity: High]
Does passing &value (s8 *) to ec_read(u8, u8 *) trigger a -Wpointer-sign
warning (and build failure under CONFIG_WERROR)?

> +
> +	/* Degree Celsius to millidegree Celsius */
> +	*val = value * 1000;
> +
> +	return ret;
> +}
> +
> +static int simatic_ipc_ec_temp_write(const struct simatic_ipc_ec_temp *temp, u32 attr,
> +				     int channel, long val)
> +{
> +	/*
> +	 * Millidegree Celsius to degree Celsius
> +	 */
> +	s8 value = (s8)clamp((s8)DIV_ROUND_CLOSEST(val, 1000), (s8)-128, (s8)127);

[Severity: Medium]
Does casting the result of DIV_ROUND_CLOSEST(val, 1000) to s8 before
clamp() make clamp() a no-op?

Because the first argument is already truncated to s8, writing a threshold
outside [-128000, 127499] wraps modulo 256 instead of saturating (for
example, 130000 wraps to -126 C), and values near LONG_MAX or LONG_MIN can
also overflow DIV_ROUND_CLOSEST(val, 1000) unless val is clamped before
division.

[ ... ]

> +static int simatic_ipc_ec_fan_read(struct simatic_ipc_ec_fan *fan, enum hwmon_sensor_types type,
> +				   u32 attr, int channel, long *val)
> +{
> +	u16 value_u16;
> +	u8 value_u8;
> +	int ret;
> +	u8 reg;
> +
> +	switch (type) {
> +	case hwmon_fan:
> +		switch (attr) {
> +		case hwmon_fan_input:
> +			reg = fan_reg(fan->base, FAN_REG_SPEED);
> +			ret = simatic_ipc_ec_read_block(reg, &value_u16, sizeof(value_u16));
> +			*val = value_u16;
> +			return ret;
> +		default:
> +			break;
> +		}
> +		break;
> +	case hwmon_pwm:
> +		switch (attr) {
> +		case hwmon_pwm_input:
> +			reg = fan_reg(fan->base, FAN_REG_DUTY_LEVEL);
> +			ret = ec_read(reg, &value_u8);
> +			*val = value_u8;
> +			return ret;
> +		case hwmon_pwm_enable:
> +			reg = fan_reg(fan->base, FAN_REG_MODE);
> +			ret = ec_read(reg, &value_u8);
> +			*val = CONTROL_MODE_GET(value_u8);
> +			return ret;

[Severity: Medium]
When ec_read() or simatic_ipc_ec_read_block() fails here and in
simatic_ipc_ec_temp_read(), does assigning *val read uninitialized stack
variables (value_u16, value_u8, and value)?  ec_read() leaves its output
parameter untouched on error, which triggers KMSAN uninitialized-memory
warnings when *val is computed before checking ret.

[ ... ]

> +static int simatic_ipc_ec_fan_set_control_mode(struct simatic_ipc_ec_fan *fan, u8 ctrl_mode)
> +{
> +	int ret;
> +	u8 mode;
> +
> +	/* 0: full speed, 1: mannual control, 2: auto-control */
> +	if (ctrl_mode > 2)
> +		return -EINVAL;

[ ... ]

> +static int simatic_ipc_ec_fan_write(struct simatic_ipc_ec_fan *fan, u32 attr, int channel,
> +				    long val)
> +{
> +	switch (attr) {
> +	case hwmon_pwm_input:
> +		if (val < 0 || val > 0xFF)
> +			return -EINVAL;
> +		return ec_write(fan_reg(fan->base, FAN_REG_DUTY_LEVEL), (u8)val);
> +	case hwmon_pwm_enable:
> +		return simatic_ipc_ec_fan_set_control_mode(fan, (u8)val);

[Severity: Medium]
Does casting val to u8 before calling simatic_ipc_ec_fan_set_control_mode()
allow out-of-range values such as 256 or -255 to bypass the ctrl_mode > 2
check and change the EC fan control mode?

[ ... ]

> +static struct hwmon_channel_info simatic_ipc_ec_temp_ch_info = {
> +	.type = hwmon_temp,
> +	.config = NULL
> +};

[ ... ]

> +static int simatic_ipc_ec_hwmon_probe(struct device *dev, struct simatic_ipc_ec_sensor *data)
> +{

[ ... ]

> +	temp_config = devm_kzalloc(dev, (temp_count + 1) * sizeof(u32), GFP_KERNEL);
> +	if (!temp_config)
> +		return -ENOMEM;
> +
> +	simatic_ipc_ec_temp_ch_info.config = temp_config;

[Severity: Medium]
Can storing the per-device devm-allocated temp_config into the static
global simatic_ipc_ec_temp_ch_info.config leave a dangling pointer on probe
failure or unbind, or overwrite another instance's config if more than one
110A5004 device is probed?

[ ... ]

> +static int simatic_ipc_ec_fan_probe(struct device *dev, struct simatic_ipc_ec_sensor *data)
> +{

[ ... ]

> +	if (fan_name) {
> +		char *p;
> +
> +		snprintf(fan->chip_name, CHIP_NAME_MAX_LEN, "simatic_ipc_ec_%s", fan_name);
> +		for (p = fan->chip_name; *p; p++)
> +			*p = tolower(*p);
> +	} else {
> +		snprintf(fan->chip_name, CHIP_NAME_MAX_LEN, "simatic_ipc_ec_%s", label);
> +	}

[Severity: Low]
What happens if label contains uppercase characters when fan_name is
absent, or if either string contains characters disallowed in hwmon chip
names such as '-' or spaces?

The else branch skips the tolower() loop, and neither branch sanitizes
characters rejected by __hwmon_device_register() (or via
devm_hwmon_sanitize_name()).

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261116163257.1303207-1-benedikt.niedermayr@siemens.com?part=1

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH 1/1] hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver
  2026-11-16 16:50   ` sashiko-bot
@ 2026-11-16 20:38     ` Guenter Roeck
  0 siblings, 0 replies; 4+ messages in thread
From: Guenter Roeck @ 2026-11-16 20:38 UTC (permalink / raw)
  To: sashiko-reviews, Benedikt Niedermayr; +Cc: linux-hwmon

Hi,

On 11/16/26 08:50, sashiko-bot@kernel.org wrote:
> Thank you for your contribution! Sashiko AI review found 8 potential
> issues to consider:
> - [High] hwmon: simatic-ipc-ec-sensors: temp limits exposed as *_alarm
>    attributes
> - [High] hwmon: pointer-sign mismatch passing s8 * to ec_read() in temp
>    read callback
> - [Medium] hwmon: premature s8 cast before clamp() in
>    simatic_ipc_ec_temp_write()
> - [Medium] hwmon: u8 truncation in simatic_ipc_ec_fan_write() bypasses
>    range check
> - [Medium] hwmon: uninitialized reads on ec_read() error in temp and fan
>    read callbacks
> - [Medium] hwmon: devm buffer stored in global struct in
>    simatic_ipc_ec_hwmon_probe()
> - [Low] hwmon: unsanitized and unlowercased chip_name in
>    simatic_ipc_ec_fan_probe()
> - [Low] hwmon: simatic-ipc-ec-sensors: missing Documentation/hwmon/
>    driver doc

Please fix.

Tanks,
Guenter

> --
> 
> commit 830c0088242b1976cce59ca2195a3aaabae749d2
> Author: Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
> 
> hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver
> 
> This commit adds a hardware monitoring driver for temperature sensors and
> fan control on the embedded controller of Siemens SIMATIC IPC BX-54A
> systems.
> 
>> diff --git a/MAINTAINERS b/MAINTAINERS
>> index ccbcdc0799b9f..8e567b60f6487 100644
>> --- a/MAINTAINERS
>> +++ b/MAINTAINERS
>> @@ -25763,6 +25763,12 @@ F:	drivers/media/mmc/siano/
>>   F:	drivers/media/usb/siano/
>>   F:	drivers/media/usb/siano/
>>   
>> +SIEMENS IPC EC SENSORS DRIVER
>> +M:	Benedikt Niedermayr <benedikt.niedermayr@siemens.com>
>> +L:	linux-hwmon@vger.kernel.org
>> +S:	Maintained
>> +F:	drivers/hwmon/simatic-ipc-ec-sensors.c
> 
> [Severity: Low]
> New hwmon drivers require a documentation file under
> Documentation/hwmon/simatic-ipc-ec-sensors.rst per
> Documentation/hwmon/submitting-patches.rst.
> 
> [ ... ]
> 
>> diff --git a/drivers/hwmon/simatic-ipc-ec-sensors.c b/drivers/hwmon/simatic-ipc-ec-sensors.c
>> new file mode 100644
>> index 0000000000000..690da5dde2bf8
>> --- /dev/null
>> +++ b/drivers/hwmon/simatic-ipc-ec-sensors.c
>> @@ -0,0 +1,568 @@
> 
> [ ... ]
> 
>> +static umode_t simatic_ipc_ec_temp_is_visible(const struct simatic_ipc_ec_temp *temp,
>> +					      u32 attr, int channel)
>> +{
>> +	switch (attr) {
>> +	case hwmon_temp_input:
>> +		return 0444;
>> +	case hwmon_temp_max_alarm:
>> +	case hwmon_temp_min_alarm:
>> +	case hwmon_temp_crit:
>> +		return 0644;
>> +	default:
>> +		break;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int simatic_ipc_ec_temp_read(const struct simatic_ipc_ec_temp *temp, u32 attr,
>> +				    int channel, long *val)
>> +{
>> +	s8 value;
>> +	int ret;
>> +	u8 reg;
>> +
>> +	switch (attr) {
>> +	case hwmon_temp_input:
>> +		reg = temp_reg(temp->base, channel, TEMP_REG_VALUE);
>> +		break;
>> +	case hwmon_temp_max_alarm:
>> +		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_HIGHLIMIT);
>> +		break;
>> +	case hwmon_temp_min_alarm:
>> +		reg = temp_reg(temp->base, channel, TEMP_REG_ALARM_LOWLIMIT);
>> +		break;
>> +	case hwmon_temp_crit:
>> +		reg = temp_reg(temp->base, channel, TEMP_REG_CRITICAL);
>> +		break;
>> +	default:
>> +		return -EOPNOTSUPP;
>> +	}
> 
> [Severity: High]
> Should the low and high temperature thresholds use hwmon_temp_min and
> hwmon_temp_max (with HWMON_T_MIN and HWMON_T_MAX in
> simatic_ipc_ec_hwmon_probe()) instead of hwmon_temp_min_alarm and
> hwmon_temp_max_alarm?
> 
> Under the hwmon ABI, tempX_min_alarm and tempX_max_alarm are read-only
> boolean flags (0 or 1), so exposing writable millidegree Celsius limits
> there causes tools like libsensors to treat any non-zero limit as an
> active alarm while missing the min and max thresholds.
> 
>> +
>> +	ret = ec_read(reg, &value);
> 
> [Severity: High]
> Does passing &value (s8 *) to ec_read(u8, u8 *) trigger a -Wpointer-sign
> warning (and build failure under CONFIG_WERROR)?
> 
>> +
>> +	/* Degree Celsius to millidegree Celsius */
>> +	*val = value * 1000;
>> +
>> +	return ret;
>> +}
>> +
>> +static int simatic_ipc_ec_temp_write(const struct simatic_ipc_ec_temp *temp, u32 attr,
>> +				     int channel, long val)
>> +{
>> +	/*
>> +	 * Millidegree Celsius to degree Celsius
>> +	 */
>> +	s8 value = (s8)clamp((s8)DIV_ROUND_CLOSEST(val, 1000), (s8)-128, (s8)127);
> 
> [Severity: Medium]
> Does casting the result of DIV_ROUND_CLOSEST(val, 1000) to s8 before
> clamp() make clamp() a no-op?
> 
> Because the first argument is already truncated to s8, writing a threshold
> outside [-128000, 127499] wraps modulo 256 instead of saturating (for
> example, 130000 wraps to -126 C), and values near LONG_MAX or LONG_MIN can
> also overflow DIV_ROUND_CLOSEST(val, 1000) unless val is clamped before
> division.
> 
> [ ... ]
> 
>> +static int simatic_ipc_ec_fan_read(struct simatic_ipc_ec_fan *fan, enum hwmon_sensor_types type,
>> +				   u32 attr, int channel, long *val)
>> +{
>> +	u16 value_u16;
>> +	u8 value_u8;
>> +	int ret;
>> +	u8 reg;
>> +
>> +	switch (type) {
>> +	case hwmon_fan:
>> +		switch (attr) {
>> +		case hwmon_fan_input:
>> +			reg = fan_reg(fan->base, FAN_REG_SPEED);
>> +			ret = simatic_ipc_ec_read_block(reg, &value_u16, sizeof(value_u16));
>> +			*val = value_u16;
>> +			return ret;
>> +		default:
>> +			break;
>> +		}
>> +		break;
>> +	case hwmon_pwm:
>> +		switch (attr) {
>> +		case hwmon_pwm_input:
>> +			reg = fan_reg(fan->base, FAN_REG_DUTY_LEVEL);
>> +			ret = ec_read(reg, &value_u8);
>> +			*val = value_u8;
>> +			return ret;
>> +		case hwmon_pwm_enable:
>> +			reg = fan_reg(fan->base, FAN_REG_MODE);
>> +			ret = ec_read(reg, &value_u8);
>> +			*val = CONTROL_MODE_GET(value_u8);
>> +			return ret;
> 
> [Severity: Medium]
> When ec_read() or simatic_ipc_ec_read_block() fails here and in
> simatic_ipc_ec_temp_read(), does assigning *val read uninitialized stack
> variables (value_u16, value_u8, and value)?  ec_read() leaves its output
> parameter untouched on error, which triggers KMSAN uninitialized-memory
> warnings when *val is computed before checking ret.
> 
> [ ... ]
> 
>> +static int simatic_ipc_ec_fan_set_control_mode(struct simatic_ipc_ec_fan *fan, u8 ctrl_mode)
>> +{
>> +	int ret;
>> +	u8 mode;
>> +
>> +	/* 0: full speed, 1: mannual control, 2: auto-control */
>> +	if (ctrl_mode > 2)
>> +		return -EINVAL;
> 
> [ ... ]
> 
>> +static int simatic_ipc_ec_fan_write(struct simatic_ipc_ec_fan *fan, u32 attr, int channel,
>> +				    long val)
>> +{
>> +	switch (attr) {
>> +	case hwmon_pwm_input:
>> +		if (val < 0 || val > 0xFF)
>> +			return -EINVAL;
>> +		return ec_write(fan_reg(fan->base, FAN_REG_DUTY_LEVEL), (u8)val);
>> +	case hwmon_pwm_enable:
>> +		return simatic_ipc_ec_fan_set_control_mode(fan, (u8)val);
> 
> [Severity: Medium]
> Does casting val to u8 before calling simatic_ipc_ec_fan_set_control_mode()
> allow out-of-range values such as 256 or -255 to bypass the ctrl_mode > 2
> check and change the EC fan control mode?
> 
> [ ... ]
> 
>> +static struct hwmon_channel_info simatic_ipc_ec_temp_ch_info = {
>> +	.type = hwmon_temp,
>> +	.config = NULL
>> +};
> 
> [ ... ]
> 
>> +static int simatic_ipc_ec_hwmon_probe(struct device *dev, struct simatic_ipc_ec_sensor *data)
>> +{
> 
> [ ... ]
> 
>> +	temp_config = devm_kzalloc(dev, (temp_count + 1) * sizeof(u32), GFP_KERNEL);
>> +	if (!temp_config)
>> +		return -ENOMEM;
>> +
>> +	simatic_ipc_ec_temp_ch_info.config = temp_config;
> 
> [Severity: Medium]
> Can storing the per-device devm-allocated temp_config into the static
> global simatic_ipc_ec_temp_ch_info.config leave a dangling pointer on probe
> failure or unbind, or overwrite another instance's config if more than one
> 110A5004 device is probed?
> 
> [ ... ]
> 
>> +static int simatic_ipc_ec_fan_probe(struct device *dev, struct simatic_ipc_ec_sensor *data)
>> +{
> 
> [ ... ]
> 
>> +	if (fan_name) {
>> +		char *p;
>> +
>> +		snprintf(fan->chip_name, CHIP_NAME_MAX_LEN, "simatic_ipc_ec_%s", fan_name);
>> +		for (p = fan->chip_name; *p; p++)
>> +			*p = tolower(*p);
>> +	} else {
>> +		snprintf(fan->chip_name, CHIP_NAME_MAX_LEN, "simatic_ipc_ec_%s", label);
>> +	}
> 
> [Severity: Low]
> What happens if label contains uppercase characters when fan_name is
> absent, or if either string contains characters disallowed in hwmon chip
> names such as '-' or spaces?
> 
> The else branch skips the tolower() loop, and neither branch sanitizes
> characters rejected by __hwmon_device_register() (or via
> devm_hwmon_sanitize_name()).
> 


^ permalink raw reply	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2026-11-16 20:38 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-16 16:32 [PATCH 0/1] hwmon: simatic-ipc-ec-sensors: add BX-54A EC driver Benedikt Niedermayr
2026-11-16 16:32 ` [PATCH 1/1] " Benedikt Niedermayr
2026-11-16 16:50   ` sashiko-bot
2026-11-16 20:38     ` Guenter Roeck

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.