Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2007-2009 Luca Tettamanti <kronos.it@gmail.com>
0004  *
0005  * See COPYING in the top level directory of the kernel tree.
0006  */
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include <linux/debugfs.h>
0011 #include <linux/kernel.h>
0012 #include <linux/hwmon.h>
0013 #include <linux/list.h>
0014 #include <linux/module.h>
0015 #include <linux/slab.h>
0016 #include <linux/dmi.h>
0017 #include <linux/jiffies.h>
0018 #include <linux/err.h>
0019 #include <linux/acpi.h>
0020 
0021 #define ATK_HID "ATK0110"
0022 
0023 static bool new_if;
0024 module_param(new_if, bool, 0);
0025 MODULE_PARM_DESC(new_if, "Override detection heuristic and force the use of the new ATK0110 interface");
0026 
0027 static const struct dmi_system_id __initconst atk_force_new_if[] = {
0028     {
0029         /* Old interface has broken MCH temp monitoring */
0030         .ident = "Asus Sabertooth X58",
0031         .matches = {
0032             DMI_MATCH(DMI_BOARD_NAME, "SABERTOOTH X58")
0033         }
0034     }, {
0035         /* Old interface reads the same sensor for fan0 and fan1 */
0036         .ident = "Asus M5A78L",
0037         .matches = {
0038             DMI_MATCH(DMI_BOARD_NAME, "M5A78L")
0039         }
0040     },
0041     { }
0042 };
0043 
0044 /*
0045  * Minimum time between readings, enforced in order to avoid
0046  * hogging the CPU.
0047  */
0048 #define CACHE_TIME      HZ
0049 
0050 #define BOARD_ID        "MBIF"
0051 #define METHOD_ENUMERATE    "GGRP"
0052 #define METHOD_READ     "GITM"
0053 #define METHOD_WRITE        "SITM"
0054 #define METHOD_OLD_READ_TMP "RTMP"
0055 #define METHOD_OLD_READ_VLT "RVLT"
0056 #define METHOD_OLD_READ_FAN "RFAN"
0057 #define METHOD_OLD_ENUM_TMP "TSIF"
0058 #define METHOD_OLD_ENUM_VLT "VSIF"
0059 #define METHOD_OLD_ENUM_FAN "FSIF"
0060 
0061 #define ATK_MUX_HWMON       0x00000006ULL
0062 #define ATK_MUX_MGMT        0x00000011ULL
0063 
0064 #define ATK_CLASS_MASK      0xff000000ULL
0065 #define ATK_CLASS_FREQ_CTL  0x03000000ULL
0066 #define ATK_CLASS_FAN_CTL   0x04000000ULL
0067 #define ATK_CLASS_HWMON     0x06000000ULL
0068 #define ATK_CLASS_MGMT      0x11000000ULL
0069 
0070 #define ATK_TYPE_MASK       0x00ff0000ULL
0071 #define HWMON_TYPE_VOLT     0x00020000ULL
0072 #define HWMON_TYPE_TEMP     0x00030000ULL
0073 #define HWMON_TYPE_FAN      0x00040000ULL
0074 
0075 #define ATK_ELEMENT_ID_MASK 0x0000ffffULL
0076 
0077 #define ATK_EC_ID       0x11060004ULL
0078 
0079 enum atk_pack_member {
0080     HWMON_PACK_FLAGS,
0081     HWMON_PACK_NAME,
0082     HWMON_PACK_LIMIT1,
0083     HWMON_PACK_LIMIT2,
0084     HWMON_PACK_ENABLE
0085 };
0086 
0087 /* New package format */
0088 #define _HWMON_NEW_PACK_SIZE    7
0089 #define _HWMON_NEW_PACK_FLAGS   0
0090 #define _HWMON_NEW_PACK_NAME    1
0091 #define _HWMON_NEW_PACK_UNK1    2
0092 #define _HWMON_NEW_PACK_UNK2    3
0093 #define _HWMON_NEW_PACK_LIMIT1  4
0094 #define _HWMON_NEW_PACK_LIMIT2  5
0095 #define _HWMON_NEW_PACK_ENABLE  6
0096 
0097 /* Old package format */
0098 #define _HWMON_OLD_PACK_SIZE    5
0099 #define _HWMON_OLD_PACK_FLAGS   0
0100 #define _HWMON_OLD_PACK_NAME    1
0101 #define _HWMON_OLD_PACK_LIMIT1  2
0102 #define _HWMON_OLD_PACK_LIMIT2  3
0103 #define _HWMON_OLD_PACK_ENABLE  4
0104 
0105 
0106 struct atk_data {
0107     struct device *hwmon_dev;
0108     acpi_handle atk_handle;
0109     struct acpi_device *acpi_dev;
0110 
0111     bool old_interface;
0112 
0113     /* old interface */
0114     acpi_handle rtmp_handle;
0115     acpi_handle rvlt_handle;
0116     acpi_handle rfan_handle;
0117     /* new interface */
0118     acpi_handle enumerate_handle;
0119     acpi_handle read_handle;
0120     acpi_handle write_handle;
0121 
0122     bool disable_ec;
0123 
0124     int voltage_count;
0125     int temperature_count;
0126     int fan_count;
0127     struct list_head sensor_list;
0128     struct attribute_group attr_group;
0129     const struct attribute_group *attr_groups[2];
0130 
0131     struct {
0132         struct dentry *root;
0133         u32 id;
0134     } debugfs;
0135 };
0136 
0137 
0138 typedef ssize_t (*sysfs_show_func)(struct device *dev,
0139             struct device_attribute *attr, char *buf);
0140 
0141 static const struct acpi_device_id atk_ids[] = {
0142     {ATK_HID, 0},
0143     {"", 0},
0144 };
0145 MODULE_DEVICE_TABLE(acpi, atk_ids);
0146 
0147 #define ATTR_NAME_SIZE 16 /* Worst case is "tempN_input" */
0148 
0149 struct atk_sensor_data {
0150     struct list_head list;
0151     struct atk_data *data;
0152     struct device_attribute label_attr;
0153     struct device_attribute input_attr;
0154     struct device_attribute limit1_attr;
0155     struct device_attribute limit2_attr;
0156     char label_attr_name[ATTR_NAME_SIZE];
0157     char input_attr_name[ATTR_NAME_SIZE];
0158     char limit1_attr_name[ATTR_NAME_SIZE];
0159     char limit2_attr_name[ATTR_NAME_SIZE];
0160     u64 id;
0161     u64 type;
0162     u64 limit1;
0163     u64 limit2;
0164     u64 cached_value;
0165     unsigned long last_updated; /* in jiffies */
0166     bool is_valid;
0167     char const *acpi_name;
0168 };
0169 
0170 /*
0171  * Return buffer format:
0172  * [0-3] "value" is valid flag
0173  * [4-7] value
0174  * [8- ] unknown stuff on newer mobos
0175  */
0176 struct atk_acpi_ret_buffer {
0177     u32 flags;
0178     u32 value;
0179     u8 data[];
0180 };
0181 
0182 /* Input buffer used for GITM and SITM methods */
0183 struct atk_acpi_input_buf {
0184     u32 id;
0185     u32 param1;
0186     u32 param2;
0187 };
0188 
0189 static int atk_add(struct acpi_device *device);
0190 static int atk_remove(struct acpi_device *device);
0191 static void atk_print_sensor(struct atk_data *data, union acpi_object *obj);
0192 static int atk_read_value(struct atk_sensor_data *sensor, u64 *value);
0193 
0194 static struct acpi_driver atk_driver = {
0195     .name   = ATK_HID,
0196     .class  = "hwmon",
0197     .ids    = atk_ids,
0198     .ops    = {
0199         .add    = atk_add,
0200         .remove = atk_remove,
0201     },
0202 };
0203 
0204 #define input_to_atk_sensor(attr) \
0205     container_of(attr, struct atk_sensor_data, input_attr)
0206 
0207 #define label_to_atk_sensor(attr) \
0208     container_of(attr, struct atk_sensor_data, label_attr)
0209 
0210 #define limit1_to_atk_sensor(attr) \
0211     container_of(attr, struct atk_sensor_data, limit1_attr)
0212 
0213 #define limit2_to_atk_sensor(attr) \
0214     container_of(attr, struct atk_sensor_data, limit2_attr)
0215 
0216 static ssize_t atk_input_show(struct device *dev,
0217         struct device_attribute *attr, char *buf)
0218 {
0219     struct atk_sensor_data *s = input_to_atk_sensor(attr);
0220     u64 value;
0221     int err;
0222 
0223     err = atk_read_value(s, &value);
0224     if (err)
0225         return err;
0226 
0227     if (s->type == HWMON_TYPE_TEMP)
0228         /* ACPI returns decidegree */
0229         value *= 100;
0230 
0231     return sprintf(buf, "%llu\n", value);
0232 }
0233 
0234 static ssize_t atk_label_show(struct device *dev,
0235         struct device_attribute *attr, char *buf)
0236 {
0237     struct atk_sensor_data *s = label_to_atk_sensor(attr);
0238 
0239     return sprintf(buf, "%s\n", s->acpi_name);
0240 }
0241 
0242 static ssize_t atk_limit1_show(struct device *dev,
0243         struct device_attribute *attr, char *buf)
0244 {
0245     struct atk_sensor_data *s = limit1_to_atk_sensor(attr);
0246     u64 value = s->limit1;
0247 
0248     if (s->type == HWMON_TYPE_TEMP)
0249         value *= 100;
0250 
0251     return sprintf(buf, "%lld\n", value);
0252 }
0253 
0254 static ssize_t atk_limit2_show(struct device *dev,
0255         struct device_attribute *attr, char *buf)
0256 {
0257     struct atk_sensor_data *s = limit2_to_atk_sensor(attr);
0258     u64 value = s->limit2;
0259 
0260     if (s->type == HWMON_TYPE_TEMP)
0261         value *= 100;
0262 
0263     return sprintf(buf, "%lld\n", value);
0264 }
0265 
0266 static void atk_init_attribute(struct device_attribute *attr, char *name,
0267         sysfs_show_func show)
0268 {
0269     sysfs_attr_init(&attr->attr);
0270     attr->attr.name = name;
0271     attr->attr.mode = 0444;
0272     attr->show = show;
0273     attr->store = NULL;
0274 }
0275 
0276 
0277 static union acpi_object *atk_get_pack_member(struct atk_data *data,
0278                         union acpi_object *pack,
0279                         enum atk_pack_member m)
0280 {
0281     bool old_if = data->old_interface;
0282     int offset;
0283 
0284     switch (m) {
0285     case HWMON_PACK_FLAGS:
0286         offset = old_if ? _HWMON_OLD_PACK_FLAGS : _HWMON_NEW_PACK_FLAGS;
0287         break;
0288     case HWMON_PACK_NAME:
0289         offset = old_if ? _HWMON_OLD_PACK_NAME : _HWMON_NEW_PACK_NAME;
0290         break;
0291     case HWMON_PACK_LIMIT1:
0292         offset = old_if ? _HWMON_OLD_PACK_LIMIT1 :
0293                   _HWMON_NEW_PACK_LIMIT1;
0294         break;
0295     case HWMON_PACK_LIMIT2:
0296         offset = old_if ? _HWMON_OLD_PACK_LIMIT2 :
0297                   _HWMON_NEW_PACK_LIMIT2;
0298         break;
0299     case HWMON_PACK_ENABLE:
0300         offset = old_if ? _HWMON_OLD_PACK_ENABLE :
0301                   _HWMON_NEW_PACK_ENABLE;
0302         break;
0303     default:
0304         return NULL;
0305     }
0306 
0307     return &pack->package.elements[offset];
0308 }
0309 
0310 
0311 /*
0312  * New package format is:
0313  * - flag (int)
0314  *  class - used for de-muxing the request to the correct GITn
0315  *  type (volt, temp, fan)
0316  *  sensor id |
0317  *  sensor id - used for de-muxing the request _inside_ the GITn
0318  * - name (str)
0319  * - unknown (int)
0320  * - unknown (int)
0321  * - limit1 (int)
0322  * - limit2 (int)
0323  * - enable (int)
0324  *
0325  * The old package has the same format but it's missing the two unknown fields.
0326  */
0327 static int validate_hwmon_pack(struct atk_data *data, union acpi_object *obj)
0328 {
0329     struct device *dev = &data->acpi_dev->dev;
0330     union acpi_object *tmp;
0331     bool old_if = data->old_interface;
0332     int const expected_size = old_if ? _HWMON_OLD_PACK_SIZE :
0333                        _HWMON_NEW_PACK_SIZE;
0334 
0335     if (obj->type != ACPI_TYPE_PACKAGE) {
0336         dev_warn(dev, "Invalid type: %d\n", obj->type);
0337         return -EINVAL;
0338     }
0339 
0340     if (obj->package.count != expected_size) {
0341         dev_warn(dev, "Invalid package size: %d, expected: %d\n",
0342                 obj->package.count, expected_size);
0343         return -EINVAL;
0344     }
0345 
0346     tmp = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
0347     if (tmp->type != ACPI_TYPE_INTEGER) {
0348         dev_warn(dev, "Invalid type (flag): %d\n", tmp->type);
0349         return -EINVAL;
0350     }
0351 
0352     tmp = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
0353     if (tmp->type != ACPI_TYPE_STRING) {
0354         dev_warn(dev, "Invalid type (name): %d\n", tmp->type);
0355         return -EINVAL;
0356     }
0357 
0358     /* Don't check... we don't know what they're useful for anyway */
0359 #if 0
0360     tmp = &obj->package.elements[HWMON_PACK_UNK1];
0361     if (tmp->type != ACPI_TYPE_INTEGER) {
0362         dev_warn(dev, "Invalid type (unk1): %d\n", tmp->type);
0363         return -EINVAL;
0364     }
0365 
0366     tmp = &obj->package.elements[HWMON_PACK_UNK2];
0367     if (tmp->type != ACPI_TYPE_INTEGER) {
0368         dev_warn(dev, "Invalid type (unk2): %d\n", tmp->type);
0369         return -EINVAL;
0370     }
0371 #endif
0372 
0373     tmp = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
0374     if (tmp->type != ACPI_TYPE_INTEGER) {
0375         dev_warn(dev, "Invalid type (limit1): %d\n", tmp->type);
0376         return -EINVAL;
0377     }
0378 
0379     tmp = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
0380     if (tmp->type != ACPI_TYPE_INTEGER) {
0381         dev_warn(dev, "Invalid type (limit2): %d\n", tmp->type);
0382         return -EINVAL;
0383     }
0384 
0385     tmp = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
0386     if (tmp->type != ACPI_TYPE_INTEGER) {
0387         dev_warn(dev, "Invalid type (enable): %d\n", tmp->type);
0388         return -EINVAL;
0389     }
0390 
0391     atk_print_sensor(data, obj);
0392 
0393     return 0;
0394 }
0395 
0396 #ifdef DEBUG
0397 static char const *atk_sensor_type(union acpi_object *flags)
0398 {
0399     u64 type = flags->integer.value & ATK_TYPE_MASK;
0400     char const *what;
0401 
0402     switch (type) {
0403     case HWMON_TYPE_VOLT:
0404         what = "voltage";
0405         break;
0406     case HWMON_TYPE_TEMP:
0407         what = "temperature";
0408         break;
0409     case HWMON_TYPE_FAN:
0410         what = "fan";
0411         break;
0412     default:
0413         what = "unknown";
0414         break;
0415     }
0416 
0417     return what;
0418 }
0419 #endif
0420 
0421 static void atk_print_sensor(struct atk_data *data, union acpi_object *obj)
0422 {
0423 #ifdef DEBUG
0424     struct device *dev = &data->acpi_dev->dev;
0425     union acpi_object *flags;
0426     union acpi_object *name;
0427     union acpi_object *limit1;
0428     union acpi_object *limit2;
0429     union acpi_object *enable;
0430     char const *what;
0431 
0432     flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
0433     name = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
0434     limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
0435     limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
0436     enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
0437 
0438     what = atk_sensor_type(flags);
0439 
0440     dev_dbg(dev, "%s: %#llx %s [%llu-%llu] %s\n", what,
0441             flags->integer.value,
0442             name->string.pointer,
0443             limit1->integer.value, limit2->integer.value,
0444             enable->integer.value ? "enabled" : "disabled");
0445 #endif
0446 }
0447 
0448 static int atk_read_value_old(struct atk_sensor_data *sensor, u64 *value)
0449 {
0450     struct atk_data *data = sensor->data;
0451     struct device *dev = &data->acpi_dev->dev;
0452     struct acpi_object_list params;
0453     union acpi_object id;
0454     acpi_status status;
0455     acpi_handle method;
0456 
0457     switch (sensor->type) {
0458     case HWMON_TYPE_VOLT:
0459         method = data->rvlt_handle;
0460         break;
0461     case HWMON_TYPE_TEMP:
0462         method = data->rtmp_handle;
0463         break;
0464     case HWMON_TYPE_FAN:
0465         method = data->rfan_handle;
0466         break;
0467     default:
0468         return -EINVAL;
0469     }
0470 
0471     id.type = ACPI_TYPE_INTEGER;
0472     id.integer.value = sensor->id;
0473 
0474     params.count = 1;
0475     params.pointer = &id;
0476 
0477     status = acpi_evaluate_integer(method, NULL, &params, value);
0478     if (status != AE_OK) {
0479         dev_warn(dev, "%s: ACPI exception: %s\n", __func__,
0480                 acpi_format_exception(status));
0481         return -EIO;
0482     }
0483 
0484     return 0;
0485 }
0486 
0487 static union acpi_object *atk_ggrp(struct atk_data *data, u16 mux)
0488 {
0489     struct device *dev = &data->acpi_dev->dev;
0490     struct acpi_buffer buf;
0491     acpi_status ret;
0492     struct acpi_object_list params;
0493     union acpi_object id;
0494     union acpi_object *pack;
0495 
0496     id.type = ACPI_TYPE_INTEGER;
0497     id.integer.value = mux;
0498     params.count = 1;
0499     params.pointer = &id;
0500 
0501     buf.length = ACPI_ALLOCATE_BUFFER;
0502     ret = acpi_evaluate_object(data->enumerate_handle, NULL, &params, &buf);
0503     if (ret != AE_OK) {
0504         dev_err(dev, "GGRP[%#x] ACPI exception: %s\n", mux,
0505                 acpi_format_exception(ret));
0506         return ERR_PTR(-EIO);
0507     }
0508     pack = buf.pointer;
0509     if (pack->type != ACPI_TYPE_PACKAGE) {
0510         /* Execution was successful, but the id was not found */
0511         ACPI_FREE(pack);
0512         return ERR_PTR(-ENOENT);
0513     }
0514 
0515     if (pack->package.count < 1) {
0516         dev_err(dev, "GGRP[%#x] package is too small\n", mux);
0517         ACPI_FREE(pack);
0518         return ERR_PTR(-EIO);
0519     }
0520     return pack;
0521 }
0522 
0523 static union acpi_object *atk_gitm(struct atk_data *data, u64 id)
0524 {
0525     struct device *dev = &data->acpi_dev->dev;
0526     struct atk_acpi_input_buf buf;
0527     union acpi_object tmp;
0528     struct acpi_object_list params;
0529     struct acpi_buffer ret;
0530     union acpi_object *obj;
0531     acpi_status status;
0532 
0533     buf.id = id;
0534     buf.param1 = 0;
0535     buf.param2 = 0;
0536 
0537     tmp.type = ACPI_TYPE_BUFFER;
0538     tmp.buffer.pointer = (u8 *)&buf;
0539     tmp.buffer.length = sizeof(buf);
0540 
0541     params.count = 1;
0542     params.pointer = (void *)&tmp;
0543 
0544     ret.length = ACPI_ALLOCATE_BUFFER;
0545     status = acpi_evaluate_object_typed(data->read_handle, NULL, &params,
0546             &ret, ACPI_TYPE_BUFFER);
0547     if (status != AE_OK) {
0548         dev_warn(dev, "GITM[%#llx] ACPI exception: %s\n", id,
0549                 acpi_format_exception(status));
0550         return ERR_PTR(-EIO);
0551     }
0552     obj = ret.pointer;
0553 
0554     /* Sanity check */
0555     if (obj->buffer.length < 8) {
0556         dev_warn(dev, "Unexpected ASBF length: %u\n",
0557                 obj->buffer.length);
0558         ACPI_FREE(obj);
0559         return ERR_PTR(-EIO);
0560     }
0561     return obj;
0562 }
0563 
0564 static union acpi_object *atk_sitm(struct atk_data *data,
0565         struct atk_acpi_input_buf *buf)
0566 {
0567     struct device *dev = &data->acpi_dev->dev;
0568     struct acpi_object_list params;
0569     union acpi_object tmp;
0570     struct acpi_buffer ret;
0571     union acpi_object *obj;
0572     acpi_status status;
0573 
0574     tmp.type = ACPI_TYPE_BUFFER;
0575     tmp.buffer.pointer = (u8 *)buf;
0576     tmp.buffer.length = sizeof(*buf);
0577 
0578     params.count = 1;
0579     params.pointer = &tmp;
0580 
0581     ret.length = ACPI_ALLOCATE_BUFFER;
0582     status = acpi_evaluate_object_typed(data->write_handle, NULL, &params,
0583             &ret, ACPI_TYPE_BUFFER);
0584     if (status != AE_OK) {
0585         dev_warn(dev, "SITM[%#x] ACPI exception: %s\n", buf->id,
0586                 acpi_format_exception(status));
0587         return ERR_PTR(-EIO);
0588     }
0589     obj = ret.pointer;
0590 
0591     /* Sanity check */
0592     if (obj->buffer.length < 8) {
0593         dev_warn(dev, "Unexpected ASBF length: %u\n",
0594                 obj->buffer.length);
0595         ACPI_FREE(obj);
0596         return ERR_PTR(-EIO);
0597     }
0598     return obj;
0599 }
0600 
0601 static int atk_read_value_new(struct atk_sensor_data *sensor, u64 *value)
0602 {
0603     struct atk_data *data = sensor->data;
0604     struct device *dev = &data->acpi_dev->dev;
0605     union acpi_object *obj;
0606     struct atk_acpi_ret_buffer *buf;
0607     int err = 0;
0608 
0609     obj = atk_gitm(data, sensor->id);
0610     if (IS_ERR(obj))
0611         return PTR_ERR(obj);
0612 
0613     buf = (struct atk_acpi_ret_buffer *)obj->buffer.pointer;
0614     if (buf->flags == 0) {
0615         /*
0616          * The reading is not valid, possible causes:
0617          * - sensor failure
0618          * - enumeration was FUBAR (and we didn't notice)
0619          */
0620         dev_warn(dev, "Read failed, sensor = %#llx\n", sensor->id);
0621         err = -EIO;
0622         goto out;
0623     }
0624 
0625     *value = buf->value;
0626 out:
0627     ACPI_FREE(obj);
0628     return err;
0629 }
0630 
0631 static int atk_read_value(struct atk_sensor_data *sensor, u64 *value)
0632 {
0633     int err;
0634 
0635     if (!sensor->is_valid ||
0636         time_after(jiffies, sensor->last_updated + CACHE_TIME)) {
0637         if (sensor->data->old_interface)
0638             err = atk_read_value_old(sensor, value);
0639         else
0640             err = atk_read_value_new(sensor, value);
0641 
0642         if (err)
0643             return err;
0644 
0645         sensor->is_valid = true;
0646         sensor->last_updated = jiffies;
0647         sensor->cached_value = *value;
0648     } else {
0649         *value = sensor->cached_value;
0650         err = 0;
0651     }
0652 
0653     return err;
0654 }
0655 
0656 #ifdef CONFIG_DEBUG_FS
0657 static int atk_debugfs_gitm_get(void *p, u64 *val)
0658 {
0659     struct atk_data *data = p;
0660     union acpi_object *ret;
0661     struct atk_acpi_ret_buffer *buf;
0662     int err = 0;
0663 
0664     if (!data->read_handle)
0665         return -ENODEV;
0666 
0667     if (!data->debugfs.id)
0668         return -EINVAL;
0669 
0670     ret = atk_gitm(data, data->debugfs.id);
0671     if (IS_ERR(ret))
0672         return PTR_ERR(ret);
0673 
0674     buf = (struct atk_acpi_ret_buffer *)ret->buffer.pointer;
0675     if (buf->flags)
0676         *val = buf->value;
0677     else
0678         err = -EIO;
0679 
0680     ACPI_FREE(ret);
0681     return err;
0682 }
0683 
0684 DEFINE_DEBUGFS_ATTRIBUTE(atk_debugfs_gitm, atk_debugfs_gitm_get, NULL,
0685              "0x%08llx\n");
0686 
0687 static int atk_acpi_print(char *buf, size_t sz, union acpi_object *obj)
0688 {
0689     int ret = 0;
0690 
0691     switch (obj->type) {
0692     case ACPI_TYPE_INTEGER:
0693         ret = snprintf(buf, sz, "0x%08llx\n", obj->integer.value);
0694         break;
0695     case ACPI_TYPE_STRING:
0696         ret = snprintf(buf, sz, "%s\n", obj->string.pointer);
0697         break;
0698     }
0699 
0700     return ret;
0701 }
0702 
0703 static void atk_pack_print(char *buf, size_t sz, union acpi_object *pack)
0704 {
0705     int ret;
0706     int i;
0707 
0708     for (i = 0; i < pack->package.count; i++) {
0709         union acpi_object *obj = &pack->package.elements[i];
0710 
0711         ret = atk_acpi_print(buf, sz, obj);
0712         if (ret >= sz)
0713             break;
0714         buf += ret;
0715         sz -= ret;
0716     }
0717 }
0718 
0719 static int atk_debugfs_ggrp_open(struct inode *inode, struct file *file)
0720 {
0721     struct atk_data *data = inode->i_private;
0722     char *buf = NULL;
0723     union acpi_object *ret;
0724     u8 cls;
0725     int i;
0726 
0727     if (!data->enumerate_handle)
0728         return -ENODEV;
0729     if (!data->debugfs.id)
0730         return -EINVAL;
0731 
0732     cls = (data->debugfs.id & 0xff000000) >> 24;
0733     ret = atk_ggrp(data, cls);
0734     if (IS_ERR(ret))
0735         return PTR_ERR(ret);
0736 
0737     for (i = 0; i < ret->package.count; i++) {
0738         union acpi_object *pack = &ret->package.elements[i];
0739         union acpi_object *id;
0740 
0741         if (pack->type != ACPI_TYPE_PACKAGE)
0742             continue;
0743         if (!pack->package.count)
0744             continue;
0745         id = &pack->package.elements[0];
0746         if (id->integer.value == data->debugfs.id) {
0747             /* Print the package */
0748             buf = kzalloc(512, GFP_KERNEL);
0749             if (!buf) {
0750                 ACPI_FREE(ret);
0751                 return -ENOMEM;
0752             }
0753             atk_pack_print(buf, 512, pack);
0754             break;
0755         }
0756     }
0757     ACPI_FREE(ret);
0758 
0759     if (!buf)
0760         return -EINVAL;
0761 
0762     file->private_data = buf;
0763 
0764     return nonseekable_open(inode, file);
0765 }
0766 
0767 static ssize_t atk_debugfs_ggrp_read(struct file *file, char __user *buf,
0768         size_t count, loff_t *pos)
0769 {
0770     char *str = file->private_data;
0771     size_t len = strlen(str);
0772 
0773     return simple_read_from_buffer(buf, count, pos, str, len);
0774 }
0775 
0776 static int atk_debugfs_ggrp_release(struct inode *inode, struct file *file)
0777 {
0778     kfree(file->private_data);
0779     return 0;
0780 }
0781 
0782 static const struct file_operations atk_debugfs_ggrp_fops = {
0783     .read       = atk_debugfs_ggrp_read,
0784     .open       = atk_debugfs_ggrp_open,
0785     .release    = atk_debugfs_ggrp_release,
0786     .llseek     = no_llseek,
0787 };
0788 
0789 static void atk_debugfs_init(struct atk_data *data)
0790 {
0791     struct dentry *d;
0792 
0793     data->debugfs.id = 0;
0794 
0795     d = debugfs_create_dir("asus_atk0110", NULL);
0796 
0797     debugfs_create_x32("id", 0600, d, &data->debugfs.id);
0798     debugfs_create_file_unsafe("gitm", 0400, d, data, &atk_debugfs_gitm);
0799     debugfs_create_file("ggrp", 0400, d, data, &atk_debugfs_ggrp_fops);
0800 
0801     data->debugfs.root = d;
0802 }
0803 
0804 static void atk_debugfs_cleanup(struct atk_data *data)
0805 {
0806     debugfs_remove_recursive(data->debugfs.root);
0807 }
0808 
0809 #else /* CONFIG_DEBUG_FS */
0810 
0811 static void atk_debugfs_init(struct atk_data *data)
0812 {
0813 }
0814 
0815 static void atk_debugfs_cleanup(struct atk_data *data)
0816 {
0817 }
0818 #endif
0819 
0820 static int atk_add_sensor(struct atk_data *data, union acpi_object *obj)
0821 {
0822     struct device *dev = &data->acpi_dev->dev;
0823     union acpi_object *flags;
0824     union acpi_object *name;
0825     union acpi_object *limit1;
0826     union acpi_object *limit2;
0827     union acpi_object *enable;
0828     struct atk_sensor_data *sensor;
0829     char const *base_name;
0830     char const *limit1_name;
0831     char const *limit2_name;
0832     u64 type;
0833     int err;
0834     int *num;
0835     int start;
0836 
0837     if (obj->type != ACPI_TYPE_PACKAGE) {
0838         /* wft is this? */
0839         dev_warn(dev, "Unknown type for ACPI object: (%d)\n",
0840                 obj->type);
0841         return -EINVAL;
0842     }
0843 
0844     err = validate_hwmon_pack(data, obj);
0845     if (err)
0846         return err;
0847 
0848     /* Ok, we have a valid hwmon package */
0849     type = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS)->integer.value
0850            & ATK_TYPE_MASK;
0851 
0852     switch (type) {
0853     case HWMON_TYPE_VOLT:
0854         base_name = "in";
0855         limit1_name = "min";
0856         limit2_name = "max";
0857         num = &data->voltage_count;
0858         start = 0;
0859         break;
0860     case HWMON_TYPE_TEMP:
0861         base_name = "temp";
0862         limit1_name = "max";
0863         limit2_name = "crit";
0864         num = &data->temperature_count;
0865         start = 1;
0866         break;
0867     case HWMON_TYPE_FAN:
0868         base_name = "fan";
0869         limit1_name = "min";
0870         limit2_name = "max";
0871         num = &data->fan_count;
0872         start = 1;
0873         break;
0874     default:
0875         dev_warn(dev, "Unknown sensor type: %#llx\n", type);
0876         return -EINVAL;
0877     }
0878 
0879     enable = atk_get_pack_member(data, obj, HWMON_PACK_ENABLE);
0880     if (!enable->integer.value)
0881         /* sensor is disabled */
0882         return 0;
0883 
0884     flags = atk_get_pack_member(data, obj, HWMON_PACK_FLAGS);
0885     name = atk_get_pack_member(data, obj, HWMON_PACK_NAME);
0886     limit1 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT1);
0887     limit2 = atk_get_pack_member(data, obj, HWMON_PACK_LIMIT2);
0888 
0889     sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
0890     if (!sensor)
0891         return -ENOMEM;
0892 
0893     sensor->acpi_name = devm_kstrdup(dev, name->string.pointer, GFP_KERNEL);
0894     if (!sensor->acpi_name)
0895         return -ENOMEM;
0896 
0897     INIT_LIST_HEAD(&sensor->list);
0898     sensor->type = type;
0899     sensor->data = data;
0900     sensor->id = flags->integer.value;
0901     sensor->limit1 = limit1->integer.value;
0902     if (data->old_interface)
0903         sensor->limit2 = limit2->integer.value;
0904     else
0905         /* The upper limit is expressed as delta from lower limit */
0906         sensor->limit2 = sensor->limit1 + limit2->integer.value;
0907 
0908     snprintf(sensor->input_attr_name, ATTR_NAME_SIZE,
0909             "%s%d_input", base_name, start + *num);
0910     atk_init_attribute(&sensor->input_attr,
0911             sensor->input_attr_name,
0912             atk_input_show);
0913 
0914     snprintf(sensor->label_attr_name, ATTR_NAME_SIZE,
0915             "%s%d_label", base_name, start + *num);
0916     atk_init_attribute(&sensor->label_attr,
0917             sensor->label_attr_name,
0918             atk_label_show);
0919 
0920     snprintf(sensor->limit1_attr_name, ATTR_NAME_SIZE,
0921             "%s%d_%s", base_name, start + *num, limit1_name);
0922     atk_init_attribute(&sensor->limit1_attr,
0923             sensor->limit1_attr_name,
0924             atk_limit1_show);
0925 
0926     snprintf(sensor->limit2_attr_name, ATTR_NAME_SIZE,
0927             "%s%d_%s", base_name, start + *num, limit2_name);
0928     atk_init_attribute(&sensor->limit2_attr,
0929             sensor->limit2_attr_name,
0930             atk_limit2_show);
0931 
0932     list_add(&sensor->list, &data->sensor_list);
0933     (*num)++;
0934 
0935     return 1;
0936 }
0937 
0938 static int atk_enumerate_old_hwmon(struct atk_data *data)
0939 {
0940     struct device *dev = &data->acpi_dev->dev;
0941     struct acpi_buffer buf;
0942     union acpi_object *pack;
0943     acpi_status status;
0944     int i, ret;
0945     int count = 0;
0946 
0947     /* Voltages */
0948     buf.length = ACPI_ALLOCATE_BUFFER;
0949     status = acpi_evaluate_object_typed(data->atk_handle,
0950             METHOD_OLD_ENUM_VLT, NULL, &buf, ACPI_TYPE_PACKAGE);
0951     if (status != AE_OK) {
0952         dev_warn(dev, METHOD_OLD_ENUM_VLT ": ACPI exception: %s\n",
0953                 acpi_format_exception(status));
0954 
0955         return -ENODEV;
0956     }
0957 
0958     pack = buf.pointer;
0959     for (i = 1; i < pack->package.count; i++) {
0960         union acpi_object *obj = &pack->package.elements[i];
0961 
0962         ret = atk_add_sensor(data, obj);
0963         if (ret > 0)
0964             count++;
0965     }
0966     ACPI_FREE(buf.pointer);
0967 
0968     /* Temperatures */
0969     buf.length = ACPI_ALLOCATE_BUFFER;
0970     status = acpi_evaluate_object_typed(data->atk_handle,
0971             METHOD_OLD_ENUM_TMP, NULL, &buf, ACPI_TYPE_PACKAGE);
0972     if (status != AE_OK) {
0973         dev_warn(dev, METHOD_OLD_ENUM_TMP ": ACPI exception: %s\n",
0974                 acpi_format_exception(status));
0975 
0976         return -ENODEV;
0977     }
0978 
0979     pack = buf.pointer;
0980     for (i = 1; i < pack->package.count; i++) {
0981         union acpi_object *obj = &pack->package.elements[i];
0982 
0983         ret = atk_add_sensor(data, obj);
0984         if (ret > 0)
0985             count++;
0986     }
0987     ACPI_FREE(buf.pointer);
0988 
0989     /* Fans */
0990     buf.length = ACPI_ALLOCATE_BUFFER;
0991     status = acpi_evaluate_object_typed(data->atk_handle,
0992             METHOD_OLD_ENUM_FAN, NULL, &buf, ACPI_TYPE_PACKAGE);
0993     if (status != AE_OK) {
0994         dev_warn(dev, METHOD_OLD_ENUM_FAN ": ACPI exception: %s\n",
0995                 acpi_format_exception(status));
0996 
0997         return -ENODEV;
0998     }
0999 
1000     pack = buf.pointer;
1001     for (i = 1; i < pack->package.count; i++) {
1002         union acpi_object *obj = &pack->package.elements[i];
1003 
1004         ret = atk_add_sensor(data, obj);
1005         if (ret > 0)
1006             count++;
1007     }
1008     ACPI_FREE(buf.pointer);
1009 
1010     return count;
1011 }
1012 
1013 static int atk_ec_present(struct atk_data *data)
1014 {
1015     struct device *dev = &data->acpi_dev->dev;
1016     union acpi_object *pack;
1017     union acpi_object *ec;
1018     int ret;
1019     int i;
1020 
1021     pack = atk_ggrp(data, ATK_MUX_MGMT);
1022     if (IS_ERR(pack)) {
1023         if (PTR_ERR(pack) == -ENOENT) {
1024             /* The MGMT class does not exists - that's ok */
1025             dev_dbg(dev, "Class %#llx not found\n", ATK_MUX_MGMT);
1026             return 0;
1027         }
1028         return PTR_ERR(pack);
1029     }
1030 
1031     /* Search the EC */
1032     ec = NULL;
1033     for (i = 0; i < pack->package.count; i++) {
1034         union acpi_object *obj = &pack->package.elements[i];
1035         union acpi_object *id;
1036 
1037         if (obj->type != ACPI_TYPE_PACKAGE)
1038             continue;
1039 
1040         id = &obj->package.elements[0];
1041         if (id->type != ACPI_TYPE_INTEGER)
1042             continue;
1043 
1044         if (id->integer.value == ATK_EC_ID) {
1045             ec = obj;
1046             break;
1047         }
1048     }
1049 
1050     ret = (ec != NULL);
1051     if (!ret)
1052         /* The system has no EC */
1053         dev_dbg(dev, "EC not found\n");
1054 
1055     ACPI_FREE(pack);
1056     return ret;
1057 }
1058 
1059 static int atk_ec_enabled(struct atk_data *data)
1060 {
1061     struct device *dev = &data->acpi_dev->dev;
1062     union acpi_object *obj;
1063     struct atk_acpi_ret_buffer *buf;
1064     int err;
1065 
1066     obj = atk_gitm(data, ATK_EC_ID);
1067     if (IS_ERR(obj)) {
1068         dev_err(dev, "Unable to query EC status\n");
1069         return PTR_ERR(obj);
1070     }
1071     buf = (struct atk_acpi_ret_buffer *)obj->buffer.pointer;
1072 
1073     if (buf->flags == 0) {
1074         dev_err(dev, "Unable to query EC status\n");
1075         err = -EIO;
1076     } else {
1077         err = (buf->value != 0);
1078         dev_dbg(dev, "EC is %sabled\n",
1079                 err ? "en" : "dis");
1080     }
1081 
1082     ACPI_FREE(obj);
1083     return err;
1084 }
1085 
1086 static int atk_ec_ctl(struct atk_data *data, int enable)
1087 {
1088     struct device *dev = &data->acpi_dev->dev;
1089     union acpi_object *obj;
1090     struct atk_acpi_input_buf sitm;
1091     struct atk_acpi_ret_buffer *ec_ret;
1092     int err = 0;
1093 
1094     sitm.id = ATK_EC_ID;
1095     sitm.param1 = enable;
1096     sitm.param2 = 0;
1097 
1098     obj = atk_sitm(data, &sitm);
1099     if (IS_ERR(obj)) {
1100         dev_err(dev, "Failed to %sable the EC\n",
1101                 enable ? "en" : "dis");
1102         return PTR_ERR(obj);
1103     }
1104     ec_ret = (struct atk_acpi_ret_buffer *)obj->buffer.pointer;
1105     if (ec_ret->flags == 0) {
1106         dev_err(dev, "Failed to %sable the EC\n",
1107                 enable ? "en" : "dis");
1108         err = -EIO;
1109     } else {
1110         dev_info(dev, "EC %sabled\n",
1111                 enable ? "en" : "dis");
1112     }
1113 
1114     ACPI_FREE(obj);
1115     return err;
1116 }
1117 
1118 static int atk_enumerate_new_hwmon(struct atk_data *data)
1119 {
1120     struct device *dev = &data->acpi_dev->dev;
1121     union acpi_object *pack;
1122     int err;
1123     int i;
1124 
1125     err = atk_ec_present(data);
1126     if (err < 0)
1127         return err;
1128     if (err) {
1129         err = atk_ec_enabled(data);
1130         if (err < 0)
1131             return err;
1132         /* If the EC was disabled we will disable it again on unload */
1133         data->disable_ec = err;
1134 
1135         err = atk_ec_ctl(data, 1);
1136         if (err) {
1137             data->disable_ec = false;
1138             return err;
1139         }
1140     }
1141 
1142     dev_dbg(dev, "Enumerating hwmon sensors\n");
1143 
1144     pack = atk_ggrp(data, ATK_MUX_HWMON);
1145     if (IS_ERR(pack))
1146         return PTR_ERR(pack);
1147 
1148     for (i = 0; i < pack->package.count; i++) {
1149         union acpi_object *obj = &pack->package.elements[i];
1150 
1151         atk_add_sensor(data, obj);
1152     }
1153 
1154     err = data->voltage_count + data->temperature_count + data->fan_count;
1155 
1156     ACPI_FREE(pack);
1157     return err;
1158 }
1159 
1160 static int atk_init_attribute_groups(struct atk_data *data)
1161 {
1162     struct device *dev = &data->acpi_dev->dev;
1163     struct atk_sensor_data *s;
1164     struct attribute **attrs;
1165     int i = 0;
1166     int len = (data->voltage_count + data->temperature_count
1167             + data->fan_count) * 4 + 1;
1168 
1169     attrs = devm_kcalloc(dev, len, sizeof(struct attribute *), GFP_KERNEL);
1170     if (!attrs)
1171         return -ENOMEM;
1172 
1173     list_for_each_entry(s, &data->sensor_list, list) {
1174         attrs[i++] = &s->input_attr.attr;
1175         attrs[i++] = &s->label_attr.attr;
1176         attrs[i++] = &s->limit1_attr.attr;
1177         attrs[i++] = &s->limit2_attr.attr;
1178     }
1179 
1180     data->attr_group.attrs = attrs;
1181     data->attr_groups[0] = &data->attr_group;
1182 
1183     return 0;
1184 }
1185 
1186 static int atk_register_hwmon(struct atk_data *data)
1187 {
1188     struct device *dev = &data->acpi_dev->dev;
1189 
1190     dev_dbg(dev, "registering hwmon device\n");
1191     data->hwmon_dev = hwmon_device_register_with_groups(dev, "atk0110",
1192                                 data,
1193                                 data->attr_groups);
1194 
1195     return PTR_ERR_OR_ZERO(data->hwmon_dev);
1196 }
1197 
1198 static int atk_probe_if(struct atk_data *data)
1199 {
1200     struct device *dev = &data->acpi_dev->dev;
1201     acpi_handle ret;
1202     acpi_status status;
1203     int err = 0;
1204 
1205     /* RTMP: read temperature */
1206     status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_TMP, &ret);
1207     if (ACPI_SUCCESS(status))
1208         data->rtmp_handle = ret;
1209     else
1210         dev_dbg(dev, "method " METHOD_OLD_READ_TMP " not found: %s\n",
1211                 acpi_format_exception(status));
1212 
1213     /* RVLT: read voltage */
1214     status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_VLT, &ret);
1215     if (ACPI_SUCCESS(status))
1216         data->rvlt_handle = ret;
1217     else
1218         dev_dbg(dev, "method " METHOD_OLD_READ_VLT " not found: %s\n",
1219                 acpi_format_exception(status));
1220 
1221     /* RFAN: read fan status */
1222     status = acpi_get_handle(data->atk_handle, METHOD_OLD_READ_FAN, &ret);
1223     if (ACPI_SUCCESS(status))
1224         data->rfan_handle = ret;
1225     else
1226         dev_dbg(dev, "method " METHOD_OLD_READ_FAN " not found: %s\n",
1227                 acpi_format_exception(status));
1228 
1229     /* Enumeration */
1230     status = acpi_get_handle(data->atk_handle, METHOD_ENUMERATE, &ret);
1231     if (ACPI_SUCCESS(status))
1232         data->enumerate_handle = ret;
1233     else
1234         dev_dbg(dev, "method " METHOD_ENUMERATE " not found: %s\n",
1235                 acpi_format_exception(status));
1236 
1237     /* De-multiplexer (read) */
1238     status = acpi_get_handle(data->atk_handle, METHOD_READ, &ret);
1239     if (ACPI_SUCCESS(status))
1240         data->read_handle = ret;
1241     else
1242         dev_dbg(dev, "method " METHOD_READ " not found: %s\n",
1243                 acpi_format_exception(status));
1244 
1245     /* De-multiplexer (write) */
1246     status = acpi_get_handle(data->atk_handle, METHOD_WRITE, &ret);
1247     if (ACPI_SUCCESS(status))
1248         data->write_handle = ret;
1249     else
1250         dev_dbg(dev, "method " METHOD_WRITE " not found: %s\n",
1251                  acpi_format_exception(status));
1252 
1253     /*
1254      * Check for hwmon methods: first check "old" style methods; note that
1255      * both may be present: in this case we stick to the old interface;
1256      * analysis of multiple DSDTs indicates that when both interfaces
1257      * are present the new one (GGRP/GITM) is not functional.
1258      */
1259     if (new_if)
1260         dev_info(dev, "Overriding interface detection\n");
1261     if (data->rtmp_handle &&
1262             data->rvlt_handle && data->rfan_handle && !new_if)
1263         data->old_interface = true;
1264     else if (data->enumerate_handle && data->read_handle &&
1265             data->write_handle)
1266         data->old_interface = false;
1267     else
1268         err = -ENODEV;
1269 
1270     return err;
1271 }
1272 
1273 static int atk_add(struct acpi_device *device)
1274 {
1275     acpi_status ret;
1276     int err;
1277     struct acpi_buffer buf;
1278     union acpi_object *obj;
1279     struct atk_data *data;
1280 
1281     dev_dbg(&device->dev, "adding...\n");
1282 
1283     data = devm_kzalloc(&device->dev, sizeof(*data), GFP_KERNEL);
1284     if (!data)
1285         return -ENOMEM;
1286 
1287     data->acpi_dev = device;
1288     data->atk_handle = device->handle;
1289     INIT_LIST_HEAD(&data->sensor_list);
1290     data->disable_ec = false;
1291 
1292     buf.length = ACPI_ALLOCATE_BUFFER;
1293     ret = acpi_evaluate_object_typed(data->atk_handle, BOARD_ID, NULL,
1294             &buf, ACPI_TYPE_PACKAGE);
1295     if (ret != AE_OK) {
1296         dev_dbg(&device->dev, "atk: method MBIF not found\n");
1297     } else {
1298         obj = buf.pointer;
1299         if (obj->package.count >= 2) {
1300             union acpi_object *id = &obj->package.elements[1];
1301             if (id->type == ACPI_TYPE_STRING)
1302                 dev_dbg(&device->dev, "board ID = %s\n",
1303                     id->string.pointer);
1304         }
1305         ACPI_FREE(buf.pointer);
1306     }
1307 
1308     err = atk_probe_if(data);
1309     if (err) {
1310         dev_err(&device->dev, "No usable hwmon interface detected\n");
1311         goto out;
1312     }
1313 
1314     if (data->old_interface) {
1315         dev_dbg(&device->dev, "Using old hwmon interface\n");
1316         err = atk_enumerate_old_hwmon(data);
1317     } else {
1318         dev_dbg(&device->dev, "Using new hwmon interface\n");
1319         err = atk_enumerate_new_hwmon(data);
1320     }
1321     if (err < 0)
1322         goto out;
1323     if (err == 0) {
1324         dev_info(&device->dev,
1325              "No usable sensor detected, bailing out\n");
1326         err = -ENODEV;
1327         goto out;
1328     }
1329 
1330     err = atk_init_attribute_groups(data);
1331     if (err)
1332         goto out;
1333     err = atk_register_hwmon(data);
1334     if (err)
1335         goto out;
1336 
1337     atk_debugfs_init(data);
1338 
1339     device->driver_data = data;
1340     return 0;
1341 out:
1342     if (data->disable_ec)
1343         atk_ec_ctl(data, 0);
1344     return err;
1345 }
1346 
1347 static int atk_remove(struct acpi_device *device)
1348 {
1349     struct atk_data *data = device->driver_data;
1350     dev_dbg(&device->dev, "removing...\n");
1351 
1352     device->driver_data = NULL;
1353 
1354     atk_debugfs_cleanup(data);
1355 
1356     hwmon_device_unregister(data->hwmon_dev);
1357 
1358     if (data->disable_ec) {
1359         if (atk_ec_ctl(data, 0))
1360             dev_err(&device->dev, "Failed to disable EC\n");
1361     }
1362 
1363     return 0;
1364 }
1365 
1366 static int __init atk0110_init(void)
1367 {
1368     int ret;
1369 
1370     /* Make sure it's safe to access the device through ACPI */
1371     if (!acpi_resources_are_enforced()) {
1372         pr_err("Resources not safely usable due to acpi_enforce_resources kernel parameter\n");
1373         return -EBUSY;
1374     }
1375 
1376     if (dmi_check_system(atk_force_new_if))
1377         new_if = true;
1378 
1379     ret = acpi_bus_register_driver(&atk_driver);
1380     if (ret)
1381         pr_info("acpi_bus_register_driver failed: %d\n", ret);
1382 
1383     return ret;
1384 }
1385 
1386 static void __exit atk0110_exit(void)
1387 {
1388     acpi_bus_unregister_driver(&atk_driver);
1389 }
1390 
1391 module_init(atk0110_init);
1392 module_exit(atk0110_exit);
1393 
1394 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!