[mirror_ubuntu-bionic-kernel.git] / drivers / platform / x86 / dell-smbios-wmi.c

/*
 *  WMI methods for use with dell-smbios
 *
 *  Copyright (c) 2017 Dell Inc.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/dmi.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
#include <linux/wmi.h>
#include "dell-smbios.h"
#include "dell-wmi-descriptor.h"

static DEFINE_MUTEX(call_mutex);
static DEFINE_MUTEX(list_mutex);
static int wmi_supported;

struct misc_bios_flags_structure {
	struct dmi_header header;
	u16 flags0;
} __packed;
#define FLAG_HAS_ACPI_WMI 0x02

#define DELL_WMI_SMBIOS_GUID "A80593CE-A997-11DA-B012-B622A1EF5492"

struct wmi_smbios_priv {
	struct dell_wmi_smbios_buffer *buf;
	struct list_head list;
	struct wmi_device *wdev;
	struct device *child;
	u32 req_buf_size;
};
static LIST_HEAD(wmi_list);

static inline struct wmi_smbios_priv *get_first_smbios_priv(void)
{
	return list_first_entry_or_null(&wmi_list,
					struct wmi_smbios_priv,
					list);
}

static int run_smbios_call(struct wmi_device *wdev)
{
	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
	struct wmi_smbios_priv *priv;
	struct acpi_buffer input;
	union acpi_object *obj;
	acpi_status status;

	priv = dev_get_drvdata(&wdev->dev);
	input.length = priv->req_buf_size - sizeof(u64);
	input.pointer = &priv->buf->std;

	dev_dbg(&wdev->dev, "evaluating: %u/%u [%x,%x,%x,%x]\n",
		priv->buf->std.cmd_class, priv->buf->std.cmd_select,
		priv->buf->std.input[0], priv->buf->std.input[1],
		priv->buf->std.input[2], priv->buf->std.input[3]);

	status = wmidev_evaluate_method(wdev, 0, 1, &input, &output);
	if (ACPI_FAILURE(status))
		return -EIO;
	obj = (union acpi_object *)output.pointer;
	if (obj->type != ACPI_TYPE_BUFFER) {
		dev_dbg(&wdev->dev, "received type: %d\n", obj->type);
		if (obj->type == ACPI_TYPE_INTEGER)
			dev_dbg(&wdev->dev, "SMBIOS call failed: %llu\n",
				obj->integer.value);
		return -EIO;
	}
	memcpy(&priv->buf->std, obj->buffer.pointer, obj->buffer.length);
	dev_dbg(&wdev->dev, "result: [%08x,%08x,%08x,%08x]\n",
		priv->buf->std.output[0], priv->buf->std.output[1],
		priv->buf->std.output[2], priv->buf->std.output[3]);

	return 0;
}

int dell_smbios_wmi_call(struct calling_interface_buffer *buffer)
{
	struct wmi_smbios_priv *priv;
	size_t difference;
	size_t size;
	int ret;

	mutex_lock(&call_mutex);
	priv = get_first_smbios_priv();
	if (!priv) {
		ret = -ENODEV;
		goto out_wmi_call;
	}

	size = sizeof(struct calling_interface_buffer);
	difference = priv->req_buf_size - sizeof(u64) - size;

	memset(&priv->buf->ext, 0, difference);
	memcpy(&priv->buf->std, buffer, size);
	ret = run_smbios_call(priv->wdev);
	memcpy(buffer, &priv->buf->std, size);
out_wmi_call:
	mutex_unlock(&call_mutex);

	return ret;
}

static long dell_smbios_wmi_filter(struct wmi_device *wdev, unsigned int cmd,
				   struct wmi_ioctl_buffer *arg)
{
	struct wmi_smbios_priv *priv;
	int ret = 0;

	switch (cmd) {
	case DELL_WMI_SMBIOS_CMD:
		mutex_lock(&call_mutex);
		priv = dev_get_drvdata(&wdev->dev);
		if (!priv) {
			ret = -ENODEV;
			goto fail_smbios_cmd;
		}
		memcpy(priv->buf, arg, priv->req_buf_size);
		if (dell_smbios_call_filter(&wdev->dev, &priv->buf->std)) {
			dev_err(&wdev->dev, "Invalid call %d/%d:%8x\n",
				priv->buf->std.cmd_class,
				priv->buf->std.cmd_select,
				priv->buf->std.input[0]);
			ret = -EFAULT;
			goto fail_smbios_cmd;
		}
		ret = run_smbios_call(priv->wdev);
		if (ret)
			goto fail_smbios_cmd;
		memcpy(arg, priv->buf, priv->req_buf_size);
fail_smbios_cmd:
		mutex_unlock(&call_mutex);
		break;
	default:
		ret = -ENOIOCTLCMD;
	}
	return ret;
}

static int dell_smbios_wmi_probe(struct wmi_device *wdev)
{
	struct wmi_driver *wdriver =
		container_of(wdev->dev.driver, struct wmi_driver, driver);
	struct wmi_smbios_priv *priv;
	u32 hotfix;
	int count;
	int ret;

	ret = dell_wmi_get_descriptor_valid();
	if (ret)
		return ret;

	priv = devm_kzalloc(&wdev->dev, sizeof(struct wmi_smbios_priv),
			    GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	/* WMI buffer size will be either 4k or 32k depending on machine */
	if (!dell_wmi_get_size(&priv->req_buf_size))
		return -EPROBE_DEFER;

	/* some SMBIOS calls fail unless BIOS contains hotfix */
	if (!dell_wmi_get_hotfix(&hotfix))
		return -EPROBE_DEFER;
	if (!hotfix) {
		dev_warn(&wdev->dev,
			"WMI SMBIOS userspace interface not supported(%u), try upgrading to a newer BIOS\n",
			hotfix);
		wdriver->filter_callback = NULL;
	}

	/* add in the length object we will use internally with ioctl */
	priv->req_buf_size += sizeof(u64);
	ret = set_required_buffer_size(wdev, priv->req_buf_size);
	if (ret)
		return ret;

	count = get_order(priv->req_buf_size);
	priv->buf = (void *)__get_free_pages(GFP_KERNEL, count);
	if (!priv->buf)
		return -ENOMEM;

	/* ID is used by dell-smbios to set priority of drivers */
	wdev->dev.id = 1;
	ret = dell_smbios_register_device(&wdev->dev, &dell_smbios_wmi_call);
	if (ret)
		goto fail_register;

	priv->wdev = wdev;
	dev_set_drvdata(&wdev->dev, priv);
	mutex_lock(&list_mutex);
	list_add_tail(&priv->list, &wmi_list);
	mutex_unlock(&list_mutex);

	return 0;

