Skip to contentSkip to conversation

misc: amd-sbi: Refactor SBTSI driver with I3C support and ioctl interface

PATCH Superseded Akshay Gupta 3 participants 13 messages May 15 – May 28

Subsystems (3)

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v2 cover misc: amd-sbi: Refactor SBTSI driver with I3C support and ioctl interface

This series refactors the AMD SB-TSI (Side-Band Temperature Sensor Interface) driver by moving the core from the hwmon subsystem into the drivers/misc/amd-sbi framework, alongside the existing SB-RMI driver. Registers an auxiliary device keeping hwmon sensors functionality intact.

Background:
The SB-TSI driver currently lives under drivers/hwmon/sbtsi_temp.c and is limited to exposing temperature readings via the hwmon interface. As AMD platforms evolve, SB-TSI access is required from multiple consumers (hwmon, userspace via ioctl, I3C-attached devices), making the hwmon-only placement insufficient.

This series restructures the driver into a layered design:

- tsi-core.c : core register access and ioctl/miscdevice support
- tsi.c : I2C/I3C probe and glue
- sbtsi_temp.c : hwmon sensor layer built on top of the core using aux device

Changes in this series:
1. Move core SBTSI driver probe from drivers/hwmon into drivers/misc/amd-sbi, and registering an auxiliary device in core for hwmon subsystem probing

2. Register order follows the device ReadOrder bit so both parts latch atomically; limit registers (temp / temp1_max / temp1_min) use the same helpers instead of separate SMBus calls.

3. Move sbtsi register transfer to core abstraction to decouple the hwmon sensor driver from the underlying bus transport. Preparing for I3C support in a subsequent patch

4. Extend the driver to support SB-TSI over I3C in addition to I2C. Both buses share the same core read/write path via sbtsi_xfer(); the is_i3c flag selects the underlying transport at probe time. Backward compatibility with existing I2C deployments is maintained.

5. Add a miscdevice (/dev/sbtsi-<addr>) and an ioctl interface (SBTSI_IOCTL_REG_XFER_CMD) that allows root userspace to perform SB-TSI register read/write operations through the APML protocol, consistent with the existing SBRMI ioctl interface.

6. Document the new SBTSI miscdevice and its ioctl in Documentation/misc-devices/amd-sbi.rst.

Testing:
Tested on AMD Genoa/Turin/Venice BMC platforms with both I2C and I3C-attached SB-TSI targets. hwmon sysfs attributes (tempX_input, tempX_max, etc.) and ioctl register transfers verified against hardware.

Prathima (6):
hwmon/misc: amd-sbi: Move core sbtsi support from hwmon to misc
hwmon: sbtsi_temp: Refactor temperature register access into helpers hwmon/misc: amd-sbi: Move sbtsi register transfer to core abstraction
misc: amd-sbi: Add support for SB-TSI over I3C
misc: amd-sbi: Add SBTSI ioctl register transfer interface
docs: misc: amd-sbi: Document SBTSI userspace interface

 Documentation/misc-devices/amd-sbi.rst |  64 ++++++++
 drivers/hwmon/Kconfig                  |   2 +-
 drivers/hwmon/sbtsi_temp.c             | 158 ++++++++++----------
 drivers/misc/amd-sbi/Kconfig           |  13 ++
 drivers/misc/amd-sbi/Makefile          |   3 +
 drivers/misc/amd-sbi/tsi-core.c        | 148 ++++++++++++++++++
 drivers/misc/amd-sbi/tsi-core.h        |  15 ++
 drivers/misc/amd-sbi/tsi.c             | 198 +++++++++++++++++++++++++
 include/linux/misc/tsi.h               |  63 ++++++++
 include/uapi/misc/amd-apml.h           |  23 +++
 10 files changed, 604 insertions(+), 83 deletions(-)
 create mode 100644 drivers/misc/amd-sbi/tsi-core.c
 create mode 100644 drivers/misc/amd-sbi/tsi-core.h
 create mode 100644 drivers/misc/amd-sbi/tsi.c
 create mode 100644 include/linux/misc/tsi.h
Signature · 1 line
2.34.1
#1 lore raw

PATCH v2 1/6 hwmon/misc: amd-sbi: Move core sbtsi support from hwmon to misc

From: Prathima <[email protected]>

Move SBTSI(Side-Band Temperature Sensor Interface) core functionality out of the hwmon-only path and into drivers/misc/amd-sbi so it can be reused by non-hwmon consumers.

I2C probe parsing is moved from drivers/hwmon/sbtsi_temp.c into drivers/misc/amd-sbi/tsi.c under CONFIG_AMD_SBTSI. The core driver stores struct sbtsi_data on the bus device and registers an auxiliary device amd-sbtsi.temp-sensor.<addr> per target.

This split prepares the driver for additional interfaces while keeping hwmon support in hwmon subsystem on top of common SBTSI core logic.

---
Changes since v1:
- Use auxiliary device to probe hwmon sensor instead of moving the hwmon functionality to misc subsystem. This change is as per feedback.

 drivers/hwmon/Kconfig         |   2 +-
 drivers/hwmon/sbtsi_temp.c    |  73 ++++---------------
 drivers/misc/amd-sbi/Kconfig  |  13 ++++
 drivers/misc/amd-sbi/Makefile |   3 +
 drivers/misc/amd-sbi/tsi.c    | 129 ++++++++++++++++++++++++++++++++++
 include/linux/misc/tsi.h      |  34 +++++++++
 6 files changed, 194 insertions(+), 60 deletions(-)
 create mode 100644 drivers/misc/amd-sbi/tsi.c
 create mode 100644 include/linux/misc/tsi.h
drivers/hwmon/Kconfig +1 -1
index 14e4cea48acc..6fa51e6ef6ff 100644
@@ -1939,7 +1939,7 @@ config SENSORS_SL28CPLD
 
 config SENSORS_SBTSI
 	tristate "Emulated SB-TSI temperature sensor"
-	depends on I2C
+	depends on AMD_SBTSI
 	help
 	  If you say yes here you get support for emulated temperature
 	  sensors on AMD SoCs with SB-TSI interface connected to a BMC device.
drivers/hwmon/sbtsi_temp.c +14 -59

121 lines not on this page · raw message

drivers/misc/amd-sbi/Kconfig +13 -0
index 30e7fad7356c..512251690e0e 100644
@@ -20,3 +20,16 @@ config AMD_SBRMI_HWMON
 	  This provides support for RMI device hardware monitoring. If enabled,
 	  a hardware monitoring device will be created for each socket in
 	  the system.
+
+config AMD_SBTSI
+	tristate "AMD side band TSI support"
+	depends on I2C
+	depends on ARM || ARM64 || COMPILE_TEST
+	select AUXILIARY_BUS
+	help
+	  Enables support for the AMD SB-TSI (Side Band Temperature Sensor
+	  Interface) driver, which provides access to emulated CPU temperature
+	  sensors on AMD SoCs via an I2C connected BMC device.
+
+	  This driver can also be built as a module. If so, the module will
+	  be called sbtsi.
drivers/misc/amd-sbi/Makefile +3 -0
index 38eaaa651fd9..28f95b9e204f 100644
@@ -2,3 +2,6 @@
 sbrmi-i2c-objs  		+= rmi-i2c.o rmi-core.o
 sbrmi-i2c-$(CONFIG_AMD_SBRMI_HWMON)	+= rmi-hwmon.o
 obj-$(CONFIG_AMD_SBRMI_I2C)	+= sbrmi-i2c.o
