From 6ecf15d63a6dc0151f8b5191f53a3c8000cba1a5 Mon Sep 17 00:00:00 2001 From: Carlo Szelinsky Date: Tue, 9 Jun 2026 22:58:59 +0200 Subject: [PATCH] realtek: add hasivo-mcu sensor driver Add a temperature/fan sensor (hwmon) driver for the Hasivo / Horaco management MCU as a second child of the hasivo MCU MFD (alongside the watchdog). It exposes the CPU and system temperatures and a 3-state fan control (auto / force-on / force-off), read/written through the parent's shared syscon regmap. The register protocol was reverse-engineered from the stock 'imi' firmware and verified on hardware. The fan-status register (0xFB) reflects the MCU's effective drive state, not actual rotation (a blocked fan still reads force-on), so no fanN_alarm is exposed. pwm1 echoes the commanded state so a write reads back consistently, and falls back to the live drive state in automatic mode. The register map is shared across boards. Signed-off-by: Carlo Szelinsky Link: https://github.com/openwrt/openwrt/pull/23762 Signed-off-by: Markus Stockhausen --- target/linux/realtek/modules.mk | 17 + .../813-add-hasivo-mcu-sensor.patch | 488 ++++++++++++++++++ target/linux/realtek/rtl838x/config-6.18 | 1 + target/linux/realtek/rtl839x/config-6.18 | 1 + target/linux/realtek/rtl930x/config-6.18 | 1 + target/linux/realtek/rtl930x_nand/config-6.18 | 1 + target/linux/realtek/rtl931x/config-6.18 | 1 + target/linux/realtek/rtl931x_nand/config-6.18 | 1 + 8 files changed, 511 insertions(+) create mode 100644 target/linux/realtek/patches-6.18/813-add-hasivo-mcu-sensor.patch diff --git a/target/linux/realtek/modules.mk b/target/linux/realtek/modules.mk index 0d50b4f25cd..57025004f91 100644 --- a/target/linux/realtek/modules.mk +++ b/target/linux/realtek/modules.mk @@ -39,3 +39,20 @@ define KernelPackage/mfd-hasivo-stc8/description endef $(eval $(call KernelPackage,mfd-hasivo-stc8)) + +define KernelPackage/hasivo-mcu-sensor + SUBMENU:=$(HWMON_MENU) + TITLE:=Hasivo management MCU sensor driver + KCONFIG:=CONFIG_SENSORS_HASIVO_MCU + FILES:=$(LINUX_DIR)/drivers/hwmon/hasivo-mcu-sensor.ko + DEPENDS:=@TARGET_realtek +kmod-mfd-hasivo-stc8 + AUTOLOAD:=$(call AutoProbe,hasivo-mcu-sensor,1) +endef + +define KernelPackage/hasivo-mcu-sensor/description + sensor driver for the Hasivo management MCU (CPU/system + temperatures and fan control) on Hasivo / Horaco network switches. + A child of the hasivo MCU MFD. +endef + +$(eval $(call KernelPackage,hasivo-mcu-sensor)) diff --git a/target/linux/realtek/patches-6.18/813-add-hasivo-mcu-sensor.patch b/target/linux/realtek/patches-6.18/813-add-hasivo-mcu-sensor.patch new file mode 100644 index 00000000000..c07e9da285e --- /dev/null +++ b/target/linux/realtek/patches-6.18/813-add-hasivo-mcu-sensor.patch @@ -0,0 +1,488 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Carlo Szelinsky +Date: Sat, 24 May 2026 12:00:00 +0200 +Subject: hwmon: add Hasivo management MCU sensor driver + +Exposes CPU/system temperatures and fan presence + control for the +external management MCU found on Hasivo / Horaco network switches. +The sensor driver is a child of the hasivo MCU MFD (syscon regmap) and +reads temperature, capability and fan registers over I2C. + +The same temperature/fan register map is shared across Hasivo boards +(verified by diffing the stock firmware of the S1300WP-8XGT-4S+ and +S1100W-8XGT-SE); register 0xFD is a per-board firmware revision byte, not +a fixed chip identity, so the driver does not gate on a specific value. + +The driver, its device-tree binding and the Kconfig/Makefile wiring are +added to the kernel tree as a realtek target patch and exposed as the +kmod-hasivo-mcu-sensor KernelPackage. Keeping the binding in the kernel +tree lets dt_binding_check exercise it and makes the driver easy to drop +once it lands upstream. + +Signed-off-by: Carlo Szelinsky +--- +--- /dev/null ++++ b/Documentation/devicetree/bindings/hwmon/hasivo,mcu-sensor.yaml +@@ -0,0 +1,43 @@ ++# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) ++%YAML 1.2 ++--- ++$id: http://devicetree.org/schemas/hwmon/hasivo,mcu-sensor.yaml# ++$schema: http://devicetree.org/meta-schemas/core.yaml# ++ ++title: Hasivo management MCU sensor ++ ++maintainers: ++ - Carlo Szelinsky ++ ++description: | ++ Sensor node of the Hasivo management MCU MFD (compatible ++ "hasivo,stc8-mfd"). The microcontroller reports CPU and system ++ temperatures and provides a 3-state fan control (auto / force-on / ++ force-off) and reports the fan drive state. Fan speed is regulated ++ internally by the microcontroller; there is no host-side PWM duty or ++ tachometer register. ++ ++properties: ++ compatible: ++ const: hasivo,mcu-sensor ++ ++required: ++ - compatible ++ ++additionalProperties: false ++ ++examples: ++ - | ++ i2c { ++ #address-cells = <1>; ++ #size-cells = <0>; ++ ++ mcu: mcu-mfd@6f { ++ compatible = "hasivo,stc8-mfd", "syscon"; ++ reg = <0x6f>; ++ ++ sensor { ++ compatible = "hasivo,mcu-sensor"; ++ }; ++ }; ++ }; +--- a/drivers/hwmon/Kconfig ++++ b/drivers/hwmon/Kconfig +@@ -819,6 +819,21 @@ config SENSORS_GXP_FAN_CTRL + The GXP controls fan function via the CPLD through the use of PWM + registers. This driver reports status and pwm setting of the fans. + ++config SENSORS_HASIVO_MCU ++ tristate "Hasivo management MCU sensor" ++ depends on MFD_HASIVO_STC8 ++ depends on OF ++ select REGMAP ++ help ++ Sensor child of the Hasivo MCU MFD. Exposes CPU and system ++ temperatures plus a 3-state fan control knob (auto / force-on ++ / force-off) plus a fan drive-state reading. Used on Hasivo managed ++ switches that carry the management MCU for thermal and ++ fan management (S1300WP-8XGT-4S+ and similar). ++ ++ This driver can also be built as a module, which will be ++ called hasivo-mcu-sensor. ++ + config SENSORS_HIH6130 + tristate "Honeywell Humidicon HIH-6130 humidity/temperature sensor" + depends on I2C +--- a/drivers/hwmon/Makefile ++++ b/drivers/hwmon/Makefile +@@ -91,6 +91,7 @@ obj-$(CONFIG_SENSORS_GSC) += gsc-hwmon.o + obj-$(CONFIG_SENSORS_GPD) += gpd-fan.o + obj-$(CONFIG_SENSORS_GPIO_FAN) += gpio-fan.o + obj-$(CONFIG_SENSORS_GXP_FAN_CTRL) += gxp-fan-ctrl.o ++obj-$(CONFIG_SENSORS_HASIVO_MCU) += hasivo-mcu-sensor.o + obj-$(CONFIG_SENSORS_HIH6130) += hih6130.o + obj-$(CONFIG_SENSORS_HS3001) += hs3001.o + obj-$(CONFIG_SENSORS_HTU31) += htu31.o +--- /dev/null ++++ b/drivers/hwmon/hasivo-mcu-sensor.c +@@ -0,0 +1,382 @@ ++// SPDX-License-Identifier: GPL-2.0-only ++/* ++ * Hasivo management MCU sensor driver ++ * ++ * Exposes CPU/system temperatures and fan control as hwmon attributes via ++ * the parent MFD's syscon regmap. The MCU regulates fan speed internally; ++ * the host can only pick one of three modes (auto / force-on / force-off) ++ * via the fan-control register 0xFA, with pwm_enable following the hwmon ++ * convention: ++ * 0 = no host control (fan forced full speed) ++ * 1 = manual (state determined by pwm_input) ++ * 2 = automatic (MCU regulates based on internal temperature) ++ * ++ * There is no tachometer. The fan-status register 0xFB reflects the MCU's ++ * effective drive state (0x4f = auto-running, 0x5f = force-on, 0x40 = off), ++ * not actual rotation: blocking the blade while force-on still reads 0x5f. ++ * So pwm_input reports the live drive state from 0xFB (accurate in auto ++ * too), and no fanN_alarm is exposed - a stuck/dead fan is not detectable ++ * from these registers, and thermal protection is the MCU's own job. ++ * ++ * Register protocol reverse-engineered from the stock 'imi' binary and ++ * verified on hardware. The same temperature/fan register map is shared ++ * across Hasivo boards (S1300WP-8XGT-4S+, S1100W-8XGT-SE); reg 0xFD is a ++ * per-board firmware revision byte (0x91 / 0xFC), not a fixed chip identity. ++ * ++ * Copyright (C) 2026 Carlo Szelinsky ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define MCU_REG_CPU_TEMP_SIGN 0x01 ++#define MCU_REG_CPU_TEMP_MAG 0x02 ++#define MCU_REG_SYS_TEMP_SIGN 0x03 ++#define MCU_REG_SYS_TEMP_MAG 0x04 ++#define MCU_REG_FAN_CONTROL 0xfa ++#define MCU_REG_FAN_STATUS 0xfb ++#define MCU_REG_REVISION 0xfd ++#define MCU_REG_CAPABILITIES 0xfe ++ ++#define MCU_CAP_FAN_PRESENT BIT(6) ++#define MCU_CAP_TEMP_MASK GENMASK(5, 0) ++#define MCU_TEMP_FLAG_NONE 1 ++#define MCU_TEMP_FLAG_SYSTEM_ONLY 2 ++ ++/* ++ * Values written to the fan-control register (0xFA); the fan-status ++ * register (0xFB) reports the MCU's effective drive using the same encoding. ++ */ ++#define MCU_FAN_VAL_AUTO 0x4f ++#define MCU_FAN_VAL_FORCE_ON 0x5f ++#define MCU_FAN_VAL_FORCE_OFF 0x40 ++ ++#define MCU_PWM_FORCE_THRESHOLD 128 ++ ++enum mcu_temp_channel { ++ MCU_TEMP_CPU = 0, ++ MCU_TEMP_SYS, ++}; ++ ++struct mcu_sensor { ++ struct regmap *regmap; ++ bool fan_present; ++ bool cpu_temp_avail; ++ bool sys_temp_avail; ++}; ++ ++static int mcu_read_temp(struct regmap *regmap, unsigned int sign_reg, ++ unsigned int mag_reg, long *temp) ++{ ++ unsigned int sign, mag; ++ int ret; ++ ++ ret = regmap_read(regmap, sign_reg, &sign); ++ if (ret) ++ return ret; ++ ret = regmap_read(regmap, mag_reg, &mag); ++ if (ret) ++ return ret; ++ ++ /* ++ * The sign register is 0 for positive, non-zero (1 in practice) for ++ * negative. Treat any non-zero value as negative rather than only ++ * 0x01, so a stray reading can't be reported as a plausible positive ++ * temperature. ++ */ ++ *temp = (long)(sign ? -(int)mag : (int)mag) * 1000; ++ return 0; ++} ++ ++static umode_t mcu_is_visible(const void *drvdata, ++ enum hwmon_sensor_types type, ++ u32 attr, int channel) ++{ ++ const struct mcu_sensor *priv = drvdata; ++ ++ switch (type) { ++ case hwmon_temp: ++ /* ++ * Expose both temperature channels unconditionally so ++ * sysfs numbering stays contiguous (some userspace tools ++ * assume so). Per-channel availability is reported via ++ * tempN_fault. ++ */ ++ switch (attr) { ++ case hwmon_temp_input: ++ case hwmon_temp_label: ++ case hwmon_temp_fault: ++ return 0444; ++ } ++ break; ++ case hwmon_pwm: ++ if (!priv->fan_present) ++ return 0; ++ if (attr == hwmon_pwm_enable || attr == hwmon_pwm_input) ++ return 0644; ++ break; ++ default: ++ break; ++ } ++ return 0; ++} ++ ++static int mcu_read(struct device *dev, enum hwmon_sensor_types type, ++ u32 attr, int channel, long *val) ++{ ++ struct mcu_sensor *priv = dev_get_drvdata(dev); ++ unsigned int v; ++ int ret; ++ ++ switch (type) { ++ case hwmon_temp: ++ switch (attr) { ++ case hwmon_temp_input: ++ if (channel == MCU_TEMP_CPU) { ++ if (!priv->cpu_temp_avail) ++ return -ENODATA; ++ return mcu_read_temp(priv->regmap, ++ MCU_REG_CPU_TEMP_SIGN, ++ MCU_REG_CPU_TEMP_MAG, ++ val); ++ } ++ if (!priv->sys_temp_avail) ++ return -ENODATA; ++ return mcu_read_temp(priv->regmap, ++ MCU_REG_SYS_TEMP_SIGN, ++ MCU_REG_SYS_TEMP_MAG, ++ val); ++ case hwmon_temp_fault: ++ if (channel == MCU_TEMP_CPU) ++ *val = priv->cpu_temp_avail ? 0 : 1; ++ else ++ *val = priv->sys_temp_avail ? 0 : 1; ++ return 0; ++ } ++ break; ++ case hwmon_pwm: ++ switch (attr) { ++ case hwmon_pwm_enable: ++ /* ++ * Mode from the control register (0xFA), per the hwmon ++ * convention: 0 = force-on (full speed), 1 = manual ++ * (force-off; pwm_input drives it), 2 = automatic. ++ */ ++ ret = regmap_read(priv->regmap, MCU_REG_FAN_CONTROL, &v); ++ if (ret) ++ return ret; ++ switch (v) { ++ case MCU_FAN_VAL_AUTO: ++ *val = 2; ++ break; ++ case MCU_FAN_VAL_FORCE_ON: ++ *val = 0; ++ break; ++ default: ++ *val = 1; ++ break; ++ } ++ return 0; ++ case hwmon_pwm_input: ++ /* ++ * Echo the commanded state from the control register ++ * (0xFA) so a pwm write reads back consistently. The ++ * control register carries no duty in automatic mode, ++ * so there fall back to the live drive state (0xFB): ++ * 0x4f (auto-running) / 0x5f mean driven on, else off. ++ */ ++ ret = regmap_read(priv->regmap, MCU_REG_FAN_CONTROL, &v); ++ if (ret) ++ return ret; ++ if (v == MCU_FAN_VAL_AUTO) { ++ ret = regmap_read(priv->regmap, ++ MCU_REG_FAN_STATUS, &v); ++ if (ret) ++ return ret; ++ } ++ *val = (v == MCU_FAN_VAL_AUTO || v == MCU_FAN_VAL_FORCE_ON) ? 255 : 0; ++ return 0; ++ default: ++ return -EOPNOTSUPP; ++ } ++ break; ++ default: ++ break; ++ } ++ return -EOPNOTSUPP; ++} ++ ++static int mcu_read_string(struct device *dev, enum hwmon_sensor_types type, ++ u32 attr, int channel, const char **str) ++{ ++ if (type == hwmon_temp && attr == hwmon_temp_label) { ++ *str = (channel == MCU_TEMP_CPU) ? "CPU" : "System"; ++ return 0; ++ } ++ return -EOPNOTSUPP; ++} ++ ++static int mcu_write(struct device *dev, enum hwmon_sensor_types type, ++ u32 attr, int channel, long val) ++{ ++ struct mcu_sensor *priv = dev_get_drvdata(dev); ++ unsigned int byte; ++ ++ if (type != hwmon_pwm) ++ return -EOPNOTSUPP; ++ ++ switch (attr) { ++ case hwmon_pwm_enable: ++ switch (val) { ++ case 0: ++ byte = MCU_FAN_VAL_FORCE_ON; ++ break; ++ case 1: ++ /* ++ * Manual: leave the MCU's automatic regulation ++ * by switching to an explicit FORCE_OFF state so ++ * a subsequent pwm_enable read reports 1 (manual) ++ * even before any pwm_input write. Userspace is ++ * expected to follow up by writing pwm_input to ++ * pick the actual fan state. ++ */ ++ byte = MCU_FAN_VAL_FORCE_OFF; ++ break; ++ case 2: ++ byte = MCU_FAN_VAL_AUTO; ++ break; ++ default: ++ return -EINVAL; ++ } ++ break; ++ case hwmon_pwm_input: ++ if (val < 0) ++ return -EINVAL; ++ val = clamp_val(val, 0, 255); ++ byte = (val >= MCU_PWM_FORCE_THRESHOLD) ? ++ MCU_FAN_VAL_FORCE_ON : MCU_FAN_VAL_FORCE_OFF; ++ break; ++ default: ++ return -EOPNOTSUPP; ++ } ++ ++ return regmap_write(priv->regmap, MCU_REG_FAN_CONTROL, byte); ++} ++ ++static const struct hwmon_channel_info *const mcu_sensor_info[] = { ++ HWMON_CHANNEL_INFO(temp, ++ HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_FAULT, ++ HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_FAULT), ++ HWMON_CHANNEL_INFO(pwm, HWMON_PWM_ENABLE | HWMON_PWM_INPUT), ++ NULL ++}; ++ ++static const struct hwmon_ops mcu_sensor_ops = { ++ .is_visible = mcu_is_visible, ++ .read = mcu_read, ++ .read_string = mcu_read_string, ++ .write = mcu_write, ++}; ++ ++static const struct hwmon_chip_info mcu_sensor_chip_info = { ++ .ops = &mcu_sensor_ops, ++ .info = mcu_sensor_info, ++}; ++ ++static int mcu_sensor_probe(struct platform_device *pdev) ++{ ++ struct device *dev = &pdev->dev; ++ struct mcu_sensor *priv; ++ struct device *hwmon_dev; ++ unsigned int rev, caps, flag; ++ int ret; ++ ++ priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); ++ if (!priv) ++ return -ENOMEM; ++ ++ priv->regmap = syscon_node_to_regmap(dev_of_node(dev->parent)); ++ if (IS_ERR(priv->regmap)) ++ return dev_err_probe(dev, PTR_ERR(priv->regmap), ++ "failed to get parent regmap\n"); ++ ++ /* ++ * Register 0xFD holds a board/firmware revision byte (e.g. 0x91 on the ++ * S1300WP-8XGT-4S+, 0xFC on the S1100W-8XGT-SE), not a fixed chip ID; ++ * the stock firmware never gates on a specific value. Only reject the ++ * all-zero / all-ones reads that mean the MCU isn't responding, and ++ * leave actual feature detection to the capability register below. ++ */ ++ ret = regmap_read(priv->regmap, MCU_REG_REVISION, &rev); ++ if (ret) ++ return dev_err_probe(dev, ret, "failed to read revision\n"); ++ if (rev == 0x00 || rev == 0xff) ++ return dev_err_probe(dev, -ENODEV, ++ "MCU not responding (revision 0x%02x)\n", ++ rev); ++ ++ ret = regmap_read(priv->regmap, MCU_REG_CAPABILITIES, &caps); ++ if (ret) ++ return dev_err_probe(dev, ret, "failed to read capabilities\n"); ++ ++ priv->fan_present = !!(caps & MCU_CAP_FAN_PRESENT); ++ flag = caps & MCU_CAP_TEMP_MASK; ++ priv->cpu_temp_avail = flag != MCU_TEMP_FLAG_NONE && ++ flag != MCU_TEMP_FLAG_SYSTEM_ONLY; ++ priv->sys_temp_avail = flag != MCU_TEMP_FLAG_NONE; ++ ++ dev_info(dev, "rev 0x%02x: fan=%s cpu_temp=%s sys_temp=%s\n", rev, ++ priv->fan_present ? "present" : "absent", ++ priv->cpu_temp_avail ? "yes" : "no", ++ priv->sys_temp_avail ? "yes" : "no"); ++ ++ platform_set_drvdata(pdev, priv); ++ ++ hwmon_dev = devm_hwmon_device_register_with_info(dev, "hasivo_mcu", ++ priv, ++ &mcu_sensor_chip_info, ++ NULL); ++ return PTR_ERR_OR_ZERO(hwmon_dev); ++} ++ ++static void mcu_sensor_remove(struct platform_device *pdev) ++{ ++ struct mcu_sensor *priv = platform_get_drvdata(pdev); ++ ++ /* ++ * Restore AUTO mode so the MCU resumes thermal regulation after ++ * unload. Skipping this would leave a user-forced state in ++ * effect indefinitely (e.g. fan off after a force-off ++ * experiment + reboot), which is a real thermal-safety hazard. ++ */ ++ if (priv->fan_present) ++ regmap_write(priv->regmap, MCU_REG_FAN_CONTROL, ++ MCU_FAN_VAL_AUTO); ++} ++ ++static const struct of_device_id mcu_sensor_of_match[] = { ++ { .compatible = "hasivo,mcu-sensor" }, ++ { } ++}; ++MODULE_DEVICE_TABLE(of, mcu_sensor_of_match); ++ ++static struct platform_driver mcu_sensor_driver = { ++ .driver = { ++ .name = "hasivo-mcu-sensor", ++ .of_match_table = mcu_sensor_of_match, ++ }, ++ .probe = mcu_sensor_probe, ++ .remove = mcu_sensor_remove, ++}; ++module_platform_driver(mcu_sensor_driver); ++ ++MODULE_AUTHOR("Carlo Szelinsky "); ++MODULE_DESCRIPTION("Hasivo management MCU sensor driver"); ++MODULE_LICENSE("GPL"); diff --git a/target/linux/realtek/rtl838x/config-6.18 b/target/linux/realtek/rtl838x/config-6.18 index 9020be7c04b..4feac081b50 100644 --- a/target/linux/realtek/rtl838x/config-6.18 +++ b/target/linux/realtek/rtl838x/config-6.18 @@ -225,6 +225,7 @@ CONFIG_RESET_CONTROLLER=y CONFIG_RTL838X=y # CONFIG_RTL839X is not set # CONFIG_RTL930X is not set +# CONFIG_SENSORS_HASIVO_MCU is not set CONFIG_SERIAL_MCTRL_GPIO=y CONFIG_SERIAL_OF_PLATFORM=y CONFIG_SFP=y diff --git a/target/linux/realtek/rtl839x/config-6.18 b/target/linux/realtek/rtl839x/config-6.18 index 243e0ac5b29..5494c2b86e3 100644 --- a/target/linux/realtek/rtl839x/config-6.18 +++ b/target/linux/realtek/rtl839x/config-6.18 @@ -237,6 +237,7 @@ CONFIG_RPS=y # CONFIG_RTL838X is not set CONFIG_RTL839X=y # CONFIG_RTL930X is not set +# CONFIG_SENSORS_HASIVO_MCU is not set CONFIG_SERIAL_MCTRL_GPIO=y CONFIG_SERIAL_OF_PLATFORM=y CONFIG_SFP=y diff --git a/target/linux/realtek/rtl930x/config-6.18 b/target/linux/realtek/rtl930x/config-6.18 index ce48ee74d99..f361ccfc245 100644 --- a/target/linux/realtek/rtl930x/config-6.18 +++ b/target/linux/realtek/rtl930x/config-6.18 @@ -229,6 +229,7 @@ CONFIG_RPS=y CONFIG_RTL930X=y # CONFIG_RTL931X is not set CONFIG_SENSORS_GPIO_FAN=y +# CONFIG_SENSORS_HASIVO_MCU is not set CONFIG_SERIAL_MCTRL_GPIO=y CONFIG_SERIAL_OF_PLATFORM=y CONFIG_SFP=y diff --git a/target/linux/realtek/rtl930x_nand/config-6.18 b/target/linux/realtek/rtl930x_nand/config-6.18 index 2c0595f17ea..3708d692dc9 100644 --- a/target/linux/realtek/rtl930x_nand/config-6.18 +++ b/target/linux/realtek/rtl930x_nand/config-6.18 @@ -238,6 +238,7 @@ CONFIG_RPS=y # CONFIG_RTL839X is not set CONFIG_RTL930X=y # CONFIG_RTL931X is not set +# CONFIG_SENSORS_HASIVO_MCU is not set CONFIG_SERIAL_MCTRL_GPIO=y CONFIG_SERIAL_OF_PLATFORM=y CONFIG_SFP=y diff --git a/target/linux/realtek/rtl931x/config-6.18 b/target/linux/realtek/rtl931x/config-6.18 index 8d97246e31b..cdc6233afaa 100644 --- a/target/linux/realtek/rtl931x/config-6.18 +++ b/target/linux/realtek/rtl931x/config-6.18 @@ -234,6 +234,7 @@ CONFIG_RPS=y CONFIG_RTL930X=y CONFIG_RTL931X=y CONFIG_SENSORS_GPIO_FAN=y +# CONFIG_SENSORS_HASIVO_MCU is not set CONFIG_SENSORS_LM75=y CONFIG_SERIAL_MCTRL_GPIO=y CONFIG_SERIAL_OF_PLATFORM=y diff --git a/target/linux/realtek/rtl931x_nand/config-6.18 b/target/linux/realtek/rtl931x_nand/config-6.18 index 75129075f58..9483a0aeb13 100644 --- a/target/linux/realtek/rtl931x_nand/config-6.18 +++ b/target/linux/realtek/rtl931x_nand/config-6.18 @@ -243,6 +243,7 @@ CONFIG_RPS=y CONFIG_RTL930X=y CONFIG_RTL931X=y CONFIG_SENSORS_GPIO_FAN=y +# CONFIG_SENSORS_HASIVO_MCU is not set CONFIG_SENSORS_LM75=y CONFIG_SERIAL_MCTRL_GPIO=y CONFIG_SERIAL_OF_PLATFORM=y -- 2.47.3