// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Linux driver for WMI platform features on MSI notebooks.
 *
 * Copyright (C) 2024 Armin Wolf <W_Armin@gmx.de>
 */

#define pr_format(fmt) KBUILD_MODNAME ": " fmt

#include <linux/acpi.h>
#include <linux/bits.h>
#include <linux/bitfield.h>
#include <linux/cleanup.h>
#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/device/driver.h>
#include <linux/dmi.h>
#include <linux/errno.h>
#include <linux/hwmon.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/printk.h>
#include <linux/rwsem.h>
#include <linux/types.h>
#include <linux/wmi.h>

#include <linux/unaligned.h>

#define DRIVER_NAME     "msi-wmi-platform"

#define MSI_PLATFORM_GUID       "ABBC0F6E-8EA1-11D1-00A0-C90629100000"

#define MSI_WMI_PLATFORM_INTERFACE_VERSION      2

#define MSI_PLATFORM_WMI_MAJOR_OFFSET   1
#define MSI_PLATFORM_WMI_MINOR_OFFSET   2

#define MSI_PLATFORM_EC_FLAGS_OFFSET    1
#define MSI_PLATFORM_EC_MINOR_MASK      GENMASK(3, 0)
#define MSI_PLATFORM_EC_MAJOR_MASK      GENMASK(5, 4)
#define MSI_PLATFORM_EC_CHANGED_PAGE    BIT(6)
#define MSI_PLATFORM_EC_IS_TIGERLAKE    BIT(7)
#define MSI_PLATFORM_EC_VERSION_OFFSET  2

static bool force;
module_param_unsafe(force, bool, 0);
MODULE_PARM_DESC(force, "Force loading without checking for supported WMI interface versions");

enum msi_wmi_platform_method {
        MSI_PLATFORM_GET_PACKAGE        = 0x01,
        MSI_PLATFORM_SET_PACKAGE        = 0x02,
        MSI_PLATFORM_GET_EC             = 0x03,
        MSI_PLATFORM_SET_EC             = 0x04,
        MSI_PLATFORM_GET_BIOS           = 0x05,
        MSI_PLATFORM_SET_BIOS           = 0x06,
        MSI_PLATFORM_GET_SMBUS          = 0x07,
        MSI_PLATFORM_SET_SMBUS          = 0x08,
        MSI_PLATFORM_GET_MASTER_BATTERY = 0x09,
        MSI_PLATFORM_SET_MASTER_BATTERY = 0x0a,
        MSI_PLATFORM_GET_SLAVE_BATTERY  = 0x0b,
        MSI_PLATFORM_SET_SLAVE_BATTERY  = 0x0c,
        MSI_PLATFORM_GET_TEMPERATURE    = 0x0d,
        MSI_PLATFORM_SET_TEMPERATURE    = 0x0e,
        MSI_PLATFORM_GET_THERMAL        = 0x0f,
        MSI_PLATFORM_SET_THERMAL        = 0x10,
        MSI_PLATFORM_GET_FAN            = 0x11,
        MSI_PLATFORM_SET_FAN            = 0x12,
        MSI_PLATFORM_GET_DEVICE         = 0x13,
        MSI_PLATFORM_SET_DEVICE         = 0x14,
        MSI_PLATFORM_GET_POWER          = 0x15,
        MSI_PLATFORM_SET_POWER          = 0x16,
        MSI_PLATFORM_GET_DEBUG          = 0x17,
        MSI_PLATFORM_SET_DEBUG          = 0x18,
        MSI_PLATFORM_GET_AP             = 0x19,
        MSI_PLATFORM_SET_AP             = 0x1a,
        MSI_PLATFORM_GET_DATA           = 0x1b,
        MSI_PLATFORM_SET_DATA           = 0x1c,
        MSI_PLATFORM_GET_WMI            = 0x1d,
};

struct msi_wmi_platform_data {
        struct wmi_device *wdev;
        struct mutex wmi_lock;  /* Necessary when calling WMI methods */
};

