1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * HWMON driver for ASUS motherboards that publish some sensor values 4 * via the embedded controller registers. 5 * 6 * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com> 7 8 * EC provides: 9 * - Chipset temperature 10 * - CPU temperature 11 * - Motherboard temperature 12 * - T_Sensor temperature 13 * - VRM temperature 14 * - Water In temperature 15 * - Water Out temperature 16 * - CPU Optional fan RPM 17 * - Chipset fan RPM 18 * - VRM Heat Sink fan RPM 19 * - Water Flow fan RPM 20 * - CPU current 21 * - CPU core voltage 22 */ 23 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> 36 37 #include <asm/unaligned.h> 38 39 static char *mutex_path_override; 40 41 /* Writing to this EC register switches EC bank */ 42 #define ASUS_EC_BANK_REGISTER 0xff 43 #define SENSOR_LABEL_LEN 16 44 45 /* 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. 49 */ 50 #define ASUS_EC_MAX_BANK 3 51 52 #define ACPI_LOCK_DELAY_MS 500 53 54 /* ACPI mutex for locking access to the EC for the firmware */ 55 #define ASUS_HW_ACCESS_MUTEX_ASMX "\\AMW0.ASMX" 56 57 #define MAX_IDENTICAL_BOARD_VARIATIONS 3 58 59 /* Moniker for the ACPI global lock (':' is not allowed in ASL identifiers) */ 60 #define ACPI_GLOBAL_LOCK_PSEUDO_PATH ":GLOBAL_LOCK" 61 62 typedef union { 63 u32 value; 64 struct { 65 u8 index; 66 u8 bank; 67 u8 size; 68 u8 dummy; 69 } components; 70 } sensor_address; 71 72 #define MAKE_SENSOR_ADDRESS(size, bank, index) { \ 73 .value = (size << 16) + (bank << 8) + index \ 74 } 75 76 static u32 hwmon_attributes[hwmon_max] = { 77 [hwmon_chip] = HWMON_C_REGISTER_TZ, 78 [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL, 79 [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL, 80 [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL, 81 [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL, 82 }; 83 84 struct ec_sensor_info { 85 char label[SENSOR_LABEL_LEN]; 86 enum hwmon_sensor_types type; 87 sensor_address addr; 88 }; 89 90 #define EC_SENSOR(sensor_label, sensor_type, size, bank, index) { \ 91 .label = sensor_label, .type = sensor_type, \ 92 .addr = MAKE_SENSOR_ADDRESS(size, bank, index), \ 93 } 94 95 enum ec_sensors { 96 /* chipset temperature [℃] */ 97 ec_sensor_temp_chipset, 98 /* CPU temperature [℃] */ 99 ec_sensor_temp_cpu, 100 /* motherboard temperature [℃] */ 101 ec_sensor_temp_mb, 102 /* "T_Sensor" temperature sensor reading [℃] */ 103 ec_sensor_temp_t_sensor, 104 /* VRM temperature [℃] */ 105 ec_sensor_temp_vrm, 106 /* CPU Core voltage [mV] */ 107 ec_sensor_in_cpu_core, 108 /* CPU_Opt fan [RPM] */ 109 ec_sensor_fan_cpu_opt, 110 /* VRM heat sink fan [RPM] */ 111 ec_sensor_fan_vrm_hs, 112 /* Chipset fan [RPM] */ 113 ec_sensor_fan_chipset, 114 /* Water flow sensor reading [RPM] */ 115 ec_sensor_fan_water_flow, 116 /* CPU current [A] */ 117 ec_sensor_curr_cpu, 118 /* "Water_In" temperature sensor reading [℃] */ 119 ec_sensor_temp_water_in, 120 /* "Water_Out" temperature sensor reading [℃] */ 121 ec_sensor_temp_water_out, 122 }; 123 124 #define SENSOR_TEMP_CHIPSET BIT(ec_sensor_temp_chipset) 125 #define SENSOR_TEMP_CPU BIT(ec_sensor_temp_cpu) 126 #define SENSOR_TEMP_MB BIT(ec_sensor_temp_mb) 127 #define SENSOR_TEMP_T_SENSOR BIT(ec_sensor_temp_t_sensor) 128 #define SENSOR_TEMP_VRM BIT(ec_sensor_temp_vrm) 129 #define SENSOR_IN_CPU_CORE BIT(ec_sensor_in_cpu_core) 130 #define SENSOR_FAN_CPU_OPT BIT(ec_sensor_fan_cpu_opt) 131 #define SENSOR_FAN_VRM_HS BIT(ec_sensor_fan_vrm_hs) 132 #define SENSOR_FAN_CHIPSET BIT(ec_sensor_fan_chipset) 133 #define SENSOR_FAN_WATER_FLOW BIT(ec_sensor_fan_water_flow) 134 #define SENSOR_CURR_CPU BIT(ec_sensor_curr_cpu) 135 #define SENSOR_TEMP_WATER_IN BIT(ec_sensor_temp_water_in) 136 #define SENSOR_TEMP_WATER_OUT BIT(ec_sensor_temp_water_out) 137 138 enum board_family { 139 family_unknown, 140 family_amd_400_series, 141 family_amd_500_series, 142 }; 143 144 /* All the known sensors for ASUS EC controllers */ 145 static const struct ec_sensor_info sensors_family_amd_400[] = { 146 [ec_sensor_temp_chipset] = 147 EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a), 148 [ec_sensor_temp_cpu] = 149 EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b), 150 [ec_sensor_temp_mb] = 151 EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c), 152 [ec_sensor_temp_t_sensor] = 153 EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d), 154 [ec_sensor_temp_vrm] = 155 EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e), 156 [ec_sensor_in_cpu_core] = 157 EC_SENSOR("CPU Core", hwmon_in, 2, 0x00, 0xa2), 158 [ec_sensor_fan_cpu_opt] = 159 EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xbc), 160 [ec_sensor_fan_vrm_hs] = 161 EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2), 162 [ec_sensor_fan_chipset] = 163 /* no chipset fans in this generation */ 164 EC_SENSOR("Chipset", hwmon_fan, 0, 0x00, 0x00), 165 [ec_sensor_fan_water_flow] = 166 EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xb4), 167 [ec_sensor_curr_cpu] = 168 EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4), 169 [ec_sensor_temp_water_in] = 170 EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x0d), 171 [ec_sensor_temp_water_out] = 172 EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x0b), 173 }; 174 175 static const struct ec_sensor_info sensors_family_amd_500[] = { 176 [ec_sensor_temp_chipset] = 177 EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a), 178 [ec_sensor_temp_cpu] = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b), 179 [ec_sensor_temp_mb] = 180 EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c), 181 [ec_sensor_temp_t_sensor] = 182 EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d), 183 [ec_sensor_temp_vrm] = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e), 184 [ec_sensor_in_cpu_core] = 185 EC_SENSOR("CPU Core", hwmon_in, 2, 0x00, 0xa2), 186 [ec_sensor_fan_cpu_opt] = 187 EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0), 188 [ec_sensor_fan_vrm_hs] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2), 189 [ec_sensor_fan_chipset] = 190 EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4), 191 [ec_sensor_fan_water_flow] = 192 EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc), 193 [ec_sensor_curr_cpu] = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4), 194 [ec_sensor_temp_water_in] = 195 EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00), 196 [ec_sensor_temp_water_out] = 197 EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01), 198 }; 199 200 /* Shortcuts for common combinations */ 201 #define SENSOR_SET_TEMP_CHIPSET_CPU_MB \ 202 (SENSOR_TEMP_CHIPSET | SENSOR_TEMP_CPU | SENSOR_TEMP_MB) 203 #define SENSOR_SET_TEMP_WATER (SENSOR_TEMP_WATER_IN | SENSOR_TEMP_WATER_OUT) 204 205 struct ec_board_info { 206 const char *board_names[MAX_IDENTICAL_BOARD_VARIATIONS]; 207 unsigned long sensors; 208 /* 209 * Defines which mutex to use for guarding access to the state and the 210 * hardware. Can be either a full path to an AML mutex or the 211 * pseudo-path ACPI_GLOBAL_LOCK_PSEUDO_PATH to use the global ACPI lock, 212 * or left empty to use a regular mutex object, in which case access to 213 * the hardware is not guarded. 214 */ 215 const char *mutex_path; 216 enum board_family family; 217 }; 218 219 static const struct ec_board_info board_info[] = { 220 { 221 .board_names = {"PRIME X470-PRO"}, 222 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 223 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM | 224 SENSOR_FAN_CPU_OPT | 225 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE, 226 .mutex_path = ACPI_GLOBAL_LOCK_PSEUDO_PATH, 227 .family = family_amd_400_series, 228 }, 229 { 230 .board_names = {"PRIME X570-PRO"}, 231 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM | 232 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET, 233 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 234 .family = family_amd_500_series, 235 }, 236 { 237 .board_names = {"ProArt X570-CREATOR WIFI"}, 238 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM | 239 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CPU_OPT | 240 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE, 241 }, 242 { 243 .board_names = {"Pro WS X570-ACE"}, 244 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | SENSOR_TEMP_VRM | 245 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET | 246 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE, 247 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 248 .family = family_amd_500_series, 249 }, 250 { 251 .board_names = {"ROG CROSSHAIR VIII DARK HERO"}, 252 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 253 SENSOR_TEMP_T_SENSOR | 254 SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER | 255 SENSOR_FAN_CPU_OPT | SENSOR_FAN_WATER_FLOW | 256 SENSOR_CURR_CPU | SENSOR_IN_CPU_CORE, 257 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 258 .family = family_amd_500_series, 259 }, 260 { 261 .board_names = { 262 "ROG CROSSHAIR VIII FORMULA", 263 "ROG CROSSHAIR VIII HERO", 264 "ROG CROSSHAIR VIII HERO (WI-FI)", 265 }, 266 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 267 SENSOR_TEMP_T_SENSOR | 268 SENSOR_TEMP_VRM | SENSOR_SET_TEMP_WATER | 269 SENSOR_FAN_CPU_OPT | SENSOR_FAN_CHIPSET | 270 SENSOR_FAN_WATER_FLOW | SENSOR_CURR_CPU | 271 SENSOR_IN_CPU_CORE, 272 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 273 .family = family_amd_500_series, 274 }, 275 { 276 .board_names = {"ROG CROSSHAIR VIII IMPACT"}, 277 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 278 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM | 279 SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU | 280 SENSOR_IN_CPU_CORE, 281 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 282 .family = family_amd_500_series, 283 }, 284 { 285 .board_names = {"ROG STRIX B550-E GAMING"}, 286 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 287 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM | 288 SENSOR_FAN_CPU_OPT, 289 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 290 .family = family_amd_500_series, 291 }, 292 { 293 .board_names = {"ROG STRIX B550-I GAMING"}, 294 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 295 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM | 296 SENSOR_FAN_VRM_HS | SENSOR_CURR_CPU | 297 SENSOR_IN_CPU_CORE, 298 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 299 .family = family_amd_500_series, 300 }, 301 { 302 .board_names = {"ROG STRIX X570-E GAMING"}, 303 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 304 SENSOR_TEMP_T_SENSOR | SENSOR_TEMP_VRM | 305 SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU | 306 SENSOR_IN_CPU_CORE, 307 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 308 .family = family_amd_500_series, 309 }, 310 { 311 .board_names = {"ROG STRIX X570-E GAMING WIFI II"}, 312 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 313 SENSOR_TEMP_T_SENSOR | SENSOR_CURR_CPU | 314 SENSOR_IN_CPU_CORE, 315 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 316 .family = family_amd_500_series, 317 }, 318 { 319 .board_names = {"ROG STRIX X570-F GAMING"}, 320 .sensors = SENSOR_SET_TEMP_CHIPSET_CPU_MB | 321 SENSOR_TEMP_T_SENSOR | SENSOR_FAN_CHIPSET, 322 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 323 .family = family_amd_500_series, 324 }, 325 { 326 .board_names = {"ROG STRIX X570-I GAMING"}, 327 .sensors = SENSOR_TEMP_T_SENSOR | SENSOR_FAN_VRM_HS | 328 SENSOR_FAN_CHIPSET | SENSOR_CURR_CPU | 329 SENSOR_IN_CPU_CORE, 330 .mutex_path = ASUS_HW_ACCESS_MUTEX_ASMX, 331 .family = family_amd_500_series, 332 }, 333 {} 334 }; 335 336 struct ec_sensor { 337 unsigned int info_index; 338 s32 cached_value; 339 }; 340 341 struct lock_data { 342 union { 343 acpi_handle aml; 344 /* global lock handle */ 345 u32 glk; 346 } mutex; 347 bool (*lock)(struct lock_data *data); 348 bool (*unlock)(struct lock_data *data); 349 }; 350 351 /* 352 * The next function pairs implement options for locking access to the 353 * state and the EC 354 */ 355 static bool lock_via_acpi_mutex(struct lock_data *data) 356 { 357 /* 358 * ASUS DSDT does not specify that access to the EC has to be guarded, 359 * but firmware does access it via ACPI 360 */ 361 return ACPI_SUCCESS(acpi_acquire_mutex(data->mutex.aml, 362 NULL, ACPI_LOCK_DELAY_MS)); 363 } 364 365 static bool unlock_acpi_mutex(struct lock_data *data) 366 { 367 return ACPI_SUCCESS(acpi_release_mutex(data->mutex.aml, NULL)); 368 } 369 370 static bool lock_via_global_acpi_lock(struct lock_data *data) 371 { 372 return ACPI_SUCCESS(acpi_acquire_global_lock(ACPI_LOCK_DELAY_MS, 373 &data->mutex.glk)); 374 } 375 376 static bool unlock_global_acpi_lock(struct lock_data *data) 377 { 378 return ACPI_SUCCESS(acpi_release_global_lock(data->mutex.glk)); 379 } 380 381 struct ec_sensors_data { 382 const struct ec_board_info *board_info; 383 const struct ec_sensor_info *sensors_info; 384 struct ec_sensor *sensors; 385 /* EC registers to read from */ 386 u16 *registers; 387 u8 *read_buffer; 388 /* sorted list of unique register banks */ 389 u8 banks[ASUS_EC_MAX_BANK + 1]; 390 /* in jiffies */ 391 unsigned long last_updated; 392 struct lock_data lock_data; 393 /* number of board EC sensors */ 394 u8 nr_sensors; 395 /* 396 * number of EC registers to read 397 * (sensor might span more than 1 register) 398 */ 399 u8 nr_registers; 400 /* number of unique register banks */ 401 u8 nr_banks; 402 }; 403 404 static u8 register_bank(u16 reg) 405 { 406 return reg >> 8; 407 } 408 409 static u8 register_index(u16 reg) 410 { 411 return reg & 0x00ff; 412 } 413 414 static bool is_sensor_data_signed(const struct ec_sensor_info *si) 415 { 416 /* 417 * guessed from WMI functions in DSDT code for boards 418 * of the X470 generation 419 */ 420 return si->type == hwmon_temp; 421 } 422 423 static const struct ec_sensor_info * 424 get_sensor_info(const struct ec_sensors_data *state, int index) 425 { 426 return state->sensors_info + state->sensors[index].info_index; 427 } 428 429 static int find_ec_sensor_index(const struct ec_sensors_data *ec, 430 enum hwmon_sensor_types type, int channel) 431 { 432 unsigned int i; 433 434 for (i = 0; i < ec->nr_sensors; i++) { 435 if (get_sensor_info(ec, i)->type == type) { 436 if (channel == 0) 437 return i; 438 channel--; 439 } 440 } 441 return -ENOENT; 442 } 443 444 static int __init bank_compare(const void *a, const void *b) 445 { 446 return *((const s8 *)a) - *((const s8 *)b); 447 } 448 449 static void __init setup_sensor_data(struct ec_sensors_data *ec) 450 { 451 struct ec_sensor *s = ec->sensors; 452 bool bank_found; 453 int i, j; 454 u8 bank; 455 456 ec->nr_banks = 0; 457 ec->nr_registers = 0; 458 459 for_each_set_bit(i, &ec->board_info->sensors, 460 BITS_PER_TYPE(ec->board_info->sensors)) { 461 s->info_index = i; 462 s->cached_value = 0; 463 ec->nr_registers += 464 ec->sensors_info[s->info_index].addr.components.size; 465 bank_found = false; 466 bank = ec->sensors_info[s->info_index].addr.components.bank; 467 for (j = 0; j < ec->nr_banks; j++) { 468 if (ec->banks[j] == bank) { 469 bank_found = true; 470 break; 471 } 472 } 473 if (!bank_found) { 474 ec->banks[ec->nr_banks++] = bank; 475 } 476 s++; 477 } 478 sort(ec->banks, ec->nr_banks, 1, bank_compare, NULL); 479 } 480 481 static void __init fill_ec_registers(struct ec_sensors_data *ec) 482 { 483 const struct ec_sensor_info *si; 484 unsigned int i, j, register_idx = 0; 485 486 for (i = 0; i < ec->nr_sensors; ++i) { 487 si = get_sensor_info(ec, i); 488 for (j = 0; j < si->addr.components.size; ++j, ++register_idx) { 489 ec->registers[register_idx] = 490 (si->addr.components.bank << 8) + 491 si->addr.components.index + j; 492 } 493 } 494 } 495 496 static int __init setup_lock_data(struct device *dev) 497 { 498 const char *mutex_path; 499 int status; 500 struct ec_sensors_data *state = dev_get_drvdata(dev); 501 502 mutex_path = mutex_path_override ? 503 mutex_path_override : state->board_info->mutex_path; 504 505 if (!mutex_path || !strlen(mutex_path)) { 506 dev_err(dev, "Hardware access guard mutex name is empty"); 507 return -EINVAL; 508 } 509 if (!strcmp(mutex_path, ACPI_GLOBAL_LOCK_PSEUDO_PATH)) { 510 state->lock_data.mutex.glk = 0; 511 state->lock_data.lock = lock_via_global_acpi_lock; 512 state->lock_data.unlock = unlock_global_acpi_lock; 513 } else { 514 status = acpi_get_handle(NULL, (acpi_string)mutex_path, 515 &state->lock_data.mutex.aml); 516 if (ACPI_FAILURE(status)) { 517 dev_err(dev, 518 "Failed to get hardware access guard AML mutex '%s': error %d", 519 mutex_path, status); 520 return -ENOENT; 521 } 522 state->lock_data.lock = lock_via_acpi_mutex; 523 state->lock_data.unlock = unlock_acpi_mutex; 524 } 525 return 0; 526 } 527 528 static int asus_ec_bank_switch(u8 bank, u8 *old) 529 { 530 int status = 0; 531 532 if (old) { 533 status = ec_read(ASUS_EC_BANK_REGISTER, old); 534 } 535 if (status || (old && (*old == bank))) 536 return status; 537 return ec_write(ASUS_EC_BANK_REGISTER, bank); 538 } 539 540 static int asus_ec_block_read(const struct device *dev, 541 struct ec_sensors_data *ec) 542 { 543 int ireg, ibank, status; 544 u8 bank, reg_bank, prev_bank; 545 546 bank = 0; 547 status = asus_ec_bank_switch(bank, &prev_bank); 548 if (status) { 549 dev_warn(dev, "EC bank switch failed"); 550 return status; 551 } 552 553 if (prev_bank) { 554 /* oops... somebody else is working with the EC too */ 555 dev_warn(dev, 556 "Concurrent access to the ACPI EC detected.\nRace condition possible."); 557 } 558 559 /* read registers minimizing bank switches. */ 560 for (ibank = 0; ibank < ec->nr_banks; ibank++) { 561 if (bank != ec->banks[ibank]) { 562 bank = ec->banks[ibank]; 563 if (asus_ec_bank_switch(bank, NULL)) { 564 dev_warn(dev, "EC bank switch to %d failed", 565 bank); 566 break; 567 } 568 } 569 for (ireg = 0; ireg < ec->nr_registers; ireg++) { 570 reg_bank = register_bank(ec->registers[ireg]); 571 if (reg_bank < bank) { 572 continue; 573 } 574 ec_read(register_index(ec->registers[ireg]), 575 ec->read_buffer + ireg); 576 } 577 } 578 579 status = asus_ec_bank_switch(prev_bank, NULL); 580 return status; 581 } 582 583 static inline s32 get_sensor_value(const struct ec_sensor_info *si, u8 *data) 584 { 585 if (is_sensor_data_signed(si)) { 586 switch (si->addr.components.size) { 587 case 1: 588 return (s8)*data; 589 case 2: 590 return (s16)get_unaligned_be16(data); 591 case 4: 592 return (s32)get_unaligned_be32(data); 593 default: 594 return 0; 595 } 596 } else { 597 switch (si->addr.components.size) { 598 case 1: 599 return *data; 600 case 2: 601 return get_unaligned_be16(data); 602 case 4: 603 return get_unaligned_be32(data); 604 default: 605 return 0; 606 } 607 } 608 } 609 610 static void update_sensor_values(struct ec_sensors_data *ec, u8 *data) 611 { 612 const struct ec_sensor_info *si; 613 struct ec_sensor *s, *sensor_end; 614 615 sensor_end = ec->sensors + ec->nr_sensors; 616 for (s = ec->sensors; s != sensor_end; s++) { 617 si = ec->sensors_info + s->info_index; 618 s->cached_value = get_sensor_value(si, data); 619 data += si->addr.components.size; 620 } 621 } 622 623 static int update_ec_sensors(const struct device *dev, 624 struct ec_sensors_data *ec) 625 { 626 int status; 627 628 if (!ec->lock_data.lock(&ec->lock_data)) { 629 dev_warn(dev, "Failed to acquire mutex"); 630 return -EBUSY; 631 } 632 633 status = asus_ec_block_read(dev, ec); 634 635 if (!status) { 636 update_sensor_values(ec, ec->read_buffer); 637 } 638 639 if (!ec->lock_data.unlock(&ec->lock_data)) 640 dev_err(dev, "Failed to release mutex"); 641 642 return status; 643 } 644 645 static long scale_sensor_value(s32 value, int data_type) 646 { 647 switch (data_type) { 648 case hwmon_curr: 649 case hwmon_temp: 650 return value * MILLI; 651 default: 652 return value; 653 } 654 } 655 656 static int get_cached_value_or_update(const struct device *dev, 657 int sensor_index, 658 struct ec_sensors_data *state, s32 *value) 659 { 660 if (time_after(jiffies, state->last_updated + HZ)) { 661 if (update_ec_sensors(dev, state)) { 662 dev_err(dev, "update_ec_sensors() failure\n"); 663 return -EIO; 664 } 665 666 state->last_updated = jiffies; 667 } 668 669 *value = state->sensors[sensor_index].cached_value; 670 return 0; 671 } 672 673 /* 674 * Now follow the functions that implement the hwmon interface 675 */ 676 677 static int asus_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type, 678 u32 attr, int channel, long *val) 679 { 680 int ret; 681 s32 value = 0; 682 683 struct ec_sensors_data *state = dev_get_drvdata(dev); 684 int sidx = find_ec_sensor_index(state, type, channel); 685 686 if (sidx < 0) { 687 return sidx; 688 } 689 690 ret = get_cached_value_or_update(dev, sidx, state, &value); 691 if (!ret) { 692 *val = scale_sensor_value(value, 693 get_sensor_info(state, sidx)->type); 694 } 695 696 return ret; 697 } 698 699 static int asus_ec_hwmon_read_string(struct device *dev, 700 enum hwmon_sensor_types type, u32 attr, 701 int channel, const char **str) 702 { 703 struct ec_sensors_data *state = dev_get_drvdata(dev); 704 int sensor_index = find_ec_sensor_index(state, type, channel); 705 *str = get_sensor_info(state, sensor_index)->label; 706 707 return 0; 708 } 709 710 static umode_t asus_ec_hwmon_is_visible(const void *drvdata, 711 enum hwmon_sensor_types type, u32 attr, 712 int channel) 713 { 714 const struct ec_sensors_data *state = drvdata; 715 716 return find_ec_sensor_index(state, type, channel) >= 0 ? S_IRUGO : 0; 717 } 718 719 static int __init 720 asus_ec_hwmon_add_chan_info(struct hwmon_channel_info *asus_ec_hwmon_chan, 721 struct device *dev, int num, 722 enum hwmon_sensor_types type, u32 config) 723 { 724 int i; 725 u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL); 726 727 if (!cfg) 728 return -ENOMEM; 729 730 asus_ec_hwmon_chan->type = type; 731 asus_ec_hwmon_chan->config = cfg; 732 for (i = 0; i < num; i++, cfg++) 733 *cfg = config; 734 735 return 0; 736 } 737 738 static const struct hwmon_ops asus_ec_hwmon_ops = { 739 .is_visible = asus_ec_hwmon_is_visible, 740 .read = asus_ec_hwmon_read, 741 .read_string = asus_ec_hwmon_read_string, 742 }; 743 744 static struct hwmon_chip_info asus_ec_chip_info = { 745 .ops = &asus_ec_hwmon_ops, 746 }; 747 748 static const struct ec_board_info * __init get_board_info(void) 749 { 750 const char *dmi_board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR); 751 const char *dmi_board_name = dmi_get_system_info(DMI_BOARD_NAME); 752 const struct ec_board_info *board; 753 754 if (!dmi_board_vendor || !dmi_board_name || 755 strcasecmp(dmi_board_vendor, "ASUSTeK COMPUTER INC.")) 756 return NULL; 757 758 for (board = board_info; board->sensors; board++) { 759 if (match_string(board->board_names, 760 MAX_IDENTICAL_BOARD_VARIATIONS, 761 dmi_board_name) >= 0) 762 return board; 763 } 764 765 return NULL; 766 } 767 768 static int __init asus_ec_probe(struct platform_device *pdev) 769 { 770 const struct hwmon_channel_info **ptr_asus_ec_ci; 771 int nr_count[hwmon_max] = { 0 }, nr_types = 0; 772 struct hwmon_channel_info *asus_ec_hwmon_chan; 773 const struct ec_board_info *pboard_info; 774 const struct hwmon_chip_info *chip_info; 775 struct device *dev = &pdev->dev; 776 struct ec_sensors_data *ec_data; 777 const struct ec_sensor_info *si; 778 enum hwmon_sensor_types type; 779 struct device *hwdev; 780 unsigned int i; 781 int status; 782 783 pboard_info = get_board_info(); 784 if (!pboard_info) 785 return -ENODEV; 786 787 ec_data = devm_kzalloc(dev, sizeof(struct ec_sensors_data), 788 GFP_KERNEL); 789 if (!ec_data) 790 return -ENOMEM; 791 792 dev_set_drvdata(dev, ec_data); 793 ec_data->board_info = pboard_info; 794 795 switch (ec_data->board_info->family) { 796 case family_amd_400_series: 797 ec_data->sensors_info = sensors_family_amd_400; 798 break; 799 case family_amd_500_series: 800 ec_data->sensors_info = sensors_family_amd_500; 801 break; 802 default: 803 dev_err(dev, "Unknown board family: %d", 804 ec_data->board_info->family); 805 return -EINVAL; 806 } 807 808 ec_data->nr_sensors = hweight_long(ec_data->board_info->sensors); 809 ec_data->sensors = devm_kcalloc(dev, ec_data->nr_sensors, 810 sizeof(struct ec_sensor), GFP_KERNEL); 811 812 status = setup_lock_data(dev); 813 if (status) { 814 dev_err(dev, "Failed to setup state/EC locking: %d", status); 815 return status; 816 } 817 818 setup_sensor_data(ec_data); 819 ec_data->registers = devm_kcalloc(dev, ec_data->nr_registers, 820 sizeof(u16), GFP_KERNEL); 821 ec_data->read_buffer = devm_kcalloc(dev, ec_data->nr_registers, 822 sizeof(u8), GFP_KERNEL); 823 824 if (!ec_data->registers || !ec_data->read_buffer) 825 return -ENOMEM; 826 827 fill_ec_registers(ec_data); 828 829 for (i = 0; i < ec_data->nr_sensors; ++i) { 830 si = get_sensor_info(ec_data, i); 831 if (!nr_count[si->type]) 832 ++nr_types; 833 ++nr_count[si->type]; 834 } 835 836 if (nr_count[hwmon_temp]) 837 nr_count[hwmon_chip]++, nr_types++; 838 839 asus_ec_hwmon_chan = devm_kcalloc( 840 dev, nr_types, sizeof(*asus_ec_hwmon_chan), GFP_KERNEL); 841 if (!asus_ec_hwmon_chan) 842 return -ENOMEM; 843 844 ptr_asus_ec_ci = devm_kcalloc(dev, nr_types + 1, 845 sizeof(*ptr_asus_ec_ci), GFP_KERNEL); 846 if (!ptr_asus_ec_ci) 847 return -ENOMEM; 848 849 asus_ec_chip_info.info = ptr_asus_ec_ci; 850 chip_info = &asus_ec_chip_info; 851 852 for (type = 0; type < hwmon_max; ++type) { 853 if (!nr_count[type]) 854 continue; 855 856 asus_ec_hwmon_add_chan_info(asus_ec_hwmon_chan, dev, 857 nr_count[type], type, 858 hwmon_attributes[type]); 859 *ptr_asus_ec_ci++ = asus_ec_hwmon_chan++; 860 } 861 862 dev_info(dev, "board has %d EC sensors that span %d registers", 863 ec_data->nr_sensors, ec_data->nr_registers); 864 865 hwdev = devm_hwmon_device_register_with_info(dev, "asusec", 866 ec_data, chip_info, NULL); 867 868 return PTR_ERR_OR_ZERO(hwdev); 869 } 870 871 872 static const struct acpi_device_id acpi_ec_ids[] = { 873 /* Embedded Controller Device */ 874 { "PNP0C09", 0 }, 875 {} 876 }; 877 878 static struct platform_driver asus_ec_sensors_platform_driver = { 879 .driver = { 880 .name = "asus-ec-sensors", 881 .acpi_match_table = acpi_ec_ids, 882 }, 883 }; 884 885 MODULE_DEVICE_TABLE(acpi, acpi_ec_ids); 886 /* 887 * we use module_platform_driver_probe() rather than module_platform_driver() 888 * because the probe function (and its dependants) are marked with __init, which 889 * means we can't put it into the .probe member of the platform_driver struct 890 * above, and we can't mark the asus_ec_sensors_platform_driver object as __init 891 * because the object is referenced from the module exit code. 892 */ 893 module_platform_driver_probe(asus_ec_sensors_platform_driver, asus_ec_probe); 894 895 module_param_named(mutex_path, mutex_path_override, charp, 0); 896 MODULE_PARM_DESC(mutex_path, 897 "Override ACPI mutex path used to guard access to hardware"); 898 899 MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>"); 900 MODULE_DESCRIPTION( 901 "HWMON driver for sensors accessible via ACPI EC in ASUS motherboards"); 902 MODULE_LICENSE("GPL"); 903