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