PATCH v3 ASUS EC Sensors

PATCH v3 ASUS EC Sensors

[Eugene Shalygin]

Changes in v3:
    - Removed BIOS version checks and BIOS version dependent mutex path.

[PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

This driver provides the same data as the asus_wmi_ec_sensors driver
(and gets it from the same source) but does not use WMI, polling
the ACPI EC directly.

That provides two enhancements: sensor reading became quicker (on some
systems or kernel configuration it took almost a full second to read
all the sensors, that transfers less than 15 bytes of data), the driver
became more flexible. The driver now relies on ACPI mutex to lock access
to the EC in the same way as the WMI code does.

Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
---
 MAINTAINERS                     |   6 +
 drivers/hwmon/Kconfig           |  11 +
 drivers/hwmon/Makefile          |   1 +
 drivers/hwmon/asus-ec-sensors.c | 733 ++++++++++++++++++++++++++++++++
 4 files changed, 751 insertions(+)
 create mode 100644 drivers/hwmon/asus-ec-sensors.c

diff --git a/MAINTAINERS b/MAINTAINERS
index fddd28d3db15..845f09bc0457 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3012,6 +3012,12 @@ L:	linux-hwmon@vger.kernel.org
 S:	Maintained
 F:	drivers/hwmon/asus_wmi_ec_sensors.c
 
+ASUS EC HARDWARE MONITOR DRIVER
+M:	Eugene Shalygin <eugene.shalygin@gmail.com>
+L:	linux-hwmon@vger.kernel.org
+S:	Maintained
+F:	drivers/hwmon/asus-ec-sensors.c
+
 ASUS WIRELESS RADIO CONTROL DRIVER
 M:	João Paulo Rechi Vita <jprvita@gmail.com>
 L:	platform-driver-x86@vger.kernel.org
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 43e5245874ad..2c16b19d2c03 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -2253,6 +2253,17 @@ config SENSORS_ASUS_WMI_EC
 	  This driver can also be built as a module. If so, the module
 	  will be called asus_wmi_sensors_ec.
 
+config SENSORS_ASUS_EC
+	tristate "ASUS EC Sensors"
+	help
+	  If you say yes here you get support for the ACPI embedded controller
+	  hardware monitoring interface found in ASUS motherboards. The driver
+	  currently supports B550/X570 boards, although other ASUS boards might
+	  provide this monitoring interface as well.
+
+	  This driver can also be built as a module. If so, the module
+	  will be called asus_ec_sensors.
+
 endif # ACPI
 
 endif # HWMON
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 3a1551b3d570..2e5c216bb5d7 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID)		+= hwmon-vid.o
 # APCI drivers
 obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
 obj-$(CONFIG_SENSORS_ATK0110)	+= asus_atk0110.o
+obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
 
diff --git a/drivers/hwmon/asus-ec-sensors.c b/drivers/hwmon/asus-ec-sensors.c
new file mode 100644
index 000000000000..83921c3dee84
--- /dev/null
+++ b/drivers/hwmon/asus-ec-sensors.c
@@ -0,0 +1,733 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * HWMON driver for ASUS motherboards that publish some sensor values
+ * via the embedded controller registers.
+ *
+ * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
+
+ * EC provides:
+ * - Chipset temperature
+ * - CPU temperature
+ * - Motherboard temperature
+ * - T_Sensor temperature
+ * - VRM temperature
+ * - Water In temperature
+ * - Water Out temperature
+ * - CPU Optional fan RPM
+ * - Chipset fan RPM
+ * - VRM Heat Sink fan RPM
+ * - Water Flow fan RPM
+ * - CPU current
+ */
+
+#include <linux/acpi.h>
+#include <linux/bitops.h>
+#include <linux/dev_printk.h>
+#include <linux/dmi.h>
+#include <linux/hwmon.h>
+#include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/sort.h>
+#include <linux/units.h>
+
+#include <asm/unaligned.h>
+
+static char *mutex_path_override;
+
+/** Writing to this EC register switches EC bank */
+#define ASUS_EC_BANK_REGISTER 0xff
+#define SENSOR_LABEL_LEN 16
+
+/**
+ * Arbitrary set max. allowed bank number. Required for sorting banks and
+ * currently is overkill with just 2 banks used at max, but for the sake
+ * of alignment let's set it to a higher value.
+ */
+#define ASUS_EC_MAX_BANK 3
+
+#define ACPI_LOCK_DELAY_MS 500
+
+/* ACPI mutex for locking access to the EC for the firmware */
+#define ASUS_HW_ACCESS_MUTEX_ASMX "\\AMW0.ASMX"
+
+/* There are two variants of the vendor spelling */
+#define VENDOR_ASUS_UPPER_CASE "ASUSTeK COMPUTER INC."
+
+typedef union {
+	u32 value;
+	struct {
+		u8 index;
+		u8 bank;
+		u8 size;
+		u8 dummy;
+	} components;
+} sensor_address;
+
+#define MAKE_SENSOR_ADDRESS(size, bank, index) {                               \
+		.value = (size << 16) + (bank << 8) + index                    \
+	}
+
+static u32 hwmon_attributes[hwmon_max] = {
+	[hwmon_chip] = HWMON_C_REGISTER_TZ,
+	[hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
+	[hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
+	[hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
+	[hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
+};
+
+struct ec_sensor_info {
+	char label[SENSOR_LABEL_LEN];
+	enum hwmon_sensor_types type;
+	sensor_address addr;
+};
+
+#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) {              \
+		.label = sensor_label, .type = sensor_type,                    \
+		.addr = MAKE_SENSOR_ADDRESS(size, bank, index),                \
+	}
+
+enum ec_sensors {
+	/** chipset temperature [℃] */
+	ec_sensor_temp_chipset,
+	/** CPU temperature [℃] */
+	ec_sensor_temp_cpu,
+	/** motherboard temperature [℃] */
+	ec_sensor_temp_mb,
+	/** "T_Sensor" temperature sensor reading [℃] */
+	ec_sensor_temp_t_sensor,
+	/** VRM temperature [℃] */
+	ec_sensor_temp_vrm,
+	/** CPU_Opt fan [RPM] */
+	ec_sensor_fan_cpu_opt,
+	/** VRM heat sink fan [RPM] */
+	ec_sensor_fan_vrm_hs,
+	/** Chipset fan [RPM] */
+	ec_sensor_fan_chipset,
+	/** Water flow sensor reading [RPM] */
+	ec_sensor_fan_water_flow,
+	/** CPU current [A] */
+	ec_sensor_curr_cpu,
+	/** "Water_In" temperature sensor reading [℃] */
+	ec_sensor_temp_water_in,
+	/** "Water_Out" temperature sensor reading [℃] */
+	ec_sensor_temp_water_out,
+};
+
+#define SENSOR_TEMP_CHIPSET BIT(ec_sensor_temp_chipset)
+#define SENSOR_TEMP_CPU BIT(ec_sensor_temp_cpu)
+#define SENSOR_TEMP_MB BIT(ec_sensor_temp_mb)
+#define SENSOR_TEMP_T_SENSOR BIT(ec_sensor_temp_t_sensor)
+#define SENSOR_TEMP_VRM BIT(ec_sensor_temp_vrm)
+#define SENSOR_FAN_CPU_OPT BIT(ec_sensor_fan_cpu_opt)
+#define SENSOR_FAN_VRM_HS BIT(ec_sensor_fan_vrm_hs)
+#define SENSOR_FAN_CHIPSET BIT(ec_sensor_fan_chipset)
+#define SENSOR_FAN_WATER_FLOW BIT(ec_sensor_fan_water_flow)
+#define SENSOR_CURR_CPU BIT(ec_sensor_curr_cpu)
+#define SENSOR_TEMP_WATER_IN BIT(ec_sensor_temp_water_in)
+#define SENSOR_TEMP_WATER_OUT BIT(ec_sensor_temp_water_out)
+
+/**
+ * All the known sensors for ASUS EC controllers
+ */
+static const struct ec_sensor_info known_ec_sensors[] = {
+	[ec_sensor_temp_chipset] =
+		EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
+	[ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
+	[ec_sensor_temp_mb] =
+		EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
+	[ec_sensor_temp_t_sensor] =
+		EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
+	[ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
+	[ec_sensor_fan_cpu_opt] =
+		EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
+	[ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
+	[ec_sensor_fan_chipset] =
+		EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
+	[ec_sensor_fan_water_flow] =
+		EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
+	[ec_sensor_curr_cpu] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
+	[ec_sensor_temp_water_in] =
+		EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
+	[ec_sensor_temp_water_out] =
+		EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
+};
+
+struct asus_ec_board_info {
+	unsigned long sensors;
+};
+
+/* Shortcuts for common combinations */
+#define SENSOR_SET_TEMP_CHIPSET_CPU_MB                                         \
+	(SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB)
+#define SENSOR_SET_TEMP_WATER (SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT)
+
+static struct asus_ec_board_info board_P_X570_P = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
+		   SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET,
+};
+
+static struct asus_ec_board_info board_PW_X570_A = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
+		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+};
+
+static struct asus_ec_board_info board_R_C8H = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
+		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
+		   SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
+};
+
+/* Same as Hero but without chipset fan */
+static struct asus_ec_board_info board_R_C8DH = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
+		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
+};
+
+/* Same as Hero but without water */
+static struct asus_ec_board_info board_R_C8F = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
+		   SENSOR_CURR_CPU,
+};
+
+static struct asus_ec_board_info board_R_C8I = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+};
+
+static struct asus_ec_board_info board_RS_B550_E_G = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT,
+};
+
+static struct asus_ec_board_info board_RS_B550_I_G = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_VRM_HS | SENSOR_CURR_CPU,
+};
+
+static struct asus_ec_board_info board_RS_X570_E_G = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+};
+
+static struct asus_ec_board_info board_RS_X570_I_G = {
+	.sensors = SENSOR_TEMP_T_SENSOR | SENSOR_FAN_VRM_HS |
+		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+};
+
+#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {                         \
+	.matches = {                                                           \
+		DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),                     \
+		DMI_EXACT_MATCH(DMI_BOARD_NAME, name),                         \
+	},                                                                     \
+	.driver_data = sensors, \
+}
+
+static const struct dmi_system_id asus_ec_dmi_table[] __initconst = {
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "PRIME X570-PRO",
+			      &board_P_X570_P),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "Pro WS X570-ACE",
+			      &board_PW_X570_A),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII DARK HERO", &board_R_C8DH),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII FORMULA", &board_R_C8F),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG CROSSHAIR VIII HERO",
+			      &board_R_C8H),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII IMPACT", &board_R_C8I),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-E GAMING",
+			      &board_RS_B550_E_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-I GAMING",
+			      &board_RS_B550_I_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-E GAMING",
+			      &board_RS_X570_E_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-I GAMING",
+			      &board_RS_X570_I_G),
+	{}
+};
+
+struct ec_sensor {
+	unsigned int info_index;
+	u32 cached_value;
+};
+
+struct ec_sensors_data {
+	const struct asus_ec_board_info *board;
+	struct ec_sensor *sensors;
+	/** EC registers to read from */
+	u16 *registers;
+	u8 *read_buffer;
+	/** sorted list of unique register banks */
+	u8 banks[ASUS_EC_MAX_BANK + 1];
+	/** in jiffies */
+	unsigned long last_updated;
+	acpi_handle aml_mutex;
+	/** number of board EC sensors */
+	u8 nr_sensors;
+	/** number of EC registers to read (sensor might span more than 1 register) */
+	u8 nr_registers;
+	/** number of unique register banks */
+	u8 nr_banks;
+};
+
+static u8 register_bank(u16 reg)
+{
+	return reg >> 8;
+}
+
+static u8 register_index(u16 reg)
+{
+	return reg & 0x00ff;
+}
+
+static const struct ec_sensor_info *
+get_sensor_info(const struct ec_sensors_data *state, int index)
+{
+	return &known_ec_sensors[state->sensors[index].info_index];
+}
+
+static int find_ec_sensor_index(const struct ec_sensors_data *ec,
+				enum hwmon_sensor_types type, int channel)
+{
+	unsigned int i;
+
+	for (i = 0; i < ec->nr_sensors; i++) {
+		if (get_sensor_info(ec, i)->type == type) {
+			if (channel == 0)
+				return i;
+			channel--;
+		}
+	}
+	return -ENOENT;
+}
+
+static int __init bank_compare(const void *a, const void *b)
+{
+	return *((const s8 *)a) - *((const s8 *)b);
+}
+
+static int __init board_sensors_count(const struct asus_ec_board_info *board)
+{
+	return hweight_long(board->sensors);
+}
+
+static void __init setup_sensor_data(struct ec_sensors_data *ec)
+{
+	struct ec_sensor *s = ec->sensors;
+	bool bank_found;
+	int i, j;
+	u8 bank;
+
+	ec->nr_banks = 0;
+	ec->nr_registers = 0;
+
+	for_each_set_bit(i, &ec->board->sensors,
+			  BITS_PER_TYPE(ec->board->sensors)) {
+		s->info_index = i;
+		s->cached_value = 0;
+		ec->nr_registers +=
+			known_ec_sensors[s->info_index].addr.components.size;
+		bank_found = false;
+		bank = known_ec_sensors[s->info_index].addr.components.bank;
+		for (j = 0; j < ec->nr_banks; j++) {
+			if (ec->banks[j] == bank) {
+				bank_found = true;
+				break;
+			}
+		}
+		if (!bank_found) {
+			ec->banks[ec->nr_banks++] = bank;
+		}
+		s++;
+	}
+	sort(ec->banks, ec->nr_banks, 1, bank_compare, NULL);
+}
+
+static void __init fill_ec_registers(struct ec_sensors_data *ec)
+{
+	const struct ec_sensor_info *si;
+	unsigned int i, j, register_idx = 0;
+
+	for (i = 0; i < ec->nr_sensors; ++i) {
+		si = get_sensor_info(ec, i);
+		for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {
+			ec->registers[register_idx] =
+				(si->addr.components.bank << 8) +
+				si->addr.components.index + j;
+		}
+	}
+}
+
+static acpi_handle asus_hw_access_mutex(struct device *dev)
+{
+	const char *mutex_path;
+	acpi_handle res;
+	int status;
+
+	mutex_path = mutex_path_override ?
+		mutex_path_override : ASUS_HW_ACCESS_MUTEX_ASMX;
+
+	status = acpi_get_handle(NULL, (acpi_string)mutex_path, &res);
+	if (ACPI_FAILURE(status)) {
+		dev_err(dev,
+			"Could not get hardware access guard mutex '%s': error %d",
+			mutex_path, status);
+		return NULL;
+	}
+	return res;
+}
+
+static int asus_ec_bank_switch(u8 bank, u8 *old)
+{
+	int status = 0;
+
+	if (old) {
+		status = ec_read(ASUS_EC_BANK_REGISTER, old);
+	}
+	if (status || (old && (*old == bank)))
+		return status;
+	return ec_write(ASUS_EC_BANK_REGISTER, bank);
+}
+
+static int asus_ec_block_read(const struct device *dev,
+			      struct ec_sensors_data *ec)
+{
+	int ireg, ibank, status;
+	u8 bank, reg_bank, prev_bank;
+
+	bank = 0;
+	status = asus_ec_bank_switch(bank, &prev_bank);
+	if (status) {
+		dev_warn(dev, "EC bank switch failed");
+		return status;
+	}
+
+	if (prev_bank) {
+		/* oops... somebody else is working with the EC too */
+		dev_warn(dev,
+			"Concurrent access to the ACPI EC detected.\nRace condition possible.");
+	}
+
+	/*
+	 * read registers minimizing bank switches.
+	 */
+	for (ibank = 0; ibank < ec->nr_banks; ibank++) {
+		if (bank != ec->banks[ibank]) {
+			bank = ec->banks[ibank];
+			if (asus_ec_bank_switch(bank, NULL)) {
+				dev_warn(dev, "EC bank switch to %d failed",
+					 bank);
+				break;
+			}
+		}
+		for (ireg = 0; ireg < ec->nr_registers; ireg++) {
+			reg_bank = register_bank(ec->registers[ireg]);
+			if (reg_bank < bank) {
+				continue;
+			}
+			ec_read(register_index(ec->registers[ireg]),
+				ec->read_buffer + ireg);
+		}
+	}
+
+	status = asus_ec_bank_switch(prev_bank, NULL);
+	return status;
+}
+
+static inline u32 get_sensor_value(const struct ec_sensor_info *si, u8 *data)
+{
+	switch (si->addr.components.size) {
+	case 1:
+		return *data;
+	case 2:
+		return get_unaligned_be16(data);
+	case 4:
+		return get_unaligned_be32(data);
+	default:
+		return 0;
+	}
+}
+
+static void update_sensor_values(struct ec_sensors_data *ec, u8 *data)
+{
+	const struct ec_sensor_info *si;
+	struct ec_sensor *s;
+
+	for (s = ec->sensors; s != ec->sensors + ec->nr_sensors; s++) {
+		si = &known_ec_sensors[s->info_index];
+		s->cached_value = get_sensor_value(si, data);
+		data += si->addr.components.size;
+	}
+}
+
+static int update_ec_sensors(const struct device *dev,
+			     struct ec_sensors_data *ec)
+{
+	int status;
+
+	/*
+	 * ASUS DSDT does not specify that access to the EC has to be guarded,
+	 * but firmware does access it via ACPI
+	 */
+	if (ACPI_FAILURE(acpi_acquire_mutex(ec->aml_mutex, NULL,
+					    ACPI_LOCK_DELAY_MS))) {
+		dev_err(dev, "Failed to acquire AML mutex");
+		status = -EBUSY;
+		goto cleanup;
+	}
+
+	status = asus_ec_block_read(dev, ec);
+
+	if (!status) {
+		update_sensor_values(ec, ec->read_buffer);
+	}
+	if (ACPI_FAILURE(acpi_release_mutex(ec->aml_mutex, NULL))) {
+		dev_err(dev, "Failed to release AML mutex");
+	}
+cleanup:
+	return status;
+}
+
+static int scale_sensor_value(u32 value, int data_type)
+{
+	switch (data_type) {
+	case hwmon_curr:
+	case hwmon_temp:
+	case hwmon_in:
+		return value * MILLI;
+	default:
+		return value;
+	}
+}
+
+static int get_cached_value_or_update(const struct device *dev,
+				      int sensor_index,
+				      struct ec_sensors_data *state, u32 *value)
+{
+	if (time_after(jiffies, state->last_updated + HZ)) {
+		if (update_ec_sensors(dev, state)) {
+			dev_err(dev, "update_ec_sensors() failure\n");
+			return -EIO;
+		}
+
+		state->last_updated = jiffies;
+	}
+
+	*value = state->sensors[sensor_index].cached_value;
+	return 0;
+}
+
+/*
+ * Now follow the functions that implement the hwmon interface
+ */
+
+static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
+			      u32 attr, int channel, long *val)
+{
+	int ret;
+	u32 value = 0;
+
+	struct ec_sensors_data *state = dev_get_drvdata(dev);
+	int sidx = find_ec_sensor_index(state, type, channel);
+
+	if (sidx < 0) {
+		return sidx;
+	}
+
+	ret = get_cached_value_or_update(dev, sidx, state, &value);
+	if (!ret) {
+		*val = scale_sensor_value(value,
+					  get_sensor_info(state, sidx)->type);
+	}
+
+	return ret;
+}
+
+static int asus_ec_hwmon_read_string(struct device *dev,
+				     enum hwmon_sensor_types type, u32 attr,
+				     int channel, const char **str)
+{
+	struct ec_sensors_data *state = dev_get_drvdata(dev);
+	int sensor_index = find_ec_sensor_index(state, type, channel);
+	*str = get_sensor_info(state, sensor_index)->label;
+
+	return 0;
+}
+
+static umode_t asus_ec_hwmon_is_visible(const void *drvdata,
+					enum hwmon_sensor_types type, u32 attr,
+					int channel)
+{
+	const struct ec_sensors_data *state = drvdata;
+
+	return find_ec_sensor_index(state, type, channel) >= 0 ? S_IRUGO : 0;
+}
+
+static int
+asus_ec_hwmon_add_chan_info(struct hwmon_channel_info *asus_ec_hwmon_chan,
+			     struct device *dev, int num,
+			     enum hwmon_sensor_types type, u32 config)
+{
+	int i;
+	u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
+
+	if (!cfg)
+		return -ENOMEM;
+
+	asus_ec_hwmon_chan->type = type;
+	asus_ec_hwmon_chan->config = cfg;
+	for (i = 0; i < num; i++, cfg++)
+		*cfg = config;
+
+	return 0;
+}
+
+static const struct hwmon_ops asus_ec_hwmon_ops = {
+	.is_visible = asus_ec_hwmon_is_visible,
+	.read = asus_ec_hwmon_read,
+	.read_string = asus_ec_hwmon_read_string,
+};
+
+static struct hwmon_chip_info asus_ec_chip_info = {
+	.ops = &asus_ec_hwmon_ops,
+};
+
+static const struct asus_ec_board_info *__init
+get_board_info(const struct device *dev)
+{
+	const struct dmi_system_id *dmi_entry;
+
+	dmi_entry = dmi_first_match(asus_ec_dmi_table);
+	if (!dmi_entry) {
+		dev_info(dev, "Unsupported board");
+		return NULL;
+	}
+
+	return dmi_entry->driver_data;
+}
+
+static int __init configure_sensor_setup(struct device *dev)
+{
+	struct ec_sensors_data *ec_data = dev_get_drvdata(dev);
+	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
+	struct device *hwdev;
+	struct hwmon_channel_info *asus_ec_hwmon_chan;
+	const struct hwmon_channel_info **ptr_asus_ec_ci;
+	const struct hwmon_chip_info *chip_info;
+	const struct ec_sensor_info *si;
+	enum hwmon_sensor_types type;
+	unsigned int i;
+
+	ec_data->board = get_board_info(dev);
+	if (!ec_data->board) {
+		return -ENODEV;
+	}
+
+	ec_data->nr_sensors = board_sensors_count(ec_data->board);
+	ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors,
+					sizeof(struct ec_sensor), GFP_KERNEL);
+
+	setup_sensor_data(ec_data);
+	ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers,
+					  sizeof(u16), GFP_KERNEL);
+	ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers,
+					    sizeof(u8), GFP_KERNEL);
+
+	if (!ec_data->registers || !ec_data->read_buffer) {
+		return -ENOMEM;
+	}
+
+	fill_ec_registers(ec_data);
+
+	ec_data->aml_mutex = asus_hw_access_mutex(dev);
+
+	for (i = 0; i < ec_data->nr_sensors; ++i) {
+		si = get_sensor_info(ec_data, i);
+		if (!nr_count[si->type])
+			++nr_types;
+		++nr_count[si->type];
+	}
+
+	if (nr_count[hwmon_temp])
+		nr_count[hwmon_chip]++, nr_types++;
+
+	asus_ec_hwmon_chan = devm_kcalloc(
+		dev, nr_types, sizeof(*asus_ec_hwmon_chan), GFP_KERNEL);
+	if (!asus_ec_hwmon_chan)
+		return -ENOMEM;
+
+	ptr_asus_ec_ci = devm_kcalloc(dev, nr_types + 1,
+				       sizeof(*ptr_asus_ec_ci), GFP_KERNEL);
+	if (!ptr_asus_ec_ci)
+		return -ENOMEM;
+
+	asus_ec_chip_info.info = ptr_asus_ec_ci;
+	chip_info = &asus_ec_chip_info;
+
+	for (type = 0; type < hwmon_max; ++type) {
+		if (!nr_count[type])
+			continue;
+
+		asus_ec_hwmon_add_chan_info(asus_ec_hwmon_chan, dev,
+					     nr_count[type], type,
+					     hwmon_attributes[type]);
+		*ptr_asus_ec_ci++ = asus_ec_hwmon_chan++;
+	}
+
+	dev_info(dev, "board has %d EC sensors that span %d registers",
+		 ec_data->nr_sensors, ec_data->nr_registers);
+
+	hwdev = devm_hwmon_device_register_with_info(dev, "asus-ec-sensors",
+						     ec_data, chip_info, NULL);
+
+	return PTR_ERR_OR_ZERO(hwdev);
+}
+
+static int __init asus_ec_probe(struct platform_device *pdev)
+{
+	struct asus_ec_sensors *state;
+	int status = 0;
+
+	state = devm_kzalloc(&pdev->dev, sizeof(struct ec_sensors_data),
+			     GFP_KERNEL);
+
+	if (!state) {
+		return -ENOMEM;
+	}
+
+	dev_set_drvdata(&pdev->dev, state);
+	status = configure_sensor_setup(&pdev->dev);
+	return status;
+}
+
+static const struct acpi_device_id acpi_ec_ids[] = {
+	/* Embedded Controller Device */
+	{ "PNP0C09", 0 },
+	{}
+};
+
+static struct platform_driver asus_ec_sensors_platform_driver = {
+	.driver = {
+		.name	= "asus-ec-sensors",
+		.acpi_match_table = acpi_ec_ids,
+	},
+};
+
+MODULE_DEVICE_TABLE(dmi, asus_ec_dmi_table);
+module_platform_driver_probe(asus_ec_sensors_platform_driver, asus_ec_probe);
+
+module_param_named(mutex_path, mutex_path_override, charp, 0);
+MODULE_PARM_DESC(mutex_path,
+		 "Override ACPI mutex path used to guard access to hardware");
+
+MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
+MODULE_DESCRIPTION(
+	"HWMON driver for sensors accessible via ACPI EC in ASUS motherboards");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1");
-- 
2.34.1

