Skip to contentSkip to conversation

hwmon: (yogafan) Add universal Lenovo Yoga/Legion fan driver

PATCH In review Sergio Melas 2 participants 2 messages Mar 20

Subsystems (3)
lore
Share & tools
lore

Sergio Melas

author maintainer
#0 lore raw

PATCH v3 1/1 hwmon: (yogafan) Add universal Lenovo Yoga/Legion fan driver

This driver provides fan speed monitoring for modern Lenovo Yoga, Legion, and IdeaPad laptops via ACPI.

This version (v3) replaces the previous background-worker approach with a passive RLLag (Rate Limited Lag) filter to maximize CPU sleep states and improve power efficiency.

Technical Validation:
- Filter constants (TAU_MS = 3000) verified via physical tachometer and FOPTD (First Order Plus Time Delay) identification.
- Uses 10-bit fixed-point math for the Taylor-approximated alpha = Ts / (Tau + Ts) calculation.
- Renamed to 'yogafan' for hwmon compliance.
- Added MAINTAINERS entry and linked documentation to the build system.

---
 Documentation/hwmon/index.rst   |   1 +
 Documentation/hwmon/yogafan.rst |  51 ++++++
 MAINTAINERS                     |   7 +
 drivers/hwmon/Kconfig           |   7 +-
 drivers/hwmon/Makefile          |   2 +-
 drivers/hwmon/yogafan.c         | 273 ++++++++++++++++++++++++++++++++
 6 files changed, 335 insertions(+), 6 deletions(-)
 create mode 100644 Documentation/hwmon/yogafan.rst
 create mode 100644 drivers/hwmon/yogafan.c
Documentation/hwmon/index.rst +1 -0
index b2ca8513c..ca438f294 100644
@@ -282,4 +282,5 @@ Hardware Monitoring Kernel Drivers
    xdp710
    xdpe12284
    xdpe152c4
+   yogafan
    zl6100
Documentation/hwmon/yogafan.rst new file +51 -0

51 lines not on this page · raw message

MAINTAINERS +7 -0
index 96ea84948..dd16c882c 100644
@@ -29070,6 +29070,13 @@ S:	Maintained
 F:	Documentation/input/devices/yealink.rst
 F:	drivers/input/misc/yealink.*
 
+YOGAFAN HARDWARE MONITORING DRIVER
+M:	Sergio Melas <[email protected]>
+L:	[email protected]
+S:	Maintained
+F:	Documentation/hwmon/yogafan.rst
+F:	drivers/hwmon/yogafan.c
+
 Z8530 DRIVER FOR AX.25
 M:	Joerg Reuter <[email protected]>
 L:	[email protected]
drivers/hwmon/Kconfig +2 -5
index 7d938308d..d276763d6 100644
@@ -2468,6 +2468,7 @@ config SENSORS_YOGAFAN
 	  This driver can also be built as a module. If so, the module
 	  will be called yoga_fan.
 
+
 config SENSORS_VIA_CPUTEMP
 	tristate "VIA CPU temperature sensor"
 	depends on X86
@@ -2753,8 +2754,4 @@ config SENSORS_HP_WMI
 endif # ACPI
 
 endif # HWMON
-config SENSORS_YOGA_FAN
-	tristate "Lenovo Yoga Fan Hardware Monitoring"
-	depends on ACPI && HWMON
-	help
-	  Support for fan RPM on modern Lenovo laptops.
+
drivers/hwmon/Makefile +1 -1
index d8d4ff834..c74b71ec2 100644
@@ -251,5 +251,5 @@ obj-$(CONFIG_SENSORS_PECI)	+= peci/
 obj-$(CONFIG_PMBUS)		+= pmbus/
 
 ccflags-$(CONFIG_HWMON_DEBUG_CHIP) := -DDEBUG
-obj-$(CONFIG_SENSORS_YOGA_FAN) += yoga_fan.o
+obj-$(CONFIG_SENSORS_YOGAFAN) += yogafan.o
 
drivers/hwmon/yogafan.c new file +273 -0

273 lines not on this page · raw message

Signature · 1 line
2.53.0
maintainer
#1 lore raw
Quoted 7 lines · Sergio Melas

