[PATCH v2 0/3] [PATCH v2 0/3] Update ASUS WMI supported boards

[PATCH v2 0/3] [PATCH v2 0/3] Update ASUS WMI supported boards

[Denis Pauk]

Add support to nct6775:
* PRIME B360-PLUS
* PRIME X570-PRO
* ROG CROSSHAIR VIII FORMULA
* ROG STRIX B550-I GAMING
* ROG STRIX X570-F GAMING
* ROG STRIX Z390-E GAMING
* TUF GAMING B550-PRO
* TUF GAMING Z490-PLUS
* TUF GAMING Z490-PLUS (WI-FI)

Add support by WMI interface privided by Asus for B550/X570 boards: 
* ROG CROSSHAIR VIII HERO
* ROG CROSSHAIR VIII DARK HERO
* ROG CROSSHAIR VIII FORMULA
* ROG STRIX X570-E GAMING
* ROG STRIX B550-E GAMING

Add support by WMI interface privided by Asus for X370/X470/
B450/X399 boards:
* ROG CROSSHAIR VI HERO,
* PRIME X399-A,
* PRIME X470-PRO,
* ROG CROSSHAIR VI EXTREME,
* ROG CROSSHAIR VI HERO (WI-FI AC),
* ROG CROSSHAIR VII HERO,
* ROG CROSSHAIR VII HERO (WI-FI),
* ROG STRIX B450-E GAMING,
* ROG STRIX B450-F GAMING,
* ROG STRIX B450-I GAMING,
* ROG STRIX X399-E GAMING,
* ROG STRIX X470-F GAMING,
* ROG STRIX X470-I GAMING,
* ROG ZENITH EXTREME,
* ROG ZENITH EXTREME ALPHA.

Could you please review?

BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
Signed-off-by: Ed Brindley <kernel@maidavale.org>
Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>

---
Changes in v2:
 - asus_wmi_ec_sensors: Rename asus_wmi_sensors to asus_wmi_ec_sensors for 
   B550/X570 boards.
 - asus_wmi_ec_sensors: Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade 
   fuctions.
 - asus_wmi_ec_sensors: Use post increment.
 - asus_wmi_ec_sensors: Use get_unaligned* for convert values.
 - asus_wmi_ec_sensors: Use PTR_ERR_OR_ZERO.
 - asus_wmi_ec_sensors: Specify per-board sensors in a declarative way 
   (by Eugene Shalygin).
 - asus_wmi_sensors: Add support for X370/X470/B450/X399 boards.

Denis Pauk (3):
  hwmon: (nct6775) Add additional ASUS motherboards
  hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.
  hwmon: (asus_wmi_sensors) Support X370 Asus WMI.

 MAINTAINERS                         |   8 +
 drivers/hwmon/Kconfig               |  24 +-
 drivers/hwmon/Makefile              |   2 +
 drivers/hwmon/asus_wmi_ec_sensors.c | 631 ++++++++++++++++++++++++++
 drivers/hwmon/asus_wmi_sensors.c    | 661 ++++++++++++++++++++++++++++
 drivers/hwmon/nct6775.c             |   9 +
 6 files changed, 1334 insertions(+), 1 deletion(-)
 create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
 create mode 100644 drivers/hwmon/asus_wmi_sensors.c


base-commit: 0889b7c73a4d8eaaa321eafcf66835979ead862a
-- 
2.33.0

[PATCH v2 1/3] hwmon: (nct6775) Add additional ASUS motherboards

[Denis Pauk]

Add support:
* PRIME B360-PLUS
* PRIME X570-PRO
* ROG CROSSHAIR VIII FORMULA
* ROG STRIX B550-I GAMING
* ROG STRIX X570-F GAMING
* ROG STRIX Z390-E GAMING
* TUF GAMING B550-PRO
* TUF GAMING Z490-PLUS
* TUF GAMING Z490-PLUS (WI-FI)

BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
Tested-by: matt-testalltheway <sefoci9222@rerunway.com>
Tested-by: Kamil Dudka <kdudka@redhat.com>
Tested-by: Robert Swiecki <robert@swiecki.net>
Tested-by: Kamil Pietrzak <kpietrzak@disroot.org>
Tested-by: Igor <igor@svelig.com>
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
---
Changes in v2:
  - Without changes.
---
 drivers/hwmon/nct6775.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/drivers/hwmon/nct6775.c b/drivers/hwmon/nct6775.c
index aa58ead0ad43..8eaf86ea2433 100644
--- a/drivers/hwmon/nct6775.c
+++ b/drivers/hwmon/nct6775.c
@@ -4986,20 +4986,29 @@ static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data)
 static struct platform_device *pdev[2];
 
 static const char * const asus_wmi_boards[] = {
+	"PRIME B360-PLUS",
 	"PRIME B460-PLUS",
+	"PRIME X570-PRO",
 	"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-F GAMING",
 	"ROG STRIX B550-F GAMING (WI-FI)",
+	"ROG STRIX B550-I GAMING",
+	"ROG STRIX X570-F GAMING",
+	"ROG STRIX Z390-E GAMING",
 	"ROG STRIX Z490-I GAMING",
 	"TUF GAMING B550M-PLUS",
 	"TUF GAMING B550M-PLUS (WI-FI)",
 	"TUF GAMING B550-PLUS",
+	"TUF GAMING B550-PRO",
 	"TUF GAMING X570-PLUS",
 	"TUF GAMING X570-PLUS (WI-FI)",
 	"TUF GAMING X570-PRO (WI-FI)",
+	"TUF GAMING Z490-PLUS",
+	"TUF GAMING Z490-PLUS (WI-FI)",
 };
 
 static int __init sensors_nct6775_init(void)
-- 
2.33.0

[PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Denis Pauk]

Linux HWMON sensors driver for ASUS motherboards to read
sensors from the embedded controller.

Many ASUS motherboards do not publish all the available
sensors via the Super I/O chip but the missing ones are
available through the embedded controller (EC) registers.

This driver implements reading those sensor data via the
WMI method BREC, which is known to be present in all ASUS
motherboards based on the AMD 500 series chipsets (and
probably is available in other models too). The driver
needs to know exact register addresses for the sensors and
thus support for each motherboard has to be added explicitly.

The EC registers do not provide critical values for the
sensors and as such they are not published to the HWMON.

Supported motherboards:
* ROG CROSSHAIR VIII HERO
* ROG CROSSHAIR VIII DARK HERO
* ROG CROSSHAIR VIII FORMULA
* ROG STRIX X570-E GAMING
* ROG STRIX B550-E GAMING

BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>

---
Changes in v2:
 - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
 - Use post increment.
 - Use get_unaligned* for convert values.
 - Use PTR_ERR_OR_ZERO.
 - Specify per-board sensors in a declarative way (by Eugene Shalygin).
---
 MAINTAINERS                         |   7 +
 drivers/hwmon/Kconfig               |  13 +-
 drivers/hwmon/Makefile              |   1 +
 drivers/hwmon/asus_wmi_ec_sensors.c | 631 ++++++++++++++++++++++++++++
 4 files changed, 651 insertions(+), 1 deletion(-)
 create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c

diff --git a/MAINTAINERS b/MAINTAINERS
index bae3f62f548f..bc2e981a54e2 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2937,6 +2937,13 @@ W:	http://acpi4asus.sf.net
 F:	drivers/platform/x86/asus*.c
 F:	drivers/platform/x86/eeepc*.c
 
+ASUS WMI 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 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 7fde4c6e1e7f..b7107721a401 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
 
 config SENSORS_AMC6821
 	tristate "Texas Instruments AMC6821"
-	depends on I2C 
+	depends on I2C
 	help
 	  If you say yes here you get support for the Texas Instruments
 	  AMC6821 hardware monitoring chips.
@@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
 	  This driver can also be built as a module. If so, the module
 	  will be called asus_atk0110.
 
+config SENSORS_ASUS_WMI_EC
+	tristate "ASUS WMI B550/X570"
+	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.
+
 endif # ACPI
 
 endif # HWMON
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index baee6a8d4dd1..aae2ff5c7335 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_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
new file mode 100644
index 000000000000..553d9ee8656d
--- /dev/null
+++ b/drivers/hwmon/asus_wmi_ec_sensors.c
@@ -0,0 +1,631 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * 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 provided:
+ * Chipset temperature,
+ * CPU temperature,
+ * Motherboard temperature,
+ * T_Sensor temperature,
+ * VRM  temperature,
+ * Water In temperature,
+ * Water Out temperature,
+ * CPU Optional Fan,
+ * Chipset fan,
+ * Water Flow fan,
+ * CPU current.
+ *
+ */
+#include <asm/unaligned.h>
+#include <linux/acpi.h>
+#include <linux/dmi.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.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/platform_device.h>
+#include <linux/units.h>
+#include <linux/wmi.h>
+
+#define ASUSWMI_MONITORING_GUID		"466747A0-70EC-11DE-8A39-0800200C9A66"
+#define ASUSWMI_METHODID_BLOCK_READ_EC		0x42524543 /* BREC */
+
+#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS DSDT source */
+/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value */
+#define ASUS_WMI_MAX_BUF_LEN 0x80
+#define MAX_SENSOR_LABEL_LENGTH 0x10
+
+enum asus_wmi_ec_board {
+	BOARD_PW_X570_A, /* Pro WS X570-ACE */
+	BOARD_R_C8H, /* ROG Crosshair VIII Hero */
+	BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
+	BOARD_R_C8F, /* ROG Crosshair VIII Formula */
+	BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
+	BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
+	BOARD_MAX
+};
+
+/* boards with EC support */
+static const char *const asus_wmi_ec_boards_names[] = {
+	[BOARD_PW_X570_A] = "Pro WS X570-ACE",
+	[BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
+	[BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
+	[BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
+	[BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
+	[BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
+};
+
+static u32 hwmon_attributes[] = {
+	[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 {
+	char label[MAX_SENSOR_LABEL_LENGTH];
+	enum hwmon_sensor_types type;
+	struct asus_wmi_ec_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,
+	SENSOR_TEMP_CPU,
+	SENSOR_TEMP_MB,
+	SENSOR_TEMP_T_SENSOR,
+	SENSOR_TEMP_VRM,
+	SENSOR_FAN_CPU_OPT,
+	SENSOR_FAN_CHIPSET,
+	SENSOR_FAN_WATER_FLOW,
+	SENSOR_CURR_CPU,
+	SENSOR_TEMP_WATER_IN,
+	SENSOR_TEMP_WATER_OUT,
+	SENSOR_MAX
+};
+
+/*
+ * Array of the 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_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),
+};
+
+static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
+	[BOARD_PW_X570_A] = {
+		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
+		SENSOR_FAN_CHIPSET,
+		SENSOR_MAX
+	},
+	[BOARD_R_C8H] = {
+		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
+	},
+	[BOARD_R_C8DH] = { /* Same as Hero but without chipset fan */
+		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
+	},
+	[BOARD_R_C8F] = { /* Same as Hero but without water */
+		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
+	},
+	[BOARD_RS_B550_E_G] = {
+		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
+		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
+		SENSOR_FAN_CPU_OPT,
+		SENSOR_CURR_CPU,
+		SENSOR_MAX
+	},
+	[BOARD_RS_X570_E_G] = {
+		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
+		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
+		SENSOR_FAN_CHIPSET,
+		SENSOR_MAX
+	},
+};
+
+struct ec_sensor {
+	enum known_ec_sensor info_index;
+	u32 cached_value;
+};
+
+/**
+ * struct asus_wmi_ec_info - sensor info.
+ * @sensors: list of sensors.
+ * @read_arg: UTF-16 string to pass to BRxx() WMI function.
+ * @read_buffer: WMI function output.
+ * @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[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) + 1) * 2];
+	u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
+	unsigned int nr_sensors;
+	unsigned int nr_registers;
+	unsigned long last_updated;
+};
+
+struct asus_wmi_sensors {
+	/* lock access to instrnal cache */
+	struct mutex lock;
+	struct asus_wmi_ec_info ec;
+
+	int ec_board;
+};
+
+struct asus_wmi_data {
+	int ec_board;
+};
+
+static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec, int board)
+{
+	const enum known_ec_sensor *bsi = known_board_sensors[board];
+	struct ec_sensor *s = ec->sensors;
+	int i;
+
+	ec->nr_sensors = 0;
+	ec->nr_registers = 0;
+
+	for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
+		s[i].info_index = bsi[i];
+		s[i].cached_value = 0;
+		ec->nr_sensors++;
+		ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
+	}
+}
+
+/*
+ * The next four functions converts to/from BRxx string argument format
+ * The format of the string is as follows:
+ * The string consists of two-byte UTF-16 characters
+ * The value of the very first byte int 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 pairs of (bank, index) pairs, where both
+ * values are byte-long (0x00 to 0xFF)
+ * Numbers are encoded as UTF-16 hex values
+ */
+static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
+{
+	unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
+	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
+	const char *pos = buffer;
+	const u8 *data = inp + 2;
+	unsigned int i;
+
+	utf16s_to_utf8s((wchar_t *)data, len * 2,  UTF16_LITTLE_ENDIAN, buffer, len * 2);
+
+	for (i = 0; i < len; i++, pos += 2)
+		out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
+}
+
+static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
+{
+	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
+	char *pos = buffer;
+	unsigned int i;
+	u8 byte;
+
+	*out++ = len * 8;
+	*out++ = 0;
+
+	for (i = 0; i < len; i++) {
+		byte = registers[i] >> 8;
+		*pos = hex_asc_hi(byte);
+		pos++;
+		*pos = hex_asc_lo(byte);
+		pos++;
+		byte = registers[i];
+		*pos = hex_asc_hi(byte);
+		pos++;
+		*pos = hex_asc_lo(byte);
+		pos++;
+	}
+
+	utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
+}
+
+static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
+{
+	u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
+	const struct ec_sensor_info *si;
+	long i, j, register_idx = 0;
+
+	/*
+	 * if we can get values for all the registers in a single query,
+	 * the query will not change from call to call
+	 */
+	if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX &&
+	    ec->read_arg[0] > 0) {
+		/* no need to update */
+		return;
+	}
+
+	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++, register_idx++) {
+			registers[register_idx] = (si->addr.bank << 8) + si->addr.index + j;
+		}
+	}
+
+	asus_wmi_ec_encode_registers(registers, ec->nr_registers, 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;
+
+	/* the first byte of the BRxx() argument string has to be the string size */
+	input.length = (acpi_size)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 || obj->type != ACPI_TYPE_BUFFER) {
+		if (!obj)
+			acpi_os_free(output.pointer);
+
+		return -EIO;
+	}
+	asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
+	acpi_os_free(output.pointer);
+	return 0;
+}
+
+static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
+{
+	const struct ec_sensor_info *si;
+	struct ec_sensor *s;
+
+	u32 value;
+	int status;
+	u8 i_sensor, read_reg_ct;
+
+	asus_wmi_ec_make_block_read_query(ec);
+	status = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
+					ec->read_arg,
+					ec->read_buffer);
+	if (status)
+		return status;
+
+	read_reg_ct = 0;
+	for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
+		s = &ec->sensors[i_sensor];
+		si = &known_ec_sensors[s->info_index];
+
+		if (si->addr.size == 1)
+			value = ec->read_buffer[read_reg_ct];
+		else if (si->addr.size == 2)
+			value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
+		else if (si->addr.size == 4)
+			value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
+
+		read_reg_ct += si->addr.size;
+		s->cached_value = value;
+	}
+	return 0;
+}
+
+static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
+{
+	switch (data_type) {
+	case hwmon_curr:
+	case hwmon_temp:
+	case hwmon_in:
+		return value * KILO;
+	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(int sensor_index,
+						  struct asus_wmi_sensors *state,
+						  u32 *value)
+{
+	int ret;
+
+	if (time_after(jiffies, state->ec.last_updated + HZ)) {
+		ret = asus_wmi_ec_update_ec_sensors(&state->ec);
+		if (ret)
+			return ret;
+
+		state->ec.last_updated = jiffies;
+	}
+
+	*value = state->ec.sensors[sensor_index].cached_value;
+	return 0;
+}
+
+/*
+ * 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);
+	int ret, sidx, info_index;
+	u32 value = 0;
+
+	sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
+	if (sidx < 0)
+		return sidx;
+
+	mutex_lock(&sensor_data->lock);
+	ret = asus_wmi_ec_get_cached_value_or_update(sidx, sensor_data, &value);
+	mutex_unlock(&sensor_data->lock);
+	if (ret)
+		return ret;
+
+	info_index = sensor_data->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);
+	int sensor_index;
+
+	sensor_index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
+	*str = known_ec_sensors[sensor_data->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)
+{
+	int index;
+	const struct asus_wmi_sensors *sensor_data = drvdata;
+
+	index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
+
+	return index == 0xff ? 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 platform_device *pdev,
+					      struct asus_wmi_sensors *sensor_data)
+{
+	struct hwmon_channel_info *asus_wmi_hwmon_chan;
+	const struct hwmon_channel_info **ptr_asus_wmi_ci;
+	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
+	const struct hwmon_chip_info *chip_info;
+	struct device *dev = &pdev->dev;
+	const struct ec_sensor_info *si;
+	enum hwmon_sensor_types type;
+	struct device *hwdev;
+	int i;
+
+	asus_wmi_ec_fill_board_sensors(&sensor_data->ec, sensor_data->ec_board);
+
+	if (!sensor_data->ec.nr_sensors)
+		return -ENODEV;
+
+	for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
+		si = &known_ec_sensors[sensor_data->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++;
+	}
+
+	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_ec_chip_info.info = ptr_asus_wmi_ci;
+	chip_info = &asus_wmi_ec_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_dbg(&pdev->dev, "%s board has %d EC sensors that span %d registers",
+		asus_wmi_ec_boards_names[sensor_data->ec_board],
+		sensor_data->ec.nr_sensors,
+		sensor_data->ec.nr_registers);
+
+	hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
+						     sensor_data, chip_info, NULL);
+
+	return PTR_ERR_OR_ZERO(hwdev);
+}
+
+static int asus_wmi_probe(struct platform_device *pdev)
+{
+	struct asus_wmi_sensors *sensor_data;
+	struct device *dev = &pdev->dev;
+	struct asus_wmi_data *data;
+
+	data = dev_get_platdata(dev);
+
+	sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
+				   GFP_KERNEL);
+	if (!sensor_data)
+		return -ENOMEM;
+
+	mutex_init(&sensor_data->lock);
+	sensor_data->ec_board = data->ec_board;
+
+	platform_set_drvdata(pdev, sensor_data);
+
+	/* ec init */
+	return asus_wmi_ec_configure_sensor_setup(pdev,
+						  sensor_data);
+}
+
+static struct platform_driver asus_wmi_sensors_platform_driver = {
+	.driver = {
+		.name	= "asus-wmi-sensors",
+	},
+	.probe = asus_wmi_probe,
+};
+
+static struct platform_device *sensors_pdev;
+
+static int __init asus_wmi_init(void)
+{
+	const char *board_vendor, *board_name;
+	struct asus_wmi_data data;
+
+	data.ec_board = -1;
+
+	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+	board_name = dmi_get_system_info(DMI_BOARD_NAME);
+
+	if (board_vendor && board_name &&
+	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
+		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
+			return -ENODEV;
+
+		data.ec_board = match_string(asus_wmi_ec_boards_names,
+					     ARRAY_SIZE(asus_wmi_ec_boards_names),
+					     board_name);
+	}
+
+	/* Nothing to support */
+	if (data.ec_board < 0)
+		return -ENODEV;
+
+	sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
+					      asus_wmi_probe,
+					      NULL, 0,
+					      &data, sizeof(struct asus_wmi_data));
+
+	return PTR_ERR_OR_ZERO(sensors_pdev);
+}
+module_init(asus_wmi_init);
+
+static void __exit asus_wmi_exit(void)
+{
+	platform_device_unregister(sensors_pdev);
+	platform_driver_unregister(&asus_wmi_sensors_platform_driver);
+}
+module_exit(asus_wmi_exit);
+
+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.33.0

[PATCH v2 3/3] hwmon: (asus_wmi_sensors) Support X370 Asus WMI.

[Denis Pauk]

Provides a Linux kernel module "asus_wmi_sensors" that provides sensor
readouts via ASUS' WMI interface present in the UEFI of
X370/X470/B450/X399 Ryzen motherboards.

Supported motherboards:
* ROG CROSSHAIR VI HERO,
* PRIME X399-A,
* PRIME X470-PRO,
* ROG CROSSHAIR VI EXTREME,
* ROG CROSSHAIR VI HERO (WI-FI AC),
* ROG CROSSHAIR VII HERO,
* ROG CROSSHAIR VII HERO (WI-FI),
* ROG STRIX B450-E GAMING,
* ROG STRIX B450-F GAMING,
* ROG STRIX B450-I GAMING,
* ROG STRIX X399-E GAMING,
* ROG STRIX X470-F GAMING,
* ROG STRIX X470-I GAMING,
* ROG ZENITH EXTREME,
* ROG ZENITH EXTREME ALPHA.

BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
Co-developed-by: Ed Brindley <kernel@maidavale.org>
Signed-off-by: Ed Brindley <kernel@maidavale.org>

---
Changes in v2:
- Add module for boards with support of WMI interface returned sensor name and
   value of sensor..
---
 MAINTAINERS                      |   1 +
 drivers/hwmon/Kconfig            |  11 +
 drivers/hwmon/Makefile           |   1 +
 drivers/hwmon/asus_wmi_sensors.c | 661 +++++++++++++++++++++++++++++++
 4 files changed, 674 insertions(+)
 create mode 100644 drivers/hwmon/asus_wmi_sensors.c

diff --git a/MAINTAINERS b/MAINTAINERS
index bc2e981a54e2..3f77d1d17841 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2942,6 +2942,7 @@ 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_sensors.c
 F:	drivers/hwmon/asus_wmi_ec_sensors.c
 
 ASUS WIRELESS RADIO CONTROL DRIVER
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index b7107721a401..ddb1d251d81a 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
 	  This driver can also be built as a module. If so, the module
 	  will be called asus_atk0110.
 
+config SENSORS_ASUS_WMI
+	tristate "ASUS WMI X370/X470/B450/X399"
+	help
+	  If you say yes here you get support for the ACPI hardware monitoring
+	  interface found in X370/X470/B450/X399 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.
+
 config SENSORS_ASUS_WMI_EC
 	tristate "ASUS WMI B550/X570"
 	help
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index aae2ff5c7335..656a6191a0f8 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_WMI)	+= asus_wmi_sensors.o
 obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
 
 # Native drivers
