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