[PATCH 2/3] hwmon: (asus-ec-sensors) update documentation

[Eugene Shalygin]

Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
---
 Documentation/hwmon/asus_ec_sensors.rst     | 51 +++++++++++++++++++++
 Documentation/hwmon/asus_wmi_ec_sensors.rst | 38 ---------------
 2 files changed, 51 insertions(+), 38 deletions(-)
 create mode 100644 Documentation/hwmon/asus_ec_sensors.rst
 delete mode 100644 Documentation/hwmon/asus_wmi_ec_sensors.rst

diff --git a/Documentation/hwmon/asus_ec_sensors.rst b/Documentation/hwmon/asus_ec_sensors.rst
new file mode 100644
index 000000000000..b8820cd1bd62
--- /dev/null
+++ b/Documentation/hwmon/asus_ec_sensors.rst
@@ -0,0 +1,51 @@
+.. SPDX-License-Identifier: GPL-2.0-or-later
+
+Kernel driver asus_ec_sensors
+=================================
+
+Supported boards:
+ * PRIME X570-PRO,
+ * Pro WS X570-ACE,
+ * ROG CROSSHAIR VIII DARK HERO,
+ * ROG CROSSHAIR VIII FORMULA,
+ * ROG CROSSHAIR VIII HERO,
+ * ROG CROSSHAIR VIII IMPACT,
+ * ROG STRIX B550-E GAMING,
+ * ROG STRIX B550-I GAMING,
+ * ROG STRIX X570-E GAMING,
+ * ROG STRIX X570-I GAMING
+
+Authors:
+    - Eugene Shalygin <eugene.shalygin@gmail.com>
+
+Description:
+------------
+ASUS mainboards publish hardware monitoring information via Super I/O
+chip and the ACPI embedded controller (EC) registers. Some of the sensors
+are only available via the EC.
+
+The driver is aware of and reads the following sensors:
+
+1. Chipset (PCH) temperature
+2. CPU package temperature
+3. Motherboard temperature
+4. Readings from the T_Sensor header
+5. VRM temperature
+6. CPU_Opt fan RPM
+7. VRM heatsink fan RPM
+8. Chipset fan RPM
+9. Readings from the "Water flow meter" header (RPM)
+10. Readings from the "Water In" and "Water Out" temperature headers
+11. CPU current
+
+Sensor values are read from EC registers, and to avoid race with the board
+firmware the driver acquires ACPI mutex, the one used by the WMI when its
+methods access the EC.
+
+Module Parameters
+-----------------
+ * mutex_path: string
+		The driver holds path to the ACPI mutex for each board (actually,
+		the path is mostly identical for them). If ASUS changes this path
+		in a future BIOS update, this parameter can be used to override
+		the stored in the driver value until it gets updated.
diff --git a/Documentation/hwmon/asus_wmi_ec_sensors.rst b/Documentation/hwmon/asus_wmi_ec_sensors.rst
deleted file mode 100644
index 1b287f229e86..000000000000
--- a/Documentation/hwmon/asus_wmi_ec_sensors.rst
+++ /dev/null
@@ -1,38 +0,0 @@
-.. SPDX-License-Identifier: GPL-2.0-or-later
-
-Kernel driver asus_wmi_ec_sensors
-=================================
-
-Supported boards:
- * PRIME X570-PRO,
- * Pro WS X570-ACE,
- * ROG CROSSHAIR VIII DARK HERO,
- * ROG CROSSHAIR VIII FORMULA,
- * ROG CROSSHAIR VIII HERO,
- * ROG STRIX B550-E GAMING,
- * ROG STRIX B550-I GAMING,
- * ROG STRIX X570-E GAMING.
-
-Authors:
-    - Eugene Shalygin <eugene.shalygin@gmail.com>
-
-Description:
-------------
-ASUS mainboards publish hardware monitoring information via Super I/O
-chip and the ACPI embedded controller (EC) registers. Some of the sensors
-are only available via the EC.
-
-ASUS WMI interface provides a method (BREC) to read data from EC registers,
-which is utilized by this driver to publish those sensor readings to the
-HWMON system. The driver is aware of and reads the following sensors:
-
-1. Chipset (PCH) temperature
-2. CPU package temperature
-3. Motherboard temperature
-4. Readings from the T_Sensor header
-5. VRM temperature
-6. CPU_Opt fan RPM
-7. Chipset fan RPM
-8. Readings from the "Water flow meter" header (RPM)
-9. Readings from the "Water In" and "Water Out" temperature headers
-10. CPU current
-- 
2.34.1

[PATCH 3/3] hwmon: (asus_wmi_ec_sensors) remove the driver

[Eugene Shalygin]

The driver is superceeded by asus-ec-sensors

Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
---
 MAINTAINERS                         |   7 -
 drivers/hwmon/Kconfig               |  12 -
 drivers/hwmon/Makefile              |   1 -
 drivers/hwmon/asus_wmi_ec_sensors.c | 621 ----------------------------
 4 files changed, 641 deletions(-)
 delete mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c

diff --git a/MAINTAINERS b/MAINTAINERS
index 845f09bc0457..6d2589d1d242 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3005,13 +3005,6 @@ L:	linux-hwmon@vger.kernel.org
 S:	Maintained
 F:	drivers/hwmon/asus_wmi_sensors.c
 
-ASUS WMI EC HARDWARE MONITOR DRIVER
-M:	Eugene Shalygin <eugene.shalygin@gmail.com>
-M:	Denis Pauk <pauk.denis@gmail.com>
-L:	linux-hwmon@vger.kernel.org
-S:	Maintained
-F:	drivers/hwmon/asus_wmi_ec_sensors.c
-
 ASUS EC HARDWARE MONITOR DRIVER
 M:	Eugene Shalygin <eugene.shalygin@gmail.com>
 L:	linux-hwmon@vger.kernel.org
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 2c16b19d2c03..6f43c5dcb0dd 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -2241,18 +2241,6 @@ config SENSORS_ASUS_WMI
 	  This driver can also be built as a module. If so, the module
 	  will be called asus_wmi_sensors.
 
-config SENSORS_ASUS_WMI_EC
-	tristate "ASUS WMI B550/X570"
-	depends on ACPI_WMI
-	help
-	  If you say yes here you get support for the ACPI embedded controller
-	  hardware monitoring interface found in B550/X570 ASUS motherboards.
-	  This driver will provide readings of fans, voltages and temperatures
-	  through the system firmware.
-
-	  This driver can also be built as a module. If so, the module
-	  will be called asus_wmi_sensors_ec.
-
 config SENSORS_ASUS_EC
 	tristate "ASUS EC Sensors"
 	help
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 2e5c216bb5d7..71eb2d548e20 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -11,7 +11,6 @@ obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
 obj-$(CONFIG_SENSORS_ATK0110)	+= asus_atk0110.o
 obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
-obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
 
 # Native drivers
 # asb100, then w83781d go first, as they can override other drivers' addresses.
diff --git a/drivers/hwmon/asus_wmi_ec_sensors.c b/drivers/hwmon/asus_wmi_ec_sensors.c
deleted file mode 100644
index 22a1459305a7..000000000000
--- a/drivers/hwmon/asus_wmi_ec_sensors.c
+++ /dev/null
@@ -1,621 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * HWMON driver for ASUS B550/X570 motherboards that publish sensor
- * values via the embedded controller registers.
- *
- * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
- * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
- *
- * EC provides:
- * - Chipset temperature
- * - CPU temperature
- * - Motherboard temperature
- * - T_Sensor temperature
- * - VRM temperature
- * - Water In temperature
- * - Water Out temperature
- * - CPU Optional Fan RPM
- * - Chipset Fan RPM
- * - Water Flow Fan RPM
- * - CPU current
- */
-
-#include <linux/acpi.h>
-#include <linux/dmi.h>
-#include <linux/hwmon.h>
-#include <linux/init.h>
-#include <linux/jiffies.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/nls.h>
-#include <linux/units.h>
-#include <linux/wmi.h>
-
-#include <asm/unaligned.h>
-
-#define ASUSWMI_MONITORING_GUID		"466747A0-70EC-11DE-8A39-0800200C9A66"
-#define ASUSWMI_METHODID_BLOCK_READ_EC	0x42524543 /* BREC */
-/* From the ASUS DSDT source */
-#define ASUSWMI_BREC_REGISTERS_MAX	16
-#define ASUSWMI_MAX_BUF_LEN		128
-#define SENSOR_LABEL_LEN		16
-
-static u32 hwmon_attributes[hwmon_max] = {
-	[hwmon_chip]	= HWMON_C_REGISTER_TZ,
-	[hwmon_temp]	= HWMON_T_INPUT | HWMON_T_LABEL,
-	[hwmon_in]	= HWMON_I_INPUT | HWMON_I_LABEL,
-	[hwmon_curr]	= HWMON_C_INPUT | HWMON_C_LABEL,
-	[hwmon_fan]	= HWMON_F_INPUT | HWMON_F_LABEL,
-};
-
-struct asus_wmi_ec_sensor_address {
-	u8 index;
-	u8 bank;
-	u8 size;
-};
-
-#define MAKE_SENSOR_ADDRESS(size_i, bank_i, index_i) {	\
-	.size = size_i,					\
-	.bank = bank_i,					\
-	.index = index_i,				\
-}
-
-struct ec_sensor_info {
-	struct asus_wmi_ec_sensor_address addr;
-	char label[SENSOR_LABEL_LEN];
-	enum hwmon_sensor_types type;
-};
-
-#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) {	\
-	.addr = MAKE_SENSOR_ADDRESS(size, bank, index),			\
-	.label = sensor_label,						\
-	.type = sensor_type,						\
-}
-
-enum known_ec_sensor {
-	SENSOR_TEMP_CHIPSET,
-	SENSOR_TEMP_CPU,
-	SENSOR_TEMP_MB,
-	SENSOR_TEMP_T_SENSOR,
-	SENSOR_TEMP_VRM,
-	SENSOR_FAN_CPU_OPT,
-	SENSOR_FAN_CHIPSET,
-	SENSOR_FAN_VRM_HS,
-	SENSOR_FAN_WATER_FLOW,
-	SENSOR_CURR_CPU,
-	SENSOR_TEMP_WATER_IN,
-	SENSOR_TEMP_WATER_OUT,
-	SENSOR_MAX
-};
-
-/* All known sensors for ASUS EC controllers */
-static const struct ec_sensor_info known_ec_sensors[] = {
-	[SENSOR_TEMP_CHIPSET]	= EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
-	[SENSOR_TEMP_CPU]	= EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
-	[SENSOR_TEMP_MB]	= EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
-	[SENSOR_TEMP_T_SENSOR]	= EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
-	[SENSOR_TEMP_VRM]	= EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
-	[SENSOR_FAN_CPU_OPT]	= EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
-	[SENSOR_FAN_VRM_HS]	= EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
-	[SENSOR_FAN_CHIPSET]	= EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
-	[SENSOR_FAN_WATER_FLOW]	= EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
-	[SENSOR_CURR_CPU]	= EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
-	[SENSOR_TEMP_WATER_IN]	= EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
-	[SENSOR_TEMP_WATER_OUT]	= EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
-};
-
-struct asus_wmi_data {
-	const enum known_ec_sensor known_board_sensors[SENSOR_MAX + 1];
-};
-
-/* boards with EC support */
-static struct asus_wmi_data sensors_board_PW_X570_P = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
-		SENSOR_FAN_CHIPSET,
-		SENSOR_MAX
-	},
-};
-
-static struct asus_wmi_data sensors_board_PW_X570_A = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
-		SENSOR_FAN_CHIPSET,
-		SENSOR_CURR_CPU,
-		SENSOR_MAX
-	},
-};
-
-static struct asus_wmi_data sensors_board_R_C8H = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
-		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
-		SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
-		SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET, SENSOR_FAN_WATER_FLOW,
-		SENSOR_CURR_CPU,
-		SENSOR_MAX
-	},
-};
-
-/* Same as Hero but without chipset fan */
-static struct asus_wmi_data sensors_board_R_C8DH = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
-		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
-		SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
-		SENSOR_FAN_CPU_OPT, SENSOR_FAN_WATER_FLOW,
-		SENSOR_CURR_CPU,
-		SENSOR_MAX
-	},
-};
-
-/* Same as Hero but without water */
-static struct asus_wmi_data sensors_board_R_C8F = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
-		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
-		SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
-		SENSOR_CURR_CPU,
-		SENSOR_MAX
-	},
-};
-
-static struct asus_wmi_data sensors_board_RS_B550_E_G = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
-		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
-		SENSOR_FAN_CPU_OPT,
-		SENSOR_MAX
-	},
-};
-
-static struct asus_wmi_data sensors_board_RS_B550_I_G = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
-		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
-		SENSOR_FAN_VRM_HS,
-		SENSOR_CURR_CPU,
-		SENSOR_MAX
-	},
-};
-
-static struct asus_wmi_data sensors_board_RS_X570_E_G = {
-	.known_board_sensors = {
-		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
-		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
-		SENSOR_FAN_CHIPSET,
-		SENSOR_CURR_CPU,
-		SENSOR_MAX
-	},
-};
-
-#define DMI_EXACT_MATCH_ASUS_BOARD_NAME(name, sensors) {			\
-	.matches = {								\
-		DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "ASUSTeK COMPUTER INC."),	\
-		DMI_EXACT_MATCH(DMI_BOARD_NAME, name),				\
-	},									\
-	.driver_data = sensors,							\
-}
-
-static const struct dmi_system_id asus_wmi_ec_dmi_table[] = {
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("PRIME X570-PRO", &sensors_board_PW_X570_P),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("Pro WS X570-ACE", &sensors_board_PW_X570_A),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII DARK HERO", &sensors_board_R_C8DH),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII FORMULA", &sensors_board_R_C8F),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII HERO", &sensors_board_R_C8H),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX B550-E GAMING", &sensors_board_RS_B550_E_G),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX B550-I GAMING", &sensors_board_RS_B550_I_G),
-	DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX X570-E GAMING", &sensors_board_RS_X570_E_G),
-	{}
-};
-MODULE_DEVICE_TABLE(dmi, asus_wmi_ec_dmi_table);
-
-struct ec_sensor {
-	enum known_ec_sensor info_index;
-	long cached_value;
-};
-
-/**
- * struct asus_wmi_ec_info - sensor info.
- * @sensors: list of sensors.
- * @read_arg: UTF-16LE string to pass to BRxx() WMI function.
- * @read_buffer: decoded output from WMI result.
- * @nr_sensors: number of board EC sensors.
- * @nr_registers: number of EC registers to read (sensor might span more than 1 register).
- * @last_updated: in jiffies.
- */
-struct asus_wmi_ec_info {
-	struct ec_sensor sensors[SENSOR_MAX];
-	char read_arg[(ASUSWMI_BREC_REGISTERS_MAX * 4 + 1) * 2];
-	u8 read_buffer[ASUSWMI_BREC_REGISTERS_MAX];
-	unsigned int nr_sensors;
-	unsigned int nr_registers;
-	unsigned long last_updated;
-};
-
-struct asus_wmi_sensors {
-	struct asus_wmi_ec_info ec;
-	/* lock access to internal cache */
-	struct mutex lock;
-};
-
-static int asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec,
-					  const enum known_ec_sensor *bsi)
-{
-	struct ec_sensor *s = ec->sensors;
-	int i;
-
-	ec->nr_sensors = 0;
-	ec->nr_registers = 0;
-
-	for (i = 0; bsi[i] != SENSOR_MAX; i++) {
-		s[i].info_index = bsi[i];
-		ec->nr_sensors++;
-		ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
-	}
-
-	return 0;
-}
-
-/*
- * The next four functions convert to or from BRxx string argument format.
- * The format of the string is as follows:
- * - The string consists of two-byte UTF-16LE characters.
- * - The value of the very first byte in the string is equal to the total
- *   length of the next string in bytes, thus excluding the first two-byte
- *   character.
- * - The rest of the string encodes the pairs of (bank, index) pairs, where
- *   both values are byte-long (0x00 to 0xFF).
- * - Numbers are encoded as UTF-16LE hex values.
- */
-static int asus_wmi_ec_decode_reply_buffer(const u8 *in, u32 length, u8 *out)
-{
-	char buffer[ASUSWMI_MAX_BUF_LEN * 2];
-	u32 len = min_t(u32, get_unaligned_le16(in), length - 2);
-
-	utf16s_to_utf8s((wchar_t *)(in + 2), len / 2, UTF16_LITTLE_ENDIAN, buffer, sizeof(buffer));
-
-	return hex2bin(out, buffer, len / 4);
-}
-
-static void asus_wmi_ec_encode_registers(const u8 *in, u32 len, char *out)
-{
-	char buffer[ASUSWMI_MAX_BUF_LEN * 2];
-
-	bin2hex(buffer, in, len);
-
-	utf8s_to_utf16s(buffer, len * 2, UTF16_LITTLE_ENDIAN, (wchar_t *)(out + 2), len * 2);
-
-	put_unaligned_le16(len * 4, out);
-}
-
-static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
-{
-	u8 registers[ASUSWMI_BREC_REGISTERS_MAX * 2];
-	const struct ec_sensor_info *si;
-	int i, j, offset;
-
-	offset = 0;
-	for (i = 0; i < ec->nr_sensors; i++) {
-		si = &known_ec_sensors[ec->sensors[i].info_index];
-		for (j = 0; j < si->addr.size; j++) {
-			registers[offset++] = si->addr.bank;
-			registers[offset++] = si->addr.index + j;
-		}
-	}
-
-	asus_wmi_ec_encode_registers(registers, offset, ec->read_arg);
-}
-
-static int asus_wmi_ec_block_read(u32 method_id, char *query, u8 *out)
-{
-	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
-	struct acpi_buffer input;
-	union acpi_object *obj;
-	acpi_status status;
-	int ret;
-
-	/* The first byte of the BRxx() argument string has to be the string size. */
-	input.length = query[0] + 2;
-	input.pointer = query;
-	status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, method_id, &input, &output);
-	if (ACPI_FAILURE(status))
-		return -EIO;
-
-	obj = output.pointer;
-	if (!obj)
-		return -EIO;
-
-	if (obj->type != ACPI_TYPE_BUFFER || obj->buffer.length < 2) {
-		ret = -EIO;
-		goto out_free_obj;
-	}
-
-	ret = asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, obj->buffer.length, out);
-
-out_free_obj:
-	ACPI_FREE(obj);
-	return ret;
-}
-
-static inline long get_sensor_value(const struct ec_sensor_info *si, u8 *data)
-{
-	switch (si->addr.size) {
-	case 1:
-		return *data;
-	case 2:
-		return get_unaligned_be16(data);
-	case 4:
-		return get_unaligned_be32(data);
-	default:
-		return 0;
-	}
-}
-
-static void asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
-{
-	const struct ec_sensor_info *si;
-	struct ec_sensor *s;
-	u8 i_sensor;
-	u8 *data;
-
-	data = ec->read_buffer;
-	for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
-		s = &ec->sensors[i_sensor];
-		si = &known_ec_sensors[s->info_index];
-		s->cached_value = get_sensor_value(si, data);
-		data += si->addr.size;
-	}
-}
-
-static long asus_wmi_ec_scale_sensor_value(long value, int data_type)
-{
-	switch (data_type) {
-	case hwmon_curr:
-	case hwmon_temp:
-	case hwmon_in:
-		return value * MILLI;
-	default:
-		return value;
-	}
-}
-
-static int asus_wmi_ec_find_sensor_index(const struct asus_wmi_ec_info *ec,
-					 enum hwmon_sensor_types type, int channel)
-{
-	int i;
-
-	for (i = 0; i < ec->nr_sensors; i++) {
-		if (known_ec_sensors[ec->sensors[i].info_index].type == type) {
-			if (channel == 0)
-				return i;
-
-			channel--;
-		}
-	}
-	return -EINVAL;
-}
-
-static int asus_wmi_ec_get_cached_value_or_update(struct asus_wmi_sensors *sensor_data,
-						  int sensor_index,
-						  long *value)
-{
-	struct asus_wmi_ec_info *ec = &sensor_data->ec;
-	int ret = 0;
-
-	mutex_lock(&sensor_data->lock);
-
-	if (time_after(jiffies, ec->last_updated + HZ)) {
-		ret = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
-					     ec->read_arg, ec->read_buffer);
-		if (ret)
-			goto unlock;
-
-		asus_wmi_ec_update_ec_sensors(ec);
-		ec->last_updated = jiffies;
-	}
-
-	*value = ec->sensors[sensor_index].cached_value;
-
-unlock:
-	mutex_unlock(&sensor_data->lock);
-
-	return ret;
-}
-
-/* Now follow the functions that implement the hwmon interface */
-
-static int asus_wmi_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
-				  u32 attr, int channel, long *val)
-{
-	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
-	struct asus_wmi_ec_info *ec = &sensor_data->ec;
-	int ret, sidx, info_index;
-	long value = 0;
-
-	sidx = asus_wmi_ec_find_sensor_index(ec, type, channel);
-	if (sidx < 0)
-		return sidx;
-
-	ret = asus_wmi_ec_get_cached_value_or_update(sensor_data, sidx, &value);
-	if (ret)
-		return ret;
-
-	info_index = ec->sensors[sidx].info_index;
-	*val = asus_wmi_ec_scale_sensor_value(value, known_ec_sensors[info_index].type);
-
-	return ret;
-}
-
-static int asus_wmi_ec_hwmon_read_string(struct device *dev,
-					 enum hwmon_sensor_types type, u32 attr,
-					 int channel, const char **str)
-{
-	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
-	struct asus_wmi_ec_info *ec = &sensor_data->ec;
-	int sensor_index;
-
-	sensor_index = asus_wmi_ec_find_sensor_index(ec, type, channel);
-	*str = known_ec_sensors[ec->sensors[sensor_index].info_index].label;
-
-	return 0;
-}
-
-static umode_t asus_wmi_ec_hwmon_is_visible(const void *drvdata,
-					    enum hwmon_sensor_types type, u32 attr,
-					    int channel)
-{
-	const struct asus_wmi_sensors *sensor_data = drvdata;
-	const struct asus_wmi_ec_info *ec = &sensor_data->ec;
-	int index;
-
-	index = asus_wmi_ec_find_sensor_index(ec, type, channel);
-
-	return index < 0 ? 0 : 0444;
-}
-
-static int asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info *asus_wmi_hwmon_chan,
-					struct device *dev, int num,
-					enum hwmon_sensor_types type, u32 config)
-{
-	u32 *cfg;
-
-	cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
-	if (!cfg)
-		return -ENOMEM;
-
-	asus_wmi_hwmon_chan->type = type;
-	asus_wmi_hwmon_chan->config = cfg;
-	memset32(cfg, config, num);
-
-	return 0;
-}
-
-static const struct hwmon_ops asus_wmi_ec_hwmon_ops = {
-	.is_visible = asus_wmi_ec_hwmon_is_visible,
-	.read = asus_wmi_ec_hwmon_read,
-	.read_string = asus_wmi_ec_hwmon_read_string,
-};
-
-static struct hwmon_chip_info asus_wmi_ec_chip_info = {
-	.ops = &asus_wmi_ec_hwmon_ops,
-};
-
-static int asus_wmi_ec_configure_sensor_setup(struct device *dev,
-					      const enum known_ec_sensor *bsi)
-{
-	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
-	struct asus_wmi_ec_info *ec = &sensor_data->ec;
-	struct hwmon_channel_info *asus_wmi_hwmon_chan;
-	const struct hwmon_channel_info **asus_wmi_ci;
-	int nr_count[hwmon_max] = {}, nr_types = 0;
-	const struct hwmon_chip_info *chip_info;
-	const struct ec_sensor_info *si;
-	enum hwmon_sensor_types type;
-	struct device *hwdev;
-	int i, ret;
-
-	ret = asus_wmi_ec_fill_board_sensors(ec, bsi);
-	if (ret)
-		return ret;
-
-	if (!sensor_data->ec.nr_sensors)
-		return -ENODEV;
-
-	for (i = 0; i < ec->nr_sensors; i++) {
-		si = &known_ec_sensors[ec->sensors[i].info_index];
-		if (!nr_count[si->type])
-			nr_types++;
-		nr_count[si->type]++;
-	}
-
-	if (nr_count[hwmon_temp]) {
-		nr_count[hwmon_chip]++;
-		nr_types++;
-	}
-
-	/*
-	 * If we can get values for all the registers in a single query,
-	 * the query will not change from call to call.
-	 */
-	asus_wmi_ec_make_block_read_query(ec);
-
-	asus_wmi_hwmon_chan = devm_kcalloc(dev, nr_types, sizeof(*asus_wmi_hwmon_chan),
-					   GFP_KERNEL);
-	if (!asus_wmi_hwmon_chan)
-		return -ENOMEM;
-
-	asus_wmi_ci = devm_kcalloc(dev, nr_types + 1, sizeof(*asus_wmi_ci), GFP_KERNEL);
-	if (!asus_wmi_ci)
-		return -ENOMEM;
-
-	asus_wmi_ec_chip_info.info = asus_wmi_ci;
-	chip_info = &asus_wmi_ec_chip_info;
-
-	for (type = 0; type < hwmon_max; type++) {
-		if (!nr_count[type])
-			continue;
-
-		ret = asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan, dev,
-						   nr_count[type], type,
-						   hwmon_attributes[type]);
-		if (ret)
-			return ret;
-
-		*asus_wmi_ci++ = asus_wmi_hwmon_chan++;
-	}
-
-	dev_dbg(dev, "board has %d EC sensors that span %d registers",
-		ec->nr_sensors, ec->nr_registers);
-
-	hwdev = devm_hwmon_device_register_with_info(dev, "asus_wmi_ec_sensors",
-						     sensor_data, chip_info, NULL);
-
-	return PTR_ERR_OR_ZERO(hwdev);
-}
-
-static int asus_wmi_probe(struct wmi_device *wdev, const void *context)
-{
-	struct asus_wmi_sensors *sensor_data;
-	struct asus_wmi_data *board_sensors;
-	const struct dmi_system_id *dmi_id;
-	const enum known_ec_sensor *bsi;
-	struct device *dev = &wdev->dev;
-
-	dmi_id = dmi_first_match(asus_wmi_ec_dmi_table);
-	if (!dmi_id)
-		return -ENODEV;
-
-	board_sensors = dmi_id->driver_data;
-	bsi = board_sensors->known_board_sensors;
-
-	sensor_data = devm_kzalloc(dev, sizeof(*sensor_data), GFP_KERNEL);
-	if (!sensor_data)
-		return -ENOMEM;
-
-	mutex_init(&sensor_data->lock);
-
-	dev_set_drvdata(dev, sensor_data);
-
-	return asus_wmi_ec_configure_sensor_setup(dev, bsi);
-}
-
-static const struct wmi_device_id asus_ec_wmi_id_table[] = {
-	{ ASUSWMI_MONITORING_GUID, NULL },
-	{ }
-};
-
-static struct wmi_driver asus_sensors_wmi_driver = {
-	.driver = {
-		.name = "asus_wmi_ec_sensors",
-	},
-	.id_table = asus_ec_wmi_id_table,
-	.probe = asus_wmi_probe,
-};
-module_wmi_driver(asus_sensors_wmi_driver);
-
-MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
-MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
-MODULE_DESCRIPTION("Asus WMI Sensors Driver");
-MODULE_LICENSE("GPL");
-- 
2.34.1

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Guenter Roeck]