diff --git a/drivers/hwmon/asus_wmi_sensors.c b/drivers/hwmon/asus_wmi_sensors.c
new file mode 100644
index 000000000000..792872b068d7
--- /dev/null
+++ b/drivers/hwmon/asus_wmi_sensors.c
@@ -0,0 +1,661 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * HWMON driver for ASUS motherboards that provides sensor readouts via WMI
+ * interface present in the UEFI of the X370/X470/B450/X399 Ryzen motherboards.
+ *
+ * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
+ * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
+ *
+ * WMI interface provided:
+ * CPU Core Voltage,
+ * CPU SOC Voltage,
+ * DRAM Voltage,
+ * VDDP Voltage,
+ * 1.8V PLL Voltage,
+ * +12V Voltage,
+ * +5V Voltage,
+ * 3VSB Voltage,
+ * VBAT Voltage,
+ * AVCC3 Voltage,
+ * SB 1.05V Voltage,
+ * CPU Core Voltage,
+ * CPU SOC Voltage,
+ * DRAM Voltage,
+ * CPU Fan,
+ * Chassis Fan 1,
+ * Chassis Fan 2,
+ * Chassis Fan 3,
+ * HAMP Fan,
+ * Water Pump,
+ * CPU OPT,
+ * Water Flow,
+ * AIO Pump,
+ * CPU Temperature,
+ * CPU Socket Temperature,
+ * Motherboard Temperature,
+ * Chipset Temperature,
+ * Tsensor 1 Temperature,
+ * CPU VRM Temperature,
+ * Water In,
+ * Water Out,
+ * CPU VRM Output Current.
+ */
+#include <linux/acpi.h>
+#include <linux/dmi.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/init.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/platform_device.h>
+#include <linux/units.h>
+#include <linux/wmi.h>
+
+#define ASUSWMI_MONITORING_GUID		"466747A0-70EC-11DE-8A39-0800200C9A66"
+#define ASUSWMI_METHODID_GET_VALUE	0x52574543
+#define ASUSWMI_METHODID_UPDATE_BUFFER	0x51574543
+#define ASUSWMI_METHODID_GET_INFO	0x50574543
+#define ASUSWMI_METHODID_GET_NUMBER		0x50574572
+#define ASUSWMI_METHODID_GET_VERSION		0x50574574
+
+#define ASUS_WMI_MAX_STR_SIZE	32
+
+/* boards with wmi sensors support */
+static const char *const asus_wmi_boards_names[] = {
+	"ROG CROSSHAIR VI HERO",
+	"PRIME X399-A",
+	"PRIME X470-PRO",
+	"ROG CROSSHAIR VI EXTREME",
+	"ROG CROSSHAIR VI HERO (WI-FI AC)",
+	"ROG CROSSHAIR VII HERO",
+	"ROG CROSSHAIR VII HERO (WI-FI)",
+	"ROG STRIX B450-E GAMING",
+	"ROG STRIX B450-F GAMING",
+	"ROG STRIX B450-I GAMING",
+	"ROG STRIX X399-E GAMING",
+	"ROG STRIX X470-F GAMING",
+	"ROG STRIX X470-I GAMING",
+	"ROG ZENITH EXTREME",
+	"ROG ZENITH EXTREME ALPHA",
+};
+
+enum asus_wmi_sensor_class {
+	VOLTAGE = 0x0,
+	TEMPERATURE_C = 0x1,
+	FAN_RPM = 0x2,
+	CURRENT = 0x3,
+	WATER_FLOW = 0x4,
+};
+
+enum asus_wmi_location {
+	CPU = 0x0,
+	CPU_SOC = 0x1,
+	DRAM = 0x2,
+	MOTHERBOARD = 0x3,
+	CHIPSET = 0x4,
+	AUX = 0x5,
+	VRM = 0x6,
+	COOLER = 0x7
+};
+
+enum asus_wmi_type {
+	SIGNED_INT = 0x0,
+	UNSIGNED_INT = 0x1,
+	SCALED = 0x3,
+};
+
+enum asus_wmi_source {
+	SIO = 0x1,
+	EC = 0x2
+};
+
+static enum hwmon_sensor_types asus_data_types[] = {
+	[VOLTAGE] = hwmon_in,
+	[TEMPERATURE_C] = hwmon_temp,
+	[FAN_RPM] = hwmon_fan,
+	[CURRENT] = hwmon_curr,
+	[WATER_FLOW] = hwmon_fan,
+};
+
+static u32 hwmon_attributes[] = {
+	[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_sensor_info - sensor info.
+ * @id: sensor id.
+ * @data_type: sensor class e.g. voltage, temp etc.
+ * @location: sensor location.
+ * @name: sensor name.
+ * @source: sensor source.
+ * @type: sensor type signed, unsigned etc.
+ * @cached_value: cached sensor value.
+ */
+struct asus_wmi_sensor_info {
+	u32 id;
+	int data_type;
+	int location;
+	char name[ASUS_WMI_MAX_STR_SIZE];
+	int source;
+	int type;
+	u32 cached_value;
+};
+
+struct asus_wmi_wmi_info {
+	u8 buffer;
+	unsigned long source_last_updated[3];	/* in jiffies */
+	u8 sensor_count;
+
+	const struct asus_wmi_sensor_info **info[hwmon_max];
+	struct asus_wmi_sensor_info **info_by_id;
+};
+
+struct asus_wmi_sensors {
+	/* lock access to instrnal cache */
+	struct mutex lock;
+	struct asus_wmi_wmi_info wmi;
+
+	int wmi_board;
+};
+
+struct asus_wmi_data {
+	int wmi_board;
+	int wmi_count;
+};
+
+/*
+ * Universal method for calling WMI method
+ */
+static int asus_wmi_call_method(u32 method_id, u32 *args, struct acpi_buffer *output)
+{
+	struct acpi_buffer input = {(acpi_size) sizeof(*args), args };
+	acpi_status status;
+
+	status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, method_id, &input, output);
+	if (ACPI_FAILURE(status))
+		return -EIO;
+
+	return 0;
+}
+
+/*
+ * Gets the version of the ASUS sensors interface implemented
+ */
+static int asus_wmi_get_version(u32 *version)
+{
+	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+	u32 args[] = {0, 0, 0};
+	union acpi_object *obj;
+	int err;
+
+	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_VERSION, args, &output);
+	if (err)
+		return err;
+
+	obj = output.pointer;
+	if (!obj || obj->type != ACPI_TYPE_INTEGER)
+		return -EIO;
+
+	*version = obj->integer.value;
+
+	return 0;
+}
+
+/*
+ * Gets the number of sensor items
+ */
+static int asus_wmi_get_item_count(u32 *count)
+{
+	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+	u32 args[] = {0, 0, 0};
+	union acpi_object *obj;
+	int err;
+
+	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_NUMBER, args, &output);
+	if (err)
+		return err;
+
+	obj = output.pointer;
+	if (!obj || obj->type != ACPI_TYPE_INTEGER)
+		return -EIO;
+
+	*count = obj->integer.value;
+
+	return 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)
+{
+	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;
+}
+
+/*
+ * For a given sensor item returns details e.g. type (voltage/temperature/fan speed etc), bank etc
+ */
+static int asus_wmi_sensor_info(int index, struct asus_wmi_sensor_info *s)
+{
+	union acpi_object name_obj, data_type_obj, location_obj, source_obj, type_obj;
+	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+	u32 args[] = {index, 0};
+	union acpi_object *obj;
+	int err;
+
+	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_INFO, args, &output);
+	if (err)
+		return err;
+
+	s->id = index;
+
+	obj = output.pointer;
+	if (!obj || obj->type != ACPI_TYPE_PACKAGE)
+		return -EIO;
+
+	if (obj->package.count != 5)
+		return 1;
+
+	name_obj = obj->package.elements[0];
+
+	if (name_obj.type != ACPI_TYPE_STRING)
+		return 1;
+
+	strncpy(s->name, name_obj.string.pointer, sizeof(s->name) - 1);
+
+	data_type_obj = obj->package.elements[1];
+
+	if (data_type_obj.type != ACPI_TYPE_INTEGER)
+		return 1;
+
+	s->data_type = data_type_obj.integer.value;
+
+	location_obj = obj->package.elements[2];
+
+	if (location_obj.type != ACPI_TYPE_INTEGER)
+		return 1;
+
+	s->location = location_obj.integer.value;
+
+	source_obj = obj->package.elements[3];
+
+	if (source_obj.type != ACPI_TYPE_INTEGER)
+		return 1;
+
+	s->source = source_obj.integer.value;
+
+	type_obj = obj->package.elements[4];
+
+	if (type_obj.type != ACPI_TYPE_INTEGER)
+		return 1;
+
+	s->type = type_obj.integer.value;
+
+	return 0;
+}
+
+static int asus_wmi_update_buffer(u8 source)
+{
+	u32 args[] = {source, 0};
+	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+
+	return asus_wmi_call_method(ASUSWMI_METHODID_UPDATE_BUFFER, args, &output);
+}
+
+static int asus_wmi_get_sensor_value(u8 index, u32 *value)
+{
+	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+	u32 args[] = {index, 0};
+	union acpi_object *obj;
+	int err;
+
+	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_VALUE, args, &output);
+	if (err)
+		return err;
+
+	obj = output.pointer;
+	if (!obj || obj->type != ACPI_TYPE_INTEGER)
+		return -EIO;
+
+	*value = obj->integer.value;
+
+	return 0;
+}
+
+static void asus_wmi_update_values_for_source(u8 source, struct asus_wmi_sensors *sensor_data)
+{
+	int ret = 0;
+	int value = 0;
+	int i;
+	struct asus_wmi_sensor_info *sensor;
+
+	for (i = 0; i < sensor_data->wmi.sensor_count; i++) {
+		sensor = sensor_data->wmi.info_by_id[i];
+		if (sensor && sensor->source == source) {
+			ret = asus_wmi_get_sensor_value(sensor->id, &value);
+			if (!ret)
+				sensor->cached_value = value;
+		}
+	}
+}
+
+static int asus_wmi_scale_sensor_value(u32 value, int data_type)
+{
+	/* FAN_RPM and WATER_FLOW don't need scaling */
+	switch (data_type) {
+	case VOLTAGE:
+		return DIV_ROUND_CLOSEST(value, 1000);
+	case TEMPERATURE_C:
+		return value * 1000;
+	case CURRENT:
+		return value * 1000;
+	}
+	return value;
+}
+
+static int asus_wmi_get_cached_value_or_update(const struct asus_wmi_sensor_info *sensor,
+					       struct asus_wmi_sensors *sensor_data,
+					       u32 *value)
+{
+	int ret;
+
+	if (time_after(jiffies, sensor_data->wmi.source_last_updated[sensor->source] + HZ)) {
+		ret = asus_wmi_update_buffer(sensor->source);
+		if (ret)
+			return -EIO;
+
+		sensor_data->wmi.buffer = sensor->source;
+
+		asus_wmi_update_values_for_source(sensor->source, sensor_data);
+		sensor_data->wmi.source_last_updated[sensor->source] = jiffies;
+	}
+
+	*value = sensor->cached_value;
+	return 0;
+}
+
+/*
+ * Now follow the functions that implement the hwmon interface
+ */
+
+static int asus_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
+			       u32 attr, int channel, long *val)
+{
+	int ret;
+	u32 value = 0;
+	const struct asus_wmi_sensor_info *sensor;
+
+	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
+
+	sensor = *(sensor_data->wmi.info[type] + channel);
+
+	mutex_lock(&sensor_data->lock);
+
+	ret = asus_wmi_get_cached_value_or_update(sensor, sensor_data, &value);
+	mutex_unlock(&sensor_data->lock);
+
+	if (!ret)
+		*val = asus_wmi_scale_sensor_value(value, sensor->data_type);
+
+	return ret;
+}
+
+static int asus_wmi_hwmon_read_string(struct device *dev,
+				      enum hwmon_sensor_types type, u32 attr,
+				      int channel, const char **str)
+{
+	const struct asus_wmi_sensor_info *sensor;
+	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
+
+	sensor = *(sensor_data->wmi.info[type] + channel);
+	*str = sensor->name;
+
+	return 0;
+}
+
+static umode_t asus_wmi_hwmon_is_visible(const void *drvdata,
+					 enum hwmon_sensor_types type, u32 attr,
+					 int channel)
+{
+	const struct asus_wmi_sensor_info *sensor;
+	const struct asus_wmi_sensors *sensor_data = drvdata;
+
+	sensor = *(sensor_data->wmi.info[type] + channel);
+	if (sensor && sensor->name)
+		return 0444;
+
+	return 0;
+}
+
+static const struct hwmon_ops asus_wmi_hwmon_ops = {
+	.is_visible = asus_wmi_hwmon_is_visible,
+	.read = asus_wmi_hwmon_read,
+	.read_string = asus_wmi_hwmon_read_string,
+};
+
+static struct hwmon_chip_info asus_wmi_chip_info = {
+	.ops = &asus_wmi_hwmon_ops,
+	.info = NULL,
+};
+
+static int asus_wmi_configure_sensor_setup(struct platform_device *pdev,
+					   struct asus_wmi_sensors *sensor_data)
+{
+	int err;
+	int i, idx;
+	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;
+	struct asus_wmi_sensor_info *temp_sensor;
+	enum hwmon_sensor_types type;
+	const struct hwmon_channel_info **ptr_asus_wmi_ci;
+	const struct hwmon_chip_info *chip_info;
+
+	sensor_data->wmi.buffer = -1;
+	temp_sensor = devm_kcalloc(dev, 1, sizeof(*temp_sensor), GFP_KERNEL);
+	if (!temp_sensor)
+		return -ENOMEM;
+
+	for (i = 0; i < sensor_data->wmi.sensor_count; i++) {
+		err = asus_wmi_sensor_info(i, temp_sensor);
+		if (err)
+			return -EINVAL;
+
+		switch (temp_sensor->data_type) {
+		case TEMPERATURE_C:
+		case VOLTAGE:
+		case CURRENT:
+		case FAN_RPM:
+		case WATER_FLOW:
+			type = asus_data_types[temp_sensor->data_type];
+			if (!nr_count[type])
+				nr_types++;
+			nr_count[type]++;
+			break;
+		}
+	}
+
+	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;
+
+	sensor_data->wmi.info_by_id = devm_kcalloc(dev, sensor_data->wmi.sensor_count,
+						   sizeof(*sensor_data->wmi.info_by_id),
+						   GFP_KERNEL);
+
+	if (!sensor_data->wmi.info_by_id)
+		return -ENOMEM;
+
+	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++;
+
+		sensor_data->wmi.info[type] = devm_kcalloc(dev,
+							   nr_count[type],
+							   sizeof(*sensor_data->wmi.info),
+							   GFP_KERNEL);
+		if (!sensor_data->wmi.info[type])
+			return -ENOMEM;
+	}
+
+	for (i = sensor_data->wmi.sensor_count - 1; i >= 0 ; i--) {
+		temp_sensor = devm_kzalloc(dev, sizeof(*temp_sensor), GFP_KERNEL);
+		if (!temp_sensor)
+			return -ENOMEM;
+
+		err = asus_wmi_sensor_info(i, temp_sensor);
+		if (err)
+			continue;
+
+		switch (temp_sensor->data_type) {
+		case TEMPERATURE_C:
+		case VOLTAGE:
+		case CURRENT:
+		case FAN_RPM:
+		case WATER_FLOW:
+			type = asus_data_types[temp_sensor->data_type];
+			idx = --nr_count[type];
+			*(sensor_data->wmi.info[type] + idx) = temp_sensor;
+			sensor_data->wmi.info_by_id[i] = temp_sensor;
+			break;
+		}
+	}
+
+	dev_dbg(&pdev->dev, "%s board has %d sensors",
+		asus_wmi_boards_names[sensor_data->wmi_board],
+		sensor_data->wmi.sensor_count);
+
+	hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
+						     sensor_data, chip_info, NULL);
+
+	return PTR_ERR_OR_ZERO(hwdev);
+}
+
+static int asus_wmi_probe(struct platform_device *pdev)
+{
+	struct asus_wmi_sensors *sensor_data;
+	struct device *dev = &pdev->dev;
+	struct asus_wmi_data *data;
+
+	data = dev_get_platdata(dev);
+
+	sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
+				   GFP_KERNEL);
+	if (!sensor_data)
+		return -ENOMEM;
+
+	mutex_init(&sensor_data->lock);
+	sensor_data->wmi_board = data->wmi_board;
+	sensor_data->wmi.sensor_count = data->wmi_count;
+
+	platform_set_drvdata(pdev, sensor_data);
+
+	return asus_wmi_configure_sensor_setup(pdev,
+					       sensor_data);
+	return 0;
+}
+
+static struct platform_driver asus_wmi_sensors_platform_driver = {
+	.driver = {
+		.name	= "asus-wmi-sensors",
+	},
+	.probe = asus_wmi_probe,
+};
+
+static struct platform_device *sensors_pdev;
+
+static int __init asus_wmi_init(void)
+{
+	const char *board_vendor, *board_name;
+	u32 version = 0;
+	struct asus_wmi_data data;
+
+	data.wmi_board = -1;
+	data.wmi_count = 0;
+
+	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+	board_name = dmi_get_system_info(DMI_BOARD_NAME);
+
+	if (board_vendor && board_name &&
+	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
+		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
+			return -ENODEV;
+
+		data.wmi_board = match_string(asus_wmi_boards_names,
+					      ARRAY_SIZE(asus_wmi_boards_names),
+					      board_name);
+
+		if (data.wmi_board >= 0) {
+			if (asus_wmi_get_item_count(&data.wmi_count))
+				return -ENODEV;
+
+			if (asus_wmi_get_version(&version))
+				return -ENODEV;
+
+			if (data.wmi_count  <= 0 || version < 2) {
+				pr_err("Board: %s WMI wmi version: %u with %d sensors is unsupported\n",
+				       board_name, version, data.wmi_count);
+
+				data.wmi_board = -ENODEV;
+			}
+		}
+	}
+
+	/* Nothing to support */
+	if (data.wmi_board < 0)
+		return -ENODEV;
+
+	sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
+					      asus_wmi_probe,
+					      NULL, 0,
+					      &data, sizeof(struct asus_wmi_data));
+
+	return PTR_ERR_OR_ZERO(sensors_pdev);
+}
+module_init(asus_wmi_init);
+
+static void __exit asus_wmi_exit(void)
+{
+	platform_device_unregister(sensors_pdev);
+	platform_driver_unregister(&asus_wmi_sensors_platform_driver);
+}
+module_exit(asus_wmi_exit);
+
+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.33.0

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
>

> Supported motherboards:
> * ROG CROSSHAIR VIII HERO
> * ROG CROSSHAIR VIII DARK HERO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX X570-E GAMING
> * ROG STRIX B550-E GAMING

Pro WS X570-ACE is missing from this list.

> + * EC provided:
provides

> + * Chipset temperature,
> + * CPU temperature,
> + * Motherboard temperature,
> + * T_Sensor temperature,
> + * VRM  temperature,
> + * Water In temperature,
> + * Water Out temperature,
> + * CPU Optional Fan,
Hereinafter "CPU Optional Fan RPM"?

