1 // SPDX-License-Identifier: GPL-2.0+
3 * HWMON driver for ASUS motherboards that publish some sensor values
4 * via the embedded controller registers.
6 * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
9 * - Chipset temperature
11 * - Motherboard temperature
12 * - T_Sensor temperature
14 * - Water In temperature
15 * - Water Out temperature
16 * - CPU Optional fan RPM
18 * - VRM Heat Sink fan RPM
19 * - Water Flow fan RPM
24 #include <linux/acpi.h>
25 #include <linux/bitops.h>
26 #include <linux/dev_printk.h>
27 #include <linux/dmi.h>
28 #include <linux/hwmon.h>
29 #include <linux/init.h>
30 #include <linux/jiffies.h>
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/platform_device.h>
34 #include <linux/sort.h>
35 #include <linux/units.h>
37 #include <asm/unaligned.h>
39 static char *mutex_path_override;
41 /* Writing to this EC register switches EC bank */
42 #define ASUS_EC_BANK_REGISTER 0xff
43 #define SENSOR_LABEL_LEN 16
46 * Arbitrary set max. allowed bank number. Required for sorting banks and
47 * currently is overkill with just 2 banks used at max, but for the sake
48 * of alignment let's set it to a higher value.
50 #define ASUS_EC_MAX_BANK 3
52 #define ACPI_LOCK_DELAY_MS 500
54 /* ACPI mutex for locking access to the EC for the firmware */
55 #define ASUS_HW_ACCESS_MUTEX_ASMX "\\AMW0.ASMX"
57 #define ASUS_HW_ACCESS_MUTEX_RMTW_ASMX "\\RMTW.ASMX"
59 #define ASUS_HW_ACCESS_MUTEX_SB_PCI0_SBRG_SIO1_MUT0 "\\_SB_.PCI0.SBRG.SIO1.MUT0"
61 #define MAX_IDENTICAL_BOARD_VARIATIONS 3
63 /* Moniker for the ACPI global lock (':' is not allowed in ASL identifiers) */
64 #define ACPI_GLOBAL_LOCK_PSEUDO_PATH ":GLOBAL_LOCK"
76 #define MAKE_SENSOR_ADDRESS(size, bank, index) { \
77 .value = (size << 16) + (bank << 8) + index \
80 static u32 hwmon_attributes[hwmon_max] = {
81 [hwmon_chip] = HWMON_C_REGISTER_TZ,
82 [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL,
83 [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL,
84 [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL,
85 [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
88 struct ec_sensor_info {
89 char label[SENSOR_LABEL_LEN];
90 enum hwmon_sensor_types type;
94 #define EC_SENSOR(sensor_label, sensor_type, size, bank, index) { \
95 .label = sensor_label, .type = sensor_type, \
96 .addr = MAKE_SENSOR_ADDRESS(size, bank, index), \
100 /* chipset temperature [℃] */
101 ec_sensor_temp_chipset,
102 /* CPU temperature [℃] */
104 /* motherboard temperature [℃] */
106 /* "T_Sensor" temperature sensor reading [℃] */
107 ec_sensor_temp_t_sensor,
108 /* VRM temperature [℃] */
110 /* CPU Core voltage [mV] */
111 ec_sensor_in_cpu_core,
112 /* CPU_Opt fan [RPM] */
113 ec_sensor_fan_cpu_opt,
114 /* VRM heat sink fan [RPM] */
115 ec_sensor_fan_vrm_hs,
116 /* Chipset fan [RPM] */
117 ec_sensor_fan_chipset,
118 /* Water flow sensor reading [RPM] */
119 ec_sensor_fan_water_flow,
120 /* CPU current [A] */
122 /* "Water_In" temperature sensor reading [℃] */
123 ec_sensor_temp_water_in,
124 /* "Water_Out" temperature sensor reading [℃] */
125 ec_sensor_temp_water_out,
126 /* "Water_Block_In" temperature sensor reading [℃] */
127 ec_sensor_temp_water_block_in,
128 /* "Water_Block_Out" temperature sensor reading [℃] */
129 ec_sensor_temp_water_block_out,
130 /* "T_sensor_2" temperature sensor reading [℃] */
131 ec_sensor_temp_t_sensor_2,
132 /* "Extra_1" temperature sensor reading [℃] */
133 ec_sensor_temp_sensor_extra_1,
134 /* "Extra_2" temperature sensor reading [℃] */
135 ec_sensor_temp_sensor_extra_2,
136 /* "Extra_3" temperature sensor reading [℃] */
137 ec_sensor_temp_sensor_extra_3,
140 #define SENSOR_TEMP_CHIPSET BIT(ec_sensor_temp_chipset)
141 #define SENSOR_TEMP_CPU BIT(ec_sensor_temp_cpu)
142 #define SENSOR_TEMP_MB BIT(ec_sensor_temp_mb)
143 #define SENSOR_TEMP_T_SENSOR BIT(ec_sensor_temp_t_sensor)
144 #define SENSOR_TEMP_VRM BIT(ec_sensor_temp_vrm)
145 #define SENSOR_IN_CPU_CORE BIT(ec_sensor_in_cpu_core)
146 #define SENSOR_FAN_CPU_OPT BIT(ec_sensor_fan_cpu_opt)
147 #define SENSOR_FAN_VRM_HS BIT(ec_sensor_fan_vrm_hs)
148 #define SENSOR_FAN_CHIPSET BIT(ec_sensor_fan_chipset)
149 #define SENSOR_FAN_WATER_FLOW BIT(ec_sensor_fan_water_flow)
150 #define SENSOR_CURR_CPU BIT(ec_sensor_curr_cpu)
151 #define SENSOR_TEMP_WATER_IN BIT(ec_sensor_temp_water_in)
152 #define SENSOR_TEMP_WATER_OUT BIT(ec_sensor_temp_water_out)
153 #define SENSOR_TEMP_WATER_BLOCK_IN BIT(ec_sensor_temp_water_block_in)
154 #define SENSOR_TEMP_WATER_BLOCK_OUT BIT(ec_sensor_temp_water_block_out)
155 #define SENSOR_TEMP_T_SENSOR_2 BIT(ec_sensor_temp_t_sensor_2)
156 #define SENSOR_TEMP_SENSOR_EXTRA_1 BIT(ec_sensor_temp_sensor_extra_1)
157 #define SENSOR_TEMP_SENSOR_EXTRA_2 BIT(ec_sensor_temp_sensor_extra_2)
158 #define SENSOR_TEMP_SENSOR_EXTRA_3 BIT(ec_sensor_temp_sensor_extra_3)
162 family_amd_400_series,
163 family_amd_500_series,
164 family_intel_300_series,
165 family_intel_600_series
168 /* All the known sensors for ASUS EC controllers */
169 static const struct ec_sensor_info sensors_family_amd_400[] = {
170 [ec_sensor_temp_chipset] =
171 EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
172 [ec_sensor_temp_cpu] =
173 EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
174 [ec_sensor_temp_mb] =
175 EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
176 [ec_sensor_temp_t_sensor] =
177 EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
178 [ec_sensor_temp_vrm] =
179 EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
180 [ec_sensor_in_cpu_core] =
181 EC_SENSOR("CPU Core", hwmon_in, 2, 0x00, 0xa2),
182 [ec_sensor_fan_cpu_opt] =
183 EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xbc),
184 [ec_sensor_fan_vrm_hs] =
185 EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
186 [ec_sensor_fan_chipset] =
187 /* no chipset fans in this generation */
188 EC_SENSOR("Chipset", hwmon_fan, 0, 0x00, 0x00),
189 [ec_sensor_fan_water_flow] =
190 EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xb4),
191 [ec_sensor_curr_cpu] =
192 EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
193 [ec_sensor_temp_water_in] =
194 EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x0d),
195 [ec_sensor_temp_water_out] =
196 EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x0b),
199 static const struct ec_sensor_info sensors_family_amd_500[] = {
200 [ec_sensor_temp_chipset] =
201 EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
202 [ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
203 [ec_sensor_temp_mb] =
204 EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
205 [ec_sensor_temp_t_sensor] =
206 EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
207 [ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
208 [ec_sensor_in_cpu_core] =
209 EC_SENSOR("CPU Core", hwmon_in, 2, 0x00, 0xa2),
210 [ec_sensor_fan_cpu_opt] =
211 EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
212 [ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
213 [ec_sensor_fan_chipset] =
214 EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
215 [ec_sensor_fan_water_flow] =
216 EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
217 [ec_sensor_curr_cpu] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
218 [ec_sensor_temp_water_in] =
219 EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
220 [ec_sensor_temp_water_out] =
221 EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
222 [ec_sensor_temp_water_block_in] =
223 EC_SENSOR("Water_Block_In", hwmon_temp, 1, 0x01, 0x02),
224 [ec_sensor_temp_water_block_out] =
225 EC_SENSOR("Water_Block_Out", hwmon_temp, 1, 0x01, 0x03),
226 [ec_sensor_temp_sensor_extra_1] =
227 EC_SENSOR("Extra_1", hwmon_temp, 1, 0x01, 0x09),
228 [ec_sensor_temp_t_sensor_2] =
229 EC_SENSOR("T_sensor_2", hwmon_temp, 1, 0x01, 0x0a),
230 [ec_sensor_temp_sensor_extra_2] =
231 EC_SENSOR("Extra_2", hwmon_temp, 1, 0x01, 0x0b),
232 [ec_sensor_temp_sensor_extra_3] =
233 EC_SENSOR("Extra_3", hwmon_temp, 1, 0x01, 0x0c),
236 static const struct ec_sensor_info sensors_family_intel_300[] = {
237 [ec_sensor_temp_chipset] =
238 EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
239 [ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
240 [ec_sensor_temp_mb] =
241 EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
242 [ec_sensor_temp_t_sensor] =
243 EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
244 [ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
245 [ec_sensor_fan_cpu_opt] =
246 EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
247 [ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
248 [ec_sensor_fan_water_flow] =
249 EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
250 [ec_sensor_temp_water_in] =
251 EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
252 [ec_sensor_temp_water_out] =
253 EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
256 static const struct ec_sensor_info sensors_family_intel_600[] = {
257 [ec_sensor_temp_t_sensor] =
258 EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
259 [ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
262 /* Shortcuts for common combinations */
263 #define SENSOR_SET_TEMP_CHIPSET_CPU_MB \
264 (SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB)
265 #define SENSOR_SET_TEMP_WATER (SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT)
266 #define SENSOR_SET_WATER_BLOCK \
267 (SENSOR_TEMP_WATER_BLOCK_IN | SENSOR_TEMP_WATER_BLOCK_OUT)
269 struct ec_board_info {
270 unsigned long sensors;
272 * Defines which mutex to use for guarding access to the state and the
273 * hardware. Can be either a full path to an AML mutex or the
274 * pseudo-path ACPI_GLOBAL_LOCK_PSEUDO_PATH to use the global ACPI lock,
275 * or left empty to use a regular mutex object, in which case access to
276 * the hardware is not guarded.
278 const char *mutex_path;
279 enum board_family family;
282 static const struct ec_board_info board_info_prime_x470_pro = {
283 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
284 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM |
286 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE,
287 .mutex_path = ACPI_GLOBAL_LOCK_PSEUDO_PATH,
288 .family = family_amd_400_series,
291 static const struct ec_board_info board_info_prime_x570_pro = {
292 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
293 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET,
294 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
295 .family = family_amd_500_series,
298 static const struct ec_board_info board_info_pro_art_x570_creator_wifi = {
299 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
300 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CPU_OPT |
301 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE,
302 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
303 .family = family_amd_500_series,
306 static const struct ec_board_info board_info_pro_art_b550_creator = {
307 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
308 SENSOR_TEMP_T_SENSOR |
310 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
311 .family = family_amd_500_series,
314 static const struct ec_board_info board_info_pro_ws_x570_ace = {
315 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM |
316 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET |
317 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE,
318 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
319 .family = family_amd_500_series,
322 static const struct ec_board_info board_info_crosshair_viii_dark_hero = {
323 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
324 SENSOR_TEMP_T_SENSOR |
325 SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
326 SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW |
327 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE,
328 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
329 .family = family_amd_500_series,
332 static const struct ec_board_info board_info_crosshair_viii_hero = {
333 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
334 SENSOR_TEMP_T_SENSOR |
335 SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
336 SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET |
337 SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU |
339 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
340 .family = family_amd_500_series,
343 static const struct ec_board_info board_info_maximus_xi_hero = {
344 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
345 SENSOR_TEMP_T_SENSOR |
346 SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
347 SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW,
348 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
349 .family = family_intel_300_series,
352 static const struct ec_board_info board_info_crosshair_viii_impact = {
353 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
354 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM |
355 SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU |
357 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
358 .family = family_amd_500_series,
361 static const struct ec_board_info board_info_strix_b550_e_gaming = {
362 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
363 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM |
365 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
366 .family = family_amd_500_series,
369 static const struct ec_board_info board_info_strix_b550_i_gaming = {
370 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
371 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM |
372 SENSOR_FAN_VRM_HS | SENSOR_CURR_CPU |
374 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
375 .family = family_amd_500_series,
378 static const struct ec_board_info board_info_strix_x570_e_gaming = {
379 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
380 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM |
381 SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU |
383 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
384 .family = family_amd_500_series,
387 static const struct ec_board_info board_info_strix_x570_e_gaming_wifi_ii = {
388 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
389 SENSOR_TEMP_T_SENSOR | SENSOR_CURR_CPU |
391 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
392 .family = family_amd_500_series,
395 static const struct ec_board_info board_info_strix_x570_f_gaming = {
396 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB |
397 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET,
398 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
399 .family = family_amd_500_series,
402 static const struct ec_board_info board_info_strix_x570_i_gaming = {
403 .sensors = SENSOR_TEMP_CHIPSET | SENSOR_TEMP_VRM |
404 SENSOR_TEMP_T_SENSOR |
405 SENSOR_FAN_VRM_HS | SENSOR_FAN_CHIPSET |
406 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE,
407 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX,
408 .family = family_amd_500_series,
411 static const struct ec_board_info board_info_strix_z690_a_gaming_wifi_d4 = {
412 .sensors = SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM,
413 .mutex_path = ASUS_HW_ACCESS_MUTEX_RMTW_ASMX,
414 .family = family_intel_600_series,
417 static const struct ec_board_info board_info_zenith_ii_extreme = {
418 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_T_SENSOR |
419 SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER |
420 SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET | SENSOR_FAN_VRM_HS |
421 SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE |
422 SENSOR_SET_WATER_BLOCK |
423 SENSOR_TEMP_T_SENSOR_2 | SENSOR_TEMP_SENSOR_EXTRA_1 |
424 SENSOR_TEMP_SENSOR_EXTRA_2 | SENSOR_TEMP_SENSOR_EXTRA_3,
425 .mutex_path = ASUS_HW_ACCESS_MUTEX_SB_PCI0_SBRG_SIO1_MUT0,
426 .family = family_amd_500_series,
429 #define DMI_EXACT_MATCH_ASUS_BOARD_NAME(name, board_info) \
432 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, \
433 "ASUSTeK COMPUTER INC."), \
434 DMI_EXACT_MATCH(DMI_BOARD_NAME, name), \
436 .driver_data = (void *)board_info, \
439 static const struct dmi_system_id dmi_table[] = {
440 DMI_EXACT_MATCH_ASUS_BOARD_NAME("PRIME X470-PRO",
441 &board_info_prime_x470_pro),
442 DMI_EXACT_MATCH_ASUS_BOARD_NAME("PRIME X570-PRO",
443 &board_info_prime_x570_pro),
444 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ProArt X570-CREATOR WIFI",
445 &board_info_pro_art_x570_creator_wifi),
446 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ProArt B550-CREATOR",
447 &board_info_pro_art_b550_creator),
448 DMI_EXACT_MATCH_ASUS_BOARD_NAME("Pro WS X570-ACE",
449 &board_info_pro_ws_x570_ace),
450 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII DARK HERO",
451 &board_info_crosshair_viii_dark_hero),
452 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII FORMULA",
453 &board_info_crosshair_viii_hero),
454 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII HERO",
455 &board_info_crosshair_viii_hero),
456 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII HERO (WI-FI)",
457 &board_info_crosshair_viii_hero),
458 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG MAXIMUS XI HERO",
459 &board_info_maximus_xi_hero),
460 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG MAXIMUS XI HERO (WI-FI)",
461 &board_info_maximus_xi_hero),
462 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII IMPACT",
463 &board_info_crosshair_viii_impact),
464 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX B550-E GAMING",
465 &board_info_strix_b550_e_gaming),
466 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX B550-I GAMING",
467 &board_info_strix_b550_i_gaming),
468 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX X570-E GAMING",
469 &board_info_strix_x570_e_gaming),
470 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX X570-E GAMING WIFI II",
471 &board_info_strix_x570_e_gaming_wifi_ii),
472 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX X570-F GAMING",
473 &board_info_strix_x570_f_gaming),
474 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX X570-I GAMING",
475 &board_info_strix_x570_i_gaming),
476 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX Z690-A GAMING WIFI D4",
477 &board_info_strix_z690_a_gaming_wifi_d4),
478 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG ZENITH II EXTREME",
479 &board_info_zenith_ii_extreme),
480 DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG ZENITH II EXTREME ALPHA",
481 &board_info_zenith_ii_extreme),
486 unsigned int info_index;
493 /* global lock handle */
496 bool (*lock)(struct lock_data *data);
497 bool (*unlock)(struct lock_data *data);
501 * The next function pairs implement options for locking access to the
504 static bool lock_via_acpi_mutex(struct lock_data *data)
507 * ASUS DSDT does not specify that access to the EC has to be guarded,
508 * but firmware does access it via ACPI
510 return ACPI_SUCCESS(acpi_acquire_mutex(data->mutex.aml,
511 NULL, ACPI_LOCK_DELAY_MS));
514 static bool unlock_acpi_mutex(struct lock_data *data)
516 return ACPI_SUCCESS(acpi_release_mutex(data->mutex.aml, NULL));
519 static bool lock_via_global_acpi_lock(struct lock_data *data)
521 return ACPI_SUCCESS(acpi_acquire_global_lock(ACPI_LOCK_DELAY_MS,
525 static bool unlock_global_acpi_lock(struct lock_data *data)
527 return ACPI_SUCCESS(acpi_release_global_lock(data->mutex.glk));
530 struct ec_sensors_data {
531 const struct ec_board_info *board_info;
532 const struct ec_sensor_info *sensors_info;
533 struct ec_sensor *sensors;
534 /* EC registers to read from */
537 /* sorted list of unique register banks */
538 u8 banks[ASUS_EC_MAX_BANK + 1];
540 unsigned long last_updated;
541 struct lock_data lock_data;
542 /* number of board EC sensors */
545 * number of EC registers to read
546 * (sensor might span more than 1 register)
549 /* number of unique register banks */
553 static u8 register_bank(u16 reg)
558 static u8 register_index(u16 reg)
563 static bool is_sensor_data_signed(const struct ec_sensor_info *si)
566 * guessed from WMI functions in DSDT code for boards
567 * of the X470 generation
569 return si->type == hwmon_temp;
572 static const struct ec_sensor_info *
573 get_sensor_info(const struct ec_sensors_data *state, int index)
575 return state->sensors_info + state->sensors[index].info_index;
578 static int find_ec_sensor_index(const struct ec_sensors_data *ec,
579 enum hwmon_sensor_types type, int channel)
583 for (i = 0; i < ec->nr_sensors; i++) {
584 if (get_sensor_info(ec, i)->type == type) {
593 static int bank_compare(const void *a, const void *b)
595 return *((const s8 *)a) - *((const s8 *)b);
598 static void setup_sensor_data(struct ec_sensors_data *ec)
600 struct ec_sensor *s = ec->sensors;
606 ec->nr_registers = 0;
608 for_each_set_bit(i, &ec->board_info->sensors,
609 BITS_PER_TYPE(ec->board_info->sensors)) {
613 ec->sensors_info[s->info_index].addr.components.size;
615 bank = ec->sensors_info[s->info_index].addr.components.bank;
616 for (j = 0; j < ec->nr_banks; j++) {
617 if (ec->banks[j] == bank) {
623 ec->banks[ec->nr_banks++] = bank;
627 sort(ec->banks, ec->nr_banks, 1, bank_compare, NULL);
630 static void fill_ec_registers(struct ec_sensors_data *ec)
632 const struct ec_sensor_info *si;
633 unsigned int i, j, register_idx = 0;
635 for (i = 0; i < ec->nr_sensors; ++i) {
636 si = get_sensor_info(ec, i);
637 for (j = 0; j < si->addr.components.size; ++j, ++register_idx) {
638 ec->registers[register_idx] =
639 (si->addr.components.bank << 8) +
640 si->addr.components.index + j;
645 static int setup_lock_data(struct device *dev)
647 const char *mutex_path;
649 struct ec_sensors_data *state = dev_get_drvdata(dev);
651 mutex_path = mutex_path_override ?
652 mutex_path_override : state->board_info->mutex_path;
654 if (!mutex_path || !strlen(mutex_path)) {
655 dev_err(dev, "Hardware access guard mutex name is empty");
658 if (!strcmp(mutex_path, ACPI_GLOBAL_LOCK_PSEUDO_PATH)) {
659 state->lock_data.mutex.glk = 0;
660 state->lock_data.lock = lock_via_global_acpi_lock;
661 state->lock_data.unlock = unlock_global_acpi_lock;
663 status = acpi_get_handle(NULL, (acpi_string)mutex_path,
664 &state->lock_data.mutex.aml);
665 if (ACPI_FAILURE(status)) {
667 "Failed to get hardware access guard AML mutex '%s': error %d",
671 state->lock_data.lock = lock_via_acpi_mutex;
672 state->lock_data.unlock = unlock_acpi_mutex;
677 static int asus_ec_bank_switch(u8 bank, u8 *old)
682 status = ec_read(ASUS_EC_BANK_REGISTER, old);
684 if (status || (old && (*old == bank)))
686 return ec_write(ASUS_EC_BANK_REGISTER, bank);
689 static int asus_ec_block_read(const struct device *dev,
690 struct ec_sensors_data *ec)
692 int ireg, ibank, status;
693 u8 bank, reg_bank, prev_bank;
696 status = asus_ec_bank_switch(bank, &prev_bank);
698 dev_warn(dev, "EC bank switch failed");
703 /* oops... somebody else is working with the EC too */
705 "Concurrent access to the ACPI EC detected.\nRace condition possible.");
708 /* read registers minimizing bank switches. */
709 for (ibank = 0; ibank < ec->nr_banks; ibank++) {
710 if (bank != ec->banks[ibank]) {
711 bank = ec->banks[ibank];
712 if (asus_ec_bank_switch(bank, NULL)) {
713 dev_warn(dev, "EC bank switch to %d failed",
718 for (ireg = 0; ireg < ec->nr_registers; ireg++) {
719 reg_bank = register_bank(ec->registers[ireg]);
720 if (reg_bank < bank) {
723 ec_read(register_index(ec->registers[ireg]),
724 ec->read_buffer + ireg);
728 status = asus_ec_bank_switch(prev_bank, NULL);
732 static inline s32 get_sensor_value(const struct ec_sensor_info *si, u8 *data)
734 if (is_sensor_data_signed(si)) {
735 switch (si->addr.components.size) {
739 return (s16)get_unaligned_be16(data);
741 return (s32)get_unaligned_be32(data);
746 switch (si->addr.components.size) {
750 return get_unaligned_be16(data);
752 return get_unaligned_be32(data);
759 static void update_sensor_values(struct ec_sensors_data *ec, u8 *data)
761 const struct ec_sensor_info *si;
762 struct ec_sensor *s, *sensor_end;
764 sensor_end = ec->sensors + ec->nr_sensors;
765 for (s = ec->sensors; s != sensor_end; s++) {
766 si = ec->sensors_info + s->info_index;
767 s->cached_value = get_sensor_value(si, data);
768 data += si->addr.components.size;
772 static int update_ec_sensors(const struct device *dev,
773 struct ec_sensors_data *ec)
777 if (!ec->lock_data.lock(&ec->lock_data)) {
778 dev_warn(dev, "Failed to acquire mutex");
782 status = asus_ec_block_read(dev, ec);
785 update_sensor_values(ec, ec->read_buffer);
788 if (!ec->lock_data.unlock(&ec->lock_data))
789 dev_err(dev, "Failed to release mutex");
794 static long scale_sensor_value(s32 value, int data_type)
799 return value * MILLI;
805 static int get_cached_value_or_update(const struct device *dev,
807 struct ec_sensors_data *state, s32 *value)
809 if (time_after(jiffies, state->last_updated + HZ)) {
810 if (update_ec_sensors(dev, state)) {
811 dev_err(dev, "update_ec_sensors() failure\n");
815 state->last_updated = jiffies;
818 *value = state->sensors[sensor_index].cached_value;
823 * Now follow the functions that implement the hwmon interface
826 static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
827 u32 attr, int channel, long *val)
832 struct ec_sensors_data *state = dev_get_drvdata(dev);
833 int sidx = find_ec_sensor_index(state, type, channel);
839 ret = get_cached_value_or_update(dev, sidx, state, &value);
841 *val = scale_sensor_value(value,
842 get_sensor_info(state, sidx)->type);
848 static int asus_ec_hwmon_read_string(struct device *dev,
849 enum hwmon_sensor_types type, u32 attr,
850 int channel, const char **str)
852 struct ec_sensors_data *state = dev_get_drvdata(dev);
853 int sensor_index = find_ec_sensor_index(state, type, channel);
854 *str = get_sensor_info(state, sensor_index)->label;
859 static umode_t asus_ec_hwmon_is_visible(const void *drvdata,
860 enum hwmon_sensor_types type, u32 attr,
863 const struct ec_sensors_data *state = drvdata;
865 return find_ec_sensor_index(state, type, channel) >= 0 ? S_IRUGO : 0;
869 asus_ec_hwmon_add_chan_info(struct hwmon_channel_info *asus_ec_hwmon_chan,
870 struct device *dev, int num,
871 enum hwmon_sensor_types type, u32 config)
874 u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
879 asus_ec_hwmon_chan->type = type;
880 asus_ec_hwmon_chan->config = cfg;
881 for (i = 0; i < num; i++, cfg++)
887 static const struct hwmon_ops asus_ec_hwmon_ops = {
888 .is_visible = asus_ec_hwmon_is_visible,
889 .read = asus_ec_hwmon_read,
890 .read_string = asus_ec_hwmon_read_string,
893 static struct hwmon_chip_info asus_ec_chip_info = {
894 .ops = &asus_ec_hwmon_ops,
897 static const struct ec_board_info *get_board_info(void)
899 const struct dmi_system_id *dmi_entry;
901 dmi_entry = dmi_first_match(dmi_table);
902 return dmi_entry ? dmi_entry->driver_data : NULL;
905 static int asus_ec_probe(struct platform_device *pdev)
907 const struct hwmon_channel_info **ptr_asus_ec_ci;
908 int nr_count[hwmon_max] = { 0 }, nr_types = 0;
909 struct hwmon_channel_info *asus_ec_hwmon_chan;
910 const struct ec_board_info *pboard_info;
911 const struct hwmon_chip_info *chip_info;
912 struct device *dev = &pdev->dev;
913 struct ec_sensors_data *ec_data;
914 const struct ec_sensor_info *si;
915 enum hwmon_sensor_types type;
916 struct device *hwdev;
920 pboard_info = get_board_info();
924 ec_data = devm_kzalloc(dev, sizeof(struct ec_sensors_data),
929 dev_set_drvdata(dev, ec_data);
930 ec_data->board_info = pboard_info;
932 switch (ec_data->board_info->family) {
933 case family_amd_400_series:
934 ec_data->sensors_info = sensors_family_amd_400;
936 case family_amd_500_series:
937 ec_data->sensors_info = sensors_family_amd_500;
939 case family_intel_300_series:
940 ec_data->sensors_info = sensors_family_intel_300;
942 case family_intel_600_series:
943 ec_data->sensors_info = sensors_family_intel_600;
946 dev_err(dev, "Unknown board family: %d",
947 ec_data->board_info->family);
951 ec_data->nr_sensors = hweight_long(ec_data->board_info->sensors);
952 ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors,
953 sizeof(struct ec_sensor), GFP_KERNEL);
954 if (!ec_data->sensors)
957 status = setup_lock_data(dev);
959 dev_err(dev, "Failed to setup state/EC locking: %d", status);
963 setup_sensor_data(ec_data);
964 ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers,
965 sizeof(u16), GFP_KERNEL);
966 ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers,
967 sizeof(u8), GFP_KERNEL);
969 if (!ec_data->registers || !ec_data->read_buffer)
972 fill_ec_registers(ec_data);
974 for (i = 0; i < ec_data->nr_sensors; ++i) {
975 si = get_sensor_info(ec_data, i);
976 if (!nr_count[si->type])
978 ++nr_count[si->type];
981 if (nr_count[hwmon_temp])
982 nr_count[hwmon_chip]++, nr_types++;
984 asus_ec_hwmon_chan = devm_kcalloc(
985 dev, nr_types, sizeof(*asus_ec_hwmon_chan), GFP_KERNEL);
986 if (!asus_ec_hwmon_chan)
989 ptr_asus_ec_ci = devm_kcalloc(dev, nr_types + 1,
990 sizeof(*ptr_asus_ec_ci), GFP_KERNEL);
994 asus_ec_chip_info.info = ptr_asus_ec_ci;
995 chip_info = &asus_ec_chip_info;
997 for (type = 0; type < hwmon_max; ++type) {
1001 asus_ec_hwmon_add_chan_info(asus_ec_hwmon_chan, dev,
1002 nr_count[type], type,
1003 hwmon_attributes[type]);
1004 *ptr_asus_ec_ci++ = asus_ec_hwmon_chan++;
1007 dev_info(dev, "board has %d EC sensors that span %d registers",
1008 ec_data->nr_sensors, ec_data->nr_registers);
1010 hwdev = devm_hwmon_device_register_with_info(dev, "asusec",
1011 ec_data, chip_info, NULL);
1013 return PTR_ERR_OR_ZERO(hwdev);
1016 MODULE_DEVICE_TABLE(dmi, dmi_table);
1018 static struct platform_driver asus_ec_sensors_platform_driver = {
1020 .name = "asus-ec-sensors",
1022 .probe = asus_ec_probe,
1025 static struct platform_device *asus_ec_sensors_platform_device;
1027 static int __init asus_ec_init(void)
1029 asus_ec_sensors_platform_device =
1030 platform_create_bundle(&asus_ec_sensors_platform_driver,
1031 asus_ec_probe, NULL, 0, NULL, 0);
1033 if (IS_ERR(asus_ec_sensors_platform_device))
1034 return PTR_ERR(asus_ec_sensors_platform_device);
1039 static void __exit asus_ec_exit(void)
1041 platform_device_unregister(asus_ec_sensors_platform_device);
1042 platform_driver_unregister(&asus_ec_sensors_platform_driver);
1045 module_init(asus_ec_init);
1046 module_exit(asus_ec_exit);
1048 module_param_named(mutex_path, mutex_path_override, charp, 0);
1049 MODULE_PARM_DESC(mutex_path,
1050 "Override ACPI mutex path used to guard access to hardware");
1052 MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
1054 "HWMON driver for sensors accessible via ACPI EC in ASUS motherboards");
1055 MODULE_LICENSE("GPL");