On 1/11/22 8:08 AM, Eugene Shalygin wrote:
> This driver provides the same data as the asus_wmi_ec_sensors driver
> (and gets it from the same source) but does not use WMI, polling
> the ACPI EC directly.
> 
> That provides two enhancements: sensor reading became quicker (on some
> systems or kernel configuration it took almost a full second to read
> all the sensors, that transfers less than 15 bytes of data), the driver
> became more flexible. The driver now relies on ACPI mutex to lock access
> to the EC in the same way as the WMI code does.
> 
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>

Please version all patches, not just the intro. As it is, the version doesn't
show up in patchwork, which is confusing.

Guenter

Re: [PATCH 3/3] hwmon: (asus_wmi_ec_sensors) remove the driver

[Guenter Roeck]

On 1/11/22 8:08 AM, Eugene Shalygin wrote:
> The driver is superceeded by asus-ec-sensors
> 
superseded

I want to have this handled differently: In Kconfig, mark the
SENSORS_ASUS_WMI_EC driver as depending on !SENSORS_ASUS_EC,
and add a note to Kconfig stating that the driver is replaced
by SENSORS_ASUS_EC, which should be used instead. Then, in a couple
of releases, we can remove the obsolete driver. This will give
us some test coverage of the new driver but still provide an alternative.

Thanks,
Guenter

Re: PATCH v3 ASUS EC Sensors

[Guenter Roeck]

On 1/11/22 8:08 AM, Eugene Shalygin wrote:
> Changes in v3:
>      - Removed BIOS version checks and BIOS version dependent mutex path.
> 
> 
Subject should start with [PATCH v3 0/3], and there should be a proper introduction,
not just a brief change log for the last version.

Guenter

Re: PATCH v3 ASUS EC Sensors

[Eugene Shalygin]

> Subject should start with [PATCH v3 0/3], and there should be a proper introduction,
> not just a brief change log for the last version.

Thank you, I hope v4 is properly done.

Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Guenter Roeck]

On 1/11/22 8:08 AM, Eugene Shalygin wrote:
> This driver provides the same data as the asus_wmi_ec_sensors driver
> (and gets it from the same source) but does not use WMI, polling
> the ACPI EC directly.
> 
> That provides two enhancements: sensor reading became quicker (on some
> systems or kernel configuration it took almost a full second to read
> all the sensors, that transfers less than 15 bytes of data), the driver
> became more flexible. The driver now relies on ACPI mutex to lock access
> to the EC in the same way as the WMI code does.
> 
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> ---
>   MAINTAINERS                     |   6 +
>   drivers/hwmon/Kconfig           |  11 +
>   drivers/hwmon/Makefile          |   1 +
>   drivers/hwmon/asus-ec-sensors.c | 733 ++++++++++++++++++++++++++++++++
>   4 files changed, 751 insertions(+)
>   create mode 100644 drivers/hwmon/asus-ec-sensors.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index fddd28d3db15..845f09bc0457 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -3012,6 +3012,12 @@ L:	linux-hwmon@vger.kernel.org
>   S:	Maintained
>   F:	drivers/hwmon/asus_wmi_ec_sensors.c
>   
> +ASUS EC HARDWARE MONITOR DRIVER
> +M:	Eugene Shalygin <eugene.shalygin@gmail.com>
> +L:	linux-hwmon@vger.kernel.org
> +S:	Maintained
> +F:	drivers/hwmon/asus-ec-sensors.c
> +
>   ASUS WIRELESS RADIO CONTROL DRIVER
>   M:	João Paulo Rechi Vita <jprvita@gmail.com>
>   L:	platform-driver-x86@vger.kernel.org
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 43e5245874ad..2c16b19d2c03 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -2253,6 +2253,17 @@ config SENSORS_ASUS_WMI_EC
>   	  This driver can also be built as a module. If so, the module
>   	  will be called asus_wmi_sensors_ec.
>   
> +config SENSORS_ASUS_EC
> +	tristate "ASUS EC Sensors"
> +	help
> +	  If you say yes here you get support for the ACPI embedded controller
> +	  hardware monitoring interface found in ASUS motherboards. The driver
> +	  currently supports B550/X570 boards, although other ASUS boards might
> +	  provide this monitoring interface as well.
> +
> +	  This driver can also be built as a module. If so, the module
> +	  will be called asus_ec_sensors.
> +
>   endif # ACPI
>   
>   endif # HWMON
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 3a1551b3d570..2e5c216bb5d7 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID)		+= hwmon-vid.o
>   # APCI drivers
>   obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
>   obj-$(CONFIG_SENSORS_ATK0110)	+= asus_atk0110.o
> +obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
>   obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
>   obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
>   
> diff --git a/drivers/hwmon/asus-ec-sensors.c b/drivers/hwmon/asus-ec-sensors.c
> new file mode 100644
> index 000000000000..83921c3dee84
> --- /dev/null
> +++ b/drivers/hwmon/asus-ec-sensors.c
> @@ -0,0 +1,733 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * HWMON driver for ASUS motherboards that publish some sensor values
> + * via the embedded controller registers.
> + *
> + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> +
> + * EC provides:
> + * - Chipset temperature
> + * - CPU temperature
> + * - Motherboard temperature
> + * - T_Sensor temperature
> + * - VRM temperature
> + * - Water In temperature
> + * - Water Out temperature
> + * - CPU Optional fan RPM
> + * - Chipset fan RPM
> + * - VRM Heat Sink fan RPM
> + * - Water Flow fan RPM
> + * - CPU current
> + */
> +
> +#include <linux/acpi.h>
> +#include <linux/bitops.h>
> +#include <linux/dev_printk.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/init.h>
> +#include <linux/jiffies.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/sort.h>
> +#include <linux/units.h>
> +
> +#include <asm/unaligned.h>
> +
> +static char *mutex_path_override;
> +
> +/** Writing to this EC register switches EC bank */
> +#define ASUS_EC_BANK_REGISTER 0xff
> +#define SENSOR_LABEL_LEN 16
> +
> +/**
> + * Arbitrary set max. allowed bank number. Required for sorting banks and
> + * currently is overkill with just 2 banks used at max, but for the sake
> + * of alignment let's set it to a higher value.
> + */
> +#define ASUS_EC_MAX_BANK 3
> +
> +#define ACPI_LOCK_DELAY_MS 500
> +
> +/* ACPI mutex for locking access to the EC for the firmware */
> +#define ASUS_HW_ACCESS_MUTEX_ASMX "\\AMW0.ASMX"
> +
> +/* There are two variants of the vendor spelling */
> +#define VENDOR_ASUS_UPPER_CASE "ASUSTeK COMPUTER INC."
> +

Everywhere:

#define<space>DEFINE<tab>VALUE

please.

> +typedef union {
> +	u32 value;
> +	struct {
> +		u8 index;
> +		u8 bank;
> +		u8 size;
> +		u8 dummy;
> +	} components;
> +} sensor_address;
> +
> +#define MAKE_SENSOR_ADDRESS(size, bank, index) {                               \
> +		.value = (size << 16) + (bank << 8) + index                    \
> +	}
> +
> +static u32 hwmon_attributes[hwmon_max] = {
> +	[hwmon_chip] = HWMON_C_REGISTER_TZ,
> +	[hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
> +	[hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
> +	[hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
> +	[hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
> +};
> +
> +struct ec_sensor_info {
> +	char label[SENSOR_LABEL_LEN];
> +	enum hwmon_sensor_types type;
> +	sensor_address addr;
> +};
> +
> +#define EC_SENSOR(sensor_label, sensor_type, size, bank, index) {              \
> +		.label = sensor_label, .type = sensor_type,                    \
> +		.addr = MAKE_SENSOR_ADDRESS(size, bank, index),                \
> +	}
> +
> +enum ec_sensors {
> +	/** chipset temperature [℃] */

I do not see the point of marking this as doc strings

> +	ec_sensor_temp_chipset,
> +	/** CPU temperature [℃] */
> +	ec_sensor_temp_cpu,
> +	/** motherboard temperature [℃] */
> +	ec_sensor_temp_mb,
> +	/** "T_Sensor" temperature sensor reading [℃] */
> +	ec_sensor_temp_t_sensor,
> +	/** VRM temperature [℃] */
> +	ec_sensor_temp_vrm,
> +	/** CPU_Opt fan [RPM] */
> +	ec_sensor_fan_cpu_opt,
> +	/** VRM heat sink fan [RPM] */
> +	ec_sensor_fan_vrm_hs,
> +	/** Chipset fan [RPM] */
> +	ec_sensor_fan_chipset,
> +	/** Water flow sensor reading [RPM] */
> +	ec_sensor_fan_water_flow,
> +	/** CPU current [A] */
> +	ec_sensor_curr_cpu,
> +	/** "Water_In" temperature sensor reading [℃] */
> +	ec_sensor_temp_water_in,
> +	/** "Water_Out" temperature sensor reading [℃] */
> +	ec_sensor_temp_water_out,
> +};
> +
> +#define SENSOR_TEMP_CHIPSET BIT(ec_sensor_temp_chipset)
> +#define SENSOR_TEMP_CPU BIT(ec_sensor_temp_cpu)
> +#define SENSOR_TEMP_MB BIT(ec_sensor_temp_mb)
> +#define SENSOR_TEMP_T_SENSOR BIT(ec_sensor_temp_t_sensor)
> +#define SENSOR_TEMP_VRM BIT(ec_sensor_temp_vrm)
> +#define SENSOR_FAN_CPU_OPT BIT(ec_sensor_fan_cpu_opt)
> +#define SENSOR_FAN_VRM_HS BIT(ec_sensor_fan_vrm_hs)
> +#define SENSOR_FAN_CHIPSET BIT(ec_sensor_fan_chipset)
> +#define SENSOR_FAN_WATER_FLOW BIT(ec_sensor_fan_water_flow)
> +#define SENSOR_CURR_CPU BIT(ec_sensor_curr_cpu)
> +#define SENSOR_TEMP_WATER_IN BIT(ec_sensor_temp_water_in)
> +#define SENSOR_TEMP_WATER_OUT BIT(ec_sensor_temp_water_out)
> +
> +/**
> + * All the known sensors for ASUS EC controllers
> + */

and neither this one, nor anywhere else where "**" is used.
The resulting "documentation" is just confusing and provides no value.

> +static const struct ec_sensor_info known_ec_sensors[] = {
> +	[ec_sensor_temp_chipset] =
> +		EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
> +	[ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
> +	[ec_sensor_temp_mb] =
> +		EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
> +	[ec_sensor_temp_t_sensor] =
> +		EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
> +	[ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
> +	[ec_sensor_fan_cpu_opt] =
> +		EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
> +	[ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
> +	[ec_sensor_fan_chipset] =
> +		EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
> +	[ec_sensor_fan_water_flow] =
> +		EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
> +	[ec_sensor_curr_cpu] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
> +	[ec_sensor_temp_water_in] =
> +		EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
> +	[ec_sensor_temp_water_out] =
> +		EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
> +};
> +
> +struct asus_ec_board_info {
> +	unsigned long sensors;
> +};

Why not just "sensors" directly ? Is there ever going to be anything else ?
If not, the value could be added to the dmi array directly without pointer
indirection.

> +
> +/* Shortcuts for common combinations */
> +#define SENSOR_SET_TEMP_CHIPSET_CPU_MB                                         \
> +	(SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB)
> +#define SENSOR_SET_TEMP_WATER (SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT)
> +
> +static struct asus_ec_board_info board_P_X570_P = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
> +		   SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET,
> +};
> +
> +static struct asus_ec_board_info board_PW_X570_A = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
> +		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +};
> +
> +static struct asus_ec_board_info board_R_C8H = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
> +		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
> +		   SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
> +};
> +
> +/* Same as Hero but without chipset fan */
> +static struct asus_ec_board_info board_R_C8DH = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
> +		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
> +};
> +
> +/* Same as Hero but without water */
> +static struct asus_ec_board_info board_R_C8F = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
> +		   SENSOR_CURR_CPU,
> +};
> +
> +static struct asus_ec_board_info board_R_C8I = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +};
> +
> +static struct asus_ec_board_info board_RS_B550_E_G = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT,
> +};
> +
> +static struct asus_ec_board_info board_RS_B550_I_G = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_VRM_HS | SENSOR_CURR_CPU,
> +};
> +
> +static struct asus_ec_board_info board_RS_X570_E_G = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +};
> +
> +static struct asus_ec_board_info board_RS_X570_I_G = {
> +	.sensors = SENSOR_TEMP_T_SENSOR | SENSOR_FAN_VRM_HS |
> +		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +};
> +
> +#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {                         \
> +	.matches = {                                                           \
> +		DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),                     \
> +		DMI_EXACT_MATCH(DMI_BOARD_NAME, name),                         \
> +	},                                                                     \
> +	.driver_data = sensors, \
> +}
> +
> +static const struct dmi_system_id asus_ec_dmi_table[] __initconst = {
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "PRIME X570-PRO",
> +			      &board_P_X570_P),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "Pro WS X570-ACE",
> +			      &board_PW_X570_A),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
> +			      "ROG CROSSHAIR VIII DARK HERO", &board_R_C8DH),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
> +			      "ROG CROSSHAIR VIII FORMULA", &board_R_C8F),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG CROSSHAIR VIII HERO",
> +			      &board_R_C8H),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
> +			      "ROG CROSSHAIR VIII IMPACT", &board_R_C8I),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-E GAMING",
> +			      &board_RS_B550_E_G),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-I GAMING",
> +			      &board_RS_B550_I_G),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-E GAMING",
> +			      &board_RS_X570_E_G),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-I GAMING",
> +			      &board_RS_X570_I_G),
> +	{}
> +};
> +
> +struct ec_sensor {
> +	unsigned int info_index;
> +	u32 cached_value;
> +};
> +
> +struct ec_sensors_data {
> +	const struct asus_ec_board_info *board;
> +	struct ec_sensor *sensors;
> +	/** EC registers to read from */
> +	u16 *registers;
> +	u8 *read_buffer;
> +	/** sorted list of unique register banks */
> +	u8 banks[ASUS_EC_MAX_BANK + 1];
> +	/** in jiffies */
> +	unsigned long last_updated;
> +	acpi_handle aml_mutex;
> +	/** number of board EC sensors */
> +	u8 nr_sensors;
> +	/** number of EC registers to read (sensor might span more than 1 register) */
> +	u8 nr_registers;
> +	/** number of unique register banks */
> +	u8 nr_banks;
> +};
> +
> +static u8 register_bank(u16 reg)
> +{
> +	return reg >> 8;
> +}
> +
> +static u8 register_index(u16 reg)
> +{
> +	return reg & 0x00ff;
> +}
> +
> +static const struct ec_sensor_info *
> +get_sensor_info(const struct ec_sensors_data *state, int index)
> +{
> +	return &known_ec_sensors[state->sensors[index].info_index];
> +}
> +
> +static int find_ec_sensor_index(const struct ec_sensors_data *ec,
> +				enum hwmon_sensor_types type, int channel)
> +{
> +	unsigned int i;
> +
> +	for (i = 0; i < ec->nr_sensors; i++) {
> +		if (get_sensor_info(ec, i)->type == type) {
> +			if (channel == 0)
> +				return i;
> +			channel--;
> +		}
> +	}
> +	return -ENOENT;
> +}
> +
> +static int __init bank_compare(const void *a, const void *b)
> +{
> +	return *((const s8 *)a) - *((const s8 *)b);
> +}
> +
> +static int __init board_sensors_count(const struct asus_ec_board_info *board)
> +{
> +	return hweight_long(board->sensors);
> +}
> +
> +static void __init setup_sensor_data(struct ec_sensors_data *ec)
> +{
> +	struct ec_sensor *s = ec->sensors;
> +	bool bank_found;
> +	int i, j;
> +	u8 bank;
> +
> +	ec->nr_banks = 0;
> +	ec->nr_registers = 0;
> +
> +	for_each_set_bit(i, &ec->board->sensors,
> +			  BITS_PER_TYPE(ec->board->sensors)) {
> +		s->info_index = i;
> +		s->cached_value = 0;
> +		ec->nr_registers +=
> +			known_ec_sensors[s->info_index].addr.components.size;
> +		bank_found = false;
> +		bank = known_ec_sensors[s->info_index].addr.components.bank;
> +		for (j = 0; j < ec->nr_banks; j++) {
> +			if (ec->banks[j] == bank) {
> +				bank_found = true;
> +				break;
> +			}
> +		}
> +		if (!bank_found) {
> +			ec->banks[ec->nr_banks++] = bank;
> +		}
> +		s++;
> +	}
> +	sort(ec->banks, ec->nr_banks, 1, bank_compare, NULL);
> +}
> +
> +static void __init fill_ec_registers(struct ec_sensors_data *ec)
> +{
> +	const struct ec_sensor_info *si;
> +	unsigned int i, j, register_idx = 0;
> +
> +	for (i = 0; i < ec->nr_sensors; ++i) {
> +		si = get_sensor_info(ec, i);
> +		for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {
> +			ec->registers[register_idx] =
> +				(si->addr.components.bank << 8) +
> +				si->addr.components.index + j;
> +		}
> +	}
> +}
> +
> +static acpi_handle asus_hw_access_mutex(struct device *dev)
> +{
> +	const char *mutex_path;
> +	acpi_handle res;
> +	int status;
> +
> +	mutex_path = mutex_path_override ?
> +		mutex_path_override : ASUS_HW_ACCESS_MUTEX_ASMX;
> +
> +	status = acpi_get_handle(NULL, (acpi_string)mutex_path, &res);
> +	if (ACPI_FAILURE(status)) {
> +		dev_err(dev,
> +			"Could not get hardware access guard mutex '%s': error %d",
> +			mutex_path, status);
> +		return NULL;
> +	}
> +	return res;
> +}
> +
> +static int asus_ec_bank_switch(u8 bank, u8 *old)
> +{
> +	int status = 0;
> +
> +	if (old) {
> +		status = ec_read(ASUS_EC_BANK_REGISTER, old);
> +	}
> +	if (status || (old && (*old == bank)))
> +		return status;
> +	return ec_write(ASUS_EC_BANK_REGISTER, bank);
> +}
> +
> +static int asus_ec_block_read(const struct device *dev,
> +			      struct ec_sensors_data *ec)
> +{
> +	int ireg, ibank, status;
> +	u8 bank, reg_bank, prev_bank;
> +
> +	bank = 0;
> +	status = asus_ec_bank_switch(bank, &prev_bank);
> +	if (status) {
> +		dev_warn(dev, "EC bank switch failed");
> +		return status;
> +	}
> +
> +	if (prev_bank) {
> +		/* oops... somebody else is working with the EC too */
> +		dev_warn(dev,
> +			"Concurrent access to the ACPI EC detected.\nRace condition possible.");
> +	}
> +
> +	/*
> +	 * read registers minimizing bank switches.
> +	 */
> +	for (ibank = 0; ibank < ec->nr_banks; ibank++) {
> +		if (bank != ec->banks[ibank]) {
> +			bank = ec->banks[ibank];
> +			if (asus_ec_bank_switch(bank, NULL)) {
> +				dev_warn(dev, "EC bank switch to %d failed",
> +					 bank);
> +				break;
> +			}
> +		}
> +		for (ireg = 0; ireg < ec->nr_registers; ireg++) {
> +			reg_bank = register_bank(ec->registers[ireg]);
> +			if (reg_bank < bank) {
> +				continue;
> +			}
> +			ec_read(register_index(ec->registers[ireg]),
> +				ec->read_buffer + ireg);
> +		}
> +	}
> +
> +	status = asus_ec_bank_switch(prev_bank, NULL);
> +	return status;
> +}
> +
> +static inline u32 get_sensor_value(const struct ec_sensor_info *si, u8 *data)
> +{
> +	switch (si->addr.components.size) {
> +	case 1:
> +		return *data;
> +	case 2:
> +		return get_unaligned_be16(data);
> +	case 4:
> +		return get_unaligned_be32(data);
> +	default:
> +		return 0;
> +	}
> +}
> +
> +static void update_sensor_values(struct ec_sensors_data *ec, u8 *data)
> +{
> +	const struct ec_sensor_info *si;
> +	struct ec_sensor *s;
> +
> +	for (s = ec->sensors; s != ec->sensors + ec->nr_sensors; s++) {
> +		si = &known_ec_sensors[s->info_index];
> +		s->cached_value = get_sensor_value(si, data);
> +		data += si->addr.components.size;
> +	}
> +}
> +
> +static int update_ec_sensors(const struct device *dev,
> +			     struct ec_sensors_data *ec)
> +{
> +	int status;
> +
> +	/*
> +	 * ASUS DSDT does not specify that access to the EC has to be guarded,
> +	 * but firmware does access it via ACPI
> +	 */
> +	if (ACPI_FAILURE(acpi_acquire_mutex(ec->aml_mutex, NULL,
> +					    ACPI_LOCK_DELAY_MS))) {
> +		dev_err(dev, "Failed to acquire AML mutex");
> +		status = -EBUSY;
> +		goto cleanup;
> +	}
> +
> +	status = asus_ec_block_read(dev, ec);
> +
> +	if (!status) {
> +		update_sensor_values(ec, ec->read_buffer);
> +	}
> +	if (ACPI_FAILURE(acpi_release_mutex(ec->aml_mutex, NULL))) {
> +		dev_err(dev, "Failed to release AML mutex");
> +	}
> +cleanup:
> +	return status;
> +}
> +
> +static int scale_sensor_value(u32 value, int data_type)
> +{
> +	switch (data_type) {
> +	case hwmon_curr:
> +	case hwmon_temp:
> +	case hwmon_in:
> +		return value * MILLI;
> +	default:
> +		return value;
> +	}
> +}
> +
> +static int get_cached_value_or_update(const struct device *dev,
> +				      int sensor_index,
> +				      struct ec_sensors_data *state, u32 *value)
> +{
> +	if (time_after(jiffies, state->last_updated + HZ)) {
> +		if (update_ec_sensors(dev, state)) {
> +			dev_err(dev, "update_ec_sensors() failure\n");
> +			return -EIO;
> +		}
> +
> +		state->last_updated = jiffies;
> +	}
> +
> +	*value = state->sensors[sensor_index].cached_value;
> +	return 0;
> +}
> +
> +/*
> + * Now follow the functions that implement the hwmon interface
> + */
> +
> +static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
> +			      u32 attr, int channel, long *val)
> +{
> +	int ret;
> +	u32 value = 0;
> +
> +	struct ec_sensors_data *state = dev_get_drvdata(dev);
> +	int sidx = find_ec_sensor_index(state, type, channel);
> +
> +	if (sidx < 0) {
> +		return sidx;
> +	}
> +
> +	ret = get_cached_value_or_update(dev, sidx, state, &value);
> +	if (!ret) {
> +		*val = scale_sensor_value(value,
> +					  get_sensor_info(state, sidx)->type);
> +	}
> +
> +	return ret;
> +}
> +
> +static int asus_ec_hwmon_read_string(struct device *dev,
> +				     enum hwmon_sensor_types type, u32 attr,
> +				     int channel, const char **str)
> +{
> +	struct ec_sensors_data *state = dev_get_drvdata(dev);
> +	int sensor_index = find_ec_sensor_index(state, type, channel);
> +	*str = get_sensor_info(state, sensor_index)->label;
> +
> +	return 0;
> +}
> +
> +static umode_t asus_ec_hwmon_is_visible(const void *drvdata,
> +					enum hwmon_sensor_types type, u32 attr,
> +					int channel)
> +{
> +	const struct ec_sensors_data *state = drvdata;
> +
> +	return find_ec_sensor_index(state, type, channel) >= 0 ? S_IRUGO : 0;
> +}
> +
> +static int
> +asus_ec_hwmon_add_chan_info(struct hwmon_channel_info *asus_ec_hwmon_chan,
> +			     struct device *dev, int num,
> +			     enum hwmon_sensor_types type, u32 config)
> +{
> +	int i;
> +	u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
> +
> +	if (!cfg)
> +		return -ENOMEM;
> +
> +	asus_ec_hwmon_chan->type = type;
> +	asus_ec_hwmon_chan->config = cfg;
> +	for (i = 0; i < num; i++, cfg++)
> +		*cfg = config;
> +
> +	return 0;
> +}
> +
> +static const struct hwmon_ops asus_ec_hwmon_ops = {
> +	.is_visible = asus_ec_hwmon_is_visible,
> +	.read = asus_ec_hwmon_read,
> +	.read_string = asus_ec_hwmon_read_string,
> +};
> +
> +static struct hwmon_chip_info asus_ec_chip_info = {
> +	.ops = &asus_ec_hwmon_ops,
> +};
> +
> +static const struct asus_ec_board_info *__init
> +get_board_info(const struct device *dev)
> +{
> +	const struct dmi_system_id *dmi_entry;
> +
> +	dmi_entry = dmi_first_match(asus_ec_dmi_table);
> +	if (!dmi_entry) {
> +		dev_info(dev, "Unsupported board");
> +		return NULL;
> +	}
> +
> +	return dmi_entry->driver_data;
> +}
> +
> +static int __init configure_sensor_setup(struct device *dev)
> +{
> +	struct ec_sensors_data *ec_data = dev_get_drvdata(dev);
> +	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> +	struct device *hwdev;
> +	struct hwmon_channel_info *asus_ec_hwmon_chan;
> +	const struct hwmon_channel_info **ptr_asus_ec_ci;
> +	const struct hwmon_chip_info *chip_info;
> +	const struct ec_sensor_info *si;
> +	enum hwmon_sensor_types type;
> +	unsigned int i;
> +
> +	ec_data->board = get_board_info(dev);
> +	if (!ec_data->board) {
> +		return -ENODEV;
> +	}
> +
> +	ec_data->nr_sensors = board_sensors_count(ec_data->board);
> +	ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors,
> +					sizeof(struct ec_sensor), GFP_KERNEL);
> +
> +	setup_sensor_data(ec_data);
> +	ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers,
> +					  sizeof(u16), GFP_KERNEL);
> +	ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers,
> +					    sizeof(u8), GFP_KERNEL);
> +
> +	if (!ec_data->registers || !ec_data->read_buffer) {
> +		return -ENOMEM;
> +	}
> +
> +	fill_ec_registers(ec_data);
> +
> +	ec_data->aml_mutex = asus_hw_access_mutex(dev);
> +
> +	for (i = 0; i < ec_data->nr_sensors; ++i) {
> +		si = get_sensor_info(ec_data, i);
> +		if (!nr_count[si->type])
> +			++nr_types;
> +		++nr_count[si->type];
> +	}
> +
> +	if (nr_count[hwmon_temp])
> +		nr_count[hwmon_chip]++, nr_types++;
> +
> +	asus_ec_hwmon_chan = devm_kcalloc(
> +		dev, nr_types, sizeof(*asus_ec_hwmon_chan), GFP_KERNEL);
> +	if (!asus_ec_hwmon_chan)
> +		return -ENOMEM;
> +
> +	ptr_asus_ec_ci = devm_kcalloc(dev, nr_types + 1,
> +				       sizeof(*ptr_asus_ec_ci), GFP_KERNEL);
> +	if (!ptr_asus_ec_ci)
> +		return -ENOMEM;
> +
> +	asus_ec_chip_info.info = ptr_asus_ec_ci;
> +	chip_info = &asus_ec_chip_info;
> +
> +	for (type = 0; type < hwmon_max; ++type) {
> +		if (!nr_count[type])
> +			continue;
> +
> +		asus_ec_hwmon_add_chan_info(asus_ec_hwmon_chan, dev,
> +					     nr_count[type], type,
> +					     hwmon_attributes[type]);
> +		*ptr_asus_ec_ci++ = asus_ec_hwmon_chan++;
> +	}
> +
> +	dev_info(dev, "board has %d EC sensors that span %d registers",
> +		 ec_data->nr_sensors, ec_data->nr_registers);
> +
> +	hwdev = devm_hwmon_device_register_with_info(dev, "asus-ec-sensors",
> +						     ec_data, chip_info, NULL);
> +
> +	return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int __init asus_ec_probe(struct platform_device *pdev)
> +{
> +	struct asus_ec_sensors *state;
> +	int status = 0;
> +
> +	state = devm_kzalloc(&pdev->dev, sizeof(struct ec_sensors_data),
> +			     GFP_KERNEL);
> +
> +	if (!state) {
> +		return -ENOMEM;
> +	}
> +
> +	dev_set_drvdata(&pdev->dev, state);
> +	status = configure_sensor_setup(&pdev->dev);
> +	return status;
> +}
> +
> +static const struct acpi_device_id acpi_ec_ids[] = {
> +	/* Embedded Controller Device */
> +	{ "PNP0C09", 0 },
> +	{}
> +};
> +
> +static struct platform_driver asus_ec_sensors_platform_driver = {
> +	.driver = {
> +		.name	= "asus-ec-sensors",
> +		.acpi_match_table = acpi_ec_ids,
> +	},
> +};
> +
> +MODULE_DEVICE_TABLE(dmi, asus_ec_dmi_table);
> +module_platform_driver_probe(asus_ec_sensors_platform_driver, asus_ec_probe);
> +
> +module_param_named(mutex_path, mutex_path_override, charp, 0);
> +MODULE_PARM_DESC(mutex_path,
> +		 "Override ACPI mutex path used to guard access to hardware");
> +
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION(
> +	"HWMON driver for sensors accessible via ACPI EC in ASUS motherboards");
> +MODULE_LICENSE("GPL");
> +MODULE_VERSION("1");
> 