struct msi_wmi_platform_debugfs_data {
        struct msi_wmi_platform_data *data;
        enum msi_wmi_platform_method method;
        struct rw_semaphore buffer_lock;        /* Protects debugfs buffer */
        size_t length;
        u8 buffer[32];
};

static const char * const msi_wmi_platform_debugfs_names[] = {
        "get_package",
        "set_package",
        "get_ec",
        "set_ec",
        "get_bios",
        "set_bios",
        "get_smbus",
        "set_smbus",
        "get_master_battery",
        "set_master_battery",
        "get_slave_battery",
        "set_slave_battery",
        "get_temperature",
        "set_temperature",
        "get_thermal",
        "set_thermal",
        "get_fan",
        "set_fan",
        "get_device",
        "set_device",
        "get_power",
        "set_power",
        "get_debug",
        "set_debug",
        "get_ap",
        "set_ap",
        "get_data",
        "set_data",
        "get_wmi"
};

static int msi_wmi_platform_parse_buffer(union acpi_object *obj, u8 *output, size_t length)
{
        if (obj->type != ACPI_TYPE_BUFFER)
                return -ENOMSG;

        if (obj->buffer.length != length)
                return -EPROTO;

        if (!obj->buffer.pointer[0])
                return -EIO;

        memcpy(output, obj->buffer.pointer, obj->buffer.length);

        return 0;
}

static int msi_wmi_platform_query(struct msi_wmi_platform_data *data,
                                  enum msi_wmi_platform_method method, u8 *input,
                                  size_t input_length, u8 *output, size_t output_length)
{
        struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
        struct acpi_buffer in = {
                .length = input_length,
                .pointer = input
        };
        union acpi_object *obj;
        acpi_status status;
        int ret;

        if (!input_length || !output_length)
                return -EINVAL;

        /*
         * The ACPI control method responsible for handling the WMI method calls
         * is not thread-safe. Because of this we have to do the locking ourself.
         */
        scoped_guard(mutex, &data->wmi_lock) {
                status = wmidev_evaluate_method(data->wdev, 0x0, method, &in, &out);
                if (ACPI_FAILURE(status))
                        return -EIO;
        }

        obj = out.pointer;
        if (!obj)
                return -ENODATA;

        ret = msi_wmi_platform_parse_buffer(obj, output, output_length);
        kfree(obj);

        return ret;
}

static umode_t msi_wmi_platform_is_visible(const void *drvdata, enum hwmon_sensor_types type,
                                           u32 attr, int channel)
{
        return 0444;
}

static int msi_wmi_platform_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
                                 int channel, long *val)
{
        struct msi_wmi_platform_data *data = dev_get_drvdata(dev);
        u8 input[32] = { 0 };
        u8 output[32];
        u16 value;
        int ret;

        ret = msi_wmi_platform_query(data, MSI_PLATFORM_GET_FAN, input, sizeof(input), output,
                                     sizeof(output));
        if (ret < 0)
                return ret;

        value = get_unaligned_be16(&output[channel * 2 + 1]);
        if (!value)
                *val = 0;
        else
                *val = 480000 / value;

        return 0;
}

static const struct hwmon_ops msi_wmi_platform_ops = {
        .is_visible = msi_wmi_platform_is_visible,
        .read = msi_wmi_platform_read,
};

static const struct hwmon_channel_info * const msi_wmi_platform_info[] = {
        HWMON_CHANNEL_INFO(fan,
                           HWMON_F_INPUT,
                           HWMON_F_INPUT,
                           HWMON_F_INPUT,
                           HWMON_F_INPUT
                           ),
        NULL
};

static const struct hwmon_chip_info msi_wmi_platform_chip_info = {
        .ops = &msi_wmi_platform_ops,
        .info = msi_wmi_platform_info,
};

