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