+# SBTSI Configuration
+sbtsi-objs	+= tsi.o
+obj-$(CONFIG_AMD_SBTSI)	+= sbtsi.o
drivers/misc/amd-sbi/tsi.c new file +129 -0

129 lines not on this page · raw message

include/linux/misc/tsi.h new file +34 -0
new file mode 100644
index 000000000000..6f7177edbcf5
@@ -0,0 +1,34 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * AMD SBTSI shared data structure and auxiliary bus definitions.
+ *
+ * Copyright (C) 2026 Advanced Micro Devices, Inc.
+ */
+
+#ifndef _LINUX_TSI_H_
+#define _LINUX_TSI_H_
+
+#include <linux/i2c.h>
+#include <linux/types.h>
+
+/**
+ * struct sbtsi_data - driver private data for an AMD SB-TSI device
+ * @client:	underlying I2C client
+ * @ext_range_mode:	sensor uses extended temperature range
+ * @read_order:	if set, decimal part must be read before integer part
+ */
+struct sbtsi_data {
+	struct i2c_client *client;
+	bool ext_range_mode;
+	bool read_order;
+};
+
+/*
+ * Name of the auxiliary device published on the auxiliary bus by the core
+ * driver.  The full device name is "amd-sbtsi.temp-sensor.<id>". where
+ * <id> is the auxiliary device instance id.
+ */
+#define AMD_SBTSI_ADEV		"amd-sbtsi"
+#define AMD_SBTSI_AUX_HWMON	"temp-sensor"
+
+#endif /* _LINUX_TSI_H_ */
Signature · 1 line
2.34.1
#2 lore raw

Re: [PATCH v2 1/6] hwmon/misc: amd-sbi: Move core sbtsi support from hwmon to misc

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [High] Auxiliary device ID collision prevents probe of multiple SB-TSI sensors - [Medium] Kconfig…

Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [High] Auxiliary device ID collision prevents probe of multiple SB-TSI sensors
- [Medium] Kconfig dependency change causes silent loss of the hwmon driver on kernel upgrades --

commit fe75a41fdaa2ec32654699f9128ef6e13b7c7140
Author: Prathima <[email protected]>

hwmon/misc: amd-sbi: Move core sbtsi support from hwmon to misc

This commit moves the core Side-Band Temperature Sensor Interface (SBTSI) logic into drivers/misc/amd-sbi/tsi.c. It registers an auxiliary device per target so that the hwmon driver can bind to it while allowing other consumers to reuse the core functionality.

drivers/hwmon/Kconfig config SENSORS_SL28CPLD · line 1942

Quoted 10 lines
drivers/hwmon/Kconfig +1 -1
index 14e4cea48acc4..6fa51e6ef6ff4 100644
@@ -1939,7 +1939,7 @@ config SENSORS_SL28CPLD
 
 config SENSORS_SBTSI
 	tristate "Emulated SB-TSI temperature sensor"
-	depends on I2C
+	depends on AMD_SBTSI

Is there a risk that this dependency change could silently disable the hwmon driver on kernel upgrades?

Because CONFIG_AMD_SBTSI has no default value, an unattended configuration update like make olddefconfig might drop CONFIG_SENSORS_SBTSI entirely due to unmet dependencies.

Could CONFIG_AMD_SBTSI be selected by CONFIG_SENSORS_SBTSI instead, or use a default strategy to ensure existing user configurations are preserved?

[ ... ]

Quoted 5 lines
drivers/misc/amd-sbi/tsi.c new file +0 -0
new file mode 100644
index 0000000000000..ee22167855505

[ ... ]

drivers/misc/amd-sbi/tsi.c line 63

Quoted 11 lines
drivers/misc/amd-sbi/tsi.c new file +11 -0
+static int sbtsi_create_hwmon_adev(struct device *dev, u8 dev_addr)
+{
+	struct auxiliary_device *adev;
+	int ret;
+
+	adev = kzalloc_obj(*adev);
+	if (!adev)
+		return -ENOMEM;
+
+	adev->name = AMD_SBTSI_AUX_HWMON;
+	adev->id = dev_addr;

Could this assignment to adev->id cause a collision on multi-socket AMD systems?

It looks like auxiliary device names are constructed globally as modname.name.id by __auxiliary_device_add().

If multi-socket systems have identical sensors at the same I2C address (for example, 0x4c) on different I2C adapters, probing the second sensor might result in a duplicate sysfs name and cause device_add() to fail with -EEXIST.

Should the driver allocate a globally unique instance ID for each auxiliary device using an IDA, rather than relying solely on the I2C address?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#3 lore raw

PATCH v2 2/6 hwmon: sbtsi_temp: Refactor temperature register access into helpers

In reply to Akshay Gupta

From: Prathima <[email protected]>

Extract the paired integer/decimal register reads and writes from the hwmon read/write callbacks into sbtsi_temp_read() and sbtsi_temp_write() helpers. This consolidates error handling and respects the ReadOrder bit for atomic temperature latching.

This keeps register access independent while preserving existing hwmon functionality.

---
Changes since v1:
- New patch

 drivers/hwmon/sbtsi_temp.c | 84 +++++++++++++++++++++++++++-----------
 1 file changed, 61 insertions(+), 23 deletions(-)
drivers/hwmon/sbtsi_temp.c +61 -23
index 28258bf49922..078f4ab25bde 100644
@@ -61,40 +61,82 @@ static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal)
 	*decimal = (temp & 0x7) << 5;
 }
 
+/*
+ * Read integer and decimal parts of an SB-TSI temperature register pair
+ * The read order is determined by the ReadOrder bit to ensure atomic latching.
+ */
+static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
+			   u8 *val1, u8 *val2)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, reg1);
+	if (ret < 0)
+		return ret;
+	*val1 = ret;
+	ret = i2c_smbus_read_byte_data(data->client, reg2);
+	if (ret < 0)
+		return ret;
+	*val2 = ret;
+	return 0;
+}
+
+/*
+ * Write integer and decimal parts of an SB-TSI temperature register pair.
+ */
+static int sbtsi_temp_write(struct sbtsi_data *data, u8 reg_int, u8 reg_dec,
+			    u8 val_int, u8 val_dec)
+{
+	int ret;
+
+	ret = i2c_smbus_write_byte_data(data->client, reg_int, val_int);
+	if (!ret)
+		ret = i2c_smbus_write_byte_data(data->client, reg_dec, val_dec);
+	return ret;
+}
+
 static int sbtsi_read(struct device *dev, enum hwmon_sensor_types type,
 		      u32 attr, int channel, long *val)
 {
 	struct sbtsi_data *data = dev_get_drvdata(dev);
 	s32 temp_int, temp_dec;
+	int err;
+	u8 val_int, val_dec;
 
 	switch (attr) {
 	case hwmon_temp_input:
-		if (data->read_order) {
-			temp_dec = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_DEC);
-			temp_int = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_INT);
-		} else {
-			temp_int = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_INT);
-			temp_dec = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_DEC);
-		}
+		if (data->read_order)
+			err = sbtsi_temp_read(data,
+					      SBTSI_REG_TEMP_DEC, SBTSI_REG_TEMP_INT,
+					      &val_dec, &val_int);
+		else
+			err = sbtsi_temp_read(data,
+					      SBTSI_REG_TEMP_INT, SBTSI_REG_TEMP_DEC,
+					      &val_int, &val_dec);
+		if (err < 0)
+			return err;
 		break;
 	case hwmon_temp_max:
