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

/*
 * Dell WMI descriptor driver
 *
 * Copyright (C) 2017 Dell Inc. All Rights Reserved.
 *
 *  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.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/acpi.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/wmi.h>
#include "dell-wmi-descriptor.h"

#define DELL_WMI_DESCRIPTOR_GUID "8D9DDCBC-A997-11DA-B012-B622A1EF5492"

struct descriptor_priv {
	struct list_head list;
	u32 interface_version;
	u32 size;
	u32 hotfix;
};
static int descriptor_valid = -EPROBE_DEFER;
static LIST_HEAD(wmi_list);
static DEFINE_MUTEX(list_mutex);

int dell_wmi_get_descriptor_valid(void)
{
	if (!wmi_has_guid(DELL_WMI_DESCRIPTOR_GUID))
		return -ENODEV;

	return descriptor_valid;
}
EXPORT_SYMBOL_GPL(dell_wmi_get_descriptor_valid);

bool dell_wmi_get_interface_version(u32 *version)
{
	struct descriptor_priv *priv;
	bool ret = false;

	mutex_lock(&list_mutex);
	priv = list_first_entry_or_null(&wmi_list,
					struct descriptor_priv,
					list);
	if (priv) {
		*version = priv->interface_version;
		ret = true;
	}
	mutex_unlock(&list_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(dell_wmi_get_interface_version);

bool dell_wmi_get_size(u32 *size)
{
	struct descriptor_priv *priv;
	bool ret = false;

	mutex_lock(&list_mutex);
	priv = list_first_entry_or_null(&wmi_list,
					struct descriptor_priv,
					list);
	if (priv) {
		*size = priv->size;
		ret = true;
	}
	mutex_unlock(&list_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(dell_wmi_get_size);

bool dell_wmi_get_hotfix(u32 *hotfix)
{
	struct descriptor_priv *priv;
	bool ret = false;

	mutex_lock(&list_mutex);
	priv = list_first_entry_or_null(&wmi_list,
					struct descriptor_priv,
					list);
	if (priv) {
		*hotfix = priv->hotfix;
		ret = true;
	}
	mutex_unlock(&list_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(dell_wmi_get_hotfix);

/*
 * Descriptor buffer is 128 byte long and contains:
 *
 *       Name             Offset  Length  Value
 * Vendor Signature          0       4    "DELL"
 * Object Signature          4       4    " WMI"
 * WMI Interface Version     8       4    <version>
 * WMI buffer length        12       4    <length>
 * WMI hotfix number        16       4    <hotfix>
 */
static int dell_wmi_descriptor_probe(struct wmi_device *wdev)
{
	union acpi_object *obj = NULL;
	struct descriptor_priv *priv;
	u32 *buffer;
	int ret;

	obj = wmidev_block_query(wdev, 0);
	if (!obj) {
		dev_err(&wdev->dev, "failed to read Dell WMI descriptor\n");
		ret = -EIO;
		goto out;
	}

	if (obj->type != ACPI_TYPE_BUFFER) {
		dev_err(&wdev->dev, "Dell descriptor has wrong type\n");
		ret = -EINVAL;
		descriptor_valid = ret;
		goto out;
	}

	/* Although it's not technically a failure, this would lead to
	 * unexpected behavior
	 */
	if (obj->buffer.length != 128) {
		dev_err(&wdev->dev,
			"Dell descriptor buffer has unexpected length (%d)\n",
			obj->buffer.length);
		ret = -EINVAL;
		descriptor_valid = ret;
		goto out;
	}

	buffer = (u32 *)obj->buffer.pointer;

	if (strncmp(obj->string.pointer, "DELL WMI", 8) != 0) {
		dev_err(&wdev->dev, "Dell descriptor buffer has invalid signature (%8ph)\n",
			buffer);
		ret = -EINVAL;
		descriptor_valid = ret;
		goto out;
	}
	descriptor_valid = 0;

	if (buffer[2] != 0 && buffer[2] != 1)
		dev_warn(&wdev->dev, "Dell descriptor buffer has unknown version (%lu)\n",
			(unsigned long) buffer[2]);

	priv = devm_kzalloc(&wdev->dev, sizeof(struct descriptor_priv),
	GFP_KERNEL);

	if (!priv) {
		ret = -ENOMEM;
		goto out;
	}

	priv->interface_version = buffer[2];
	priv->size = buffer[3];
	priv->hotfix = buffer[4];
	ret = 0;
	dev_set_drvdata(&wdev->dev, priv);
	mutex_lock(&list_mutex);
	list_add_tail(&priv->list, &wmi_list);
	mutex_unlock(&list_mutex);

	dev_dbg(&wdev->dev, "Detected Dell WMI interface version %lu, buffer size %lu, hotfix %lu\n",
		(unsigned long) priv->interface_version,
		(unsigned long) priv->size,
		(unsigned long) priv->hotfix);

out:
	kfree(obj);
	return ret;
}