FWIW, MODULE_VERSION tends to have zero value since it tends to end up
not being updated.

Guenter

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

> I do not see the point of marking this as doc strings
…
> and neither this one, nor anywhere else where "**" is used.
> The resulting "documentation" is just confusing and provides no value.

My editor shows nice tooltips for /** comments and I did not realise
kernel doc processes
all the source unconditionally. Anyway, I removed them.

> Why not just "sensors" directly ? Is there ever going to be anything else ?
> If not, the value could be added to the dmi array directly without pointer
> indirection.

I once had an ASUS board where they changed board headers in some
hardware revision. I suspect the EC sensors
interface is valid for their other boards too, we just need users to
collect those data. It's quite possible that the DMI
board version would change in that case, so that we can add another
DMI match if required.
So, I'll take your advice and move the sensors to the driver_data field.

> FWIW, MODULE_VERSION tends to have zero value since it tends to end up
> not being updated.

Setting the value to 0 then :)

Best regards,
Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Guenter Roeck]

On 1/11/22 9:22 AM, Eugene Shalygin wrote:
>> I do not see the point of marking this as doc strings
> …
>> and neither this one, nor anywhere else where "**" is used.
>> The resulting "documentation" is just confusing and provides no value.
> 
> My editor shows nice tooltips for /** comments and I did not realise
> kernel doc processes
> all the source unconditionally. Anyway, I removed them.
> 
>> Why not just "sensors" directly ? Is there ever going to be anything else ?
>> If not, the value could be added to the dmi array directly without pointer
>> indirection.
> 
> I once had an ASUS board where they changed board headers in some
> hardware revision. I suspect the EC sensors
> interface is valid for their other boards too, we just need users to
> collect those data. It's quite possible that the DMI
> board version would change in that case, so that we can add another
> DMI match if required.
> So, I'll take your advice and move the sensors to the driver_data field.
> 
>> FWIW, MODULE_VERSION tends to have zero value since it tends to end up
>> not being updated.
> 
> Setting the value to 0 then :)
> 

Just drop it.

Guenter

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

> Just drop it.

OK.
Are there any other edits (want to generate as few new emails as possible)?

Regards,
Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Guenter Roeck]

On 1/11/22 10:52 AM, Eugene Shalygin wrote:
>> Just drop it.
> 
> OK.
> Are there any other edits (want to generate as few new emails as possible)?
> 

No need to resend because of this; I can drop it myself. No,
I don't have any further comments at this point, but I would
like to see (test/review) feedback by others before applying
the series.

Guenter

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

> No need to resend because of this; I can drop it myself. No,
> I don't have any further comments at this point, but I would
> like to see (test/review) feedback by others before applying
> the series.

Great! Thank you!

Regards,
Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Denis Pauk]

Hi Eugene,

I see. Thank you.

On Thu, 16 Dec 2021 23:58:40 +0100
Eugene Shalygin <eugene.shalygin@gmail.com> wrote:

> Hi Denis,
> 
> On Thu, 16 Dec 2021 at 23:04, Denis Pauk <pauk.denis@gmail.com> wrote:
> >
> > Hi Eugene,
> >
> > Have you found some issues with idea of usage ACPI WMI methods as
> > failback solution, like in case when ASUS will release some BIOS
> > with different mutex path or different motherboard where will be
> > same WMI methods but fully different internal logic?  
> 
> Not direct ones, but yes. First of all, I still don't understand what
> causes the big slowdown in ec_read() calls. I learned that Fedora and
> Arch kernel configs result in the slowdown, while my custom minimal
> kernel does not (well, it is still slow but nevertheless). I tried to
> unload all the modules I do not have in my custom kernel, I tried to
> disable every option which is related to ACPI in the Fedora config,
> but the slowdown did not disappear. Then it is not that simple to
> gather information from other users, because one needs the ec_sys
> module to measure ec_read() performance, but it is not available in
> many distribution kernels it seems.
> 
> Instead of that I've changed data structures for board description to
> include the mutex path there, so that we can handle various paths or
> version dependent paths for each motherboard. I can add code to select
> the mutex path based on the BIOS version for the next iteration. Also
> considering adding a module parameter to override that path. I think
> that will be maintainable and give users a way for a local fix while
> waiting for kernel update. Would you agree?
> 
> That way, I believe, the WMI fallback is rendered barely useful and I
> decided to drop it.
> 
> Best regards,
> Eugene



Best regards,
             Denis.

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Guenter Roeck]

On 12/17/21 2:33 PM, Eugene Shalygin wrote:
> Günter,
> 
> On Fri, 17 Dec 2021 at 22:52, Guenter Roeck <linux@roeck-us.net> wrote:
>> There is a lot of complexity around mutex_path in this driver, yet there is
>> always exactly one entry for each board, and the name of the mutex is always
>> the same for all boards. This doesn't make sense. Either the code is needed
>> or it isn't. We don't usually add complex code like this into the kernel
>> "just because it may be needed at some point in the future". Either give me
>> a use case, or drop it all.
> 
> When we discussed this approach which utilises an ACPI mutex, Andy and
> Denis were sceptical about its maintainability. One of the objections
> was that the mutex name is internal to the DSDT code and can be
> changed by ASUS. I know when older AM4 boards received BIOS updates
> for Ryzen 5000, their BIOS changed completely and I overheard that the
> DSDT code changed too. Unfortunately, I have no samples at hand. So I
> went ahead and added version support. I can, of course, revert that
> and apply it if somebody encounters such a BIOS update. To some extent
> I wanted to demonstrate how overcoming the problem with possible
> changes of the mutex path can look.
> 

That is not how kernel development works. It does not make sense to
introduce code that isn't used. The code is by its nature untested,
and it is completely unknown if it is even going to work if it is ever
needed. We simply can not predict how a future BIOS version / DSDT
looks like.

I don't have an answer for the maintainability problem, but introducing
speculative code is most definitely not the answer.

Guenter

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

Günter,

On Fri, 17 Dec 2021 at 22:52, Guenter Roeck <linux@roeck-us.net> wrote:
> There is a lot of complexity around mutex_path in this driver, yet there is
> always exactly one entry for each board, and the name of the mutex is always
> the same for all boards. This doesn't make sense. Either the code is needed
> or it isn't. We don't usually add complex code like this into the kernel
> "just because it may be needed at some point in the future". Either give me
> a use case, or drop it all.

When we discussed this approach which utilises an ACPI mutex, Andy and
Denis were sceptical about its maintainability. One of the objections
was that the mutex name is internal to the DSDT code and can be
changed by ASUS. I know when older AM4 boards received BIOS updates
for Ryzen 5000, their BIOS changed completely and I overheard that the
DSDT code changed too. Unfortunately, I have no samples at hand. So I
went ahead and added version support. I can, of course, revert that
and apply it if somebody encounters such a BIOS update. To some extent
I wanted to demonstrate how overcoming the problem with possible
changes of the mutex path can look.

Best regards,
Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Guenter Roeck]

On Fri, Dec 17, 2021 at 05:43:04PM +0100, Eugene Shalygin wrote:
> This driver provides the same data as the asus_wmi_ec_sensors driver
> (and gets it from the same source) but does not use WMI, polling
> the ACPI EC directly.
> 
> That provides two enhancements: sensor reading became quicker (on some
> systems or kernel configuration it took almost a full second to read
> all the sensors, that transfers less than 15 bytes of data), the driver
> became more flexible. The driver now relies on ACPI mutex to lock access
> to the EC in the same way as the WMI code does.
> 
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> ---
>  MAINTAINERS                     |   6 +
>  drivers/hwmon/Kconfig           |  11 +
>  drivers/hwmon/Makefile          |   1 +
>  drivers/hwmon/asus-ec-sensors.c | 790 ++++++++++++++++++++++++++++++++
>  4 files changed, 808 insertions(+)
>  create mode 100644 drivers/hwmon/asus-ec-sensors.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index fddd28d3db15..845f09bc0457 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -3012,6 +3012,12 @@ L:	linux-hwmon@vger.kernel.org
>  S:	Maintained
>  F:	drivers/hwmon/asus_wmi_ec_sensors.c
>  
> +ASUS EC HARDWARE MONITOR DRIVER
> +M:	Eugene Shalygin <eugene.shalygin@gmail.com>
> +L:	linux-hwmon@vger.kernel.org
> +S:	Maintained
> +F:	drivers/hwmon/asus-ec-sensors.c
> +
>  ASUS WIRELESS RADIO CONTROL DRIVER
>  M:	João Paulo Rechi Vita <jprvita@gmail.com>
>  L:	platform-driver-x86@vger.kernel.org
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index 43e5245874ad..2c16b19d2c03 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -2253,6 +2253,17 @@ config SENSORS_ASUS_WMI_EC
>  	  This driver can also be built as a module. If so, the module
>  	  will be called asus_wmi_sensors_ec.
>  
> +config SENSORS_ASUS_EC
> +	tristate "ASUS EC Sensors"
> +	help
> +	  If you say yes here you get support for the ACPI embedded controller
> +	  hardware monitoring interface found in ASUS motherboards. The driver
> +	  currently supports B550/X570 boards, although other ASUS boards might
> +	  provide this monitoring interface as well.
> +
> +	  This driver can also be built as a module. If so, the module
> +	  will be called asus_ec_sensors.
> +
>  endif # ACPI
>  
>  endif # HWMON
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 3a1551b3d570..2e5c216bb5d7 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID)		+= hwmon-vid.o
>  # APCI drivers
>  obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
>  obj-$(CONFIG_SENSORS_ATK0110)	+= asus_atk0110.o
> +obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
>  obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
>  obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
>  
> diff --git a/drivers/hwmon/asus-ec-sensors.c b/drivers/hwmon/asus-ec-sensors.c
> new file mode 100644
> index 000000000000..d7e44be00aae
> --- /dev/null
> +++ b/drivers/hwmon/asus-ec-sensors.c
> @@ -0,0 +1,790 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * HWMON driver for ASUS motherboards that publish some sensor values
> + * via the embedded controller registers.
> + *
> + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> +
> + * EC provides:
> + * - Chipset temperature
> + * - CPU temperature
> + * - Motherboard temperature
> + * - T_Sensor temperature
> + * - VRM temperature
> + * - Water In temperature
> + * - Water Out temperature
> + * - CPU Optional fan RPM
> + * - Chipset fan RPM
> + * - VRM Heat Sink fan RPM
> + * - Water Flow fan RPM
> + * - CPU current
> + */
> +
> +#include <linux/acpi.h>
> +#include <linux/bitops.h>
> +#include <linux/dev_printk.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/init.h>
> +#include <linux/jiffies.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/platform_device.h>
> +#include <linux/sort.h>
> +#include <linux/units.h>
> +
> +#include <asm/unaligned.h>
> +
> +static char *mutex_path_override;
> +
> +/** Writing to this EC register switches EC bank */
> +#define ASUS_EC_BANK_REGISTER 0xff
> +#define SENSOR_LABEL_LEN 16
> +
> +/**
> + * Arbitrary set max. allowed bank number. Required for sorting banks and
> + * currently is overkill with just 2 banks used at max, but for the sake
> + * of alignment let's set it to a higher value.
> + */
> +#define ASUS_EC_MAX_BANK 3
> +
> +#define ACPI_LOCK_DELAY_MS 500
> +
> +/* ACPI mutex for locking access to the EC for the firmware */
> +#define ASUS_HW_ACCESS_MUTEX_ASMX "\\AMW0.ASMX"
> +
> +/* There are two variants of the vendor spelling */
> +#define VENDOR_ASUS_UPPER_CASE "ASUSTeK COMPUTER INC."
> +
> +typedef union {
> +	u32 value;
> +	struct {
> +		u8 index;
> +		u8 bank;
> +		u8 size;
> +		u8 dummy;
> +	} components;
> +} sensor_address;
> +
> +#define MAKE_SENSOR_ADDRESS(size, bank, index) {                               \
> +		.value = (size << 16) + (bank << 8) + index                    \
> +	}
> +
> +static u32 hwmon_attributes[hwmon_max] = {
> +	[hwmon_chip] = HWMON_C_REGISTER_TZ,
> +	[hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
> +	[hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
> +	[hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
> +	[hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
> +};
> +
> +struct ec_sensor_info {
> +	char label[SENSOR_LABEL_LEN];
> +	enum hwmon_sensor_types type;
> +	sensor_address addr;
> +};
> +
> +#define EC_SENSOR(sensor_label, sensor_type, size, bank, index)	{              \
> +		.label = sensor_label, .type = sensor_type,                    \
> +		.addr = MAKE_SENSOR_ADDRESS(size, bank, index),                \
> +	}
> +
> +enum ec_sensors {
> +	/** chipset temperature [℃] */
> +	ec_sensor_temp_chipset,
> +	/** CPU temperature [℃] */
> +	ec_sensor_temp_cpu,
> +	/** motherboard temperature [℃] */
> +	ec_sensor_temp_mb,
> +	/** "T_Sensor" temperature sensor reading [℃] */
> +	ec_sensor_temp_t_sensor,
> +	/** VRM temperature [℃] */
> +	ec_sensor_temp_vrm,
> +	/** CPU_Opt fan [RPM] */
> +	ec_sensor_fan_cpu_opt,
> +	/** VRM heat sink fan [RPM] */
> +	ec_sensor_fan_vrm_hs,
> +	/** Chipset fan [RPM] */
> +	ec_sensor_fan_chipset,
> +	/** Water flow sensor reading [RPM] */
> +	ec_sensor_fan_water_flow,
> +	/** CPU current [A] */
> +	ec_sensor_curr_cpu,
> +	/** "Water_In" temperature sensor reading [℃] */
> +	ec_sensor_temp_water_in,
> +	/** "Water_Out" temperature sensor reading [℃] */
> +	ec_sensor_temp_water_out,
> +};
> +
> +#define SENSOR_TEMP_CHIPSET BIT(ec_sensor_temp_chipset)
> +#define SENSOR_TEMP_CPU BIT(ec_sensor_temp_cpu)
> +#define SENSOR_TEMP_MB BIT(ec_sensor_temp_mb)
> +#define SENSOR_TEMP_T_SENSOR BIT(ec_sensor_temp_t_sensor)
> +#define SENSOR_TEMP_VRM BIT(ec_sensor_temp_vrm)
> +#define SENSOR_FAN_CPU_OPT BIT(ec_sensor_fan_cpu_opt)
> +#define SENSOR_FAN_VRM_HS BIT(ec_sensor_fan_vrm_hs)
> +#define SENSOR_FAN_CHIPSET BIT(ec_sensor_fan_chipset)
> +#define SENSOR_FAN_WATER_FLOW BIT(ec_sensor_fan_water_flow)
> +#define SENSOR_CURR_CPU BIT(ec_sensor_curr_cpu)
> +#define SENSOR_TEMP_WATER_IN BIT(ec_sensor_temp_water_in)
> +#define SENSOR_TEMP_WATER_OUT BIT(ec_sensor_temp_water_out)
> +
> +/**
> + * All the known sensors for ASUS EC controllers
> + */
> +static const struct ec_sensor_info known_ec_sensors[] = {
> +	[ec_sensor_temp_chipset] =
> +		EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
> +	[ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
> +	[ec_sensor_temp_mb] =
> +		EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
> +	[ec_sensor_temp_t_sensor] =
> +		EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
> +	[ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
> +	[ec_sensor_fan_cpu_opt] =
> +		EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
> +	[ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
> +	[ec_sensor_fan_chipset] =
> +		EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
> +	[ec_sensor_fan_water_flow] =
> +		EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
> +	[ec_sensor_curr_cpu] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
> +	[ec_sensor_temp_water_in] =
> +		EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
> +	[ec_sensor_temp_water_out] =
> +		EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
> +};
> +
> +struct asus_ec_board_versioned_mutex_path {
> +	/** Minimal applicable BIOS version */
> +	int version;
> +	const char *value;
> +};
> +
> +struct asus_ec_board_info {
> +	unsigned long sensors;
> +	struct asus_ec_board_versioned_mutex_path mutex_path[];
> +};
> +
> +/* Shortcuts for common combinations */
> +#define SENSOR_SET_TEMP_CHIPSET_CPU_MB                                         \
> +	(SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB)
> +#define SENSOR_SET_TEMP_WATER (SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT)
> +
> +static struct asus_ec_board_info board_P_X570_P = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
> +		   SENSOR_FAN_CHIPSET,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_PW_X570_A = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
> +		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_R_C8H = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
> +		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
> +		   SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +/* Same as Hero but without chipset fan */
> +static struct asus_ec_board_info board_R_C8DH = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
> +		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +/* Same as Hero but without water */
> +static struct asus_ec_board_info board_R_C8F = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
> +		   SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_R_C8I = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_RS_B550_E_G = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_RS_B550_I_G = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_VRM_HS | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_RS_X570_E_G = {
> +	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
> +		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +static struct asus_ec_board_info board_RS_X570_I_G = {
> +	.sensors = SENSOR_TEMP_T_SENSOR | SENSOR_FAN_VRM_HS |
> +		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
> +	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
> +};
> +
> +#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {                         \
> +	.matches = {                                                           \
> +		DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),                     \
> +		DMI_EXACT_MATCH(DMI_BOARD_NAME, name),                         \
> +	},                                                                     \
> +	.driver_data = sensors, \
> +}
> +
> +static const struct dmi_system_id asus_ec_dmi_table[] __initconst = {
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "PRIME X570-PRO",
> +			      &board_P_X570_P),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "Pro WS X570-ACE",
> +			      &board_PW_X570_A),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
> +			      "ROG CROSSHAIR VIII DARK HERO", &board_R_C8DH),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
> +			      "ROG CROSSHAIR VIII FORMULA", &board_R_C8F),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG CROSSHAIR VIII HERO",
> +			      &board_R_C8H),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
> +			      "ROG CROSSHAIR VIII IMPACT", &board_R_C8I),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-E GAMING",
> +			      &board_RS_B550_E_G),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-I GAMING",
> +			      &board_RS_B550_I_G),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-E GAMING",
> +			      &board_RS_X570_E_G),
> +	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-I GAMING",
> +			      &board_RS_X570_I_G),
> +	{}
> +};
> +
> +struct ec_sensor {
> +	unsigned int info_index;
> +	u32 cached_value;
> +};
> +
> +struct ec_sensors_data {
> +	const struct asus_ec_board_info *board;
> +	struct ec_sensor *sensors;
> +	/** EC registers to read from */
> +	u16 *registers;
> +	u8 *read_buffer;
> +	/** sorted list of unique register banks */
> +	u8 banks[ASUS_EC_MAX_BANK + 1];
> +	/** in jiffies */
> +	unsigned long last_updated;
> +	acpi_handle aml_mutex;
> +	/** number of board EC sensors */
> +	u8 nr_sensors;
> +	/** number of EC registers to read (sensor might span more than 1 register) */
> +	u8 nr_registers;
> +	/** number of unique register banks */
> +	u8 nr_banks;
> +};
> +
> +static u8 register_bank(u16 reg)
> +{
> +	return reg >> 8;
> +}
> +
> +static u8 register_index(u16 reg)
> +{
> +	return reg & 0x00ff;
> +}
> +
> +static const struct ec_sensor_info *
> +get_sensor_info(const struct ec_sensors_data *state, int index)
> +{
> +	return &known_ec_sensors[state->sensors[index].info_index];
> +}
> +
> +static int find_ec_sensor_index(const struct ec_sensors_data *ec,
> +				enum hwmon_sensor_types type, int channel)
> +{
> +	unsigned int i;
> +
> +	for (i = 0; i < ec->nr_sensors; i++) {
> +		if (get_sensor_info(ec, i)->type == type) {
> +			if (channel == 0)
> +				return i;
> +			channel--;
> +		}
> +	}
> +	return -ENOENT;
> +}
> +
> +static int __init bank_compare(const void *a, const void *b)
> +{
> +	return *((const s8 *)a) - *((const s8 *)b);
> +}
> +
> +static int __init board_sensors_count(const struct asus_ec_board_info *board)
> +{
> +	return hweight_long(board->sensors);
> +}
> +
> +static void __init setup_sensor_data(struct ec_sensors_data *ec)
> +{
> +	struct ec_sensor *s = ec->sensors;
> +	bool bank_found;
> +	int i, j;
> +	u8 bank;
> +
> +	ec->nr_banks = 0;
> +	ec->nr_registers = 0;
> +
> +	for_each_set_bit(i, &ec->board->sensors,
> +			  BITS_PER_TYPE(ec->board->sensors)) {
> +		s->info_index = i;
> +		s->cached_value = 0;
> +		ec->nr_registers +=
> +			known_ec_sensors[s->info_index].addr.components.size;
> +		bank_found = false;
> +		bank = known_ec_sensors[s->info_index].addr.components.bank;
> +		for (j = 0; j < ec->nr_banks; j++) {
> +			if (ec->banks[j] == bank) {
> +				bank_found = true;
> +				break;
> +			}
> +		}
> +		if (!bank_found) {
> +			ec->banks[ec->nr_banks++] = bank;
> +		}
> +		s++;
> +	}
> +	sort(ec->banks, ec->nr_banks, 1, bank_compare, NULL);
> +}
> +
> +static void __init fill_ec_registers(struct ec_sensors_data *ec)
> +{
> +	const struct ec_sensor_info *si;
> +	unsigned int i, j, register_idx = 0;
> +
> +	for (i = 0; i < ec->nr_sensors; ++i) {
> +		si = get_sensor_info(ec, i);
> +		for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {
> +			ec->registers[register_idx] =
> +				(si->addr.components.bank << 8) +
> +				si->addr.components.index + j;
> +		}
> +	}
> +}
> +
> +static int get_bios_version(int *version)
> +{
> +	return kstrtoint(dmi_get_system_info(DMI_BIOS_VERSION), 10, version);
> +}
> +
> +static int mutex_versions_count(
> +	const struct asus_ec_board_versioned_mutex_path *mutex_info)
> +{
> +	int res;
> +
> +	for (res = 0; mutex_info[res].value; res++) {
> +	}
> +	return res;
> +}
> +
> +static acpi_handle asus_hw_access_mutex(struct device *dev)
> +{
> +	struct ec_sensors_data *state = dev_get_drvdata(dev);
> +	int versions_count = mutex_versions_count(state->board->mutex_path);
> +	int bios_version, status, i;
> +	const char *mutex_path;
> +	acpi_handle res;
> +
> +	if (mutex_path_override) {
> +		mutex_path = mutex_path_override;
> +	} else if (versions_count == 1) {
> +		/*
> +		 * We do not check bios version in this case, maybe it's
> +		 * even broken or in a format we can't parse.
> +		 */
> +		mutex_path = state->board->mutex_path[0].value;
> +	} else {
> +		status = get_bios_version(&bios_version);
> +		if (status) {
> +			dev_err(dev, "Could not get BIOS version: error %d",
> +				status);
> +			return NULL;
> +		}
> +		/*
> +		 * otherwise we choose the first version which is less or equal to
> +		 * the BIOS version
> +		 */
> +		for (i = versions_count - 1; i > 0; i--) {
> +			if (state->board->mutex_path[i].version <= bios_version)
> +				break;
> +		}
> +		mutex_path = state->board->mutex_path[i].value;
> +	}

There is a lot of complexity around mutex_path in this driver, yet there is
always exactly one entry for each board, and the name of the mutex is always
the same for all boards. This doesn't make sense. Either the code is needed
or it isn't. We don't usually add complex code like this into the kernel
"just because it may be needed at some point in the future". Either give me
a use case, or drop it all.

Thanks,
Guenter

> +
> +	status = acpi_get_handle(NULL, (acpi_string)mutex_path, &res);
> +	if (ACPI_FAILURE(status)) {
> +		dev_err(dev,
> +			"Could not get hardware access guard mutex '%s': error %d",
> +			mutex_path, status);
> +		return NULL;
> +	}
> +	return res;
> +}
> +
> +static int asus_ec_bank_switch(u8 bank, u8 *old)
> +{
> +	int status = 0;
> +
> +	if (old) {
> +		status = ec_read(ASUS_EC_BANK_REGISTER, old);
> +	}
> +	if (status || (old && (*old == bank)))
> +		return status;
> +	return ec_write(ASUS_EC_BANK_REGISTER, bank);
> +}
> +
> +static int asus_ec_block_read(const struct device *dev,
> +			      struct ec_sensors_data *ec)
> +{
> +	int ireg, ibank, status;
> +	u8 bank, reg_bank, prev_bank;
> +
> +	bank = 0;
> +	status = asus_ec_bank_switch(bank, &prev_bank);
> +	if (status) {
> +		dev_warn(dev, "EC bank switch failed");
> +		return status;
> +	}
> +
> +	if (prev_bank) {
> +		/* oops... somebody else is working with the EC too */
> +		dev_warn(dev,
> +			"Concurrent access to the ACPI EC detected.\nRace condition possible.");
> +	}
> +
> +	/*
> +	 * read registers minimizing bank switches.
> +	 */
> +	for (ibank = 0; ibank < ec->nr_banks; ibank++) {
> +		if (bank != ec->banks[ibank]) {
> +			bank = ec->banks[ibank];
> +			if (asus_ec_bank_switch(bank, NULL)) {
> +				dev_warn(dev, "EC bank switch to %d failed",
> +					 bank);
> +				break;
> +			}
> +		}
> +		for (ireg = 0; ireg < ec->nr_registers; ireg++) {
> +			reg_bank = register_bank(ec->registers[ireg]);
> +			if (reg_bank < bank) {
> +				continue;
> +			}
> +			ec_read(register_index(ec->registers[ireg]),
> +				ec->read_buffer + ireg);
> +		}
> +	}
> +
> +	status = asus_ec_bank_switch(prev_bank, NULL);
> +	return status;
> +}
> +
> +static inline u32 get_sensor_value(const struct ec_sensor_info *si, u8 *data)
> +{
> +	switch (si->addr.components.size) {
> +	case 1:
> +		return *data;
> +	case 2:
> +		return get_unaligned_be16(data);
> +	case 4:
> +		return get_unaligned_be32(data);
> +	default:
> +		return 0;
> +	}
> +}
> +
> +static void update_sensor_values(struct ec_sensors_data *ec, u8 *data)
> +{
> +	const struct ec_sensor_info *si;
> +	struct ec_sensor *s;
> +
> +	for (s = ec->sensors; s != ec->sensors + ec->nr_sensors; s++) {
> +		si = &known_ec_sensors[s->info_index];
> +		s->cached_value = get_sensor_value(si, data);
> +		data += si->addr.components.size;
> +	}
> +}
> +
> +static int update_ec_sensors(const struct device *dev,
> +			     struct ec_sensors_data *ec)
> +{
> +	int status;
> +
> +	/*
> +	 * ASUS DSDT does not specify that access to the EC has to be guarded,
> +	 * but firmware does access it via ACPI
> +	 */
> +	if (ACPI_FAILURE(acpi_acquire_mutex(ec->aml_mutex, NULL,
> +					    ACPI_LOCK_DELAY_MS))) {
> +		dev_err(dev, "Failed to acquire AML mutex");
> +		status = -EBUSY;
> +		goto cleanup;
> +	}
> +
> +	status = asus_ec_block_read(dev, ec);
> +
> +	if (!status) {
> +		update_sensor_values(ec, ec->read_buffer);
> +	}
> +	if (ACPI_FAILURE(acpi_release_mutex(ec->aml_mutex, NULL))) {
> +		dev_err(dev, "Failed to release AML mutex");
> +	}
> +cleanup:
> +	return status;
> +}
> +
> +static int scale_sensor_value(u32 value, int data_type)
> +{
> +	switch (data_type) {
> +	case hwmon_curr:
> +	case hwmon_temp:
> +	case hwmon_in:
> +		return value * MILLI;
> +	default:
> +		return value;
> +	}
> +}
> +
> +static int get_cached_value_or_update(const struct device *dev,
> +				      int sensor_index,
> +				      struct ec_sensors_data *state, u32 *value)
> +{
> +	if (time_after(jiffies, state->last_updated + HZ)) {
> +		if (update_ec_sensors(dev, state)) {
> +			dev_err(dev, "update_ec_sensors() failure\n");
> +			return -EIO;
> +		}
> +
> +		state->last_updated = jiffies;
> +	}
> +
> +	*value = state->sensors[sensor_index].cached_value;
> +	return 0;
> +}
> +
> +/*
> + * Now follow the functions that implement the hwmon interface
> + */
> +
> +static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
> +			      u32 attr, int channel, long *val)
> +{
> +	int ret;
> +	u32 value = 0;
> +
> +	struct ec_sensors_data *state = dev_get_drvdata(dev);
> +	int sidx = find_ec_sensor_index(state, type, channel);
> +
> +	if (sidx < 0) {
> +		return sidx;
> +	}
> +
> +	ret = get_cached_value_or_update(dev, sidx, state, &value);
> +	if (!ret) {
> +		*val = scale_sensor_value(value,
> +					  get_sensor_info(state, sidx)->type);
> +	}
> +
> +	return ret;
> +}
> +
> +static int asus_ec_hwmon_read_string(struct device *dev,
> +				     enum hwmon_sensor_types type, u32 attr,
> +				     int channel, const char **str)
> +{
> +	struct ec_sensors_data *state = dev_get_drvdata(dev);
> +	int sensor_index = find_ec_sensor_index(state, type, channel);
> +	*str = get_sensor_info(state, sensor_index)->label;
> +
> +	return 0;
> +}
> +
> +static umode_t asus_ec_hwmon_is_visible(const void *drvdata,
> +					enum hwmon_sensor_types type, u32 attr,
> +					int channel)
> +{
> +	const struct ec_sensors_data *state = drvdata;
> +
> +	return find_ec_sensor_index(state, type, channel) >= 0 ? S_IRUGO : 0;
> +}
> +
> +static int
> +asus_ec_hwmon_add_chan_info(struct hwmon_channel_info *asus_ec_hwmon_chan,
> +			     struct device *dev, int num,
> +			     enum hwmon_sensor_types type, u32 config)
> +{
> +	int i;
> +	u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
> +
> +	if (!cfg)
> +		return -ENOMEM;
> +
> +	asus_ec_hwmon_chan->type = type;
> +	asus_ec_hwmon_chan->config = cfg;
> +	for (i = 0; i < num; i++, cfg++)
> +		*cfg = config;
> +
> +	return 0;
> +}
> +
> +static const struct hwmon_ops asus_ec_hwmon_ops = {
> +	.is_visible = asus_ec_hwmon_is_visible,
> +	.read = asus_ec_hwmon_read,
> +	.read_string = asus_ec_hwmon_read_string,
> +};
> +
> +static struct hwmon_chip_info asus_ec_chip_info = {
> +	.ops = &asus_ec_hwmon_ops,
> +};
> +
> +static const struct asus_ec_board_info *__init
> +get_board_info(const struct device *dev)
> +{
> +	const struct dmi_system_id *dmi_entry;
> +
> +	dmi_entry = dmi_first_match(asus_ec_dmi_table);
> +	if (!dmi_entry) {
> +		dev_info(dev, "Unsupported board");
> +		return NULL;
> +	}
> +
> +	return dmi_entry->driver_data;
> +}
> +
> +static int __init configure_sensor_setup(struct device *dev)
> +{
> +	struct ec_sensors_data *ec_data = dev_get_drvdata(dev);
> +	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> +	struct device *hwdev;
> +	struct hwmon_channel_info *asus_ec_hwmon_chan;
> +	const struct hwmon_channel_info **ptr_asus_ec_ci;
> +	const struct hwmon_chip_info *chip_info;
> +	const struct ec_sensor_info *si;
> +	enum hwmon_sensor_types type;
> +	unsigned int i;
> +
> +	ec_data->board = get_board_info(dev);
> +	if (!ec_data->board) {
> +		return -ENODEV;
> +	}
> +
> +	ec_data->nr_sensors = board_sensors_count(ec_data->board);
> +	ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors,
> +					sizeof(struct ec_sensor), GFP_KERNEL);
> +
> +	setup_sensor_data(ec_data);
> +	ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers,
> +					  sizeof(u16), GFP_KERNEL);
> +	ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers,
> +					    sizeof(u8), GFP_KERNEL);
> +
> +	if (!ec_data->registers || !ec_data->read_buffer) {
> +		return -ENOMEM;
> +	}
> +
> +	fill_ec_registers(ec_data);
> +
> +	ec_data->aml_mutex = asus_hw_access_mutex(dev);
> +
> +	for (i = 0; i < ec_data->nr_sensors; ++i) {
> +		si = get_sensor_info(ec_data, i);
> +		if (!nr_count[si->type])
> +			++nr_types;
> +		++nr_count[si->type];
> +	}
> +
> +	if (nr_count[hwmon_temp])
> +		nr_count[hwmon_chip]++, nr_types++;
> +
> +	asus_ec_hwmon_chan = devm_kcalloc(
> +		dev, nr_types, sizeof(*asus_ec_hwmon_chan), GFP_KERNEL);
> +	if (!asus_ec_hwmon_chan)
> +		return -ENOMEM;
> +
> +	ptr_asus_ec_ci = devm_kcalloc(dev, nr_types + 1,
> +				       sizeof(*ptr_asus_ec_ci), GFP_KERNEL);
> +	if (!ptr_asus_ec_ci)
> +		return -ENOMEM;
> +
> +	asus_ec_chip_info.info = ptr_asus_ec_ci;
> +	chip_info = &asus_ec_chip_info;
> +
> +	for (type = 0; type < hwmon_max; ++type) {
> +		if (!nr_count[type])
> +			continue;
> +
> +		asus_ec_hwmon_add_chan_info(asus_ec_hwmon_chan, dev,
> +					     nr_count[type], type,
> +					     hwmon_attributes[type]);
> +		*ptr_asus_ec_ci++ = asus_ec_hwmon_chan++;
> +	}
> +
> +	dev_info(dev, "board has %d EC sensors that span %d registers",
> +		 ec_data->nr_sensors, ec_data->nr_registers);
> +
> +	hwdev = devm_hwmon_device_register_with_info(dev, "asus-ec-sensors",
> +						     ec_data, chip_info, NULL);
> +
> +	return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int __init asus_ec_probe(struct platform_device *pdev)
> +{
> +	struct asus_ec_sensors *state;
> +	int status = 0;
> +
> +	state = devm_kzalloc(&pdev->dev, sizeof(struct ec_sensors_data),
> +			     GFP_KERNEL);
> +
> +	if (!state) {
> +		return -ENOMEM;
> +	}
> +
> +	dev_set_drvdata(&pdev->dev, state);
> +	status = configure_sensor_setup(&pdev->dev);
> +	return status;
> +}
> +
> +static const struct acpi_device_id acpi_ec_ids[] = {
> +	/* Embedded Controller Device */
> +	{ "PNP0C09", 0 },
> +	{}
> +};
> +
> +static struct platform_driver asus_ec_sensors_platform_driver = {
> +	.driver = {
> +		.name	= "asus-ec-sensors",
> +		.acpi_match_table = acpi_ec_ids,
> +	},
> +};
> +
> +MODULE_DEVICE_TABLE(dmi, asus_ec_dmi_table);
> +module_platform_driver_probe(asus_ec_sensors_platform_driver, asus_ec_probe);
> +
> +module_param_named(mutex_path, mutex_path_override, charp, 0);
> +MODULE_PARM_DESC(mutex_path,
> +		 "Override ACPI mutex path used to guard access to hardware");
> +
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION(
> +	"HWMON driver for sensors accessible via EC in ASUS motherboards");
> +MODULE_LICENSE("GPL");
> +MODULE_VERSION("1");

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[kernel test robot]