-		temp_int = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_HIGH_INT);
-		temp_dec = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_HIGH_DEC);
+		err = sbtsi_temp_read(data,
+				      SBTSI_REG_TEMP_HIGH_INT, SBTSI_REG_TEMP_HIGH_DEC,
+				      &val_int, &val_dec);
+		if (err < 0)
+			return err;
 		break;
 	case hwmon_temp_min:
-		temp_int = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_LOW_INT);
-		temp_dec = i2c_smbus_read_byte_data(data->client, SBTSI_REG_TEMP_LOW_DEC);
+		err = sbtsi_temp_read(data,
+				      SBTSI_REG_TEMP_LOW_INT, SBTSI_REG_TEMP_LOW_DEC,
+				      &val_int, &val_dec);
+
+		if (err < 0)
+			return err;
 		break;
 	default:
 		return -EINVAL;
 	}
 
-
-	if (temp_int < 0)
-		return temp_int;
-	if (temp_dec < 0)
-		return temp_dec;
-
+	temp_int = val_int;
+	temp_dec = val_dec;
 	*val = sbtsi_reg_to_mc(temp_int, temp_dec);
 	if (data->ext_range_mode)
 		*val -= SBTSI_TEMP_EXT_RANGE_ADJ;
@@ -106,7 +148,7 @@ static int sbtsi_write(struct device *dev, enum hwmon_sensor_types type,
 		       u32 attr, int channel, long val)
 {
 	struct sbtsi_data *data = dev_get_drvdata(dev);
-	int reg_int, reg_dec, err;
+	int reg_int, reg_dec;
 	u8 temp_int, temp_dec;
 
 	switch (attr) {
@@ -127,11 +169,7 @@ static int sbtsi_write(struct device *dev, enum hwmon_sensor_types type,
 	val = clamp_val(val, SBTSI_TEMP_MIN, SBTSI_TEMP_MAX);
 	sbtsi_mc_to_reg(val, &temp_int, &temp_dec);
 
-	err = i2c_smbus_write_byte_data(data->client, reg_int, temp_int);
-	if (err)
-		return err;
-
-	return i2c_smbus_write_byte_data(data->client, reg_dec, temp_dec);
+	return sbtsi_temp_write(data, reg_int, reg_dec, temp_int, temp_dec);
 }
 
 static umode_t sbtsi_is_visible(const void *data,
Signature · 1 line
2.34.1
#4 lore raw

PATCH v2 3/6 hwmon/misc: amd-sbi: Move sbtsi register transfer to core abstraction

In reply to Akshay Gupta

From: Prathima <[email protected]>

Move the I2C read/write byte operations from the sbtsi hwmon driver into a common sbtsi_xfer() function in tsi-core.c.
This decouples the hwmon sensor driver from the underlying bus transport, preparing for I3C support in a subsequent patch.
This patch does not introduce any functional changes. The updates are limited to code organization/cleanup and should not affect the runtime behavior of the driver

---
Changes since v1:
- New patch

 drivers/hwmon/sbtsi_temp.c      | 17 ++++++-----------
 drivers/misc/amd-sbi/Makefile   |  2 +-
 drivers/misc/amd-sbi/tsi-core.c | 30 ++++++++++++++++++++++++++++++
 include/linux/misc/tsi.h        | 13 +++++++++++++
 4 files changed, 50 insertions(+), 12 deletions(-)
 create mode 100644 drivers/misc/amd-sbi/tsi-core.c
drivers/hwmon/sbtsi_temp.c +6 -11
index 078f4ab25bde..d7ae986d824c 100644
@@ -70,15 +70,10 @@ static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
 {
 	int ret;
 
-	ret = i2c_smbus_read_byte_data(data->client, reg1);
-	if (ret < 0)
-		return ret;
-	*val1 = ret;
-	ret = i2c_smbus_read_byte_data(data->client, reg2);
-	if (ret < 0)
-		return ret;
-	*val2 = ret;
-	return 0;
+	ret = sbtsi_xfer(data, reg1, val1, true);
+	if (!ret)
+		ret = sbtsi_xfer(data, reg2, val2, true);
+	return ret;
 }
 
 /*
@@ -89,9 +84,9 @@ static int sbtsi_temp_write(struct sbtsi_data *data, u8 reg_int, u8 reg_dec,
 {
 	int ret;
 
-	ret = i2c_smbus_write_byte_data(data->client, reg_int, val_int);
+	ret = sbtsi_xfer(data, reg_int, &val_int, false);
 	if (!ret)
-		ret = i2c_smbus_write_byte_data(data->client, reg_dec, val_dec);
+		ret = sbtsi_xfer(data, reg_dec, &val_dec, false);
 	return ret;
 }
 
drivers/misc/amd-sbi/Makefile +1 -1
index 28f95b9e204f..ce9321f5c601 100644
@@ -3,5 +3,5 @@ sbrmi-i2c-objs  		+= rmi-i2c.o rmi-core.o
 sbrmi-i2c-$(CONFIG_AMD_SBRMI_HWMON)	+= rmi-hwmon.o
 obj-$(CONFIG_AMD_SBRMI_I2C)	+= sbrmi-i2c.o
 # SBTSI Configuration
-sbtsi-objs	+= tsi.o
+sbtsi-objs	+= tsi.o tsi-core.o
 obj-$(CONFIG_AMD_SBTSI)	+= sbtsi.o
drivers/misc/amd-sbi/tsi-core.c new file +30 -0
new file mode 100644
index 000000000000..6ef1831515bb
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * tsi-core.c - file defining SB-TSI protocols compliant
+ *              AMD SoC device.
+ *
+ * Copyright (C) 2026 Advanced Micro Devices, Inc.
+ */
+
+#include <linux/module.h>
+#include <linux/misc/tsi.h>
+
+/* I2C transfer function */
+static int sbtsi_i2c_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read)
+{
+	if (is_read) {
+		int ret = i2c_smbus_read_byte_data(data->client, reg);
+
+		if (ret < 0)
+			return ret;
+		*val = ret;
+		return 0;
+	}
+	return i2c_smbus_write_byte_data(data->client, reg, *val);
+}
+
+int sbtsi_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read)
+{
+	return sbtsi_i2c_xfer(data, reg, val, is_read);
+}
+EXPORT_SYMBOL_GPL(sbtsi_xfer);
include/linux/misc/tsi.h +13 -0
index 6f7177edbcf5..8f8cb90c2023 100644
@@ -31,4 +31,17 @@ struct sbtsi_data {
 #define AMD_SBTSI_ADEV		"amd-sbtsi"
 #define AMD_SBTSI_AUX_HWMON	"temp-sensor"
 
+/**
+ * sbtsi_xfer - Perform a register read or write transfer on an AMD SB-TSI device.
+ *
+ * @data:    Pointer to the sbtsi_data structure containing the device context
+ * @reg:     Register address to access.
+ * @val:     Pointer to the value to read into or write from.
+ * @is_read: If true, performs a read transfer and stores the result in @val.
+ *           If false, performs a write transfer using the value in @val.
+ *
+ * Returns 0 on success, or a negative error code on failure.
+ */
+int sbtsi_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read);
+
 #endif /* _LINUX_TSI_H_ */
Signature · 1 line
2.34.1
#5 lore raw

PATCH v2 4/6 misc: amd-sbi: Add support for SB-TSI over I3C

In reply to Akshay Gupta

From: Prathima <[email protected]>

AMD SB-TSI temperature sensors can be accessed over both I2C and I3C buses depending on the platform configuration. Extend the SB-TSI driver to support both I2C and I3C bus interfaces by selecting the appropriate transport based on the probed bus type. The driver maintains backward compatibility with existing I2C deployments while enabling support for systems using the I3C bus. Register both I2C and I3C drivers using module_i3c_i2c_driver() and update the Kconfig dependency from I2C to I3C_OR_I2C.

---
Changes since v1:
- Changes in accordance with usage of auxiliary device

 drivers/misc/amd-sbi/Kconfig    |  4 +--
 drivers/misc/amd-sbi/tsi-core.c | 38 ++++++++++++++++++++
 drivers/misc/amd-sbi/tsi.c      | 61 +++++++++++++++++++++++++++++++--
 include/linux/misc/tsi.h        | 10 +++++-
 4 files changed, 107 insertions(+), 6 deletions(-)
drivers/misc/amd-sbi/Kconfig +2 -2
index 512251690e0e..1a96b71f8506 100644
@@ -23,13 +23,13 @@ config AMD_SBRMI_HWMON
 
 config AMD_SBTSI
 	tristate "AMD side band TSI support"
-	depends on I2C
+	depends on I3C_OR_I2C
 	depends on ARM || ARM64 || COMPILE_TEST
 	select AUXILIARY_BUS
 	help
 	  Enables support for the AMD SB-TSI (Side Band Temperature Sensor
 	  Interface) driver, which provides access to emulated CPU temperature
-	  sensors on AMD SoCs via an I2C connected BMC device.
+	  sensors on AMD SoCs via an I2C/I3C connected BMC device.
 
 	  This driver can also be built as a module. If so, the module will
 	  be called sbtsi.
drivers/misc/amd-sbi/tsi-core.c +38 -0
index 6ef1831515bb..19388737b225 100644
@@ -23,8 +23,46 @@ static int sbtsi_i2c_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read
 	return i2c_smbus_write_byte_data(data->client, reg, *val);
 }
 