static int dell_wmi_descriptor_remove(struct wmi_device *wdev)
{
	struct descriptor_priv *priv = dev_get_drvdata(&wdev->dev);

	mutex_lock(&list_mutex);
	list_del(&priv->list);
	mutex_unlock(&list_mutex);
	return 0;
}

static const struct wmi_device_id dell_wmi_descriptor_id_table[] = {
	{ .guid_string = DELL_WMI_DESCRIPTOR_GUID },
	{ },
};

static struct wmi_driver dell_wmi_descriptor_driver = {
	.driver = {
		.name = "dell-wmi-descriptor",
	},
	.probe = dell_wmi_descriptor_probe,
	.remove = dell_wmi_descriptor_remove,
	.id_table = dell_wmi_descriptor_id_table,
};

module_wmi_driver(dell_wmi_descriptor_driver);

MODULE_ALIAS("wmi:" DELL_WMI_DESCRIPTOR_GUID);
MODULE_AUTHOR("Mario Limonciello <mario.limonciello@dell.com>");
MODULE_DESCRIPTION("Dell WMI descriptor driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
92b8c540 ML	1	/*
	2	* Dell WMI descriptor driver
	3	*
	4	* Copyright (C) 2017 Dell Inc. All Rights Reserved.
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License version 2 as published
	8	* by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15
	16	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	17
	18	#include <linux/acpi.h>
	19	#include <linux/list.h>
	20	#include <linux/module.h>
	21	#include <linux/wmi.h>
	22	#include "dell-wmi-descriptor.h"
	23
868b8d33 ML	24	#define DELL_WMI_DESCRIPTOR_GUID "8D9DDCBC-A997-11DA-B012-B622A1EF5492"
868b8d33 ML	25
92b8c540 ML	26	struct descriptor_priv {
	27	struct list_head list;
	28	u32 interface_version;
	29	u32 size;
4255c30f	30	u32 hotfix;
92b8c540	31	};
868b8d33	32	static int descriptor_valid = -EPROBE_DEFER;
92b8c540 ML	33	static LIST_HEAD(wmi_list);
	34	static DEFINE_MUTEX(list_mutex);
	35
868b8d33 ML	36	int dell_wmi_get_descriptor_valid(void)
	37	{
	38	if (!wmi_has_guid(DELL_WMI_DESCRIPTOR_GUID))
	39	return -ENODEV;
	40
	41	return descriptor_valid;
	42	}
	43	EXPORT_SYMBOL_GPL(dell_wmi_get_descriptor_valid);
	44
92b8c540 ML	45	bool dell_wmi_get_interface_version(u32 *version)
	46	{
	47	struct descriptor_priv *priv;
	48	bool ret = false;
	49
	50	mutex_lock(&list_mutex);
	51	priv = list_first_entry_or_null(&wmi_list,
	52	struct descriptor_priv,
	53	list);
	54	if (priv) {
	55	*version = priv->interface_version;
	56	ret = true;
	57	}
	58	mutex_unlock(&list_mutex);
	59	return ret;
	60	}
	61	EXPORT_SYMBOL_GPL(dell_wmi_get_interface_version);
	62
	63	bool dell_wmi_get_size(u32 *size)
	64	{
	65	struct descriptor_priv *priv;
	66	bool ret = false;
	67
	68	mutex_lock(&list_mutex);
	69	priv = list_first_entry_or_null(&wmi_list,
	70	struct descriptor_priv,
	71	list);
	72	if (priv) {
	73	*size = priv->size;
	74	ret = true;
	75	}
	76	mutex_unlock(&list_mutex);
	77	return ret;
	78	}
	79	EXPORT_SYMBOL_GPL(dell_wmi_get_size);
	80
4255c30f ML	81	bool dell_wmi_get_hotfix(u32 *hotfix)
	82	{
	83	struct descriptor_priv *priv;
	84	bool ret = false;
	85
	86	mutex_lock(&list_mutex);
	87	priv = list_first_entry_or_null(&wmi_list,
	88	struct descriptor_priv,
	89	list);
	90	if (priv) {
	91	*hotfix = priv->hotfix;
	92	ret = true;
	93	}
	94	mutex_unlock(&list_mutex);
	95	return ret;
	96	}
	97	EXPORT_SYMBOL_GPL(dell_wmi_get_hotfix);
	98
92b8c540 ML	99	/*
	100	* Descriptor buffer is 128 byte long and contains:
	101	*
	102	* Name Offset Length Value
	103	* Vendor Signature 0 4 "DELL"
	104	* Object Signature 4 4 " WMI"
	105	* WMI Interface Version 8 4 <version>
	106	* WMI buffer length 12 4 <length>
4255c30f	107	* WMI hotfix number 16 4 <hotfix>
92b8c540 ML	108	*/
	109	static int dell_wmi_descriptor_probe(struct wmi_device *wdev)
	110	{
	111	union acpi_object *obj = NULL;
	112	struct descriptor_priv *priv;
	113	u32 *buffer;
	114	int ret;
	115
	116	obj = wmidev_block_query(wdev, 0);
	117	if (!obj) {
	118	dev_err(&wdev->dev, "failed to read Dell WMI descriptor\n");
	119	ret = -EIO;
	120	goto out;
	121	}
	122
	123	if (obj->type != ACPI_TYPE_BUFFER) {
	124	dev_err(&wdev->dev, "Dell descriptor has wrong type\n");
	125	ret = -EINVAL;
868b8d33	126	descriptor_valid = ret;
92b8c540 ML	127	goto out;
	128	}
	129
	130	/* Although it's not technically a failure, this would lead to
	131	* unexpected behavior
	132	*/
	133	if (obj->buffer.length != 128) {
	134	dev_err(&wdev->dev,
	135	"Dell descriptor buffer has unexpected length (%d)\n",
	136	obj->buffer.length);
	137	ret = -EINVAL;
868b8d33	138	descriptor_valid = ret;
92b8c540 ML	139	goto out;
	140	}
	141
	142	buffer = (u32 *)obj->buffer.pointer;
	143
	144	if (strncmp(obj->string.pointer, "DELL WMI", 8) != 0) {
	145	dev_err(&wdev->dev, "Dell descriptor buffer has invalid signature (%8ph)\n",
	146	buffer);
	147	ret = -EINVAL;
868b8d33	148	descriptor_valid = ret;
92b8c540 ML	149	goto out;
92b8c540 ML	150	}
868b8d33	151	descriptor_valid = 0;
92b8c540 ML	152
	153	if (buffer[2] != 0 && buffer[2] != 1)
	154	dev_warn(&wdev->dev, "Dell descriptor buffer has unknown version (%lu)\n",
	155	(unsigned long) buffer[2]);
	156
	157	priv = devm_kzalloc(&wdev->dev, sizeof(struct descriptor_priv),
	158	GFP_KERNEL);
	159
8b9528a6 ML	160	if (!priv) {
	161	ret = -ENOMEM;
	162	goto out;
	163	}
	164
92b8c540 ML	165	priv->interface_version = buffer[2];
92b8c540 ML	166	priv->size = buffer[3];
4255c30f	167	priv->hotfix = buffer[4];
92b8c540 ML	168	ret = 0;
	169	dev_set_drvdata(&wdev->dev, priv);
	170	mutex_lock(&list_mutex);
	171	list_add_tail(&priv->list, &wmi_list);
	172	mutex_unlock(&list_mutex);
	173
4255c30f	174	dev_dbg(&wdev->dev, "Detected Dell WMI interface version %lu, buffer size %lu, hotfix %lu\n",
92b8c540	175	(unsigned long) priv->interface_version,
4255c30f ML	176	(unsigned long) priv->size,
4255c30f ML	177	(unsigned long) priv->hotfix);
92b8c540 ML	178
	179	out:
	180	kfree(obj);
	181	return ret;
	182	}
	183
	184	static int dell_wmi_descriptor_remove(struct wmi_device *wdev)
	185	{
	186	struct descriptor_priv *priv = dev_get_drvdata(&wdev->dev);
	187
	188	mutex_lock(&list_mutex);
	189	list_del(&priv->list);
	190	mutex_unlock(&list_mutex);
	191	return 0;
	192	}
	193
	194	static const struct wmi_device_id dell_wmi_descriptor_id_table[] = {
	195	{ .guid_string = DELL_WMI_DESCRIPTOR_GUID },
	196	{ },
	197	};
	198
	199	static struct wmi_driver dell_wmi_descriptor_driver = {
	200	.driver = {
	201	.name = "dell-wmi-descriptor",
	202	},
	203	.probe = dell_wmi_descriptor_probe,
	204	.remove = dell_wmi_descriptor_remove,
	205	.id_table = dell_wmi_descriptor_id_table,
	206	};
	207
	208	module_wmi_driver(dell_wmi_descriptor_driver);
	209
	210	MODULE_ALIAS("wmi:" DELL_WMI_DESCRIPTOR_GUID);
	211	MODULE_AUTHOR("Mario Limonciello <mario.limonciello@dell.com>");
	212	MODULE_DESCRIPTION("Dell WMI descriptor driver");
	213	MODULE_LICENSE("GPL");