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         return err;
 678 }
 679
 680 DEFINE_SIMPLE_ATTRIBUTE(atk_debugfs_gitm,
 681                         atk_debugfs_gitm_get,
 682                         NULL,
 683                         "0x%08llx\n")
 684
 685 static int atk_acpi_print(char *buf, size_t sz, union acpi_object *obj)
 686 {
 687         int ret = 0;
 688
 689         switch (obj->type) {
 690         case ACPI_TYPE_INTEGER:
 691                 ret = snprintf(buf, sz, "0x%08llx\n", obj->integer.value);
 692                 break;
 693         case ACPI_TYPE_STRING:
 694                 ret = snprintf(buf, sz, "%s\n", obj->string.pointer);
 695                 break;
 696         }
 697
 698         return ret;
 699 }
 700
 701 static void atk_pack_print(char *buf, size_t sz, union acpi_object *pack)
 702 {
 703         int ret;
 704         int i;
 705
 706         for (i = 0; i < pack->package.count; i++) {
 707                 union acpi_object *obj = &pack->package.elements[i];
 708
 709                 ret = atk_acpi_print(buf, sz, obj);
 710                 if (ret >= sz)
 711                         break;
 712                 buf += ret;
 713                 sz -= ret;
 714         }
 715 }
 716
 717 static int atk_debugfs_ggrp_open(struct inode *inode, struct file *file)
 718 {
 719         struct atk_data *data = inode->i_private;
 720         char *buf = NULL;
 721         union acpi_object *ret;
 722         u8 cls;
 723         int i;
 724
 725         if (!data->enumerate_handle)
 726                 return -ENODEV;
 727         if (!data->debugfs.id)
 728                 return -EINVAL;
 729
 730         cls = (data->debugfs.id & 0xff000000) >> 24;
 731         ret = atk_ggrp(data, cls);
 732         if (IS_ERR(ret))
 733                 return PTR_ERR(ret);
 734
 735         for (i = 0; i < ret->package.count; i++) {
 736                 union acpi_object *pack = &ret->package.elements[i];
 737                 union acpi_object *id;
 738
 739                 if (pack->type != ACPI_TYPE_PACKAGE)
 740                         continue;
 741                 if (!pack->package.count)
 742                         continue;
 743                 id = &pack->package.elements[0];
 744                 if (id->integer.value == data->debugfs.id) {
 745                         /* Print the package */
 746                         buf = kzalloc(512, GFP_KERNEL);
 747                         if (!buf) {
 748                                 ACPI_FREE(ret);
 749                                 return -ENOMEM;
 750                         }
 751                         atk_pack_print(buf, 512, pack);
 752                         break;
 753                 }
 754         }
 755         ACPI_FREE(ret);
 756
 757         if (!buf)
 758                 return -EINVAL;
 759
 760         file->private_data = buf;
 761
 762         return nonseekable_open(inode, file);
 763 }
 764
 765 static ssize_t atk_debugfs_ggrp_read(struct file *file, char __user *buf,
 766                 size_t count, loff_t *pos)
 767 {
 768         char *str = file->private_data;
 769         size_t len = strlen(str);
 770
 771         return simple_read_from_buffer(buf, count, pos, str, len);
 772 }
 773
 774 static int atk_debugfs_ggrp_release(struct inode *inode, struct file *file)
 775 {
 776         kfree(file->private_data);
 777         return 0;
 778 }
 779
 780 static const struct file_operations atk_debugfs_ggrp_fops = {
 781         .read           = atk_debugfs_ggrp_read,
 782         .open           = atk_debugfs_ggrp_open,
 783         .release        = atk_debugfs_ggrp_release,
 784         .llseek         = no_llseek,
 785 };
 786
 787 static void atk_debugfs_init(struct atk_data *data)
 788 {
 789         struct dentry *d;
 790         struct dentry *f;
 791
 792         data->debugfs.id = 0;
 793
 794         d = debugfs_create_dir("asus_atk0110", NULL);
 795         if (!d || IS_ERR(d))
 796                 return;
 797
 798         f = debugfs_create_x32("id", S_IRUSR | S_IWUSR, d, &data->debugfs.id);
 799         if (!f || IS_ERR(f))
 800                 goto cleanup;
 801
 802         f = debugfs_create_file("gitm", S_IRUSR, d, data,
 803                         &atk_debugfs_gitm);
 804         if (!f || IS_ERR(f))
 805                 goto cleanup;
 806
 807         f = debugfs_create_file("ggrp", S_IRUSR, d, data,
 808                         &atk_debugfs_ggrp_fops);
 809         if (!f || IS_ERR(f))
 810                 goto cleanup;
 811
 812         data->debugfs.root = d;
 813
 814         return;
 815 cleanup:
 816         debugfs_remove_recursive(d);
 817 }
 818
 819 static void atk_debugfs_cleanup(struct atk_data *data)
 820 {
 821         debugfs_remove_recursive(data->debugfs.root);
 822 }
 823
 824 #else /* CONFIG_DEBUG_FS */
 825
 826 static void atk_debugfs_init(struct atk_data *data)
 827 {
 828 }
 829
 830 static void atk_debugfs_cleanup(struct atk_data *data)
 831 {
 832 }
 833 #endif
 834
 835 static int atk_add_sensor(struct atk_data *data, union acpi_object *obj)
 836 {
 837         struct device *dev = &data->acpi_dev->dev;
 838         union acpi_object *flags;
 839         union acpi_object *name;
 840         union acpi_object *limit1;
 841         union acpi_object *limit2;
 842         union acpi_object *enable;
 843         struct atk_sensor_data *sensor;
 844         char const *base_name;
 845         char const *limit1_name;
 846         char const *limit2_name;
 847         u64 type;
 848         int err;
 849         int *num;
 850         int start;
 851
 852         if (obj->type != ACPI_TYPE_PACKAGE) {
 853                 /* wft is this? */
 854                 dev_warn(dev, "Unknown type for ACPI object: (%d)\n",
 855                                 obj->type);
 856                 return -EINVAL;
 857         }
 858
 859         err = validate_hwmon_pack(data, obj);
 860         if (err)
 861                 return err;
 862
 863         /* Ok, we have a valid hwmon package */
 864         type = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS)->integer.value
 865                & ATK_TYPE_MASK;
 866
 867         switch (type) {
 868         case HWMON_TYPE_VOLT:
 869                 base_name = "in";
 870                 limit1_name = "min";
 871                 limit2_name = "max";
 872                 num = &data->voltage_count;
 873                 start = 0;
 874                 break;
 875         case HWMON_TYPE_TEMP:
 876                 base_name = "temp";
 877                 limit1_name = "max";
 878                 limit2_name = "crit";
 879                 num = &data->temperature_count;
 880                 start = 1;
 881                 break;
 882         case HWMON_TYPE_FAN:
 883                 base_name = "fan";
 884                 limit1_name = "min";
 885                 limit2_name = "max";
 886                 num = &data->fan_count;
 887                 start = 1;
 888                 break;
 889         default:
 890                 dev_warn(dev, "Unknown sensor type: %#llx\n", type);
 891                 return -EINVAL;
 892         }
 893
 894         enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
 895         if (!enable->integer.value)
 896                 /* sensor is disabled */
 897                 return 0;
 898
 899         flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
 900         name = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
 901         limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
 902         limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
 903
 904         sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
 905         if (!sensor)
 906                 return -ENOMEM;
 907
 908         sensor->acpi_name = kstrdup(name->string.pointer, GFP_KERNEL);
 909         if (!sensor->acpi_name) {
 910                 err = -ENOMEM;
 911                 goto out;
 912         }
 913
 914         INIT_LIST_HEAD(&sensor->list);
 915         sensor->type = type;
 916         sensor->data = data;
 917         sensor->id = flags->integer.value;
 918         sensor->limit1 = limit1->integer.value;
 919         if (data->old_interface)
 920                 sensor->limit2 = limit2->integer.value;
 921         else
 922                 /* The upper limit is expressed as delta from lower limit */
 923                 sensor->limit2 = sensor->limit1 + limit2->integer.value;
 924
 925         snprintf(sensor->input_attr_name, ATTR_NAME_SIZE,
 926                         "%s%d_input", base_name, start + *num);
 927         atk_init_attribute(&sensor->input_attr,
 928                         sensor->input_attr_name,
 929                         atk_input_show);
 930
 931         snprintf(sensor->label_attr_name, ATTR_NAME_SIZE,
 932                         "%s%d_label", base_name, start + *num);
 933         atk_init_attribute(&sensor->label_attr,
 934                         sensor->label_attr_name,
 935                         atk_label_show);
 936
 937         snprintf(sensor->limit1_attr_name, ATTR_NAME_SIZE,
 938                         "%s%d_%s", base_name, start + *num, limit1_name);
 939         atk_init_attribute(&sensor->limit1_attr,
 940                         sensor->limit1_attr_name,
 941                         atk_limit1_show);
 942
 943         snprintf(sensor->limit2_attr_name, ATTR_NAME_SIZE,
 944                         "%s%d_%s", base_name, start + *num, limit2_name);
 945         atk_init_attribute(&sensor->limit2_attr,
 946                         sensor->limit2_attr_name,
 947                         atk_limit2_show);
 948
 949         list_add(&sensor->list, &data->sensor_list);
 950         (*num)++;
 951
 952         return 1;
 953 out:
 954         kfree(sensor->acpi_name);
 955         kfree(sensor);
 956         return err;
 957 }
 958
 959 static int atk_enumerate_old_hwmon(struct atk_data *data)
 960 {
 961         struct device *dev = &data->acpi_dev->dev;
 962         struct acpi_buffer buf;
 963         union acpi_object *pack;
 964         acpi_status status;
 965         int i, ret;
 966         int count = 0;
 967
 968         /* Voltages */
 969         buf.length = ACPI_ALLOCATE_BUFFER;
 970         status = acpi_evaluate_object_typed(data->atk_handle,
 971                         METHOD_OLD_ENUM_VLT, NULL, &buf, ACPI_TYPE_PACKAGE);
 972         if (status != AE_OK) {
 973                 dev_warn(dev, METHOD_OLD_ENUM_VLT ": ACPI exception: %s\n",
 974                                 acpi_format_exception(status));
 975
 976                 return -ENODEV;
 977         }
 978
 979         pack = buf.pointer;
 980         for (i = 1; i < pack->package.count; i++) {
 981                 union acpi_object *obj = &pack->package.elements[i];
 982
 983                 ret = atk_add_sensor(data, obj);
 984                 if (ret > 0)
 985                         count++;
 986         }
 987         ACPI_FREE(buf.pointer);
 988
 989         /* Temperatures */
 990         buf.length = ACPI_ALLOCATE_BUFFER;
 991         status = acpi_evaluate_object_typed(data->atk_handle,
 992                         METHOD_OLD_ENUM_TMP, NULL, &buf, ACPI_TYPE_PACKAGE);
 993         if (status != AE_OK) {
 994                 dev_warn(dev, METHOD_OLD_ENUM_TMP ": ACPI exception: %s\n",
 995                                 acpi_format_exception(status));
 996
 997                 ret = -ENODEV;
 998                 goto cleanup;
 999         }
1000
1001         pack = buf.pointer;
1002         for (i = 1; i < pack->package.count; i++) {
1003                 union acpi_object *obj = &pack->package.elements[i];
1004
1005                 ret = atk_add_sensor(data, obj);
1006                 if (ret > 0)
1007                         count++;
1008         }
1009         ACPI_FREE(buf.pointer);
1010
1011         /* Fans */
1012         buf.length = ACPI_ALLOCATE_BUFFER;
1013         status = acpi_evaluate_object_typed(data->atk_handle,
1014                         METHOD_OLD_ENUM_FAN, NULL, &buf, ACPI_TYPE_PACKAGE);
1015         if (status != AE_OK) {
1016                 dev_warn(dev, METHOD_OLD_ENUM_FAN ": ACPI exception: %s\n",
1017                                 acpi_format_exception(status));
1018
1019                 ret = -ENODEV;
1020                 goto cleanup;
1021         }
1022
1023         pack = buf.pointer;
1024         for (i = 1; i < pack->package.count; i++) {
1025                 union acpi_object *obj = &pack->package.elements[i];
1026
1027                 ret = atk_add_sensor(data, obj);
1028                 if (ret > 0)
1029                         count++;
1030         }
1031         ACPI_FREE(buf.pointer);
1032
1033         return count;
1034 cleanup:
1035         atk_free_sensors(data);
1036         return ret;
1037 }
1038
1039 static int atk_ec_present(struct atk_data *data)
1040 {
1041         struct device *dev = &data->acpi_dev->dev;
1042         union acpi_object *pack;
1043         union acpi_object *ec;
1044         int ret;
1045         int i;
1046
1047         pack = atk_ggrp(data, ATK_MUX_MGMT);
1048         if (IS_ERR(pack)) {
1049                 if (PTR_ERR(pack) == -ENOENT) {
1050                         /* The MGMT class does not exists - that's ok */
1051                         dev_dbg(dev, "Class %#llx not found\n", ATK_MUX_MGMT);
1052                         return 0;
1053                 }
1054                 return PTR_ERR(pack);
1055         }
1056
1057         /* Search the EC */
1058         ec = NULL;
1059         for (i = 0; i < pack->package.count; i++) {
1060                 union acpi_object *obj = &pack->package.elements[i];
1061                 union acpi_object *id;
1062
1063                 if (obj->type != ACPI_TYPE_PACKAGE)
1064                         continue;
1065
1066                 id = &obj->package.elements[0];
1067                 if (id->type != ACPI_TYPE_INTEGER)
1068                         continue;
1069
1070                 if (id->integer.value == ATK_EC_ID) {
1071                         ec = obj;
1072                         break;
1073                 }
1074         }
1075
1076         ret = (ec != NULL);
1077         if (!ret)
1078                 /* The system has no EC */
1079                 dev_dbg(dev, "EC not found\n");
1080
1081         ACPI_FREE(pack);
1082         return ret;
1083 }
1084
1085 static int atk_ec_enabled(struct atk_data *data)
1086 {
1087         struct device *dev = &data->acpi_dev->dev;
1088         union acpi_object *obj;
1089         struct atk_acpi_ret_buffer *buf;
1090         int err;
1091
1092         obj = atk_gitm(data, ATK_EC_ID);
1093         if (IS_ERR(obj)) {
1094                 dev_err(dev, "Unable to query EC status\n");
1095                 return PTR_ERR(obj);
1096         }
1097         buf = (struct atk_acpi_ret_buffer *)obj->buffer.pointer;
1098
1099         if (buf->flags == 0) {
1100                 dev_err(dev, "Unable to query EC status\n");
1101                 err = -EIO;
1102         } else {
1103                 err = (buf->value != 0);
1104                 dev_dbg(dev, "EC is %sabled\n",
1105                                 err ? "en" : "dis");
1106         }
1107
1108         ACPI_FREE(obj);
1109         return err;
1110 }
1111
1112 static int atk_ec_ctl(struct atk_data *data, int enable)
1113 {
1114         struct device *dev = &data->acpi_dev->dev;
1115         union acpi_object *obj;
1116         struct atk_acpi_input_buf sitm;
1117         struct atk_acpi_ret_buffer *ec_ret;
1118         int err = 0;
1119
1120         sitm.id = ATK_EC_ID;
1121         sitm.param1 = enable;
1122         sitm.param2 = 0;
1123
1124         obj = atk_sitm(data, &sitm);
1125         if (IS_ERR(obj)) {
1126                 dev_err(dev, "Failed to %sable the EC\n",
1127                                 enable ? "en" : "dis");
1128                 return PTR_ERR(obj);
1129         }
1130         ec_ret = (struct atk_acpi_ret_buffer *)obj->buffer.pointer;
1131         if (ec_ret->flags == 0) {
1132                 dev_err(dev, "Failed to %sable the EC\n",
1133                                 enable ? "en" : "dis");
1134                 err = -EIO;
1135         } else {
1136                 dev_info(dev, "EC %sabled\n",
1137                                 enable ? "en" : "dis");
1138         }
1139
1140         ACPI_FREE(obj);
1141         return err;
1142 }
1143
1144 static int atk_enumerate_new_hwmon(struct atk_data *data)
1145 {
1146         struct device *dev = &data->acpi_dev->dev;
1147         union acpi_object *pack;
1148         int err;
1149         int i;
1150
1151         err = atk_ec_present(data);
1152         if (err < 0)
1153                 return err;
1154         if (err) {
1155                 err = atk_ec_enabled(data);
1156                 if (err < 0)
1157                         return err;
1158                 /* If the EC was disabled we will disable it again on unload */
1159                 data->disable_ec = err;
1160
1161                 err = atk_ec_ctl(data, 1);
1162                 if (err) {
1163                         data->disable_ec = false;
1164                         return err;
1165                 }
1166         }
1167
1168         dev_dbg(dev, "Enumerating hwmon sensors\n");
1169
1170         pack = atk_ggrp(data, ATK_MUX_HWMON);
1171         if (IS_ERR(pack))
1172                 return PTR_ERR(pack);
1173
1174         for (i = 0; i < pack->package.count; i++) {
1175                 union acpi_object *obj = &pack->package.elements[i];
1176
1177                 atk_add_sensor(data, obj);
1178         }
1179
1180         err = data->voltage_count + data->temperature_count + data->fan_count;
1181
1182         ACPI_FREE(pack);
1183         return err;
1184 }
1185
1186 static int atk_create_files(struct atk_data *data)
1187 {
1188         struct atk_sensor_data *s;
1189         int err;
1190
1191         list_for_each_entry(s, &data->sensor_list, list) {
1192                 err = device_create_file(data->hwmon_dev, &s->input_attr);
1193                 if (err)
1194                         return err;
1195                 err = device_create_file(data->hwmon_dev, &s->label_attr);
1196                 if (err)
1197                         return err;
1198                 err = device_create_file(data->hwmon_dev, &s->limit1_attr);
1199                 if (err)
1200                         return err;
1201                 err = device_create_file(data->hwmon_dev, &s->limit2_attr);
1202                 if (err)
1203                         return err;
1204         }
1205
1206         err = device_create_file(data->hwmon_dev, &atk_name_attr);
1207
1208         return err;
1209 }
1210
1211 static void atk_remove_files(struct atk_data *data)
1212 {
1213         struct atk_sensor_data *s;
1214
1215         list_for_each_entry(s, &data->sensor_list, list) {
1216                 device_remove_file(data->hwmon_dev, &s->input_attr);
1217                 device_remove_file(data->hwmon_dev, &s->label_attr);
1218                 device_remove_file(data->hwmon_dev, &s->limit1_attr);
1219                 device_remove_file(data->hwmon_dev, &s->limit2_attr);
1220         }
1221         device_remove_file(data->hwmon_dev, &atk_name_attr);
1222 }
1223
1224 static void atk_free_sensors(struct atk_data *data)
1225 {
1226         struct list_head *head = &data->sensor_list;
1227         struct atk_sensor_data *s, *tmp;
1228
1229         list_for_each_entry_safe(s, tmp, head, list) {
1230                 kfree(s->acpi_name);
1231                 kfree(s);
1232         }
1233 }
1234
1235 static int atk_register_hwmon(struct atk_data *data)
1236 {
1237         struct device *dev = &data->acpi_dev->dev;
1238         int err;
1239
1240         dev_dbg(dev, "registering hwmon device\n");
1241         data->hwmon_dev = hwmon_device_register(dev);
1242         if (IS_ERR(data->hwmon_dev))
1243                 return PTR_ERR(data->hwmon_dev);
1244
1245         dev_dbg(dev, "populating sysfs directory\n");
1246         err = atk_create_files(data);
1247         if (err)
1248                 goto remove;
1249
1250         return 0;
1251 remove:
1252         /* Cleanup the registered files */
1253         atk_remove_files(data);
1254         hwmon_device_unregister(data->hwmon_dev);
1255         return err;
1256 }
1257
1258 static int atk_probe_if(struct atk_data *data)
1259 {
1260         struct device *dev = &data->acpi_dev->dev;
1261         acpi_handle ret;
1262         acpi_status status;
1263         int err = 0;
1264
1265         /* RTMP: read temperature */
1266         status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_TMP, &ret);
1267         if (ACPI_SUCCESS(status))
1268                 data->rtmp_handle = ret;
1269         else
1270                 dev_dbg(dev, "method " METHOD_OLD_READ_TMP " not found: %s\n",
1271                                 acpi_format_exception(status));
1272
1273         /* RVLT: read voltage */
1274         status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_VLT, &ret);
1275         if (ACPI_SUCCESS(status))
1276                 data->rvlt_handle = ret;
1277         else
1278                 dev_dbg(dev, "method " METHOD_OLD_READ_VLT " not found: %s\n",
1279                                 acpi_format_exception(status));
1280
1281         /* RFAN: read fan status */
1282         status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_FAN, &ret);
1283         if (ACPI_SUCCESS(status))
1284                 data->rfan_handle = ret;
1285         else
1286                 dev_dbg(dev, "method " METHOD_OLD_READ_FAN " not found: %s\n",
1287                                 acpi_format_exception(status));
1288
1289         /* Enumeration */
1290         status = acpi_get_handle(data->atk_handle, METHOD_ENUMERATE, &ret);
1291         if (ACPI_SUCCESS(status))
1292                 data->enumerate_handle = ret;
1293         else
1294                 dev_dbg(dev, "method " METHOD_ENUMERATE " not found: %s\n",
1295                                 acpi_format_exception(status));
1296
1297         /* De-multiplexer (read) */
1298         status = acpi_get_handle(data->atk_handle, METHOD_READ, &ret);
1299         if (ACPI_SUCCESS(status))
1300                 data->read_handle = ret;
1301         else
1302                 dev_dbg(dev, "method " METHOD_READ " not found: %s\n",
1303                                 acpi_format_exception(status));
1304
1305         /* De-multiplexer (write) */
1306         status = acpi_get_handle(data->atk_handle, METHOD_WRITE, &ret);
1307         if (ACPI_SUCCESS(status))
1308                 data->write_handle = ret;
1309         else
1310                 dev_dbg(dev, "method " METHOD_WRITE " not found: %s\n",
1311                                  acpi_format_exception(status));
1312
1313         /* Check for hwmon methods: first check "old" style methods; note that
1314          * both may be present: in this case we stick to the old interface;
1315          * analysis of multiple DSDTs indicates that when both interfaces
1316          * are present the new one (GGRP/GITM) is not functional.
1317          */
1318         if (new_if)
1319                 dev_info(dev, "Overriding interface detection\n");
1320         if (data->rtmp_handle && data->rvlt_handle && data->rfan_handle && !new_if)
1321                 data->old_interface = true;
1322         else if (data->enumerate_handle && data->read_handle &&
1323                         data->write_handle)
1324                 data->old_interface = false;
1325         else
1326                 err = -ENODEV;
1327
1328         return err;
1329 }
1330
1331 static int atk_add(struct acpi_device *device)
1332 {
1333         acpi_status ret;
1334         int err;
1335         struct acpi_buffer buf;
1336         union acpi_object *obj;
1337         struct atk_data *data;
1338
1339         dev_dbg(&device->dev, "adding...\n");
1340
1341         data = kzalloc(sizeof(*data), GFP_KERNEL);
1342         if (!data)
1343                 return -ENOMEM;
1344
1345         data->acpi_dev = device;
1346         data->atk_handle = device->handle;
1347         INIT_LIST_HEAD(&data->sensor_list);
1348         data->disable_ec = false;
1349
1350         buf.length = ACPI_ALLOCATE_BUFFER;
1351         ret = acpi_evaluate_object_typed(data->atk_handle, BOARD_ID, NULL,
1352                         &buf, ACPI_TYPE_PACKAGE);
1353         if (ret != AE_OK) {
1354                 dev_dbg(&device->dev, "atk: method MBIF not found\n");
1355         } else {
1356                 obj = buf.pointer;
1357                 if (obj->package.count >= 2) {
1358                         union acpi_object *id = &obj->package.elements[1];
1359                         if (id->type == ACPI_TYPE_STRING)
1360                                 dev_dbg(&device->dev, "board ID = %s\n",
1361                                         id->string.pointer);
1362                 }
1363                 ACPI_FREE(buf.pointer);
1364         }
1365
1366         err = atk_probe_if(data);
1367         if (err) {
1368                 dev_err(&device->dev, "No usable hwmon interface detected\n");
1369                 goto out;
1370         }
1371
1372         if (data->old_interface) {
1373                 dev_dbg(&device->dev, "Using old hwmon interface\n");
1374                 err = atk_enumerate_old_hwmon(data);
1375         } else {
1376                 dev_dbg(&device->dev, "Using new hwmon interface\n");
1377                 err = atk_enumerate_new_hwmon(data);
1378         }
1379         if (err < 0)
1380                 goto out;
1381         if (err == 0) {
1382                 dev_info(&device->dev,
1383                          "No usable sensor detected, bailing out\n");
1384                 err = -ENODEV;
1385                 goto out;
1386         }
1387
1388         err = atk_register_hwmon(data);
1389         if (err)
1390                 goto cleanup;
1391
1392         atk_debugfs_init(data);
1393
1394         device->driver_data = data;
1395         return 0;
1396 cleanup:
1397         atk_free_sensors(data);
1398 out:
1399         if (data->disable_ec)
1400                 atk_ec_ctl(data, 0);
1401         kfree(data);
1402         return err;
1403 }
1404
1405 static int atk_remove(struct acpi_device *device, int type)
1406 {
1407         struct atk_data *data = device->driver_data;
1408         dev_dbg(&device->dev, "removing...\n");
1409
1410         device->driver_data = NULL;
1411
1412         atk_debugfs_cleanup(data);
1413
1414         atk_remove_files(data);
1415         atk_free_sensors(data);
1416         hwmon_device_unregister(data->hwmon_dev);
1417
1418         if (data->disable_ec) {
1419                 if (atk_ec_ctl(data, 0))
1420                         dev_err(&device->dev, "Failed to disable EC\n");
1421         }
1422
1423         kfree(data);
1424
1425         return 0;
1426 }
1427
1428 static int __init atk0110_init(void)
1429 {
1430         int ret;
1431
1432         /* Make sure it's safe to access the device through ACPI */
1433         if (!acpi_resources_are_enforced()) {
1434                 pr_err("Resources not safely usable due to acpi_enforce_resources kernel parameter\n");
1435                 return -EBUSY;
1436         }
1437
1438         if (dmi_check_system(atk_force_new_if))
1439                 new_if = true;
1440
1441         ret = acpi_bus_register_driver(&atk_driver);
1442         if (ret)
1443                 pr_info("acpi_bus_register_driver failed: %d\n", ret);
1444
1445         return ret;
1446 }
1447
1448 static void __exit atk0110_exit(void)
1449 {
1450         acpi_bus_unregister_driver(&atk_driver);
1451 }
1452
1453 module_init(atk0110_init);
1454 module_exit(atk0110_exit);
1455
1456 MODULE_LICENSE("GPL");