+/* I3C read transfer function */
+static int sbtsi_i3c_read(struct sbtsi_data *data, u8 reg, u8 *val)
+{
+	struct i3c_xfer xfers[2] = { };
+
+	/* Add Register data to read/write */
+	xfers[0].rnw = false;
+	xfers[0].len = 1;
+	xfers[0].data.out = &reg;
+
+	xfers[1].rnw = true;
+	xfers[1].len = 1;
+	xfers[1].data.in = val;
+
+	return i3c_device_do_xfers(data->i3cdev, xfers, 2, I3C_SDR);
+}
+
+/* I3C write transfer function */
+static int sbtsi_i3c_write(struct sbtsi_data *data, u8 reg, u8 val)
+{
+	u8 buf[2];
+	struct i3c_xfer xfers = {
+		.rnw = false,
+		.len = 2,
+		.data.out = buf,
+	};
+
+	buf[0] = reg;
+	buf[1] = val;
+
+	return i3c_device_do_xfers(data->i3cdev, &xfers, 1, I3C_SDR);
+}
+
+/* Unified transfer function for I2C and I3C access */
 int sbtsi_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read)
 {
+	if (data->is_i3c)
+		return is_read ? sbtsi_i3c_read(data, reg, val)
+			       : sbtsi_i3c_write(data, reg, *val);
+
 	return sbtsi_i2c_xfer(data, reg, val, is_read);
 }
 EXPORT_SYMBOL_GPL(sbtsi_xfer);
drivers/misc/amd-sbi/tsi.c +58 -3

77 lines not on this page · raw message

include/linux/misc/tsi.h +9 -1
index 8f8cb90c2023..7ce689081427 100644
@@ -9,18 +9,26 @@
 #define _LINUX_TSI_H_
 
 #include <linux/i2c.h>
+#include <linux/i3c/device.h>
+#include <linux/i3c/master.h>
 #include <linux/types.h>
 
 /**
  * struct sbtsi_data - driver private data for an AMD SB-TSI device
  * @client:	underlying I2C client
+ * @i3cdev:	underlying I3C device (when using I3C bus)
  * @ext_range_mode:	sensor uses extended temperature range
  * @read_order:	if set, decimal part must be read before integer part
+ * @is_i3c:	true when the device is accessed over I3C
  */
 struct sbtsi_data {
-	struct i2c_client *client;
+	union {
+		struct i2c_client *client;
+		struct i3c_device *i3cdev;
+	};
 	bool ext_range_mode;
 	bool read_order;
+	bool is_i3c;
 };
 
 /*
Signature · 1 line
2.34.1
#6 lore raw

Re: [PATCH v2 4/6] misc: amd-sbi: Add support for SB-TSI over I3C

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] Kconfig dependency uses a non-existent symbol (`I3C_OR_I2C`), causing silent build failures.…

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Kconfig dependency uses a non-existent symbol (I3C_OR_I2C), causing silent build failures.
- [High] I3C transfer functions pass stack-allocated buffers for DMA transfers, risking memory corruption and panics.
- [Medium] The driver violates I3C subsystem API boundaries by including <linux/i3c/master.h> to access opaque internal structures. --

commit fd51ed18b45ce179c5ee6ea15c970ec2d140c6c7
Author: Prathima <[email protected]>

misc: amd-sbi: Add support for SB-TSI over I3C

Extend the SB-TSI driver to support both I2C and I3C bus interfaces by selecting the appropriate transport based on the probed bus type. The driver registers both I2C and I3C drivers using module_i3c_i2c_driver().

drivers/misc/amd-sbi/Kconfig config AMD_SBRMI_HWMON · line 26

Quoted 9 lines
drivers/misc/amd-sbi/Kconfig +1 -1
@@ -23,13 +23,13 @@ config AMD_SBRMI_HWMON
 
 config AMD_SBTSI
 	tristate "AMD side band TSI support"
-	depends on I2C
+	depends on I3C_OR_I2C

Is this a valid Kconfig symbol? It looks like it will evaluate as a single config symbol named CONFIG_I3C_OR_I2C instead of a logical OR. Could this cause the driver to be silently unbuildable? Perhaps it should be written as depends on I3C || I2C?

Quoted 3 lines
drivers/misc/amd-sbi/tsi-core.c +0 -0

[ ... ]

Quoted 6 lines
drivers/misc/amd-sbi/tsi-core.c +6 -0
+/* I3C read transfer function */
+static int sbtsi_i3c_read(struct sbtsi_data *data, u8 reg, u8 *val)
+{
+	struct i3c_xfer xfers[2] = { };
+
+	/* Add Register data to read/write */

drivers/misc/amd-sbi/tsi-core.c static int sbtsi_i2c_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read · line 41

Quoted 10 lines
drivers/misc/amd-sbi/tsi-core.c +10 -0
+	xfers[0].rnw = false;
+	xfers[0].len = 1;
+	xfers[0].data.out = &reg;
+
+	xfers[1].rnw = true;
+	xfers[1].len = 1;
+	xfers[1].data.in = val;
+
+	return i3c_device_do_xfers(data->i3cdev, xfers, 2, I3C_SDR);
+}

Does i3c_device_do_xfers() map the buffers for DMA? If so, passing stack memory like &reg and val could lead to memory corruption or kernel panics when CONFIG_VMAP_STACK is enabled. Could these buffers be allocated on the heap, for example by embedding them in the sbtsi_data structure?

