]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/hwmon/asus_atk0110.c
Merge branch 'hwmon-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
[linux-2.6.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 #include <linux/kernel.h>
9 #include <linux/hwmon.h>
10 #include <linux/list.h>
11 #include <linux/module.h>
12
13 #include <acpi/acpi.h>
14 #include <acpi/acpixf.h>
15 #include <acpi/acpi_drivers.h>
16 #include <acpi/acpi_bus.h>
17
18
19 #define ATK_HID "ATK0110"
20
21 /* Minimum time between readings, enforced in order to avoid
22  * hogging the CPU.
23  */
24 #define CACHE_TIME              HZ
25
26 #define BOARD_ID                "MBIF"
27 #define METHOD_ENUMERATE        "GGRP"
28 #define METHOD_READ             "GITM"
29 #define METHOD_WRITE            "SITM"
30 #define METHOD_OLD_READ_TMP     "RTMP"
31 #define METHOD_OLD_READ_VLT     "RVLT"
32 #define METHOD_OLD_READ_FAN     "RFAN"
33 #define METHOD_OLD_ENUM_TMP     "TSIF"
34 #define METHOD_OLD_ENUM_VLT     "VSIF"
35 #define METHOD_OLD_ENUM_FAN     "FSIF"
36
37 #define ATK_MUX_HWMON           0x00000006ULL
38
39 #define ATK_CLASS_MASK          0xff000000ULL
40 #define ATK_CLASS_FREQ_CTL      0x03000000ULL
41 #define ATK_CLASS_FAN_CTL       0x04000000ULL
42 #define ATK_CLASS_HWMON         0x06000000ULL
43
44 #define ATK_TYPE_MASK           0x00ff0000ULL
45 #define HWMON_TYPE_VOLT         0x00020000ULL
46 #define HWMON_TYPE_TEMP         0x00030000ULL
47 #define HWMON_TYPE_FAN          0x00040000ULL
48
49 #define HWMON_SENSOR_ID_MASK    0x0000ffffULL
50
51 enum atk_pack_member {
52         HWMON_PACK_FLAGS,
53         HWMON_PACK_NAME,
54         HWMON_PACK_LIMIT1,
55         HWMON_PACK_LIMIT2,
56         HWMON_PACK_ENABLE
57 };
58
59 /* New package format */
60 #define _HWMON_NEW_PACK_SIZE    7
61 #define _HWMON_NEW_PACK_FLAGS   0
62 #define _HWMON_NEW_PACK_NAME    1
63 #define _HWMON_NEW_PACK_UNK1    2
64 #define _HWMON_NEW_PACK_UNK2    3
65 #define _HWMON_NEW_PACK_LIMIT1  4
66 #define _HWMON_NEW_PACK_LIMIT2  5
67 #define _HWMON_NEW_PACK_ENABLE  6
68
69 /* Old package format */
70 #define _HWMON_OLD_PACK_SIZE    5
71 #define _HWMON_OLD_PACK_FLAGS   0
72 #define _HWMON_OLD_PACK_NAME    1
73 #define _HWMON_OLD_PACK_LIMIT1  2
74 #define _HWMON_OLD_PACK_LIMIT2  3
75 #define _HWMON_OLD_PACK_ENABLE  4
76
77
78 struct atk_data {
79         struct device *hwmon_dev;
80         acpi_handle atk_handle;
81         struct acpi_device *acpi_dev;
82
83         bool old_interface;
84
85         /* old interface */
86         acpi_handle rtmp_handle;
87         acpi_handle rvlt_handle;
88         acpi_handle rfan_handle;
89         /* new inteface */
90         acpi_handle enumerate_handle;
91         acpi_handle read_handle;
92
93         int voltage_count;
94         int temperature_count;
95         int fan_count;
96         struct list_head sensor_list;
97 };
98
99
100 typedef ssize_t (*sysfs_show_func)(struct device *dev,
101                         struct device_attribute *attr, char *buf);
102
103 static const struct acpi_device_id atk_ids[] = {
104         {ATK_HID, 0},
105         {"", 0},
106 };
107 MODULE_DEVICE_TABLE(acpi, atk_ids);
108
109 #define ATTR_NAME_SIZE 16 /* Worst case is "tempN_input" */
110
111 struct atk_sensor_data {
112         struct list_head list;
113         struct atk_data *data;
114         struct device_attribute label_attr;
115         struct device_attribute input_attr;
116         struct device_attribute limit1_attr;
117         struct device_attribute limit2_attr;
118         char label_attr_name[ATTR_NAME_SIZE];
119         char input_attr_name[ATTR_NAME_SIZE];
120         char limit1_attr_name[ATTR_NAME_SIZE];
121         char limit2_attr_name[ATTR_NAME_SIZE];
122         u64 id;
123         u64 type;
124         u64 limit1;
125         u64 limit2;
126         u64 cached_value;
127         unsigned long last_updated; /* in jiffies */
128         bool is_valid;
129         char const *acpi_name;
130 };
131
132 struct atk_acpi_buffer_u64 {
133         union acpi_object buf;
134         u64 value;
135 };
136
137 static int atk_add(struct acpi_device *device);
138 static int atk_remove(struct acpi_device *device, int type);
139 static void atk_print_sensor(struct atk_data *data, union acpi_object *obj);
140 static int atk_read_value(struct atk_sensor_data *sensor, u64 *value);
141 static void atk_free_sensors(struct atk_data *data);
142
143 static struct acpi_driver atk_driver = {
144         .name   = ATK_HID,
145         .class  = "hwmon",
146         .ids    = atk_ids,
147         .ops    = {
148                 .add    = atk_add,
149                 .remove = atk_remove,
150         },
151 };
152
153 #define input_to_atk_sensor(attr) \
154         container_of(attr, struct atk_sensor_data, input_attr)
155
156 #define label_to_atk_sensor(attr) \
157         container_of(attr, struct atk_sensor_data, label_attr)
158
159 #define limit1_to_atk_sensor(attr) \
160         container_of(attr, struct atk_sensor_data, limit1_attr)
161
162 #define limit2_to_atk_sensor(attr) \
163         container_of(attr, struct atk_sensor_data, limit2_attr)
164
165 static ssize_t atk_input_show(struct device *dev,
166                 struct device_attribute *attr, char *buf)
167 {
168         struct atk_sensor_data *s = input_to_atk_sensor(attr);
169         u64 value;
170         int err;
171
172         err = atk_read_value(s, &value);
173         if (err)
174                 return err;
175
176         if (s->type == HWMON_TYPE_TEMP)
177                 /* ACPI returns decidegree */
178                 value *= 100;
179
180         return sprintf(buf, "%llu\n", value);
181 }
182
183 static ssize_t atk_label_show(struct device *dev,
184                 struct device_attribute *attr, char *buf)
185 {
186         struct atk_sensor_data *s = label_to_atk_sensor(attr);
187
188         return sprintf(buf, "%s\n", s->acpi_name);
189 }
190
191 static ssize_t atk_limit1_show(struct device *dev,
192                 struct device_attribute *attr, char *buf)
193 {
194         struct atk_sensor_data *s = limit1_to_atk_sensor(attr);
195         u64 value = s->limit1;
196
197         if (s->type == HWMON_TYPE_TEMP)
198                 value *= 100;
199
200         return sprintf(buf, "%lld\n", value);
201 }
202
203 static ssize_t atk_limit2_show(struct device *dev,
204                 struct device_attribute *attr, char *buf)
205 {
206         struct atk_sensor_data *s = limit2_to_atk_sensor(attr);
207         u64 value = s->limit2;
208
209         if (s->type == HWMON_TYPE_TEMP)
210                 value *= 100;
211
212         return sprintf(buf, "%lld\n", value);
213 }
214
215 static ssize_t atk_name_show(struct device *dev,
216                                 struct device_attribute *attr, char *buf)
217 {
218         return sprintf(buf, "atk0110\n");
219 }
220 static struct device_attribute atk_name_attr =
221                 __ATTR(name, 0444, atk_name_show, NULL);
222
223 static void atk_init_attribute(struct device_attribute *attr, char *name,
224                 sysfs_show_func show)
225 {
226         attr->attr.name = name;
227         attr->attr.mode = 0444;
228         attr->show = show;
229         attr->store = NULL;
230 }
231
232
233 static union acpi_object *atk_get_pack_member(struct atk_data *data,
234                                                 union acpi_object *pack,
235                                                 enum atk_pack_member m)
236 {
237         bool old_if = data->old_interface;
238         int offset;
239
240         switch (m) {
241         case HWMON_PACK_FLAGS:
242                 offset = old_if ? _HWMON_OLD_PACK_FLAGS : _HWMON_NEW_PACK_FLAGS;
243                 break;
244         case HWMON_PACK_NAME:
245                 offset = old_if ? _HWMON_OLD_PACK_NAME : _HWMON_NEW_PACK_NAME;
246                 break;
247         case HWMON_PACK_LIMIT1:
248                 offset = old_if ? _HWMON_OLD_PACK_LIMIT1 :
249                                   _HWMON_NEW_PACK_LIMIT1;
250                 break;
251         case HWMON_PACK_LIMIT2:
252                 offset = old_if ? _HWMON_OLD_PACK_LIMIT2 :
253                                   _HWMON_NEW_PACK_LIMIT2;
254                 break;
255         case HWMON_PACK_ENABLE:
256                 offset = old_if ? _HWMON_OLD_PACK_ENABLE :
257                                   _HWMON_NEW_PACK_ENABLE;
258                 break;
259         default:
260                 return NULL;
261         }
262
263         return &pack->package.elements[offset];
264 }
265
266
267 /* New package format is:
268  * - flag (int)
269  *      class - used for de-muxing the request to the correct GITn
270  *      type (volt, temp, fan)
271  *      sensor id |
272  *      sensor id - used for de-muxing the request _inside_ the GITn
273  * - name (str)
274  * - unknown (int)
275  * - unknown (int)
276  * - limit1 (int)
277  * - limit2 (int)
278  * - enable (int)
279  *
280  * The old package has the same format but it's missing the two unknown fields.
281  */
282 static int validate_hwmon_pack(struct atk_data *data, union acpi_object *obj)
283 {
284         struct device *dev = &data->acpi_dev->dev;
285         union acpi_object *tmp;
286         bool old_if = data->old_interface;
287         int const expected_size = old_if ? _HWMON_OLD_PACK_SIZE :
288                                            _HWMON_NEW_PACK_SIZE;
289
290         if (obj->type != ACPI_TYPE_PACKAGE) {
291                 dev_warn(dev, "Invalid type: %d\n", obj->type);
292                 return -EINVAL;
293         }
294
295         if (obj->package.count != expected_size) {
296                 dev_warn(dev, "Invalid package size: %d, expected: %d\n",
297                                 obj->package.count, expected_size);
298                 return -EINVAL;
299         }
300
301         tmp = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
302         if (tmp->type != ACPI_TYPE_INTEGER) {
303                 dev_warn(dev, "Invalid type (flag): %d\n", tmp->type);
304                 return -EINVAL;
305         }
306
307         tmp = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
308         if (tmp->type != ACPI_TYPE_STRING) {
309                 dev_warn(dev, "Invalid type (name): %d\n", tmp->type);
310                 return -EINVAL;
311         }
312
313         /* Don't check... we don't know what they're useful for anyway */
314 #if 0
315         tmp = &obj->package.elements[HWMON_PACK_UNK1];
316         if (tmp->type != ACPI_TYPE_INTEGER) {
317                 dev_warn(dev, "Invalid type (unk1): %d\n", tmp->type);
318                 return -EINVAL;
319         }
320
321         tmp = &obj->package.elements[HWMON_PACK_UNK2];
322         if (tmp->type != ACPI_TYPE_INTEGER) {
323                 dev_warn(dev, "Invalid type (unk2): %d\n", tmp->type);
324                 return -EINVAL;
325         }
326 #endif
327
328         tmp = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
329         if (tmp->type != ACPI_TYPE_INTEGER) {
330                 dev_warn(dev, "Invalid type (limit1): %d\n", tmp->type);
331                 return -EINVAL;
332         }
333
334         tmp = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
335         if (tmp->type != ACPI_TYPE_INTEGER) {
336                 dev_warn(dev, "Invalid type (limit2): %d\n", tmp->type);
337                 return -EINVAL;
338         }
339
340         tmp = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
341         if (tmp->type != ACPI_TYPE_INTEGER) {
342                 dev_warn(dev, "Invalid type (enable): %d\n", tmp->type);
343                 return -EINVAL;
344         }
345
346         atk_print_sensor(data, obj);
347
348         return 0;
349 }
350
351 static char const *atk_sensor_type(union acpi_object *flags)
352 {
353         u64 type = flags->integer.value & ATK_TYPE_MASK;
354         char const *what;
355
356         switch (type) {
357         case HWMON_TYPE_VOLT:
358                 what = "voltage";
359                 break;
360         case HWMON_TYPE_TEMP:
361                 what = "temperature";
362                 break;
363         case HWMON_TYPE_FAN:
364                 what = "fan";
365                 break;
366         default:
367                 what = "unknown";
368                 break;
369         }
370
371         return what;
372 }
373
374 static void atk_print_sensor(struct atk_data *data, union acpi_object *obj)
375 {
376 #ifdef DEBUG
377         struct device *dev = &data->acpi_dev->dev;
378         union acpi_object *flags;
379         union acpi_object *name;
380         union acpi_object *limit1;
381         union acpi_object *limit2;
382         union acpi_object *enable;
383         char const *what;
384
385         flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
386         name = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
387         limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
388         limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
389         enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
390
391         what = atk_sensor_type(flags);
392
393         dev_dbg(dev, "%s: %#llx %s [%llu-%llu] %s\n", what,
394                         flags->integer.value,
395                         name->string.pointer,
396                         limit1->integer.value, limit2->integer.value,
397                         enable->integer.value ? "enabled" : "disabled");
398 #endif
399 }
400
401 static int atk_read_value_old(struct atk_sensor_data *sensor, u64 *value)
402 {
403         struct atk_data *data = sensor->data;
404         struct device *dev = &data->acpi_dev->dev;
405         struct acpi_object_list params;
406         union acpi_object id;
407         acpi_status status;
408         acpi_handle method;
409
410         switch (sensor->type) {
411         case HWMON_TYPE_VOLT:
412                 method = data->rvlt_handle;
413                 break;
414         case HWMON_TYPE_TEMP:
415                 method = data->rtmp_handle;
416                 break;
417         case HWMON_TYPE_FAN:
418                 method = data->rfan_handle;
419                 break;
420         default:
421                 return -EINVAL;
422         }
423
424         id.type = ACPI_TYPE_INTEGER;
425         id.integer.value = sensor->id;
426
427         params.count = 1;
428         params.pointer = &id;
429
430         status = acpi_evaluate_integer(method, NULL, &params, value);
431         if (status != AE_OK) {
432                 dev_warn(dev, "%s: ACPI exception: %s\n", __func__,
433                                 acpi_format_exception(status));
434                 return -EIO;
435         }
436
437         return 0;
438 }
439
440 static int atk_read_value_new(struct atk_sensor_data *sensor, u64 *value)
441 {
442         struct atk_data *data = sensor->data;
443         struct device *dev = &data->acpi_dev->dev;
444         struct acpi_object_list params;
445         struct acpi_buffer ret;
446         union acpi_object id;
447         struct atk_acpi_buffer_u64 tmp;
448         acpi_status status;
449
450         id.type = ACPI_TYPE_INTEGER;
451         id.integer.value = sensor->id;
452
453         params.count = 1;
454         params.pointer = &id;
455
456         tmp.buf.type = ACPI_TYPE_BUFFER;
457         tmp.buf.buffer.pointer = (u8 *)&tmp.value;
458         tmp.buf.buffer.length = sizeof(u64);
459         ret.length = sizeof(tmp);
460         ret.pointer = &tmp;
461
462         status = acpi_evaluate_object_typed(data->read_handle, NULL, &params,
463                         &ret, ACPI_TYPE_BUFFER);
464         if (status != AE_OK) {
465                 dev_warn(dev, "%s: ACPI exception: %s\n", __func__,
466                                 acpi_format_exception(status));
467                 return -EIO;
468         }
469
470         /* Return buffer format:
471          * [0-3] "value" is valid flag
472          * [4-7] value
473          */
474         if (!(tmp.value & 0xffffffff)) {
475                 /* The reading is not valid, possible causes:
476                  * - sensor failure
477                  * - enumeration was FUBAR (and we didn't notice)
478                  */
479                 dev_info(dev, "Failure: %#llx\n", tmp.value);
480                 return -EIO;
481         }
482
483         *value = (tmp.value & 0xffffffff00000000ULL) >> 32;
484
485         return 0;
486 }
487
488 static int atk_read_value(struct atk_sensor_data *sensor, u64 *value)
489 {
490         int err;
491
492         if (!sensor->is_valid ||
493             time_after(jiffies, sensor->last_updated + CACHE_TIME)) {
494                 if (sensor->data->old_interface)
495                         err = atk_read_value_old(sensor, value);
496                 else
497                         err = atk_read_value_new(sensor, value);
498
499                 sensor->is_valid = true;
500                 sensor->last_updated = jiffies;
501                 sensor->cached_value = *value;
502         } else {
503                 *value = sensor->cached_value;
504                 err = 0;
505         }
506
507         return err;
508 }
509
510 static int atk_add_sensor(struct atk_data *data, union acpi_object *obj)
511 {
512         struct device *dev = &data->acpi_dev->dev;
513         union acpi_object *flags;
514         union acpi_object *name;
515         union acpi_object *limit1;
516         union acpi_object *limit2;
517         union acpi_object *enable;
518         struct atk_sensor_data *sensor;
519         char const *base_name;
520         char const *limit1_name;
521         char const *limit2_name;
522         u64 type;
523         int err;
524         int *num;
525         int start;
526
527         if (obj->type != ACPI_TYPE_PACKAGE) {
528                 /* wft is this? */
529                 dev_warn(dev, "Unknown type for ACPI object: (%d)\n",
530                                 obj->type);
531                 return -EINVAL;
532         }
533
534         err = validate_hwmon_pack(data, obj);
535         if (err)
536                 return err;
537
538         /* Ok, we have a valid hwmon package */
539         type = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS)->integer.value
540                & ATK_TYPE_MASK;
541
542         switch (type) {
543         case HWMON_TYPE_VOLT:
544                 base_name = "in";
545                 limit1_name = "min";
546                 limit2_name = "max";
547                 num = &data->voltage_count;
548                 start = 0;
549                 break;
550         case HWMON_TYPE_TEMP:
551                 base_name = "temp";
552                 limit1_name = "max";
553                 limit2_name = "crit";
554                 num = &data->temperature_count;
555                 start = 1;
556                 break;
557         case HWMON_TYPE_FAN:
558                 base_name = "fan";
559                 limit1_name = "min";
560                 limit2_name = "max";
561                 num = &data->fan_count;
562                 start = 1;
563                 break;
564         default:
565                 dev_warn(dev, "Unknown sensor type: %#llx\n", type);
566                 return -EINVAL;
567         }
568
569         enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
570         if (!enable->integer.value)
571                 /* sensor is disabled */
572                 return 0;
573
574         flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
575         name = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
576         limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
577         limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
578
579         sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
580         if (!sensor)
581                 return -ENOMEM;
582
583         sensor->acpi_name = kstrdup(name->string.pointer, GFP_KERNEL);
584         if (!sensor->acpi_name) {
585                 err = -ENOMEM;
586                 goto out;
587         }
588
589         INIT_LIST_HEAD(&sensor->list);
590         sensor->type = type;
591         sensor->data = data;
592         sensor->id = flags->integer.value;
593         sensor->limit1 = limit1->integer.value;
594         sensor->limit2 = limit2->integer.value;
595
596         snprintf(sensor->input_attr_name, ATTR_NAME_SIZE,
597                         "%s%d_input", base_name, start + *num);
598         atk_init_attribute(&sensor->input_attr,
599                         sensor->input_attr_name,
600                         atk_input_show);
601
602         snprintf(sensor->label_attr_name, ATTR_NAME_SIZE,
603                         "%s%d_label", base_name, start + *num);
604         atk_init_attribute(&sensor->label_attr,
605                         sensor->label_attr_name,
606                         atk_label_show);
607
608         snprintf(sensor->limit1_attr_name, ATTR_NAME_SIZE,
609                         "%s%d_%s", base_name, start + *num, limit1_name);
610         atk_init_attribute(&sensor->limit1_attr,
611                         sensor->limit1_attr_name,
612                         atk_limit1_show);
613
614         snprintf(sensor->limit2_attr_name, ATTR_NAME_SIZE,
615                         "%s%d_%s", base_name, start + *num, limit2_name);
616         atk_init_attribute(&sensor->limit2_attr,
617                         sensor->limit2_attr_name,
618                         atk_limit2_show);
619
620         list_add(&sensor->list, &data->sensor_list);
621         (*num)++;
622
623         return 1;
624 out:
625         kfree(sensor->acpi_name);
626         kfree(sensor);
627         return err;
628 }
629
630 static int atk_enumerate_old_hwmon(struct atk_data *data)
631 {
632         struct device *dev = &data->acpi_dev->dev;
633         struct acpi_buffer buf;
634         union acpi_object *pack;
635         acpi_status status;
636         int i, ret;
637         int count = 0;
638
639         /* Voltages */
640         buf.length = ACPI_ALLOCATE_BUFFER;
641         status = acpi_evaluate_object_typed(data->atk_handle,
642                         METHOD_OLD_ENUM_VLT, NULL, &buf, ACPI_TYPE_PACKAGE);
643         if (status != AE_OK) {
644                 dev_warn(dev, METHOD_OLD_ENUM_VLT ": ACPI exception: %s\n",
645                                 acpi_format_exception(status));
646
647                 return -ENODEV;
648         }
649
650         pack = buf.pointer;
651         for (i = 1; i < pack->package.count; i++) {
652                 union acpi_object *obj = &pack->package.elements[i];
653
654                 ret = atk_add_sensor(data, obj);
655                 if (ret > 0)
656                         count++;
657         }
658         ACPI_FREE(buf.pointer);
659
660         /* Temperatures */
661         buf.length = ACPI_ALLOCATE_BUFFER;
662         status = acpi_evaluate_object_typed(data->atk_handle,
663                         METHOD_OLD_ENUM_TMP, NULL, &buf, ACPI_TYPE_PACKAGE);
664         if (status != AE_OK) {
665                 dev_warn(dev, METHOD_OLD_ENUM_TMP ": ACPI exception: %s\n",
666                                 acpi_format_exception(status));
667
668                 ret = -ENODEV;
669                 goto cleanup;
670         }
671
672         pack = buf.pointer;
673         for (i = 1; i < pack->package.count; i++) {
674                 union acpi_object *obj = &pack->package.elements[i];
675
676                 ret = atk_add_sensor(data, obj);
677                 if (ret > 0)
678                         count++;
679         }
680         ACPI_FREE(buf.pointer);
681
682         /* Fans */
683         buf.length = ACPI_ALLOCATE_BUFFER;
684         status = acpi_evaluate_object_typed(data->atk_handle,
685                         METHOD_OLD_ENUM_FAN, NULL, &buf, ACPI_TYPE_PACKAGE);
686         if (status != AE_OK) {
687                 dev_warn(dev, METHOD_OLD_ENUM_FAN ": ACPI exception: %s\n",
688                                 acpi_format_exception(status));
689
690                 ret = -ENODEV;
691                 goto cleanup;
692         }
693
694         pack = buf.pointer;
695         for (i = 1; i < pack->package.count; i++) {
696                 union acpi_object *obj = &pack->package.elements[i];
697
698                 ret = atk_add_sensor(data, obj);
699                 if (ret > 0)
700                         count++;
701         }
702         ACPI_FREE(buf.pointer);
703
704         return count;
705 cleanup:
706         atk_free_sensors(data);
707         return ret;
708 }
709
710 static int atk_enumerate_new_hwmon(struct atk_data *data)
711 {
712         struct device *dev = &data->acpi_dev->dev;
713         struct acpi_buffer buf;
714         acpi_status ret;
715         struct acpi_object_list params;
716         union acpi_object id;
717         union acpi_object *pack;
718         int err;
719         int i;
720
721         dev_dbg(dev, "Enumerating hwmon sensors\n");
722
723         id.type = ACPI_TYPE_INTEGER;
724         id.integer.value = ATK_MUX_HWMON;
725         params.count = 1;
726         params.pointer = &id;
727
728         buf.length = ACPI_ALLOCATE_BUFFER;
729         ret = acpi_evaluate_object_typed(data->enumerate_handle, NULL, &params,
730                         &buf, ACPI_TYPE_PACKAGE);
731         if (ret != AE_OK) {
732                 dev_warn(dev, METHOD_ENUMERATE ": ACPI exception: %s\n",
733                                 acpi_format_exception(ret));
734                 return -ENODEV;
735         }
736
737         /* Result must be a package */
738         pack = buf.pointer;
739
740         if (pack->package.count < 1) {
741                 dev_dbg(dev, "%s: hwmon package is too small: %d\n", __func__,
742                                 pack->package.count);
743                 err = -EINVAL;
744                 goto out;
745         }
746
747         for (i = 0; i < pack->package.count; i++) {
748                 union acpi_object *obj = &pack->package.elements[i];
749
750                 atk_add_sensor(data, obj);
751         }
752
753         err = data->voltage_count + data->temperature_count + data->fan_count;
754
755 out:
756         ACPI_FREE(buf.pointer);
757         return err;
758 }
759
760 static int atk_create_files(struct atk_data *data)
761 {
762         struct atk_sensor_data *s;
763         int err;
764
765         list_for_each_entry(s, &data->sensor_list, list) {
766                 err = device_create_file(data->hwmon_dev, &s->input_attr);
767                 if (err)
768                         return err;
769                 err = device_create_file(data->hwmon_dev, &s->label_attr);
770                 if (err)
771                         return err;
772                 err = device_create_file(data->hwmon_dev, &s->limit1_attr);
773                 if (err)
774                         return err;
775                 err = device_create_file(data->hwmon_dev, &s->limit2_attr);
776                 if (err)
777                         return err;
778         }
779
780         err = device_create_file(data->hwmon_dev, &atk_name_attr);
781
782         return err;
783 }
784
785 static void atk_remove_files(struct atk_data *data)
786 {
787         struct atk_sensor_data *s;
788
789         list_for_each_entry(s, &data->sensor_list, list) {
790                 device_remove_file(data->hwmon_dev, &s->input_attr);
791                 device_remove_file(data->hwmon_dev, &s->label_attr);
792                 device_remove_file(data->hwmon_dev, &s->limit1_attr);
793                 device_remove_file(data->hwmon_dev, &s->limit2_attr);
794         }
795         device_remove_file(data->hwmon_dev, &atk_name_attr);
796 }
797
798 static void atk_free_sensors(struct atk_data *data)
799 {
800         struct list_head *head = &data->sensor_list;
801         struct atk_sensor_data *s, *tmp;
802
803         list_for_each_entry_safe(s, tmp, head, list) {
804                 kfree(s->acpi_name);
805                 kfree(s);
806         }
807 }
808
809 static int atk_register_hwmon(struct atk_data *data)
810 {
811         struct device *dev = &data->acpi_dev->dev;
812         int err;
813
814         dev_dbg(dev, "registering hwmon device\n");
815         data->hwmon_dev = hwmon_device_register(dev);
816         if (IS_ERR(data->hwmon_dev))
817                 return PTR_ERR(data->hwmon_dev);
818
819         dev_dbg(dev, "populating sysfs directory\n");
820         err = atk_create_files(data);
821         if (err)
822                 goto remove;
823
824         return 0;
825 remove:
826         /* Cleanup the registered files */
827         atk_remove_files(data);
828         hwmon_device_unregister(data->hwmon_dev);
829         return err;
830 }
831
832 static int atk_check_old_if(struct atk_data *data)
833 {
834         struct device *dev = &data->acpi_dev->dev;
835         acpi_handle ret;
836         acpi_status status;
837
838         /* RTMP: read temperature */
839         status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_TMP, &ret);
840         if (status != AE_OK) {
841                 dev_dbg(dev, "method " METHOD_OLD_READ_TMP " not found: %s\n",
842                                 acpi_format_exception(status));
843                 return -ENODEV;
844         }
845         data->rtmp_handle = ret;
846
847         /* RVLT: read voltage */
848         status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_VLT, &ret);
849         if (status != AE_OK) {
850                 dev_dbg(dev, "method " METHOD_OLD_READ_VLT " not found: %s\n",
851                                 acpi_format_exception(status));
852                 return -ENODEV;
853         }
854         data->rvlt_handle = ret;
855
856         /* RFAN: read fan status */
857         status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_FAN, &ret);
858         if (status != AE_OK) {
859                 dev_dbg(dev, "method " METHOD_OLD_READ_FAN " not found: %s\n",
860                                 acpi_format_exception(status));
861                 return -ENODEV;
862         }
863         data->rfan_handle = ret;
864
865         return 0;
866 }
867
868 static int atk_check_new_if(struct atk_data *data)
869 {
870         struct device *dev = &data->acpi_dev->dev;
871         acpi_handle ret;
872         acpi_status status;
873
874         /* Enumeration */
875         status = acpi_get_handle(data->atk_handle, METHOD_ENUMERATE, &ret);
876         if (status != AE_OK) {
877                 dev_dbg(dev, "method " METHOD_ENUMERATE " not found: %s\n",
878                                 acpi_format_exception(status));
879                 return -ENODEV;
880         }
881         data->enumerate_handle = ret;
882
883         /* De-multiplexer (read) */
884         status = acpi_get_handle(data->atk_handle, METHOD_READ, &ret);
885         if (status != AE_OK) {
886                 dev_dbg(dev, "method " METHOD_READ " not found: %s\n",
887                                 acpi_format_exception(status));
888                 return -ENODEV;
889         }
890         data->read_handle = ret;
891
892         return 0;
893 }
894
895 static int atk_add(struct acpi_device *device)
896 {
897         acpi_status ret;
898         int err;
899         struct acpi_buffer buf;
900         union acpi_object *obj;
901         struct atk_data *data;
902
903         dev_dbg(&device->dev, "adding...\n");
904
905         data = kzalloc(sizeof(*data), GFP_KERNEL);
906         if (!data)
907                 return -ENOMEM;
908
909         data->acpi_dev = device;
910         data->atk_handle = device->handle;
911         INIT_LIST_HEAD(&data->sensor_list);
912
913         buf.length = ACPI_ALLOCATE_BUFFER;
914         ret = acpi_evaluate_object_typed(data->atk_handle, BOARD_ID, NULL,
915                         &buf, ACPI_TYPE_PACKAGE);
916         if (ret != AE_OK) {
917                 dev_dbg(&device->dev, "atk: method MBIF not found\n");
918                 err = -ENODEV;
919                 goto out;
920         }
921
922         obj = buf.pointer;
923         if (obj->package.count >= 2 &&
924                         obj->package.elements[1].type == ACPI_TYPE_STRING) {
925                 dev_dbg(&device->dev, "board ID = %s\n",
926                                 obj->package.elements[1].string.pointer);
927         }
928         ACPI_FREE(buf.pointer);
929
930         /* Check for hwmon methods: first check "old" style methods; note that
931          * both may be present: in this case we stick to the old interface;
932          * analysis of multiple DSDTs indicates that when both interfaces
933          * are present the new one (GGRP/GITM) is not functional.
934          */
935         err = atk_check_old_if(data);
936         if (!err) {
937                 dev_dbg(&device->dev, "Using old hwmon interface\n");
938                 data->old_interface = true;
939         } else {
940                 err = atk_check_new_if(data);
941                 if (err)
942                         goto out;
943
944                 dev_dbg(&device->dev, "Using new hwmon interface\n");
945                 data->old_interface = false;
946         }
947
948         if (data->old_interface)
949                 err = atk_enumerate_old_hwmon(data);
950         else
951                 err = atk_enumerate_new_hwmon(data);
952         if (err < 0)
953                 goto out;
954         if (err == 0) {
955                 dev_info(&device->dev,
956                          "No usable sensor detected, bailing out\n");
957                 err = -ENODEV;
958                 goto out;
959         }
960
961         err = atk_register_hwmon(data);
962         if (err)
963                 goto cleanup;
964
965         device->driver_data = data;
966         return 0;
967 cleanup:
968         atk_free_sensors(data);
969 out:
970         kfree(data);
971         return err;
972 }
973
974 static int atk_remove(struct acpi_device *device, int type)
975 {
976         struct atk_data *data = device->driver_data;
977         dev_dbg(&device->dev, "removing...\n");
978
979         device->driver_data = NULL;
980
981         atk_remove_files(data);
982         atk_free_sensors(data);
983         hwmon_device_unregister(data->hwmon_dev);
984
985         kfree(data);
986
987         return 0;
988 }
989
990 static int __init atk0110_init(void)
991 {
992         int ret;
993
994         ret = acpi_bus_register_driver(&atk_driver);
995         if (ret)
996                 pr_info("atk: acpi_bus_register_driver failed: %d\n", ret);
997
998         return ret;
999 }
1000
1001 static void __exit atk0110_exit(void)
1002 {
1003         acpi_bus_unregister_driver(&atk_driver);
1004 }
1005
1006 module_init(atk0110_init);
1007 module_exit(atk0110_exit);
1008
1009 MODULE_LICENSE("GPL");