[linux.git] / drivers / platform / x86 / msi-wmi-platform.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Linux driver for WMI platform features on MSI notebooks.
 *
 * Copyright (C) 2024 Armin Wolf <[email protected]>
 */

#define pr_format(fmt) KBUILD_MODNAME ": " fmt

#include <linux/acpi.h>
#include <linux/bits.h>
#include <linux/bitfield.h>
#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/device/driver.h>
#include <linux/errno.h>
#include <linux/hwmon.h>
#include <linux/kernel.h>
#include <linux/module.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_debugfs_data {
	struct wmi_device *wdev;
	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 wmi_device *wdev, 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;

	status = wmidev_evaluate_method(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 wmi_device *wdev = dev_get_drvdata(dev);
	u8 input[32] = { 0 };
	u8 output[32];
	u16 data;
	int ret;

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

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

	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->wdev, 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 wmi_device *wdev, 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(&wdev->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return;

	data->wdev = wdev;
	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(&wdev->dev, data);
}

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

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

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

	ret = devm_add_action_or_reset(&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(wdev, dir, msi_wmi_platform_debugfs_names[method - 1],
					     method);
}

static int msi_wmi_platform_hwmon_init(struct wmi_device *wdev)
{
	struct device *hdev;

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

	return PTR_ERR_OR_ZERO(hdev);
}

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

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

	flags = output[MSI_PLATFORM_EC_FLAGS_OFFSET];

	dev_dbg(&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(&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(&wdev->dev, "Loading on a non-Tigerlake platform\n");
	}

	return 0;
}

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

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

	dev_dbg(&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(&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)
{
	int ret;

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

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

	msi_wmi_platform_debugfs_init(wdev);

	return msi_wmi_platform_hwmon_init(wdev);
}

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,
};
module_wmi_driver(msi_wmi_platform_driver);

MODULE_AUTHOR("Armin Wolf <[email protected]>");
MODULE_DESCRIPTION("MSI WMI platform features");
MODULE_LICENSE("GPL");
Commit	Line	Data
9c0beb6b AW	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Linux driver for WMI platform features on MSI notebooks.
	4	*
	5	* Copyright (C) 2024 Armin Wolf <[email protected]>
	6	*/
	7
	8	#define pr_format(fmt) KBUILD_MODNAME ": " fmt
	9
	10	#include <linux/acpi.h>
	11	#include <linux/bits.h>
	12	#include <linux/bitfield.h>
	13	#include <linux/debugfs.h>
	14	#include <linux/device.h>
	15	#include <linux/device/driver.h>
	16	#include <linux/errno.h>
	17	#include <linux/hwmon.h>
	18	#include <linux/kernel.h>
	19	#include <linux/module.h>
	20	#include <linux/printk.h>
	21	#include <linux/rwsem.h>
	22	#include <linux/types.h>
	23	#include <linux/wmi.h>
	24
5f60d5f6	25	#include <linux/unaligned.h>
9c0beb6b AW	26
	27	#define DRIVER_NAME "msi-wmi-platform"
	28
	29	#define MSI_PLATFORM_GUID "ABBC0F6E-8EA1-11d1-00A0-C90629100000"
	30
	31	#define MSI_WMI_PLATFORM_INTERFACE_VERSION 2
	32
	33	#define MSI_PLATFORM_WMI_MAJOR_OFFSET 1
	34	#define MSI_PLATFORM_WMI_MINOR_OFFSET 2
	35
	36	#define MSI_PLATFORM_EC_FLAGS_OFFSET 1
	37	#define MSI_PLATFORM_EC_MINOR_MASK GENMASK(3, 0)
	38	#define MSI_PLATFORM_EC_MAJOR_MASK GENMASK(5, 4)
	39	#define MSI_PLATFORM_EC_CHANGED_PAGE BIT(6)
	40	#define MSI_PLATFORM_EC_IS_TIGERLAKE BIT(7)
	41	#define MSI_PLATFORM_EC_VERSION_OFFSET 2
	42
	43	static bool force;
	44	module_param_unsafe(force, bool, 0);
	45	MODULE_PARM_DESC(force, "Force loading without checking for supported WMI interface versions");
	46
	47	enum msi_wmi_platform_method {
	48	MSI_PLATFORM_GET_PACKAGE = 0x01,
	49	MSI_PLATFORM_SET_PACKAGE = 0x02,
	50	MSI_PLATFORM_GET_EC = 0x03,
	51	MSI_PLATFORM_SET_EC = 0x04,
	52	MSI_PLATFORM_GET_BIOS = 0x05,
	53	MSI_PLATFORM_SET_BIOS = 0x06,
	54	MSI_PLATFORM_GET_SMBUS = 0x07,
	55	MSI_PLATFORM_SET_SMBUS = 0x08,
	56	MSI_PLATFORM_GET_MASTER_BATTERY = 0x09,
	57	MSI_PLATFORM_SET_MASTER_BATTERY = 0x0a,
	58	MSI_PLATFORM_GET_SLAVE_BATTERY = 0x0b,
	59	MSI_PLATFORM_SET_SLAVE_BATTERY = 0x0c,
	60	MSI_PLATFORM_GET_TEMPERATURE = 0x0d,
	61	MSI_PLATFORM_SET_TEMPERATURE = 0x0e,
	62	MSI_PLATFORM_GET_THERMAL = 0x0f,
	63	MSI_PLATFORM_SET_THERMAL = 0x10,
	64	MSI_PLATFORM_GET_FAN = 0x11,
	65	MSI_PLATFORM_SET_FAN = 0x12,
	66	MSI_PLATFORM_GET_DEVICE = 0x13,
	67	MSI_PLATFORM_SET_DEVICE = 0x14,
	68	MSI_PLATFORM_GET_POWER = 0x15,
	69	MSI_PLATFORM_SET_POWER = 0x16,
	70	MSI_PLATFORM_GET_DEBUG = 0x17,
	71	MSI_PLATFORM_SET_DEBUG = 0x18,
	72	MSI_PLATFORM_GET_AP = 0x19,
	73	MSI_PLATFORM_SET_AP = 0x1a,
	74	MSI_PLATFORM_GET_DATA = 0x1b,
	75	MSI_PLATFORM_SET_DATA = 0x1c,
	76	MSI_PLATFORM_GET_WMI = 0x1d,
	77	};
	78
	79	struct msi_wmi_platform_debugfs_data {
	80	struct wmi_device *wdev;
	81	enum msi_wmi_platform_method method;
	82	struct rw_semaphore buffer_lock; /* Protects debugfs buffer */
	83	size_t length;
	84	u8 buffer[32];
	85	};
	86
	87	static const char * const msi_wmi_platform_debugfs_names[] = {
	88	"get_package",
	89	"set_package",
90	"get_ec",
91	"set_ec",
92	"get_bios",
93	"set_bios",
94	"get_smbus",
95	"set_smbus",
96	"get_master_battery",
97	"set_master_battery",
98	"get_slave_battery",
99	"set_slave_battery",
100	"get_temperature",
101	"set_temperature",
102	"get_thermal",
103	"set_thermal",
104	"get_fan",
105	"set_fan",
106	"get_device",
107	"set_device",
108	"get_power",
109	"set_power",
110	"get_debug",
111	"set_debug",
112	"get_ap",
113	"set_ap",
114	"get_data",
115	"set_data",
116	"get_wmi"
117	};
118
119	static int msi_wmi_platform_parse_buffer(union acpi_object obj, u8 output, size_t length)
120	{
121	if (obj->type != ACPI_TYPE_BUFFER)
122	return -ENOMSG;
123
124	if (obj->buffer.length != length)
125	return -EPROTO;
126
127	if (!obj->buffer.pointer[0])
128	return -EIO;
129
130	memcpy(output, obj->buffer.pointer, obj->buffer.length);
131
132	return 0;
133	}
134
135	static int msi_wmi_platform_query(struct wmi_device *wdev, enum msi_wmi_platform_method method,
136	u8 input, size_t input_length, u8 output, size_t output_length)
137	{
138	struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
139	struct acpi_buffer in = {
140	.length = input_length,
141	.pointer = input
142	};
143	union acpi_object *obj;
144	acpi_status status;
145	int ret;
146
147	if (!input_length \|\| !output_length)
148	return -EINVAL;
149
150	status = wmidev_evaluate_method(wdev, 0x0, method, &in, &out);
151	if (ACPI_FAILURE(status))
152	return -EIO;
153
154	obj = out.pointer;
155	if (!obj)
156	return -ENODATA;
157
158	ret = msi_wmi_platform_parse_buffer(obj, output, output_length);
159	kfree(obj);
160
161	return ret;
162	}
163
164	static umode_t msi_wmi_platform_is_visible(const void *drvdata, enum hwmon_sensor_types type,
165	u32 attr, int channel)
166	{
167	return 0444;
168	}
169
170	static int msi_wmi_platform_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
171	int channel, long *val)
172	{
173	struct wmi_device *wdev = dev_get_drvdata(dev);
174	u8 input[32] = { 0 };
175	u8 output[32];
176	u16 data;
177	int ret;
178
179	ret = msi_wmi_platform_query(wdev, MSI_PLATFORM_GET_FAN, input, sizeof(input), output,
180	sizeof(output));
181	if (ret < 0)
182	return ret;
183
184	data = get_unaligned_be16(&output[channel * 2 + 1]);
185	if (!data)
186	*val = 0;
187	else
188	*val = 480000 / data;
189
190	return 0;
191	}
192
193	static const struct hwmon_ops msi_wmi_platform_ops = {
194	.is_visible = msi_wmi_platform_is_visible,
195	.read = msi_wmi_platform_read,
196	};
197
198	static const struct hwmon_channel_info * const msi_wmi_platform_info[] = {
199	HWMON_CHANNEL_INFO(fan,
200	HWMON_F_INPUT,
201	HWMON_F_INPUT,
202	HWMON_F_INPUT,
203	HWMON_F_INPUT
204	),
205	NULL
206	};
207
208	static const struct hwmon_chip_info msi_wmi_platform_chip_info = {
209	.ops = &msi_wmi_platform_ops,
210	.info = msi_wmi_platform_info,
211	};
212
213	static ssize_t msi_wmi_platform_write(struct file fp, const char __user input, size_t length,
214	loff_t *offset)
215	{
216	struct seq_file *seq = fp->private_data;
217	struct msi_wmi_platform_debugfs_data *data = seq->private;
218	u8 payload[32] = { };
219	ssize_t ret;
220
221	/* Do not allow partial writes */
222	if (*offset != 0)
223	return -EINVAL;
224
225	/* Do not allow incomplete command buffers */
226	if (length != data->length)
227	return -EINVAL;
228
229	ret = simple_write_to_buffer(payload, sizeof(payload), offset, input, length);
230	if (ret < 0)
231	return ret;
232
233	down_write(&data->buffer_lock);
234	ret = msi_wmi_platform_query(data->wdev, data->method, payload, data->length, data->buffer,
235	data->length);
236	up_write(&data->buffer_lock);
237
238	if (ret < 0)
239	return ret;
240
241	return length;
242	}
243
244	static int msi_wmi_platform_show(struct seq_file seq, void p)
245	{
246	struct msi_wmi_platform_debugfs_data *data = seq->private;
247	int ret;
248
249	down_read(&data->buffer_lock);
250	ret = seq_write(seq, data->buffer, data->length);
251	up_read(&data->buffer_lock);
252
253	return ret;
254	}
255
256	static int msi_wmi_platform_open(struct inode inode, struct file fp)
257	{
258	struct msi_wmi_platform_debugfs_data *data = inode->i_private;
259
260	/* The seq_file uses the last byte of the buffer for detecting buffer overflows */
261	return single_open_size(fp, msi_wmi_platform_show, data, data->length + 1);
262	}
263
264	static const struct file_operations msi_wmi_platform_debugfs_fops = {
265	.owner = THIS_MODULE,
266	.open = msi_wmi_platform_open,
267	.read = seq_read,
268	.write = msi_wmi_platform_write,
269	.llseek = seq_lseek,
270	.release = single_release,
271	};
272
273	static void msi_wmi_platform_debugfs_remove(void *data)
274	{
275	struct dentry *dir = data;
276
277	debugfs_remove_recursive(dir);
278	}
279
280	static void msi_wmi_platform_debugfs_add(struct wmi_device wdev, struct dentry dir,
281	const char *name, enum msi_wmi_platform_method method)
282	{
283	struct msi_wmi_platform_debugfs_data *data;
284	struct dentry *entry;
285
286	data = devm_kzalloc(&wdev->dev, sizeof(*data), GFP_KERNEL);
287	if (!data)
288	return;
289
290	data->wdev = wdev;
291	data->method = method;
292	init_rwsem(&data->buffer_lock);
293
294	/* The ACPI firmware for now always requires a 32 byte input buffer due to
295	* a peculiarity in how Windows handles the CreateByteField() ACPI operator.
296	*/
297	data->length = 32;
298
299	entry = debugfs_create_file(name, 0600, dir, data, &msi_wmi_platform_debugfs_fops);
300	if (IS_ERR(entry))
301	devm_kfree(&wdev->dev, data);
302	}
303
304	static void msi_wmi_platform_debugfs_init(struct wmi_device *wdev)
305	{
306	struct dentry *dir;
307	char dir_name[64];
308	int ret, method;
309
310	scnprintf(dir_name, ARRAY_SIZE(dir_name), "%s-%s", DRIVER_NAME, dev_name(&wdev->dev));
311
312	dir = debugfs_create_dir(dir_name, NULL);
313	if (IS_ERR(dir))
314	return;
315
316	ret = devm_add_action_or_reset(&wdev->dev, msi_wmi_platform_debugfs_remove, dir);
317	if (ret < 0)
318	return;
319
320	for (method = MSI_PLATFORM_GET_PACKAGE; method <= MSI_PLATFORM_GET_WMI; method++)
321	msi_wmi_platform_debugfs_add(wdev, dir, msi_wmi_platform_debugfs_names[method - 1],
322	method);
323	}
324
325	static int msi_wmi_platform_hwmon_init(struct wmi_device *wdev)
326	{
327	struct device *hdev;
328
329	hdev = devm_hwmon_device_register_with_info(&wdev->dev, "msi_wmi_platform", wdev,
330	&msi_wmi_platform_chip_info, NULL);
331
332	return PTR_ERR_OR_ZERO(hdev);
333	}
334
335	static int msi_wmi_platform_ec_init(struct wmi_device *wdev)
336	{
337	u8 input[32] = { 0 };
338	u8 output[32];
339	u8 flags;
340	int ret;
341
342	ret = msi_wmi_platform_query(wdev, MSI_PLATFORM_GET_EC, input, sizeof(input), output,
343	sizeof(output));
344	if (ret < 0)
345	return ret;
346
347	flags = output[MSI_PLATFORM_EC_FLAGS_OFFSET];
348
349	dev_dbg(&wdev->dev, "EC RAM version %lu.%lu\n",
350	FIELD_GET(MSI_PLATFORM_EC_MAJOR_MASK, flags),
351	FIELD_GET(MSI_PLATFORM_EC_MINOR_MASK, flags));
352	dev_dbg(&wdev->dev, "EC firmware version %.28s\n",
353	&output[MSI_PLATFORM_EC_VERSION_OFFSET]);
354
355	if (!(flags & MSI_PLATFORM_EC_IS_TIGERLAKE)) {
356	if (!force)
357	return -ENODEV;
358
359	dev_warn(&wdev->dev, "Loading on a non-Tigerlake platform\n");
360	}
361
362	return 0;
363	}
364
365	static int msi_wmi_platform_init(struct wmi_device *wdev)
366	{
367	u8 input[32] = { 0 };
368	u8 output[32];
369	int ret;
370
371	ret = msi_wmi_platform_query(wdev, MSI_PLATFORM_GET_WMI, input, sizeof(input), output,
372	sizeof(output));
373	if (ret < 0)
374	return ret;
375
376	dev_dbg(&wdev->dev, "WMI interface version %u.%u\n",
377	output[MSI_PLATFORM_WMI_MAJOR_OFFSET],
378	output[MSI_PLATFORM_WMI_MINOR_OFFSET]);
379
380	if (output[MSI_PLATFORM_WMI_MAJOR_OFFSET] != MSI_WMI_PLATFORM_INTERFACE_VERSION) {
381	if (!force)
382	return -ENODEV;
383
384	dev_warn(&wdev->dev, "Loading despite unsupported WMI interface version (%u.%u)\n",
385	output[MSI_PLATFORM_WMI_MAJOR_OFFSET],
386	output[MSI_PLATFORM_WMI_MINOR_OFFSET]);
387	}
388
389	return 0;
390	}
391
392	static int msi_wmi_platform_probe(struct wmi_device wdev, const void context)
393	{
394	int ret;
395
396	ret = msi_wmi_platform_init(wdev);
397	if (ret < 0)
398	return ret;
399
400	ret = msi_wmi_platform_ec_init(wdev);
401	if (ret < 0)
402	return ret;
403
404	msi_wmi_platform_debugfs_init(wdev);
405
406	return msi_wmi_platform_hwmon_init(wdev);
407	}
408
409	static const struct wmi_device_id msi_wmi_platform_id_table[] = {
410	{ MSI_PLATFORM_GUID, NULL },
411	{ }
412	};
413	MODULE_DEVICE_TABLE(wmi, msi_wmi_platform_id_table);
414
415	static struct wmi_driver msi_wmi_platform_driver = {
416	.driver = {
417	.name = DRIVER_NAME,
418	.probe_type = PROBE_PREFER_ASYNCHRONOUS,
419	},
420	.id_table = msi_wmi_platform_id_table,
421	.probe = msi_wmi_platform_probe,
422	.no_singleton = true,
423	};
424	module_wmi_driver(msi_wmi_platform_driver);
425
426	MODULE_AUTHOR("Armin Wolf <[email protected]>");
427	MODULE_DESCRIPTION("MSI WMI platform features");
428	MODULE_LICENSE("GPL");