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