fail_register:
	free_pages((unsigned long)priv->buf, count);
	return ret;
}

static int dell_smbios_wmi_remove(struct wmi_device *wdev)
{
	struct wmi_smbios_priv *priv = dev_get_drvdata(&wdev->dev);
	int count;

	mutex_lock(&call_mutex);
	mutex_lock(&list_mutex);
	list_del(&priv->list);
	mutex_unlock(&list_mutex);
	dell_smbios_unregister_device(&wdev->dev);
	count = get_order(priv->req_buf_size);
	free_pages((unsigned long)priv->buf, count);
	mutex_unlock(&call_mutex);
	return 0;
}

static const struct wmi_device_id dell_smbios_wmi_id_table[] = {
	{ .guid_string = DELL_WMI_SMBIOS_GUID },
	{ },
};

static void __init parse_b1_table(const struct dmi_header *dm)
{
	struct misc_bios_flags_structure *flags =
	container_of(dm, struct misc_bios_flags_structure, header);

	/* 4 bytes header, 8 bytes flags */
	if (dm->length < 12)
		return;
	if (dm->handle != 0xb100)
		return;
	if ((flags->flags0 & FLAG_HAS_ACPI_WMI))
		wmi_supported = 1;
}

static void __init find_b1(const struct dmi_header *dm, void *dummy)
{
	switch (dm->type) {
	case 0xb1: /* misc bios flags */
		parse_b1_table(dm);
		break;
	}
}