Quoted 5 lines
drivers/misc/amd-sbi/tsi-core.c +5 -0
+/* I3C write transfer function */
+static int sbtsi_i3c_write(struct sbtsi_data *data, u8 reg, u8 val)
+{
+	u8 buf[2];
+	struct i3c_xfer xfers = {

drivers/misc/amd-sbi/tsi-core.c static int sbtsi_i2c_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read · line 57

Quoted 10 lines
drivers/misc/amd-sbi/tsi-core.c +10 -0
+		.rnw = false,
+		.len = 2,
+		.data.out = buf,
+	};
+
+	buf[0] = reg;
+	buf[1] = val;
+
+	return i3c_device_do_xfers(data->i3cdev, &xfers, 1, I3C_SDR);
+}

Similarly, does buf[2] on the stack present a DMA mapping issue here?

Quoted 3 lines
drivers/misc/amd-sbi/tsi.c +0 -0

[ ... ]

Quoted 6 lines
drivers/misc/amd-sbi/tsi.c +6 -0
+static int sbtsi_i3c_probe(struct i3c_device *i3cdev)
+{
+	struct device *dev = i3cdev_to_dev(i3cdev);
+	struct sbtsi_data *data;
+	int err;
+	u8 val;

drivers/misc/amd-sbi/tsi.c static struct i2c_driver sbtsi_driver = { · line 142

Quoted 10 lines
drivers/misc/amd-sbi/tsi.c +10 -0
+
+	/*
+	 * AMD OOB devices differ on basis of Instance ID,
+	 * for SBTSI, instance ID is 0.
+	 * As the device Id match is not on basis of Instance ID,
+	 * add the below check to probe the SBTSI device only and
+	 * not other OOB devices.
+	 */
+	if (I3C_PID_INSTANCE_ID(i3cdev->desc->info.pid) != 0)
+		return -ENXIO;

Is accessing i3cdev->desc->info.pid directly safe? The i3c_device struct is typically treated as opaque to client drivers. Would it be better to use i3c_device_get_info() to populate a struct i3c_device_info and read the fields from there to ensure internal locking is respected?

[ ... ]

drivers/misc/amd-sbi/tsi.c static struct i2c_driver sbtsi_driver = { · line 160

Quoted 6 lines
drivers/misc/amd-sbi/tsi.c +6 -0
+	data->ext_range_mode = FIELD_GET(BIT(SBTSI_CONFIG_EXT_RANGE_SHIFT), val);
+	data->read_order = FIELD_GET(BIT(SBTSI_CONFIG_READ_ORDER_SHIFT), val);
+
+	dev_set_drvdata(dev, data);
+	return sbtsi_create_hwmon_adev(dev, i3cdev->desc->info.dyn_addr);
+}

Similarly here, can this direct access to i3cdev->desc->info.dyn_addr be replaced with the public i3c_device_get_info() API?

include/linux/misc/tsi.h line 13

Quoted 9 lines
include/linux/misc/tsi.h +2 -0
@@ -9,18 +9,26 @@
 #define _LINUX_TSI_H_
 
 #include <linux/i2c.h>
+#include <linux/i3c/device.h>
+#include <linux/i3c/master.h>

Does the driver need to include linux/i3c/master.h? Client drivers normally only include linux/i3c/device.h, and relying on master.h might break the I3C API boundaries.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
maintainer
#7 lore raw

Re: [PATCH v2 4/6] misc: amd-sbi: Add support for SB-TSI over I3C

On 5/15/26 08:33, [email protected] wrote:
...

Quoted 6 lines
Quoted 6 lines
drivers/misc/amd-sbi/Kconfig +0 -0
@@ -23,13 +23,13 @@ config AMD_SBRMI_HWMON
 
Quoted 10 lines

drivers/misc/amd-sbi/Kconfig config AMD_SBRMI_HWMON · line 26

Quoted 4 lines
drivers/misc/amd-sbi/Kconfig +1 -1
  config AMD_SBTSI
  	tristate "AMD side band TSI support"
-	depends on I2C
+	depends on I3C_OR_I2C

Is this a valid Kconfig symbol? It looks like it will evaluate as a single config symbol named CONFIG_I3C_OR_I2C instead of a logical OR. Could this cause the driver to be silently unbuildable? Perhaps it should be written as depends on I3C || I2C?

We'll need to teach Sashiko about this. I submitted a pull request.

Guenter

#8 lore raw

PATCH v2 5/6 misc: amd-sbi: Add SBTSI ioctl register transfer interface

In reply to Akshay Gupta

From: Prathima <[email protected]>

Implement IOCTL interface for SB-TSI driver to enable userspace access to TSI register read/write operations through the AMD Advanced Platform Management Link (APML) protocol.
Add an ioctl command (SBTSI_IOCTL_REG_XFER_CMD) that accepts a register address, data byte, and direction flag. Serialize access with a mutex shared between the hwmon and ioctl paths to prevent concurrent bus transactions from corrupting register state.

---
Changes since v1:
- Use of devm_mutex_init in place of mutex_init
- Use of guard_mutex in place of mutex_lock()/mutex_unlock()
- Use of devm_add_action_or_reset() for clean removal

 drivers/hwmon/sbtsi_temp.c      |  6 +++
 drivers/misc/amd-sbi/tsi-core.c | 84 ++++++++++++++++++++++++++++++++-
 drivers/misc/amd-sbi/tsi-core.h | 15 ++++++
 drivers/misc/amd-sbi/tsi.c      | 20 ++++++--
 include/linux/misc/tsi.h        |  8 ++++
 include/uapi/misc/amd-apml.h    | 23 +++++++++
 6 files changed, 151 insertions(+), 5 deletions(-)
 create mode 100644 drivers/misc/amd-sbi/tsi-core.h
drivers/hwmon/sbtsi_temp.c +6 -0
index d7ae986d824c..00e982f4c716 100644
@@ -64,12 +64,15 @@ static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal)
 /*
  * Read integer and decimal parts of an SB-TSI temperature register pair
  * The read order is determined by the ReadOrder bit to ensure atomic latching.
+ * The mutex protects against concurrent access to the shared I2C/I3C bus by
+ * the hwmon sysfs and a userspace ioctl
  */
 static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
 			   u8 *val1, u8 *val2)
 {
 	int ret;
 
+	guard(mutex)(&data->lock);
 	ret = sbtsi_xfer(data, reg1, val1, true);
 	if (!ret)
 		ret = sbtsi_xfer(data, reg2, val2, true);
@@ -78,12 +81,15 @@ static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
 
 /*
  * Write integer and decimal parts of an SB-TSI temperature register pair.
+ * The mutex protects against concurrent access to the shared I2C/I3C bus by
+ * the hwmon sysfs and a userspace ioctl
  */
 static int sbtsi_temp_write(struct sbtsi_data *data, u8 reg_int, u8 reg_dec,
 			    u8 val_int, u8 val_dec)
 {
 	int ret;
 
+	guard(mutex)(&data->lock);
 	ret = sbtsi_xfer(data, reg_int, &val_int, false);
 	if (!ret)
 		ret = sbtsi_xfer(data, reg_dec, &val_dec, false);
drivers/misc/amd-sbi/tsi-core.c +82 -2

97 lines not on this page · raw message

drivers/misc/amd-sbi/tsi-core.h new file +15 -0
new file mode 100644
index 000000000000..7bf967a09837
@@ -0,0 +1,15 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * AMD SBTSI misc tsi device .
+ *
+ * Copyright (C) 2026 Advanced Micro Devices, Inc.
+ */
+
+#ifndef _LINUX_TSI_CORE_H_
+#define _LINUX_TSI_CORE_H_
+
+#include <linux/misc/tsi.h>
+
+int create_misc_tsi_device(struct sbtsi_data *data, struct device *dev);
+
+#endif /* _LINUX_TSI_CORE_H_ */
drivers/misc/amd-sbi/tsi.c +17 -3
index 43bbac7faf08..6a9356740f4e 100644
@@ -10,8 +10,8 @@
 #include <linux/bitfield.h>
 #include <linux/module.h>
 #include <linux/of.h>
-#include <linux/misc/tsi.h>
 #include <linux/slab.h>
+#include "tsi-core.h"
 
 #define SBTSI_REG_CONFIG		0x03 /* RO */
 
@@ -89,6 +89,9 @@ static int sbtsi_i2c_probe(struct i2c_client *client)
 	if (!data)
 		return -ENOMEM;
 
+	err = devm_mutex_init(dev, &data->lock);
+	if (err)
+		return err;
 	data->is_i3c = false;
 	data->client = client;
 	err = i2c_smbus_read_byte_data(data->client, SBTSI_REG_CONFIG);
@@ -98,7 +101,11 @@ static int sbtsi_i2c_probe(struct i2c_client *client)
 	data->read_order = FIELD_GET(BIT(SBTSI_CONFIG_READ_ORDER_SHIFT), err);
 
 	dev_set_drvdata(dev, data);
-	return sbtsi_create_hwmon_adev(dev, client->addr);
+	err = sbtsi_create_hwmon_adev(dev, client->addr);
+	if (err < 0)
+		return err;
+	data->dev_addr = client->addr;
+	return create_misc_tsi_device(data, dev);
 }
 
 static const struct i2c_device_id sbtsi_id[] = {
@@ -145,6 +152,9 @@ static int sbtsi_i3c_probe(struct i3c_device *i3cdev)
 	if (!data)
 		return -ENOMEM;
 
+	err = devm_mutex_init(dev, &data->lock);
+	if (err)
+		return err;
 	data->i3cdev = i3cdev;
 	data->is_i3c = true;
 
@@ -156,7 +166,11 @@ static int sbtsi_i3c_probe(struct i3c_device *i3cdev)
 	data->read_order = FIELD_GET(BIT(SBTSI_CONFIG_READ_ORDER_SHIFT), val);
 
 	dev_set_drvdata(dev, data);
-	return sbtsi_create_hwmon_adev(dev, i3cdev->desc->info.dyn_addr);
+	err = sbtsi_create_hwmon_adev(dev, i3cdev->desc->info.dyn_addr);
+	if (err < 0)
+		return err;
+	data->dev_addr = i3cdev->desc->info.dyn_addr;
+	return create_misc_tsi_device(data, dev);
 }
 
 static const struct i3c_device_id sbtsi_i3c_id[] = {
include/linux/misc/tsi.h +8 -0
index 7ce689081427..184b1aa14f0a 100644
@@ -11,12 +11,17 @@
 #include <linux/i2c.h>
 #include <linux/i3c/device.h>
 #include <linux/i3c/master.h>
+#include <linux/miscdevice.h>
+#include <linux/mutex.h>
 #include <linux/types.h>
 
 /**
  * struct sbtsi_data - driver private data for an AMD SB-TSI device
  * @client:	underlying I2C client
  * @i3cdev:	underlying I3C device (when using I3C bus)
+ * @sbtsi_misc_dev: miscdevice exposing ioctl interface at /dev/sbtsi-<addr>
+ * @lock:           mutex protecting concurrent access to the device
+ * @dev_addr:       I2C/I3C device address, used to name the misc device node
  * @ext_range_mode:	sensor uses extended temperature range
  * @read_order:	if set, decimal part must be read before integer part
  * @is_i3c:	true when the device is accessed over I3C
@@ -26,6 +31,9 @@ struct sbtsi_data {
 		struct i2c_client *client;
 		struct i3c_device *i3cdev;
 	};
+	struct miscdevice sbtsi_misc_dev;
+	struct mutex lock;	/* protects concurrent access to the device */
+	u8 dev_addr;
 	bool ext_range_mode;
 	bool read_order;
 	bool is_i3c;
include/uapi/misc/amd-apml.h +23 -0
index 745b3338fc06..8a85f79b0938 100644
@@ -73,6 +73,13 @@ struct apml_reg_xfer_msg {
 	__u8 rflag;
 };
 
+struct apml_tsi_xfer_msg {
+	__u8 reg_addr;		/* TSI register address offset */
+	__u8 data_in_out;	/* Register data for read/write */
+	__u8 rflag;		/* Register read or write */
+	__u8 pad;		/* Explicit padding */
+};
+
 /*
  * AMD sideband interface base IOCTL
  */
@@ -149,4 +156,20 @@ struct apml_reg_xfer_msg {
  */
 #define SBRMI_IOCTL_REG_XFER_CMD	_IOWR(SB_BASE_IOCTL_NR, 3, struct apml_reg_xfer_msg)
 
+/**
+ * DOC: SBTSI_IOCTL_REG_XFER_CMD
+ *
+ * @Parameters
+ *
+ * @struct apml_tsi_xfer_msg
+ *	Pointer to the &struct apml_tsi_xfer_msg that will contain the protocol
+ *	information
+ *
+ * @Description
+ * IOCTL command for APML TSI messages using generic _IOWR
+ * The IOCTL provides userspace access to AMD sideband TSI register xfer protocol
+ * - TSI protocol to read/write temperature sensor registers
+ */
+#define SBTSI_IOCTL_REG_XFER_CMD	_IOWR(SB_BASE_IOCTL_NR, 4, struct apml_tsi_xfer_msg)
+
 #endif /*_AMD_APML_H_*/
Signature · 1 line
2.34.1
maintainer
#9 lore raw

Re: [PATCH v2 5/6] misc: amd-sbi: Add SBTSI ioctl register transfer interface

Quoted 34 lines · Akshay Gupta

From: Prathima <[email protected]>

Implement IOCTL interface for SB-TSI driver to enable userspace access to TSI register read/write operations through the AMD Advanced Platform Management Link (APML) protocol.
Add an ioctl command (SBTSI_IOCTL_REG_XFER_CMD) that accepts a register address, data byte, and direction flag. Serialize access with a mutex shared between the hwmon and ioctl paths to prevent concurrent bus transactions from corrupting register state.

---
Changes since v1:
- Use of devm_mutex_init in place of mutex_init
- Use of guard_mutex in place of mutex_lock()/mutex_unlock()
- Use of devm_add_action_or_reset() for clean removal

  drivers/hwmon/sbtsi_temp.c      |  6 +++
  drivers/misc/amd-sbi/tsi-core.c | 84 ++++++++++++++++++++++++++++++++-
  drivers/misc/amd-sbi/tsi-core.h | 15 ++++++
  drivers/misc/amd-sbi/tsi.c      | 20 ++++++--
  include/linux/misc/tsi.h        |  8 ++++
  include/uapi/misc/amd-apml.h    | 23 +++++++++
  6 files changed, 151 insertions(+), 5 deletions(-)

create mode 100644 drivers/misc/amd-sbi/tsi-core.h

drivers/hwmon/sbtsi_temp.c +0 -0
index d7ae986d824c..00e982f4c716 100644
@@ -64,12 +64,15 @@ static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal)
  /*
   * Read integer and decimal parts of an SB-TSI temperature register pair

drivers/hwmon/sbtsi_temp.c static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal) · line 75

Quoted 10 lines
drivers/hwmon/sbtsi_temp.c +3 -0
   * The read order is determined by the ReadOrder bit to ensure atomic latching.
+ * The mutex protects against concurrent access to the shared I2C/I3C bus by
+ * the hwmon sysfs and a userspace ioctl
   */
  static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
  			   u8 *val1, u8 *val2)
  {
  	int ret;
 
+	guard(mutex)(&data->lock);

I would suggest to hide this behind access functions such as sbtsi_lock(), sbtsi_unlock(), and the matching guard functions. That can be done in a separate patch; it should not be necessary to include hwmon in the patch introducing the ioctl.

Thanks,
Guenter

#10 lore raw

Re: [PATCH v2 5/6] misc: amd-sbi: Add SBTSI ioctl register transfer interface

Quoted 47 lines · Guenter Roeck

Caution: This message originated from an External Source. Use proper caution when opening attachments, clicking links, or responding.

Quoted 43 lines · Akshay Gupta

From: Prathima <[email protected]>

Implement IOCTL interface for SB-TSI driver to enable userspace access to TSI register read/write operations through the AMD Advanced Platform Management Link (APML) protocol.
Add an ioctl command (SBTSI_IOCTL_REG_XFER_CMD) that accepts a register address, data byte, and direction flag. Serialize access with a mutex shared between the hwmon and ioctl paths to prevent concurrent bus transactions from corrupting register state.

---
Changes since v1:
- Use of devm_mutex_init in place of mutex_init
- Use of guard_mutex in place of mutex_lock()/mutex_unlock()
- Use of devm_add_action_or_reset() for clean removal

   drivers/hwmon/sbtsi_temp.c      |  6 +++
   drivers/misc/amd-sbi/tsi-core.c | 84 ++++++++++++++++++++++++++++++++-
   drivers/misc/amd-sbi/tsi-core.h | 15 ++++++
   drivers/misc/amd-sbi/tsi.c      | 20 ++++++--
   include/linux/misc/tsi.h        |  8 ++++
   include/uapi/misc/amd-apml.h    | 23 +++++++++
   6 files changed, 151 insertions(+), 5 deletions(-)

create mode 100644 drivers/misc/amd-sbi/tsi-core.h

drivers/hwmon/sbtsi_temp.c +2 -0
index d7ae986d824c..00e982f4c716 100644
@@ -64,12 +64,15 @@ static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal)
   /*
    * Read integer and decimal parts of an SB-TSI temperature register pair
    * The read order is determined by the ReadOrder bit to ensure atomic latching.
+ * The mutex protects against concurrent access to the shared I2C/I3C bus by
+ * the hwmon sysfs and a userspace ioctl
    */
   static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
                          u8 *val1, u8 *val2)
   {
       int ret;
 
Quoted 8 lines

drivers/hwmon/sbtsi_temp.c static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal) · line 75

