FILE
asus_atk0110.c
File preview with syntax highlighting.
linux-6.19.14/drivers/hwmon/asus_atk0110.c
1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) 2007-2009 Luca Tettamanti <kronos.it@gmail.com> 4 * 5 * See COPYING in the top level directory of the kernel tree. 6 */ 7 8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10#include <linux/debugfs.h> 11#include <linux/kernel.h> 12#include <linux/hwmon.h> 13#include <linux/list.h> 14#include <linux/module.h> 15#include <linux/slab.h> 16#include <linux/dmi.h> 17#include <linux/jiffies.h> 18#include <linux/err.h> 19#include <linux/acpi.h> 20#include <linux/string_choices.h> 21 22#define ATK_HID "ATK0110" 23 24static bool new_if; 25module_param(new_if, bool, 0); 26MODULE_PARM_DESC(new_if, "Override detection heuristic and force the use of the new ATK0110 interface"); 27 28static const struct dmi_system_id __initconst atk_force_new_if[] = { 29 { 30 /* Old interface has broken MCH temp monitoring */ 31 .ident = "Asus Sabertooth X58", 32 .matches = { 33 DMI_MATCH(DMI_BOARD_NAME, "SABERTOOTH X58") 34 } 35 }, { 36 /* Old interface reads the same sensor for fan0 and fan1 */ 37 .ident = "Asus M5A78L", 38 .matches = { 39 DMI_MATCH(DMI_BOARD_NAME, "M5A78L") 40 } 41 }, 42 { } 43}; 44 45/* 46 * Minimum time between readings, enforced in order to avoid 47 * hogging the CPU. 48 */ 49#define CACHE_TIME HZ 50 51#define BOARD_ID "MBIF" 52#define METHOD_ENUMERATE "GGRP" 53#define METHOD_READ "GITM" 54#define METHOD_WRITE "SITM" 55#define METHOD_OLD_READ_TMP "RTMP" 56#define METHOD_OLD_READ_VLT "RVLT" 57#define METHOD_OLD_READ_FAN "RFAN" 58#define METHOD_OLD_ENUM_TMP "TSIF" 59#define METHOD_OLD_ENUM_VLT "VSIF" 60#define METHOD_OLD_ENUM_FAN "FSIF" 61 62#define ATK_MUX_HWMON 0x00000006ULL 63#define ATK_MUX_MGMT 0x00000011ULL 64 65#define ATK_CLASS_MASK 0xff000000ULL 66#define ATK_CLASS_FREQ_CTL 0x03000000ULL 67#define ATK_CLASS_FAN_CTL 0x04000000ULL 68#define ATK_CLASS_HWMON 0x06000000ULL 69#define ATK_CLASS_MGMT 0x11000000ULL 70 71#define ATK_TYPE_MASK 0x00ff0000ULL 72#define HWMON_TYPE_VOLT 0x00020000ULL 73#define HWMON_TYPE_TEMP 0x00030000ULL 74#define HWMON_TYPE_FAN 0x00040000ULL 75 76#define ATK_ELEMENT_ID_MASK 0x0000ffffULL 77 78#define ATK_EC_ID 0x11060004ULL 79 80enum atk_pack_member { 81 HWMON_PACK_FLAGS, 82 HWMON_PACK_NAME, 83 HWMON_PACK_LIMIT1, 84 HWMON_PACK_LIMIT2, 85 HWMON_PACK_ENABLE 86}; 87 88/* New package format */ 89#define _HWMON_NEW_PACK_SIZE 7 90#define _HWMON_NEW_PACK_FLAGS 0 91#define _HWMON_NEW_PACK_NAME 1 92#define _HWMON_NEW_PACK_UNK1 2 93#define _HWMON_NEW_PACK_UNK2 3 94#define _HWMON_NEW_PACK_LIMIT1 4 95#define _HWMON_NEW_PACK_LIMIT2 5 96#define _HWMON_NEW_PACK_ENABLE 6 97 98/* Old package format */ 99#define _HWMON_OLD_PACK_SIZE 5 100#define _HWMON_OLD_PACK_FLAGS 0 101#define _HWMON_OLD_PACK_NAME 1 102#define _HWMON_OLD_PACK_LIMIT1 2 103#define _HWMON_OLD_PACK_LIMIT2 3 104#define _HWMON_OLD_PACK_ENABLE 4 105 106 107struct atk_data { 108 struct device *hwmon_dev; 109 acpi_handle atk_handle; 110 struct acpi_device *acpi_dev; 111 112 bool old_interface; 113 114 /* old interface */ 115 acpi_handle rtmp_handle; 116 acpi_handle rvlt_handle; 117 acpi_handle rfan_handle; 118 /* new interface */ 119 acpi_handle enumerate_handle; 120 acpi_handle read_handle; 121 acpi_handle write_handle; 122 123 bool disable_ec; 124 125 int voltage_count; 126 int temperature_count; 127 int fan_count; 128 struct list_head sensor_list; 129 struct attribute_group attr_group; 130 const struct attribute_group *attr_groups[2]; 131 132 struct { 133 struct dentry *root; 134 u32 id; 135 } debugfs; 136}; 137 138 139typedef ssize_t (*sysfs_show_func)(struct device *dev, 140 struct device_attribute *attr, char *buf); 141 142static const struct acpi_device_id atk_ids[] = { 143 {ATK_HID, 0}, 144 {"", 0}, 145}; 146MODULE_DEVICE_TABLE(acpi, atk_ids); 147 148#define ATTR_NAME_SIZE 16 /* Worst case is "tempN_input" */ 149 150struct atk_sensor_data { 151 struct list_head list; 152 struct atk_data *data; 153 struct device_attribute label_attr; 154 struct device_attribute input_attr; 155 struct device_attribute limit1_attr; 156 struct device_attribute limit2_attr; 157 char label_attr_name[ATTR_NAME_SIZE]; 158 char input_attr_name[ATTR_NAME_SIZE]; 159 char limit1_attr_name[ATTR_NAME_SIZE]; 160 char limit2_attr_name[ATTR_NAME_SIZE]; 161 u64 id; 162 u64 type; 163 u64 limit1; 164 u64 limit2; 165 u64 cached_value; 166 unsigned long last_updated; /* in jiffies */ 167 bool is_valid; 168 char const *acpi_name; 169}; 170 171/* 172 * Return buffer format: 173 * [0-3] "value" is valid flag 174 * [4-7] value 175 * [8- ] unknown stuff on newer mobos 176 */ 177struct atk_acpi_ret_buffer { 178 u32 flags; 179 u32 value; 180 u8 data[]; 181}; 182 183/* Input buffer used for GITM and SITM methods */ 184struct atk_acpi_input_buf { 185 u32 id; 186 u32 param1; 187 u32 param2; 188}; 189 190static int atk_add(struct acpi_device *device); 191static void atk_remove(struct acpi_device *device); 192static void atk_print_sensor(struct atk_data *data, union acpi_object *obj); 193static int atk_read_value(struct atk_sensor_data *sensor, u64 *value); 194 195static struct acpi_driver atk_driver = { 196 .name = ATK_HID, 197 .class = "hwmon", 198 .ids = atk_ids, 199 .ops = { 200 .add = atk_add, 201 .remove = atk_remove, 202 }, 203}; 204 205#define input_to_atk_sensor(attr) \ 206 container_of(attr, struct atk_sensor_data, input_attr) 207 208#define label_to_atk_sensor(attr) \ 209 container_of(attr, struct atk_sensor_data, label_attr) 210 211#define limit1_to_atk_sensor(attr) \ 212 container_of(attr, struct atk_sensor_data, limit1_attr) 213 214#define limit2_to_atk_sensor(attr) \ 215 container_of(attr, struct atk_sensor_data, limit2_attr) 216 217static ssize_t atk_input_show(struct device *dev, 218 struct device_attribute *attr, char *buf) 219{ 220 struct atk_sensor_data *s = input_to_atk_sensor(attr); 221 u64 value; 222 int err; 223 224 err = atk_read_value(s, &value); 225 if (err) 226 return err; 227 228 if (s->type == HWMON_TYPE_TEMP) 229 /* ACPI returns decidegree */ 230 value *= 100; 231 232 return sprintf(buf, "%llu\n", value); 233} 234 235static ssize_t atk_label_show(struct device *dev, 236 struct device_attribute *attr, char *buf) 237{ 238 struct atk_sensor_data *s = label_to_atk_sensor(attr); 239 240 return sprintf(buf, "%s\n", s->acpi_name); 241} 242 243static ssize_t atk_limit1_show(struct device *dev, 244 struct device_attribute *attr, char *buf) 245{ 246 struct atk_sensor_data *s = limit1_to_atk_sensor(attr); 247 u64 value = s->limit1; 248 249 if (s->type == HWMON_TYPE_TEMP) 250 value *= 100; 251 252 return sprintf(buf, "%lld\n", value); 253} 254 255static ssize_t atk_limit2_show(struct device *dev, 256 struct device_attribute *attr, char *buf) 257{ 258 struct atk_sensor_data *s = limit2_to_atk_sensor(attr); 259 u64 value = s->limit2; 260 261 if (s->type == HWMON_TYPE_TEMP) 262 value *= 100; 263 264 return sprintf(buf, "%lld\n", value); 265} 266 267static void atk_init_attribute(struct device_attribute *attr, char *name, 268 sysfs_show_func show) 269{ 270 sysfs_attr_init(&attr->attr); 271 attr->attr.name = name; 272 attr->attr.mode = 0444; 273 attr->show = show; 274 attr->store = NULL; 275} 276 277 278static union acpi_object *atk_get_pack_member(struct atk_data *data, 279 union acpi_object *pack, 280 enum atk_pack_member m) 281{ 282 bool old_if = data->old_interface; 283 int offset; 284 285 switch (m) { 286 case HWMON_PACK_FLAGS: 287 offset = old_if ? _HWMON_OLD_PACK_FLAGS : _HWMON_NEW_PACK_FLAGS; 288 break; 289 case HWMON_PACK_NAME: 290 offset = old_if ? _HWMON_OLD_PACK_NAME : _HWMON_NEW_PACK_NAME; 291 break; 292 case HWMON_PACK_LIMIT1: 293 offset = old_if ? _HWMON_OLD_PACK_LIMIT1 : 294 _HWMON_NEW_PACK_LIMIT1; 295 break; 296 case HWMON_PACK_LIMIT2: 297 offset = old_if ? _HWMON_OLD_PACK_LIMIT2 : 298 _HWMON_NEW_PACK_LIMIT2; 299 break; 300 case HWMON_PACK_ENABLE: 301 offset = old_if ? _HWMON_OLD_PACK_ENABLE : 302 _HWMON_NEW_PACK_ENABLE; 303 break; 304 default: 305 return NULL; 306 } 307 308 return &pack->package.elements[offset]; 309} 310 311 312/* 313 * New package format is: 314 * - flag (int) 315 * class - used for de-muxing the request to the correct GITn 316 * type (volt, temp, fan) 317 * sensor id | 318 * sensor id - used for de-muxing the request _inside_ the GITn 319 * - name (str) 320 * - unknown (int) 321 * - unknown (int) 322 * - limit1 (int) 323 * - limit2 (int) 324 * - enable (int) 325 * 326 * The old package has the same format but it's missing the two unknown fields. 327 */ 328static int validate_hwmon_pack(struct atk_data *data, union acpi_object *obj) 329{ 330 struct device *dev = &data->acpi_dev->dev; 331 union acpi_object *tmp; 332 bool old_if = data->old_interface; 333 int const expected_size = old_if ? _HWMON_OLD_PACK_SIZE : 334 _HWMON_NEW_PACK_SIZE; 335 336 if (obj->type != ACPI_TYPE_PACKAGE) { 337 dev_warn(dev, "Invalid type: %d\n", obj->type); 338 return -EINVAL; 339 } 340 341 if (obj->package.count != expected_size) { 342 dev_warn(dev, "Invalid package size: %d, expected: %d\n", 343 obj->package.count, expected_size); 344 return -EINVAL; 345 } 346 347 tmp = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS); 348 if (tmp->type != ACPI_TYPE_INTEGER) { 349 dev_warn(dev, "Invalid type (flag): %d\n", tmp->type); 350 return -EINVAL; 351 } 352 353 tmp = atk_get_pack_member(data, obj, HWMON_PACK_NAME); 354 if (tmp->type != ACPI_TYPE_STRING) { 355 dev_warn(dev, "Invalid type (name): %d\n", tmp->type); 356 return -EINVAL; 357 } 358 359 /* Don't check... we don't know what they're useful for anyway */ 360#if 0 361 tmp = &obj->package.elements[HWMON_PACK_UNK1]; 362 if (tmp->type != ACPI_TYPE_INTEGER) { 363 dev_warn(dev, "Invalid type (unk1): %d\n", tmp->type); 364 return -EINVAL; 365 } 366 367 tmp = &obj->package.elements[HWMON_PACK_UNK2]; 368 if (tmp->type != ACPI_TYPE_INTEGER) { 369 dev_warn(dev, "Invalid type (unk2): %d\n", tmp->type); 370 return -EINVAL; 371 } 372#endif 373 374 tmp = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1); 375 if (tmp->type != ACPI_TYPE_INTEGER) { 376 dev_warn(dev, "Invalid type (limit1): %d\n", tmp->type); 377 return -EINVAL; 378 } 379 380 tmp = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2); 381 if (tmp->type != ACPI_TYPE_INTEGER) { 382 dev_warn(dev, "Invalid type (limit2): %d\n", tmp->type); 383 return -EINVAL; 384 } 385 386 tmp = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE); 387 if (tmp->type != ACPI_TYPE_INTEGER) { 388 dev_warn(dev, "Invalid type (enable): %d\n", tmp->type); 389 return -EINVAL; 390 } 391 392 atk_print_sensor(data, obj); 393 394 return 0; 395} 396 397#ifdef DEBUG 398static char const *atk_sensor_type(union acpi_object *flags) 399{ 400 u64 type = flags->integer.value & ATK_TYPE_MASK; 401 char const *what; 402 403 switch (type) { 404 case HWMON_TYPE_VOLT: 405 what = "voltage"; 406 break; 407 case HWMON_TYPE_TEMP: 408 what = "temperature"; 409 break; 410 case HWMON_TYPE_FAN: 411 what = "fan"; 412 break; 413 default: 414 what = "unknown"; 415 break; 416 } 417 418 return what; 419} 420#endif 421 422static void atk_print_sensor(struct atk_data *data, union acpi_object *obj) 423{ 424#ifdef DEBUG 425 struct device *dev = &data->acpi_dev->dev; 426 union acpi_object *flags; 427 union acpi_object *name; 428 union acpi_object *limit1; 429 union acpi_object *limit2; 430 union acpi_object *enable; 431 char const *what; 432 433 flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS); 434 name = atk_get_pack_member(data, obj, HWMON_PACK_NAME); 435 limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1); 436 limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2); 437 enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE); 438 439 what = atk_sensor_type(flags); 440 441 dev_dbg(dev, "%s: %#llx %s [%llu-%llu] %s\n", what, 442 flags->integer.value, 443 name->string.pointer, 444 limit1->integer.value, limit2->integer.value, 445 str_enabled_disabled(enable->integer.value)); 446#endif 447} 448 449static int atk_read_value_old(struct atk_sensor_data *sensor, u64 *value) 450{ 451 struct atk_data *data = sensor->data; 452 struct device *dev = &data->acpi_dev->dev; 453 struct acpi_object_list params; 454 union acpi_object id; 455 acpi_status status; 456 acpi_handle method; 457 458 switch (sensor->type) { 459 case HWMON_TYPE_VOLT: 460 method = data->rvlt_handle; 461 break; 462 case HWMON_TYPE_TEMP: 463 method = data->rtmp_handle; 464 break; 465 case HWMON_TYPE_FAN: 466 method = data->rfan_handle; 467 break; 468 default: 469 return -EINVAL; 470 } 471 472 id.type = ACPI_TYPE_INTEGER; 473 id.integer.value = sensor->id; 474 475 params.count = 1; 476 params.pointer = &id; 477 478 status = acpi_evaluate_integer(method, NULL, ¶ms, value); 479 if (status != AE_OK) { 480 dev_warn(dev, "%s: ACPI exception: %s\n", __func__, 481 acpi_format_exception(status)); 482 return -EIO; 483 } 484 485 return 0; 486} 487 488static union acpi_object *atk_ggrp(struct atk_data *data, u16 mux) 489{ 490 struct device *dev = &data->acpi_dev->dev; 491 struct acpi_buffer buf; 492 acpi_status ret; 493 struct acpi_object_list params; 494 union acpi_object id; 495 union acpi_object *pack; 496 497 id.type = ACPI_TYPE_INTEGER; 498 id.integer.value = mux; 499 params.count = 1; 500 params.pointer = &id; 501 502 buf.length = ACPI_ALLOCATE_BUFFER; 503 ret = acpi_evaluate_object(data->enumerate_handle, NULL, ¶ms, &buf); 504 if (ret != AE_OK) { 505 dev_err(dev, "GGRP[%#x] ACPI exception: %s\n", mux, 506 acpi_format_exception(ret)); 507 return ERR_PTR(-EIO); 508 } 509 pack = buf.pointer; 510 if (pack->type != ACPI_TYPE_PACKAGE) { 511 /* Execution was successful, but the id was not found */ 512 ACPI_FREE(pack); 513 return ERR_PTR(-ENOENT); 514 } 515 516 if (pack->package.count < 1) { 517 dev_err(dev, "GGRP[%#x] package is too small\n", mux); 518 ACPI_FREE(pack); 519 return ERR_PTR(-EIO); 520 } 521 return pack; 522} 523 524static union acpi_object *atk_gitm(struct atk_data *data, u64 id) 525{ 526 struct device *dev = &data->acpi_dev->dev; 527 struct atk_acpi_input_buf buf; 528 union acpi_object tmp; 529 struct acpi_object_list params; 530 struct acpi_buffer ret; 531 union acpi_object *obj; 532 acpi_status status; 533 534 buf.id = id; 535 buf.param1 = 0; 536 buf.param2 = 0; 537 538 tmp.type = ACPI_TYPE_BUFFER; 539 tmp.buffer.pointer = (u8 *)&buf; 540 tmp.buffer.length = sizeof(buf); 541 542 params.count = 1; 543 params.pointer = (void *)&tmp; 544 545 ret.length = ACPI_ALLOCATE_BUFFER; 546 status = acpi_evaluate_object_typed(data->read_handle, NULL, ¶ms, 547 &ret, ACPI_TYPE_BUFFER); 548 if (status != AE_OK) { 549 dev_warn(dev, "GITM[%#llx] ACPI exception: %s\n", id, 550 acpi_format_exception(status)); 551 return ERR_PTR(-EIO); 552 } 553 obj = ret.pointer; 554 555 /* Sanity check */ 556 if (obj->buffer.length < 8) { 557 dev_warn(dev, "Unexpected ASBF length: %u\n", 558 obj->buffer.length); 559 ACPI_FREE(obj); 560 return ERR_PTR(-EIO); 561 } 562 return obj; 563} 564 565static union acpi_object *atk_sitm(struct atk_data *data, 566 struct atk_acpi_input_buf *buf) 567{ 568 struct device *dev = &data->acpi_dev->dev; 569 struct acpi_object_list params; 570 union acpi_object tmp; 571 struct acpi_buffer ret; 572 union acpi_object *obj; 573 acpi_status status; 574 575 tmp.type = ACPI_TYPE_BUFFER; 576 tmp.buffer.pointer = (u8 *)buf; 577 tmp.buffer.length = sizeof(*buf); 578 579 params.count = 1; 580 params.pointer = &tmp; 581 582 ret.length = ACPI_ALLOCATE_BUFFER; 583 status = acpi_evaluate_object_typed(data->write_handle, NULL, ¶ms, 584 &ret, ACPI_TYPE_BUFFER); 585 if (status != AE_OK) { 586 dev_warn(dev, "SITM[%#x] ACPI exception: %s\n", buf->id, 587 acpi_format_exception(status)); 588 return ERR_PTR(-EIO); 589 } 590 obj = ret.pointer; 591 592 /* Sanity check */ 593 if (obj->buffer.length < 8) { 594 dev_warn(dev, "Unexpected ASBF length: %u\n", 595 obj->buffer.length); 596 ACPI_FREE(obj); 597 return ERR_PTR(-EIO); 598 } 599 return obj; 600} 601 602static int atk_read_value_new(struct atk_sensor_data *sensor, u64 *value) 603{ 604 struct atk_data *data = sensor->data; 605 struct device *dev = &data->acpi_dev->dev; 606 union acpi_object *obj; 607 struct atk_acpi_ret_buffer *buf; 608 int err = 0; 609 610 obj = atk_gitm(data, sensor->id); 611 if (IS_ERR(obj)) 612 return PTR_ERR(obj); 613 614 buf = (struct atk_acpi_ret_buffer *)obj->buffer.pointer; 615 if (buf->flags == 0) { 616 /* 617 * The reading is not valid, possible causes: 618 * - sensor failure 619 * - enumeration was FUBAR (and we didn't notice) 620 */ 621 dev_warn(dev, "Read failed, sensor = %#llx\n", sensor->id); 622 err = -EIO; 623 goto out; 624 } 625 626 *value = buf->value; 627out: 628 ACPI_FREE(obj); 629 return err; 630} 631 632static int atk_read_value(struct atk_sensor_data *sensor, u64 *value) 633{ 634 int err; 635 636 if (!sensor->is_valid || 637 time_after(jiffies, sensor->last_updated + CACHE_TIME)) { 638 if (sensor->data->old_interface) 639 err = atk_read_value_old(sensor, value); 640 else 641 err = atk_read_value_new(sensor, value); 642 643 if (err) 644 return err; 645 646 sensor->is_valid = true; 647 sensor->last_updated = jiffies; 648 sensor->cached_value = *value; 649 } else { 650 *value = sensor->cached_value; 651 err = 0; 652 } 653 654 return err; 655} 656 657#ifdef CONFIG_DEBUG_FS 658static int atk_debugfs_gitm_get(void *p, u64 *val) 659{ 660 struct atk_data *data = p; 661 union acpi_object *ret; 662 struct atk_acpi_ret_buffer *buf; 663 int err = 0; 664 665 if (!data->read_handle) 666 return -ENODEV; 667 668 if (!data->debugfs.id) 669 return -EINVAL; 670 671 ret = atk_gitm(data, data->debugfs.id); 672 if (IS_ERR(ret)) 673 return PTR_ERR(ret); 674 675 buf = (struct atk_acpi_ret_buffer *)ret->buffer.pointer; 676 if (buf->flags) 677 *val = buf->value; 678 else 679 err = -EIO; 680 681 ACPI_FREE(ret); 682 return err; 683} 684 685DEFINE_DEBUGFS_ATTRIBUTE(atk_debugfs_gitm, atk_debugfs_gitm_get, NULL, 686 "0x%08llx\n"); 687 688static int atk_acpi_print(char *buf, size_t sz, union acpi_object *obj) 689{ 690 int ret = 0; 691 692 switch (obj->type) { 693 case ACPI_TYPE_INTEGER: 694 ret = snprintf(buf, sz, "0x%08llx\n", obj->integer.value); 695 break; 696 case ACPI_TYPE_STRING: 697 ret = snprintf(buf, sz, "%s\n", obj->string.pointer); 698 break; 699 } 700 701 return ret; 702} 703 704static void atk_pack_print(char *buf, size_t sz, union acpi_object *pack) 705{ 706 int ret; 707 int i; 708 709 for (i = 0; i < pack->package.count; i++) { 710 union acpi_object *obj = &pack->package.elements[i]; 711 712 ret = atk_acpi_print(buf, sz, obj); 713 if (ret >= sz) 714 break; 715 buf += ret; 716 sz -= ret; 717 } 718} 719 720static int atk_debugfs_ggrp_open(struct inode *inode, struct file *file) 721{ 722 struct atk_data *data = inode->i_private; 723 char *buf = NULL; 724 union acpi_object *ret; 725 u8 cls; 726 int i; 727 728 if (!data->enumerate_handle) 729 return -ENODEV; 730 if (!data->debugfs.id) 731 return -EINVAL; 732 733 cls = (data->debugfs.id & 0xff000000) >> 24; 734 ret = atk_ggrp(data, cls); 735 if (IS_ERR(ret)) 736 return PTR_ERR(ret); 737 738 for (i = 0; i < ret->package.count; i++) { 739 union acpi_object *pack = &ret->package.elements[i]; 740 union acpi_object *id; 741 742 if (pack->type != ACPI_TYPE_PACKAGE) 743 continue; 744 if (!pack->package.count) 745 continue; 746 id = &pack->package.elements[0]; 747 if (id->integer.value == data->debugfs.id) { 748 /* Print the package */ 749 buf = kzalloc(512, GFP_KERNEL); 750 if (!buf) { 751 ACPI_FREE(ret); 752 return -ENOMEM; 753 } 754 atk_pack_print(buf, 512, pack); 755 break; 756 } 757 } 758 ACPI_FREE(ret); 759 760 if (!buf) 761 return -EINVAL; 762 763 file->private_data = buf; 764 765 return nonseekable_open(inode, file); 766} 767 768static ssize_t atk_debugfs_ggrp_read(struct file *file, char __user *buf, 769 size_t count, loff_t *pos) 770{ 771 char *str = file->private_data; 772 size_t len = strlen(str); 773 774 return simple_read_from_buffer(buf, count, pos, str, len); 775} 776 777static int atk_debugfs_ggrp_release(struct inode *inode, struct file *file) 778{ 779 kfree(file->private_data); 780 return 0; 781} 782 783static const struct file_operations atk_debugfs_ggrp_fops = { 784 .read = atk_debugfs_ggrp_read, 785 .open = atk_debugfs_ggrp_open, 786 .release = atk_debugfs_ggrp_release, 787}; 788 789static void atk_debugfs_init(struct atk_data *data) 790{ 791 struct dentry *d; 792 793 data->debugfs.id = 0; 794 795 d = debugfs_create_dir("asus_atk0110", NULL); 796 797 debugfs_create_x32("id", 0600, d, &data->debugfs.id); 798 debugfs_create_file_unsafe("gitm", 0400, d, data, &atk_debugfs_gitm); 799 debugfs_create_file("ggrp", 0400, d, data, &atk_debugfs_ggrp_fops); 800 801 data->debugfs.root = d; 802} 803 804static void atk_debugfs_cleanup(struct atk_data *data) 805{ 806 debugfs_remove_recursive(data->debugfs.root); 807} 808 809#else /* CONFIG_DEBUG_FS */ 810 811static void atk_debugfs_init(struct atk_data *data) 812{ 813} 814 815static void atk_debugfs_cleanup(struct atk_data *data) 816{ 817} 818#endif 819 820static int atk_add_sensor(struct atk_data *data, union acpi_object *obj) 821{ 822 struct device *dev = &data->acpi_dev->dev; 823 union acpi_object *flags; 824 union acpi_object *name; 825 union acpi_object *limit1; 826 union acpi_object *limit2; 827 union acpi_object *enable; 828 struct atk_sensor_data *sensor; 829 char const *base_name; 830 char const *limit1_name; 831 char const *limit2_name; 832 u64 type; 833 int err; 834 int *num; 835 int start; 836 837 if (obj->type != ACPI_TYPE_PACKAGE) { 838 /* wft is this? */ 839 dev_warn(dev, "Unknown type for ACPI object: (%d)\n", 840 obj->type); 841 return -EINVAL; 842 } 843 844 err = validate_hwmon_pack(data, obj); 845 if (err) 846 return err; 847 848 /* Ok, we have a valid hwmon package */ 849 type = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS)->integer.value 850 & ATK_TYPE_MASK; 851 852 switch (type) { 853 case HWMON_TYPE_VOLT: 854 base_name = "in"; 855 limit1_name = "min"; 856 limit2_name = "max"; 857 num = &data->voltage_count; 858 start = 0; 859 break; 860 case HWMON_TYPE_TEMP: 861 base_name = "temp"; 862 limit1_name = "max"; 863 limit2_name = "crit"; 864 num = &data->temperature_count; 865 start = 1; 866 break; 867 case HWMON_TYPE_FAN: 868 base_name = "fan"; 869 limit1_name = "min"; 870 limit2_name = "max"; 871 num = &data->fan_count; 872 start = 1; 873 break; 874 default: 875 dev_warn(dev, "Unknown sensor type: %#llx\n", type); 876 return -EINVAL; 877 } 878 879 enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE); 880 if (!enable->integer.value) 881 /* sensor is disabled */ 882 return 0; 883 884 flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS); 885 name = atk_get_pack_member(data, obj, HWMON_PACK_NAME); 886 limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1); 887 limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2); 888 889 sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL); 890 if (!sensor) 891 return -ENOMEM; 892 893 sensor->acpi_name = devm_kstrdup(dev, name->string.pointer, GFP_KERNEL); 894 if (!sensor->acpi_name) 895 return -ENOMEM; 896 897 INIT_LIST_HEAD(&sensor->list); 898 sensor->type = type; 899 sensor->data = data; 900 sensor->id = flags->integer.value; 901 sensor->limit1 = limit1->integer.value; 902 if (data->old_interface) 903 sensor->limit2 = limit2->integer.value; 904 else 905 /* The upper limit is expressed as delta from lower limit */ 906 sensor->limit2 = sensor->limit1 + limit2->integer.value; 907 908 snprintf(sensor->input_attr_name, ATTR_NAME_SIZE, 909 "%s%d_input", base_name, start + *num); 910 atk_init_attribute(&sensor->input_attr, 911 sensor->input_attr_name, 912 atk_input_show); 913 914 snprintf(sensor->label_attr_name, ATTR_NAME_SIZE, 915 "%s%d_label", base_name, start + *num); 916 atk_init_attribute(&sensor->label_attr, 917 sensor->label_attr_name, 918 atk_label_show); 919 920 snprintf(sensor->limit1_attr_name, ATTR_NAME_SIZE, 921 "%s%d_%s", base_name, start + *num, limit1_name); 922 atk_init_attribute(&sensor->limit1_attr, 923 sensor->limit1_attr_name, 924 atk_limit1_show); 925 926 snprintf(sensor->limit2_attr_name, ATTR_NAME_SIZE, 927 "%s%d_%s", base_name, start + *num, limit2_name); 928 atk_init_attribute(&sensor->limit2_attr, 929 sensor->limit2_attr_name, 930 atk_limit2_show); 931 932 list_add(&sensor->list, &data->sensor_list); 933 (*num)++; 934 935 return 1; 936} 937 938static int atk_enumerate_old_hwmon(struct atk_data *data) 939{ 940 struct device *dev = &data->acpi_dev->dev; 941 struct acpi_buffer buf; 942 union acpi_object *pack; 943 acpi_status status; 944 int i, ret; 945 int count = 0; 946 947 /* Voltages */ 948 buf.length = ACPI_ALLOCATE_BUFFER; 949 status = acpi_evaluate_object_typed(data->atk_handle, 950 METHOD_OLD_ENUM_VLT, NULL, &buf, ACPI_TYPE_PACKAGE); 951 if (status != AE_OK) { 952 dev_warn(dev, METHOD_OLD_ENUM_VLT ": ACPI exception: %s\n", 953 acpi_format_exception(status)); 954 955 return -ENODEV; 956 } 957 958 pack = buf.pointer; 959 for (i = 1; i < pack->package.count; i++) { 960 union acpi_object *obj = &pack->package.elements[i]; 961 962 ret = atk_add_sensor(data, obj); 963 if (ret > 0) 964 count++; 965 } 966 ACPI_FREE(buf.pointer); 967 968 /* Temperatures */ 969 buf.length = ACPI_ALLOCATE_BUFFER; 970 status = acpi_evaluate_object_typed(data->atk_handle, 971 METHOD_OLD_ENUM_TMP, NULL, &buf, ACPI_TYPE_PACKAGE); 972 if (status != AE_OK) { 973 dev_warn(dev, METHOD_OLD_ENUM_TMP ": ACPI exception: %s\n", 974 acpi_format_exception(status)); 975 976 return -ENODEV; 977 } 978 979 pack = buf.pointer; 980 for (i = 1; i < pack->package.count; i++) { 981 union acpi_object *obj = &pack->package.elements[i]; 982 983 ret = atk_add_sensor(data, obj); 984 if (ret > 0) 985 count++; 986 } 987 ACPI_FREE(buf.pointer); 988 989 /* Fans */ 990 buf.length = ACPI_ALLOCATE_BUFFER; 991 status = acpi_evaluate_object_typed(data->atk_handle, 992 METHOD_OLD_ENUM_FAN, NULL, &buf, ACPI_TYPE_PACKAGE); 993 if (status != AE_OK) { 994 dev_warn(dev, METHOD_OLD_ENUM_FAN ": ACPI exception: %s\n", 995 acpi_format_exception(status)); 996 997 return -ENODEV; 998 } 999 1000 pack = buf.pointer; 1001 for (i = 1; i < pack->package.count; i++) { 1002 union acpi_object *obj = &pack->package.elements[i]; 1003 1004 ret = atk_add_sensor(data, obj); 1005 if (ret > 0) 1006 count++; 1007 } 1008 ACPI_FREE(buf.pointer); 1009 1010 return count; 1011} 1012 1013static int atk_ec_present(struct atk_data *data) 1014{ 1015 struct device *dev = &data->acpi_dev->dev; 1016 union acpi_object *pack; 1017 union acpi_object *ec; 1018 int ret; 1019 int i; 1020 1021 pack = atk_ggrp(data, ATK_MUX_MGMT); 1022 if (IS_ERR(pack)) { 1023 if (PTR_ERR(pack) == -ENOENT) { 1024 /* The MGMT class does not exists - that's ok */ 1025 dev_dbg(dev, "Class %#llx not found\n", ATK_MUX_MGMT); 1026 return 0; 1027 } 1028 return PTR_ERR(pack); 1029 } 1030 1031 /* Search the EC */ 1032 ec = NULL; 1033 for (i = 0; i < pack->package.count; i++) { 1034 union acpi_object *obj = &pack->package.elements[i]; 1035 union acpi_object *id; 1036 1037 if (obj->type != ACPI_TYPE_PACKAGE) 1038 continue; 1039 1040 id = &obj->package.elements[0]; 1041 if (id->type != ACPI_TYPE_INTEGER) 1042 continue; 1043 1044 if (id->integer.value == ATK_EC_ID) { 1045 ec = obj; 1046 break; 1047 } 1048 } 1049 1050 ret = (ec != NULL); 1051 if (!ret) 1052 /* The system has no EC */ 1053 dev_dbg(dev, "EC not found\n"); 1054 1055 ACPI_FREE(pack); 1056 return ret; 1057} 1058 1059static int atk_ec_enabled(struct atk_data *data) 1060{ 1061 struct device *dev = &data->acpi_dev->dev; 1062 union acpi_object *obj; 1063 struct atk_acpi_ret_buffer *buf; 1064 int err; 1065 1066 obj = atk_gitm(data, ATK_EC_ID); 1067 if (IS_ERR(obj)) { 1068 dev_err(dev, "Unable to query EC status\n"); 1069 return PTR_ERR(obj); 1070 } 1071 buf = (struct atk_acpi_ret_buffer *)obj->buffer.pointer; 1072 1073 if (buf->flags == 0) { 1074 dev_err(dev, "Unable to query EC status\n"); 1075 err = -EIO; 1076 } else { 1077 err = (buf->value != 0); 1078 dev_dbg(dev, "EC is %s\n", str_enabled_disabled(err)); 1079 } 1080 1081 ACPI_FREE(obj); 1082 return err; 1083} 1084 1085static int atk_ec_ctl(struct atk_data *data, int enable) 1086{ 1087 struct device *dev = &data->acpi_dev->dev; 1088 union acpi_object *obj; 1089 struct atk_acpi_input_buf sitm; 1090 struct atk_acpi_ret_buffer *ec_ret; 1091 int err = 0; 1092 1093 sitm.id = ATK_EC_ID; 1094 sitm.param1 = enable; 1095 sitm.param2 = 0; 1096 1097 obj = atk_sitm(data, &sitm); 1098 if (IS_ERR(obj)) { 1099 dev_err(dev, "Failed to %s the EC\n", str_enable_disable(enable)); 1100 return PTR_ERR(obj); 1101 } 1102 ec_ret = (struct atk_acpi_ret_buffer *)obj->buffer.pointer; 1103 if (ec_ret->flags == 0) { 1104 dev_err(dev, "Failed to %s the EC\n", str_enable_disable(enable)); 1105 err = -EIO; 1106 } else { 1107 dev_info(dev, "EC %s\n", str_enabled_disabled(enable)); 1108 } 1109 1110 ACPI_FREE(obj); 1111 return err; 1112} 1113 1114static int atk_enumerate_new_hwmon(struct atk_data *data) 1115{ 1116 struct device *dev = &data->acpi_dev->dev; 1117 union acpi_object *pack; 1118 int err; 1119 int i; 1120 1121 err = atk_ec_present(data); 1122 if (err < 0) 1123 return err; 1124 if (err) { 1125 err = atk_ec_enabled(data); 1126 if (err < 0) 1127 return err; 1128 /* If the EC was disabled we will disable it again on unload */ 1129 data->disable_ec = err; 1130 1131 err = atk_ec_ctl(data, 1); 1132 if (err) { 1133 data->disable_ec = false; 1134 return err; 1135 } 1136 } 1137 1138 dev_dbg(dev, "Enumerating hwmon sensors\n"); 1139 1140 pack = atk_ggrp(data, ATK_MUX_HWMON); 1141 if (IS_ERR(pack)) 1142 return PTR_ERR(pack); 1143 1144 for (i = 0; i < pack->package.count; i++) { 1145 union acpi_object *obj = &pack->package.elements[i]; 1146 1147 atk_add_sensor(data, obj); 1148 } 1149 1150 err = data->voltage_count + data->temperature_count + data->fan_count; 1151 1152 ACPI_FREE(pack); 1153 return err; 1154} 1155 1156static int atk_init_attribute_groups(struct atk_data *data) 1157{ 1158 struct device *dev = &data->acpi_dev->dev; 1159 struct atk_sensor_data *s; 1160 struct attribute **attrs; 1161 int i = 0; 1162 int len = (data->voltage_count + data->temperature_count 1163 + data->fan_count) * 4 + 1; 1164 1165 attrs = devm_kcalloc(dev, len, sizeof(struct attribute *), GFP_KERNEL); 1166 if (!attrs) 1167 return -ENOMEM; 1168 1169 list_for_each_entry(s, &data->sensor_list, list) { 1170 attrs[i++] = &s->input_attr.attr; 1171 attrs[i++] = &s->label_attr.attr; 1172 attrs[i++] = &s->limit1_attr.attr; 1173 attrs[i++] = &s->limit2_attr.attr; 1174 } 1175 1176 data->attr_group.attrs = attrs; 1177 data->attr_groups[0] = &data->attr_group; 1178 1179 return 0; 1180} 1181 1182static int atk_register_hwmon(struct atk_data *data) 1183{ 1184 struct device *dev = &data->acpi_dev->dev; 1185 1186 dev_dbg(dev, "registering hwmon device\n"); 1187 data->hwmon_dev = hwmon_device_register_with_groups(dev, "atk0110", 1188 data, 1189 data->attr_groups); 1190 1191 return PTR_ERR_OR_ZERO(data->hwmon_dev); 1192} 1193 1194static int atk_probe_if(struct atk_data *data) 1195{ 1196 struct device *dev = &data->acpi_dev->dev; 1197 acpi_handle ret; 1198 acpi_status status; 1199 int err = 0; 1200 1201 /* RTMP: read temperature */ 1202 status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_TMP, &ret); 1203 if (ACPI_SUCCESS(status)) 1204 data->rtmp_handle = ret; 1205 else 1206 dev_dbg(dev, "method " METHOD_OLD_READ_TMP " not found: %s\n", 1207 acpi_format_exception(status)); 1208 1209 /* RVLT: read voltage */ 1210 status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_VLT, &ret); 1211 if (ACPI_SUCCESS(status)) 1212 data->rvlt_handle = ret; 1213 else 1214 dev_dbg(dev, "method " METHOD_OLD_READ_VLT " not found: %s\n", 1215 acpi_format_exception(status)); 1216 1217 /* RFAN: read fan status */ 1218 status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_FAN, &ret); 1219 if (ACPI_SUCCESS(status)) 1220 data->rfan_handle = ret; 1221 else 1222 dev_dbg(dev, "method " METHOD_OLD_READ_FAN " not found: %s\n", 1223 acpi_format_exception(status)); 1224 1225 /* Enumeration */ 1226 status = acpi_get_handle(data->atk_handle, METHOD_ENUMERATE, &ret); 1227 if (ACPI_SUCCESS(status)) 1228 data->enumerate_handle = ret; 1229 else 1230 dev_dbg(dev, "method " METHOD_ENUMERATE " not found: %s\n", 1231 acpi_format_exception(status)); 1232 1233 /* De-multiplexer (read) */ 1234 status = acpi_get_handle(data->atk_handle, METHOD_READ, &ret); 1235 if (ACPI_SUCCESS(status)) 1236 data->read_handle = ret; 1237 else 1238 dev_dbg(dev, "method " METHOD_READ " not found: %s\n", 1239 acpi_format_exception(status)); 1240 1241 /* De-multiplexer (write) */ 1242 status = acpi_get_handle(data->atk_handle, METHOD_WRITE, &ret); 1243 if (ACPI_SUCCESS(status)) 1244 data->write_handle = ret; 1245 else 1246 dev_dbg(dev, "method " METHOD_WRITE " not found: %s\n", 1247 acpi_format_exception(status)); 1248 1249 /* 1250 * Check for hwmon methods: first check "old" style methods; note that 1251 * both may be present: in this case we stick to the old interface; 1252 * analysis of multiple DSDTs indicates that when both interfaces 1253 * are present the new one (GGRP/GITM) is not functional. 1254 */ 1255 if (new_if) 1256 dev_info(dev, "Overriding interface detection\n"); 1257 if (data->rtmp_handle && 1258 data->rvlt_handle && data->rfan_handle && !new_if) 1259 data->old_interface = true; 1260 else if (data->enumerate_handle && data->read_handle && 1261 data->write_handle) 1262 data->old_interface = false; 1263 else 1264 err = -ENODEV; 1265 1266 return err; 1267} 1268 1269static int atk_add(struct acpi_device *device) 1270{ 1271 acpi_status ret; 1272 int err; 1273 struct acpi_buffer buf; 1274 union acpi_object *obj; 1275 struct atk_data *data; 1276 1277 dev_dbg(&device->dev, "adding...\n"); 1278 1279 data = devm_kzalloc(&device->dev, sizeof(*data), GFP_KERNEL); 1280 if (!data) 1281 return -ENOMEM; 1282 1283 data->acpi_dev = device; 1284 data->atk_handle = device->handle; 1285 INIT_LIST_HEAD(&data->sensor_list); 1286 data->disable_ec = false; 1287 1288 buf.length = ACPI_ALLOCATE_BUFFER; 1289 ret = acpi_evaluate_object_typed(data->atk_handle, BOARD_ID, NULL, 1290 &buf, ACPI_TYPE_PACKAGE); 1291 if (ret != AE_OK) { 1292 dev_dbg(&device->dev, "atk: method MBIF not found\n"); 1293 } else { 1294 obj = buf.pointer; 1295 if (obj->package.count >= 2) { 1296 union acpi_object *id = &obj->package.elements[1]; 1297 if (id->type == ACPI_TYPE_STRING) 1298 dev_dbg(&device->dev, "board ID = %s\n", 1299 id->string.pointer); 1300 } 1301 ACPI_FREE(buf.pointer); 1302 } 1303 1304 err = atk_probe_if(data); 1305 if (err) { 1306 dev_err(&device->dev, "No usable hwmon interface detected\n"); 1307 goto out; 1308 } 1309 1310 if (data->old_interface) { 1311 dev_dbg(&device->dev, "Using old hwmon interface\n"); 1312 err = atk_enumerate_old_hwmon(data); 1313 } else { 1314 dev_dbg(&device->dev, "Using new hwmon interface\n"); 1315 err = atk_enumerate_new_hwmon(data); 1316 } 1317 if (err < 0) 1318 goto out; 1319 if (err == 0) { 1320 dev_info(&device->dev, 1321 "No usable sensor detected, bailing out\n"); 1322 err = -ENODEV; 1323 goto out; 1324 } 1325 1326 err = atk_init_attribute_groups(data); 1327 if (err) 1328 goto out; 1329 err = atk_register_hwmon(data); 1330 if (err) 1331 goto out; 1332 1333 atk_debugfs_init(data); 1334 1335 device->driver_data = data; 1336 return 0; 1337out: 1338 if (data->disable_ec) 1339 atk_ec_ctl(data, 0); 1340 return err; 1341} 1342 1343static void atk_remove(struct acpi_device *device) 1344{ 1345 struct atk_data *data = device->driver_data; 1346 dev_dbg(&device->dev, "removing...\n"); 1347 1348 device->driver_data = NULL; 1349 1350 atk_debugfs_cleanup(data); 1351 1352 hwmon_device_unregister(data->hwmon_dev); 1353 1354 if (data->disable_ec) { 1355 if (atk_ec_ctl(data, 0)) 1356 dev_err(&device->dev, "Failed to disable EC\n"); 1357 } 1358} 1359 1360static int __init atk0110_init(void) 1361{ 1362 int ret; 1363 1364 /* Make sure it's safe to access the device through ACPI */ 1365 if (!acpi_resources_are_enforced()) { 1366 pr_err("Resources not safely usable due to acpi_enforce_resources kernel parameter\n"); 1367 return -EBUSY; 1368 } 1369 1370 if (dmi_check_system(atk_force_new_if)) 1371 new_if = true; 1372 1373 ret = acpi_bus_register_driver(&atk_driver); 1374 if (ret) 1375 pr_info("acpi_bus_register_driver failed: %d\n", ret); 1376 1377 return ret; 1378} 1379 1380static void __exit atk0110_exit(void) 1381{ 1382 acpi_bus_unregister_driver(&atk_driver); 1383} 1384 1385module_init(atk0110_init); 1386module_exit(atk0110_exit); 1387 1388MODULE_DESCRIPTION("ASUS ATK0110 driver"); 1389MODULE_LICENSE("GPL");
~/
Read-only file preview.