[-- Attachment #1: Type: text/plain, Size: 2571 bytes --]

Hi Eugene,

I love your patch! Perhaps something to improve:

[auto build test WARNING on groeck-staging/hwmon-next]
[also build test WARNING on next-20211217]
[cannot apply to linus/master v5.16-rc5]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Eugene-Shalygin/hwmon-asus-ec-sensors-add-driver-for-ASUS-EC/20211218-014433
base:   https://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git hwmon-next
config: ia64-allyesconfig (https://download.01.org/0day-ci/archive/20211218/202112180502.QgAc0Kak-lkp(a)intel.com/config)
compiler: ia64-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/0day-ci/linux/commit/f18e6c103f89584b0027d079425d8e868a535a6d
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Eugene-Shalygin/hwmon-asus-ec-sensors-add-driver-for-ASUS-EC/20211218-014433
        git checkout f18e6c103f89584b0027d079425d8e868a535a6d
        # save the config file to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=ia64 SHELL=/bin/bash drivers/hwmon/

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All warnings (new ones prefixed by >>):

>> drivers/hwmon/asus-ec-sensors.c:45: warning: This comment starts with '/**', but isn't a kernel-doc comment. Refer Documentation/doc-guide/kernel-doc.rst
    * Arbitrary set max. allowed bank number. Required for sorting banks and
   drivers/hwmon/asus-ec-sensors.c:133: warning: This comment starts with '/**', but isn't a kernel-doc comment. Refer Documentation/doc-guide/kernel-doc.rst
    * All the known sensors for ASUS EC controllers


vim +45 drivers/hwmon/asus-ec-sensors.c

    43	
    44	/**
  > 45	 * Arbitrary set max. allowed bank number. Required for sorting banks and
    46	 * currently is overkill with just 2 banks used at max, but for the sake
    47	 * of alignment let's set it to a higher value.
    48	 */
    49	#define ASUS_EC_MAX_BANK 3
    50	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

[PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

This driver provides the same data as the asus_wmi_ec_sensors driver
(and gets it from the same source) but does not use WMI, polling
the ACPI EC directly.

That provides two enhancements: sensor reading became quicker (on some
systems or kernel configuration it took almost a full second to read
all the sensors, that transfers less than 15 bytes of data), the driver
became more flexible. The driver now relies on ACPI mutex to lock access
to the EC in the same way as the WMI code does.

Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
---
 MAINTAINERS                     |   6 +
 drivers/hwmon/Kconfig           |  11 +
 drivers/hwmon/Makefile          |   1 +
 drivers/hwmon/asus-ec-sensors.c | 790 ++++++++++++++++++++++++++++++++
 4 files changed, 808 insertions(+)
 create mode 100644 drivers/hwmon/asus-ec-sensors.c

diff --git a/MAINTAINERS b/MAINTAINERS
index fddd28d3db15..845f09bc0457 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -3012,6 +3012,12 @@ L:	linux-hwmon@vger.kernel.org
 S:	Maintained
 F:	drivers/hwmon/asus_wmi_ec_sensors.c
 
+ASUS EC HARDWARE MONITOR DRIVER
+M:	Eugene Shalygin <eugene.shalygin@gmail.com>
+L:	linux-hwmon@vger.kernel.org
+S:	Maintained
+F:	drivers/hwmon/asus-ec-sensors.c
+
 ASUS WIRELESS RADIO CONTROL DRIVER
 M:	João Paulo Rechi Vita <jprvita@gmail.com>
 L:	platform-driver-x86@vger.kernel.org
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 43e5245874ad..2c16b19d2c03 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -2253,6 +2253,17 @@ config SENSORS_ASUS_WMI_EC
 	  This driver can also be built as a module. If so, the module
 	  will be called asus_wmi_sensors_ec.
 
+config SENSORS_ASUS_EC
+	tristate "ASUS EC Sensors"
+	help
+	  If you say yes here you get support for the ACPI embedded controller
+	  hardware monitoring interface found in ASUS motherboards. The driver
+	  currently supports B550/X570 boards, although other ASUS boards might
+	  provide this monitoring interface as well.
+
+	  This driver can also be built as a module. If so, the module
+	  will be called asus_ec_sensors.
+
 endif # ACPI
 
 endif # HWMON
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 3a1551b3d570..2e5c216bb5d7 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID)		+= hwmon-vid.o
 # APCI drivers
 obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
 obj-$(CONFIG_SENSORS_ATK0110)	+= asus_atk0110.o
+obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
 
diff --git a/drivers/hwmon/asus-ec-sensors.c b/drivers/hwmon/asus-ec-sensors.c
new file mode 100644
index 000000000000..d7e44be00aae
--- /dev/null
+++ b/drivers/hwmon/asus-ec-sensors.c
@@ -0,0 +1,790 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * HWMON driver for ASUS motherboards that publish some sensor values
+ * via the embedded controller registers.
+ *
+ * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
+
+ * EC provides:
+ * - Chipset temperature
+ * - CPU temperature
+ * - Motherboard temperature
+ * - T_Sensor temperature
+ * - VRM temperature
+ * - Water In temperature
+ * - Water Out temperature
+ * - CPU Optional fan RPM
+ * - Chipset fan RPM
+ * - VRM Heat Sink fan RPM
+ * - Water Flow fan RPM
+ * - CPU current
+ */
+
+#include <linux/acpi.h>
+#include <linux/bitops.h>
+#include <linux/dev_printk.h>
+#include <linux/dmi.h>
+#include <linux/hwmon.h>
+#include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/sort.h>
+#include <linux/units.h>
+
+#include <asm/unaligned.h>
+
+static char *mutex_path_override;
+
+/** Writing to this EC register switches EC bank */
+#define ASUS_EC_BANK_REGISTER 0xff
+#define SENSOR_LABEL_LEN 16
+
+/**
+ * Arbitrary set max. allowed bank number. Required for sorting banks and
+ * currently is overkill with just 2 banks used at max, but for the sake
+ * of alignment let's set it to a higher value.
+ */
+#define ASUS_EC_MAX_BANK 3
+
+#define ACPI_LOCK_DELAY_MS 500
+
+/* ACPI mutex for locking access to the EC for the firmware */
+#define ASUS_HW_ACCESS_MUTEX_ASMX "\\AMW0.ASMX"
+
+/* There are two variants of the vendor spelling */
+#define VENDOR_ASUS_UPPER_CASE "ASUSTeK COMPUTER INC."
+
+typedef union {
+	u32 value;
+	struct {
+		u8 index;
+		u8 bank;
+		u8 size;
+		u8 dummy;
+	} components;
+} sensor_address;
+
+#define MAKE_SENSOR_ADDRESS(size, bank, index) {                               \
+		.value = (size << 16) + (bank << 8) + index                    \
+	}
+
+static u32 hwmon_attributes[hwmon_max] = {
+	[hwmon_chip] = HWMON_C_REGISTER_TZ,
+	[hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
+	[hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
+	[hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
+	[hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
+};
+
+struct ec_sensor_info {
+	char label[SENSOR_LABEL_LEN];
+	enum hwmon_sensor_types type;
+	sensor_address addr;
+};
+
+#define EC_SENSOR(sensor_label, sensor_type, size, bank, index)	{              \
+		.label = sensor_label, .type = sensor_type,                    \
+		.addr = MAKE_SENSOR_ADDRESS(size, bank, index),                \
+	}
+
+enum ec_sensors {
+	/** chipset temperature [℃] */
+	ec_sensor_temp_chipset,
+	/** CPU temperature [℃] */
+	ec_sensor_temp_cpu,
+	/** motherboard temperature [℃] */
+	ec_sensor_temp_mb,
+	/** "T_Sensor" temperature sensor reading [℃] */
+	ec_sensor_temp_t_sensor,
+	/** VRM temperature [℃] */
+	ec_sensor_temp_vrm,
+	/** CPU_Opt fan [RPM] */
+	ec_sensor_fan_cpu_opt,
+	/** VRM heat sink fan [RPM] */
+	ec_sensor_fan_vrm_hs,
+	/** Chipset fan [RPM] */
+	ec_sensor_fan_chipset,
+	/** Water flow sensor reading [RPM] */
+	ec_sensor_fan_water_flow,
+	/** CPU current [A] */
+	ec_sensor_curr_cpu,
+	/** "Water_In" temperature sensor reading [℃] */
+	ec_sensor_temp_water_in,
+	/** "Water_Out" temperature sensor reading [℃] */
+	ec_sensor_temp_water_out,
+};
+
+#define SENSOR_TEMP_CHIPSET BIT(ec_sensor_temp_chipset)
+#define SENSOR_TEMP_CPU BIT(ec_sensor_temp_cpu)
+#define SENSOR_TEMP_MB BIT(ec_sensor_temp_mb)
+#define SENSOR_TEMP_T_SENSOR BIT(ec_sensor_temp_t_sensor)
+#define SENSOR_TEMP_VRM BIT(ec_sensor_temp_vrm)
+#define SENSOR_FAN_CPU_OPT BIT(ec_sensor_fan_cpu_opt)
+#define SENSOR_FAN_VRM_HS BIT(ec_sensor_fan_vrm_hs)
+#define SENSOR_FAN_CHIPSET BIT(ec_sensor_fan_chipset)
+#define SENSOR_FAN_WATER_FLOW BIT(ec_sensor_fan_water_flow)
+#define SENSOR_CURR_CPU BIT(ec_sensor_curr_cpu)
+#define SENSOR_TEMP_WATER_IN BIT(ec_sensor_temp_water_in)
+#define SENSOR_TEMP_WATER_OUT BIT(ec_sensor_temp_water_out)
+
+/**
+ * All the known sensors for ASUS EC controllers
+ */
+static const struct ec_sensor_info known_ec_sensors[] = {
+	[ec_sensor_temp_chipset] =
+		EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
+	[ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
+	[ec_sensor_temp_mb] =
+		EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
+	[ec_sensor_temp_t_sensor] =
+		EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
+	[ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
+	[ec_sensor_fan_cpu_opt] =
+		EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
+	[ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
+	[ec_sensor_fan_chipset] =
+		EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
+	[ec_sensor_fan_water_flow] =
+		EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
+	[ec_sensor_curr_cpu] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
+	[ec_sensor_temp_water_in] =
+		EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
+	[ec_sensor_temp_water_out] =
+		EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
+};
+
+struct asus_ec_board_versioned_mutex_path {
+	/** Minimal applicable BIOS version */
+	int version;
+	const char *value;
+};
+
+struct asus_ec_board_info {
+	unsigned long sensors;
+	struct asus_ec_board_versioned_mutex_path mutex_path[];
+};
+
+/* Shortcuts for common combinations */
+#define SENSOR_SET_TEMP_CHIPSET_CPU_MB                                         \
+	(SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB)
+#define SENSOR_SET_TEMP_WATER (SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT)
+
+static struct asus_ec_board_info board_P_X570_P = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
+		   SENSOR_FAN_CHIPSET,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_PW_X570_A = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
+		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_R_C8H = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
+		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
+		   SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+/* Same as Hero but without chipset fan */
+static struct asus_ec_board_info board_R_C8DH = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
+		   SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+/* Same as Hero but without water */
+static struct asus_ec_board_info board_R_C8F = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
+		   SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_R_C8I = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_RS_B550_E_G = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CPU_OPT,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_RS_B550_I_G = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_VRM_HS | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_RS_X570_E_G = {
+	.sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
+		   SENSOR_TEMP_VRM | SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+static struct asus_ec_board_info board_RS_X570_I_G = {
+	.sensors = SENSOR_TEMP_T_SENSOR | SENSOR_FAN_VRM_HS |
+		   SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU,
+	.mutex_path = { { 0, ASUS_HW_ACCESS_MUTEX_ASMX }, {} }
+};
+
+#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {                         \
+	.matches = {                                                           \
+		DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),                     \
+		DMI_EXACT_MATCH(DMI_BOARD_NAME, name),                         \
+	},                                                                     \
+	.driver_data = sensors, \
+}
+
+static const struct dmi_system_id asus_ec_dmi_table[] __initconst = {
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "PRIME X570-PRO",
+			      &board_P_X570_P),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "Pro WS X570-ACE",
+			      &board_PW_X570_A),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII DARK HERO", &board_R_C8DH),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII FORMULA", &board_R_C8F),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG CROSSHAIR VIII HERO",
+			      &board_R_C8H),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII IMPACT", &board_R_C8I),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-E GAMING",
+			      &board_RS_B550_E_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX B550-I GAMING",
+			      &board_RS_B550_I_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-E GAMING",
+			      &board_RS_X570_E_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE, "ROG STRIX X570-I GAMING",
+			      &board_RS_X570_I_G),
+	{}
+};
+
+struct ec_sensor {
+	unsigned int info_index;
+	u32 cached_value;
+};
+
+struct ec_sensors_data {
+	const struct asus_ec_board_info *board;
+	struct ec_sensor *sensors;
+	/** EC registers to read from */
+	u16 *registers;
+	u8 *read_buffer;
+	/** sorted list of unique register banks */
+	u8 banks[ASUS_EC_MAX_BANK + 1];
+	/** in jiffies */
+	unsigned long last_updated;
+	acpi_handle aml_mutex;
+	/** number of board EC sensors */
+	u8 nr_sensors;
+	/** number of EC registers to read (sensor might span more than 1 register) */
+	u8 nr_registers;
+	/** number of unique register banks */
+	u8 nr_banks;
+};
+
+static u8 register_bank(u16 reg)
+{
+	return reg >> 8;
+}
+
+static u8 register_index(u16 reg)
+{
+	return reg & 0x00ff;
+}
+
+static const struct ec_sensor_info *
+get_sensor_info(const struct ec_sensors_data *state, int index)
+{
+	return &known_ec_sensors[state->sensors[index].info_index];
+}
+
+static int find_ec_sensor_index(const struct ec_sensors_data *ec,
+				enum hwmon_sensor_types type, int channel)
+{
+	unsigned int i;
+
+	for (i = 0; i < ec->nr_sensors; i++) {
+		if (get_sensor_info(ec, i)->type == type) {
+			if (channel == 0)
+				return i;
+			channel--;
+		}
+	}
+	return -ENOENT;
+}
+
+static int __init bank_compare(const void *a, const void *b)
+{
+	return *((const s8 *)a) - *((const s8 *)b);
+}
+
+static int __init board_sensors_count(const struct asus_ec_board_info *board)
+{
+	return hweight_long(board->sensors);
+}
+
+static void __init setup_sensor_data(struct ec_sensors_data *ec)
+{
+	struct ec_sensor *s = ec->sensors;
+	bool bank_found;
+	int i, j;
+	u8 bank;
+
+	ec->nr_banks = 0;
+	ec->nr_registers = 0;
+
+	for_each_set_bit(i, &ec->board->sensors,
+			  BITS_PER_TYPE(ec->board->sensors)) {
+		s->info_index = i;
+		s->cached_value = 0;
+		ec->nr_registers +=
+			known_ec_sensors[s->info_index].addr.components.size;
+		bank_found = false;
+		bank = known_ec_sensors[s->info_index].addr.components.bank;
+		for (j = 0; j < ec->nr_banks; j++) {
+			if (ec->banks[j] == bank) {
+				bank_found = true;
+				break;
+			}
+		}
+		if (!bank_found) {
+			ec->banks[ec->nr_banks++] = bank;
+		}
+		s++;
+	}
+	sort(ec->banks, ec->nr_banks, 1, bank_compare, NULL);
+}
+
+static void __init fill_ec_registers(struct ec_sensors_data *ec)
+{
+	const struct ec_sensor_info *si;
+	unsigned int i, j, register_idx = 0;
+
+	for (i = 0; i < ec->nr_sensors; ++i) {
+		si = get_sensor_info(ec, i);
+		for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {
+			ec->registers[register_idx] =
+				(si->addr.components.bank << 8) +
+				si->addr.components.index + j;
+		}
+	}
+}
+
+static int get_bios_version(int *version)
+{
+	return kstrtoint(dmi_get_system_info(DMI_BIOS_VERSION), 10, version);
+}
+
+static int mutex_versions_count(
+	const struct asus_ec_board_versioned_mutex_path *mutex_info)
+{
+	int res;
+
+	for (res = 0; mutex_info[res].value; res++) {
+	}
+	return res;
+}
+
+static acpi_handle asus_hw_access_mutex(struct device *dev)
+{
+	struct ec_sensors_data *state = dev_get_drvdata(dev);
+	int versions_count = mutex_versions_count(state->board->mutex_path);
+	int bios_version, status, i;
+	const char *mutex_path;
+	acpi_handle res;
+
+	if (mutex_path_override) {
+		mutex_path = mutex_path_override;
+	} else if (versions_count == 1) {
+		/*
+		 * We do not check bios version in this case, maybe it's
+		 * even broken or in a format we can't parse.
+		 */
+		mutex_path = state->board->mutex_path[0].value;
+	} else {
+		status = get_bios_version(&bios_version);
+		if (status) {
+			dev_err(dev, "Could not get BIOS version: error %d",
+				status);
+			return NULL;
+		}
+		/*
+		 * otherwise we choose the first version which is less or equal to
+		 * the BIOS version
+		 */
+		for (i = versions_count - 1; i > 0; i--) {
+			if (state->board->mutex_path[i].version <= bios_version)
+				break;
+		}
+		mutex_path = state->board->mutex_path[i].value;
+	}
+
+	status = acpi_get_handle(NULL, (acpi_string)mutex_path, &res);
+	if (ACPI_FAILURE(status)) {
+		dev_err(dev,
+			"Could not get hardware access guard mutex '%s': error %d",
+			mutex_path, status);
+		return NULL;
+	}
+	return res;
+}
+
+static int asus_ec_bank_switch(u8 bank, u8 *old)
+{
+	int status = 0;
+
+	if (old) {
+		status = ec_read(ASUS_EC_BANK_REGISTER, old);
+	}
+	if (status || (old && (*old == bank)))
+		return status;
+	return ec_write(ASUS_EC_BANK_REGISTER, bank);
+}
+
+static int asus_ec_block_read(const struct device *dev,
+			      struct ec_sensors_data *ec)
+{
+	int ireg, ibank, status;
+	u8 bank, reg_bank, prev_bank;
+
+	bank = 0;
+	status = asus_ec_bank_switch(bank, &prev_bank);
+	if (status) {
+		dev_warn(dev, "EC bank switch failed");
+		return status;
+	}
+
+	if (prev_bank) {
+		/* oops... somebody else is working with the EC too */
+		dev_warn(dev,
+			"Concurrent access to the ACPI EC detected.\nRace condition possible.");
+	}
+
+	/*
+	 * read registers minimizing bank switches.
+	 */
+	for (ibank = 0; ibank < ec->nr_banks; ibank++) {
+		if (bank != ec->banks[ibank]) {
+			bank = ec->banks[ibank];
+			if (asus_ec_bank_switch(bank, NULL)) {
+				dev_warn(dev, "EC bank switch to %d failed",
+					 bank);
+				break;
+			}
+		}
+		for (ireg = 0; ireg < ec->nr_registers; ireg++) {
+			reg_bank = register_bank(ec->registers[ireg]);
+			if (reg_bank < bank) {
+				continue;
+			}
+			ec_read(register_index(ec->registers[ireg]),
+				ec->read_buffer + ireg);
+		}
+	}
+
+	status = asus_ec_bank_switch(prev_bank, NULL);
+	return status;
+}
+
+static inline u32 get_sensor_value(const struct ec_sensor_info *si, u8 *data)
+{
+	switch (si->addr.components.size) {
+	case 1:
+		return *data;
+	case 2:
+		return get_unaligned_be16(data);
+	case 4:
+		return get_unaligned_be32(data);
+	default:
+		return 0;
+	}
+}
+
+static void update_sensor_values(struct ec_sensors_data *ec, u8 *data)
+{
+	const struct ec_sensor_info *si;
+	struct ec_sensor *s;
+
+	for (s = ec->sensors; s != ec->sensors + ec->nr_sensors; s++) {
+		si = &known_ec_sensors[s->info_index];
+		s->cached_value = get_sensor_value(si, data);
+		data += si->addr.components.size;
+	}
+}
+
+static int update_ec_sensors(const struct device *dev,
+			     struct ec_sensors_data *ec)
+{
+	int status;
+
+	/*
+	 * ASUS DSDT does not specify that access to the EC has to be guarded,
+	 * but firmware does access it via ACPI
+	 */
+	if (ACPI_FAILURE(acpi_acquire_mutex(ec->aml_mutex, NULL,
+					    ACPI_LOCK_DELAY_MS))) {
+		dev_err(dev, "Failed to acquire AML mutex");
+		status = -EBUSY;
+		goto cleanup;
+	}
+
+	status = asus_ec_block_read(dev, ec);
+
+	if (!status) {
+		update_sensor_values(ec, ec->read_buffer);
+	}
+	if (ACPI_FAILURE(acpi_release_mutex(ec->aml_mutex, NULL))) {
+		dev_err(dev, "Failed to release AML mutex");
+	}
+cleanup:
+	return status;
+}
+
+static int scale_sensor_value(u32 value, int data_type)
+{
+	switch (data_type) {
+	case hwmon_curr:
+	case hwmon_temp:
+	case hwmon_in:
+		return value * MILLI;
+	default:
+		return value;
+	}
+}
+
+static int get_cached_value_or_update(const struct device *dev,
+				      int sensor_index,
+				      struct ec_sensors_data *state, u32 *value)
+{
+	if (time_after(jiffies, state->last_updated + HZ)) {
+		if (update_ec_sensors(dev, state)) {
+			dev_err(dev, "update_ec_sensors() failure\n");
+			return -EIO;
+		}
+
+		state->last_updated = jiffies;
+	}
+
+	*value = state->sensors[sensor_index].cached_value;
+	return 0;
+}
+
+/*
+ * Now follow the functions that implement the hwmon interface
+ */
+
+static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
+			      u32 attr, int channel, long *val)
+{
+	int ret;
+	u32 value = 0;
+
+	struct ec_sensors_data *state = dev_get_drvdata(dev);
+	int sidx = find_ec_sensor_index(state, type, channel);
+
+	if (sidx < 0) {
+		return sidx;
+	}
+
+	ret = get_cached_value_or_update(dev, sidx, state, &value);
+	if (!ret) {
+		*val = scale_sensor_value(value,
+					  get_sensor_info(state, sidx)->type);
+	}
+
+	return ret;
+}
+
+static int asus_ec_hwmon_read_string(struct device *dev,
+				     enum hwmon_sensor_types type, u32 attr,
+				     int channel, const char **str)
+{
+	struct ec_sensors_data *state = dev_get_drvdata(dev);
+	int sensor_index = find_ec_sensor_index(state, type, channel);
+	*str = get_sensor_info(state, sensor_index)->label;
+
+	return 0;
+}
+
+static umode_t asus_ec_hwmon_is_visible(const void *drvdata,
+					enum hwmon_sensor_types type, u32 attr,
+					int channel)
+{
+	const struct ec_sensors_data *state = drvdata;
+
+	return find_ec_sensor_index(state, type, channel) >= 0 ? S_IRUGO : 0;
+}
+
+static int
+asus_ec_hwmon_add_chan_info(struct hwmon_channel_info *asus_ec_hwmon_chan,
+			     struct device *dev, int num,
+			     enum hwmon_sensor_types type, u32 config)
+{
+	int i;
+	u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
+
+	if (!cfg)
+		return -ENOMEM;
+
+	asus_ec_hwmon_chan->type = type;
+	asus_ec_hwmon_chan->config = cfg;
+	for (i = 0; i < num; i++, cfg++)
+		*cfg = config;
+
+	return 0;
+}
+
+static const struct hwmon_ops asus_ec_hwmon_ops = {
+	.is_visible = asus_ec_hwmon_is_visible,
+	.read = asus_ec_hwmon_read,
+	.read_string = asus_ec_hwmon_read_string,
+};
+
+static struct hwmon_chip_info asus_ec_chip_info = {
+	.ops = &asus_ec_hwmon_ops,
+};
+
+static const struct asus_ec_board_info *__init
+get_board_info(const struct device *dev)
+{
+	const struct dmi_system_id *dmi_entry;
+
+	dmi_entry = dmi_first_match(asus_ec_dmi_table);
+	if (!dmi_entry) {
+		dev_info(dev, "Unsupported board");
+		return NULL;
+	}
+
+	return dmi_entry->driver_data;
+}
+
+static int __init configure_sensor_setup(struct device *dev)
+{
+	struct ec_sensors_data *ec_data = dev_get_drvdata(dev);
+	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
+	struct device *hwdev;
+	struct hwmon_channel_info *asus_ec_hwmon_chan;
+	const struct hwmon_channel_info **ptr_asus_ec_ci;
+	const struct hwmon_chip_info *chip_info;
+	const struct ec_sensor_info *si;
+	enum hwmon_sensor_types type;
+	unsigned int i;
+
+	ec_data->board = get_board_info(dev);
+	if (!ec_data->board) {
+		return -ENODEV;
+	}
+
+	ec_data->nr_sensors = board_sensors_count(ec_data->board);
+	ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors,
+					sizeof(struct ec_sensor), GFP_KERNEL);
+
+	setup_sensor_data(ec_data);
+	ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers,
+					  sizeof(u16), GFP_KERNEL);
+	ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers,
+					    sizeof(u8), GFP_KERNEL);
+
+	if (!ec_data->registers || !ec_data->read_buffer) {
+		return -ENOMEM;
+	}
+
+	fill_ec_registers(ec_data);
+
+	ec_data->aml_mutex = asus_hw_access_mutex(dev);
+
+	for (i = 0; i < ec_data->nr_sensors; ++i) {
+		si = get_sensor_info(ec_data, i);
+		if (!nr_count[si->type])
+			++nr_types;
+		++nr_count[si->type];
+	}
+
+	if (nr_count[hwmon_temp])
+		nr_count[hwmon_chip]++, nr_types++;
+
+	asus_ec_hwmon_chan = devm_kcalloc(
+		dev, nr_types, sizeof(*asus_ec_hwmon_chan), GFP_KERNEL);
+	if (!asus_ec_hwmon_chan)
+		return -ENOMEM;
+
+	ptr_asus_ec_ci = devm_kcalloc(dev, nr_types + 1,
+				       sizeof(*ptr_asus_ec_ci), GFP_KERNEL);
+	if (!ptr_asus_ec_ci)
+		return -ENOMEM;
+
+	asus_ec_chip_info.info = ptr_asus_ec_ci;
+	chip_info = &asus_ec_chip_info;
+
+	for (type = 0; type < hwmon_max; ++type) {
+		if (!nr_count[type])
+			continue;
+
+		asus_ec_hwmon_add_chan_info(asus_ec_hwmon_chan, dev,
+					     nr_count[type], type,
+					     hwmon_attributes[type]);
+		*ptr_asus_ec_ci++ = asus_ec_hwmon_chan++;
+	}
+
+	dev_info(dev, "board has %d EC sensors that span %d registers",
+		 ec_data->nr_sensors, ec_data->nr_registers);
+
+	hwdev = devm_hwmon_device_register_with_info(dev, "asus-ec-sensors",
+						     ec_data, chip_info, NULL);
+
+	return PTR_ERR_OR_ZERO(hwdev);
+}
+
+static int __init asus_ec_probe(struct platform_device *pdev)
+{
+	struct asus_ec_sensors *state;
+	int status = 0;
+
+	state = devm_kzalloc(&pdev->dev, sizeof(struct ec_sensors_data),
+			     GFP_KERNEL);
+
+	if (!state) {
+		return -ENOMEM;
+	}
+
+	dev_set_drvdata(&pdev->dev, state);
+	status = configure_sensor_setup(&pdev->dev);
+	return status;
+}
+
+static const struct acpi_device_id acpi_ec_ids[] = {
+	/* Embedded Controller Device */
+	{ "PNP0C09", 0 },
+	{}
+};
+
+static struct platform_driver asus_ec_sensors_platform_driver = {
+	.driver = {
+		.name	= "asus-ec-sensors",
+		.acpi_match_table = acpi_ec_ids,
+	},
+};
+
+MODULE_DEVICE_TABLE(dmi, asus_ec_dmi_table);
+module_platform_driver_probe(asus_ec_sensors_platform_driver, asus_ec_probe);
+
+module_param_named(mutex_path, mutex_path_override, charp, 0);
+MODULE_PARM_DESC(mutex_path,
+		 "Override ACPI mutex path used to guard access to hardware");
+
+MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
+MODULE_DESCRIPTION(
+	"HWMON driver for sensors accessible via EC in ASUS motherboards");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1");
-- 
2.34.1

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[kernel test robot]

