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>
18 #include <acpi/acpi.h>
19 #include <acpi/acpixf.h>
20 #include <acpi/acpi_drivers.h>
21 #include <acpi/acpi_bus.h>
24 #define ATK_HID "ATK0110"
27 module_param(new_if
, bool, 0);
28 MODULE_PARM_DESC(new_if
, "Override detection heuristic and force the use of the new ATK0110 interface");
30 static const struct dmi_system_id __initconst atk_force_new_if
[] = {
32 /* Old interface has broken MCH temp monitoring */
33 .ident
= "Asus Sabertooth X58",
35 DMI_MATCH(DMI_BOARD_NAME
, "SABERTOOTH X58")
41 /* Minimum time between readings, enforced in order to avoid
46 #define BOARD_ID "MBIF"
47 #define METHOD_ENUMERATE "GGRP"
48 #define METHOD_READ "GITM"
49 #define METHOD_WRITE "SITM"
50 #define METHOD_OLD_READ_TMP "RTMP"
51 #define METHOD_OLD_READ_VLT "RVLT"
52 #define METHOD_OLD_READ_FAN "RFAN"
53 #define METHOD_OLD_ENUM_TMP "TSIF"
54 #define METHOD_OLD_ENUM_VLT "VSIF"
55 #define METHOD_OLD_ENUM_FAN "FSIF"
57 #define ATK_MUX_HWMON 0x00000006ULL
58 #define ATK_MUX_MGMT 0x00000011ULL
60 #define ATK_CLASS_MASK 0xff000000ULL
61 #define ATK_CLASS_FREQ_CTL 0x03000000ULL
62 #define ATK_CLASS_FAN_CTL 0x04000000ULL
63 #define ATK_CLASS_HWMON 0x06000000ULL
64 #define ATK_CLASS_MGMT 0x11000000ULL
66 #define ATK_TYPE_MASK 0x00ff0000ULL
67 #define HWMON_TYPE_VOLT 0x00020000ULL
68 #define HWMON_TYPE_TEMP 0x00030000ULL
69 #define HWMON_TYPE_FAN 0x00040000ULL
71 #define ATK_ELEMENT_ID_MASK 0x0000ffffULL
73 #define ATK_EC_ID 0x11060004ULL
75 enum atk_pack_member
{
83 /* New package format */
84 #define _HWMON_NEW_PACK_SIZE 7
85 #define _HWMON_NEW_PACK_FLAGS 0
86 #define _HWMON_NEW_PACK_NAME 1
87 #define _HWMON_NEW_PACK_UNK1 2
88 #define _HWMON_NEW_PACK_UNK2 3
89 #define _HWMON_NEW_PACK_LIMIT1 4
90 #define _HWMON_NEW_PACK_LIMIT2 5
91 #define _HWMON_NEW_PACK_ENABLE 6
93 /* Old package format */
94 #define _HWMON_OLD_PACK_SIZE 5
95 #define _HWMON_OLD_PACK_FLAGS 0
96 #define _HWMON_OLD_PACK_NAME 1
97 #define _HWMON_OLD_PACK_LIMIT1 2
98 #define _HWMON_OLD_PACK_LIMIT2 3
99 #define _HWMON_OLD_PACK_ENABLE 4
103 struct device
*hwmon_dev
;
104 acpi_handle atk_handle
;
105 struct acpi_device
*acpi_dev
;
110 acpi_handle rtmp_handle
;
111 acpi_handle rvlt_handle
;
112 acpi_handle rfan_handle
;
114 acpi_handle enumerate_handle
;
115 acpi_handle read_handle
;
116 acpi_handle write_handle
;
121 int temperature_count
;
123 struct list_head sensor_list
;
132 typedef ssize_t (*sysfs_show_func
)(struct device
*dev
,
133 struct device_attribute
*attr
, char *buf
);
135 static const struct acpi_device_id atk_ids
[] = {
139 MODULE_DEVICE_TABLE(acpi
, atk_ids
);
141 #define ATTR_NAME_SIZE 16 /* Worst case is "tempN_input" */
143 struct atk_sensor_data
{
144 struct list_head list
;
145 struct atk_data
*data
;
146 struct device_attribute label_attr
;
147 struct device_attribute input_attr
;
148 struct device_attribute limit1_attr
;
149 struct device_attribute limit2_attr
;
150 char label_attr_name
[ATTR_NAME_SIZE
];
151 char input_attr_name
[ATTR_NAME_SIZE
];
152 char limit1_attr_name
[ATTR_NAME_SIZE
];
153 char limit2_attr_name
[ATTR_NAME_SIZE
];
159 unsigned long last_updated
; /* in jiffies */
161 char const *acpi_name
;
164 /* Return buffer format:
165 * [0-3] "value" is valid flag
167 * [8- ] unknown stuff on newer mobos
169 struct atk_acpi_ret_buffer
{
175 /* Input buffer used for GITM and SITM methods */
176 struct atk_acpi_input_buf
{
182 static int atk_add(struct acpi_device
*device
);
183 static int atk_remove(struct acpi_device
*device
, int type
);
184 static void atk_print_sensor(struct atk_data
*data
, union acpi_object
*obj
);
185 static int atk_read_value(struct atk_sensor_data
*sensor
, u64
*value
);
186 static void atk_free_sensors(struct atk_data
*data
);
188 static struct acpi_driver atk_driver
= {
194 .remove
= atk_remove
,
198 #define input_to_atk_sensor(attr) \
199 container_of(attr, struct atk_sensor_data, input_attr)
201 #define label_to_atk_sensor(attr) \
202 container_of(attr, struct atk_sensor_data, label_attr)
204 #define limit1_to_atk_sensor(attr) \
205 container_of(attr, struct atk_sensor_data, limit1_attr)
207 #define limit2_to_atk_sensor(attr) \
208 container_of(attr, struct atk_sensor_data, limit2_attr)
210 static ssize_t
atk_input_show(struct device
*dev
,
211 struct device_attribute
*attr
, char *buf
)
213 struct atk_sensor_data
*s
= input_to_atk_sensor(attr
);
217 err
= atk_read_value(s
, &value
);
221 if (s
->type
== HWMON_TYPE_TEMP
)
222 /* ACPI returns decidegree */
225 return sprintf(buf
, "%llu\n", value
);
228 static ssize_t
atk_label_show(struct device
*dev
,
229 struct device_attribute
*attr
, char *buf
)
231 struct atk_sensor_data
*s
= label_to_atk_sensor(attr
);
233 return sprintf(buf
, "%s\n", s
->acpi_name
);
236 static ssize_t
atk_limit1_show(struct device
*dev
,
237 struct device_attribute
*attr
, char *buf
)
239 struct atk_sensor_data
*s
= limit1_to_atk_sensor(attr
);
240 u64 value
= s
->limit1
;
242 if (s
->type
== HWMON_TYPE_TEMP
)
245 return sprintf(buf
, "%lld\n", value
);
248 static ssize_t
atk_limit2_show(struct device
*dev
,
249 struct device_attribute
*attr
, char *buf
)
251 struct atk_sensor_data
*s
= limit2_to_atk_sensor(attr
);
252 u64 value
= s
->limit2
;
254 if (s
->type
== HWMON_TYPE_TEMP
)
257 return sprintf(buf
, "%lld\n", value
);
260 static ssize_t
atk_name_show(struct device
*dev
,
261 struct device_attribute
*attr
, char *buf
)
263 return sprintf(buf
, "atk0110\n");
265 static struct device_attribute atk_name_attr
=
266 __ATTR(name
, 0444, atk_name_show
, NULL
);
268 static void atk_init_attribute(struct device_attribute
*attr
, char *name
,
269 sysfs_show_func show
)
271 attr
->attr
.name
= name
;
272 attr
->attr
.mode
= 0444;
278 static union acpi_object
*atk_get_pack_member(struct atk_data
*data
,
279 union acpi_object
*pack
,
280 enum atk_pack_member m
)
282 bool old_if
= data
->old_interface
;
286 case HWMON_PACK_FLAGS
:
287 offset
= old_if
? _HWMON_OLD_PACK_FLAGS
: _HWMON_NEW_PACK_FLAGS
;
289 case HWMON_PACK_NAME
:
290 offset
= old_if
? _HWMON_OLD_PACK_NAME
: _HWMON_NEW_PACK_NAME
;
292 case HWMON_PACK_LIMIT1
:
293 offset
= old_if
? _HWMON_OLD_PACK_LIMIT1
:
294 _HWMON_NEW_PACK_LIMIT1
;
296 case HWMON_PACK_LIMIT2
:
297 offset
= old_if
? _HWMON_OLD_PACK_LIMIT2
:
298 _HWMON_NEW_PACK_LIMIT2
;
300 case HWMON_PACK_ENABLE
:
301 offset
= old_if
? _HWMON_OLD_PACK_ENABLE
:
302 _HWMON_NEW_PACK_ENABLE
;
308 return &pack
->package
.elements
[offset
];
312 /* New package format is:
314 * class - used for de-muxing the request to the correct GITn
315 * type (volt, temp, fan)
317 * sensor id - used for de-muxing the request _inside_ the GITn
325 * The old package has the same format but it's missing the two unknown fields.
327 static int validate_hwmon_pack(struct atk_data
*data
, union acpi_object
*obj
)
329 struct device
*dev
= &data
->acpi_dev
->dev
;
330 union acpi_object
*tmp
;
331 bool old_if
= data
->old_interface
;
332 int const expected_size
= old_if
? _HWMON_OLD_PACK_SIZE
:
333 _HWMON_NEW_PACK_SIZE
;
335 if (obj
->type
!= ACPI_TYPE_PACKAGE
) {
336 dev_warn(dev
, "Invalid type: %d\n", obj
->type
);
340 if (obj
->package
.count
!= expected_size
) {
341 dev_warn(dev
, "Invalid package size: %d, expected: %d\n",
342 obj
->package
.count
, expected_size
);
346 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
);
347 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
348 dev_warn(dev
, "Invalid type (flag): %d\n", tmp
->type
);
352 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_NAME
);
353 if (tmp
->type
!= ACPI_TYPE_STRING
) {
354 dev_warn(dev
, "Invalid type (name): %d\n", tmp
->type
);
358 /* Don't check... we don't know what they're useful for anyway */
360 tmp
= &obj
->package
.elements
[HWMON_PACK_UNK1
];
361 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
362 dev_warn(dev
, "Invalid type (unk1): %d\n", tmp
->type
);
366 tmp
= &obj
->package
.elements
[HWMON_PACK_UNK2
];
367 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
368 dev_warn(dev
, "Invalid type (unk2): %d\n", tmp
->type
);
373 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT1
);
374 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
375 dev_warn(dev
, "Invalid type (limit1): %d\n", tmp
->type
);
379 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT2
);
380 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
381 dev_warn(dev
, "Invalid type (limit2): %d\n", tmp
->type
);
385 tmp
= atk_get_pack_member(data
, obj
, HWMON_PACK_ENABLE
);
386 if (tmp
->type
!= ACPI_TYPE_INTEGER
) {
387 dev_warn(dev
, "Invalid type (enable): %d\n", tmp
->type
);
391 atk_print_sensor(data
, obj
);
397 static char const *atk_sensor_type(union acpi_object
*flags
)
399 u64 type
= flags
->integer
.value
& ATK_TYPE_MASK
;
403 case HWMON_TYPE_VOLT
:
406 case HWMON_TYPE_TEMP
:
407 what
= "temperature";
421 static void atk_print_sensor(struct atk_data
*data
, union acpi_object
*obj
)
424 struct device
*dev
= &data
->acpi_dev
->dev
;
425 union acpi_object
*flags
;
426 union acpi_object
*name
;
427 union acpi_object
*limit1
;
428 union acpi_object
*limit2
;
429 union acpi_object
*enable
;
432 flags
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
);
433 name
= atk_get_pack_member(data
, obj
, HWMON_PACK_NAME
);
434 limit1
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT1
);
435 limit2
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT2
);
436 enable
= atk_get_pack_member(data
, obj
, HWMON_PACK_ENABLE
);
438 what
= atk_sensor_type(flags
);
440 dev_dbg(dev
, "%s: %#llx %s [%llu-%llu] %s\n", what
,
441 flags
->integer
.value
,
442 name
->string
.pointer
,
443 limit1
->integer
.value
, limit2
->integer
.value
,
444 enable
->integer
.value
? "enabled" : "disabled");
448 static int atk_read_value_old(struct atk_sensor_data
*sensor
, u64
*value
)
450 struct atk_data
*data
= sensor
->data
;
451 struct device
*dev
= &data
->acpi_dev
->dev
;
452 struct acpi_object_list params
;
453 union acpi_object id
;
457 switch (sensor
->type
) {
458 case HWMON_TYPE_VOLT
:
459 method
= data
->rvlt_handle
;
461 case HWMON_TYPE_TEMP
:
462 method
= data
->rtmp_handle
;
465 method
= data
->rfan_handle
;
471 id
.type
= ACPI_TYPE_INTEGER
;
472 id
.integer
.value
= sensor
->id
;
475 params
.pointer
= &id
;
477 status
= acpi_evaluate_integer(method
, NULL
, ¶ms
, value
);
478 if (status
!= AE_OK
) {
479 dev_warn(dev
, "%s: ACPI exception: %s\n", __func__
,
480 acpi_format_exception(status
));
487 static union acpi_object
*atk_ggrp(struct atk_data
*data
, u16 mux
)
489 struct device
*dev
= &data
->acpi_dev
->dev
;
490 struct acpi_buffer buf
;
492 struct acpi_object_list params
;
493 union acpi_object id
;
494 union acpi_object
*pack
;
496 id
.type
= ACPI_TYPE_INTEGER
;
497 id
.integer
.value
= mux
;
499 params
.pointer
= &id
;
501 buf
.length
= ACPI_ALLOCATE_BUFFER
;
502 ret
= acpi_evaluate_object(data
->enumerate_handle
, NULL
, ¶ms
, &buf
);
504 dev_err(dev
, "GGRP[%#x] ACPI exception: %s\n", mux
,
505 acpi_format_exception(ret
));
506 return ERR_PTR(-EIO
);
509 if (pack
->type
!= ACPI_TYPE_PACKAGE
) {
510 /* Execution was successful, but the id was not found */
512 return ERR_PTR(-ENOENT
);
515 if (pack
->package
.count
< 1) {
516 dev_err(dev
, "GGRP[%#x] package is too small\n", mux
);
518 return ERR_PTR(-EIO
);
523 static union acpi_object
*atk_gitm(struct atk_data
*data
, u64 id
)
525 struct device
*dev
= &data
->acpi_dev
->dev
;
526 struct atk_acpi_input_buf buf
;
527 union acpi_object tmp
;
528 struct acpi_object_list params
;
529 struct acpi_buffer ret
;
530 union acpi_object
*obj
;
537 tmp
.type
= ACPI_TYPE_BUFFER
;
538 tmp
.buffer
.pointer
= (u8
*)&buf
;
539 tmp
.buffer
.length
= sizeof(buf
);
542 params
.pointer
= (void *)&tmp
;
544 ret
.length
= ACPI_ALLOCATE_BUFFER
;
545 status
= acpi_evaluate_object_typed(data
->read_handle
, NULL
, ¶ms
,
546 &ret
, ACPI_TYPE_BUFFER
);
547 if (status
!= AE_OK
) {
548 dev_warn(dev
, "GITM[%#llx] ACPI exception: %s\n", id
,
549 acpi_format_exception(status
));
550 return ERR_PTR(-EIO
);
555 if (obj
->buffer
.length
< 8) {
556 dev_warn(dev
, "Unexpected ASBF length: %u\n",
559 return ERR_PTR(-EIO
);
564 static union acpi_object
*atk_sitm(struct atk_data
*data
,
565 struct atk_acpi_input_buf
*buf
)
567 struct device
*dev
= &data
->acpi_dev
->dev
;
568 struct acpi_object_list params
;
569 union acpi_object tmp
;
570 struct acpi_buffer ret
;
571 union acpi_object
*obj
;
574 tmp
.type
= ACPI_TYPE_BUFFER
;
575 tmp
.buffer
.pointer
= (u8
*)buf
;
576 tmp
.buffer
.length
= sizeof(*buf
);
579 params
.pointer
= &tmp
;
581 ret
.length
= ACPI_ALLOCATE_BUFFER
;
582 status
= acpi_evaluate_object_typed(data
->write_handle
, NULL
, ¶ms
,
583 &ret
, ACPI_TYPE_BUFFER
);
584 if (status
!= AE_OK
) {
585 dev_warn(dev
, "SITM[%#x] ACPI exception: %s\n", buf
->id
,
586 acpi_format_exception(status
));
587 return ERR_PTR(-EIO
);
592 if (obj
->buffer
.length
< 8) {
593 dev_warn(dev
, "Unexpected ASBF length: %u\n",
596 return ERR_PTR(-EIO
);
601 static int atk_read_value_new(struct atk_sensor_data
*sensor
, u64
*value
)
603 struct atk_data
*data
= sensor
->data
;
604 struct device
*dev
= &data
->acpi_dev
->dev
;
605 union acpi_object
*obj
;
606 struct atk_acpi_ret_buffer
*buf
;
609 obj
= atk_gitm(data
, sensor
->id
);
613 buf
= (struct atk_acpi_ret_buffer
*)obj
->buffer
.pointer
;
614 if (buf
->flags
== 0) {
615 /* The reading is not valid, possible causes:
617 * - enumeration was FUBAR (and we didn't notice)
619 dev_warn(dev
, "Read failed, sensor = %#llx\n", sensor
->id
);
630 static int atk_read_value(struct atk_sensor_data
*sensor
, u64
*value
)
634 if (!sensor
->is_valid
||
635 time_after(jiffies
, sensor
->last_updated
+ CACHE_TIME
)) {
636 if (sensor
->data
->old_interface
)
637 err
= atk_read_value_old(sensor
, value
);
639 err
= atk_read_value_new(sensor
, value
);
641 sensor
->is_valid
= true;
642 sensor
->last_updated
= jiffies
;
643 sensor
->cached_value
= *value
;
645 *value
= sensor
->cached_value
;
652 #ifdef CONFIG_DEBUG_FS
653 static int atk_debugfs_gitm_get(void *p
, u64
*val
)
655 struct atk_data
*data
= p
;
656 union acpi_object
*ret
;
657 struct atk_acpi_ret_buffer
*buf
;
660 if (!data
->read_handle
)
663 if (!data
->debugfs
.id
)
666 ret
= atk_gitm(data
, data
->debugfs
.id
);
670 buf
= (struct atk_acpi_ret_buffer
*)ret
->buffer
.pointer
;
680 DEFINE_SIMPLE_ATTRIBUTE(atk_debugfs_gitm
,
681 atk_debugfs_gitm_get
,
685 static int atk_acpi_print(char *buf
, size_t sz
, union acpi_object
*obj
)
690 case ACPI_TYPE_INTEGER
:
691 ret
= snprintf(buf
, sz
, "0x%08llx\n", obj
->integer
.value
);
693 case ACPI_TYPE_STRING
:
694 ret
= snprintf(buf
, sz
, "%s\n", obj
->string
.pointer
);
701 static void atk_pack_print(char *buf
, size_t sz
, union acpi_object
*pack
)
706 for (i
= 0; i
< pack
->package
.count
; i
++) {
707 union acpi_object
*obj
= &pack
->package
.elements
[i
];
709 ret
= atk_acpi_print(buf
, sz
, obj
);
717 static int atk_debugfs_ggrp_open(struct inode
*inode
, struct file
*file
)
719 struct atk_data
*data
= inode
->i_private
;
721 union acpi_object
*ret
;
725 if (!data
->enumerate_handle
)
727 if (!data
->debugfs
.id
)
730 cls
= (data
->debugfs
.id
& 0xff000000) >> 24;
731 ret
= atk_ggrp(data
, cls
);
735 for (i
= 0; i
< ret
->package
.count
; i
++) {
736 union acpi_object
*pack
= &ret
->package
.elements
[i
];
737 union acpi_object
*id
;
739 if (pack
->type
!= ACPI_TYPE_PACKAGE
)
741 if (!pack
->package
.count
)
743 id
= &pack
->package
.elements
[0];
744 if (id
->integer
.value
== data
->debugfs
.id
) {
745 /* Print the package */
746 buf
= kzalloc(512, GFP_KERNEL
);
751 atk_pack_print(buf
, 512, pack
);
760 file
->private_data
= buf
;
762 return nonseekable_open(inode
, file
);
765 static ssize_t
atk_debugfs_ggrp_read(struct file
*file
, char __user
*buf
,
766 size_t count
, loff_t
*pos
)
768 char *str
= file
->private_data
;
769 size_t len
= strlen(str
);
771 return simple_read_from_buffer(buf
, count
, pos
, str
, len
);
774 static int atk_debugfs_ggrp_release(struct inode
*inode
, struct file
*file
)
776 kfree(file
->private_data
);
780 static const struct file_operations atk_debugfs_ggrp_fops
= {
781 .read
= atk_debugfs_ggrp_read
,
782 .open
= atk_debugfs_ggrp_open
,
783 .release
= atk_debugfs_ggrp_release
,
787 static void atk_debugfs_init(struct atk_data
*data
)
792 data
->debugfs
.id
= 0;
794 d
= debugfs_create_dir("asus_atk0110", NULL
);
798 f
= debugfs_create_x32("id", S_IRUSR
| S_IWUSR
, d
, &data
->debugfs
.id
);
802 f
= debugfs_create_file("gitm", S_IRUSR
, d
, data
,
807 f
= debugfs_create_file("ggrp", S_IRUSR
, d
, data
,
808 &atk_debugfs_ggrp_fops
);
812 data
->debugfs
.root
= d
;
816 debugfs_remove_recursive(d
);
819 static void atk_debugfs_cleanup(struct atk_data
*data
)
821 debugfs_remove_recursive(data
->debugfs
.root
);
824 #else /* CONFIG_DEBUG_FS */
826 static void atk_debugfs_init(struct atk_data
*data
)
830 static void atk_debugfs_cleanup(struct atk_data
*data
)
835 static int atk_add_sensor(struct atk_data
*data
, union acpi_object
*obj
)
837 struct device
*dev
= &data
->acpi_dev
->dev
;
838 union acpi_object
*flags
;
839 union acpi_object
*name
;
840 union acpi_object
*limit1
;
841 union acpi_object
*limit2
;
842 union acpi_object
*enable
;
843 struct atk_sensor_data
*sensor
;
844 char const *base_name
;
845 char const *limit1_name
;
846 char const *limit2_name
;
852 if (obj
->type
!= ACPI_TYPE_PACKAGE
) {
854 dev_warn(dev
, "Unknown type for ACPI object: (%d)\n",
859 err
= validate_hwmon_pack(data
, obj
);
863 /* Ok, we have a valid hwmon package */
864 type
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
)->integer
.value
868 case HWMON_TYPE_VOLT
:
872 num
= &data
->voltage_count
;
875 case HWMON_TYPE_TEMP
:
878 limit2_name
= "crit";
879 num
= &data
->temperature_count
;
886 num
= &data
->fan_count
;
890 dev_warn(dev
, "Unknown sensor type: %#llx\n", type
);
894 enable
= atk_get_pack_member(data
, obj
, HWMON_PACK_ENABLE
);
895 if (!enable
->integer
.value
)
896 /* sensor is disabled */
899 flags
= atk_get_pack_member(data
, obj
, HWMON_PACK_FLAGS
);
900 name
= atk_get_pack_member(data
, obj
, HWMON_PACK_NAME
);
901 limit1
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT1
);
902 limit2
= atk_get_pack_member(data
, obj
, HWMON_PACK_LIMIT2
);
904 sensor
= kzalloc(sizeof(*sensor
), GFP_KERNEL
);
908 sensor
->acpi_name
= kstrdup(name
->string
.pointer
, GFP_KERNEL
);
909 if (!sensor
->acpi_name
) {
914 INIT_LIST_HEAD(&sensor
->list
);
917 sensor
->id
= flags
->integer
.value
;
918 sensor
->limit1
= limit1
->integer
.value
;
919 if (data
->old_interface
)
920 sensor
->limit2
= limit2
->integer
.value
;
922 /* The upper limit is expressed as delta from lower limit */
923 sensor
->limit2
= sensor
->limit1
+ limit2
->integer
.value
;
925 snprintf(sensor
->input_attr_name
, ATTR_NAME_SIZE
,
926 "%s%d_input", base_name
, start
+ *num
);
927 atk_init_attribute(&sensor
->input_attr
,
928 sensor
->input_attr_name
,
931 snprintf(sensor
->label_attr_name
, ATTR_NAME_SIZE
,
932 "%s%d_label", base_name
, start
+ *num
);
933 atk_init_attribute(&sensor
->label_attr
,
934 sensor
->label_attr_name
,
937 snprintf(sensor
->limit1_attr_name
, ATTR_NAME_SIZE
,
938 "%s%d_%s", base_name
, start
+ *num
, limit1_name
);
939 atk_init_attribute(&sensor
->limit1_attr
,
940 sensor
->limit1_attr_name
,
943 snprintf(sensor
->limit2_attr_name
, ATTR_NAME_SIZE
,
944 "%s%d_%s", base_name
, start
+ *num
, limit2_name
);
945 atk_init_attribute(&sensor
->limit2_attr
,
946 sensor
->limit2_attr_name
,
949 list_add(&sensor
->list
, &data
->sensor_list
);
954 kfree(sensor
->acpi_name
);
959 static int atk_enumerate_old_hwmon(struct atk_data
*data
)
961 struct device
*dev
= &data
->acpi_dev
->dev
;
962 struct acpi_buffer buf
;
963 union acpi_object
*pack
;
969 buf
.length
= ACPI_ALLOCATE_BUFFER
;
970 status
= acpi_evaluate_object_typed(data
->atk_handle
,
971 METHOD_OLD_ENUM_VLT
, NULL
, &buf
, ACPI_TYPE_PACKAGE
);
972 if (status
!= AE_OK
) {
973 dev_warn(dev
, METHOD_OLD_ENUM_VLT
": ACPI exception: %s\n",
974 acpi_format_exception(status
));
980 for (i
= 1; i
< pack
->package
.count
; i
++) {
981 union acpi_object
*obj
= &pack
->package
.elements
[i
];
983 ret
= atk_add_sensor(data
, obj
);
987 ACPI_FREE(buf
.pointer
);
990 buf
.length
= ACPI_ALLOCATE_BUFFER
;
991 status
= acpi_evaluate_object_typed(data
->atk_handle
,
992 METHOD_OLD_ENUM_TMP
, NULL
, &buf
, ACPI_TYPE_PACKAGE
);
993 if (status
!= AE_OK
) {
994 dev_warn(dev
, METHOD_OLD_ENUM_TMP
": ACPI exception: %s\n",
995 acpi_format_exception(status
));
1002 for (i
= 1; i
< pack
->package
.count
; i
++) {
1003 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1005 ret
= atk_add_sensor(data
, obj
);
1009 ACPI_FREE(buf
.pointer
);
1012 buf
.length
= ACPI_ALLOCATE_BUFFER
;
1013 status
= acpi_evaluate_object_typed(data
->atk_handle
,
1014 METHOD_OLD_ENUM_FAN
, NULL
, &buf
, ACPI_TYPE_PACKAGE
);
1015 if (status
!= AE_OK
) {
1016 dev_warn(dev
, METHOD_OLD_ENUM_FAN
": ACPI exception: %s\n",
1017 acpi_format_exception(status
));
1024 for (i
= 1; i
< pack
->package
.count
; i
++) {
1025 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1027 ret
= atk_add_sensor(data
, obj
);
1031 ACPI_FREE(buf
.pointer
);
1035 atk_free_sensors(data
);
1039 static int atk_ec_present(struct atk_data
*data
)
1041 struct device
*dev
= &data
->acpi_dev
->dev
;
1042 union acpi_object
*pack
;
1043 union acpi_object
*ec
;
1047 pack
= atk_ggrp(data
, ATK_MUX_MGMT
);
1049 if (PTR_ERR(pack
) == -ENOENT
) {
1050 /* The MGMT class does not exists - that's ok */
1051 dev_dbg(dev
, "Class %#llx not found\n", ATK_MUX_MGMT
);
1054 return PTR_ERR(pack
);
1059 for (i
= 0; i
< pack
->package
.count
; i
++) {
1060 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1061 union acpi_object
*id
;
1063 if (obj
->type
!= ACPI_TYPE_PACKAGE
)
1066 id
= &obj
->package
.elements
[0];
1067 if (id
->type
!= ACPI_TYPE_INTEGER
)
1070 if (id
->integer
.value
== ATK_EC_ID
) {
1078 /* The system has no EC */
1079 dev_dbg(dev
, "EC not found\n");
1085 static int atk_ec_enabled(struct atk_data
*data
)
1087 struct device
*dev
= &data
->acpi_dev
->dev
;
1088 union acpi_object
*obj
;
1089 struct atk_acpi_ret_buffer
*buf
;
1092 obj
= atk_gitm(data
, ATK_EC_ID
);
1094 dev_err(dev
, "Unable to query EC status\n");
1095 return PTR_ERR(obj
);
1097 buf
= (struct atk_acpi_ret_buffer
*)obj
->buffer
.pointer
;
1099 if (buf
->flags
== 0) {
1100 dev_err(dev
, "Unable to query EC status\n");
1103 err
= (buf
->value
!= 0);
1104 dev_dbg(dev
, "EC is %sabled\n",
1105 err
? "en" : "dis");
1112 static int atk_ec_ctl(struct atk_data
*data
, int enable
)
1114 struct device
*dev
= &data
->acpi_dev
->dev
;
1115 union acpi_object
*obj
;
1116 struct atk_acpi_input_buf sitm
;
1117 struct atk_acpi_ret_buffer
*ec_ret
;
1120 sitm
.id
= ATK_EC_ID
;
1121 sitm
.param1
= enable
;
1124 obj
= atk_sitm(data
, &sitm
);
1126 dev_err(dev
, "Failed to %sable the EC\n",
1127 enable
? "en" : "dis");
1128 return PTR_ERR(obj
);
1130 ec_ret
= (struct atk_acpi_ret_buffer
*)obj
->buffer
.pointer
;
1131 if (ec_ret
->flags
== 0) {
1132 dev_err(dev
, "Failed to %sable the EC\n",
1133 enable
? "en" : "dis");
1136 dev_info(dev
, "EC %sabled\n",
1137 enable
? "en" : "dis");
1144 static int atk_enumerate_new_hwmon(struct atk_data
*data
)
1146 struct device
*dev
= &data
->acpi_dev
->dev
;
1147 union acpi_object
*pack
;
1151 err
= atk_ec_present(data
);
1155 err
= atk_ec_enabled(data
);
1158 /* If the EC was disabled we will disable it again on unload */
1159 data
->disable_ec
= err
;
1161 err
= atk_ec_ctl(data
, 1);
1163 data
->disable_ec
= false;
1168 dev_dbg(dev
, "Enumerating hwmon sensors\n");
1170 pack
= atk_ggrp(data
, ATK_MUX_HWMON
);
1172 return PTR_ERR(pack
);
1174 for (i
= 0; i
< pack
->package
.count
; i
++) {
1175 union acpi_object
*obj
= &pack
->package
.elements
[i
];
1177 atk_add_sensor(data
, obj
);
1180 err
= data
->voltage_count
+ data
->temperature_count
+ data
->fan_count
;
1186 static int atk_create_files(struct atk_data
*data
)
1188 struct atk_sensor_data
*s
;
1191 list_for_each_entry(s
, &data
->sensor_list
, list
) {
1192 sysfs_attr_init(&s
->input_attr
.attr
);
1193 err
= device_create_file(data
->hwmon_dev
, &s
->input_attr
);
1196 sysfs_attr_init(&s
->label_attr
.attr
);
1197 err
= device_create_file(data
->hwmon_dev
, &s
->label_attr
);
1200 sysfs_attr_init(&s
->limit1_attr
.attr
);
1201 err
= device_create_file(data
->hwmon_dev
, &s
->limit1_attr
);
1204 sysfs_attr_init(&s
->limit2_attr
.attr
);
1205 err
= device_create_file(data
->hwmon_dev
, &s
->limit2_attr
);
1210 err
= device_create_file(data
->hwmon_dev
, &atk_name_attr
);
1215 static void atk_remove_files(struct atk_data
*data
)
1217 struct atk_sensor_data
*s
;
1219 list_for_each_entry(s
, &data
->sensor_list
, list
) {
1220 device_remove_file(data
->hwmon_dev
, &s
->input_attr
);
1221 device_remove_file(data
->hwmon_dev
, &s
->label_attr
);
1222 device_remove_file(data
->hwmon_dev
, &s
->limit1_attr
);
1223 device_remove_file(data
->hwmon_dev
, &s
->limit2_attr
);
1225 device_remove_file(data
->hwmon_dev
, &atk_name_attr
);
1228 static void atk_free_sensors(struct atk_data
*data
)
1230 struct list_head
*head
= &data
->sensor_list
;
1231 struct atk_sensor_data
*s
, *tmp
;
1233 list_for_each_entry_safe(s
, tmp
, head
, list
) {
1234 kfree(s
->acpi_name
);
1239 static int atk_register_hwmon(struct atk_data
*data
)
1241 struct device
*dev
= &data
->acpi_dev
->dev
;
1244 dev_dbg(dev
, "registering hwmon device\n");
1245 data
->hwmon_dev
= hwmon_device_register(dev
);
1246 if (IS_ERR(data
->hwmon_dev
))
1247 return PTR_ERR(data
->hwmon_dev
);
1249 dev_dbg(dev
, "populating sysfs directory\n");
1250 err
= atk_create_files(data
);
1256 /* Cleanup the registered files */
1257 atk_remove_files(data
);
1258 hwmon_device_unregister(data
->hwmon_dev
);
1262 static int atk_probe_if(struct atk_data
*data
)
1264 struct device
*dev
= &data
->acpi_dev
->dev
;
1269 /* RTMP: read temperature */
1270 status
= acpi_get_handle(data
->atk_handle
, METHOD_OLD_READ_TMP
, &ret
);
1271 if (ACPI_SUCCESS(status
))
1272 data
->rtmp_handle
= ret
;
1274 dev_dbg(dev
, "method " METHOD_OLD_READ_TMP
" not found: %s\n",
1275 acpi_format_exception(status
));
1277 /* RVLT: read voltage */
1278 status
= acpi_get_handle(data
->atk_handle
, METHOD_OLD_READ_VLT
, &ret
);
1279 if (ACPI_SUCCESS(status
))
1280 data
->rvlt_handle
= ret
;
1282 dev_dbg(dev
, "method " METHOD_OLD_READ_VLT
" not found: %s\n",
1283 acpi_format_exception(status
));
1285 /* RFAN: read fan status */
1286 status
= acpi_get_handle(data
->atk_handle
, METHOD_OLD_READ_FAN
, &ret
);
1287 if (ACPI_SUCCESS(status
))
1288 data
->rfan_handle
= ret
;
1290 dev_dbg(dev
, "method " METHOD_OLD_READ_FAN
" not found: %s\n",
1291 acpi_format_exception(status
));
1294 status
= acpi_get_handle(data
->atk_handle
, METHOD_ENUMERATE
, &ret
);
1295 if (ACPI_SUCCESS(status
))
1296 data
->enumerate_handle
= ret
;
1298 dev_dbg(dev
, "method " METHOD_ENUMERATE
" not found: %s\n",
1299 acpi_format_exception(status
));
1301 /* De-multiplexer (read) */
1302 status
= acpi_get_handle(data
->atk_handle
, METHOD_READ
, &ret
);
1303 if (ACPI_SUCCESS(status
))
1304 data
->read_handle
= ret
;
1306 dev_dbg(dev
, "method " METHOD_READ
" not found: %s\n",
1307 acpi_format_exception(status
));
1309 /* De-multiplexer (write) */
1310 status
= acpi_get_handle(data
->atk_handle
, METHOD_WRITE
, &ret
);
1311 if (ACPI_SUCCESS(status
))
1312 data
->write_handle
= ret
;
1314 dev_dbg(dev
, "method " METHOD_WRITE
" not found: %s\n",
1315 acpi_format_exception(status
));
1317 /* Check for hwmon methods: first check "old" style methods; note that
1318 * both may be present: in this case we stick to the old interface;
1319 * analysis of multiple DSDTs indicates that when both interfaces
1320 * are present the new one (GGRP/GITM) is not functional.
1323 dev_info(dev
, "Overriding interface detection\n");
1324 if (data
->rtmp_handle
&& data
->rvlt_handle
&& data
->rfan_handle
&& !new_if
)
1325 data
->old_interface
= true;
1326 else if (data
->enumerate_handle
&& data
->read_handle
&&
1328 data
->old_interface
= false;
1335 static int atk_add(struct acpi_device
*device
)
1339 struct acpi_buffer buf
;
1340 union acpi_object
*obj
;
1341 struct atk_data
*data
;
1343 dev_dbg(&device
->dev
, "adding...\n");
1345 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1349 data
->acpi_dev
= device
;
1350 data
->atk_handle
= device
->handle
;
1351 INIT_LIST_HEAD(&data
->sensor_list
);
1352 data
->disable_ec
= false;
1354 buf
.length
= ACPI_ALLOCATE_BUFFER
;
1355 ret
= acpi_evaluate_object_typed(data
->atk_handle
, BOARD_ID
, NULL
,
1356 &buf
, ACPI_TYPE_PACKAGE
);
1358 dev_dbg(&device
->dev
, "atk: method MBIF not found\n");
1361 if (obj
->package
.count
>= 2) {
1362 union acpi_object
*id
= &obj
->package
.elements
[1];
1363 if (id
->type
== ACPI_TYPE_STRING
)
1364 dev_dbg(&device
->dev
, "board ID = %s\n",
1365 id
->string
.pointer
);
1367 ACPI_FREE(buf
.pointer
);
1370 err
= atk_probe_if(data
);
1372 dev_err(&device
->dev
, "No usable hwmon interface detected\n");
1376 if (data
->old_interface
) {
1377 dev_dbg(&device
->dev
, "Using old hwmon interface\n");
1378 err
= atk_enumerate_old_hwmon(data
);
1380 dev_dbg(&device
->dev
, "Using new hwmon interface\n");
1381 err
= atk_enumerate_new_hwmon(data
);
1386 dev_info(&device
->dev
,
1387 "No usable sensor detected, bailing out\n");
1392 err
= atk_register_hwmon(data
);
1396 atk_debugfs_init(data
);
1398 device
->driver_data
= data
;
1401 atk_free_sensors(data
);
1403 if (data
->disable_ec
)
1404 atk_ec_ctl(data
, 0);
1409 static int atk_remove(struct acpi_device
*device
, int type
)
1411 struct atk_data
*data
= device
->driver_data
;
1412 dev_dbg(&device
->dev
, "removing...\n");
1414 device
->driver_data
= NULL
;
1416 atk_debugfs_cleanup(data
);
1418 atk_remove_files(data
);
1419 atk_free_sensors(data
);
1420 hwmon_device_unregister(data
->hwmon_dev
);
1422 if (data
->disable_ec
) {
1423 if (atk_ec_ctl(data
, 0))
1424 dev_err(&device
->dev
, "Failed to disable EC\n");
1432 static int __init
atk0110_init(void)
1436 /* Make sure it's safe to access the device through ACPI */
1437 if (!acpi_resources_are_enforced()) {
1438 pr_err("Resources not safely usable due to acpi_enforce_resources kernel parameter\n");
1442 if (dmi_check_system(atk_force_new_if
))
1445 ret
= acpi_bus_register_driver(&atk_driver
);
1447 pr_info("acpi_bus_register_driver failed: %d\n", ret
);
1452 static void __exit
atk0110_exit(void)
1454 acpi_bus_unregister_driver(&atk_driver
);
1457 module_init(atk0110_init
);
1458 module_exit(atk0110_exit
);
1460 MODULE_LICENSE("GPL");