Quoted 1 line
drivers/hwmon/sbtsi_temp.c +1 -0
+     guard(mutex)(&data->lock);

I would suggest to hide this behind access functions such as sbtsi_lock(), sbtsi_unlock(), and the matching guard functions. That can be done in a separate patch; it should not be necessary to include hwmon in the patch introducing the ioctl.

Thanks,
Guenter

Thank you for the feedback, Guenter.

In the next version, we will address this by implementing the matching guard function in the ioctl patch and creating a new patch for hwmon.

Quoted 1 line
#11 lore raw

Re: [PATCH v2 5/6] misc: amd-sbi: Add SBTSI ioctl register transfer interface

In reply to Akshay Gupta
Thank you for your contribution! Sashiko AI review found 6 potential issue(s) to consider: - [Critical] Use-After-Free of `sbtsi_data` due to misaligned devres and VFS lifecycles - [High] Unsafe DMA…

Thank you for your contribution! Sashiko AI review found 6 potential issue(s) to consider:
- [Critical] Use-After-Free of sbtsi_data due to misaligned devres and VFS lifecycles
- [High] Unsafe DMA Buffer Allocation from stack variables
- [High] Subsystem Guideline Violation: Redundant custom lock instead of hwmon_lock()
- [High] sysfs name collision for miscdevice on multi-bus systems
- [Medium] Hardware state desynchronization via unrestricted IOCTL writes
- [Medium] UAPI Flaw: Unvalidated padding byte in IOCTL message
--