static ssize_t msi_wmi_platform_write(struct file *fp, const char __user *input, size_t length,
                                      loff_t *offset)
{
        struct seq_file *seq = fp->private_data;
        struct msi_wmi_platform_debugfs_data *data = seq->private;
        u8 payload[32] = { };
        ssize_t ret;

        /* Do not allow partial writes */
        if (*offset != 0)
                return -EINVAL;

        /* Do not allow incomplete command buffers */
        if (length != data->length)
                return -EINVAL;

        ret = simple_write_to_buffer(payload, sizeof(payload), offset, input, length);
        if (ret < 0)
                return ret;

        down_write(&data->buffer_lock);
        ret = msi_wmi_platform_query(data->data, data->method, payload, data->length, data->buffer,
                                     data->length);
        up_write(&data->buffer_lock);

        if (ret < 0)
                return ret;

        return length;
}

static int msi_wmi_platform_show(struct seq_file *seq, void *p)
{
        struct msi_wmi_platform_debugfs_data *data = seq->private;
        int ret;

        down_read(&data->buffer_lock);
        ret = seq_write(seq, data->buffer, data->length);
        up_read(&data->buffer_lock);

        return ret;
}

static int msi_wmi_platform_open(struct inode *inode, struct file *fp)
{
        struct msi_wmi_platform_debugfs_data *data = inode->i_private;

        /* The seq_file uses the last byte of the buffer for detecting buffer overflows */
        return single_open_size(fp, msi_wmi_platform_show, data, data->length + 1);
}

static const struct file_operations msi_wmi_platform_debugfs_fops = {
        .owner = THIS_MODULE,
        .open = msi_wmi_platform_open,
        .read = seq_read,
        .write = msi_wmi_platform_write,
        .llseek = seq_lseek,
        .release = single_release,
};

static void msi_wmi_platform_debugfs_remove(void *data)
{
        struct dentry *dir = data;

        debugfs_remove_recursive(dir);
}

static void msi_wmi_platform_debugfs_add(struct msi_wmi_platform_data *drvdata, struct dentry *dir,
                                         const char *name, enum msi_wmi_platform_method method)
{
        struct msi_wmi_platform_debugfs_data *data;
        struct dentry *entry;

        data = devm_kzalloc(&drvdata->wdev->dev, sizeof(*data), GFP_KERNEL);
        if (!data)
                return;

        data->data = drvdata;
        data->method = method;
        init_rwsem(&data->buffer_lock);

        /* The ACPI firmware for now always requires a 32 byte input buffer due to
         * a peculiarity in how Windows handles the CreateByteField() ACPI operator.
         */
        data->length = 32;

        entry = debugfs_create_file(name, 0600, dir, data, &msi_wmi_platform_debugfs_fops);
        if (IS_ERR(entry))
                devm_kfree(&drvdata->wdev->dev, data);
}

static void msi_wmi_platform_debugfs_init(struct msi_wmi_platform_data *data)
{
        struct dentry *dir;
        char dir_name[64];
        int ret, method;

        scnprintf(dir_name, ARRAY_SIZE(dir_name), "%s-%s", DRIVER_NAME, dev_name(&data->wdev->dev));

        dir = debugfs_create_dir(dir_name, NULL);
        if (IS_ERR(dir))
                return;

        ret = devm_add_action_or_reset(&data->wdev->dev, msi_wmi_platform_debugfs_remove, dir);
        if (ret < 0)
                return;

        for (method = MSI_PLATFORM_GET_PACKAGE; method <= MSI_PLATFORM_GET_WMI; method++)
                msi_wmi_platform_debugfs_add(data, dir, msi_wmi_platform_debugfs_names[method - 1],
                                             method);
}

static int msi_wmi_platform_hwmon_init(struct msi_wmi_platform_data *data)
{
        struct device *hdev;

        hdev = devm_hwmon_device_register_with_info(&data->wdev->dev, "msi_wmi_platform", data,
                                                    &msi_wmi_platform_chip_info, NULL);

        return PTR_ERR_OR_ZERO(hdev);
}