static struct wmi_driver dell_smbios_wmi_driver = {
	.driver = {
		.name = "dell-smbios",
	},
	.probe = dell_smbios_wmi_probe,
	.remove = dell_smbios_wmi_remove,
	.id_table = dell_smbios_wmi_id_table,
	.filter_callback = dell_smbios_wmi_filter,
};

static int __init init_dell_smbios_wmi(void)
{
	dmi_walk(find_b1, NULL);

	if (!wmi_supported)
		return -ENODEV;

	return wmi_driver_register(&dell_smbios_wmi_driver);
}

static void __exit exit_dell_smbios_wmi(void)
{
	wmi_driver_unregister(&dell_smbios_wmi_driver);
}

module_init(init_dell_smbios_wmi);
module_exit(exit_dell_smbios_wmi);

MODULE_ALIAS("wmi:" DELL_WMI_SMBIOS_GUID);
MODULE_AUTHOR("Mario Limonciello <mario.limonciello@dell.com>");
MODULE_DESCRIPTION("Dell SMBIOS communications over WMI");
MODULE_LICENSE("GPL");
Commit	Line	Data
1a258e67 ML	1	/*
	2	* WMI methods for use with dell-smbios
	3	*
	4	* Copyright (c) 2017 Dell Inc.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	11
	12	#include <linux/dmi.h>
	13	#include <linux/list.h>
	14	#include <linux/module.h>
	15	#include <linux/mutex.h>
	16	#include <linux/uaccess.h>
	17	#include <linux/wmi.h>
	18	#include "dell-smbios.h"
	19	#include "dell-wmi-descriptor.h"
	20
	21	static DEFINE_MUTEX(call_mutex);
	22	static DEFINE_MUTEX(list_mutex);
	23	static int wmi_supported;
	24
	25	struct misc_bios_flags_structure {
	26	struct dmi_header header;
	27	u16 flags0;
	28	} __packed;
	29	#define FLAG_HAS_ACPI_WMI 0x02
	30
	31	#define DELL_WMI_SMBIOS_GUID "A80593CE-A997-11DA-B012-B622A1EF5492"
	32
1a258e67 ML	33	struct wmi_smbios_priv {
	34	struct dell_wmi_smbios_buffer *buf;
	35	struct list_head list;
	36	struct wmi_device *wdev;
	37	struct device *child;
	38	u32 req_buf_size;
	39	};
	40	static LIST_HEAD(wmi_list);
	41
	42	static inline struct wmi_smbios_priv *get_first_smbios_priv(void)
	43	{
	44	return list_first_entry_or_null(&wmi_list,
	45	struct wmi_smbios_priv,
	46	list);
	47	}
	48
	49	static int run_smbios_call(struct wmi_device *wdev)
	50	{
	51	struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
	52	struct wmi_smbios_priv *priv;
	53	struct acpi_buffer input;
	54	union acpi_object *obj;
	55	acpi_status status;
	56
	57	priv = dev_get_drvdata(&wdev->dev);
	58	input.length = priv->req_buf_size - sizeof(u64);
	59	input.pointer = &priv->buf->std;
	60
	61	dev_dbg(&wdev->dev, "evaluating: %u/%u [%x,%x,%x,%x]\n",
	62	priv->buf->std.cmd_class, priv->buf->std.cmd_select,
	63	priv->buf->std.input[0], priv->buf->std.input[1],
	64	priv->buf->std.input[2], priv->buf->std.input[3]);
	65
	66	status = wmidev_evaluate_method(wdev, 0, 1, &input, &output);
	67	if (ACPI_FAILURE(status))
	68	return -EIO;
	69	obj = (union acpi_object *)output.pointer;
	70	if (obj->type != ACPI_TYPE_BUFFER) {
	71	dev_dbg(&wdev->dev, "received type: %d\n", obj->type);
	72	if (obj->type == ACPI_TYPE_INTEGER)
	73	dev_dbg(&wdev->dev, "SMBIOS call failed: %llu\n",
	74	obj->integer.value);
	75	return -EIO;
	76	}
	77	memcpy(&priv->buf->std, obj->buffer.pointer, obj->buffer.length);
	78	dev_dbg(&wdev->dev, "result: [%08x,%08x,%08x,%08x]\n",
	79	priv->buf->std.output[0], priv->buf->std.output[1],
	80	priv->buf->std.output[2], priv->buf->std.output[3]);
	81
	82	return 0;
	83	}
	84
	85	int dell_smbios_wmi_call(struct calling_interface_buffer *buffer)
	86	{
	87	struct wmi_smbios_priv *priv;
	88	size_t difference;
	89	size_t size;
	90	int ret;
	91
	92	mutex_lock(&call_mutex);
	93	priv = get_first_smbios_priv();
307ab2a9 ML	94	if (!priv) {
	95	ret = -ENODEV;
	96	goto out_wmi_call;
	97	}
1a258e67 ML	98
	99	size = sizeof(struct calling_interface_buffer);
	100	difference = priv->req_buf_size - sizeof(u64) - size;
	101
	102	memset(&priv->buf->ext, 0, difference);
	103	memcpy(&priv->buf->std, buffer, size);
	104	ret = run_smbios_call(priv->wdev);
	105	memcpy(buffer, &priv->buf->std, size);
307ab2a9	106	out_wmi_call:
1a258e67 ML	107	mutex_unlock(&call_mutex);
	108
	109	return ret;
	110	}
	111
f2645fa3 ML	112	static long dell_smbios_wmi_filter(struct wmi_device *wdev, unsigned int cmd,
	113	struct wmi_ioctl_buffer *arg)
	114	{
	115	struct wmi_smbios_priv *priv;
	116	int ret = 0;
	117
	118	switch (cmd) {
	119	case DELL_WMI_SMBIOS_CMD:
	120	mutex_lock(&call_mutex);
	121	priv = dev_get_drvdata(&wdev->dev);
	122	if (!priv) {
	123	ret = -ENODEV;
	124	goto fail_smbios_cmd;
	125	}
	126	memcpy(priv->buf, arg, priv->req_buf_size);
	127	if (dell_smbios_call_filter(&wdev->dev, &priv->buf->std)) {
	128	dev_err(&wdev->dev, "Invalid call %d/%d:%8x\n",
	129	priv->buf->std.cmd_class,
	130	priv->buf->std.cmd_select,
	131	priv->buf->std.input[0]);
	132	ret = -EFAULT;
	133	goto fail_smbios_cmd;
	134	}
	135	ret = run_smbios_call(priv->wdev);
	136	if (ret)
	137	goto fail_smbios_cmd;
	138	memcpy(arg, priv->buf, priv->req_buf_size);
	139	fail_smbios_cmd:
	140	mutex_unlock(&call_mutex);
	141	break;
	142	default:
	143	ret = -ENOIOCTLCMD;
	144	}
	145	return ret;
	146	}
	147
1a258e67 ML	148	static int dell_smbios_wmi_probe(struct wmi_device *wdev)
1a258e67 ML	149	{
4255c30f ML	150	struct wmi_driver *wdriver =
4255c30f ML	151	container_of(wdev->dev.driver, struct wmi_driver, driver);
1a258e67	152	struct wmi_smbios_priv *priv;
4255c30f	153	u32 hotfix;
1a258e67 ML	154	int count;
	155	int ret;
	156
868b8d33 ML	157	ret = dell_wmi_get_descriptor_valid();
	158	if (ret)
	159	return ret;
1a258e67 ML	160
	161	priv = devm_kzalloc(&wdev->dev, sizeof(struct wmi_smbios_priv),
	162	GFP_KERNEL);
	163	if (!priv)
	164	return -ENOMEM;
	165
	166	/* WMI buffer size will be either 4k or 32k depending on machine */
	167	if (!dell_wmi_get_size(&priv->req_buf_size))
	168	return -EPROBE_DEFER;
	169