Hi Eugene,

I love your patch! Perhaps something to improve:

[auto build test WARNING on groeck-staging/hwmon-next]
[also build test WARNING on next-20211215]
[cannot apply to v5.16-rc5]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Eugene-Shalygin/hwmon-asus-ec-sensors-add-driver-for-ASUS-EC/20211217-045428
base:   https://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git hwmon-next
config: ia64-allyesconfig (https://download.01.org/0day-ci/archive/20211217/202112171205.FwhZfLkY-lkp@intel.com/config)
compiler: ia64-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/0day-ci/linux/commit/27e7f47121cb02208740ed895a4cf4c7ab5bee63
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Eugene-Shalygin/hwmon-asus-ec-sensors-add-driver-for-ASUS-EC/20211217-045428
        git checkout 27e7f47121cb02208740ed895a4cf4c7ab5bee63
        # save the config file to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=ia64 SHELL=/bin/bash drivers/hwmon/

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All warnings (new ones prefixed by >>):

   drivers/hwmon/asus-ec-sensors.c: In function 'asus_ec_probe':
>> drivers/hwmon/asus-ec-sensors.c:690:26: warning: ordered comparison of pointer with integer zero [-Wextra]
     690 |         if (state->board < 0) {
         |                          ^


vim +690 drivers/hwmon/asus-ec-sensors.c

   685	
   686	static int asus_ec_probe(struct platform_device *pdev)
   687	{
   688		struct ec_sensors_data *state = platform_get_drvdata(pdev);
   689	
 > 690		if (state->board < 0) {
   691			return -ENODEV;
   692		}
   693	
   694		return 0;
   695	}
   696	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[kernel test robot]

[-- Attachment #1: Type: text/plain, Size: 2350 bytes --]

Hi Eugene,

I love your patch! Perhaps something to improve:

[auto build test WARNING on groeck-staging/hwmon-next]
[also build test WARNING on next-20211215]
[cannot apply to v5.16-rc5]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/Eugene-Shalygin/hwmon-asus-ec-sensors-add-driver-for-ASUS-EC/20211217-045428
base:   https://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging.git hwmon-next
config: ia64-allyesconfig (https://download.01.org/0day-ci/archive/20211217/202112171205.FwhZfLkY-lkp(a)intel.com/config)
compiler: ia64-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
        wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # https://github.com/0day-ci/linux/commit/27e7f47121cb02208740ed895a4cf4c7ab5bee63
        git remote add linux-review https://github.com/0day-ci/linux
        git fetch --no-tags linux-review Eugene-Shalygin/hwmon-asus-ec-sensors-add-driver-for-ASUS-EC/20211217-045428
        git checkout 27e7f47121cb02208740ed895a4cf4c7ab5bee63
        # save the config file to linux build tree
        mkdir build_dir
        COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=ia64 SHELL=/bin/bash drivers/hwmon/

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>

All warnings (new ones prefixed by >>):

   drivers/hwmon/asus-ec-sensors.c: In function 'asus_ec_probe':
>> drivers/hwmon/asus-ec-sensors.c:690:26: warning: ordered comparison of pointer with integer zero [-Wextra]
     690 |         if (state->board < 0) {
         |                          ^


vim +690 drivers/hwmon/asus-ec-sensors.c

   685	
   686	static int asus_ec_probe(struct platform_device *pdev)
   687	{
   688		struct ec_sensors_data *state = platform_get_drvdata(pdev);
   689	
 > 690		if (state->board < 0) {
   691			return -ENODEV;
   692		}
   693	
   694		return 0;
   695	}
   696	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

On Thu, 16 Dec 2021 at 22:28, Andy Shevchenko <andy.shevchenko@gmail.com> wrote:
> > to the EC, in the same way as the WMI DSDT code does.
>
> How do you know that this way there is no race with any of ACPI code?

Because this mutex is exactly what the ACPI code uses to avoid races.

> _LOCK_DELAY_MS and drop useless comment
>
> I think I gave the very same comments before. Maybe you can check the
> reviews of another driver?

I understand your frustration, sorry. In all those similar reviews I
must have missed some emails. I'll fix what I can.

> > +static const struct ec_sensor_info known_ec_sensors[] = {
> > +       EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a), /* SENSOR_TEMP_CHIPSET */
> > +       EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b), /* SENSOR_TEMP_CPU */
> > +       EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c), /* SENSOR_TEMP_MB */
> > +       EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d), /* SENSOR_TEMP_T_SENSOR */
> > +       EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e), /* SENSOR_TEMP_VRM */
> > +       EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0), /* SENSOR_FAN_CPU_OPT */
> > +       EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2), /* SENSOR_FAN_VRM_HS */
> > +       EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4), /* SENSOR_FAN_CHIPSET */
> > +       EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc), /* SENSOR_FAN_WATER_FLOW */
> > +       EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4), /* SENSOR_CURR_CPU */
> > +       EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00), /* SENSOR_TEMP_WATER_IN */
> > +       EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01), /* SENSOR_TEMP_WATER_OUT */
>
> Instead of comments, use form of
>
>   [FOO] = BAR(...),