> +static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> +       [BOARD_PW_X570_A] = {
> +               SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> +               SENSOR_FAN_CHIPSET,

I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
mistake made it here too. Sorry for that.

> +/**
> + * struct asus_wmi_ec_info - sensor info.
> + * @sensors: list of sensors.
> + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> + * @read_buffer: WMI function output.

This seems to be a bit misleading to me in a sense that the variable
holds decoded output (array of numbers as opposed to array of
characters in the WMI output buffer.

> +struct asus_wmi_data {
> +       int ec_board;
> +};

A leftover?

> +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> +{
> +       unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
> +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> +       const char *pos = buffer;
> +       const u8 *data = inp + 2;
> +       unsigned int i;
> +
> +       utf16s_to_utf8s((wchar_t *)data, len * 2,  UTF16_LITTLE_ENDIAN, buffer, len * 2);
Errr... Why is it here? You need the same loop afterwards, just with a
smaller stride.
> +
> +       for (i = 0; i < len; i++, pos += 2)
> +               out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
> +}
> +
> +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
> +{
> +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> +       char *pos = buffer;
> +       unsigned int i;
> +       u8 byte;
> +
> +       *out++ = len * 8;
> +       *out++ = 0;
> +
> +       for (i = 0; i < len; i++) {
> +               byte = registers[i] >> 8;
> +               *pos = hex_asc_hi(byte);
> +               pos++;
> +               *pos = hex_asc_lo(byte);
> +               pos++;
> +               byte = registers[i];
> +               *pos = hex_asc_hi(byte);
> +               pos++;
> +               *pos = hex_asc_lo(byte);
> +               pos++;
> +       }
> +
> +       utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
Same here. Just for the sake of calling utf8s_to_utf16s() you need the
same loop plus an additional buffer. I don't get it.

> +}
> +
> +static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
> +{
> +       u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> +       const struct ec_sensor_info *si;
> +       long i, j, register_idx = 0;
long? maybe a simple unsigned or int?

> +
> +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
> +{
> +       const struct ec_sensor_info *si;
> +       struct ec_sensor *s;
> +
> +       u32 value;
This variable is now redundant.

> +               if (si->addr.size == 1)
Maybe switch(si->addr.size)?

> +                       value = ec->read_buffer[read_reg_ct];
> +               else if (si->addr.size == 2)
> +                       value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> +               else if (si->addr.size == 4)
> +                       value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
> +
> +               read_reg_ct += si->addr.size;
> +               s->cached_value = value;
> +       }
> +       return 0;
> +}


> +       mutex_lock(&sensor_data->lock);
The mutex locking/unlocking should be moved inside the
update_ec_sensors(), I guess.

I re-read your answer to my question as to why don't you add module
aliases to the driver, and I have to admit I don't really understand
it. Could you, please, elaborate?

Thank you,
Eugene

Re: [PATCH v2 1/3] hwmon: (nct6775) Add additional ASUS motherboards

[Oleksandr Natalenko]

Hello.

On čtvrtek 7. října 2021 0:24:59 CEST Denis Pauk wrote:
> Add support:
> * PRIME B360-PLUS
> * PRIME X570-PRO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX B550-I GAMING
> * ROG STRIX X570-F GAMING
> * ROG STRIX Z390-E GAMING
> * TUF GAMING B550-PRO
> * TUF GAMING Z490-PLUS
> * TUF GAMING Z490-PLUS (WI-FI)
> 
> BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> Tested-by: matt-testalltheway <sefoci9222@rerunway.com>
> Tested-by: Kamil Dudka <kdudka@redhat.com>
> Tested-by: Robert Swiecki <robert@swiecki.net>
> Tested-by: Kamil Pietrzak <kpietrzak@disroot.org>
> Tested-by: Igor <igor@svelig.com>
> Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
> ---
> Changes in v2:
>   - Without changes.
> ---
>  drivers/hwmon/nct6775.c | 9 +++++++++
>  1 file changed, 9 insertions(+)
> 
> diff --git a/drivers/hwmon/nct6775.c b/drivers/hwmon/nct6775.c
> index aa58ead0ad43..8eaf86ea2433 100644
> --- a/drivers/hwmon/nct6775.c
> +++ b/drivers/hwmon/nct6775.c
> @@ -4986,20 +4986,29 @@ static int __init nct6775_find(int sioaddr, struct
> nct6775_sio_data *sio_data) static struct platform_device *pdev[2];
> 
>  static const char * const asus_wmi_boards[] = {
> +	"PRIME B360-PLUS",
>  	"PRIME B460-PLUS",
> +	"PRIME X570-PRO",
>  	"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-F GAMING",
>  	"ROG STRIX B550-F GAMING (WI-FI)",
> +	"ROG STRIX B550-I GAMING",
> +	"ROG STRIX X570-F GAMING",
> +	"ROG STRIX Z390-E GAMING",
>  	"ROG STRIX Z490-I GAMING",
>  	"TUF GAMING B550M-PLUS",
>  	"TUF GAMING B550M-PLUS (WI-FI)",
>  	"TUF GAMING B550-PLUS",
> +	"TUF GAMING B550-PRO",
>  	"TUF GAMING X570-PLUS",
>  	"TUF GAMING X570-PLUS (WI-FI)",
>  	"TUF GAMING X570-PRO (WI-FI)",
> +	"TUF GAMING Z490-PLUS",
> +	"TUF GAMING Z490-PLUS (WI-FI)",
>  };
> 
>  static int __init sensors_nct6775_init(void)

Please also add ASUS Pro WS X570-ACE as shown here [1].

Thanks.

[1] https://lore.kernel.org/lkml/20211003133344.9036-2-oleksandr@natalenko.name/

-- 
Oleksandr Natalenko (post-factum)

Re: [PATCH v2 3/3] hwmon: (asus_wmi_sensors) Support X370 Asus WMI.

[Eugene Shalygin]

Hello, Denis,

On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:

> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");

No, I am not.

Best regards,
Eugene

P.S. You stripped module aliases for this one too. Why? This driver
certainly can benefit from them, because the presence of the specific
WMI UUIDs unambiguously defines its condition to work.

Re: [PATCH v2 3/3] hwmon: (asus_wmi_sensors) Support X370 Asus WMI.

[Denis Pauk]

Hi Eugene,

On Thu, 7 Oct 2021 12:56:09 +0200
Eugene Shalygin <eugene.shalygin@gmail.com> wrote:

> Hello, Denis,
> 
> On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> 
> > +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");  
> 
> No, I am not.
I will remove.

> 
> Best regards,
> Eugene
> 
> P.S. You stripped module aliases for this one too. Why? This driver
> certainly can benefit from them, because the presence of the specific
> WMI UUIDs unambiguously defines its condition to work.
I looked complicated to support two kind of WMI interfaces with UUID.
As we split big support module to two separate - I will look to such
change also.

Best regards,
     Denis. 

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Denis Pauk]

Hi Eugene, 

On Thu, 7 Oct 2021 01:32:14 +0200
Eugene Shalygin <eugene.shalygin@gmail.com> wrote:

> On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> >  
> 
> > Supported motherboards:
> > * ROG CROSSHAIR VIII HERO
> > * ROG CROSSHAIR VIII DARK HERO
> > * ROG CROSSHAIR VIII FORMULA
> > * ROG STRIX X570-E GAMING
> > * ROG STRIX B550-E GAMING  
> 
> Pro WS X570-ACE is missing from this list.
Thanks, I will check.
> 
> > + * EC provided:  
> provides
Thanks, I will check.
> 
> > + * Chipset temperature,
> > + * CPU temperature,
> > + * Motherboard temperature,
> > + * T_Sensor temperature,
> > + * VRM  temperature,
> > + * Water In temperature,
> > + * Water Out temperature,
> > + * CPU Optional Fan,  
> Hereinafter "CPU Optional Fan RPM"?
> 
Thanks, I will check.
> > +static const enum known_ec_sensor
> > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > +       [BOARD_PW_X570_A] = {
> > +               SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > +               SENSOR_FAN_CHIPSET,  
> 
> I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> mistake made it here too. Sorry for that.
> 
Do you have such fix in your repository?
> > +/**
> > + * struct asus_wmi_ec_info - sensor info.
> > + * @sensors: list of sensors.
> > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > + * @read_buffer: WMI function output.  
> 
> This seems to be a bit misleading to me in a sense that the variable
> holds decoded output (array of numbers as opposed to array of
> characters in the WMI output buffer.
> 
> > +struct asus_wmi_data {
> > +       int ec_board;
> > +};  
> 
> A leftover?
> 
Its platform data and used to share board_id with probe.

> > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > +{
> > +       unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > 4);
> > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > +       const char *pos = buffer;
> > +       const u8 *data = inp + 2;
> > +       unsigned int i;
> > +
> > +       utf16s_to_utf8s((wchar_t *)data, len * 2,
> > UTF16_LITTLE_ENDIAN, buffer, len * 2);  
> Errr... Why is it here? You need the same loop afterwards, just with a
> smaller stride.
I have tried to apply Andy's idea. And it looks it does not
provide benefits. Andy, what do you think? Maybe I understand it in
wrong way. 
> > +
> > +       for (i = 0; i < len; i++, pos += 2)
> > +               out[i] = (hex_to_bin(pos[0]) << 4) +
> > hex_to_bin(pos[1]); +}
> > +
> > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > char *out) +{
> > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > +       char *pos = buffer;
> > +       unsigned int i;
> > +       u8 byte;
> > +
> > +       *out++ = len * 8;
> > +       *out++ = 0;
> > +
> > +       for (i = 0; i < len; i++) {
> > +               byte = registers[i] >> 8;
> > +               *pos = hex_asc_hi(byte);
> > +               pos++;
> > +               *pos = hex_asc_lo(byte);
> > +               pos++;
> > +               byte = registers[i];
> > +               *pos = hex_asc_hi(byte);
> > +               pos++;
> > +               *pos = hex_asc_lo(byte);
> > +               pos++;
> > +       }
> > +
> > +       utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > (wchar_t *)out, len * 4);  
> Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> same loop plus an additional buffer. I don't get it.
> 
I have tried to apply Andy's idea. And it looks it does not
provide benefits. Andy, what do you think? Maybe I understand it in
wrong way.
> > +}
> > +
> > +static void asus_wmi_ec_make_block_read_query(struct
> > asus_wmi_ec_info *ec) +{
> > +       u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > +       const struct ec_sensor_info *si;
> > +       long i, j, register_idx = 0;  
> long? maybe a simple unsigned or int?
> 
Looks as it was in original patch, I will look.
> > +
> > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > *ec) +{
> > +       const struct ec_sensor_info *si;
> > +       struct ec_sensor *s;
> > +
> > +       u32 value;  
> This variable is now redundant.
> 
Thank you, I will look.
 
> > +               if (si->addr.size == 1)  
> Maybe switch(si->addr.size)?
> 
Thank you, I will check.
> > +                       value = ec->read_buffer[read_reg_ct];
> > +               else if (si->addr.size == 2)
> > +                       value =
> > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > +               else if (si->addr.size == 4)
> > +                       value =
> > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > +               read_reg_ct += si->addr.size;
> > +               s->cached_value = value;
> > +       }
> > +       return 0;
> > +}  
> 
> 
> > +       mutex_lock(&sensor_data->lock);  
> The mutex locking/unlocking should be moved inside the
> update_ec_sensors(), I guess.
> 
> I re-read your answer to my question as to why don't you add module
> aliases to the driver, and I have to admit I don't really understand
> it. Could you, please, elaborate?
> 
It looked complicated to support two kind of WMI interfaces with UUID.
As we split big support module to two separate - I will look to such
change also.

> Thank you,
> Eugene

Best regards,
     Denis.

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Guenter Roeck]

On 10/6/21 3:25 PM, Denis Pauk wrote:
> Linux HWMON sensors driver for ASUS motherboards to read
> sensors from the embedded controller.
> 
> Many ASUS motherboards do not publish all the available
> sensors via the Super I/O chip but the missing ones are
> available through the embedded controller (EC) registers.
> 
> This driver implements reading those sensor data via the
> WMI method BREC, which is known to be present in all ASUS
> motherboards based on the AMD 500 series chipsets (and
> probably is available in other models too). The driver
> needs to know exact register addresses for the sensors and
> thus support for each motherboard has to be added explicitly.
> 
> The EC registers do not provide critical values for the
> sensors and as such they are not published to the HWMON.
> 
> Supported motherboards:
> * ROG CROSSHAIR VIII HERO
> * ROG CROSSHAIR VIII DARK HERO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX X570-E GAMING
> * ROG STRIX B550-E GAMING
> 
> BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> 
> ---
> Changes in v2:
>   - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
>   - Use post increment.
>   - Use get_unaligned* for convert values.
>   - Use PTR_ERR_OR_ZERO.
>   - Specify per-board sensors in a declarative way (by Eugene Shalygin).
> ---
>   MAINTAINERS                         |   7 +
>   drivers/hwmon/Kconfig               |  13 +-
>   drivers/hwmon/Makefile              |   1 +
>   drivers/hwmon/asus_wmi_ec_sensors.c | 631 ++++++++++++++++++++++++++++
>   4 files changed, 651 insertions(+), 1 deletion(-)
>   create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index bae3f62f548f..bc2e981a54e2 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -2937,6 +2937,13 @@ W:	http://acpi4asus.sf.net
>   F:	drivers/platform/x86/asus*.c
>   F:	drivers/platform/x86/eeepc*.c
>   
> +ASUS WMI 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 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 7fde4c6e1e7f..b7107721a401 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
>   
>   config SENSORS_AMC6821
>   	tristate "Texas Instruments AMC6821"
> -	depends on I2C
> +	depends on I2C

Completely unrelated and unacceptable change.

>   	help
>   	  If you say yes here you get support for the Texas Instruments
>   	  AMC6821 hardware monitoring chips.
> @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
>   	  This driver can also be built as a module. If so, the module
>   	  will be called asus_atk0110.
>   
> +config SENSORS_ASUS_WMI_EC
> +	tristate "ASUS WMI B550/X570"
> +	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.
> +
>   endif # ACPI
>   
>   endif # HWMON
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index baee6a8d4dd1..aae2ff5c7335 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_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
> new file mode 100644
> index 000000000000..553d9ee8656d
> --- /dev/null
> +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> @@ -0,0 +1,631 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * 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 provided:
> + * Chipset temperature,
> + * CPU temperature,
> + * Motherboard temperature,
> + * T_Sensor temperature,
> + * VRM  temperature,
> + * Water In temperature,
> + * Water Out temperature,
> + * CPU Optional Fan,
> + * Chipset fan,
> + * Water Flow fan,
> + * CPU current.
> + *
> + */
> +#include <asm/unaligned.h>
> +#include <linux/acpi.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.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/platform_device.h>
> +#include <linux/units.h>
> +#include <linux/wmi.h>
> +
> +#define ASUSWMI_MONITORING_GUID		"466747A0-70EC-11DE-8A39-0800200C9A66"
> +#define ASUSWMI_METHODID_BLOCK_READ_EC		0x42524543 /* BREC */
> +
> +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS DSDT source */
> +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value */
> +#define ASUS_WMI_MAX_BUF_LEN 0x80
> +#define MAX_SENSOR_LABEL_LENGTH 0x10
> +
> +enum asus_wmi_ec_board {
> +	BOARD_PW_X570_A, /* Pro WS X570-ACE */
> +	BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> +	BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> +	BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> +	BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> +	BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> +	BOARD_MAX
> +};
> +
> +/* boards with EC support */
> +static const char *const asus_wmi_ec_boards_names[] = {
> +	[BOARD_PW_X570_A] = "Pro WS X570-ACE",
> +	[BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> +	[BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> +	[BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> +	[BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> +	[BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> +};
> +
> +static u32 hwmon_attributes[] = {
> +	[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 {
> +	char label[MAX_SENSOR_LABEL_LENGTH];
> +	enum hwmon_sensor_types type;
> +	struct asus_wmi_ec_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,
> +	SENSOR_TEMP_CPU,
> +	SENSOR_TEMP_MB,
> +	SENSOR_TEMP_T_SENSOR,
> +	SENSOR_TEMP_VRM,
> +	SENSOR_FAN_CPU_OPT,
> +	SENSOR_FAN_CHIPSET,
> +	SENSOR_FAN_WATER_FLOW,
> +	SENSOR_CURR_CPU,
> +	SENSOR_TEMP_WATER_IN,
> +	SENSOR_TEMP_WATER_OUT,
> +	SENSOR_MAX
> +};
> +
> +/*
> + * Array of the 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_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),
> +};
> +
> +static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> +	[BOARD_PW_X570_A] = {
> +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> +		SENSOR_FAN_CHIPSET,
> +		SENSOR_MAX
> +	},
> +	[BOARD_R_C8H] = {
> +		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
> +	},
> +	[BOARD_R_C8DH] = { /* Same as Hero but without chipset fan */
> +		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
> +	},
> +	[BOARD_R_C8F] = { /* Same as Hero but without water */
> +		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
> +	},
> +	[BOARD_RS_B550_E_G] = {
> +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> +		SENSOR_FAN_CPU_OPT,
> +		SENSOR_CURR_CPU,
> +		SENSOR_MAX
> +	},
> +	[BOARD_RS_X570_E_G] = {
> +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> +		SENSOR_FAN_CHIPSET,
> +		SENSOR_MAX
> +	},
> +};
> +
> +struct ec_sensor {
> +	enum known_ec_sensor info_index;
> +	u32 cached_value;
> +};
> +
> +/**
> + * struct asus_wmi_ec_info - sensor info.
> + * @sensors: list of sensors.
> + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> + * @read_buffer: WMI function output.
> + * @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[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) + 1) * 2];
> +	u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> +	unsigned int nr_sensors;
> +	unsigned int nr_registers;
> +	unsigned long last_updated;
> +};
> +
> +struct asus_wmi_sensors {
> +	/* lock access to instrnal cache */
> +	struct mutex lock;
> +	struct asus_wmi_ec_info ec;
> +
> +	int ec_board;
> +};
> +
> +struct asus_wmi_data {
> +	int ec_board;
> +};
> +
> +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec, int board)
> +{
> +	const enum known_ec_sensor *bsi = known_board_sensors[board];
> +	struct ec_sensor *s = ec->sensors;
> +	int i;
> +
> +	ec->nr_sensors = 0;
> +	ec->nr_registers = 0;
> +
> +	for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> +		s[i].info_index = bsi[i];
> +		s[i].cached_value = 0;
> +		ec->nr_sensors++;
> +		ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
> +	}
> +}
> +
> +/*
> + * The next four functions converts to/from BRxx string argument format
> + * The format of the string is as follows:
> + * The string consists of two-byte UTF-16 characters
> + * The value of the very first byte int 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 pairs of (bank, index) pairs, where both
> + * values are byte-long (0x00 to 0xFF)
> + * Numbers are encoded as UTF-16 hex values
> + */
> +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> +{
> +	unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
> +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> +	const char *pos = buffer;
> +	const u8 *data = inp + 2;
> +	unsigned int i;
> +
> +	utf16s_to_utf8s((wchar_t *)data, len * 2,  UTF16_LITTLE_ENDIAN, buffer, len * 2);
> +
> +	for (i = 0; i < len; i++, pos += 2)
> +		out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
> +}
> +
> +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
> +{
> +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> +	char *pos = buffer;
> +	unsigned int i;
> +	u8 byte;
> +
> +	*out++ = len * 8;
> +	*out++ = 0;
> +
> +	for (i = 0; i < len; i++) {
> +		byte = registers[i] >> 8;
> +		*pos = hex_asc_hi(byte);
> +		pos++;
> +		*pos = hex_asc_lo(byte);
> +		pos++;
> +		byte = registers[i];
> +		*pos = hex_asc_hi(byte);
> +		pos++;
> +		*pos = hex_asc_lo(byte);
> +		pos++;
> +	}
> +
> +	utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
> +}
> +
> +static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
> +{
> +	u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> +	const struct ec_sensor_info *si;
> +	long i, j, register_idx = 0;
> +
> +	/*
> +	 * if we can get values for all the registers in a single query,
> +	 * the query will not change from call to call
> +	 */
> +	if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX &&
> +	    ec->read_arg[0] > 0) {
> +		/* no need to update */
> +		return;
> +	}
> +
> +	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++, register_idx++) {
> +			registers[register_idx] = (si->addr.bank << 8) + si->addr.index + j;
> +		}
> +	}
> +
> +	asus_wmi_ec_encode_registers(registers, ec->nr_registers, 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;
> +
> +	/* the first byte of the BRxx() argument string has to be the string size */
> +	input.length = (acpi_size)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 || obj->type != ACPI_TYPE_BUFFER) {
> +		if (!obj)
> +			acpi_os_free(output.pointer);
> +
> +		return -EIO;
> +	}
> +	asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> +	acpi_os_free(output.pointer);
> +	return 0;
> +}
> +
> +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
> +{
> +	const struct ec_sensor_info *si;
> +	struct ec_sensor *s;
> +
> +	u32 value;
> +	int status;
> +	u8 i_sensor, read_reg_ct;
> +
> +	asus_wmi_ec_make_block_read_query(ec);
> +	status = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> +					ec->read_arg,
> +					ec->read_buffer);
> +	if (status)
> +		return status;
> +
> +	read_reg_ct = 0;
> +	for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> +		s = &ec->sensors[i_sensor];
> +		si = &known_ec_sensors[s->info_index];
> +
> +		if (si->addr.size == 1)
> +			value = ec->read_buffer[read_reg_ct];
> +		else if (si->addr.size == 2)
> +			value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> +		else if (si->addr.size == 4)
> +			value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
> +
> +		read_reg_ct += si->addr.size;
> +		s->cached_value = value;
> +	}
> +	return 0;
> +}
> +
> +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> +{
> +	switch (data_type) {
> +	case hwmon_curr:
> +	case hwmon_temp:
> +	case hwmon_in:
> +		return value * KILO;
> +	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(int sensor_index,
> +						  struct asus_wmi_sensors *state,
> +						  u32 *value)
> +{
> +	int ret;
> +
> +	if (time_after(jiffies, state->ec.last_updated + HZ)) {
> +		ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> +		if (ret)
> +			return ret;
> +
> +		state->ec.last_updated = jiffies;
> +	}
> +
> +	*value = state->ec.sensors[sensor_index].cached_value;
> +	return 0;
> +}
> +
> +/*
> + * 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);
> +	int ret, sidx, info_index;
> +	u32 value = 0;
> +
> +	sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +	if (sidx < 0)
> +		return sidx;
> +
> +	mutex_lock(&sensor_data->lock);
> +	ret = asus_wmi_ec_get_cached_value_or_update(sidx, sensor_data, &value);
> +	mutex_unlock(&sensor_data->lock);
> +	if (ret)
> +		return ret;
> +
> +	info_index = sensor_data->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);
> +	int sensor_index;
> +
> +	sensor_index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +	*str = known_ec_sensors[sensor_data->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)
> +{
> +	int index;
> +	const struct asus_wmi_sensors *sensor_data = drvdata;
> +
> +	index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +
> +	return index == 0xff ? 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 platform_device *pdev,
> +					      struct asus_wmi_sensors *sensor_data)
> +{
> +	struct hwmon_channel_info *asus_wmi_hwmon_chan;
> +	const struct hwmon_channel_info **ptr_asus_wmi_ci;
> +	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> +	const struct hwmon_chip_info *chip_info;
> +	struct device *dev = &pdev->dev;
> +	const struct ec_sensor_info *si;
> +	enum hwmon_sensor_types type;
> +	struct device *hwdev;
> +	int i;
> +
> +	asus_wmi_ec_fill_board_sensors(&sensor_data->ec, sensor_data->ec_board);
> +
> +	if (!sensor_data->ec.nr_sensors)
> +		return -ENODEV;
> +
> +	for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> +		si = &known_ec_sensors[sensor_data->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++;
> +	}
> +
> +	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_ec_chip_info.info = ptr_asus_wmi_ci;
> +	chip_info = &asus_wmi_ec_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_dbg(&pdev->dev, "%s board has %d EC sensors that span %d registers",
> +		asus_wmi_ec_boards_names[sensor_data->ec_board],
> +		sensor_data->ec.nr_sensors,
> +		sensor_data->ec.nr_registers);
> +
> +	hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
> +						     sensor_data, chip_info, NULL);
> +
> +	return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int asus_wmi_probe(struct platform_device *pdev)
> +{
> +	struct asus_wmi_sensors *sensor_data;
> +	struct device *dev = &pdev->dev;
> +	struct asus_wmi_data *data;
> +
> +	data = dev_get_platdata(dev);
> +
> +	sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
> +				   GFP_KERNEL);
> +	if (!sensor_data)
> +		return -ENOMEM;
> +
> +	mutex_init(&sensor_data->lock);
> +	sensor_data->ec_board = data->ec_board;
> +
> +	platform_set_drvdata(pdev, sensor_data);
> +
> +	/* ec init */
> +	return asus_wmi_ec_configure_sensor_setup(pdev,
> +						  sensor_data);
> +}
> +
> +static struct platform_driver asus_wmi_sensors_platform_driver = {
> +	.driver = {
> +		.name	= "asus-wmi-sensors",
> +	},
> +	.probe = asus_wmi_probe,
> +};
> +
> +static struct platform_device *sensors_pdev;
> +
> +static int __init asus_wmi_init(void)
> +{
> +	const char *board_vendor, *board_name;
> +	struct asus_wmi_data data;
> +
> +	data.ec_board = -1;
> +
> +	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> +	board_name = dmi_get_system_info(DMI_BOARD_NAME);
> +
> +	if (board_vendor && board_name &&
> +	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> +		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> +			return -ENODEV;
> +
> +		data.ec_board = match_string(asus_wmi_ec_boards_names,
> +					     ARRAY_SIZE(asus_wmi_ec_boards_names),
> +					     board_name);
> +	}
> +
> +	/* Nothing to support */
> +	if (data.ec_board < 0)
> +		return -ENODEV;
> +
> +	sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
> +					      asus_wmi_probe,
> +					      NULL, 0,
> +					      &data, sizeof(struct asus_wmi_data));
> +
> +	return PTR_ERR_OR_ZERO(sensors_pdev);
> +}
> +module_init(asus_wmi_init);
> +
> +static void __exit asus_wmi_exit(void)
> +{
> +	platform_device_unregister(sensors_pdev);
> +	platform_driver_unregister(&asus_wmi_sensors_platform_driver);
> +}
> +module_exit(asus_wmi_exit);
> +
> +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> +MODULE_LICENSE("GPL");
> 