4255c30f ML	170	/* some SMBIOS calls fail unless BIOS contains hotfix */
	171	if (!dell_wmi_get_hotfix(&hotfix))
	172	return -EPROBE_DEFER;
	173	if (!hotfix) {
	174	dev_warn(&wdev->dev,
	175	"WMI SMBIOS userspace interface not supported(%u), try upgrading to a newer BIOS\n",
	176	hotfix);
	177	wdriver->filter_callback = NULL;
	178	}
	179
f2645fa3 ML	180	/* add in the length object we will use internally with ioctl */
	181	priv->req_buf_size += sizeof(u64);
	182	ret = set_required_buffer_size(wdev, priv->req_buf_size);
	183	if (ret)
	184	return ret;
	185
1a258e67 ML	186	count = get_order(priv->req_buf_size);
	187	priv->buf = (void *)__get_free_pages(GFP_KERNEL, count);
	188	if (!priv->buf)
	189	return -ENOMEM;
	190
	191	/* ID is used by dell-smbios to set priority of drivers */
	192	wdev->dev.id = 1;
	193	ret = dell_smbios_register_device(&wdev->dev, &dell_smbios_wmi_call);
	194	if (ret)
	195	goto fail_register;
	196
	197	priv->wdev = wdev;
	198	dev_set_drvdata(&wdev->dev, priv);
	199	mutex_lock(&list_mutex);
	200	list_add_tail(&priv->list, &wmi_list);
	201	mutex_unlock(&list_mutex);
	202
	203	return 0;
	204
	205	fail_register:
	206	free_pages((unsigned long)priv->buf, count);
	207	return ret;
	208	}
	209
	210	static int dell_smbios_wmi_remove(struct wmi_device *wdev)
	211	{
	212	struct wmi_smbios_priv *priv = dev_get_drvdata(&wdev->dev);
	213	int count;
	214
	215	mutex_lock(&call_mutex);
	216	mutex_lock(&list_mutex);
	217	list_del(&priv->list);
	218	mutex_unlock(&list_mutex);
	219	dell_smbios_unregister_device(&wdev->dev);
	220	count = get_order(priv->req_buf_size);
	221	free_pages((unsigned long)priv->buf, count);
	222	mutex_unlock(&call_mutex);
	223	return 0;
	224	}
	225
	226	static const struct wmi_device_id dell_smbios_wmi_id_table[] = {
	227	{ .guid_string = DELL_WMI_SMBIOS_GUID },
	228	{ },
	229	};
	230
	231	static void __init parse_b1_table(const struct dmi_header *dm)
	232	{
	233	struct misc_bios_flags_structure *flags =
	234	container_of(dm, struct misc_bios_flags_structure, header);
	235
	236	/* 4 bytes header, 8 bytes flags */
	237	if (dm->length < 12)
	238	return;
	239	if (dm->handle != 0xb100)
	240	return;
	241	if ((flags->flags0 & FLAG_HAS_ACPI_WMI))
	242	wmi_supported = 1;
	243	}
	244
	245	static void __init find_b1(const struct dmi_header dm, void dummy)
	246	{
	247	switch (dm->type) {
	248	case 0xb1: /* misc bios flags */
	249	parse_b1_table(dm);
250	break;
251	}
252	}
253
254	static struct wmi_driver dell_smbios_wmi_driver = {
255	.driver = {
256	.name = "dell-smbios",
257	},
258	.probe = dell_smbios_wmi_probe,
259	.remove = dell_smbios_wmi_remove,
260	.id_table = dell_smbios_wmi_id_table,
f2645fa3	261	.filter_callback = dell_smbios_wmi_filter,
1a258e67 ML	262	};
	263
	264	static int __init init_dell_smbios_wmi(void)
	265	{
	266	dmi_walk(find_b1, NULL);
	267
	268	if (!wmi_supported)
	269	return -ENODEV;
	270
	271	return wmi_driver_register(&dell_smbios_wmi_driver);
	272	}
	273
	274	static void __exit exit_dell_smbios_wmi(void)
	275	{
	276	wmi_driver_unregister(&dell_smbios_wmi_driver);
	277	}
	278
	279	module_init(init_dell_smbios_wmi);
	280	module_exit(exit_dell_smbios_wmi);
	281
	282	MODULE_ALIAS("wmi:" DELL_WMI_SMBIOS_GUID);
	283	MODULE_AUTHOR("Mario Limonciello <mario.limonciello@dell.com>");
	284	MODULE_DESCRIPTION("Dell SMBIOS communications over WMI");
	285	MODULE_LICENSE("GPL");