Was unable do that because the SENSOR_ enum is a flag enum. But given
this suggestion and the one about bit foreach loop, I will convert the
enum to bitmap.

> What's wrong with post-decrement, and I think I already commented on this.
> So, I stopped here until you go and enforce all comments given against
> previous incarnation of this driver.

I missed these ones, sorry.

> > +       for (i = 1; i < SENSOR_END; i <<= 1) {
> > +               if ((i & ec->board->sensors) == 0
> > +                       continue;
>
> Interesting way of NIH for_each_set_bit().

Will convert to bitmap.

> > +       acpi_status status = acpi_get_handle(
> > +               NULL, (acpi_string)state->board->acpi_mutex_path, &res);
>
> It looks awful (indentation), Have you run checkpatch?

Yes, but some warnings remained.

Thanks,
Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

Hi Denis,

On Thu, 16 Dec 2021 at 23:04, Denis Pauk <pauk.denis@gmail.com> wrote:
>
> Hi Eugene,
>
> Have you found some issues with idea of usage ACPI WMI methods as
> failback solution, like in case when ASUS will release some BIOS with
> different mutex path or different motherboard where will be same WMI
> methods but fully different internal logic?

Not direct ones, but yes. First of all, I still don't understand what
causes the big slowdown in ec_read() calls. I learned that Fedora and
Arch kernel configs result in the slowdown, while my custom minimal
kernel does not (well, it is still slow but nevertheless). I tried to
unload all the modules I do not have in my custom kernel, I tried to
disable every option which is related to ACPI in the Fedora config,
but the slowdown did not disappear. Then it is not that simple to
gather information from other users, because one needs the ec_sys
module to measure ec_read() performance, but it is not available in
many distribution kernels it seems.

Instead of that I've changed data structures for board description to
include the mutex path there, so that we can handle various paths or
version dependent paths for each motherboard. I can add code to select
the mutex path based on the BIOS version for the next iteration. Also
considering adding a module parameter to override that path. I think
that will be maintainable and give users a way for a local fix while
waiting for kernel update. Would you agree?

That way, I believe, the WMI fallback is rendered barely useful and I
decided to drop it.

Best regards,
Eugene

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Denis Pauk]

Hi Eugene,

Have you found some issues with idea of usage ACPI WMI methods as
failback solution, like in case when ASUS will release some BIOS with
different mutex path or different motherboard where will be same WMI
methods but fully different internal logic?
   
On Thu, 16 Dec 2021 23:27:52 +0200
Andy Shevchenko <andy.shevchenko@gmail.com> wrote:

> On Thu, Dec 16, 2021 at 10:53 PM Eugene Shalygin
> <eugene.shalygin@gmail.com> wrote:
> >
> > This driver provides the same data as the asus_wmi_ec_sensors driver
> > (and gets it from the same source) but does not use WMI, polling
> > the ACPI EC directly.
> >
> > That provides two enhancements: sensor reading became quicker (on
> > some systems or kernel configuration it took almost a full second
> > to read all the sensors, that transfers less than 15 bytes of
> > data), the driver became more fexible. The driver now relies on
> > ACPI mutex to lock access  
> 
> flexible
> 
> > to the EC, in the same way as the WMI DSDT code does.  
> 
> How do you know that this way there is no race with any of ACPI code?
> 
> ...
> 
> > +config SENSORS_ASUS_EC
> > +       tristate "ASUS EC Sensors"  
> 
> > +       depends on ACPI  
> 
> No need to duplicate. See (1) below.
> 
> > +       help
> > +         If you say yes here you get support for the ACPI embedded
> > controller
> > +         hardware monitoring interface found in ASUS motherboards.
> > The driver
> > +         currently supports B550/X570 boards, although other ASUS
> > boards might
> > +         provide this monitoring interface as well.
> > +
> > +         This driver can also be built as a module. If so, the
> > module
> > +         will be called asus_ec_sensors.
> > +
> >  endif # ACPI  
> 
> (1)
> 
> ...
> 
> > +/*
> > + * HWMON driver for ASUS motherboards that publish some sensor
> > values
> > + * via the embedded controller registers  
> 
> Missed grammatical period.
> 
> > + *  
> 
> > + */  
> 
> ...
> 
> > +#define ASUS_EC_BANK_REGISTER 0xff /* Writing to this EC register
> > switches EC bank */  
> 
> Can you put comment before the definition?
> 
> ...
> 
> > +#define SENSOR_LABEL_LEN 0x10  
> 
> Why in hex?
> 
> Missed blank line here.
> 
> > +/*
> > + * Arbitrary set max. allowed bank number. Required for sorting
> > banks and
> > + * currently is overkill with just 2 banks used at max, but for
> > the sake
> > + * of alignment let's set it to a higher value  
> 
> Check grammar everywhere, again missed period (at least).
> 
> > + */  
> 
> ...
> 
> > +#define ACPI_DELAY_MSEC_LOCK   500     /* Wait for 0.5 s max. to
> > acquire the lock */  
> 
> _LOCK_DELAY_MS and drop useless comment
> 
> I think I gave the very same comments before. Maybe you can check the
> reviews of another driver?
> 
> ...
> 
> 
> > +#define MAKE_SENSOR_ADDRESS(size, bank, index)
> >             \
> > +       {
> >            \
> > +               .value = (size << 16) + (bank << 8) + index
> >            \  
> 
> Leave comma here and everywhere else in the structure entries.
> 
> > +       }  
> 
> Besides that, would it be better to have it defined as a compound
> literal?
> 
> ...
> 
> > +enum known_ec_sensor {
> > +       SENSOR_TEMP_CHIPSET     = 1 <<  0, /* chipset temperature
> > [℃] */
> > +       SENSOR_TEMP_CPU         = 1 <<  1, /* CPU temperature [℃] */
> > +       SENSOR_TEMP_MB          = 1 <<  2, /* motherboard
> > temperature [℃] */
> > +       SENSOR_TEMP_T_SENSOR    = 1 <<  3, /* "T_Sensor"
> > temperature sensor reading [℃] */
> > +       SENSOR_TEMP_VRM         = 1 <<  4, /* VRM temperature [℃] */
> > +       SENSOR_FAN_CPU_OPT      = 1 <<  5, /* CPU_Opt fan [RPM] */
> > +       SENSOR_FAN_VRM_HS       = 1 <<  6, /* VRM heat sink fan
> > [RPM] */
> > +       SENSOR_FAN_CHIPSET      = 1 <<  7, /* chipset fan [RPM] */
> > +       SENSOR_FAN_WATER_FLOW   = 1 <<  8, /* water flow sensor
> > reading [RPM] */
> > +       SENSOR_CURR_CPU         = 1 <<  9, /* CPU current [A] */
> > +       SENSOR_TEMP_WATER_IN    = 1 << 10, /* "Water_In"
> > temperature sensor reading [℃] */
> > +       SENSOR_TEMP_WATER_OUT   = 1 << 11, /* "Water_Out"
> > temperature sensor reading [℃] */  
> 
> Perhaps kernel doc and use of BIT()?
> 
> > +       SENSOR_END
> > +};  
> 
> ...
> 
> > +static const struct ec_sensor_info known_ec_sensors[] = {
> > +       EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a), /*
> > SENSOR_TEMP_CHIPSET */
> > +       EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b), /*
> > SENSOR_TEMP_CPU */
> > +       EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c), /*
> > SENSOR_TEMP_MB */
> > +       EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d), /*
> > SENSOR_TEMP_T_SENSOR */
> > +       EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e), /*
> > SENSOR_TEMP_VRM */
> > +       EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0), /*
> > SENSOR_FAN_CPU_OPT */
> > +       EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2), /*
> > SENSOR_FAN_VRM_HS */
> > +       EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4), /*
> > SENSOR_FAN_CHIPSET */
> > +       EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc), /*
> > SENSOR_FAN_WATER_FLOW */
> > +       EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4), /*
> > SENSOR_CURR_CPU */
> > +       EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00), /*
> > SENSOR_TEMP_WATER_IN */
> > +       EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01), /*
> > SENSOR_TEMP_WATER_OUT */  
> 
> Instead of comments, use form of
> 
>   [FOO] = BAR(...),
> 
> > +};  
> 
> ...
> 
> > +static struct asus_ec_board_info board_P_X570_P = {
> > +       .sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU |
> > SENSOR_TEMP_MB | SENSOR_TEMP_VRM
> > +                | SENSOR_FAN_CHIPSET,  
> 
> It's a bit long and better to leave ' |' on the previous line(s).
> 
> > +       .acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX  
> 
> + Comma.
> 
> > +};  
> 
> Ditto for all other similar cases.
> 
> ...
> 
> > +#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {
> >             \
> > +               .matches = {
> >            \
> > +                       DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),
> >            \
> > +                       DMI_EXACT_MATCH(DMI_BOARD_NAME, name),
> >            \
> > +               },
> >            \
> > +               .driver_data = sensors
> >            \  
> 
> + Comma.
> 
> > +       }  
> 
> ...
> 
> > +struct ec_sensors_data {
> > +       const struct asus_ec_board_info *board;
> > +       struct ec_sensor *sensors;
> > +       /* EC registers to read from */
> > +       u16 *registers;
> > +       u8 *read_buffer;
> > +       /* sorted list of unique register banks */
> > +       u8 banks[ASUS_EC_MAX_BANK];
> > +       unsigned long last_updated; /* in jiffies */
> > +       acpi_handle aml_mutex;
> > +       u8 nr_sensors; /* number of board EC sensors */
> > +       /* number of EC registers to read (sensor might span more
> > than 1 register) */
> > +       u8 nr_registers;
> > +       u8 nr_banks; /* number of unique register banks */
> > +};  
> 
> Kernel doc?
> 
> ...
> 
> > +static u8 register_bank(u16 reg)
> > +{
> > +       return (reg & 0xff00) >> 8;  
> 
> ' & 0xff00' part is redundant.
> 
> > +}  
> 
> ...
> 
> > +static struct ec_sensors_data *get_sensor_data(struct device *pdev)
> > +{
> > +       return dev_get_drvdata(pdev);
> > +}  
> 
> Useless wrapper. It adds no value.
> 
> ...
> 
> > +       unsigned int i;
> > +
> > +       for (i = 0; i < ec->nr_sensors; ++i) {
> > +               if (get_sensor_info(ec, i)->type == type) {
> > +                       if (channel == 0)
> > +                               return i;  
> 
> > +                       --channel;  
> 
> What's wrong with post-decrement, and I think I already commented on
> this. So, I stopped here until you go and enforce all comments given
> against previous incarnation of this driver.
> 
> > +               }
> > +       }
> > +       return -ENOENT;
> > +}  
> 
> ...
> 
> > +       for (i = 1; i < SENSOR_END; i <<= 1) {
> > +               if ((i & ec->board->sensors) == 0
> > +                       continue;  
> 
> Interesting way of NIH for_each_set_bit().
> 
> ...
> 
> > +               for (j = 0; j < si->addr.components.size; ++j,
> > ++register_idx) {  
> 
> Why pre-increments?
> 
> > +                       ec->registers[register_idx] =
> > +                               (si->addr.components.bank << 8) +
> > +                               si->addr.components.index + j;
> > +               }
> > +       }
> > +}  
> 
> ...
> 
> > +       acpi_handle res;  
> 
> > +       acpi_status status = acpi_get_handle(
> > +               NULL, (acpi_string)state->board->acpi_mutex_path,
> > &res);  
> 
> It looks awful (indentation), Have you run checkpatch?
> 
> > +       if (ACPI_FAILURE(status)) {
> > +               dev_err(dev, "Could not get hardware access guard
> > mutex: error %d", status);
> > +               return NULL;
> > +       }  
> 
> ...
> 
> > +static struct hwmon_chip_info asus_wmi_chip_info = {
> > +       .ops = &asus_ec_hwmon_ops,  
> 
> > +       .info = NULL,  
> 
> Redundant.
> 
> > +};  
> 



Best regards,
             Denis.

Re: [PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Andy Shevchenko]

On Thu, Dec 16, 2021 at 10:53 PM Eugene Shalygin
<eugene.shalygin@gmail.com> wrote:
>
> This driver provides the same data as the asus_wmi_ec_sensors driver
> (and gets it from the same source) but does not use WMI, polling
> the ACPI EC directly.
>
> That provides two enhancements: sensor reading became quicker (on some
> systems or kernel configuration it took almost a full second to read
> all the sensors, that transfers less than 15 bytes of data), the driver
> became more fexible. The driver now relies on ACPI mutex to lock access

flexible

> to the EC, in the same way as the WMI DSDT code does.

How do you know that this way there is no race with any of ACPI code?

...

> +config SENSORS_ASUS_EC
> +       tristate "ASUS EC Sensors"

> +       depends on ACPI

No need to duplicate. See (1) below.

> +       help
> +         If you say yes here you get support for the ACPI embedded controller
> +         hardware monitoring interface found in ASUS motherboards. The driver
> +         currently supports B550/X570 boards, although other ASUS boards might
> +         provide this monitoring interface as well.
> +
> +         This driver can also be built as a module. If so, the module
> +         will be called asus_ec_sensors.
> +
>  endif # ACPI

(1)

...

> +/*
> + * HWMON driver for ASUS motherboards that publish some sensor values
> + * via the embedded controller registers

Missed grammatical period.

> + *

> + */

...

> +#define ASUS_EC_BANK_REGISTER 0xff /* Writing to this EC register switches EC bank */

Can you put comment before the definition?

...

> +#define SENSOR_LABEL_LEN 0x10

Why in hex?

Missed blank line here.

> +/*
> + * Arbitrary set max. allowed bank number. Required for sorting banks and
> + * currently is overkill with just 2 banks used at max, but for the sake
> + * of alignment let's set it to a higher value

Check grammar everywhere, again missed period (at least).

> + */

...

> +#define ACPI_DELAY_MSEC_LOCK   500     /* Wait for 0.5 s max. to acquire the lock */

_LOCK_DELAY_MS and drop useless comment

I think I gave the very same comments before. Maybe you can check the
reviews of another driver?

...


> +#define MAKE_SENSOR_ADDRESS(size, bank, index)                                 \
> +       {                                                                      \
> +               .value = (size << 16) + (bank << 8) + index                    \

Leave comma here and everywhere else in the structure entries.

> +       }

Besides that, would it be better to have it defined as a compound literal?

...

> +enum known_ec_sensor {
> +       SENSOR_TEMP_CHIPSET     = 1 <<  0, /* chipset temperature [℃] */
> +       SENSOR_TEMP_CPU         = 1 <<  1, /* CPU temperature [℃] */
> +       SENSOR_TEMP_MB          = 1 <<  2, /* motherboard temperature [℃] */
> +       SENSOR_TEMP_T_SENSOR    = 1 <<  3, /* "T_Sensor" temperature sensor reading [℃] */
> +       SENSOR_TEMP_VRM         = 1 <<  4, /* VRM temperature [℃] */
> +       SENSOR_FAN_CPU_OPT      = 1 <<  5, /* CPU_Opt fan [RPM] */
> +       SENSOR_FAN_VRM_HS       = 1 <<  6, /* VRM heat sink fan [RPM] */
> +       SENSOR_FAN_CHIPSET      = 1 <<  7, /* chipset fan [RPM] */
> +       SENSOR_FAN_WATER_FLOW   = 1 <<  8, /* water flow sensor reading [RPM] */
> +       SENSOR_CURR_CPU         = 1 <<  9, /* CPU current [A] */
> +       SENSOR_TEMP_WATER_IN    = 1 << 10, /* "Water_In" temperature sensor reading [℃] */
> +       SENSOR_TEMP_WATER_OUT   = 1 << 11, /* "Water_Out" temperature sensor reading [℃] */

Perhaps kernel doc and use of BIT()?

> +       SENSOR_END
> +};

...

> +static const struct ec_sensor_info known_ec_sensors[] = {
> +       EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a), /* SENSOR_TEMP_CHIPSET */
> +       EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b), /* SENSOR_TEMP_CPU */
> +       EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c), /* SENSOR_TEMP_MB */
> +       EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d), /* SENSOR_TEMP_T_SENSOR */
> +       EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e), /* SENSOR_TEMP_VRM */
> +       EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0), /* SENSOR_FAN_CPU_OPT */
> +       EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2), /* SENSOR_FAN_VRM_HS */
> +       EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4), /* SENSOR_FAN_CHIPSET */
> +       EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc), /* SENSOR_FAN_WATER_FLOW */
> +       EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4), /* SENSOR_CURR_CPU */
> +       EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00), /* SENSOR_TEMP_WATER_IN */
> +       EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01), /* SENSOR_TEMP_WATER_OUT */

Instead of comments, use form of

  [FOO] = BAR(...),

> +};

...

> +static struct asus_ec_board_info board_P_X570_P = {
> +       .sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB | SENSOR_TEMP_VRM
> +                | SENSOR_FAN_CHIPSET,

It's a bit long and better to leave ' |' on the previous line(s).

> +       .acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX

+ Comma.

> +};

Ditto for all other similar cases.

...

> +#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {                         \
> +               .matches = {                                                   \
> +                       DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),             \
> +                       DMI_EXACT_MATCH(DMI_BOARD_NAME, name),                 \
> +               },                                                             \
> +               .driver_data = sensors                                         \

+ Comma.

> +       }

...

> +struct ec_sensors_data {
> +       const struct asus_ec_board_info *board;
> +       struct ec_sensor *sensors;
> +       /* EC registers to read from */
> +       u16 *registers;
> +       u8 *read_buffer;
> +       /* sorted list of unique register banks */
> +       u8 banks[ASUS_EC_MAX_BANK];
> +       unsigned long last_updated; /* in jiffies */
> +       acpi_handle aml_mutex;
> +       u8 nr_sensors; /* number of board EC sensors */
> +       /* number of EC registers to read (sensor might span more than 1 register) */
> +       u8 nr_registers;
> +       u8 nr_banks; /* number of unique register banks */
> +};

Kernel doc?

...

> +static u8 register_bank(u16 reg)
> +{
> +       return (reg & 0xff00) >> 8;

' & 0xff00' part is redundant.

> +}

...

> +static struct ec_sensors_data *get_sensor_data(struct device *pdev)
> +{
> +       return dev_get_drvdata(pdev);
> +}

Useless wrapper. It adds no value.

...

> +       unsigned int i;
> +
> +       for (i = 0; i < ec->nr_sensors; ++i) {
> +               if (get_sensor_info(ec, i)->type == type) {
> +                       if (channel == 0)
> +                               return i;

> +                       --channel;

What's wrong with post-decrement, and I think I already commented on this.
So, I stopped here until you go and enforce all comments given against
previous incarnation of this driver.

> +               }
> +       }
> +       return -ENOENT;
> +}

...

> +       for (i = 1; i < SENSOR_END; i <<= 1) {
> +               if ((i & ec->board->sensors) == 0
> +                       continue;

Interesting way of NIH for_each_set_bit().

...

> +               for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {

Why pre-increments?

> +                       ec->registers[register_idx] =
> +                               (si->addr.components.bank << 8) +
> +                               si->addr.components.index + j;
> +               }
> +       }
> +}

...

> +       acpi_handle res;

> +       acpi_status status = acpi_get_handle(
> +               NULL, (acpi_string)state->board->acpi_mutex_path, &res);

It looks awful (indentation), Have you run checkpatch?

> +       if (ACPI_FAILURE(status)) {
> +               dev_err(dev, "Could not get hardware access guard mutex: error %d", status);
> +               return NULL;
> +       }

...

> +static struct hwmon_chip_info asus_wmi_chip_info = {
> +       .ops = &asus_ec_hwmon_ops,

> +       .info = NULL,

Redundant.

> +};

-- 
With Best Regards,
Andy Shevchenko

[PATCH 1/3] hwmon: (asus-ec-sensors) add driver for ASUS EC

[Eugene Shalygin]

This driver provides the same data as the asus_wmi_ec_sensors driver
(and gets it from the same source) but does not use WMI, polling
the ACPI EC directly.

That provides two enhancements: sensor reading became quicker (on some
systems or kernel configuration it took almost a full second to read
all the sensors, that transfers less than 15 bytes of data), the driver
became more fexible. The driver now relies on ACPI mutex to lock access
to the EC, in the same way as the WMI DSDT code does.

Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
---
 drivers/hwmon/Kconfig           |  12 +
 drivers/hwmon/Makefile          |   1 +
 drivers/hwmon/asus-ec-sensors.c | 753 ++++++++++++++++++++++++++++++++
 3 files changed, 766 insertions(+)
 create mode 100644 drivers/hwmon/asus-ec-sensors.c

diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 43e5245874ad..c2227118b23a 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -2253,6 +2253,18 @@ config SENSORS_ASUS_WMI_EC
 	  This driver can also be built as a module. If so, the module
 	  will be called asus_wmi_sensors_ec.
 