Re: [PATCH v2 3/3] hwmon: (asus_wmi_sensors) Support X370 Asus WMI.

[Guenter Roeck]

On 10/6/21 3:25 PM, Denis Pauk wrote:
> Provides a Linux kernel module "asus_wmi_sensors" that provides sensor
> readouts via ASUS' WMI interface present in the UEFI of
> X370/X470/B450/X399 Ryzen motherboards.
> 
> Supported motherboards:
> * ROG CROSSHAIR VI HERO,
> * PRIME X399-A,
> * PRIME X470-PRO,
> * ROG CROSSHAIR VI EXTREME,
> * ROG CROSSHAIR VI HERO (WI-FI AC),
> * ROG CROSSHAIR VII HERO,
> * ROG CROSSHAIR VII HERO (WI-FI),
> * ROG STRIX B450-E GAMING,
> * ROG STRIX B450-F GAMING,
> * ROG STRIX B450-I GAMING,
> * ROG STRIX X399-E GAMING,
> * ROG STRIX X470-F GAMING,
> * ROG STRIX X470-I GAMING,
> * ROG ZENITH EXTREME,
> * ROG ZENITH EXTREME ALPHA.
> 
> BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> Co-developed-by: Ed Brindley <kernel@maidavale.org>
> Signed-off-by: Ed Brindley <kernel@maidavale.org>
> 
> ---
> Changes in v2:
> - Add module for boards with support of WMI interface returned sensor name and
>     value of sensor..
> ---
>   MAINTAINERS                      |   1 +
>   drivers/hwmon/Kconfig            |  11 +
>   drivers/hwmon/Makefile           |   1 +
>   drivers/hwmon/asus_wmi_sensors.c | 661 +++++++++++++++++++++++++++++++

New drivers also need to be documented in Documentation/hwmon/.

How does this differ from the hwmon device instantiated from
drivers/platform/x86/asus-wmi.c ?

Guenter

>   4 files changed, 674 insertions(+)
>   create mode 100644 drivers/hwmon/asus_wmi_sensors.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index bc2e981a54e2..3f77d1d17841 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -2942,6 +2942,7 @@ 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_sensors.c
>   F:	drivers/hwmon/asus_wmi_ec_sensors.c
>   
>   ASUS WIRELESS RADIO CONTROL DRIVER
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index b7107721a401..ddb1d251d81a 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
>   	  This driver can also be built as a module. If so, the module
>   	  will be called asus_atk0110.
>   
> +config SENSORS_ASUS_WMI
> +	tristate "ASUS WMI X370/X470/B450/X399"
> +	help
> +	  If you say yes here you get support for the ACPI hardware monitoring
> +	  interface found in X370/X470/B450/X399 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.
> +
>   config SENSORS_ASUS_WMI_EC
>   	tristate "ASUS WMI B550/X570"
>   	help
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index aae2ff5c7335..656a6191a0f8 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_WMI)	+= asus_wmi_sensors.o
>   obj-$(CONFIG_SENSORS_ASUS_WMI_EC)	+= asus_wmi_ec_sensors.o
>   
>   # Native drivers
> diff --git a/drivers/hwmon/asus_wmi_sensors.c b/drivers/hwmon/asus_wmi_sensors.c
> new file mode 100644
> index 000000000000..792872b068d7
> --- /dev/null
> +++ b/drivers/hwmon/asus_wmi_sensors.c
> @@ -0,0 +1,661 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * HWMON driver for ASUS motherboards that provides sensor readouts via WMI
> + * interface present in the UEFI of the X370/X470/B450/X399 Ryzen motherboards.
> + *
> + * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
> + * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
> + *
> + * WMI interface provided:
> + * CPU Core Voltage,
> + * CPU SOC Voltage,
> + * DRAM Voltage,
> + * VDDP Voltage,
> + * 1.8V PLL Voltage,
> + * +12V Voltage,
> + * +5V Voltage,
> + * 3VSB Voltage,
> + * VBAT Voltage,
> + * AVCC3 Voltage,
> + * SB 1.05V Voltage,
> + * CPU Core Voltage,
> + * CPU SOC Voltage,
> + * DRAM Voltage,
> + * CPU Fan,
> + * Chassis Fan 1,
> + * Chassis Fan 2,
> + * Chassis Fan 3,
> + * HAMP Fan,
> + * Water Pump,
> + * CPU OPT,
> + * Water Flow,
> + * AIO Pump,
> + * CPU Temperature,
> + * CPU Socket Temperature,
> + * Motherboard Temperature,
> + * Chipset Temperature,
> + * Tsensor 1 Temperature,
> + * CPU VRM Temperature,
> + * Water In,
> + * Water Out,
> + * CPU VRM Output Current.
> + */
> +#include <linux/acpi.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/init.h>
> +#include <linux/jiffies.h>
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/platform_device.h>
> +#include <linux/units.h>
> +#include <linux/wmi.h>
> +
> +#define ASUSWMI_MONITORING_GUID		"466747A0-70EC-11DE-8A39-0800200C9A66"
> +#define ASUSWMI_METHODID_GET_VALUE	0x52574543
> +#define ASUSWMI_METHODID_UPDATE_BUFFER	0x51574543
> +#define ASUSWMI_METHODID_GET_INFO	0x50574543
> +#define ASUSWMI_METHODID_GET_NUMBER		0x50574572
> +#define ASUSWMI_METHODID_GET_VERSION		0x50574574
> +
> +#define ASUS_WMI_MAX_STR_SIZE	32
> +
> +/* boards with wmi sensors support */
> +static const char *const asus_wmi_boards_names[] = {
> +	"ROG CROSSHAIR VI HERO",
> +	"PRIME X399-A",
> +	"PRIME X470-PRO",
> +	"ROG CROSSHAIR VI EXTREME",
> +	"ROG CROSSHAIR VI HERO (WI-FI AC)",
> +	"ROG CROSSHAIR VII HERO",
> +	"ROG CROSSHAIR VII HERO (WI-FI)",
> +	"ROG STRIX B450-E GAMING",
> +	"ROG STRIX B450-F GAMING",
> +	"ROG STRIX B450-I GAMING",
> +	"ROG STRIX X399-E GAMING",
> +	"ROG STRIX X470-F GAMING",
> +	"ROG STRIX X470-I GAMING",
> +	"ROG ZENITH EXTREME",
> +	"ROG ZENITH EXTREME ALPHA",
> +};
> +
> +enum asus_wmi_sensor_class {
> +	VOLTAGE = 0x0,
> +	TEMPERATURE_C = 0x1,
> +	FAN_RPM = 0x2,
> +	CURRENT = 0x3,
> +	WATER_FLOW = 0x4,
> +};
> +
> +enum asus_wmi_location {
> +	CPU = 0x0,
> +	CPU_SOC = 0x1,
> +	DRAM = 0x2,
> +	MOTHERBOARD = 0x3,
> +	CHIPSET = 0x4,
> +	AUX = 0x5,
> +	VRM = 0x6,
> +	COOLER = 0x7
> +};
> +
> +enum asus_wmi_type {
> +	SIGNED_INT = 0x0,
> +	UNSIGNED_INT = 0x1,
> +	SCALED = 0x3,
> +};
> +
> +enum asus_wmi_source {
> +	SIO = 0x1,
> +	EC = 0x2
> +};
> +
> +static enum hwmon_sensor_types asus_data_types[] = {
> +	[VOLTAGE] = hwmon_in,
> +	[TEMPERATURE_C] = hwmon_temp,
> +	[FAN_RPM] = hwmon_fan,
> +	[CURRENT] = hwmon_curr,
> +	[WATER_FLOW] = hwmon_fan,
> +};
> +
> +static u32 hwmon_attributes[] = {
> +	[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_sensor_info - sensor info.
> + * @id: sensor id.
> + * @data_type: sensor class e.g. voltage, temp etc.
> + * @location: sensor location.
> + * @name: sensor name.
> + * @source: sensor source.
> + * @type: sensor type signed, unsigned etc.
> + * @cached_value: cached sensor value.
> + */
> +struct asus_wmi_sensor_info {
> +	u32 id;
> +	int data_type;
> +	int location;
> +	char name[ASUS_WMI_MAX_STR_SIZE];
> +	int source;
> +	int type;
> +	u32 cached_value;
> +};
> +
> +struct asus_wmi_wmi_info {
> +	u8 buffer;
> +	unsigned long source_last_updated[3];	/* in jiffies */
> +	u8 sensor_count;
> +
> +	const struct asus_wmi_sensor_info **info[hwmon_max];
> +	struct asus_wmi_sensor_info **info_by_id;
> +};
> +
> +struct asus_wmi_sensors {
> +	/* lock access to instrnal cache */
> +	struct mutex lock;
> +	struct asus_wmi_wmi_info wmi;
> +
> +	int wmi_board;
> +};
> +
> +struct asus_wmi_data {
> +	int wmi_board;
> +	int wmi_count;
> +};
> +
> +/*
> + * Universal method for calling WMI method
> + */
> +static int asus_wmi_call_method(u32 method_id, u32 *args, struct acpi_buffer *output)
> +{
> +	struct acpi_buffer input = {(acpi_size) sizeof(*args), args };
> +	acpi_status status;
> +
> +	status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, method_id, &input, output);
> +	if (ACPI_FAILURE(status))
> +		return -EIO;
> +
> +	return 0;
> +}
> +
> +/*
> + * Gets the version of the ASUS sensors interface implemented
> + */
> +static int asus_wmi_get_version(u32 *version)
> +{
> +	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
> +	u32 args[] = {0, 0, 0};
> +	union acpi_object *obj;
> +	int err;
> +
> +	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_VERSION, args, &output);
> +	if (err)
> +		return err;
> +
> +	obj = output.pointer;
> +	if (!obj || obj->type != ACPI_TYPE_INTEGER)
> +		return -EIO;
> +
> +	*version = obj->integer.value;
> +
> +	return 0;
> +}
> +
> +/*
> + * Gets the number of sensor items
> + */
> +static int asus_wmi_get_item_count(u32 *count)
> +{
> +	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
> +	u32 args[] = {0, 0, 0};
> +	union acpi_object *obj;
> +	int err;
> +
> +	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_NUMBER, args, &output);
> +	if (err)
> +		return err;
> +
> +	obj = output.pointer;
> +	if (!obj || obj->type != ACPI_TYPE_INTEGER)
> +		return -EIO;
> +
> +	*count = obj->integer.value;
> +
> +	return 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)
> +{
> +	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;
> +}
> +
> +/*
> + * For a given sensor item returns details e.g. type (voltage/temperature/fan speed etc), bank etc
> + */
> +static int asus_wmi_sensor_info(int index, struct asus_wmi_sensor_info *s)
> +{
> +	union acpi_object name_obj, data_type_obj, location_obj, source_obj, type_obj;
> +	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
> +	u32 args[] = {index, 0};
> +	union acpi_object *obj;
> +	int err;
> +
> +	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_INFO, args, &output);
> +	if (err)
> +		return err;
> +
> +	s->id = index;
> +
> +	obj = output.pointer;
> +	if (!obj || obj->type != ACPI_TYPE_PACKAGE)
> +		return -EIO;
> +
> +	if (obj->package.count != 5)
> +		return 1;
> +
> +	name_obj = obj->package.elements[0];
> +
> +	if (name_obj.type != ACPI_TYPE_STRING)
> +		return 1;
> +
> +	strncpy(s->name, name_obj.string.pointer, sizeof(s->name) - 1);
> +
> +	data_type_obj = obj->package.elements[1];
> +
> +	if (data_type_obj.type != ACPI_TYPE_INTEGER)
> +		return 1;
> +
> +	s->data_type = data_type_obj.integer.value;
> +
> +	location_obj = obj->package.elements[2];
> +
> +	if (location_obj.type != ACPI_TYPE_INTEGER)
> +		return 1;
> +
> +	s->location = location_obj.integer.value;
> +
> +	source_obj = obj->package.elements[3];
> +
> +	if (source_obj.type != ACPI_TYPE_INTEGER)
> +		return 1;
> +
> +	s->source = source_obj.integer.value;
> +
> +	type_obj = obj->package.elements[4];
> +
> +	if (type_obj.type != ACPI_TYPE_INTEGER)
> +		return 1;
> +
> +	s->type = type_obj.integer.value;
> +
> +	return 0;
> +}
> +
> +static int asus_wmi_update_buffer(u8 source)
> +{
> +	u32 args[] = {source, 0};
> +	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
> +
> +	return asus_wmi_call_method(ASUSWMI_METHODID_UPDATE_BUFFER, args, &output);
> +}
> +
> +static int asus_wmi_get_sensor_value(u8 index, u32 *value)
> +{
> +	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
> +	u32 args[] = {index, 0};
> +	union acpi_object *obj;
> +	int err;
> +
> +	err = asus_wmi_call_method(ASUSWMI_METHODID_GET_VALUE, args, &output);
> +	if (err)
> +		return err;
> +
> +	obj = output.pointer;
> +	if (!obj || obj->type != ACPI_TYPE_INTEGER)
> +		return -EIO;
> +
> +	*value = obj->integer.value;
> +
> +	return 0;
> +}
> +
> +static void asus_wmi_update_values_for_source(u8 source, struct asus_wmi_sensors *sensor_data)
> +{
> +	int ret = 0;
> +	int value = 0;
> +	int i;
> +	struct asus_wmi_sensor_info *sensor;
> +
> +	for (i = 0; i < sensor_data->wmi.sensor_count; i++) {
> +		sensor = sensor_data->wmi.info_by_id[i];
> +		if (sensor && sensor->source == source) {
> +			ret = asus_wmi_get_sensor_value(sensor->id, &value);
> +			if (!ret)
> +				sensor->cached_value = value;
> +		}
> +	}
> +}
> +
> +static int asus_wmi_scale_sensor_value(u32 value, int data_type)
> +{
> +	/* FAN_RPM and WATER_FLOW don't need scaling */
> +	switch (data_type) {
> +	case VOLTAGE:
> +		return DIV_ROUND_CLOSEST(value, 1000);
> +	case TEMPERATURE_C:
> +		return value * 1000;
> +	case CURRENT:
> +		return value * 1000;
> +	}
> +	return value;
> +}
> +
> +static int asus_wmi_get_cached_value_or_update(const struct asus_wmi_sensor_info *sensor,
> +					       struct asus_wmi_sensors *sensor_data,
> +					       u32 *value)
> +{
> +	int ret;
> +
> +	if (time_after(jiffies, sensor_data->wmi.source_last_updated[sensor->source] + HZ)) {
> +		ret = asus_wmi_update_buffer(sensor->source);
> +		if (ret)
> +			return -EIO;
> +
> +		sensor_data->wmi.buffer = sensor->source;
> +
> +		asus_wmi_update_values_for_source(sensor->source, sensor_data);
> +		sensor_data->wmi.source_last_updated[sensor->source] = jiffies;
> +	}
> +
> +	*value = sensor->cached_value;
> +	return 0;
> +}
> +
> +/*
> + * Now follow the functions that implement the hwmon interface
> + */
> +
> +static int asus_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
> +			       u32 attr, int channel, long *val)
> +{
> +	int ret;
> +	u32 value = 0;
> +	const struct asus_wmi_sensor_info *sensor;
> +
> +	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
> +
> +	sensor = *(sensor_data->wmi.info[type] + channel);
> +
> +	mutex_lock(&sensor_data->lock);
> +
> +	ret = asus_wmi_get_cached_value_or_update(sensor, sensor_data, &value);
> +	mutex_unlock(&sensor_data->lock);
> +
> +	if (!ret)
> +		*val = asus_wmi_scale_sensor_value(value, sensor->data_type);
> +
> +	return ret;
> +}
> +
> +static int asus_wmi_hwmon_read_string(struct device *dev,
> +				      enum hwmon_sensor_types type, u32 attr,
> +				      int channel, const char **str)
> +{
> +	const struct asus_wmi_sensor_info *sensor;
> +	struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
> +
> +	sensor = *(sensor_data->wmi.info[type] + channel);
> +	*str = sensor->name;
> +
> +	return 0;
> +}
> +
> +static umode_t asus_wmi_hwmon_is_visible(const void *drvdata,
> +					 enum hwmon_sensor_types type, u32 attr,
> +					 int channel)
> +{
> +	const struct asus_wmi_sensor_info *sensor;
> +	const struct asus_wmi_sensors *sensor_data = drvdata;
> +
> +	sensor = *(sensor_data->wmi.info[type] + channel);
> +	if (sensor && sensor->name)
> +		return 0444;
> +
> +	return 0;
> +}
> +
> +static const struct hwmon_ops asus_wmi_hwmon_ops = {
> +	.is_visible = asus_wmi_hwmon_is_visible,
> +	.read = asus_wmi_hwmon_read,
> +	.read_string = asus_wmi_hwmon_read_string,
> +};
> +
> +static struct hwmon_chip_info asus_wmi_chip_info = {
> +	.ops = &asus_wmi_hwmon_ops,
> +	.info = NULL,
> +};
> +
> +static int asus_wmi_configure_sensor_setup(struct platform_device *pdev,
> +					   struct asus_wmi_sensors *sensor_data)
> +{
> +	int err;
> +	int i, idx;
> +	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;
> +	struct asus_wmi_sensor_info *temp_sensor;
> +	enum hwmon_sensor_types type;
> +	const struct hwmon_channel_info **ptr_asus_wmi_ci;
> +	const struct hwmon_chip_info *chip_info;
> +
> +	sensor_data->wmi.buffer = -1;
> +	temp_sensor = devm_kcalloc(dev, 1, sizeof(*temp_sensor), GFP_KERNEL);
> +	if (!temp_sensor)
> +		return -ENOMEM;
> +
> +	for (i = 0; i < sensor_data->wmi.sensor_count; i++) {
> +		err = asus_wmi_sensor_info(i, temp_sensor);
> +		if (err)
> +			return -EINVAL;
> +
> +		switch (temp_sensor->data_type) {
> +		case TEMPERATURE_C:
> +		case VOLTAGE:
> +		case CURRENT:
> +		case FAN_RPM:
> +		case WATER_FLOW:
> +			type = asus_data_types[temp_sensor->data_type];
> +			if (!nr_count[type])
> +				nr_types++;
> +			nr_count[type]++;
> +			break;
> +		}
> +	}
> +
> +	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;
> +
> +	sensor_data->wmi.info_by_id = devm_kcalloc(dev, sensor_data->wmi.sensor_count,
> +						   sizeof(*sensor_data->wmi.info_by_id),
> +						   GFP_KERNEL);
> +
> +	if (!sensor_data->wmi.info_by_id)
> +		return -ENOMEM;
> +
> +	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++;
> +
> +		sensor_data->wmi.info[type] = devm_kcalloc(dev,
> +							   nr_count[type],
> +							   sizeof(*sensor_data->wmi.info),
> +							   GFP_KERNEL);
> +		if (!sensor_data->wmi.info[type])
> +			return -ENOMEM;
> +	}
> +
> +	for (i = sensor_data->wmi.sensor_count - 1; i >= 0 ; i--) {
> +		temp_sensor = devm_kzalloc(dev, sizeof(*temp_sensor), GFP_KERNEL);
> +		if (!temp_sensor)
> +			return -ENOMEM;
> +
> +		err = asus_wmi_sensor_info(i, temp_sensor);
> +		if (err)
> +			continue;
> +
> +		switch (temp_sensor->data_type) {
> +		case TEMPERATURE_C:
> +		case VOLTAGE:
> +		case CURRENT:
> +		case FAN_RPM:
> +		case WATER_FLOW:
> +			type = asus_data_types[temp_sensor->data_type];
> +			idx = --nr_count[type];
> +			*(sensor_data->wmi.info[type] + idx) = temp_sensor;
> +			sensor_data->wmi.info_by_id[i] = temp_sensor;
> +			break;
> +		}
> +	}
> +
> +	dev_dbg(&pdev->dev, "%s board has %d sensors",
> +		asus_wmi_boards_names[sensor_data->wmi_board],
> +		sensor_data->wmi.sensor_count);
> +
> +	hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
> +						     sensor_data, chip_info, NULL);
> +
> +	return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int asus_wmi_probe(struct platform_device *pdev)
> +{
> +	struct asus_wmi_sensors *sensor_data;
> +	struct device *dev = &pdev->dev;
> +	struct asus_wmi_data *data;
> +
> +	data = dev_get_platdata(dev);
> +
> +	sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
> +				   GFP_KERNEL);
> +	if (!sensor_data)
> +		return -ENOMEM;
> +
> +	mutex_init(&sensor_data->lock);
> +	sensor_data->wmi_board = data->wmi_board;
> +	sensor_data->wmi.sensor_count = data->wmi_count;
> +
> +	platform_set_drvdata(pdev, sensor_data);
> +
> +	return asus_wmi_configure_sensor_setup(pdev,
> +					       sensor_data);
> +	return 0;
> +}
> +
> +static struct platform_driver asus_wmi_sensors_platform_driver = {
> +	.driver = {
> +		.name	= "asus-wmi-sensors",
> +	},
> +	.probe = asus_wmi_probe,
> +};
> +
> +static struct platform_device *sensors_pdev;
> +
> +static int __init asus_wmi_init(void)
> +{
> +	const char *board_vendor, *board_name;
> +	u32 version = 0;
> +	struct asus_wmi_data data;
> +
> +	data.wmi_board = -1;
> +	data.wmi_count = 0;
> +
> +	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> +	board_name = dmi_get_system_info(DMI_BOARD_NAME);
> +
> +	if (board_vendor && board_name &&
> +	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> +		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> +			return -ENODEV;
> +
> +		data.wmi_board = match_string(asus_wmi_boards_names,
> +					      ARRAY_SIZE(asus_wmi_boards_names),
> +					      board_name);
> +
> +		if (data.wmi_board >= 0) {
> +			if (asus_wmi_get_item_count(&data.wmi_count))
> +				return -ENODEV;
> +
> +			if (asus_wmi_get_version(&version))
> +				return -ENODEV;
> +
> +			if (data.wmi_count  <= 0 || version < 2) {
> +				pr_err("Board: %s WMI wmi version: %u with %d sensors is unsupported\n",
> +				       board_name, version, data.wmi_count);
> +
> +				data.wmi_board = -ENODEV;
> +			}
> +		}
> +	}
> +
> +	/* Nothing to support */
> +	if (data.wmi_board < 0)
> +		return -ENODEV;
> +
> +	sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
> +					      asus_wmi_probe,
> +					      NULL, 0,
> +					      &data, sizeof(struct asus_wmi_data));
> +
> +	return PTR_ERR_OR_ZERO(sensors_pdev);
> +}
> +module_init(asus_wmi_init);
> +
> +static void __exit asus_wmi_exit(void)
> +{
> +	platform_device_unregister(sensors_pdev);
> +	platform_driver_unregister(&asus_wmi_sensors_platform_driver);
> +}
> +module_exit(asus_wmi_exit);
> +
> +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> +MODULE_LICENSE("GPL");
> 

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Guenter Roeck]

