2 * Copyright (C) 2007-2009 Luca Tettamanti <kronos.it@gmail.com>
4 * This file is released under the GPLv2
5 * See COPYING in the top level directory of the kernel tree.
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
20 #include <acpi/acpi.h>
21 #include <acpi/acpi_drivers.h>
22 #include <acpi/acpi_bus.h>
25 #define ATK_HID "ATK0110"
28 module_param(new_if
, bool, 0);
29 MODULE_PARM_DESC(new_if
, "Override detection heuristic and force the use of the new ATK0110 interface");
31 static const struct dmi_system_id __initconst atk_force_new_if
[] = {
33 /* Old interface has broken MCH temp monitoring */
34 .ident
= "Asus Sabertooth X58",
36 DMI_MATCH(DMI_BOARD_NAME
, "SABERTOOTH X58")
39 /* Old interface reads the same sensor for fan0 and fan1 */
40 .ident
= "Asus M5A78L",
42 DMI_MATCH(DMI_BOARD_NAME
, "M5A78L")
49 * Minimum time between readings, enforced in order to avoid
54 #define BOARD_ID "MBIF"
55 #define METHOD_ENUMERATE "GGRP"
56 #define METHOD_READ "GITM"
57 #define METHOD_WRITE "SITM"
58 #define METHOD_OLD_READ_TMP "RTMP"
59 #define METHOD_OLD_READ_VLT "RVLT"
60 #define METHOD_OLD_READ_FAN "RFAN"
61 #define METHOD_OLD_ENUM_TMP "TSIF"
62 #define METHOD_OLD_ENUM_VLT "VSIF"
63 #define METHOD_OLD_ENUM_FAN "FSIF"
65 #define ATK_MUX_HWMON 0x00000006ULL
66 #define ATK_MUX_MGMT 0x00000011ULL
68 #define ATK_CLASS_MASK 0xff000000ULL
69 #define ATK_CLASS_FREQ_CTL 0x03000000ULL
70 #define ATK_CLASS_FAN_CTL 0x04000000ULL
71 #define ATK_CLASS_HWMON 0x06000000ULL
72 #define ATK_CLASS_MGMT 0x11000000ULL
74 #define ATK_TYPE_MASK 0x00ff0000ULL
75 #define HWMON_TYPE_VOLT 0x00020000ULL
76 #define HWMON_TYPE_TEMP 0x00030000ULL
77 #define HWMON_TYPE_FAN 0x00040000ULL
79 #define ATK_ELEMENT_ID_MASK 0x0000ffffULL
81 #define ATK_EC_ID 0x11060004ULL
83 enum atk_pack_member
{
91 /* New package format */
92 #define _HWMON_NEW_PACK_SIZE 7
93 #define _HWMON_NEW_PACK_FLAGS 0
94 #define _HWMON_NEW_PACK_NAME 1
95 #define _HWMON_NEW_PACK_UNK1 2
96 #define _HWMON_NEW_PACK_UNK2 3
97 #define _HWMON_NEW_PACK_LIMIT1 4
98 #define _HWMON_NEW_PACK_LIMIT2 5
99 #define _HWMON_NEW_PACK_ENABLE 6
101 /* Old package format */
102 #define _HWMON_OLD_PACK_SIZE 5
103 #define _HWMON_OLD_PACK_FLAGS 0
104 #define _HWMON_OLD_PACK_NAME 1
105 #define _HWMON_OLD_PACK_LIMIT1 2
106 #define _HWMON_OLD_PACK_LIMIT2 3
107 #define _HWMON_OLD_PACK_ENABLE 4
111 struct device
*hwmon_dev
;
112 acpi_handle atk_handle
;
113 struct acpi_device
*acpi_dev
;
118 acpi_handle rtmp_handle
;
119 acpi_handle rvlt_handle
;
120 acpi_handle rfan_handle
;
122 acpi_handle enumerate_handle
;
123 acpi_handle read_handle
;
124 acpi_handle write_handle
;
129 int temperature_count
;
131 struct list_head sensor_list
;
140 typedef ssize_t (*sysfs_show_func
)(struct device
*dev
,
141 struct device_attribute
*attr
, char *buf
);
143 static const struct acpi_device_id atk_ids
[] = {
147 MODULE_DEVICE_TABLE(acpi
, atk_ids
);
149 #define ATTR_NAME_SIZE 16 /* Worst case is "tempN_input" */
151 struct atk_sensor_data
{
152 struct list_head list
;
153 struct atk_data
*data
;
154 struct device_attribute label_attr
;
155 struct device_attribute input_attr
;
156 struct device_attribute limit1_attr
;
157 struct device_attribute limit2_attr
;
158 char label_attr_name
[ATTR_NAME_SIZE
];
159 char input_attr_name
[ATTR_NAME_SIZE
];
160 char limit1_attr_name
[ATTR_NAME_SIZE
];
161 char limit2_attr_name
[ATTR_NAME_SIZE
];
167 unsigned long last_updated
; /* in jiffies */
169 char const *acpi_name
;
173 * Return buffer format:
174 * [0-3] "value" is valid flag
176 * [8- ] unknown stuff on newer mobos
178 struct atk_acpi_ret_buffer
{
184 /* Input buffer used for GITM and SITM methods */
185 struct atk_acpi_input_buf
{
191 static int atk_add(struct acpi_device
*device
);
192 static int atk_remove(struct acpi_device
*device
);
193 static void atk_print_sensor(struct atk_data
*data
, union acpi_object
*obj
);
194 static int atk_read_value(struct atk_sensor_data
*sensor
, u64
*value
);
195 static void atk_free_sensors(struct atk_data
*data
);
197 static struct acpi_driver atk_driver
= {
203 .remove
= atk_remove
,
207 #define input_to_atk_sensor(attr) \
208 container_of(attr, struct atk_sensor_data, input_attr)
210 #define label_to_atk_sensor(attr) \
211 container_of(attr, struct atk_sensor_data, label_attr)
213 #define limit1_to_atk_sensor(attr) \
214 container_of(attr, struct atk_sensor_data, limit1_attr)
216 #define limit2_to_atk_sensor(attr) \
217 container_of(attr, struct atk_sensor_data, limit2_attr)
219 static ssize_t
atk_input_show(struct device
*dev
,
220 struct device_attribute
*attr
, char *buf
)
222 struct atk_sensor_data
*s
= input_to_atk_sensor(attr
);
226 err
= atk_read_value(s
, &value
);
230 if (s
->type
== HWMON_TYPE_TEMP
)
231 /* ACPI returns decidegree */
234 return sprintf(buf
, "%llu\n", value
);
237 static ssize_t
atk_label_show(struct device
*dev
,
238 struct device_attribute
*attr
, char *buf
)
240 struct atk_sensor_data
*s
= label_to_atk_sensor(attr
);
242 return sprintf(buf
, "%s\n", s
->acpi_name
);
245 static ssize_t
atk_limit1_show(struct device
*dev
,
246 struct device_attribute
*attr
, char *buf
)
248 struct atk_sensor_data
*s
= limit1_to_atk_sensor(attr
);
249 u64 value
= s
->limit1
;
251 if (s
->type
== HWMON_TYPE_TEMP
)
254 return sprintf(buf
, "%lld\n", value
);
257 static ssize_t
atk_limit2_show(struct device
*dev
,
258 struct device_attribute
*attr
, char *buf
)
260 struct atk_sensor_data
*s
= limit2_to_atk_sensor(attr
);
261 u64 value
= s
->limit2
;
263 if (s
->type
== HWMON_TYPE_TEMP
)
266 return sprintf(buf
, "%lld\n", value
);
269 static ssize_t
atk_name_show(struct device
*dev
,
270 struct device_attribute
*attr
, char *buf
)
272 return sprintf(buf
, "atk0110\n");
274 static struct device_attribute atk_name_attr
=
275 __ATTR(name
, 0444, atk_name_show
, NULL
);
277 static void atk_init_attribute(struct device_attribute
*attr
, char *name
,
278 sysfs_show_func show
)
280 sysfs_attr_init(&attr
->attr
);
281 attr
->attr
.name
= name
;
282 attr
->attr
.mode
= 0444;
288 static union acpi_object
*atk_get_pack_member(struct atk_data
*data
,
289 union acpi_object
*pack
,
290 enum atk_pack_member m
)
292 bool old_if
= data
->old_interface
;
296 case HWMON_PACK_FLAGS
:
297 offset
= old_if
? _HWMON_OLD_PACK_FLAGS
: _HWMON_NEW_PACK_FLAGS
;
299 case HWMON_PACK_NAME
:
300 offset
= old_if
? _HWMON_OLD_PACK_NAME
: _HWMON_NEW_PACK_NAME
;
302 case HWMON_PACK_LIMIT1
:
303 offset
= old_if
? _HWMON_OLD_PACK_LIMIT1
:
304 _HWMON_NEW_PACK_LIMIT1
;
306 case HWMON_PACK_LIMIT2
:
307 offset
= old_if
? _HWMON_OLD_PACK_LIMIT2
:
308 _HWMON_NEW_PACK_LIMIT2
;
310 case HWMON_PACK_ENABLE
:
311 offset
= old_if
? _HWMON_OLD_PACK_ENABLE
:
312 _HWMON_NEW_PACK_ENABLE
;
318 return &pack
->package
.elements
[offset
];
323 * New package format is:
325 * class - used for de-muxing the request to the correct GITn
326 * type (volt, temp, fan)
328 * sensor id - used for de-muxing the request _inside_ the GITn
336 * The old package has the same format but it's missing the two unknown fields.
338 static int validate_hwmon_pack(struct atk_data
*data
, union acpi_object
*obj
)
340 struct device
*dev
= &data
->acpi_dev
->dev
;
341 union acpi_object
*tmp
;
342 bool old_if
= data
->old_interface
;
343 int const expected_size
= old_if
? _HWMON_OLD_PACK_SIZE
:
344 _HWMON_NEW_PACK_SIZE
;
346 if (obj
->type
!= ACPI_TYPE_PACKAGE
) {
347 dev_warn(dev
, "Invalid type: %d\n", obj
->type
);
351 if (obj
->package
.count
!= expected_size
) {
352 dev_warn(dev
, "Invalid package size: %d, expected: %d\n",
353 obj
->package
.count
, expected_size
);
357 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
);
358 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
359 dev_warn(dev
, "Invalid type (flag): %d\n", tmp
->type
);
363 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_NAME
);
364 if (tmp
->type
!= ACPI_TYPE_STRING
) {
365 dev_warn(dev
, "Invalid type (name): %d\n", tmp
->type
);
369 /* Don't check... we don't know what they're useful for anyway */
371 tmp
= &obj
->package
.elements
[HWMON_PACK_UNK1
];
372 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
373 dev_warn(dev
, "Invalid type (unk1): %d\n", tmp
->type
);
377 tmp
= &obj
->package
.elements
[HWMON_PACK_UNK2
];
378 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
379 dev_warn(dev
, "Invalid type (unk2): %d\n", tmp
->type
);
384 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT1
);
385 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
386 dev_warn(dev
, "Invalid type (limit1): %d\n", tmp
->type
);
390 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT2
);
391 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
392 dev_warn(dev
, "Invalid type (limit2): %d\n", tmp
->type
);
396 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_ENABLE
);
397 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
398 dev_warn(dev
, "Invalid type (enable): %d\n", tmp
->type
);
402 atk_print_sensor(data
, obj
);
408 static char const *atk_sensor_type(union acpi_object
*flags
)
410 u64 type
= flags
->integer
.value
& ATK_TYPE_MASK
;
414 case HWMON_TYPE_VOLT
:
417 case HWMON_TYPE_TEMP
:
418 what
= "temperature";
432 static void atk_print_sensor(struct atk_data
*data
, union acpi_object
*obj
)
435 struct device
*dev
= &data
->acpi_dev
->dev
;
436 union acpi_object
*flags
;
437 union acpi_object
*name
;
438 union acpi_object
*limit1
;
439 union acpi_object
*limit2
;
440 union acpi_object
*enable
;
443 flags
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
);
444 name
= atk_get_pack_member(data
, obj
, HWMON_PACK_NAME
);
445 limit1
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT1
);
446 limit2
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT2
);
447 enable
= atk_get_pack_member(data
, obj
, HWMON_PACK_ENABLE
);
449 what
= atk_sensor_type(flags
);
451 dev_dbg(dev
, "%s: %#llx %s [%llu-%llu] %s\n", what
,
452 flags
->integer
.value
,
453 name
->string
.pointer
,
454 limit1
->integer
.value
, limit2
->integer
.value
,
455 enable
->integer
.value
? "enabled" : "disabled");
459 static int atk_read_value_old(struct atk_sensor_data
*sensor
, u64
*value
)
461 struct atk_data
*data
= sensor
->data
;
462 struct device
*dev
= &data
->acpi_dev
->dev
;
463 struct acpi_object_list params
;
464 union acpi_object id
;
468 switch (sensor
->type
) {
469 case HWMON_TYPE_VOLT
:
470 method
= data
->rvlt_handle
;
472 case HWMON_TYPE_TEMP
:
473 method
= data
->rtmp_handle
;
476 method
= data
->rfan_handle
;
482 id
.type
= ACPI_TYPE_INTEGER
;
483 id
.integer
.value
= sensor
->id
;
486 params
.pointer
= &id
;
488 status
= acpi_evaluate_integer(method
, NULL
, ¶ms
, value
);
489 if (status
!= AE_OK
) {
490 dev_warn(dev
, "%s: ACPI exception: %s\n", __func__
,
491 acpi_format_exception(status
));
498 static union acpi_object
*atk_ggrp(struct atk_data
*data
, u16 mux
)
500 struct device
*dev
= &data
->acpi_dev
->dev
;
501 struct acpi_buffer buf
;
503 struct acpi_object_list params
;
504 union acpi_object id
;
505 union acpi_object
*pack
;
507 id
.type
= ACPI_TYPE_INTEGER
;
508 id
.integer
.value
= mux
;
510 params
.pointer
= &id
;
512 buf
.length
= ACPI_ALLOCATE_BUFFER
;
513 ret
= acpi_evaluate_object(data
->enumerate_handle
, NULL
, ¶ms
, &buf
);
515 dev_err(dev
, "GGRP[%#x] ACPI exception: %s\n", mux
,
516 acpi_format_exception(ret
));
517 return ERR_PTR(-EIO
);
520 if (pack
->type
!= ACPI_TYPE_PACKAGE
) {
521 /* Execution was successful, but the id was not found */
523 return ERR_PTR(-ENOENT
);
526 if (pack
->package
.count
< 1) {
527 dev_err(dev
, "GGRP[%#x] package is too small\n", mux
);
529 return ERR_PTR(-EIO
);
534 static union acpi_object
*atk_gitm(struct atk_data
*data
, u64 id
)
536 struct device
*dev
= &data
->acpi_dev
->dev
;
537 struct atk_acpi_input_buf buf
;
538 union acpi_object tmp
;
539 struct acpi_object_list params
;
540 struct acpi_buffer ret
;
541 union acpi_object
*obj
;
548 tmp
.type
= ACPI_TYPE_BUFFER
;
549 tmp
.buffer
.pointer
= (u8
*)&buf
;
550 tmp
.buffer
.length
= sizeof(buf
);
553 params
.pointer
= (void *)&tmp
;
555 ret
.length
= ACPI_ALLOCATE_BUFFER
;
556 status
= acpi_evaluate_object_typed(data
->read_handle
, NULL
, ¶ms
,
557 &ret
, ACPI_TYPE_BUFFER
);
558 if (status
!= AE_OK
) {
559 dev_warn(dev
, "GITM[%#llx] ACPI exception: %s\n", id
,
560 acpi_format_exception(status
));
561 return ERR_PTR(-EIO
);
566 if (obj
->buffer
.length
< 8) {
567 dev_warn(dev
, "Unexpected ASBF length: %u\n",
570 return ERR_PTR(-EIO
);
575 static union acpi_object
*atk_sitm(struct atk_data
*data
,
576 struct atk_acpi_input_buf
*buf
)
578 struct device
*dev
= &data
->acpi_dev
->dev
;
579 struct acpi_object_list params
;
580 union acpi_object tmp
;
581 struct acpi_buffer ret
;
582 union acpi_object
*obj
;
585 tmp
.type
= ACPI_TYPE_BUFFER
;
586 tmp
.buffer
.pointer
= (u8
*)buf
;
587 tmp
.buffer
.length
= sizeof(*buf
);
590 params
.pointer
= &tmp
;
592 ret
.length
= ACPI_ALLOCATE_BUFFER
;
593 status
= acpi_evaluate_object_typed(data
->write_handle
, NULL
, ¶ms
,
594 &ret
, ACPI_TYPE_BUFFER
);
595 if (status
!= AE_OK
) {
596 dev_warn(dev
, "SITM[%#x] ACPI exception: %s\n", buf
->id
,
597 acpi_format_exception(status
));
598 return ERR_PTR(-EIO
);
603 if (obj
->buffer
.length
< 8) {
604 dev_warn(dev
, "Unexpected ASBF length: %u\n",
607 return ERR_PTR(-EIO
);
612 static int atk_read_value_new(struct atk_sensor_data
*sensor
, u64
*value
)
614 struct atk_data
*data
= sensor
->data
;
615 struct device
*dev
= &data
->acpi_dev
->dev
;
616 union acpi_object
*obj
;
617 struct atk_acpi_ret_buffer
*buf
;
620 obj
= atk_gitm(data
, sensor
->id
);
624 buf
= (struct atk_acpi_ret_buffer
*)obj
->buffer
.pointer
;
625 if (buf
->flags
== 0) {
627 * The reading is not valid, possible causes:
629 * - enumeration was FUBAR (and we didn't notice)
631 dev_warn(dev
, "Read failed, sensor = %#llx\n", sensor
->id
);
642 static int atk_read_value(struct atk_sensor_data
*sensor
, u64
*value
)
646 if (!sensor
->is_valid
||
647 time_after(jiffies
, sensor
->last_updated
+ CACHE_TIME
)) {
648 if (sensor
->data
->old_interface
)
649 err
= atk_read_value_old(sensor
, value
);
651 err
= atk_read_value_new(sensor
, value
);
653 sensor
->is_valid
= true;
654 sensor
->last_updated
= jiffies
;
655 sensor
->cached_value
= *value
;
657 *value
= sensor
->cached_value
;
664 #ifdef CONFIG_DEBUG_FS
665 static int atk_debugfs_gitm_get(void *p
, u64
*val
)
667 struct atk_data
*data
= p
;
668 union acpi_object
*ret
;
669 struct atk_acpi_ret_buffer
*buf
;
672 if (!data
->read_handle
)
675 if (!data
->debugfs
.id
)
678 ret
= atk_gitm(data
, data
->debugfs
.id
);
682 buf
= (struct atk_acpi_ret_buffer
*)ret
->buffer
.pointer
;
692 DEFINE_SIMPLE_ATTRIBUTE(atk_debugfs_gitm
,
693 atk_debugfs_gitm_get
,
697 static int atk_acpi_print(char *buf
, size_t sz
, union acpi_object
*obj
)
702 case ACPI_TYPE_INTEGER
:
703 ret
= snprintf(buf
, sz
, "0x%08llx\n", obj
->integer
.value
);
705 case ACPI_TYPE_STRING
:
706 ret
= snprintf(buf
, sz
, "%s\n", obj
->string
.pointer
);
713 static void atk_pack_print(char *buf
, size_t sz
, union acpi_object
*pack
)
718 for (i
= 0; i
< pack
->package
.count
; i
++) {
719 union acpi_object
*obj
= &pack
->package
.elements
[i
];
721 ret
= atk_acpi_print(buf
, sz
, obj
);
729 static int atk_debugfs_ggrp_open(struct inode
*inode
, struct file
*file
)
731 struct atk_data
*data
= inode
->i_private
;
733 union acpi_object
*ret
;
737 if (!data
->enumerate_handle
)
739 if (!data
->debugfs
.id
)
742 cls
= (data
->debugfs
.id
& 0xff000000) >> 24;
743 ret
= atk_ggrp(data
, cls
);
747 for (i
= 0; i
< ret
->package
.count
; i
++) {
748 union acpi_object
*pack
= &ret
->package
.elements
[i
];
749 union acpi_object
*id
;
751 if (pack
->type
!= ACPI_TYPE_PACKAGE
)
753 if (!pack
->package
.count
)
755 id
= &pack
->package
.elements
[0];
756 if (id
->integer
.value
== data
->debugfs
.id
) {
757 /* Print the package */
758 buf
= kzalloc(512, GFP_KERNEL
);
763 atk_pack_print(buf
, 512, pack
);
772 file
->private_data
= buf
;
774 return nonseekable_open(inode
, file
);
777 static ssize_t
atk_debugfs_ggrp_read(struct file
*file
, char __user
*buf
,
778 size_t count
, loff_t
*pos
)
780 char *str
= file
->private_data
;
781 size_t len
= strlen(str
);
783 return simple_read_from_buffer(buf
, count
, pos
, str
, len
);
786 static int atk_debugfs_ggrp_release(struct inode
*inode
, struct file
*file
)
788 kfree(file
->private_data
);
792 static const struct file_operations atk_debugfs_ggrp_fops
= {
793 .read
= atk_debugfs_ggrp_read
,
794 .open
= atk_debugfs_ggrp_open
,
795 .release
= atk_debugfs_ggrp_release
,
799 static void atk_debugfs_init(struct atk_data
*data
)
804 data
->debugfs
.id
= 0;
806 d
= debugfs_create_dir("asus_atk0110", NULL
);
810 f
= debugfs_create_x32("id", S_IRUSR
| S_IWUSR
, d
, &data
->debugfs
.id
);
814 f
= debugfs_create_file("gitm", S_IRUSR
, d
, data
,
819 f
= debugfs_create_file("ggrp", S_IRUSR
, d
, data
,
820 &atk_debugfs_ggrp_fops
);
824 data
->debugfs
.root
= d
;
828 debugfs_remove_recursive(d
);
831 static void atk_debugfs_cleanup(struct atk_data
*data
)
833 debugfs_remove_recursive(data
->debugfs
.root
);
836 #else /* CONFIG_DEBUG_FS */
838 static void atk_debugfs_init(struct atk_data
*data
)
842 static void atk_debugfs_cleanup(struct atk_data
*data
)
847 static int atk_add_sensor(struct atk_data
*data
, union acpi_object
*obj
)
849 struct device
*dev
= &data
->acpi_dev
->dev
;
850 union acpi_object
*flags
;
851 union acpi_object
*name
;
852 union acpi_object
*limit1
;
853 union acpi_object
*limit2
;
854 union acpi_object
*enable
;
855 struct atk_sensor_data
*sensor
;
856 char const *base_name
;
857 char const *limit1_name
;
858 char const *limit2_name
;
864 if (obj
->type
!= ACPI_TYPE_PACKAGE
) {
866 dev_warn(dev
, "Unknown type for ACPI object: (%d)\n",
871 err
= validate_hwmon_pack(data
, obj
);
875 /* Ok, we have a valid hwmon package */
876 type
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
)->integer
.value
880 case HWMON_TYPE_VOLT
:
884 num
= &data
->voltage_count
;
887 case HWMON_TYPE_TEMP
:
890 limit2_name
= "crit";
891 num
= &data
->temperature_count
;
898 num
= &data
->fan_count
;
902 dev_warn(dev
, "Unknown sensor type: %#llx\n", type
);
906 enable
= atk_get_pack_member(data
, obj
, HWMON_PACK_ENABLE
);
907 if (!enable
->integer
.value
)
908 /* sensor is disabled */
911 flags
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
);
912 name
= atk_get_pack_member(data
, obj
, HWMON_PACK_NAME
);
913 limit1
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT1
);
914 limit2
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT2
);
916 sensor
= kzalloc(sizeof(*sensor
), GFP_KERNEL
);
920 sensor
->acpi_name
= kstrdup(name
->string
.pointer
, GFP_KERNEL
);
921 if (!sensor
->acpi_name
) {
926 INIT_LIST_HEAD(&sensor
->list
);
929 sensor
->id
= flags
->integer
.value
;
930 sensor
->limit1
= limit1
->integer
.value
;
931 if (data
->old_interface
)
932 sensor
->limit2
= limit2
->integer
.value
;
934 /* The upper limit is expressed as delta from lower limit */
935 sensor
->limit2
= sensor
->limit1
+ limit2
->integer
.value
;
937 snprintf(sensor
->input_attr_name
, ATTR_NAME_SIZE
,
938 "%s%d_input", base_name
, start
+ *num
);
939 atk_init_attribute(&sensor
->input_attr
,
940 sensor
->input_attr_name
,
943 snprintf(sensor
->label_attr_name
, ATTR_NAME_SIZE
,
944 "%s%d_label", base_name
, start
+ *num
);
945 atk_init_attribute(&sensor
->label_attr
,
946 sensor
->label_attr_name
,
949 snprintf(sensor
->limit1_attr_name
, ATTR_NAME_SIZE
,
950 "%s%d_%s", base_name
, start
+ *num
, limit1_name
);
951 atk_init_attribute(&sensor
->limit1_attr
,
952 sensor
->limit1_attr_name
,
955 snprintf(sensor
->limit2_attr_name
, ATTR_NAME_SIZE
,
956 "%s%d_%s", base_name
, start
+ *num
, limit2_name
);
957 atk_init_attribute(&sensor
->limit2_attr
,
958 sensor
->limit2_attr_name
,
961 list_add(&sensor
->list
, &data
->sensor_list
);
970 static int atk_enumerate_old_hwmon(struct atk_data
*data
)
972 struct device
*dev
= &data
->acpi_dev
->dev
;
973 struct acpi_buffer buf
;
974 union acpi_object
*pack
;
980 buf
.length
= ACPI_ALLOCATE_BUFFER
;
981 status
= acpi_evaluate_object_typed(data
->atk_handle
,
982 METHOD_OLD_ENUM_VLT
, NULL
, &buf
, ACPI_TYPE_PACKAGE
);
983 if (status
!= AE_OK
) {
984 dev_warn(dev
, METHOD_OLD_ENUM_VLT
": ACPI exception: %s\n",
985 acpi_format_exception(status
));
991 for (i
= 1; i
< pack
->package
.count
; i
++) {
992 union acpi_object
*obj
= &pack
->package
.elements
[i
];
994 ret
= atk_add_sensor(data
, obj
);
998 ACPI_FREE(buf
.pointer
);
1001 buf
.length
= ACPI_ALLOCATE_BUFFER
;
1002 status
= acpi_evaluate_object_typed(data
->atk_handle
,
1003 METHOD_OLD_ENUM_TMP
, NULL
, &buf
, ACPI_TYPE_PACKAGE
);
1004 if (status
!= AE_OK
) {
1005 dev_warn(dev
, METHOD_OLD_ENUM_TMP
": ACPI exception: %s\n",
1006 acpi_format_exception(status
));
1013 for (i
= 1; i
< pack
->package
.count
; i
++) {
1014 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1016 ret
= atk_add_sensor(data
, obj
);
1020 ACPI_FREE(buf
.pointer
);
1023 buf
.length
= ACPI_ALLOCATE_BUFFER
;
1024 status
= acpi_evaluate_object_typed(data
->atk_handle
,
1025 METHOD_OLD_ENUM_FAN
, NULL
, &buf
, ACPI_TYPE_PACKAGE
);
1026 if (status
!= AE_OK
) {
1027 dev_warn(dev
, METHOD_OLD_ENUM_FAN
": ACPI exception: %s\n",
1028 acpi_format_exception(status
));
1035 for (i
= 1; i
< pack
->package
.count
; i
++) {
1036 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1038 ret
= atk_add_sensor(data
, obj
);
1042 ACPI_FREE(buf
.pointer
);
1046 atk_free_sensors(data
);
1050 static int atk_ec_present(struct atk_data
*data
)
1052 struct device
*dev
= &data
->acpi_dev
->dev
;
1053 union acpi_object
*pack
;
1054 union acpi_object
*ec
;
1058 pack
= atk_ggrp(data
, ATK_MUX_MGMT
);
1060 if (PTR_ERR(pack
) == -ENOENT
) {
1061 /* The MGMT class does not exists - that's ok */
1062 dev_dbg(dev
, "Class %#llx not found\n", ATK_MUX_MGMT
);
1065 return PTR_ERR(pack
);
1070 for (i
= 0; i
< pack
->package
.count
; i
++) {
1071 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1072 union acpi_object
*id
;
1074 if (obj
->type
!= ACPI_TYPE_PACKAGE
)
1077 id
= &obj
->package
.elements
[0];
1078 if (id
->type
!= ACPI_TYPE_INTEGER
)
1081 if (id
->integer
.value
== ATK_EC_ID
) {
1089 /* The system has no EC */
1090 dev_dbg(dev
, "EC not found\n");
1096 static int atk_ec_enabled(struct atk_data
*data
)
1098 struct device
*dev
= &data
->acpi_dev
->dev
;
1099 union acpi_object
*obj
;
1100 struct atk_acpi_ret_buffer
*buf
;
1103 obj
= atk_gitm(data
, ATK_EC_ID
);
1105 dev_err(dev
, "Unable to query EC status\n");
1106 return PTR_ERR(obj
);
1108 buf
= (struct atk_acpi_ret_buffer
*)obj
->buffer
.pointer
;
1110 if (buf
->flags
== 0) {
1111 dev_err(dev
, "Unable to query EC status\n");
1114 err
= (buf
->value
!= 0);
1115 dev_dbg(dev
, "EC is %sabled\n",
1116 err
? "en" : "dis");
1123 static int atk_ec_ctl(struct atk_data
*data
, int enable
)
1125 struct device
*dev
= &data
->acpi_dev
->dev
;
1126 union acpi_object
*obj
;
1127 struct atk_acpi_input_buf sitm
;
1128 struct atk_acpi_ret_buffer
*ec_ret
;
1131 sitm
.id
= ATK_EC_ID
;
1132 sitm
.param1
= enable
;
1135 obj
= atk_sitm(data
, &sitm
);
1137 dev_err(dev
, "Failed to %sable the EC\n",
1138 enable
? "en" : "dis");
1139 return PTR_ERR(obj
);
1141 ec_ret
= (struct atk_acpi_ret_buffer
*)obj
->buffer
.pointer
;
1142 if (ec_ret
->flags
== 0) {
1143 dev_err(dev
, "Failed to %sable the EC\n",
1144 enable
? "en" : "dis");
1147 dev_info(dev
, "EC %sabled\n",
1148 enable
? "en" : "dis");
1155 static int atk_enumerate_new_hwmon(struct atk_data
*data
)
1157 struct device
*dev
= &data
->acpi_dev
->dev
;
1158 union acpi_object
*pack
;
1162 err
= atk_ec_present(data
);
1166 err
= atk_ec_enabled(data
);
1169 /* If the EC was disabled we will disable it again on unload */
1170 data
->disable_ec
= err
;
1172 err
= atk_ec_ctl(data
, 1);
1174 data
->disable_ec
= false;
1179 dev_dbg(dev
, "Enumerating hwmon sensors\n");
1181 pack
= atk_ggrp(data
, ATK_MUX_HWMON
);
1183 return PTR_ERR(pack
);
1185 for (i
= 0; i
< pack
->package
.count
; i
++) {
1186 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1188 atk_add_sensor(data
, obj
);
1191 err
= data
->voltage_count
+ data
->temperature_count
+ data
->fan_count
;
1197 static int atk_create_files(struct atk_data
*data
)
1199 struct atk_sensor_data
*s
;
1202 list_for_each_entry(s
, &data
->sensor_list
, list
) {
1203 err
= device_create_file(data
->hwmon_dev
, &s
->input_attr
);
1206 err
= device_create_file(data
->hwmon_dev
, &s
->label_attr
);
1209 err
= device_create_file(data
->hwmon_dev
, &s
->limit1_attr
);
1212 err
= device_create_file(data
->hwmon_dev
, &s
->limit2_attr
);
1217 err
= device_create_file(data
->hwmon_dev
, &atk_name_attr
);
1222 static void atk_remove_files(struct atk_data
*data
)
1224 struct atk_sensor_data
*s
;
1226 list_for_each_entry(s
, &data
->sensor_list
, list
) {
1227 device_remove_file(data
->hwmon_dev
, &s
->input_attr
);
1228 device_remove_file(data
->hwmon_dev
, &s
->label_attr
);
1229 device_remove_file(data
->hwmon_dev
, &s
->limit1_attr
);
1230 device_remove_file(data
->hwmon_dev
, &s
->limit2_attr
);
1232 device_remove_file(data
->hwmon_dev
, &atk_name_attr
);
1235 static void atk_free_sensors(struct atk_data
*data
)
1237 struct list_head
*head
= &data
->sensor_list
;
1238 struct atk_sensor_data
*s
, *tmp
;
1240 list_for_each_entry_safe(s
, tmp
, head
, list
) {
1241 kfree(s
->acpi_name
);
1246 static int atk_register_hwmon(struct atk_data
*data
)
1248 struct device
*dev
= &data
->acpi_dev
->dev
;
1251 dev_dbg(dev
, "registering hwmon device\n");
1252 data
->hwmon_dev
= hwmon_device_register(dev
);
1253 if (IS_ERR(data
->hwmon_dev
))
1254 return PTR_ERR(data
->hwmon_dev
);
1256 dev_dbg(dev
, "populating sysfs directory\n");
1257 err
= atk_create_files(data
);
1263 /* Cleanup the registered files */
1264 atk_remove_files(data
);
1265 hwmon_device_unregister(data
->hwmon_dev
);
1269 static int atk_probe_if(struct atk_data
*data
)
1271 struct device
*dev
= &data
->acpi_dev
->dev
;
1276 /* RTMP: read temperature */
1277 status
= acpi_get_handle(data
->atk_handle
, METHOD_OLD_READ_TMP
, &ret
);
1278 if (ACPI_SUCCESS(status
))
1279 data
->rtmp_handle
= ret
;
1281 dev_dbg(dev
, "method " METHOD_OLD_READ_TMP
" not found: %s\n",
1282 acpi_format_exception(status
));
1284 /* RVLT: read voltage */
1285 status
= acpi_get_handle(data
->atk_handle
, METHOD_OLD_READ_VLT
, &ret
);
1286 if (ACPI_SUCCESS(status
))
1287 data
->rvlt_handle
= ret
;
1289 dev_dbg(dev
, "method " METHOD_OLD_READ_VLT
" not found: %s\n",
1290 acpi_format_exception(status
));
1292 /* RFAN: read fan status */
1293 status
= acpi_get_handle(data
->atk_handle
, METHOD_OLD_READ_FAN
, &ret
);
1294 if (ACPI_SUCCESS(status
))
1295 data
->rfan_handle
= ret
;
1297 dev_dbg(dev
, "method " METHOD_OLD_READ_FAN
" not found: %s\n",
1298 acpi_format_exception(status
));
1301 status
= acpi_get_handle(data
->atk_handle
, METHOD_ENUMERATE
, &ret
);
1302 if (ACPI_SUCCESS(status
))
1303 data
->enumerate_handle
= ret
;
1305 dev_dbg(dev
, "method " METHOD_ENUMERATE
" not found: %s\n",
1306 acpi_format_exception(status
));
1308 /* De-multiplexer (read) */
1309 status
= acpi_get_handle(data
->atk_handle
, METHOD_READ
, &ret
);
1310 if (ACPI_SUCCESS(status
))
1311 data
->read_handle
= ret
;
1313 dev_dbg(dev
, "method " METHOD_READ
" not found: %s\n",
1314 acpi_format_exception(status
));
1316 /* De-multiplexer (write) */
1317 status
= acpi_get_handle(data
->atk_handle
, METHOD_WRITE
, &ret
);
1318 if (ACPI_SUCCESS(status
))
1319 data
->write_handle
= ret
;
1321 dev_dbg(dev
, "method " METHOD_WRITE
" not found: %s\n",
1322 acpi_format_exception(status
));
1325 * Check for hwmon methods: first check "old" style methods; note that
1326 * both may be present: in this case we stick to the old interface;
1327 * analysis of multiple DSDTs indicates that when both interfaces
1328 * are present the new one (GGRP/GITM) is not functional.
1331 dev_info(dev
, "Overriding interface detection\n");
1332 if (data
->rtmp_handle
&&
1333 data
->rvlt_handle
&& data
->rfan_handle
&& !new_if
)
1334 data
->old_interface
= true;
1335 else if (data
->enumerate_handle
&& data
->read_handle
&&
1337 data
->old_interface
= false;
1344 static int atk_add(struct acpi_device
*device
)
1348 struct acpi_buffer buf
;
1349 union acpi_object
*obj
;
1350 struct atk_data
*data
;
1352 dev_dbg(&device
->dev
, "adding...\n");
1354 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1358 data
->acpi_dev
= device
;
1359 data
->atk_handle
= device
->handle
;
1360 INIT_LIST_HEAD(&data
->sensor_list
);
1361 data
->disable_ec
= false;
1363 buf
.length
= ACPI_ALLOCATE_BUFFER
;
1364 ret
= acpi_evaluate_object_typed(data
->atk_handle
, BOARD_ID
, NULL
,
1365 &buf
, ACPI_TYPE_PACKAGE
);
1367 dev_dbg(&device
->dev
, "atk: method MBIF not found\n");
1370 if (obj
->package
.count
>= 2) {
1371 union acpi_object
*id
= &obj
->package
.elements
[1];
1372 if (id
->type
== ACPI_TYPE_STRING
)
1373 dev_dbg(&device
->dev
, "board ID = %s\n",
1374 id
->string
.pointer
);
1376 ACPI_FREE(buf
.pointer
);
1379 err
= atk_probe_if(data
);
1381 dev_err(&device
->dev
, "No usable hwmon interface detected\n");
1385 if (data
->old_interface
) {
1386 dev_dbg(&device
->dev
, "Using old hwmon interface\n");
1387 err
= atk_enumerate_old_hwmon(data
);
1389 dev_dbg(&device
->dev
, "Using new hwmon interface\n");
1390 err
= atk_enumerate_new_hwmon(data
);
1395 dev_info(&device
->dev
,
1396 "No usable sensor detected, bailing out\n");
1401 err
= atk_register_hwmon(data
);
1405 atk_debugfs_init(data
);
1407 device
->driver_data
= data
;
1410 atk_free_sensors(data
);
1412 if (data
->disable_ec
)
1413 atk_ec_ctl(data
, 0);
1418 static int atk_remove(struct acpi_device
*device
)
1420 struct atk_data
*data
= device
->driver_data
;
1421 dev_dbg(&device
->dev
, "removing...\n");
1423 device
->driver_data
= NULL
;
1425 atk_debugfs_cleanup(data
);
1427 atk_remove_files(data
);
1428 atk_free_sensors(data
);
1429 hwmon_device_unregister(data
->hwmon_dev
);
1431 if (data
->disable_ec
) {
1432 if (atk_ec_ctl(data
, 0))
1433 dev_err(&device
->dev
, "Failed to disable EC\n");
1441 static int __init
atk0110_init(void)
1445 /* Make sure it's safe to access the device through ACPI */
1446 if (!acpi_resources_are_enforced()) {
1447 pr_err("Resources not safely usable due to acpi_enforce_resources kernel parameter\n");
1451 if (dmi_check_system(atk_force_new_if
))
1454 ret
= acpi_bus_register_driver(&atk_driver
);
1456 pr_info("acpi_bus_register_driver failed: %d\n", ret
);
1461 static void __exit
atk0110_exit(void)
1463 acpi_bus_unregister_driver(&atk_driver
);
1466 module_init(atk0110_init
);
1467 module_exit(atk0110_exit
);
1469 MODULE_LICENSE("GPL");