This driver provides fan speed monitoring for modern Lenovo Yoga, Legion, and IdeaPad laptops via ACPI.

This version (v3) replaces the previous background-worker approach with a passive RLLag (Rate Limited Lag) filter to maximize CPU sleep states and improve power efficiency.

Change log and validation should be after "---"

Quoted 9 lines

Technical Validation:
- Filter constants (TAU_MS = 3000) verified via physical tachometer and FOPTD (First Order Plus Time Delay) identification.
- Uses 10-bit fixed-point math for the Taylor-approximated alpha = Ts / (Tau + Ts) calculation.
- Renamed to 'yogafan' for hwmon compliance.
- Added MAINTAINERS entry and linked documentation to the build system.

Your patch is still not based on the upstream kernel, does not apply, and therefore can not be reviewed.

Guenter

Quoted 68 lines
---
  Documentation/hwmon/index.rst   |   1 +
  Documentation/hwmon/yogafan.rst |  51 ++++++
  MAINTAINERS                     |   7 +
  drivers/hwmon/Kconfig           |   7 +-
  drivers/hwmon/Makefile          |   2 +-
  drivers/hwmon/yogafan.c         | 273 ++++++++++++++++++++++++++++++++
  6 files changed, 335 insertions(+), 6 deletions(-)

create mode 100644 Documentation/hwmon/yogafan.rst create mode 100644 drivers/hwmon/yogafan.c

Documentation/hwmon/index.rst +1 -0
index b2ca8513c..ca438f294 100644
@@ -282,4 +282,5 @@ Hardware Monitoring Kernel Drivers
     xdp710
     xdpe12284
     xdpe152c4
+   yogafan
     zl6100
Documentation/hwmon/yogafan.rst new file +41 -0
new file mode 100644
index 000000000..c1614f502
@@ -0,0 +1,51 @@
+.. SPDX-License-Identifier: GPL-2.0-only
+
+Kernel driver yogafan
+=====================
+
+Supported chips:
+  * Lenovo Yoga / Legion / IdeaPad Embedded Controllers
+    Prefix: 'yogafan'
+    Addresses: ACPI (Dynamic probing of FANS, FA2S, FANX, etc.)
+
+Description
+-----------
+
+This driver provides fan speed monitoring for modern Lenovo laptops.
+It interfaces with the Lenovo Embedded Controller (EC) via ACPI to
+retrieve fan tachometer data.
+
+Many Lenovo ECs report RPM values that oscillate rapidly due to
+low-resolution internal sampling. To provide a stable reading in
+userspace (e.g., KDE Plasma, MangoHud), this driver implements a
+"Passive RLLag" (Rate Limited Lag) filter.
+
+Filter Logic:
+he driver implements a Rate-Limited Lag (RLLag) filter using a multirate
+approach. Instead of a fixed-interval background worker, the sampling
+time (Ts) is calculated dynamically as the ktime delta between userspace
+read requests.
+
+This mimics a continuous-time First Order Plus Time Delay (FOPTD) model:
+    rpm_k+1 = rpm_k + clamp(step, -limit, limit)
+
+Where:
+    step = alpha * (raw_rpm - rpm_k)
+    alpha = Ts / (Tau + Ts)  [First-order Taylor approximation of 1-exp(-Ts/Tau)]
+    limit = MaxSlew * Ts
+
+This ensures physical consistency of the signal regardless of the
+userspace polling rate, while maximizing CPU sleep states.
+
+Probing:
+The driver dynamically searches for common Lenovo ACPI fan handles.

Documentation/hwmon/yogafan.rst line 51

Quoted 10 lines
Documentation/hwmon/yogafan.rst new file +10 -0
+It does not assume a fixed number of fans, making it compatible
+across various Yoga and Legion generations.
+
+Usage Note:
+If your device shows more fans than physically present, the EC is likely
+exposing a virtual or secondary hardware channel.
+
+
+
+

Unnecessary empty lines

Quoted 23 lines
MAINTAINERS +7 -0
index 96ea84948..dd16c882c 100644
@@ -29070,6 +29070,13 @@ S:	Maintained
  F:	Documentation/input/devices/yealink.rst
  F:	drivers/input/misc/yealink.*
 