On 10/6/21 3:25 PM, Denis Pauk wrote:
> Linux HWMON sensors driver for ASUS motherboards to read
> sensors from the embedded controller.
> 
> Many ASUS motherboards do not publish all the available
> sensors via the Super I/O chip but the missing ones are
> available through the embedded controller (EC) registers.
> 
> This driver implements reading those sensor data via the
> WMI method BREC, which is known to be present in all ASUS
> motherboards based on the AMD 500 series chipsets (and
> probably is available in other models too). The driver
> needs to know exact register addresses for the sensors and
> thus support for each motherboard has to be added explicitly.
> 
> The EC registers do not provide critical values for the
> sensors and as such they are not published to the HWMON.
> 
> Supported motherboards:
> * ROG CROSSHAIR VIII HERO
> * ROG CROSSHAIR VIII DARK HERO
> * ROG CROSSHAIR VIII FORMULA
> * ROG STRIX X570-E GAMING
> * ROG STRIX B550-E GAMING
> 
> BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> 
> ---
> Changes in v2:
>   - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
>   - Use post increment.
>   - Use get_unaligned* for convert values.
>   - Use PTR_ERR_OR_ZERO.
>   - Specify per-board sensors in a declarative way (by Eugene Shalygin).
> ---
>   MAINTAINERS                         |   7 +
>   drivers/hwmon/Kconfig               |  13 +-
>   drivers/hwmon/Makefile              |   1 +
>   drivers/hwmon/asus_wmi_ec_sensors.c | 631 ++++++++++++++++++++++++++++

Documentation needed. Also,what is the difference to the hwmon device
instantiated from drivers/platform/x86/asus-wmi.c, and how is it guaranteed
that there is no overlap ?

Guenter

>   4 files changed, 651 insertions(+), 1 deletion(-)
>   create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index bae3f62f548f..bc2e981a54e2 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -2937,6 +2937,13 @@ W:	http://acpi4asus.sf.net
>   F:	drivers/platform/x86/asus*.c
>   F:	drivers/platform/x86/eeepc*.c
>   
> +ASUS WMI 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 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 7fde4c6e1e7f..b7107721a401 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
>   
>   config SENSORS_AMC6821
>   	tristate "Texas Instruments AMC6821"
> -	depends on I2C
> +	depends on I2C
>   	help
>   	  If you say yes here you get support for the Texas Instruments
>   	  AMC6821 hardware monitoring chips.
> @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
>   	  This driver can also be built as a module. If so, the module
>   	  will be called asus_atk0110.
>   
> +config SENSORS_ASUS_WMI_EC
> +	tristate "ASUS WMI B550/X570"
> +	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.
> +
>   endif # ACPI
>   
>   endif # HWMON
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index baee6a8d4dd1..aae2ff5c7335 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_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
> new file mode 100644
> index 000000000000..553d9ee8656d
> --- /dev/null
> +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> @@ -0,0 +1,631 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * 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 provided:
> + * Chipset temperature,
> + * CPU temperature,
> + * Motherboard temperature,
> + * T_Sensor temperature,
> + * VRM  temperature,
> + * Water In temperature,
> + * Water Out temperature,
> + * CPU Optional Fan,
> + * Chipset fan,
> + * Water Flow fan,
> + * CPU current.
> + *
> + */
> +#include <asm/unaligned.h>
> +#include <linux/acpi.h>
> +#include <linux/dmi.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.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/platform_device.h>
> +#include <linux/units.h>
> +#include <linux/wmi.h>
> +
> +#define ASUSWMI_MONITORING_GUID		"466747A0-70EC-11DE-8A39-0800200C9A66"
> +#define ASUSWMI_METHODID_BLOCK_READ_EC		0x42524543 /* BREC */
> +
> +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS DSDT source */
> +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value */
> +#define ASUS_WMI_MAX_BUF_LEN 0x80
> +#define MAX_SENSOR_LABEL_LENGTH 0x10
> +
> +enum asus_wmi_ec_board {
> +	BOARD_PW_X570_A, /* Pro WS X570-ACE */
> +	BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> +	BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> +	BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> +	BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> +	BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> +	BOARD_MAX
> +};
> +
> +/* boards with EC support */
> +static const char *const asus_wmi_ec_boards_names[] = {
> +	[BOARD_PW_X570_A] = "Pro WS X570-ACE",
> +	[BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> +	[BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> +	[BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> +	[BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> +	[BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> +};
> +
> +static u32 hwmon_attributes[] = {
> +	[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 {
> +	char label[MAX_SENSOR_LABEL_LENGTH];
> +	enum hwmon_sensor_types type;
> +	struct asus_wmi_ec_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,
> +	SENSOR_TEMP_CPU,
> +	SENSOR_TEMP_MB,
> +	SENSOR_TEMP_T_SENSOR,
> +	SENSOR_TEMP_VRM,
> +	SENSOR_FAN_CPU_OPT,
> +	SENSOR_FAN_CHIPSET,
> +	SENSOR_FAN_WATER_FLOW,
> +	SENSOR_CURR_CPU,
> +	SENSOR_TEMP_WATER_IN,
> +	SENSOR_TEMP_WATER_OUT,
> +	SENSOR_MAX
> +};
> +
> +/*
> + * Array of the 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_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),
> +};
> +
> +static const enum known_ec_sensor known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> +	[BOARD_PW_X570_A] = {
> +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> +		SENSOR_FAN_CHIPSET,
> +		SENSOR_MAX
> +	},
> +	[BOARD_R_C8H] = {
> +		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
> +	},
> +	[BOARD_R_C8DH] = { /* Same as Hero but without chipset fan */
> +		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
> +	},
> +	[BOARD_R_C8F] = { /* Same as Hero but without water */
> +		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
> +	},
> +	[BOARD_RS_B550_E_G] = {
> +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> +		SENSOR_FAN_CPU_OPT,
> +		SENSOR_CURR_CPU,
> +		SENSOR_MAX
> +	},
> +	[BOARD_RS_X570_E_G] = {
> +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
> +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> +		SENSOR_FAN_CHIPSET,
> +		SENSOR_MAX
> +	},
> +};
> +
> +struct ec_sensor {
> +	enum known_ec_sensor info_index;
> +	u32 cached_value;
> +};
> +
> +/**
> + * struct asus_wmi_ec_info - sensor info.
> + * @sensors: list of sensors.
> + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> + * @read_buffer: WMI function output.
> + * @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[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) + 1) * 2];
> +	u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> +	unsigned int nr_sensors;
> +	unsigned int nr_registers;
> +	unsigned long last_updated;
> +};
> +
> +struct asus_wmi_sensors {
> +	/* lock access to instrnal cache */
> +	struct mutex lock;
> +	struct asus_wmi_ec_info ec;
> +
> +	int ec_board;
> +};
> +
> +struct asus_wmi_data {
> +	int ec_board;
> +};
> +
> +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec, int board)
> +{
> +	const enum known_ec_sensor *bsi = known_board_sensors[board];
> +	struct ec_sensor *s = ec->sensors;
> +	int i;
> +
> +	ec->nr_sensors = 0;
> +	ec->nr_registers = 0;
> +
> +	for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> +		s[i].info_index = bsi[i];
> +		s[i].cached_value = 0;
> +		ec->nr_sensors++;
> +		ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
> +	}
> +}
> +
> +/*
> + * The next four functions converts to/from BRxx string argument format
> + * The format of the string is as follows:
> + * The string consists of two-byte UTF-16 characters
> + * The value of the very first byte int 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 pairs of (bank, index) pairs, where both
> + * values are byte-long (0x00 to 0xFF)
> + * Numbers are encoded as UTF-16 hex values
> + */
> +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> +{
> +	unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] / 4);
> +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> +	const char *pos = buffer;
> +	const u8 *data = inp + 2;
> +	unsigned int i;
> +
> +	utf16s_to_utf8s((wchar_t *)data, len * 2,  UTF16_LITTLE_ENDIAN, buffer, len * 2);
> +
> +	for (i = 0; i < len; i++, pos += 2)
> +		out[i] = (hex_to_bin(pos[0]) << 4) + hex_to_bin(pos[1]);
> +}
> +
> +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len, char *out)
> +{
> +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> +	char *pos = buffer;
> +	unsigned int i;
> +	u8 byte;
> +
> +	*out++ = len * 8;
> +	*out++ = 0;
> +
> +	for (i = 0; i < len; i++) {
> +		byte = registers[i] >> 8;
> +		*pos = hex_asc_hi(byte);
> +		pos++;
> +		*pos = hex_asc_lo(byte);
> +		pos++;
> +		byte = registers[i];
> +		*pos = hex_asc_hi(byte);
> +		pos++;
> +		*pos = hex_asc_lo(byte);
> +		pos++;
> +	}
> +
> +	utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN, (wchar_t *)out, len * 4);
> +}
> +
> +static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
> +{
> +	u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> +	const struct ec_sensor_info *si;
> +	long i, j, register_idx = 0;
> +
> +	/*
> +	 * if we can get values for all the registers in a single query,
> +	 * the query will not change from call to call
> +	 */
> +	if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX &&
> +	    ec->read_arg[0] > 0) {
> +		/* no need to update */
> +		return;
> +	}
> +
> +	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++, register_idx++) {
> +			registers[register_idx] = (si->addr.bank << 8) + si->addr.index + j;
> +		}
> +	}
> +
> +	asus_wmi_ec_encode_registers(registers, ec->nr_registers, 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;
> +
> +	/* the first byte of the BRxx() argument string has to be the string size */
> +	input.length = (acpi_size)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 || obj->type != ACPI_TYPE_BUFFER) {
> +		if (!obj)
> +			acpi_os_free(output.pointer);
> +
> +		return -EIO;
> +	}
> +	asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> +	acpi_os_free(output.pointer);
> +	return 0;
> +}
> +
> +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
> +{
> +	const struct ec_sensor_info *si;
> +	struct ec_sensor *s;
> +
> +	u32 value;
> +	int status;
> +	u8 i_sensor, read_reg_ct;
> +
> +	asus_wmi_ec_make_block_read_query(ec);
> +	status = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> +					ec->read_arg,
> +					ec->read_buffer);
> +	if (status)
> +		return status;
> +
> +	read_reg_ct = 0;
> +	for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> +		s = &ec->sensors[i_sensor];
> +		si = &known_ec_sensors[s->info_index];
> +
> +		if (si->addr.size == 1)
> +			value = ec->read_buffer[read_reg_ct];
> +		else if (si->addr.size == 2)
> +			value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> +		else if (si->addr.size == 4)
> +			value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);
> +
> +		read_reg_ct += si->addr.size;
> +		s->cached_value = value;
> +	}
> +	return 0;
> +}
> +
> +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> +{
> +	switch (data_type) {
> +	case hwmon_curr:
> +	case hwmon_temp:
> +	case hwmon_in:
> +		return value * KILO;
> +	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(int sensor_index,
> +						  struct asus_wmi_sensors *state,
> +						  u32 *value)
> +{
> +	int ret;
> +
> +	if (time_after(jiffies, state->ec.last_updated + HZ)) {
> +		ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> +		if (ret)
> +			return ret;
> +
> +		state->ec.last_updated = jiffies;
> +	}
> +
> +	*value = state->ec.sensors[sensor_index].cached_value;
> +	return 0;
> +}
> +
> +/*
> + * 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);
> +	int ret, sidx, info_index;
> +	u32 value = 0;
> +
> +	sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +	if (sidx < 0)
> +		return sidx;
> +
> +	mutex_lock(&sensor_data->lock);
> +	ret = asus_wmi_ec_get_cached_value_or_update(sidx, sensor_data, &value);
> +	mutex_unlock(&sensor_data->lock);
> +	if (ret)
> +		return ret;
> +
> +	info_index = sensor_data->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);
> +	int sensor_index;
> +
> +	sensor_index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +	*str = known_ec_sensors[sensor_data->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)
> +{
> +	int index;
> +	const struct asus_wmi_sensors *sensor_data = drvdata;
> +
> +	index = asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> +
> +	return index == 0xff ? 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 platform_device *pdev,
> +					      struct asus_wmi_sensors *sensor_data)
> +{
> +	struct hwmon_channel_info *asus_wmi_hwmon_chan;
> +	const struct hwmon_channel_info **ptr_asus_wmi_ci;
> +	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> +	const struct hwmon_chip_info *chip_info;
> +	struct device *dev = &pdev->dev;
> +	const struct ec_sensor_info *si;
> +	enum hwmon_sensor_types type;
> +	struct device *hwdev;
> +	int i;
> +
> +	asus_wmi_ec_fill_board_sensors(&sensor_data->ec, sensor_data->ec_board);
> +
> +	if (!sensor_data->ec.nr_sensors)
> +		return -ENODEV;
> +
> +	for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> +		si = &known_ec_sensors[sensor_data->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++;
> +	}
> +
> +	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_ec_chip_info.info = ptr_asus_wmi_ci;
> +	chip_info = &asus_wmi_ec_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_dbg(&pdev->dev, "%s board has %d EC sensors that span %d registers",
> +		asus_wmi_ec_boards_names[sensor_data->ec_board],
> +		sensor_data->ec.nr_sensors,
> +		sensor_data->ec.nr_registers);
> +
> +	hwdev = devm_hwmon_device_register_with_info(dev, KBUILD_MODNAME,
> +						     sensor_data, chip_info, NULL);
> +
> +	return PTR_ERR_OR_ZERO(hwdev);
> +}
> +
> +static int asus_wmi_probe(struct platform_device *pdev)
> +{
> +	struct asus_wmi_sensors *sensor_data;
> +	struct device *dev = &pdev->dev;
> +	struct asus_wmi_data *data;
> +
> +	data = dev_get_platdata(dev);
> +
> +	sensor_data = devm_kzalloc(dev, sizeof(struct asus_wmi_sensors),
> +				   GFP_KERNEL);
> +	if (!sensor_data)
> +		return -ENOMEM;
> +
> +	mutex_init(&sensor_data->lock);
> +	sensor_data->ec_board = data->ec_board;
> +
> +	platform_set_drvdata(pdev, sensor_data);
> +
> +	/* ec init */
> +	return asus_wmi_ec_configure_sensor_setup(pdev,
> +						  sensor_data);
> +}
> +
> +static struct platform_driver asus_wmi_sensors_platform_driver = {
> +	.driver = {
> +		.name	= "asus-wmi-sensors",
> +	},
> +	.probe = asus_wmi_probe,
> +};
> +
> +static struct platform_device *sensors_pdev;
> +
> +static int __init asus_wmi_init(void)
> +{
> +	const char *board_vendor, *board_name;
> +	struct asus_wmi_data data;
> +
> +	data.ec_board = -1;
> +
> +	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> +	board_name = dmi_get_system_info(DMI_BOARD_NAME);
> +
> +	if (board_vendor && board_name &&
> +	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> +		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> +			return -ENODEV;
> +
> +		data.ec_board = match_string(asus_wmi_ec_boards_names,
> +					     ARRAY_SIZE(asus_wmi_ec_boards_names),
> +					     board_name);
> +	}
> +
> +	/* Nothing to support */
> +	if (data.ec_board < 0)
> +		return -ENODEV;
> +
> +	sensors_pdev = platform_create_bundle(&asus_wmi_sensors_platform_driver,
> +					      asus_wmi_probe,
> +					      NULL, 0,
> +					      &data, sizeof(struct asus_wmi_data));
> +
> +	return PTR_ERR_OR_ZERO(sensors_pdev);
> +}
> +module_init(asus_wmi_init);
> +
> +static void __exit asus_wmi_exit(void)
> +{
> +	platform_device_unregister(sensors_pdev);
> +	platform_driver_unregister(&asus_wmi_sensors_platform_driver);
> +}
> +module_exit(asus_wmi_exit);
> +
> +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> +MODULE_LICENSE("GPL");
> 

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Denis Pauk]

On Thu, 7 Oct 2021 09:47:27 -0700
Guenter Roeck <linux@roeck-us.net> wrote:

> On 10/6/21 3:25 PM, Denis Pauk wrote:
> > Linux HWMON sensors driver for ASUS motherboards to read
> > sensors from the embedded controller.
> > 
> > Many ASUS motherboards do not publish all the available
> > sensors via the Super I/O chip but the missing ones are
> > available through the embedded controller (EC) registers.
> > 
> > This driver implements reading those sensor data via the
> > WMI method BREC, which is known to be present in all ASUS
> > motherboards based on the AMD 500 series chipsets (and
> > probably is available in other models too). The driver
> > needs to know exact register addresses for the sensors and
> > thus support for each motherboard has to be added explicitly.
> > 
> > The EC registers do not provide critical values for the
> > sensors and as such they are not published to the HWMON.
> > 
> > Supported motherboards:
> > * ROG CROSSHAIR VIII HERO
> > * ROG CROSSHAIR VIII DARK HERO
> > * ROG CROSSHAIR VIII FORMULA
> > * ROG STRIX X570-E GAMING
> > * ROG STRIX B550-E GAMING
> > 
> > BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> > Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> > Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> > Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> > 
> > ---
> > Changes in v2:
> >   - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
> >   - Use post increment.
> >   - Use get_unaligned* for convert values.
> >   - Use PTR_ERR_OR_ZERO.
> >   - Specify per-board sensors in a declarative way (by Eugene
> > Shalygin). ---
> >   MAINTAINERS                         |   7 +
> >   drivers/hwmon/Kconfig               |  13 +-
> >   drivers/hwmon/Makefile              |   1 +
> >   drivers/hwmon/asus_wmi_ec_sensors.c | 631
> > ++++++++++++++++++++++++++++  
> 
> Documentation needed. Also,what is the difference to the hwmon device
> instantiated from drivers/platform/x86/asus-wmi.c, and how is it
> guaranteed that there is no overlap ?
> 
> Guenter
> 

Both modules in patch series use "466747A0-70EC-11DE-8A39-0800200C9A66"
when asus-wmi uses "97845ED0-4E6D-11DE-8A39-0800200C9A66".

I will create documentation.

Thank you.
 