commit a076ef47ca989260af804712d32ac63c2aaf11cb
Author: Prathima <[email protected]>

misc: amd-sbi: Add SBTSI ioctl register transfer interface

Implement IOCTL interface for SB-TSI driver to enable userspace access to TSI register read/write operations through the AMD Advanced Platform Management Link (APML) protocol.
Add an ioctl command (SBTSI_IOCTL_REG_XFER_CMD) that accepts a register address, data byte, and direction flag.

Quoted 7 lines
drivers/hwmon/sbtsi_temp.c +0 -0
index d7ae986d824c4..00e982f4c716c 100644
@@ -64,12 +64,15 @@ static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal)
 /*
  * Read integer and decimal parts of an SB-TSI temperature register pair

drivers/hwmon/sbtsi_temp.c static inline void sbtsi_mc_to_reg(s32 temp, u8 *integer, u8 *decimal) · line 75

Quoted 10 lines
drivers/hwmon/sbtsi_temp.c +3 -0
  * The read order is determined by the ReadOrder bit to ensure atomic latching.
+ * The mutex protects against concurrent access to the shared I2C/I3C bus by
+ * the hwmon sysfs and a userspace ioctl
  */
 static int sbtsi_temp_read(struct sbtsi_data *data, u8 reg1, u8 reg2,
 			   u8 *val1, u8 *val2)
 {
 	int ret;
 
+	guard(mutex)(&data->lock);

Does this custom lock bypass the standardized hwmon core synchronization mechanism? The hwmon subsystem guidelines appear to mandate using hwmon_lock() and hwmon_unlock() to serialize sysfs operations against attributes registered by other means.

[ ... ]

Quoted 4 lines
drivers/misc/amd-sbi/tsi-core.c +0 -0
index 19388737b225e..c5bd60409d5bb 100644

[ ... ]

drivers/misc/amd-sbi/tsi-core.c int sbtsi_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read) · line 92

Quoted 10 lines
drivers/misc/amd-sbi/tsi-core.c +10 -0
+static int apml_tsi_reg_xfer(struct sbtsi_data *data,
+			     struct apml_tsi_xfer_msg __user *arg)
+{
+	struct apml_tsi_xfer_msg msg = { 0 };
+	int ret;
+
+	if (copy_from_user(&msg, arg, sizeof(struct apml_tsi_xfer_msg)))
+		return -EFAULT;
+
+	ret = sbtsi_xfer_ioctl(data, msg.reg_addr, &msg.data_in_out, msg.rflag);

Could passing &msg.data_in_out to sbtsi_xfer_ioctl() eventually result in a DMA transfer from stack memory?

If the transfer goes over I3C, sbtsi_i3c_read() uses this pointer directly:

static int sbtsi_i3c_read(struct sbtsi_data *data, u8 reg, u8 *val)

{
	struct i3c_xfer xfers[2] = { };

	xfers[0].rnw = false;
	xfers[0].len = 1;
	xfers[0].data.out = &reg;

	xfers[1].rnw = true;
	xfers[1].len = 1;
	xfers[1].data.in = val;

	return i3c_device_do_xfers(data->i3cdev, xfers, 2, I3C_SDR);
}

Since I3C host controllers commonly use DMA, and stack variables are not cacheline aligned (and reside in virtually mapped memory with CONFIG_VMAP_STACK enabled), this might violate the DMA API and lead to adjacent stack corruption.

Furthermore, does this unrestricted IOCTL write capability allow userspace to overwrite the SBTSI_REG_CONFIG register?

During probe, the driver caches hardware state (ext_range_mode and read_order) from this register. If userspace modifies it without the driver intercepting the write to update its cache, the hwmon interface could report incorrect temperatures.

[ ... ]

drivers/misc/amd-sbi/tsi-core.c int sbtsi_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read) · line 106