+YOGAFAN HARDWARE MONITORING DRIVER
+M:	Sergio Melas <[email protected]>
+L:	[email protected]
+S:	Maintained
+F:	Documentation/hwmon/yogafan.rst
+F:	drivers/hwmon/yogafan.c
+
  Z8530 DRIVER FOR AX.25
  M:	Joerg Reuter <[email protected]>
  L:	[email protected]
drivers/hwmon/Kconfig +0 -0
index 7d938308d..d276763d6 100644

drivers/hwmon/Kconfig config SENSORS_YOGAFAN · line 2471

Quoted 4 lines
drivers/hwmon/Kconfig +1 -0
@@ -2468,6 +2468,7 @@ config SENSORS_YOGAFAN
  	  This driver can also be built as a module. If so, the module
  	  will be called yoga_fan.
 
+

No.

drivers/hwmon/Kconfig config SENSORS_HP_WMI · line 2757

Quoted 13 lines
drivers/hwmon/Kconfig +1 -5
  config SENSORS_VIA_CPUTEMP
  	tristate "VIA CPU temperature sensor"
  	depends on X86
@@ -2753,8 +2754,4 @@ config SENSORS_HP_WMI
  endif # ACPI
 
  endif # HWMON
-config SENSORS_YOGA_FAN
-	tristate "Lenovo Yoga Fan Hardware Monitoring"
-	depends on ACPI && HWMON
-	help
-	  Support for fan RPM on modern Lenovo laptops.
+

Huh ?

drivers/hwmon/Makefile obj-$(CONFIG_SENSORS_PECI) += peci/ · line 254

Quoted 9 lines
drivers/hwmon/Makefile +0 -1
index d8d4ff834..c74b71ec2 100644
@@ -251,5 +251,5 @@ obj-$(CONFIG_SENSORS_PECI)	+= peci/
  obj-$(CONFIG_PMBUS)		+= pmbus/
 
  ccflags-$(CONFIG_HWMON_DEBUG_CHIP) := -DDEBUG
-obj-$(CONFIG_SENSORS_YOGA_FAN) += yoga_fan.o

Huh ?

Quoted 281 lines
drivers/hwmon/Makefile +1 -0
+obj-$(CONFIG_SENSORS_YOGAFAN) += yogafan.o
 