> >   4 files changed, 651 insertions(+), 1 deletion(-)
> >   create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
> > 
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index bae3f62f548f..bc2e981a54e2 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -2937,6 +2937,13 @@ W:	http://acpi4asus.sf.net
> >   F:	drivers/platform/x86/asus*.c
> >   F:	drivers/platform/x86/eeepc*.c
> >   
> > +ASUS WMI 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 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 7fde4c6e1e7f..b7107721a401 100644
> > --- a/drivers/hwmon/Kconfig
> > +++ b/drivers/hwmon/Kconfig
> > @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
> >   
> >   config SENSORS_AMC6821
> >   	tristate "Texas Instruments AMC6821"
> > -	depends on I2C
> > +	depends on I2C
> >   	help
> >   	  If you say yes here you get support for the Texas
> > Instruments AMC6821 hardware monitoring chips.
> > @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
> >   	  This driver can also be built as a module. If so, the
> > module will be called asus_atk0110.
> >   
> > +config SENSORS_ASUS_WMI_EC
> > +	tristate "ASUS WMI B550/X570"
> > +	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.
> > +
> >   endif # ACPI
> >   
> >   endif # HWMON
> > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> > index baee6a8d4dd1..aae2ff5c7335 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_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 new file mode 100644 index
> > 000000000000..553d9ee8656d --- /dev/null
> > +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> > @@ -0,0 +1,631 @@
> > +// SPDX-License-Identifier: GPL-2.0+
> > +/*
> > + * 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 provided:
> > + * Chipset temperature,
> > + * CPU temperature,
> > + * Motherboard temperature,
> > + * T_Sensor temperature,
> > + * VRM  temperature,
> > + * Water In temperature,
> > + * Water Out temperature,
> > + * CPU Optional Fan,
> > + * Chipset fan,
> > + * Water Flow fan,
> > + * CPU current.
> > + *
> > + */
> > +#include <asm/unaligned.h>
> > +#include <linux/acpi.h>
> > +#include <linux/dmi.h>
> > +#include <linux/hwmon.h>
> > +#include <linux/hwmon-sysfs.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/platform_device.h>
> > +#include <linux/units.h>
> > +#include <linux/wmi.h>
> > +
> > +#define ASUSWMI_MONITORING_GUID
> > "466747A0-70EC-11DE-8A39-0800200C9A66" +#define
> > ASUSWMI_METHODID_BLOCK_READ_EC		0x42524543 /* BREC */
> > + +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS
> > DSDT source */ +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value
> > */ +#define ASUS_WMI_MAX_BUF_LEN 0x80
> > +#define MAX_SENSOR_LABEL_LENGTH 0x10
> > +
> > +enum asus_wmi_ec_board {
> > +	BOARD_PW_X570_A, /* Pro WS X570-ACE */
> > +	BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> > +	BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> > +	BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> > +	BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> > +	BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> > +	BOARD_MAX
> > +};
> > +
> > +/* boards with EC support */
> > +static const char *const asus_wmi_ec_boards_names[] = {
> > +	[BOARD_PW_X570_A] = "Pro WS X570-ACE",
> > +	[BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> > +	[BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> > +	[BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> > +	[BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> > +	[BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> > +};
> > +
> > +static u32 hwmon_attributes[] = {
> > +	[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 {
> > +	char label[MAX_SENSOR_LABEL_LENGTH];
> > +	enum hwmon_sensor_types type;
> > +	struct asus_wmi_ec_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,
> > +	SENSOR_TEMP_CPU,
> > +	SENSOR_TEMP_MB,
> > +	SENSOR_TEMP_T_SENSOR,
> > +	SENSOR_TEMP_VRM,
> > +	SENSOR_FAN_CPU_OPT,
> > +	SENSOR_FAN_CHIPSET,
> > +	SENSOR_FAN_WATER_FLOW,
> > +	SENSOR_CURR_CPU,
> > +	SENSOR_TEMP_WATER_IN,
> > +	SENSOR_TEMP_WATER_OUT,
> > +	SENSOR_MAX
> > +};
> > +
> > +/*
> > + * Array of the 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_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), +};
> > +
> > +static const enum known_ec_sensor
> > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > +	[BOARD_PW_X570_A] = {
> > +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > +		SENSOR_FAN_CHIPSET,
> > +		SENSOR_MAX
> > +	},
> > +	[BOARD_R_C8H] = {
> > +		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
> > +	},
> > +	[BOARD_R_C8DH] = { /* Same as Hero but without chipset fan
> > */
> > +		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
> > +	},
> > +	[BOARD_R_C8F] = { /* Same as Hero but without water */
> > +		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
> > +	},
> > +	[BOARD_RS_B550_E_G] = {
> > +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > +		SENSOR_FAN_CPU_OPT,
> > +		SENSOR_CURR_CPU,
> > +		SENSOR_MAX
> > +	},
> > +	[BOARD_RS_X570_E_G] = {
> > +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > +		SENSOR_FAN_CHIPSET,
> > +		SENSOR_MAX
> > +	},
> > +};
> > +
> > +struct ec_sensor {
> > +	enum known_ec_sensor info_index;
> > +	u32 cached_value;
> > +};
> > +
> > +/**
> > + * struct asus_wmi_ec_info - sensor info.
> > + * @sensors: list of sensors.
> > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > + * @read_buffer: WMI function output.
> > + * @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[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) +
> > 1) * 2];
> > +	u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > +	unsigned int nr_sensors;
> > +	unsigned int nr_registers;
> > +	unsigned long last_updated;
> > +};
> > +
> > +struct asus_wmi_sensors {
> > +	/* lock access to instrnal cache */
> > +	struct mutex lock;
> > +	struct asus_wmi_ec_info ec;
> > +
> > +	int ec_board;
> > +};
> > +
> > +struct asus_wmi_data {
> > +	int ec_board;
> > +};
> > +
> > +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info
> > *ec, int board) +{
> > +	const enum known_ec_sensor *bsi =
> > known_board_sensors[board];
> > +	struct ec_sensor *s = ec->sensors;
> > +	int i;
> > +
> > +	ec->nr_sensors = 0;
> > +	ec->nr_registers = 0;
> > +
> > +	for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> > +		s[i].info_index = bsi[i];
> > +		s[i].cached_value = 0;
> > +		ec->nr_sensors++;
> > +		ec->nr_registers +=
> > known_ec_sensors[bsi[i]].addr.size;
> > +	}
> > +}
> > +
> > +/*
> > + * The next four functions converts to/from BRxx string argument
> > format
> > + * The format of the string is as follows:
> > + * The string consists of two-byte UTF-16 characters
> > + * The value of the very first byte int 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 pairs of (bank, index) pairs,
> > where both
> > + * values are byte-long (0x00 to 0xFF)
> > + * Numbers are encoded as UTF-16 hex values
> > + */
> > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > +{
> > +	unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > 4);
> > +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > +	const char *pos = buffer;
> > +	const u8 *data = inp + 2;
> > +	unsigned int i;
> > +
> > +	utf16s_to_utf8s((wchar_t *)data, len * 2,
> > UTF16_LITTLE_ENDIAN, buffer, len * 2); +
> > +	for (i = 0; i < len; i++, pos += 2)
> > +		out[i] = (hex_to_bin(pos[0]) << 4) +
> > hex_to_bin(pos[1]); +}
> > +
> > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > char *out) +{
> > +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > +	char *pos = buffer;
> > +	unsigned int i;
> > +	u8 byte;
> > +
> > +	*out++ = len * 8;
> > +	*out++ = 0;
> > +
> > +	for (i = 0; i < len; i++) {
> > +		byte = registers[i] >> 8;
> > +		*pos = hex_asc_hi(byte);
> > +		pos++;
> > +		*pos = hex_asc_lo(byte);
> > +		pos++;
> > +		byte = registers[i];
> > +		*pos = hex_asc_hi(byte);
> > +		pos++;
> > +		*pos = hex_asc_lo(byte);
> > +		pos++;
> > +	}
> > +
> > +	utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > (wchar_t *)out, len * 4); +}
> > +
> > +static void asus_wmi_ec_make_block_read_query(struct
> > asus_wmi_ec_info *ec) +{
> > +	u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > +	const struct ec_sensor_info *si;
> > +	long i, j, register_idx = 0;
> > +
> > +	/*
> > +	 * if we can get values for all the registers in a single
> > query,
> > +	 * the query will not change from call to call
> > +	 */
> > +	if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX
> > &&
> > +	    ec->read_arg[0] > 0) {
> > +		/* no need to update */
> > +		return;
> > +	}
> > +
> > +	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++, register_idx++) {
> > +			registers[register_idx] = (si->addr.bank
> > << 8) + si->addr.index + j;
> > +		}
> > +	}
> > +
> > +	asus_wmi_ec_encode_registers(registers, ec->nr_registers,
> > 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;
> > +
> > +	/* the first byte of the BRxx() argument string has to be
> > the string size */
> > +	input.length = (acpi_size)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 || obj->type != ACPI_TYPE_BUFFER) {
> > +		if (!obj)
> > +			acpi_os_free(output.pointer);
> > +
> > +		return -EIO;
> > +	}
> > +	asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> > +	acpi_os_free(output.pointer);
> > +	return 0;
> > +}
> > +
> > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > *ec) +{
> > +	const struct ec_sensor_info *si;
> > +	struct ec_sensor *s;
> > +
> > +	u32 value;
> > +	int status;
> > +	u8 i_sensor, read_reg_ct;
> > +
> > +	asus_wmi_ec_make_block_read_query(ec);
> > +	status =
> > asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> > +					ec->read_arg,
> > +					ec->read_buffer);
> > +	if (status)
> > +		return status;
> > +
> > +	read_reg_ct = 0;
> > +	for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> > +		s = &ec->sensors[i_sensor];
> > +		si = &known_ec_sensors[s->info_index];
> > +
> > +		if (si->addr.size == 1)
> > +			value = ec->read_buffer[read_reg_ct];
> > +		else if (si->addr.size == 2)
> > +			value =
> > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > +		else if (si->addr.size == 4)
> > +			value =
> > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > +		read_reg_ct += si->addr.size;
> > +		s->cached_value = value;
> > +	}
> > +	return 0;
> > +}
> > +
> > +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> > +{
> > +	switch (data_type) {
> > +	case hwmon_curr:
> > +	case hwmon_temp:
> > +	case hwmon_in:
> > +		return value * KILO;
> > +	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(int sensor_index,
> > +						  struct
> > asus_wmi_sensors *state,
> > +						  u32 *value)
> > +{
> > +	int ret;
> > +
> > +	if (time_after(jiffies, state->ec.last_updated + HZ)) {
> > +		ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> > +		if (ret)
> > +			return ret;
> > +
> > +		state->ec.last_updated = jiffies;
> > +	}
> > +
> > +	*value = state->ec.sensors[sensor_index].cached_value;
> > +	return 0;
> > +}
> > +
> > +/*
> > + * 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);
> > +	int ret, sidx, info_index;
> > +	u32 value = 0;
> > +
> > +	sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel);
> > +	if (sidx < 0)
> > +		return sidx;
> > +
> > +	mutex_lock(&sensor_data->lock);
> > +	ret = asus_wmi_ec_get_cached_value_or_update(sidx,
> > sensor_data, &value);
> > +	mutex_unlock(&sensor_data->lock);
> > +	if (ret)
> > +		return ret;
> > +
> > +	info_index = sensor_data->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);
> > +	int sensor_index;
> > +
> > +	sensor_index =
> > asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> > +	*str =
> > known_ec_sensors[sensor_data->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)
> > +{
> > +	int index;
> > +	const struct asus_wmi_sensors *sensor_data = drvdata;
> > +
> > +	index = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel); +
> > +	return index == 0xff ? 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
> > platform_device *pdev,
> > +					      struct
> > asus_wmi_sensors *sensor_data) +{
> > +	struct hwmon_channel_info *asus_wmi_hwmon_chan;
> > +	const struct hwmon_channel_info **ptr_asus_wmi_ci;
> > +	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> > +	const struct hwmon_chip_info *chip_info;
> > +	struct device *dev = &pdev->dev;
> > +	const struct ec_sensor_info *si;
> > +	enum hwmon_sensor_types type;
> > +	struct device *hwdev;
> > +	int i;
> > +
> > +	asus_wmi_ec_fill_board_sensors(&sensor_data->ec,
> > sensor_data->ec_board); +
> > +	if (!sensor_data->ec.nr_sensors)
> > +		return -ENODEV;
> > +
> > +	for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> > +		si =
> > &known_ec_sensors[sensor_data->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++;
> > +	}
> > +
> > +	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_ec_chip_info.info = ptr_asus_wmi_ci;
> > +	chip_info = &asus_wmi_ec_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_dbg(&pdev->dev, "%s board has %d EC sensors that span
> > %d registers",
> > +		asus_wmi_ec_boards_names[sensor_data->ec_board],
> > +		sensor_data->ec.nr_sensors,
> > +		sensor_data->ec.nr_registers);
> > +
> > +	hwdev = devm_hwmon_device_register_with_info(dev,
> > KBUILD_MODNAME,
> > +						     sensor_data,
> > chip_info, NULL); +
> > +	return PTR_ERR_OR_ZERO(hwdev);
> > +}
> > +
> > +static int asus_wmi_probe(struct platform_device *pdev)
> > +{
> > +	struct asus_wmi_sensors *sensor_data;
> > +	struct device *dev = &pdev->dev;
> > +	struct asus_wmi_data *data;
> > +
> > +	data = dev_get_platdata(dev);
> > +
> > +	sensor_data = devm_kzalloc(dev, sizeof(struct
> > asus_wmi_sensors),
> > +				   GFP_KERNEL);
> > +	if (!sensor_data)
> > +		return -ENOMEM;
> > +
> > +	mutex_init(&sensor_data->lock);
> > +	sensor_data->ec_board = data->ec_board;
> > +
> > +	platform_set_drvdata(pdev, sensor_data);
> > +
> > +	/* ec init */
> > +	return asus_wmi_ec_configure_sensor_setup(pdev,
> > +						  sensor_data);
> > +}
> > +
> > +static struct platform_driver asus_wmi_sensors_platform_driver = {
> > +	.driver = {
> > +		.name	= "asus-wmi-sensors",
> > +	},
> > +	.probe = asus_wmi_probe,
> > +};
> > +
> > +static struct platform_device *sensors_pdev;
> > +
> > +static int __init asus_wmi_init(void)
> > +{
> > +	const char *board_vendor, *board_name;
> > +	struct asus_wmi_data data;
> > +
> > +	data.ec_board = -1;
> > +
> > +	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> > +	board_name = dmi_get_system_info(DMI_BOARD_NAME);
> > +
> > +	if (board_vendor && board_name &&
> > +	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> > +		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> > +			return -ENODEV;
> > +
> > +		data.ec_board =
> > match_string(asus_wmi_ec_boards_names,
> > +
> > ARRAY_SIZE(asus_wmi_ec_boards_names),
> > +					     board_name);
> > +	}
> > +
> > +	/* Nothing to support */
> > +	if (data.ec_board < 0)
> > +		return -ENODEV;
> > +
> > +	sensors_pdev =
> > platform_create_bundle(&asus_wmi_sensors_platform_driver,
> > +					      asus_wmi_probe,
> > +					      NULL, 0,
> > +					      &data, sizeof(struct
> > asus_wmi_data)); +
> > +	return PTR_ERR_OR_ZERO(sensors_pdev);
> > +}
> > +module_init(asus_wmi_init);
> > +
> > +static void __exit asus_wmi_exit(void)
> > +{
> > +	platform_device_unregister(sensors_pdev);
> > +
> > platform_driver_unregister(&asus_wmi_sensors_platform_driver); +}
> > +module_exit(asus_wmi_exit);
> > +
> > +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> > +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> > +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> > +MODULE_LICENSE("GPL");
> >   
> 

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Denis Pauk]

On Thu, 7 Oct 2021 09:41:30 -0700
Guenter Roeck <linux@roeck-us.net> wrote:

> On 10/6/21 3:25 PM, Denis Pauk wrote:
> > Linux HWMON sensors driver for ASUS motherboards to read
> > sensors from the embedded controller.
> > 
> > Many ASUS motherboards do not publish all the available
> > sensors via the Super I/O chip but the missing ones are
> > available through the embedded controller (EC) registers.
> > 
> > This driver implements reading those sensor data via the
> > WMI method BREC, which is known to be present in all ASUS
> > motherboards based on the AMD 500 series chipsets (and
> > probably is available in other models too). The driver
> > needs to know exact register addresses for the sensors and
> > thus support for each motherboard has to be added explicitly.
> > 
> > The EC registers do not provide critical values for the
> > sensors and as such they are not published to the HWMON.
> > 
> > Supported motherboards:
> > * ROG CROSSHAIR VIII HERO
> > * ROG CROSSHAIR VIII DARK HERO
> > * ROG CROSSHAIR VIII FORMULA
> > * ROG STRIX X570-E GAMING
> > * ROG STRIX B550-E GAMING
> > 
> > BugLink: https://bugzilla.kernel.org/show_bug.cgi?id=204807
> > Signed-off-by: Denis Pauk <pauk.denis@gmail.com>
> > Co-developed-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> > Signed-off-by: Eugene Shalygin <eugene.shalygin@gmail.com>
> > 
> > ---
> > Changes in v2:
> >   - Use utf8s_to_utf16s/utf16s_to_utf8s instead handmade fuctions.
> >   - Use post increment.
> >   - Use get_unaligned* for convert values.
> >   - Use PTR_ERR_OR_ZERO.
> >   - Specify per-board sensors in a declarative way (by Eugene
> > Shalygin). ---
> >   MAINTAINERS                         |   7 +
> >   drivers/hwmon/Kconfig               |  13 +-
> >   drivers/hwmon/Makefile              |   1 +
> >   drivers/hwmon/asus_wmi_ec_sensors.c | 631
> > ++++++++++++++++++++++++++++ 4 files changed, 651 insertions(+), 1
> > deletion(-) create mode 100644 drivers/hwmon/asus_wmi_ec_sensors.c
> > 
> > diff --git a/MAINTAINERS b/MAINTAINERS
> > index bae3f62f548f..bc2e981a54e2 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -2937,6 +2937,13 @@ W:	http://acpi4asus.sf.net
> >   F:	drivers/platform/x86/asus*.c
> >   F:	drivers/platform/x86/eeepc*.c
> >   
> > +ASUS WMI 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 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 7fde4c6e1e7f..b7107721a401 100644
> > --- a/drivers/hwmon/Kconfig
> > +++ b/drivers/hwmon/Kconfig
> > @@ -1840,7 +1840,7 @@ config SENSORS_ADS7871
> >   
> >   config SENSORS_AMC6821
> >   	tristate "Texas Instruments AMC6821"
> > -	depends on I2C
> > +	depends on I2C  
> 
> Completely unrelated and unacceptable change.
> 
Yes, I will remove it.