static int msi_wmi_platform_ec_init(struct msi_wmi_platform_data *data)
{
        u8 input[32] = { 0 };
        u8 output[32];
        u8 flags;
        int ret;

        ret = msi_wmi_platform_query(data, MSI_PLATFORM_GET_EC, input, sizeof(input), output,
                                     sizeof(output));
        if (ret < 0)
                return ret;

        flags = output[MSI_PLATFORM_EC_FLAGS_OFFSET];

        dev_dbg(&data->wdev->dev, "EC RAM version %lu.%lu\n",
                FIELD_GET(MSI_PLATFORM_EC_MAJOR_MASK, flags),
                FIELD_GET(MSI_PLATFORM_EC_MINOR_MASK, flags));
        dev_dbg(&data->wdev->dev, "EC firmware version %.28s\n",
                &output[MSI_PLATFORM_EC_VERSION_OFFSET]);

        if (!(flags & MSI_PLATFORM_EC_IS_TIGERLAKE)) {
                if (!force)
                        return -ENODEV;

                dev_warn(&data->wdev->dev, "Loading on a non-Tigerlake platform\n");
        }

        return 0;
}

static int msi_wmi_platform_init(struct msi_wmi_platform_data *data)
{
        u8 input[32] = { 0 };
        u8 output[32];
        int ret;

        ret = msi_wmi_platform_query(data, MSI_PLATFORM_GET_WMI, input, sizeof(input), output,
                                     sizeof(output));
        if (ret < 0)
                return ret;

        dev_dbg(&data->wdev->dev, "WMI interface version %u.%u\n",
                output[MSI_PLATFORM_WMI_MAJOR_OFFSET],
                output[MSI_PLATFORM_WMI_MINOR_OFFSET]);

        if (output[MSI_PLATFORM_WMI_MAJOR_OFFSET] != MSI_WMI_PLATFORM_INTERFACE_VERSION) {
                if (!force)
                        return -ENODEV;

                dev_warn(&data->wdev->dev,
                         "Loading despite unsupported WMI interface version (%u.%u)\n",
                         output[MSI_PLATFORM_WMI_MAJOR_OFFSET],
                         output[MSI_PLATFORM_WMI_MINOR_OFFSET]);
        }

        return 0;
}

static int msi_wmi_platform_probe(struct wmi_device *wdev, const void *context)
{
        struct msi_wmi_platform_data *data;
        int ret;

        data = devm_kzalloc(&wdev->dev, sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        data->wdev = wdev;
        dev_set_drvdata(&wdev->dev, data);

        ret = devm_mutex_init(&wdev->dev, &data->wmi_lock);
        if (ret < 0)
                return ret;

        ret = msi_wmi_platform_init(data);
        if (ret < 0)
                return ret;

        ret = msi_wmi_platform_ec_init(data);
        if (ret < 0)
                return ret;

        msi_wmi_platform_debugfs_init(data);

        return msi_wmi_platform_hwmon_init(data);
}

static const struct wmi_device_id msi_wmi_platform_id_table[] = {
        { MSI_PLATFORM_GUID, NULL },
        { }
};
MODULE_DEVICE_TABLE(wmi, msi_wmi_platform_id_table);

static struct wmi_driver msi_wmi_platform_driver = {
        .driver = {
                .name = DRIVER_NAME,
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table = msi_wmi_platform_id_table,
        .probe = msi_wmi_platform_probe,
        .no_singleton = true,
};

/*
 * MSI reused the WMI GUID from the WMI-ACPI sample code provided by Microsoft,
 * so other manufacturers might use it as well for their WMI-ACPI implementations.
 */
static const struct dmi_system_id msi_wmi_platform_whitelist[] __initconst = {
        {
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "MICRO-STAR INT"),
                },
        },
        {
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
                },
        },
        { }
};

static int __init msi_wmi_platform_module_init(void)
{
        if (!dmi_check_system(msi_wmi_platform_whitelist)) {
                if (!force)
                        return -ENODEV;

                pr_warn("Ignoring DMI whitelist\n");
        }

        return wmi_driver_register(&msi_wmi_platform_driver);
}

static void __exit msi_wmi_platform_module_exit(void)
{
        wmi_driver_unregister(&msi_wmi_platform_driver);
}

module_init(msi_wmi_platform_module_init);
module_exit(msi_wmi_platform_module_exit);


MODULE_AUTHOR("Armin Wolf <W_Armin@gmx.de>");
MODULE_DESCRIPTION("MSI WMI platform features");
MODULE_LICENSE("GPL");