+config SENSORS_ASUS_EC
+	tristate "ASUS EC Sensors"
+	depends on ACPI
+	help
+	  If you say yes here you get support for the ACPI embedded controller
+	  hardware monitoring interface found in ASUS motherboards. The driver
+	  currently supports B550/X570 boards, although other ASUS boards might
+	  provide this monitoring interface as well.
+
+	  This driver can also be built as a module. If so, the module
+	  will be called asus_ec_sensors.
+
 endif # ACPI
 
 endif # HWMON
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 3a1551b3d570..2e5c216bb5d7 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_HWMON_VID)		+= hwmon-vid.o
 # APCI drivers
 obj-$(CONFIG_SENSORS_ACPI_POWER) += acpi_power_meter.o
 obj-$(CONFIG_SENSORS_ATK0110)	+= asus_atk0110.o
+obj-$(CONFIG_SENSORS_ASUS_EC)	+= asus-ec-sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI)	+= asus_wmi_sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
 
diff --git a/drivers/hwmon/asus-ec-sensors.c b/drivers/hwmon/asus-ec-sensors.c
new file mode 100644
index 000000000000..dff717017ee3
--- /dev/null
+++ b/drivers/hwmon/asus-ec-sensors.c
@@ -0,0 +1,753 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * HWMON driver for ASUS motherboards that publish some sensor values
+ * via the embedded controller registers
+ *
+ * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
+
+ * EC provides:
+ * - Chipset temperature
+ * - CPU temperature
+ * - Motherboard temperature
+ * - T_Sensor temperature
+ * - VRM temperature
+ * - Water In temperature
+ * - Water Out temperature
+ * - CPU Optional fan RPM
+ * - Chipset fan RPM
+ * - VRM Heat Sink fan RPM
+ * - Water Flow fan RPM
+ * - CPU current
+ */
+
+#include <linux/acpi.h>
+#include <linux/dev_printk.h>
+#include <linux/dmi.h>
+#include <linux/hwmon.h>
+#include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/sort.h>
+#include <linux/units.h>
+
+#include <asm/unaligned.h>
+
+#define ASUS_EC_BANK_REGISTER 0xff /* Writing to this EC register switches EC bank */
+#define SENSOR_LABEL_LEN 0x10
+/*
+ * Arbitrary set max. allowed bank number. Required for sorting banks and
+ * currently is overkill with just 2 banks used at max, but for the sake
+ * of alignment let's set it to a higher value
+ */
+#define ASUS_EC_MAX_BANK 0x04
+
+#define ACPI_DELAY_MSEC_LOCK	500	/* Wait for 0.5 s max. to acquire the lock */
+
+/* ACPI mutex for locking access to the EC for the firmware */
+#define ASUS_HW_ACCESS_MUTEX_ASMX	"\\AMW0.ASMX"
+
+/* There are two variants of the vendor spelling */
+#define VENDOR_ASUS_UPPER_CASE	"ASUSTeK COMPUTER INC."
+
+typedef union {
+	u32 value;
+	struct {
+		u8 index;
+		u8 bank;
+		u8 size;
+		u8 dummy;
+	} components;
+} sensor_address;
+
+#define MAKE_SENSOR_ADDRESS(size, bank, index)                                 \
+	{                                                                      \
+		.value = (size << 16) + (bank << 8) + index                    \
+	}
+
+static u32 hwmon_attributes[hwmon_max] = {
+	[hwmon_chip] = HWMON_C_REGISTER_TZ,
+	[hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
+	[hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
+	[hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
+	[hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
+};
+
+struct ec_sensor_info {
+	char label[SENSOR_LABEL_LEN];
+	enum hwmon_sensor_types type;
+	sensor_address addr;
+};
+
+#define EC_SENSOR(sensor_label, sensor_type, size, bank, index)                \
+	{                                                                      \
+		.label = sensor_label, .type = sensor_type,                    \
+		.addr = MAKE_SENSOR_ADDRESS(size, bank, index)                 \
+	}
+
+enum known_ec_sensor {
+	SENSOR_TEMP_CHIPSET	= 1 <<  0, /* chipset temperature [℃] */
+	SENSOR_TEMP_CPU		= 1 <<  1, /* CPU temperature [℃] */
+	SENSOR_TEMP_MB		= 1 <<  2, /* motherboard temperature [℃] */
+	SENSOR_TEMP_T_SENSOR	= 1 <<  3, /* "T_Sensor" temperature sensor reading [℃] */
+	SENSOR_TEMP_VRM		= 1 <<  4, /* VRM temperature [℃] */
+	SENSOR_FAN_CPU_OPT	= 1 <<  5, /* CPU_Opt fan [RPM] */
+	SENSOR_FAN_VRM_HS	= 1 <<  6, /* VRM heat sink fan [RPM] */
+	SENSOR_FAN_CHIPSET	= 1 <<  7, /* chipset fan [RPM] */
+	SENSOR_FAN_WATER_FLOW	= 1 <<  8, /* water flow sensor reading [RPM] */
+	SENSOR_CURR_CPU		= 1 <<  9, /* CPU current [A] */
+	SENSOR_TEMP_WATER_IN	= 1 << 10, /* "Water_In" temperature sensor reading [℃] */
+	SENSOR_TEMP_WATER_OUT	= 1 << 11, /* "Water_Out" temperature sensor reading [℃] */
+	SENSOR_END
+};
+
+/*
+ * All the known sensors for ASUS EC controllers
+ */
+static const struct ec_sensor_info known_ec_sensors[] = {
+	EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a), /* SENSOR_TEMP_CHIPSET */
+	EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b), /* SENSOR_TEMP_CPU */
+	EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c), /* SENSOR_TEMP_MB */
+	EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d), /* SENSOR_TEMP_T_SENSOR */
+	EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e), /* SENSOR_TEMP_VRM */
+	EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0), /* SENSOR_FAN_CPU_OPT */
+	EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2), /* SENSOR_FAN_VRM_HS */
+	EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4), /* SENSOR_FAN_CHIPSET */
+	EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc), /* SENSOR_FAN_WATER_FLOW */
+	EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4), /* SENSOR_CURR_CPU */
+	EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00), /* SENSOR_TEMP_WATER_IN */
+	EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01), /* SENSOR_TEMP_WATER_OUT */
+};
+
+struct asus_ec_board_info {
+	int sensors;
+	const char *acpi_mutex_path;
+};
+
+static struct asus_ec_board_info board_P_X570_P = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB | SENSOR_TEMP_VRM
+		 | SENSOR_FAN_CHIPSET,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_PW_X570_A = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB | SENSOR_TEMP_VRM
+		| SENSOR_FAN_CHIPSET
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_R_C8H = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB
+		| SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM
+		| SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT
+		| SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET | SENSOR_FAN_WATER_FLOW
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+/* Same as Hero but without chipset fan */
+static struct asus_ec_board_info board_R_C8DH = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB
+		| SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM
+		| SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT
+		| SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+/* Same as Hero but without water */
+static struct asus_ec_board_info board_R_C8F = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB
+		| SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM
+		| SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_R_C8I = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB |
+		SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM |
+		SENSOR_FAN_CHIPSET |
+		SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_RS_B550_E_G = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB
+		| SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM
+		| SENSOR_FAN_CPU_OPT,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_RS_B550_I_G = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB
+		| SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM
+		| SENSOR_FAN_VRM_HS
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_RS_X570_E_G = {
+	.sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB
+		| SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM
+		| SENSOR_FAN_CHIPSET
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+static struct asus_ec_board_info board_RS_X570_I_G = {
+	.sensors = SENSOR_TEMP_T_SENSOR
+		| SENSOR_FAN_VRM_HS | SENSOR_FAN_CHIPSET
+		| SENSOR_CURR_CPU,
+	.acpi_mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX
+};
+
+#define DMI_EXACT_MATCH_BOARD(vendor, name, sensors) {                         \
+		.matches = {                                                   \
+			DMI_EXACT_MATCH(DMI_BOARD_VENDOR, vendor),             \
+			DMI_EXACT_MATCH(DMI_BOARD_NAME, name),                 \
+		},                                                             \
+		.driver_data = sensors                                         \
+	}
+
+static const struct dmi_system_id asus_ec_dmi_table[] __initconst = {
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "PRIME X570-PRO", &board_P_X570_P),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "Pro WS X570-ACE", &board_PW_X570_A),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII DARK HERO", &board_R_C8DH),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII FORMULA", &board_R_C8F),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII HERO", &board_R_C8H),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG CROSSHAIR VIII IMPACT", &board_R_C8I),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG STRIX B550-E GAMING", &board_RS_B550_E_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG STRIX B550-I GAMING", &board_RS_B550_I_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG STRIX X570-E GAMING", &board_RS_X570_E_G),
+	DMI_EXACT_MATCH_BOARD(VENDOR_ASUS_UPPER_CASE,
+			      "ROG STRIX X570-I GAMING", &board_RS_X570_I_G),
+	{}
+};
+
+struct ec_sensor {
+	unsigned int info_index;
+	u32 cached_value;
+};
+
+struct ec_sensors_data {
+	const struct asus_ec_board_info *board;
+	struct ec_sensor *sensors;
+	/* EC registers to read from */
+	u16 *registers;
+	u8 *read_buffer;
+	/* sorted list of unique register banks */
+	u8 banks[ASUS_EC_MAX_BANK];
+	unsigned long last_updated; /* in jiffies */
+	acpi_handle aml_mutex;
+	u8 nr_sensors; /* number of board EC sensors */
+	/* number of EC registers to read (sensor might span more than 1 register) */
+	u8 nr_registers;
+	u8 nr_banks; /* number of unique register banks */
+};
+
+static u8 register_bank(u16 reg)
+{
+	return (reg & 0xff00) >> 8;
+}
+
+static struct ec_sensors_data *get_sensor_data(struct device *pdev)
+{
+	return dev_get_drvdata(pdev);
+}
+
+static const struct ec_sensor_info *
+get_sensor_info(const struct ec_sensors_data *state, int index)
+{
+	return &known_ec_sensors[state->sensors[index].info_index];
+}
+
+static int find_ec_sensor_index(const struct ec_sensors_data *ec,
+				enum hwmon_sensor_types type, int channel)
+{
+	unsigned int i;
+
+	for (i = 0; i < ec->nr_sensors; ++i) {
+		if (get_sensor_info(ec, i)->type == type) {
+			if (channel == 0)
+				return i;
+			--channel;
+		}
+	}
+	return -ENOENT;
+}
+
+static int __init bank_compare(const void *a, const void *b)
+{
+	return *((const s8 *)a) - *((const s8 *)b);
+}
+
+static int __init board_sensors_count(const struct asus_ec_board_info *board)
+{
+	return hweight_long(board->sensors);
+}
+
+static void __init setup_sensor_data(struct ec_sensors_data *ec)
+{
+	struct ec_sensor *s = ec->sensors;
+	bool bank_found;
+	int i, j;
+	u8 bank;
+
+	ec->nr_banks = 0;
+	ec->nr_registers = 0;
+
+	for (i = 1; i < SENSOR_END; i <<= 1) {
+		if ((i & ec->board->sensors) == 0)
+			continue;
+		s->info_index = __builtin_ctz(i);
+		s->cached_value = 0;
+		ec->nr_registers +=
+			known_ec_sensors[s->info_index].addr.components.size;
+		bank_found = false;
+		bank = known_ec_sensors[s->info_index].addr.components.bank;
+		for (j = 0; j < ec->nr_banks; j++) {
+			if (ec->banks[j] == bank) {
+				bank_found = true;
+				break;
+			}
+		}
+		if (!bank_found) {
+			ec->banks[ec->nr_banks++] = bank;
+		}
+		s++;
+	}
+	sort(ec->banks, ec->nr_banks, 1, &bank_compare, NULL);
+}
+
+static void __init fill_ec_registers(struct ec_sensors_data *ec)
+{
+	const struct ec_sensor_info *si;
+	unsigned int i, j, register_idx = 0;
+	for (i = 0; i < ec->nr_sensors; ++i) {
+		si = get_sensor_info(ec, i);
+		for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {
+			ec->registers[register_idx] =
+				(si->addr.components.bank << 8) +
+				si->addr.components.index + j;
+		}
+	}
+}
+
+static int get_version(u32 *version)
+{
+	/* we know only a single version so far */
+	*version = 0;
+	return 0;
+}
+
+static acpi_handle asus_hw_access_mutex(struct device *dev)
+{
+	struct ec_sensors_data *state = get_sensor_data(dev);
+	acpi_handle res;
+	acpi_status status = acpi_get_handle(
+		NULL, (acpi_string)state->board->acpi_mutex_path, &res);
+	if (ACPI_FAILURE(status)) {
+		dev_err(dev, "Could not get hardware access guard mutex: error %d", status);
+		return NULL;
+	}
+	return res;
+}
+
+/*
+ * Switches ASUS EC banks.
+ */
+static int asus_ec_bank_switch(u8 bank, u8 *old)
+{
+	int status = 0;
+
+	if (old) {
+		status = ec_read(ASUS_EC_BANK_REGISTER, old);
+	}
+	if (status || (old && (*old == bank)))
+		return status;
+	return ec_write(ASUS_EC_BANK_REGISTER, bank);
+}
+
+static int asus_ec_block_read(const struct device *dev,
+			     struct ec_sensors_data *ec)
+{
+	int ireg, ibank, status;
+	u8 bank, reg_bank, prev_bank;
+
+	bank = 0;
+	status = asus_ec_bank_switch(bank, &prev_bank);
+	if (status) {
+		dev_warn(dev, "EC bank switch failed");
+		return status;
+	}
+
+	if (prev_bank) {
+		/* oops... somebody else is working with the EC too */
+		dev_warn(dev, "Concurrent access to the ACPI EC "
+			"detected.\nRace condition possible.");
+	}
+
+	/*
+	 * read registers minimizing bank switches.
+	 */
+	for (ibank = 0; ibank < ec->nr_banks; ibank++) {
+		if (bank != ec->banks[ibank]) {
+			bank = ec->banks[ibank];
+			if (asus_ec_bank_switch(bank, NULL)) {
+				dev_warn(dev, "EC bank switch to %d failed", bank);
+				break;
+			}
+		}
+		for (ireg = 0; ireg < ec->nr_registers; ireg++) {
+			reg_bank = register_bank(ec->registers[ireg]);
+			if (reg_bank < bank) {
+				continue;
+			}
+			ec_read(ec->registers[ireg] & 0x00ff, ec->read_buffer + ireg);
+		}
+	}
+
+	status = asus_ec_bank_switch(prev_bank, NULL);
+	return status;
+}
+
+static inline u32 get_sensor_value(const struct ec_sensor_info *si, u8 *data)
+{
+	switch (si->addr.components.size) {
+	case 1:
+		return *data;
+	case 2:
+		return get_unaligned_be16(data);
+	case 4:
+		return get_unaligned_be32(data);
+	default:
+		return 0;
+	}
+}
+
+static void update_sensor_values(struct ec_sensors_data *ec, u8 *data)
+{
+	const struct ec_sensor_info *si;
+	struct ec_sensor *s;
+
+	for (s = ec->sensors; s != ec->sensors + ec->nr_sensors; s++) {
+		si = &known_ec_sensors[s->info_index];
+		s->cached_value = get_sensor_value(si, data);
+		data += si->addr.components.size;
+	}
+}
+
+static int update_ec_sensors(const struct device *dev,
+			     struct ec_sensors_data *ec)
+{
+	int status;
+
+	/*
+	 * ASUS DSDT does not specify that access to the EC has to be guarded,
+	 * but firmware does access it via ACPI
+	 */
+	if (ACPI_FAILURE(acpi_acquire_mutex(ec->aml_mutex, NULL, ACPI_DELAY_MSEC_LOCK))) {
+		dev_err(dev, "Failed to acquire AML mutex");
+		status = -EBUSY;
+		goto cleanup;
+	}
+
+	status = asus_ec_block_read(dev, ec);
+
+	if (!status) {
+		update_sensor_values(ec, ec->read_buffer);
+	}
+	if (ACPI_FAILURE(acpi_release_mutex(ec->aml_mutex, NULL))) {
+		dev_err(dev, "Failed to release AML mutex");
+	}
+cleanup:
+	return status;
+}
+
+static int scale_sensor_value(u32 value, int data_type)
+{
+	switch (data_type) {
+	case hwmon_curr:
+	case hwmon_temp:
+	case hwmon_in:
+		return value * MILLI;
+	default:
+		return value;
+	}
+}
+
+static int get_cached_value_or_update(const struct device *dev,
+				      int sensor_index,
+				      struct ec_sensors_data *state, u32 *value)
+{
+	if (time_after(jiffies, state->last_updated + HZ)) {
+		if (update_ec_sensors(dev, state)) {
+			dev_err(dev, "update_ec_sensors() failure\n");
+			return -EIO;
+		}
+
+		state->last_updated = jiffies;
+	}
+
+	*value = state->sensors[sensor_index].cached_value;
+	return 0;
+}
+
+/*
+ * Now follow the functions that implement the hwmon interface
+ */
+
+static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
+			       u32 attr, int channel, long *val)
+{
+	int ret;
+	u32 value = 0;
+
+	struct ec_sensors_data *state = get_sensor_data(dev);
+	int sidx = find_ec_sensor_index(state, type, channel);
+
+	if (sidx < 0) {
+		return sidx;
+	}
+
+	ret = get_cached_value_or_update(dev, sidx, state, &value);
+	if (!ret) {
+		*val = scale_sensor_value(value,
+					  get_sensor_info(state, sidx)->type);
+	}
+
+	return ret;
+}
+
+static int asus_ec_hwmon_read_string(struct device *dev,
+				      enum hwmon_sensor_types type, u32 attr,
+				      int channel, const char **str)
+{
+	struct ec_sensors_data *state = get_sensor_data(dev);
+	int sensor_index = find_ec_sensor_index(state, type, channel);
+	*str = get_sensor_info(state, sensor_index)->label;
+
+	return 0;
+}
+
+static umode_t asus_ec_hwmon_is_visible(const void *drvdata,
+					 enum hwmon_sensor_types type, u32 attr,
+					 int channel)
+{
+	const struct ec_sensors_data *state = drvdata;
+
+	return find_ec_sensor_index(state, type, channel) >= 0 ?
+			     S_IRUGO :
+			     0;
+}
+
+static int
+asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info *asus_wmi_hwmon_chan,
+			     struct device *dev, int num,
+			     enum hwmon_sensor_types type, u32 config)
+{
+	int i;
+	u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
+
+	if (!cfg)
+		return -ENOMEM;
+
+	asus_wmi_hwmon_chan->type = type;
+	asus_wmi_hwmon_chan->config = cfg;
+	for (i = 0; i < num; i++, cfg++)
+		*cfg = config;
+
+	return 0;
+}
+
+static const struct hwmon_ops asus_ec_hwmon_ops = {
+	.is_visible = asus_ec_hwmon_is_visible,
+	.read = asus_ec_hwmon_read,
+	.read_string = asus_ec_hwmon_read_string,
+};
+
+static struct hwmon_chip_info asus_wmi_chip_info = {
+	.ops = &asus_ec_hwmon_ops,
+	.info = NULL,
+};
+
+static const struct asus_ec_board_info * __init get_board_info(const struct device *dev)
+{
+	const struct dmi_system_id *dmi_entry;
+	u32 version = 0;
+
+	dmi_entry = dmi_first_match(asus_ec_dmi_table);
+	if (!dmi_entry) {
+		dev_info(dev, "Unsupported board");
+		return NULL;
+	}
+
+	if (get_version(&version)) {
+		dev_err(dev, "Error getting version");
+		return NULL;
+	}
+
+	return dmi_entry->driver_data;
+}
+
+static int __init configure_sensor_setup(struct platform_device *pdev)
+{
+	struct ec_sensors_data *ec_data = platform_get_drvdata(pdev);
+	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
+	struct device *hwdev;
+	struct device *dev = &pdev->dev;
+	struct hwmon_channel_info *asus_wmi_hwmon_chan;
+	const struct hwmon_channel_info **ptr_asus_wmi_ci;
+	const struct hwmon_chip_info *chip_info;
+	const struct ec_sensor_info *si;
+	enum hwmon_sensor_types type;
+	unsigned int i;
+
+	ec_data->board = get_board_info(dev);
+	if (!ec_data->board) {
+		return -ENODEV;
+	}
+
+	ec_data->nr_sensors = board_sensors_count(ec_data->board);
+	ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors,
+					sizeof(struct ec_sensor), GFP_KERNEL);
+
+	setup_sensor_data(ec_data);
+	ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers,
+		sizeof(u16), GFP_KERNEL);
+	ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers,
+		sizeof(u8), GFP_KERNEL);
+
+	if (!ec_data->registers || !ec_data->read_buffer) {
+		return -ENOMEM;
+	}
+
+	fill_ec_registers(ec_data);
+
+	ec_data->aml_mutex = asus_hw_access_mutex(dev);
+
+	for (i = 0; i < ec_data->nr_sensors; ++i) {
+		si = get_sensor_info(ec_data, i);
+		if (!nr_count[si->type])
+			++nr_types;
+		++nr_count[si->type];
+	}
+
+	if (nr_count[hwmon_temp])
+		nr_count[hwmon_chip]++, nr_types++;
+
+	asus_wmi_hwmon_chan = devm_kcalloc(
+		dev, nr_types, sizeof(*asus_wmi_hwmon_chan), GFP_KERNEL);
+	if (!asus_wmi_hwmon_chan)
+		return -ENOMEM;
+
+	ptr_asus_wmi_ci = devm_kcalloc(dev, nr_types + 1,
+				       sizeof(*ptr_asus_wmi_ci), GFP_KERNEL);
+	if (!ptr_asus_wmi_ci)
+		return -ENOMEM;
+
+	asus_wmi_chip_info.info = ptr_asus_wmi_ci;
+	chip_info = &asus_wmi_chip_info;
+
+	for (type = 0; type < hwmon_max; ++type) {
+		if (!nr_count[type])
+			continue;
+
+		asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan, dev,
+					     nr_count[type], type,
+					     hwmon_attributes[type]);
+		*ptr_asus_wmi_ci++ = asus_wmi_hwmon_chan++;
+	}
+
+	dev_info(dev, "board has %d EC sensors that span %d registers",
+		 ec_data->nr_sensors,
+		 ec_data->nr_registers);
+
+	hwdev = devm_hwmon_device_register_with_info(
+		dev, "asus-ec-sensors", ec_data, chip_info, NULL);
+
+	return PTR_ERR_OR_ZERO(hwdev);
+}
+
+static struct platform_device *asus_ec_sensors_platform_device;
+
+static int asus_ec_probe(struct platform_device *pdev)
+{
+	struct ec_sensors_data *state = platform_get_drvdata(pdev);
+
+	if (state->board < 0) {
+		return -ENODEV;
+	}
+
+	return 0;
+}
+
+static struct platform_driver asus_ec_sensors_platform_driver = {
+	.driver = {
+		.name	= "asus-ec-sensors",
+	},
+	.probe		= asus_ec_probe
+};
+
+MODULE_DEVICE_TABLE(dmi, asus_ec_dmi_table);
+
+static void cleanup_device(void)
+{
+	platform_device_unregister(asus_ec_sensors_platform_device);
+	platform_driver_unregister(&asus_ec_sensors_platform_driver);
+}
+
+static int __init asus_ec_init(void)
+{
+	struct asus_ec_sensors *state;
+	int status = 0;
+
+	asus_ec_sensors_platform_device =
+		platform_create_bundle(&asus_ec_sensors_platform_driver,
+				       asus_ec_probe, NULL, 0, NULL, 0);
+
+	if (IS_ERR(asus_ec_sensors_platform_device))
+		return PTR_ERR(asus_ec_sensors_platform_device);
+
+	state = devm_kzalloc(&asus_ec_sensors_platform_device->dev,
+			     sizeof(struct ec_sensors_data), GFP_KERNEL);
+
+	if (!state) {
+		status = -ENOMEM;
+		goto cleanup;
+	}
+
+	platform_set_drvdata(asus_ec_sensors_platform_device, state);
+	status = configure_sensor_setup(asus_ec_sensors_platform_device);
+cleanup:
+	if (status) {
+		cleanup_device();
+	}
+	return status;
+}
+
+static void __exit asus_ec_exit(void)
+{
+	cleanup_device();
+}
+
+module_init(asus_ec_init);
+module_exit(asus_ec_exit);
+
+MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
+MODULE_DESCRIPTION(
+	"HWMON driver for sensors accessible via EC in ASUS motherboards");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("1");
-- 
2.34.1