Thank you. 
> >   	help
> >   	  If you say yes here you get support for the Texas
> > Instruments AMC6821 hardware monitoring chips.
> > @@ -2215,6 +2215,17 @@ config SENSORS_ATK0110
> >   	  This driver can also be built as a module. If so, the
> > module will be called asus_atk0110.
> >   
> > +config SENSORS_ASUS_WMI_EC
> > +	tristate "ASUS WMI B550/X570"
> > +	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.
> > +
> >   endif # ACPI
> >   
> >   endif # HWMON
> > diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> > index baee6a8d4dd1..aae2ff5c7335 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_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 new file mode 100644 index
> > 000000000000..553d9ee8656d --- /dev/null
> > +++ b/drivers/hwmon/asus_wmi_ec_sensors.c
> > @@ -0,0 +1,631 @@
> > +// SPDX-License-Identifier: GPL-2.0+
> > +/*
> > + * 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 provided:
> > + * Chipset temperature,
> > + * CPU temperature,
> > + * Motherboard temperature,
> > + * T_Sensor temperature,
> > + * VRM  temperature,
> > + * Water In temperature,
> > + * Water Out temperature,
> > + * CPU Optional Fan,
> > + * Chipset fan,
> > + * Water Flow fan,
> > + * CPU current.
> > + *
> > + */
> > +#include <asm/unaligned.h>
> > +#include <linux/acpi.h>
> > +#include <linux/dmi.h>
> > +#include <linux/hwmon.h>
> > +#include <linux/hwmon-sysfs.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/platform_device.h>
> > +#include <linux/units.h>
> > +#include <linux/wmi.h>
> > +
> > +#define ASUSWMI_MONITORING_GUID
> > "466747A0-70EC-11DE-8A39-0800200C9A66" +#define
> > ASUSWMI_METHODID_BLOCK_READ_EC		0x42524543 /* BREC */
> > + +#define ASUS_WMI_BLOCK_READ_REGISTERS_MAX 0x10 /* from the ASUS
> > DSDT source */ +/* from the ASUS_WMI_BLOCK_READ_REGISTERS_MAX value
> > */ +#define ASUS_WMI_MAX_BUF_LEN 0x80
> > +#define MAX_SENSOR_LABEL_LENGTH 0x10
> > +
> > +enum asus_wmi_ec_board {
> > +	BOARD_PW_X570_A, /* Pro WS X570-ACE */
> > +	BOARD_R_C8H, /* ROG Crosshair VIII Hero */
> > +	BOARD_R_C8DH, /* ROG Crosshair VIII Dark Hero */
> > +	BOARD_R_C8F, /* ROG Crosshair VIII Formula */
> > +	BOARD_RS_B550_E_G, /* ROG STRIX B550-E GAMING */
> > +	BOARD_RS_X570_E_G, /* ROG STRIX X570-E GAMING */
> > +	BOARD_MAX
> > +};
> > +
> > +/* boards with EC support */
> > +static const char *const asus_wmi_ec_boards_names[] = {
> > +	[BOARD_PW_X570_A] = "Pro WS X570-ACE",
> > +	[BOARD_R_C8H] = "ROG CROSSHAIR VIII HERO",
> > +	[BOARD_R_C8DH] = "ROG CROSSHAIR VIII DARK HERO",
> > +	[BOARD_R_C8F] = "ROG CROSSHAIR VIII FORMULA",
> > +	[BOARD_RS_B550_E_G] = "ROG STRIX B550-E GAMING",
> > +	[BOARD_RS_X570_E_G] = "ROG STRIX X570-E GAMING",
> > +};
> > +
> > +static u32 hwmon_attributes[] = {
> > +	[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 {
> > +	char label[MAX_SENSOR_LABEL_LENGTH];
> > +	enum hwmon_sensor_types type;
> > +	struct asus_wmi_ec_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,
> > +	SENSOR_TEMP_CPU,
> > +	SENSOR_TEMP_MB,
> > +	SENSOR_TEMP_T_SENSOR,
> > +	SENSOR_TEMP_VRM,
> > +	SENSOR_FAN_CPU_OPT,
> > +	SENSOR_FAN_CHIPSET,
> > +	SENSOR_FAN_WATER_FLOW,
> > +	SENSOR_CURR_CPU,
> > +	SENSOR_TEMP_WATER_IN,
> > +	SENSOR_TEMP_WATER_OUT,
> > +	SENSOR_MAX
> > +};
> > +
> > +/*
> > + * Array of the 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_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), +};
> > +
> > +static const enum known_ec_sensor
> > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > +	[BOARD_PW_X570_A] = {
> > +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > +		SENSOR_FAN_CHIPSET,
> > +		SENSOR_MAX
> > +	},
> > +	[BOARD_R_C8H] = {
> > +		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
> > +	},
> > +	[BOARD_R_C8DH] = { /* Same as Hero but without chipset fan
> > */
> > +		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
> > +	},
> > +	[BOARD_R_C8F] = { /* Same as Hero but without water */
> > +		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
> > +	},
> > +	[BOARD_RS_B550_E_G] = {
> > +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > +		SENSOR_FAN_CPU_OPT,
> > +		SENSOR_CURR_CPU,
> > +		SENSOR_MAX
> > +	},
> > +	[BOARD_RS_X570_E_G] = {
> > +		SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > SENSOR_TEMP_MB,
> > +		SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
> > +		SENSOR_FAN_CHIPSET,
> > +		SENSOR_MAX
> > +	},
> > +};
> > +
> > +struct ec_sensor {
> > +	enum known_ec_sensor info_index;
> > +	u32 cached_value;
> > +};
> > +
> > +/**
> > + * struct asus_wmi_ec_info - sensor info.
> > + * @sensors: list of sensors.
> > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > + * @read_buffer: WMI function output.
> > + * @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[((ASUS_WMI_BLOCK_READ_REGISTERS_MAX * 4) +
> > 1) * 2];
> > +	u8 read_buffer[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > +	unsigned int nr_sensors;
> > +	unsigned int nr_registers;
> > +	unsigned long last_updated;
> > +};
> > +
> > +struct asus_wmi_sensors {
> > +	/* lock access to instrnal cache */
> > +	struct mutex lock;
> > +	struct asus_wmi_ec_info ec;
> > +
> > +	int ec_board;
> > +};
> > +
> > +struct asus_wmi_data {
> > +	int ec_board;
> > +};
> > +
> > +static void asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info
> > *ec, int board) +{
> > +	const enum known_ec_sensor *bsi =
> > known_board_sensors[board];
> > +	struct ec_sensor *s = ec->sensors;
> > +	int i;
> > +
> > +	ec->nr_sensors = 0;
> > +	ec->nr_registers = 0;
> > +
> > +	for (i = 0; i < SENSOR_MAX && bsi[i] != SENSOR_MAX; i++) {
> > +		s[i].info_index = bsi[i];
> > +		s[i].cached_value = 0;
> > +		ec->nr_sensors++;
> > +		ec->nr_registers +=
> > known_ec_sensors[bsi[i]].addr.size;
> > +	}
> > +}
> > +
> > +/*
> > + * The next four functions converts to/from BRxx string argument
> > format
> > + * The format of the string is as follows:
> > + * The string consists of two-byte UTF-16 characters
> > + * The value of the very first byte int 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 pairs of (bank, index) pairs,
> > where both
> > + * values are byte-long (0x00 to 0xFF)
> > + * Numbers are encoded as UTF-16 hex values
> > + */
> > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > +{
> > +	unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > 4);
> > +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > +	const char *pos = buffer;
> > +	const u8 *data = inp + 2;
> > +	unsigned int i;
> > +
> > +	utf16s_to_utf8s((wchar_t *)data, len * 2,
> > UTF16_LITTLE_ENDIAN, buffer, len * 2); +
> > +	for (i = 0; i < len; i++, pos += 2)
> > +		out[i] = (hex_to_bin(pos[0]) << 4) +
> > hex_to_bin(pos[1]); +}
> > +
> > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > char *out) +{
> > +	char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > +	char *pos = buffer;
> > +	unsigned int i;
> > +	u8 byte;
> > +
> > +	*out++ = len * 8;
> > +	*out++ = 0;
> > +
> > +	for (i = 0; i < len; i++) {
> > +		byte = registers[i] >> 8;
> > +		*pos = hex_asc_hi(byte);
> > +		pos++;
> > +		*pos = hex_asc_lo(byte);
> > +		pos++;
> > +		byte = registers[i];
> > +		*pos = hex_asc_hi(byte);
> > +		pos++;
> > +		*pos = hex_asc_lo(byte);
> > +		pos++;
> > +	}
> > +
> > +	utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > (wchar_t *)out, len * 4); +}
> > +
> > +static void asus_wmi_ec_make_block_read_query(struct
> > asus_wmi_ec_info *ec) +{
> > +	u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > +	const struct ec_sensor_info *si;
> > +	long i, j, register_idx = 0;
> > +
> > +	/*
> > +	 * if we can get values for all the registers in a single
> > query,
> > +	 * the query will not change from call to call
> > +	 */
> > +	if (ec->nr_registers <= ASUS_WMI_BLOCK_READ_REGISTERS_MAX
> > &&
> > +	    ec->read_arg[0] > 0) {
> > +		/* no need to update */
> > +		return;
> > +	}
> > +
> > +	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++, register_idx++) {
> > +			registers[register_idx] = (si->addr.bank
> > << 8) + si->addr.index + j;
> > +		}
> > +	}
> > +
> > +	asus_wmi_ec_encode_registers(registers, ec->nr_registers,
> > 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;
> > +
> > +	/* the first byte of the BRxx() argument string has to be
> > the string size */
> > +	input.length = (acpi_size)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 || obj->type != ACPI_TYPE_BUFFER) {
> > +		if (!obj)
> > +			acpi_os_free(output.pointer);
> > +
> > +		return -EIO;
> > +	}
> > +	asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, out);
> > +	acpi_os_free(output.pointer);
> > +	return 0;
> > +}
> > +
> > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > *ec) +{
> > +	const struct ec_sensor_info *si;
> > +	struct ec_sensor *s;
> > +
> > +	u32 value;
> > +	int status;
> > +	u8 i_sensor, read_reg_ct;
> > +
> > +	asus_wmi_ec_make_block_read_query(ec);
> > +	status =
> > asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
> > +					ec->read_arg,
> > +					ec->read_buffer);
> > +	if (status)
> > +		return status;
> > +
> > +	read_reg_ct = 0;
> > +	for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
> > +		s = &ec->sensors[i_sensor];
> > +		si = &known_ec_sensors[s->info_index];
> > +
> > +		if (si->addr.size == 1)
> > +			value = ec->read_buffer[read_reg_ct];
> > +		else if (si->addr.size == 2)
> > +			value =
> > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > +		else if (si->addr.size == 4)
> > +			value =
> > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > +		read_reg_ct += si->addr.size;
> > +		s->cached_value = value;
> > +	}
> > +	return 0;
> > +}
> > +
> > +static int asus_wmi_ec_scale_sensor_value(u32 value, int data_type)
> > +{
> > +	switch (data_type) {
> > +	case hwmon_curr:
> > +	case hwmon_temp:
> > +	case hwmon_in:
> > +		return value * KILO;
> > +	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(int sensor_index,
> > +						  struct
> > asus_wmi_sensors *state,
> > +						  u32 *value)
> > +{
> > +	int ret;
> > +
> > +	if (time_after(jiffies, state->ec.last_updated + HZ)) {
> > +		ret = asus_wmi_ec_update_ec_sensors(&state->ec);
> > +		if (ret)
> > +			return ret;
> > +
> > +		state->ec.last_updated = jiffies;
> > +	}
> > +
> > +	*value = state->ec.sensors[sensor_index].cached_value;
> > +	return 0;
> > +}
> > +
> > +/*
> > + * 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);
> > +	int ret, sidx, info_index;
> > +	u32 value = 0;
> > +
> > +	sidx = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel);
> > +	if (sidx < 0)
> > +		return sidx;
> > +
> > +	mutex_lock(&sensor_data->lock);
> > +	ret = asus_wmi_ec_get_cached_value_or_update(sidx,
> > sensor_data, &value);
> > +	mutex_unlock(&sensor_data->lock);
> > +	if (ret)
> > +		return ret;
> > +
> > +	info_index = sensor_data->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);
> > +	int sensor_index;
> > +
> > +	sensor_index =
> > asus_wmi_ec_find_sensor_index(&sensor_data->ec, type, channel);
> > +	*str =
> > known_ec_sensors[sensor_data->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)
> > +{
> > +	int index;
> > +	const struct asus_wmi_sensors *sensor_data = drvdata;
> > +
> > +	index = asus_wmi_ec_find_sensor_index(&sensor_data->ec,
> > type, channel); +
> > +	return index == 0xff ? 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
> > platform_device *pdev,
> > +					      struct
> > asus_wmi_sensors *sensor_data) +{
> > +	struct hwmon_channel_info *asus_wmi_hwmon_chan;
> > +	const struct hwmon_channel_info **ptr_asus_wmi_ci;
> > +	int nr_count[hwmon_max] = { 0 }, nr_types = 0;
> > +	const struct hwmon_chip_info *chip_info;
> > +	struct device *dev = &pdev->dev;
> > +	const struct ec_sensor_info *si;
> > +	enum hwmon_sensor_types type;
> > +	struct device *hwdev;
> > +	int i;
> > +
> > +	asus_wmi_ec_fill_board_sensors(&sensor_data->ec,
> > sensor_data->ec_board); +
> > +	if (!sensor_data->ec.nr_sensors)
> > +		return -ENODEV;
> > +
> > +	for (i = 0; i < sensor_data->ec.nr_sensors; i++) {
> > +		si =
> > &known_ec_sensors[sensor_data->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++;
> > +	}
> > +
> > +	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_ec_chip_info.info = ptr_asus_wmi_ci;
> > +	chip_info = &asus_wmi_ec_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_dbg(&pdev->dev, "%s board has %d EC sensors that span
> > %d registers",
> > +		asus_wmi_ec_boards_names[sensor_data->ec_board],
> > +		sensor_data->ec.nr_sensors,
> > +		sensor_data->ec.nr_registers);
> > +
> > +	hwdev = devm_hwmon_device_register_with_info(dev,
> > KBUILD_MODNAME,
> > +						     sensor_data,
> > chip_info, NULL); +
> > +	return PTR_ERR_OR_ZERO(hwdev);
> > +}
> > +
> > +static int asus_wmi_probe(struct platform_device *pdev)
> > +{
> > +	struct asus_wmi_sensors *sensor_data;
> > +	struct device *dev = &pdev->dev;
> > +	struct asus_wmi_data *data;
> > +
> > +	data = dev_get_platdata(dev);
> > +
> > +	sensor_data = devm_kzalloc(dev, sizeof(struct
> > asus_wmi_sensors),
> > +				   GFP_KERNEL);
> > +	if (!sensor_data)
> > +		return -ENOMEM;
> > +
> > +	mutex_init(&sensor_data->lock);
> > +	sensor_data->ec_board = data->ec_board;
> > +
> > +	platform_set_drvdata(pdev, sensor_data);
> > +
> > +	/* ec init */
> > +	return asus_wmi_ec_configure_sensor_setup(pdev,
> > +						  sensor_data);
> > +}
> > +
> > +static struct platform_driver asus_wmi_sensors_platform_driver = {
> > +	.driver = {
> > +		.name	= "asus-wmi-sensors",
> > +	},
> > +	.probe = asus_wmi_probe,
> > +};
> > +
> > +static struct platform_device *sensors_pdev;
> > +
> > +static int __init asus_wmi_init(void)
> > +{
> > +	const char *board_vendor, *board_name;
> > +	struct asus_wmi_data data;
> > +
> > +	data.ec_board = -1;
> > +
> > +	board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
> > +	board_name = dmi_get_system_info(DMI_BOARD_NAME);
> > +
> > +	if (board_vendor && board_name &&
> > +	    !strcmp(board_vendor, "ASUSTeK COMPUTER INC.")) {
> > +		if (!wmi_has_guid(ASUSWMI_MONITORING_GUID))
> > +			return -ENODEV;
> > +
> > +		data.ec_board =
> > match_string(asus_wmi_ec_boards_names,
> > +
> > ARRAY_SIZE(asus_wmi_ec_boards_names),
> > +					     board_name);
> > +	}
> > +
> > +	/* Nothing to support */
> > +	if (data.ec_board < 0)
> > +		return -ENODEV;
> > +
> > +	sensors_pdev =
> > platform_create_bundle(&asus_wmi_sensors_platform_driver,
> > +					      asus_wmi_probe,
> > +					      NULL, 0,
> > +					      &data, sizeof(struct
> > asus_wmi_data)); +
> > +	return PTR_ERR_OR_ZERO(sensors_pdev);
> > +}
> > +module_init(asus_wmi_init);
> > +
> > +static void __exit asus_wmi_exit(void)
> > +{
> > +	platform_device_unregister(sensors_pdev);
> > +
> > platform_driver_unregister(&asus_wmi_sensors_platform_driver); +}
> > +module_exit(asus_wmi_exit);
> > +
> > +MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
> > +MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
> > +MODULE_DESCRIPTION("Asus WMI Sensors Driver");
> > +MODULE_LICENSE("GPL");
> >   
> 

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Hi Denis,

yes, the GH repo contains the fix and a few code cleanups, which I
would like to propose for mainlining too. Also, please find below a
draft of the documentation:

Kernel driver asus-wmi-ec-sensors
=================================

Authors:
        <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

Best regards,
Eugene

On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com> wrote:
>
> Hi Eugene,
>
> On Thu, 7 Oct 2021 01:32:14 +0200
> Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> > >
> >
> > > Supported motherboards:
> > > * ROG CROSSHAIR VIII HERO
> > > * ROG CROSSHAIR VIII DARK HERO
> > > * ROG CROSSHAIR VIII FORMULA
> > > * ROG STRIX X570-E GAMING
> > > * ROG STRIX B550-E GAMING
> >
> > Pro WS X570-ACE is missing from this list.
> Thanks, I will check.
> >
> > > + * EC provided:
> > provides
> Thanks, I will check.
> >
> > > + * Chipset temperature,
> > > + * CPU temperature,
> > > + * Motherboard temperature,
> > > + * T_Sensor temperature,
> > > + * VRM  temperature,
> > > + * Water In temperature,
> > > + * Water Out temperature,
> > > + * CPU Optional Fan,
> > Hereinafter "CPU Optional Fan RPM"?
> >
> Thanks, I will check.
> > > +static const enum known_ec_sensor
> > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > +       [BOARD_PW_X570_A] = {
> > > +               SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > +               SENSOR_FAN_CHIPSET,
> >
> > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > mistake made it here too. Sorry for that.
> >
> Do you have such fix in your repository?
> > > +/**
> > > + * struct asus_wmi_ec_info - sensor info.
> > > + * @sensors: list of sensors.
> > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > + * @read_buffer: WMI function output.
> >
> > This seems to be a bit misleading to me in a sense that the variable
> > holds decoded output (array of numbers as opposed to array of
> > characters in the WMI output buffer.
> >
> > > +struct asus_wmi_data {
> > > +       int ec_board;
> > > +};
> >
> > A leftover?
> >
> Its platform data and used to share board_id with probe.
>
> > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > > +{
> > > +       unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > > 4);
> > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > +       const char *pos = buffer;
> > > +       const u8 *data = inp + 2;
> > > +       unsigned int i;
> > > +
> > > +       utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > Errr... Why is it here? You need the same loop afterwards, just with a
> > smaller stride.
> I have tried to apply Andy's idea. And it looks it does not
> provide benefits. Andy, what do you think? Maybe I understand it in
> wrong way.
> > > +
> > > +       for (i = 0; i < len; i++, pos += 2)
> > > +               out[i] = (hex_to_bin(pos[0]) << 4) +
> > > hex_to_bin(pos[1]); +}
> > > +
> > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > > char *out) +{
> > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > +       char *pos = buffer;
> > > +       unsigned int i;
> > > +       u8 byte;
> > > +
> > > +       *out++ = len * 8;
> > > +       *out++ = 0;
> > > +
> > > +       for (i = 0; i < len; i++) {
> > > +               byte = registers[i] >> 8;
> > > +               *pos = hex_asc_hi(byte);
> > > +               pos++;
> > > +               *pos = hex_asc_lo(byte);
> > > +               pos++;
> > > +               byte = registers[i];
> > > +               *pos = hex_asc_hi(byte);
> > > +               pos++;
> > > +               *pos = hex_asc_lo(byte);
> > > +               pos++;
> > > +       }
> > > +
> > > +       utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > (wchar_t *)out, len * 4);
> > Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> > same loop plus an additional buffer. I don't get it.
> >
> I have tried to apply Andy's idea. And it looks it does not
> provide benefits. Andy, what do you think? Maybe I understand it in
> wrong way.
> > > +}
> > > +
> > > +static void asus_wmi_ec_make_block_read_query(struct
> > > asus_wmi_ec_info *ec) +{
> > > +       u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > +       const struct ec_sensor_info *si;
> > > +       long i, j, register_idx = 0;
> > long? maybe a simple unsigned or int?
> >
> Looks as it was in original patch, I will look.
> > > +
> > > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > > *ec) +{
> > > +       const struct ec_sensor_info *si;
> > > +       struct ec_sensor *s;
> > > +
> > > +       u32 value;
> > This variable is now redundant.
> >
> Thank you, I will look.
>
> > > +               if (si->addr.size == 1)
> > Maybe switch(si->addr.size)?
> >
> Thank you, I will check.
> > > +                       value = ec->read_buffer[read_reg_ct];
> > > +               else if (si->addr.size == 2)
> > > +                       value =
> > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > +               else if (si->addr.size == 4)
> > > +                       value =
> > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > +               read_reg_ct += si->addr.size;
> > > +               s->cached_value = value;
> > > +       }
> > > +       return 0;
> > > +}
> >
> >
> > > +       mutex_lock(&sensor_data->lock);
> > The mutex locking/unlocking should be moved inside the
> > update_ec_sensors(), I guess.
> >
> > I re-read your answer to my question as to why don't you add module
> > aliases to the driver, and I have to admit I don't really understand
> > it. Could you, please, elaborate?
> >
> It looked complicated to support two kind of WMI interfaces with UUID.
> As we split big support module to two separate - I will look to such
> change also.
>
> > Thank you,
> > Eugene
>
> Best regards,
>      Denis.

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Denis and All,

regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
EC registers, and this method is slow (requires almost a full second
for a single call). Maybe I'm doing something wrong, but my impression
is that the WMI calls themselves are that slow. I will try to
reimplement this driver using direct EC operations and the global ACPI
lock with a hope to make it read sensors quicker. If that works out,
perhaps the nct6775 may go the same way, as it suffers too from the
slow WMI calls. I know next to nothing about the ACPI system and learn
from the beginning, so I'm not sure about the result. I know the naive
reading from the ACPI EC registers leads to problems (fans get stuck,
etc.), and if someone with knowledge can assure me that the idea with
the ACPI global lock (as far as I understand it is even implemented in
the ec kernel driver already) is correct, I would even request to stop
accepting the EC WMI sensors driver, as it is so slow (albeit dead
simple and small).

Best regards,
Eugen

On Thu, 7 Oct 2021 at 19:55, Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> Hi Denis,
>
> yes, the GH repo contains the fix and a few code cleanups, which I
> would like to propose for mainlining too. Also, please find below a
> draft of the documentation:
>
> Kernel driver asus-wmi-ec-sensors
> =================================
>
> Authors:
>         <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
>
> Best regards,
> Eugene
>
> On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com> wrote:
> >
> > Hi Eugene,
> >
> > On Thu, 7 Oct 2021 01:32:14 +0200
> > Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> >
> > > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> > > >
> > >
> > > > Supported motherboards:
> > > > * ROG CROSSHAIR VIII HERO
> > > > * ROG CROSSHAIR VIII DARK HERO
> > > > * ROG CROSSHAIR VIII FORMULA
> > > > * ROG STRIX X570-E GAMING
> > > > * ROG STRIX B550-E GAMING
> > >
> > > Pro WS X570-ACE is missing from this list.
> > Thanks, I will check.
> > >
> > > > + * EC provided:
> > > provides
> > Thanks, I will check.
> > >
> > > > + * Chipset temperature,
> > > > + * CPU temperature,
> > > > + * Motherboard temperature,
> > > > + * T_Sensor temperature,
> > > > + * VRM  temperature,
> > > > + * Water In temperature,
> > > > + * Water Out temperature,
> > > > + * CPU Optional Fan,
> > > Hereinafter "CPU Optional Fan RPM"?
> > >
> > Thanks, I will check.
> > > > +static const enum known_ec_sensor
> > > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > > +       [BOARD_PW_X570_A] = {
> > > > +               SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > > +               SENSOR_FAN_CHIPSET,
> > >
> > > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > > mistake made it here too. Sorry for that.
> > >
> > Do you have such fix in your repository?
> > > > +/**
> > > > + * struct asus_wmi_ec_info - sensor info.
> > > > + * @sensors: list of sensors.
> > > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > > + * @read_buffer: WMI function output.
> > >
> > > This seems to be a bit misleading to me in a sense that the variable
> > > holds decoded output (array of numbers as opposed to array of
> > > characters in the WMI output buffer.
> > >
> > > > +struct asus_wmi_data {
> > > > +       int ec_board;
> > > > +};
> > >
> > > A leftover?
> > >
> > Its platform data and used to share board_id with probe.
> >
> > > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > > > +{
> > > > +       unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > > > 4);
> > > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > +       const char *pos = buffer;
> > > > +       const u8 *data = inp + 2;
> > > > +       unsigned int i;
> > > > +
> > > > +       utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > > Errr... Why is it here? You need the same loop afterwards, just with a
> > > smaller stride.
> > I have tried to apply Andy's idea. And it looks it does not
> > provide benefits. Andy, what do you think? Maybe I understand it in
> > wrong way.
> > > > +
> > > > +       for (i = 0; i < len; i++, pos += 2)
> > > > +               out[i] = (hex_to_bin(pos[0]) << 4) +
> > > > hex_to_bin(pos[1]); +}
> > > > +
> > > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > > > char *out) +{
> > > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > +       char *pos = buffer;
> > > > +       unsigned int i;
> > > > +       u8 byte;
> > > > +
> > > > +       *out++ = len * 8;
> > > > +       *out++ = 0;
> > > > +
> > > > +       for (i = 0; i < len; i++) {
> > > > +               byte = registers[i] >> 8;
> > > > +               *pos = hex_asc_hi(byte);
> > > > +               pos++;
> > > > +               *pos = hex_asc_lo(byte);
> > > > +               pos++;
> > > > +               byte = registers[i];
> > > > +               *pos = hex_asc_hi(byte);
> > > > +               pos++;
> > > > +               *pos = hex_asc_lo(byte);
> > > > +               pos++;
> > > > +       }
> > > > +
> > > > +       utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > > (wchar_t *)out, len * 4);
> > > Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> > > same loop plus an additional buffer. I don't get it.
> > >
> > I have tried to apply Andy's idea. And it looks it does not
> > provide benefits. Andy, what do you think? Maybe I understand it in
> > wrong way.
> > > > +}
> > > > +
> > > > +static void asus_wmi_ec_make_block_read_query(struct
> > > > asus_wmi_ec_info *ec) +{
> > > > +       u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > > +       const struct ec_sensor_info *si;
> > > > +       long i, j, register_idx = 0;
> > > long? maybe a simple unsigned or int?
> > >
> > Looks as it was in original patch, I will look.
> > > > +
> > > > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > > > *ec) +{
> > > > +       const struct ec_sensor_info *si;
> > > > +       struct ec_sensor *s;
> > > > +
> > > > +       u32 value;
> > > This variable is now redundant.
> > >
> > Thank you, I will look.
> >
> > > > +               if (si->addr.size == 1)
> > > Maybe switch(si->addr.size)?
> > >
> > Thank you, I will check.
> > > > +                       value = ec->read_buffer[read_reg_ct];
> > > > +               else if (si->addr.size == 2)
> > > > +                       value =
> > > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > > +               else if (si->addr.size == 4)
> > > > +                       value =
> > > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > > +               read_reg_ct += si->addr.size;
> > > > +               s->cached_value = value;
> > > > +       }
> > > > +       return 0;
> > > > +}
> > >
> > >
> > > > +       mutex_lock(&sensor_data->lock);
> > > The mutex locking/unlocking should be moved inside the
> > > update_ec_sensors(), I guess.
> > >
> > > I re-read your answer to my question as to why don't you add module
> > > aliases to the driver, and I have to admit I don't really understand
> > > it. Could you, please, elaborate?
> > >
> > It looked complicated to support two kind of WMI interfaces with UUID.
> > As we split big support module to two separate - I will look to such
> > change also.
> >
> > > Thank you,
> > > Eugene
> >
> > Best regards,
> >      Denis.

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Hi Denis,


On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> +               if (si->addr.size == 1)
> +                       value = ec->read_buffer[read_reg_ct];
> +               else if (si->addr.size == 2)
> +                       value = get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> +               else if (si->addr.size == 4)
> +                       value = get_unaligned_le32(&ec->read_buffer[read_reg_ct]);

If you did not invert the encoding scheme the data in the buffer are
in BE order.

Best regards,
Eugene

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Dear Denis and all,

Let me propose for your consideration a better approach, as I believe,
to the problem with ASUS hardware sensors for the boards with SIO and
EC resources marked as used by the ACPI code. It evolved from the
discussion and patches in the kernel bug 204807, work by Denis, and my
attempts to implement sensor reading from the ACPI EC registers.

Thanks to the users who submitted ACPI dumps for many ASUS boards in
bug 204807 and discussion in the Libre Hardware Monitor project we
learned the names for methods to read SIO and EC registers. Now we
have drivers that implement reading via the ACPI (WMI, to be precise)
methods sensor values. However, this slows down reading by a great
margin (for example, reading from EC takes almost a full second). But
do we need to use ACPI functions to read data?

If one checks out AML code for all the boards, it can be noted that
all the WMI hardware access functions are guarded by a mutex, which
has the same name for all the ASUS boards ("\AMW0.ASMX"). Thus, we do
not need to use WMI functions, but can simply lock the same mutex and
access hardware registers directly.

For the EC case this reduced reading delay from 0.99 seconds down to
0.01 -- 0.3 seconds. So, I propose to change the nct6775 code and
instead of using the SIO read function from board WMI, just grab that
mutex and read directly. For the EC sensors I've done that in a GH
repo [1].

Best regards,
Eugene

[1] https://github.com/zeule/asus-ec-sensors

On Thu, 7 Oct 2021 at 20:11, Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> Denis and All,
>
> regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
> EC registers, and this method is slow (requires almost a full second
> for a single call). Maybe I'm doing something wrong, but my impression
> is that the WMI calls themselves are that slow. I will try to
> reimplement this driver using direct EC operations and the global ACPI
> lock with a hope to make it read sensors quicker. If that works out,
> perhaps the nct6775 may go the same way, as it suffers too from the
> slow WMI calls. I know next to nothing about the ACPI system and learn
> from the beginning, so I'm not sure about the result. I know the naive
> reading from the ACPI EC registers leads to problems (fans get stuck,
> etc.), and if someone with knowledge can assure me that the idea with
> the ACPI global lock (as far as I understand it is even implemented in
> the ec kernel driver already) is correct, I would even request to stop
> accepting the EC WMI sensors driver, as it is so slow (albeit dead
> simple and small).
>
> Best regards,
> Eugen
>
> On Thu, 7 Oct 2021 at 19:55, Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> >
> > Hi Denis,
> >
> > yes, the GH repo contains the fix and a few code cleanups, which I
> > would like to propose for mainlining too. Also, please find below a
> > draft of the documentation:
> >
> > Kernel driver asus-wmi-ec-sensors
> > =================================
> >
> > Authors:
> >         <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
> >
> > Best regards,
> > Eugene
> >
> > On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com> wrote:
> > >
> > > Hi Eugene,
> > >
> > > On Thu, 7 Oct 2021 01:32:14 +0200
> > > Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> > >
> > > > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com> wrote:
> > > > >
> > > >
> > > > > Supported motherboards:
> > > > > * ROG CROSSHAIR VIII HERO
> > > > > * ROG CROSSHAIR VIII DARK HERO
> > > > > * ROG CROSSHAIR VIII FORMULA
> > > > > * ROG STRIX X570-E GAMING
> > > > > * ROG STRIX B550-E GAMING
> > > >
> > > > Pro WS X570-ACE is missing from this list.
> > > Thanks, I will check.
> > > >
> > > > > + * EC provided:
> > > > provides
> > > Thanks, I will check.
> > > >
> > > > > + * Chipset temperature,
> > > > > + * CPU temperature,
> > > > > + * Motherboard temperature,
> > > > > + * T_Sensor temperature,
> > > > > + * VRM  temperature,
> > > > > + * Water In temperature,
> > > > > + * Water Out temperature,
> > > > > + * CPU Optional Fan,
> > > > Hereinafter "CPU Optional Fan RPM"?
> > > >
> > > Thanks, I will check.
> > > > > +static const enum known_ec_sensor
> > > > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > > > +       [BOARD_PW_X570_A] = {
> > > > > +               SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > > > +               SENSOR_FAN_CHIPSET,
> > > >
> > > > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > > > mistake made it here too. Sorry for that.
> > > >
> > > Do you have such fix in your repository?
> > > > > +/**
> > > > > + * struct asus_wmi_ec_info - sensor info.
> > > > > + * @sensors: list of sensors.
> > > > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > > > + * @read_buffer: WMI function output.
> > > >
> > > > This seems to be a bit misleading to me in a sense that the variable
> > > > holds decoded output (array of numbers as opposed to array of
> > > > characters in the WMI output buffer.
> > > >
> > > > > +struct asus_wmi_data {
> > > > > +       int ec_board;
> > > > > +};
> > > >
> > > > A leftover?
> > > >
> > > Its platform data and used to share board_id with probe.
> > >
> > > > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp, u8 *out)
> > > > > +{
> > > > > +       unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN, inp[0] /
> > > > > 4);
> > > > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > +       const char *pos = buffer;
> > > > > +       const u8 *data = inp + 2;
> > > > > +       unsigned int i;
> > > > > +
> > > > > +       utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > > > UTF16_LITTLE_ENDIAN, buffer, len * 2);
> > > > Errr... Why is it here? You need the same loop afterwards, just with a
> > > > smaller stride.
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it in
> > > wrong way.
> > > > > +
> > > > > +       for (i = 0; i < len; i++, pos += 2)
> > > > > +               out[i] = (hex_to_bin(pos[0]) << 4) +
> > > > > hex_to_bin(pos[1]); +}
> > > > > +
> > > > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8 len,
> > > > > char *out) +{
> > > > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > +       char *pos = buffer;
> > > > > +       unsigned int i;
> > > > > +       u8 byte;
> > > > > +
> > > > > +       *out++ = len * 8;
> > > > > +       *out++ = 0;
> > > > > +
> > > > > +       for (i = 0; i < len; i++) {
> > > > > +               byte = registers[i] >> 8;
> > > > > +               *pos = hex_asc_hi(byte);
> > > > > +               pos++;
> > > > > +               *pos = hex_asc_lo(byte);
> > > > > +               pos++;
> > > > > +               byte = registers[i];
> > > > > +               *pos = hex_asc_hi(byte);
> > > > > +               pos++;
> > > > > +               *pos = hex_asc_lo(byte);
> > > > > +               pos++;
> > > > > +       }
> > > > > +
> > > > > +       utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > > > (wchar_t *)out, len * 4);
> > > > Same here. Just for the sake of calling utf8s_to_utf16s() you need the
> > > > same loop plus an additional buffer. I don't get it.
> > > >
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it in
> > > wrong way.
> > > > > +}
> > > > > +
> > > > > +static void asus_wmi_ec_make_block_read_query(struct
> > > > > asus_wmi_ec_info *ec) +{
> > > > > +       u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > > > +       const struct ec_sensor_info *si;
> > > > > +       long i, j, register_idx = 0;
> > > > long? maybe a simple unsigned or int?
> > > >
> > > Looks as it was in original patch, I will look.
> > > > > +
> > > > > +static int asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info
> > > > > *ec) +{
> > > > > +       const struct ec_sensor_info *si;
> > > > > +       struct ec_sensor *s;
> > > > > +
> > > > > +       u32 value;
> > > > This variable is now redundant.
> > > >
> > > Thank you, I will look.
> > >
> > > > > +               if (si->addr.size == 1)
> > > > Maybe switch(si->addr.size)?
> > > >
> > > Thank you, I will check.
> > > > > +                       value = ec->read_buffer[read_reg_ct];
> > > > > +               else if (si->addr.size == 2)
> > > > > +                       value =
> > > > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > > > +               else if (si->addr.size == 4)
> > > > > +                       value =
> > > > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > > > +               read_reg_ct += si->addr.size;
> > > > > +               s->cached_value = value;
> > > > > +       }
> > > > > +       return 0;
> > > > > +}
> > > >
> > > >
> > > > > +       mutex_lock(&sensor_data->lock);
> > > > The mutex locking/unlocking should be moved inside the
> > > > update_ec_sensors(), I guess.
> > > >
> > > > I re-read your answer to my question as to why don't you add module
> > > > aliases to the driver, and I have to admit I don't really understand
> > > > it. Could you, please, elaborate?
> > > >
> > > It looked complicated to support two kind of WMI interfaces with UUID.
> > > As we split big support module to two separate - I will look to such
> > > change also.
> > >
> > > > Thank you,
> > > > Eugene
> > >
> > > Best regards,
> > >      Denis.

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Denis Pauk]

Hi Eugene,

As for me, use WMI methods will be more reliable and cover more
motherboards.

Best regards,
            Denis.

On Thu, 7 Oct 2021 20:11:33 +0200
Eugene Shalygin <eugene.shalygin@gmail.com> wrote:

> Denis and All,
> 
> regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
> EC registers, and this method is slow (requires almost a full second
> for a single call). Maybe I'm doing something wrong, but my impression
> is that the WMI calls themselves are that slow. I will try to
> reimplement this driver using direct EC operations and the global ACPI
> lock with a hope to make it read sensors quicker. If that works out,
> perhaps the nct6775 may go the same way, as it suffers too from the
> slow WMI calls. I know next to nothing about the ACPI system and learn
> from the beginning, so I'm not sure about the result. I know the naive
> reading from the ACPI EC registers leads to problems (fans get stuck,
> etc.), and if someone with knowledge can assure me that the idea with
> the ACPI global lock (as far as I understand it is even implemented in
> the ec kernel driver already) is correct, I would even request to stop
> accepting the EC WMI sensors driver, as it is so slow (albeit dead
> simple and small).
> 
> Best regards,
> Eugen
> 
> On Thu, 7 Oct 2021 at 19:55, Eugene Shalygin
> <eugene.shalygin@gmail.com> wrote:
> >
> > Hi Denis,
> >
> > yes, the GH repo contains the fix and a few code cleanups, which I
> > would like to propose for mainlining too. Also, please find below a
> > draft of the documentation:
> >
> > Kernel driver asus-wmi-ec-sensors
> > =================================
> >
> > Authors:
> >         <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
> >
> > Best regards,
> > Eugene
> >
> > On Thu, 7 Oct 2021 at 17:46, Denis Pauk <pauk.denis@gmail.com>
> > wrote:  
> > >
> > > Hi Eugene,
> > >
> > > On Thu, 7 Oct 2021 01:32:14 +0200
> > > Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
> > >  
> > > > On Thu, 7 Oct 2021 at 00:25, Denis Pauk <pauk.denis@gmail.com>
> > > > wrote:  
> > > > >  
> > > >  
> > > > > Supported motherboards:
> > > > > * ROG CROSSHAIR VIII HERO
> > > > > * ROG CROSSHAIR VIII DARK HERO
> > > > > * ROG CROSSHAIR VIII FORMULA
> > > > > * ROG STRIX X570-E GAMING
> > > > > * ROG STRIX B550-E GAMING  
> > > >
> > > > Pro WS X570-ACE is missing from this list.  
> > > Thanks, I will check.  
> > > >  
> > > > > + * EC provided:  
> > > > provides  
> > > Thanks, I will check.  
> > > >  
> > > > > + * Chipset temperature,
> > > > > + * CPU temperature,
> > > > > + * Motherboard temperature,
> > > > > + * T_Sensor temperature,
> > > > > + * VRM  temperature,
> > > > > + * Water In temperature,
> > > > > + * Water Out temperature,
> > > > > + * CPU Optional Fan,  
> > > > Hereinafter "CPU Optional Fan RPM"?
> > > >  
> > > Thanks, I will check.  
> > > > > +static const enum known_ec_sensor
> > > > > known_board_sensors[BOARD_MAX][SENSOR_MAX + 1] = {
> > > > > +       [BOARD_PW_X570_A] = {
> > > > > +               SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU,
> > > > > SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
> > > > > +               SENSOR_FAN_CHIPSET,  
> > > >
> > > > I missed SENSOR_CURR_CPU for a few boards, and unfortunately the
> > > > mistake made it here too. Sorry for that.
> > > >  
> > > Do you have such fix in your repository?  
> > > > > +/**
> > > > > + * struct asus_wmi_ec_info - sensor info.
> > > > > + * @sensors: list of sensors.
> > > > > + * @read_arg: UTF-16 string to pass to BRxx() WMI function.
> > > > > + * @read_buffer: WMI function output.  
> > > >
> > > > This seems to be a bit misleading to me in a sense that the
> > > > variable holds decoded output (array of numbers as opposed to
> > > > array of characters in the WMI output buffer.
> > > >  
> > > > > +struct asus_wmi_data {
> > > > > +       int ec_board;
> > > > > +};  
> > > >
> > > > A leftover?
> > > >  
> > > Its platform data and used to share board_id with probe.
> > >  
> > > > > +static void asus_wmi_ec_decode_reply_buffer(const u8 *inp,
> > > > > u8 *out) +{
> > > > > +       unsigned int len = ACPI_MIN(ASUS_WMI_MAX_BUF_LEN,
> > > > > inp[0] / 4);
> > > > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > +       const char *pos = buffer;
> > > > > +       const u8 *data = inp + 2;
> > > > > +       unsigned int i;
> > > > > +
> > > > > +       utf16s_to_utf8s((wchar_t *)data, len * 2,
> > > > > UTF16_LITTLE_ENDIAN, buffer, len * 2);  
> > > > Errr... Why is it here? You need the same loop afterwards, just
> > > > with a smaller stride.  
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it
> > > in wrong way.  
> > > > > +
> > > > > +       for (i = 0; i < len; i++, pos += 2)
> > > > > +               out[i] = (hex_to_bin(pos[0]) << 4) +
> > > > > hex_to_bin(pos[1]); +}
> > > > > +
> > > > > +static void asus_wmi_ec_encode_registers(u16 *registers, u8
> > > > > len, char *out) +{
> > > > > +       char buffer[ASUS_WMI_MAX_BUF_LEN * 2];
> > > > > +       char *pos = buffer;
> > > > > +       unsigned int i;
> > > > > +       u8 byte;
> > > > > +
> > > > > +       *out++ = len * 8;
> > > > > +       *out++ = 0;
> > > > > +
> > > > > +       for (i = 0; i < len; i++) {
> > > > > +               byte = registers[i] >> 8;
> > > > > +               *pos = hex_asc_hi(byte);
> > > > > +               pos++;
> > > > > +               *pos = hex_asc_lo(byte);
> > > > > +               pos++;
> > > > > +               byte = registers[i];
> > > > > +               *pos = hex_asc_hi(byte);
> > > > > +               pos++;
> > > > > +               *pos = hex_asc_lo(byte);
> > > > > +               pos++;
> > > > > +       }
> > > > > +
> > > > > +       utf8s_to_utf16s(buffer, len * 4, UTF16_LITTLE_ENDIAN,
> > > > > (wchar_t *)out, len * 4);  
> > > > Same here. Just for the sake of calling utf8s_to_utf16s() you
> > > > need the same loop plus an additional buffer. I don't get it.
> > > >  
> > > I have tried to apply Andy's idea. And it looks it does not
> > > provide benefits. Andy, what do you think? Maybe I understand it
> > > in wrong way.  
> > > > > +}
> > > > > +
> > > > > +static void asus_wmi_ec_make_block_read_query(struct
> > > > > asus_wmi_ec_info *ec) +{
> > > > > +       u16 registers[ASUS_WMI_BLOCK_READ_REGISTERS_MAX];
> > > > > +       const struct ec_sensor_info *si;
> > > > > +       long i, j, register_idx = 0;  
> > > > long? maybe a simple unsigned or int?
> > > >  
> > > Looks as it was in original patch, I will look.  
> > > > > +
> > > > > +static int asus_wmi_ec_update_ec_sensors(struct
> > > > > asus_wmi_ec_info *ec) +{
> > > > > +       const struct ec_sensor_info *si;
> > > > > +       struct ec_sensor *s;
> > > > > +
> > > > > +       u32 value;  
> > > > This variable is now redundant.
> > > >  
> > > Thank you, I will look.
> > >  
> > > > > +               if (si->addr.size == 1)  
> > > > Maybe switch(si->addr.size)?
> > > >  
> > > Thank you, I will check.  
> > > > > +                       value = ec->read_buffer[read_reg_ct];
> > > > > +               else if (si->addr.size == 2)
> > > > > +                       value =
> > > > > get_unaligned_le16(&ec->read_buffer[read_reg_ct]);
> > > > > +               else if (si->addr.size == 4)
> > > > > +                       value =
> > > > > get_unaligned_le32(&ec->read_buffer[read_reg_ct]); +
> > > > > +               read_reg_ct += si->addr.size;
> > > > > +               s->cached_value = value;
> > > > > +       }
> > > > > +       return 0;
> > > > > +}  
> > > >
> > > >  
> > > > > +       mutex_lock(&sensor_data->lock);  
> > > > The mutex locking/unlocking should be moved inside the
> > > > update_ec_sensors(), I guess.
> > > >
> > > > I re-read your answer to my question as to why don't you add
> > > > module aliases to the driver, and I have to admit I don't
> > > > really understand it. Could you, please, elaborate?
> > > >  
> > > It looked complicated to support two kind of WMI interfaces with
> > > UUID. As we split big support module to two separate - I will
> > > look to such change also.
> > >  
> > > > Thank you,
> > > > Eugene  
> > >
> > > Best regards,
> > >      Denis.  

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Hi Denis,

On Sun, 10 Oct 2021 at 12:39, Denis Pauk <pauk.denis@gmail.com> wrote:
>
> Hi Eugene,
>
> As for me, use WMI methods will be more reliable and cover more
> motherboards.

Why do you believe they are more reliable? How does it cover more motherboards?

Thanks,
Eugene

>
> Best regards,
>             Denis.
>
> On Thu, 7 Oct 2021 20:11:33 +0200
> Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>
> > Denis and All,
> >
> > regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
> > EC registers, and this method is slow (requires almost a full second
> > for a single call). Maybe I'm doing something wrong, but my impression
> > is that the WMI calls themselves are that slow. I will try to
> > reimplement this driver using direct EC operations and the global ACPI
> > lock with a hope to make it read sensors quicker. If that works out,
> > perhaps the nct6775 may go the same way, as it suffers too from the
> > slow WMI calls. I know next to nothing about the ACPI system and learn
> > from the beginning, so I'm not sure about the result. I know the naive
> > reading from the ACPI EC registers leads to problems (fans get stuck,
> > etc.), and if someone with knowledge can assure me that the idea with
> > the ACPI global lock (as far as I understand it is even implemented in
> > the ec kernel driver already) is correct, I would even request to stop
> > accepting the EC WMI sensors driver, as it is so slow (albeit dead
> > simple and small).
> >
> > Best regards,
> > Eugen
> >

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Guenter Roeck]

On 10/10/21 6:46 AM, Eugene Shalygin wrote:
> Hi Denis,
> 
> On Sun, 10 Oct 2021 at 12:39, Denis Pauk <pauk.denis@gmail.com> wrote:
>>
>> Hi Eugene,
>>
>> As for me, use WMI methods will be more reliable and cover more
>> motherboards.
> 
> Why do you believe they are more reliable? How does it cover more motherboards?
> 

You said yourself below: "I know the naive reading from the ACPI EC registers
leads to problems (fans get stuck, etc.)".

Something in the WMI code is obviously broken and, ultimately, will need
to get fixed. I don't know if that something is on the ASUS side or on the
kernel side, or on the interface between the two. A single WMI call taking
1 second is way too long and strongly suggests that some timeout is involved.
Not using WMI because of that just seems wrong.

Guenter

> Thanks,
> Eugene
> 
>>
>> Best regards,
>>              Denis.
>>
>> On Thu, 7 Oct 2021 20:11:33 +0200
>> Eugene Shalygin <eugene.shalygin@gmail.com> wrote:
>>
>>> Denis and All,
>>>
>>> regarding the asus-wmi-ec-sensors driver: it uses a WMI method to read
>>> EC registers, and this method is slow (requires almost a full second
>>> for a single call). Maybe I'm doing something wrong, but my impression
>>> is that the WMI calls themselves are that slow. I will try to
>>> reimplement this driver using direct EC operations and the global ACPI
>>> lock with a hope to make it read sensors quicker. If that works out,
>>> perhaps the nct6775 may go the same way, as it suffers too from the
>>> slow WMI calls. I know next to nothing about the ACPI system and learn
>>> from the beginning, so I'm not sure about the result. I know the naive
>>> reading from the ACPI EC registers leads to problems (fans get stuck,
>>> etc.), and if someone with knowledge can assure me that the idea with
>>> the ACPI global lock (as far as I understand it is even implemented in
>>> the ec kernel driver already) is correct, I would even request to stop
>>> accepting the EC WMI sensors driver, as it is so slow (albeit dead
>>> simple and small).
>>>
>>> Best regards,
>>> Eugen
>>>

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Günter,

On Sun, 10 Oct 2021 at 16:33, Guenter Roeck <linux@roeck-us.net> wrote:
> > Why do you believe they are more reliable? How does it cover more motherboards?
> >
>
> You said yourself below: "I know the naive reading from the ACPI EC registers
> leads to problems (fans get stuck, etc.)".

I also know what the WMI functions (BREC, RSIO, WSIO, RHWM, ) do, as I
see their source. They lock the mutex (\AMW0.ASMX) and through
multi-level mapping access EC or Super I/O chip registers. I know all
the hardware access WMI functions begin with acquiring the same mutex,
and those accessing the SIO acquire one more mutex
(\_SB.PCI0.SBRG.SIO1.MUT0). Thus locking the same mutex and accessing
the hardware directly is safe.

By naive I meant reading EC registers without acquiring the ACPI mutex.

> Something in the WMI code is obviously broken and, ultimately, will need
> to get fixed. I don't know if that something is on the ASUS side or on the
> kernel side, or on the interface between the two. A single WMI call taking
> 1 second is way too long and strongly suggests that some timeout is involved.
> Not using WMI because of that just seems wrong.

On that machine a single reading of the EC register (i.e. a call to
ec_read()) takes approx. 14 ms. The timeout is probably right here.

From that the 990 ms delay of BREC is understandable, because for each
register it performs 4 EC transactions: read current bank,
unconditionally switch current bank, read register, switch to the old
bank. When I ask it to read 14 registers, it needs 42 ec_transaction()
calls which would sum up to 600 ms alone. In the new approach I switch
EC banks only when needed (currently only 2 times including rollback
to the previous bank) and save a lot of ec_transaction() calls. It
would help, however, to extend the EC interface in the acpi/ec.c to
allow for block reads in a single transaction.

I don't know why ec_transaction() takes so long, but in any case the
API of the WMI BREC function dictates it to perform slowly because it
needs to do a bank switch for each item in the input array, while the
direct reading allows us to avoid that bloating.

Regards,
Eugene

Re: [PATCH v2 2/3] hwmon: (asus_wmi_ec_sensors) Support B550 Asus WMI.

[Eugene Shalygin]

Hi All,

> On that machine a single reading of the EC register (i.e. a call to
> ec_read()) takes approx. 14 ms. The timeout is probably right here.

I migrated that ASUS machine to another distribution (Arch -> Gentoo,
kernel versions 5.14.8 -> 5.14.14) and surprisingly reading EC
registers became faster. I accumulated data from 14133 read operations
and the times are distributed as follows: 84 % at 4 ms, 10 % at 5 ms,
5.0 % at 6 ms and the rest is between 3 and 9 ms (but concentrating
around multiples of 0.5 ms).

In the meantime the only other user who provided EC read timeouts
showed 14 ms per EC read too.

Regards,
Eugene