drivers/hwmon/yogafan.c new file +273 -0
new file mode 100644
index 000000000..a260f4cf6
@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/**
+ * yoga_fan.c - Lenovo Yoga/Legion Fan Hardware Monitoring Driver
+ *
+ * Provides fan speed monitoring for Lenovo Yoga, Legion, and IdeaPad
+ * laptops by interfacing with the Embedded Controller (EC) via ACPI.
+ *
+ * The driver implements a passive discrete-time first-order lag filter
+ * with slew-rate limiting (RLLag). This addresses low-resolution
+ * tachometer sampling in the EC by smoothing RPM readings based on
+ * the time delta (dt) between userspace requests, ensuring physical
+ * consistency without background task overhead or race conditions.
+ * The filter has been removed implementing multirate filtering with autoreset in case
+ * of lage sampling time
+ *
+ * Copyright (C) 2021-2026 Sergio Melas <[email protected]>
+ */
+
+#include <linux/acpi.h>
+#include <linux/dmi.h>
+#include <linux/err.h>
+#include <linux/hwmon.h>
+#include <linux/init.h>
+#include <linux/ktime.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+
+#define DRVNAME "yogafan"
+#define MAX_FANS 8
+
+/* Filter Configuration Constants */
+#define TAU_MS          3000    /* Time constant for the first-order lag (ms) */
+#define MAX_SLEW_RPM_S  100     /* Maximum allowed change in RPM per second */
+#define MAX_SAMPLING    5000    /* Maximum allowed Ts for reset */
+
+struct yoga_fan_data {
+	const char *active_paths[MAX_FANS];
+	long filtered_val[MAX_FANS];
+	ktime_t last_update[MAX_FANS];
+	int fan_count;
+};
+
+/**
+ * apply_rllag_filter - Discrete-time filter update (Passive Multirate)
+ * @data: pointer to driver data
+ * @idx: fan index
+ * @raw_rpm: new raw value from ACPI
+ *
+ * Implements a Rate-Limited Lag (RLLag) filter using a multirate approach.
+ * Instead of a fixed-interval heartbeat, the sampling time (Ts) is calculated
+ * dynamically as the ktime delta between userspace read requests.
+ *
+ * This mimics a continuous-time First Order Plus Time Delay (FOPTD) model:
+ * rpm_k+1 = rpm_k + clamp(step, -limit, limit)
+ * where:
+ * step = (alpha * (raw_rpm - rpm_k))
+ * alpha = 1-exp(-Ts/Tau)
+ * Appling first order taylor approximation we get
+ * alpha = Ts / (Tau + Ts)
+ * limit = MaxSlew * Ts
+ *
+ * This ensures physical consistency of the signal regardless of the
+ * userspace polling rate.
+ */
+
+static void apply_rllag_filter(struct yoga_fan_data *data, int idx, long raw_rpm)
+{
+	ktime_t now = ktime_get();
+	s64 dt_ms;
+	long delta, step, limit, alpha;
+
+	/* Initialize on first read to avoid starting from zero */
+	if (data->last_update[idx] == 0) {
+		data->filtered_val[idx] = raw_rpm;
+		data->last_update[idx] = now;
+		return;
+	}
+
+	dt_ms = ktime_to_ms(ktime_sub(now, data->last_update[idx]));
+
+	/* * SANITATION: Reset filter if no reads occurred for MAX_SAMPLING
+	 * millisecond. This prevents massive 'lag_steps' if userspace polling resumes
+	 * after a long pause or system suspend.
+	 */
+	if (dt_ms > MAX_SAMPLING) {
+		data->filtered_val[idx] = raw_rpm;
+		data->last_update[idx] = now;
+		return;
+	}
+
+	/* SANITATION: Avoid division by zero or jitter from sub-millisecond reads */
+	if (dt_ms < 1)
+		return;
+
+	delta = raw_rpm - data->filtered_val[idx];
+
+	/* * Alpha = dt / (Tau + dt) using 10-bit fixed point math.
+	 * This mimics the physical inertia (FOPTD) of the fan blades.
+	 */
+	alpha = (dt_ms << 10) / (TAU_MS + dt_ms);
+	step = (delta * alpha) >> 10;
+
+	/* Slew Limit = (MaxSlew * dt) / 1000 - Bound the rate of change */
+	limit = (MAX_SLEW_RPM_S * (long)dt_ms) / 1000;
+
+	if (step > limit)
+		step = limit;
+	else if (step < -limit)
+		step = -limit;
+
+	data->filtered_val[idx] += step;
+
+	/* SANITATION: Floor the value to zero if RPM is negligible */
+	if (data->filtered_val[idx] < 50)
+		data->filtered_val[idx] = 0;
+
+	data->last_update[idx] = now;
+}
+
+static int yoga_fan_read(struct device *dev, enum hwmon_sensor_types type,
+			 u32 attr, int channel, long *val)
+{
+	struct yoga_fan_data *data = dev_get_drvdata(dev);
+	unsigned long long raw_acpi;
+	acpi_status status;
+	long rpm;
+
+	if (type != hwmon_fan || attr != hwmon_fan_input)
+		return -EOPNOTSUPP;
+
+	/* Implemnt better casting of staus using ACPI typedef */
+	status = acpi_evaluate_integer(NULL,
+				       (acpi_string)data->active_paths[channel], NULL, &raw_acpi);
+
+	if (ACPI_FAILURE(status))
+		return -EIO;
+
+	/* * SANITATION: Lenovo EC typically reports RPM in hundreds for values <= 255.
+	 * Values > 255 are treated as raw RPM. This handles different EC firmware styles.
+	 */
+	rpm = (raw_acpi > 0 && raw_acpi <= 255) ? ((long)raw_acpi * 100) : (long)raw_acpi;
+
+	apply_rllag_filter(data, channel, rpm);
+
+	*val = data->filtered_val[channel];
+	return 0;
+}
+
+static umode_t yoga_fan_is_visible(const void *data, enum hwmon_sensor_types type,
+				   u32 attr, int channel)
+{
+	const struct yoga_fan_data *fan_data = data;
+
+	if (type == hwmon_fan && channel < fan_data->fan_count)
+		return 0444;
+
+	return 0;
+}
+
+static const struct hwmon_ops yoga_fan_hwmon_ops = {
+	.is_visible = yoga_fan_is_visible,
+	.read = yoga_fan_read,
+};
+
+static const struct hwmon_channel_info *yoga_fan_info[] = {
+	HWMON_CHANNEL_INFO(fan,
+			   HWMON_F_INPUT, HWMON_F_INPUT, HWMON_F_INPUT, HWMON_F_INPUT,
+			   HWMON_F_INPUT, HWMON_F_INPUT, HWMON_F_INPUT, HWMON_F_INPUT),
+	NULL
+};
+
+static const struct hwmon_chip_info yoga_fan_chip_info = {
+	.ops = &yoga_fan_hwmon_ops,
+	.info = yoga_fan_info,
+};
+
+static int yoga_fan_probe(struct platform_device *pdev)
+{
+	struct yoga_fan_data *data;
+	struct device *hwmon_dev;
+	acpi_handle handle;
+	int i;
+
+	static const char * const fan_paths[] = {
+		"\\_SB.PCI0.LPC0.EC0.FANS",  /* Primary Fan (Yoga 14c) */
+		"\\_SB.PCI0.LPC0.EC0.FA2S",  /* Secondary Fan (Legion) */
+		"\\_SB.PCI0.LPC0.EC0.FAN0",  /* IdeaPad / Slim */
+		"\\_SB.PCI0.LPC.EC.FAN0",    /* Legacy */
+		"\\_SB.PCI0.LPC0.EC.FAN0",   /* Alternate */
+	};
+
+	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+	if (!data)
+		return -ENOMEM;
+
+	data->fan_count = 0;
+
+	/* SANITATION: Verify ACPI path existence before indexing */
+	for (i = 0; i < ARRAY_SIZE(fan_paths); i++) {
+		if (ACPI_SUCCESS(acpi_get_handle(NULL, (char *)fan_paths[i], &handle))) {
+			data->active_paths[data->fan_count] = fan_paths[i];
+			data->fan_count++;
+
+			if (data->fan_count >= MAX_FANS)
+				break;
+		}
+	}
+
+	if (data->fan_count == 0)
+		return -ENODEV;
+
+	/* SANITATION: Anchoring drvdata to avoid NULL returns during unload */
+	platform_set_drvdata(pdev, data);
+
+	hwmon_dev = devm_hwmon_device_register_with_info(&pdev->dev, DRVNAME,
+							 data, &yoga_fan_chip_info, NULL);
+
+	return PTR_ERR_OR_ZERO(hwmon_dev);
+}
+
+static struct platform_driver yoga_fan_driver = {
+	.driver = {
+		.name = DRVNAME,
+	},
+	.probe = yoga_fan_probe,
+};
+
+static struct platform_device *yoga_fan_device;
+
+static const struct dmi_system_id yoga_dmi_table[] __initconst = {
+	{
+		.ident = "Lenovo",
+		.matches = {
+			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
+		},
+	},
+	{ }
+};
+MODULE_DEVICE_TABLE(dmi, yoga_dmi_table);
+
+static int __init yoga_fan_init(void)
+{
+	int ret;
+
+	if (!dmi_check_system(yoga_dmi_table))
+		return -ENODEV;
+
+	ret = platform_driver_register(&yoga_fan_driver);
+	if (ret)
+		return ret;
+
+	yoga_fan_device = platform_device_register_simple(DRVNAME, 0, NULL, 0);
+	if (IS_ERR(yoga_fan_device)) {
+		platform_driver_unregister(&yoga_fan_driver);
+		return PTR_ERR(yoga_fan_device);
+	}
+
+	return 0;
+}
+
+static void __exit yoga_fan_exit(void)
+{
+	platform_device_unregister(yoga_fan_device);
+	platform_driver_unregister(&yoga_fan_driver);
+}
+
+module_init(yoga_fan_init);
+module_exit(yoga_fan_exit);
+
+MODULE_AUTHOR("Sergio Melas <[email protected]>");
+MODULE_DESCRIPTION("Lenovo Yoga/Legion Fan Monitor Driver");
+MODULE_LICENSE("GPL");