Quoted 6 lines
drivers/misc/amd-sbi/tsi-core.c +6 -0
+static long sbtsi_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
+{
+	void __user *argp = (void __user *)arg;
+	struct sbtsi_data *data;
+
+	data = container_of(fp->private_data, struct sbtsi_data, sbtsi_misc_dev);

Can this lead to a use-after-free if the device is unbound?

The sbtsi_data structure is allocated with devm_kzalloc(), tying its lifetime to the device's driver binding. When the device unbinds, devres calls misc_deregister() and frees sbtsi_data.

Since misc_deregister() does not close or revoke existing file descriptors, a process could retain its file descriptor and call ioctl() after the unbind, extracting the freed sbtsi_data pointer and attempting to lock data->lock.

[ ... ]

drivers/misc/amd-sbi/tsi-core.c int sbtsi_xfer(struct sbtsi_data *data, u8 reg, u8 *val, bool is_read) · line 131

Quoted 6 lines
drivers/misc/amd-sbi/tsi-core.c +6 -0
+int create_misc_tsi_device(struct sbtsi_data *data, struct device *dev)
+{
+	int ret;
+
+	data->sbtsi_misc_dev.name = devm_kasprintf(dev, GFP_KERNEL,
+						   "sbtsi-%x", data->dev_addr);

Will this naming scheme cause a sysfs name collision on systems with multiple I2C/I3C buses?

If identically-addressed sensors exist on different buses, it looks like misc_register() will attempt to create a duplicate sysfs entry (e.g., /sys/class/misc/sbtsi-4c), fail with -EEXIST, and abort the probe.

[ ... ]

Quoted 5 lines
include/uapi/misc/amd-apml.h +0 -0
index 745b3338fc06f..8a85f79b0938d 100644

include/uapi/misc/amd-apml.h struct apml_reg_xfer_msg { · line 81

Quoted 9 lines
include/uapi/misc/amd-apml.h +6 -0
@@ -73,6 +73,13 @@ struct apml_reg_xfer_msg {
 	__u8 rflag;
 };
 
+struct apml_tsi_xfer_msg {
+	__u8 reg_addr;		/* TSI register address offset */
+	__u8 data_in_out;	/* Register data for read/write */
+	__u8 rflag;		/* Register read or write */
+	__u8 pad;		/* Explicit padding */
+};

Should msg.pad be validated in apml_tsi_reg_xfer() to ensure it is zero?

Without this check, userspace can pass uninitialized garbage in the padding field, which might prevent safely repurposing this field for new flags or extensions in the future.

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
#12 lore raw

PATCH v2 6/6 docs: misc: amd-sbi: Document SBTSI userspace interface

In reply to Akshay Gupta

From: Prathima <[email protected]>

- Document AMD sideband IOCTL description defined
for SBTSI and its usage.
User space C-APIs are made available by esmi_oob_library [1], which is provided by the E-SMS project [2].

Include a user-space open example for /dev/sbtsi-* and list auxiliary bus sysfs paths.

---
Changes since v1:
- Elaborate the document

 Documentation/misc-devices/amd-sbi.rst | 64 ++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)
Documentation/misc-devices/amd-sbi.rst +64 -0
index f91ddadefe48..6a6344439ef5 100644
@@ -48,6 +48,56 @@ Access restrictions:
  * APML Mailbox messages and Register xfer access are read-write,
  * CPUID and MCA_MSR access is read-only.
 
+SBTSI device
+============
+
+sbtsi driver under the drivers/misc/amd-sbi creates miscdevice
+/dev/sbtsi-* to let user space programs run APML TSI register xfer
+commands.
+
+The driver supports both I2C and I3C transports for SB-TSI targets.
+The transport is selected by the bus where the device is enumerated.
+
+.. code-block:: bash
+
+   $ ls -al /dev/sbtsi-4c
+   crw-------    1 root     root       10, 116 Apr  2 05:22 /dev/sbtsi-4c
+
+
+Access restrictions:
+ * Only root user is allowed to open the file.
+ * APML TSI Register xfer access is read-write.
+
+SBTSI hwmon interface
+=====================
+
+The sbtsi_temp auxiliary driver binds to the auxiliary device published
+by the core sbtsi driver on the auxiliary bus. The auxiliary device is
+named amd-sbtsi.temp-sensor.<addr> where <addr> is the device's dynamic
+address.
+
+It registers a hwmon device, providing a standard Linux hwmon interface
+for reading CPU temperature and managing temperature limits.
+
+The hwmon device appears under ``/sys/class/hwmon/`` when both ``sbtsi.ko``
+and ``sbtsi_temp.ko`` are loaded.
+
+Verify auxiliary bus device::
+
+  ls /sys/bus/auxiliary/devices/
+  # e.g. amd-sbtsi.temp-sensor.X
+
+Example usage::
+
+  # Read current temperature
+  cat /sys/class/hwmon/hwmon<N>/temp1_input
+
+  # Set high temperature limit to 70 °C
+  echo 70000 > /sys/class/hwmon/hwmon<N>/temp1_max
+
+  # Verify
+  cat /sys/class/hwmon/hwmon<N>/temp1_max
+
 Driver IOCTLs
 =============
 
@@ -63,6 +113,9 @@ Driver IOCTLs
 .. c:macro:: SBRMI_IOCTL_REG_XFER_CMD
 .. kernel-doc:: include/uapi/misc/amd-apml.h
    :doc: SBRMI_IOCTL_REG_XFER_CMD
+.. c:macro:: SBTSI_IOCTL_REG_XFER_CMD
+.. kernel-doc:: include/uapi/misc/amd-apml.h
+   :doc: SBTSI_IOCTL_REG_XFER_CMD
 
 User-space usage
 ================
@@ -85,6 +138,16 @@ Next thing, open the device file, as follows::
     exit(1);
   }
 
+To open SB-TSI device::
+
+  int file;
+
+  file = open("/dev/sbtsi-*", O_RDWR);
+  if (file < 0) {
+    /* ERROR HANDLING */
+    exit(1);
+  }
+
 The following IOCTLs are defined:
 
 ``#define SB_BASE_IOCTL_NR      	0xF9``
@@ -92,6 +155,7 @@ The following IOCTLs are defined:
 ``#define SBRMI_IOCTL_CPUID_CMD		_IOWR(SB_BASE_IOCTL_NR, 1, struct apml_cpuid_msg)``
 ``#define SBRMI_IOCTL_MCAMSR_CMD	_IOWR(SB_BASE_IOCTL_NR, 2, struct apml_mcamsr_msg)``
 ``#define SBRMI_IOCTL_REG_XFER_CMD	_IOWR(SB_BASE_IOCTL_NR, 3, struct apml_reg_xfer_msg)``
+``#define SBTSI_IOCTL_REG_XFER_CMD      _IOWR(SB_BASE_IOCTL_NR, 4, struct apml_tsi_xfer_msg)``
 
 
 User space C-APIs are made available by esmi_oob_library, hosted at
Signature · 1 line
2.34.1