1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * ChromeOS specific ACPI extensions
4 *
5 * Copyright 2022 Google LLC
6 *
7 * This driver attaches to the ChromeOS ACPI device and then exports the
8 * values reported by the ACPI in a sysfs directory. All values are
9 * presented in the string form (numbers as decimal values) and can be
10 * accessed as the contents of the appropriate read only files in the
11 * sysfs directory tree.
12 */
13#include <linux/acpi.h>
14#include <linux/platform_device.h>
15#include <linux/kernel.h>
16#include <linux/list.h>
17#include <linux/module.h>
18
19#define ACPI_ATTR_NAME_LEN 4
20
21#define DEV_ATTR(_var, _name)					\
22	static struct device_attribute dev_attr_##_var =	\
23		__ATTR(_name, 0444, chromeos_first_level_attr_show, NULL);
24
25#define GPIO_ATTR_GROUP(_group, _name, _num)						\
26	static umode_t attr_is_visible_gpio_##_num(struct kobject *kobj,		\
27						   struct attribute *attr, int n)	\
28	{										\
29		if (_num < chromeos_acpi_gpio_groups)					\
30			return attr->mode;						\
31		return 0;								\
32	}										\
33	static ssize_t chromeos_attr_show_gpio_##_num(struct device *dev,		\
34						      struct device_attribute *attr,	\
35						      char *buf)			\
36	{										\
37		char name[ACPI_ATTR_NAME_LEN + 1];					\
38		int ret, num;								\
39											\
40		ret = parse_attr_name(attr->attr.name, name, &num);			\
41		if (ret)								\
42			return ret;							\
43		return chromeos_acpi_evaluate_method(dev, _num, num, name, buf);	\
44	}										\
45	static struct device_attribute dev_attr_0_##_group =				\
46		__ATTR(GPIO.0, 0444, chromeos_attr_show_gpio_##_num, NULL);		\
47	static struct device_attribute dev_attr_1_##_group =				\
48		__ATTR(GPIO.1, 0444, chromeos_attr_show_gpio_##_num, NULL);		\
49	static struct device_attribute dev_attr_2_##_group =				\
50		__ATTR(GPIO.2, 0444, chromeos_attr_show_gpio_##_num, NULL);		\
51	static struct device_attribute dev_attr_3_##_group =				\
52		__ATTR(GPIO.3, 0444, chromeos_attr_show_gpio_##_num, NULL);		\
53											\
54	static struct attribute *attrs_##_group[] = {					\
55		&dev_attr_0_##_group.attr,						\
56		&dev_attr_1_##_group.attr,						\
57		&dev_attr_2_##_group.attr,						\
58		&dev_attr_3_##_group.attr,						\
59		NULL									\
60	};										\
61	static const struct attribute_group attr_group_##_group = {			\
62		.name = _name,								\
63		.is_visible = attr_is_visible_gpio_##_num,				\
64		.attrs = attrs_##_group,						\
65	};
66
67static unsigned int chromeos_acpi_gpio_groups;
68
69/* Parse the ACPI package and return the data related to that attribute */
70static int chromeos_acpi_handle_package(struct device *dev, union acpi_object *obj,
71					int pkg_num, int sub_pkg_num, char *name, char *buf)
72{
73	union acpi_object *element = obj->package.elements;
74
75	if (pkg_num >= obj->package.count)
76		return -EINVAL;
77	element += pkg_num;
78
79	if (element->type == ACPI_TYPE_PACKAGE) {
80		if (sub_pkg_num >= element->package.count)
81			return -EINVAL;
82		/* select sub element inside this package */
83		element = element->package.elements;
84		element += sub_pkg_num;
85	}
86
87	switch (element->type) {
88	case ACPI_TYPE_INTEGER:
89		return sysfs_emit(buf, "%d\n", (int)element->integer.value);
90	case ACPI_TYPE_STRING:
91		return sysfs_emit(buf, "%s\n", element->string.pointer);
92	case ACPI_TYPE_BUFFER:
93		{
94			int i, r, at, room_left;
95			const int byte_per_line = 16;
96
97			at = 0;
98			room_left = PAGE_SIZE - 1;
99			for (i = 0; i < element->buffer.length && room_left; i += byte_per_line) {
100				r = hex_dump_to_buffer(element->buffer.pointer + i,
101						       element->buffer.length - i,
102						       byte_per_line, 1, buf + at, room_left,
103						       false);
104				if (r > room_left)
105					goto truncating;
106				at += r;
107				room_left -= r;
108
109				r = sysfs_emit_at(buf, at, "\n");
110				if (!r)
111					goto truncating;
112				at += r;
113				room_left -= r;
114			}
115
116			buf[at] = 0;
117			return at;
118truncating:
119			dev_info_once(dev, "truncating sysfs content for %s\n", name);
120			sysfs_emit_at(buf, PAGE_SIZE - 4, "..\n");
121			return PAGE_SIZE - 1;
122		}
123	default:
124		dev_err(dev, "element type %d not supported\n", element->type);
125		return -EINVAL;
126	}
127}
128
129static int chromeos_acpi_evaluate_method(struct device *dev, int pkg_num, int sub_pkg_num,
130					 char *name, char *buf)
131{
132	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
133	acpi_status status;
134	int ret = -EINVAL;
135
136	status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output);
137	if (ACPI_FAILURE(status)) {
138		dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status));
139		return ret;
140	}
141
142	if (((union acpi_object *)output.pointer)->type == ACPI_TYPE_PACKAGE)
143		ret = chromeos_acpi_handle_package(dev, output.pointer, pkg_num, sub_pkg_num,
144						   name, buf);
145
146	kfree(output.pointer);
147	return ret;
148}
149
150static int parse_attr_name(const char *name, char *attr_name, int *attr_num)
151{
152	int ret;
153
154	ret = strscpy(attr_name, name, ACPI_ATTR_NAME_LEN + 1);
155	if (ret == -E2BIG)
156		return kstrtoint(&name[ACPI_ATTR_NAME_LEN + 1], 0, attr_num);
157	return 0;
158}
159
160static ssize_t chromeos_first_level_attr_show(struct device *dev, struct device_attribute *attr,
161					      char *buf)
162{
163	char attr_name[ACPI_ATTR_NAME_LEN + 1];
164	int ret, attr_num = 0;
165
166	ret = parse_attr_name(attr->attr.name, attr_name, &attr_num);
167	if (ret)
168		return ret;
169	return chromeos_acpi_evaluate_method(dev, attr_num, 0, attr_name, buf);
170}
171
172static unsigned int get_gpio_pkg_num(struct device *dev)
173{
174	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
175	union acpi_object *obj;
176	acpi_status status;
177	unsigned int count = 0;
178	char *name = "GPIO";
179
180	status = acpi_evaluate_object(ACPI_HANDLE(dev), name, NULL, &output);
181	if (ACPI_FAILURE(status)) {
182		dev_err(dev, "failed to retrieve %s. %s\n", name, acpi_format_exception(status));
183		return count;
184	}
185
186	obj = output.pointer;
187
188	if (obj->type == ACPI_TYPE_PACKAGE)
189		count = obj->package.count;
190
191	kfree(output.pointer);
192	return count;
193}
194
195DEV_ATTR(binf2, BINF.2)
196DEV_ATTR(binf3, BINF.3)
197DEV_ATTR(chsw, CHSW)
198DEV_ATTR(fmap, FMAP)
199DEV_ATTR(frid, FRID)
200DEV_ATTR(fwid, FWID)
201DEV_ATTR(hwid, HWID)
202DEV_ATTR(meck, MECK)
203DEV_ATTR(vbnv0, VBNV.0)
204DEV_ATTR(vbnv1, VBNV.1)
205DEV_ATTR(vdat, VDAT)
206
207static struct attribute *first_level_attrs[] = {
208	&dev_attr_binf2.attr,
209	&dev_attr_binf3.attr,
210	&dev_attr_chsw.attr,
211	&dev_attr_fmap.attr,
212	&dev_attr_frid.attr,
213	&dev_attr_fwid.attr,
214	&dev_attr_hwid.attr,
215	&dev_attr_meck.attr,
216	&dev_attr_vbnv0.attr,
217	&dev_attr_vbnv1.attr,
218	&dev_attr_vdat.attr,
219	NULL
220};
221
222static const struct attribute_group first_level_attr_group = {
223	.attrs = first_level_attrs,
224};
225
226/*
227 * Every platform can have a different number of GPIO attribute groups.
228 * Define upper limit groups. At run time, the platform decides to show
229 * the present number of groups only, others are hidden.
230 */
231GPIO_ATTR_GROUP(gpio0, "GPIO.0", 0)
232GPIO_ATTR_GROUP(gpio1, "GPIO.1", 1)
233GPIO_ATTR_GROUP(gpio2, "GPIO.2", 2)
234GPIO_ATTR_GROUP(gpio3, "GPIO.3", 3)
235GPIO_ATTR_GROUP(gpio4, "GPIO.4", 4)
236GPIO_ATTR_GROUP(gpio5, "GPIO.5", 5)
237GPIO_ATTR_GROUP(gpio6, "GPIO.6", 6)
238GPIO_ATTR_GROUP(gpio7, "GPIO.7", 7)
239
240static const struct attribute_group *chromeos_acpi_all_groups[] = {
241	&first_level_attr_group,
242	&attr_group_gpio0,
243	&attr_group_gpio1,
244	&attr_group_gpio2,
245	&attr_group_gpio3,
246	&attr_group_gpio4,
247	&attr_group_gpio5,
248	&attr_group_gpio6,
249	&attr_group_gpio7,
250	NULL
251};
252
253static int chromeos_acpi_device_probe(struct platform_device *pdev)
254{
255	chromeos_acpi_gpio_groups = get_gpio_pkg_num(&pdev->dev);
256
257	/*
258	 * If the platform has more GPIO attribute groups than the number of
259	 * groups this driver supports, give out a warning message.
260	 */
261	if (chromeos_acpi_gpio_groups > ARRAY_SIZE(chromeos_acpi_all_groups) - 2)
262		dev_warn(&pdev->dev, "Only %zu GPIO attr groups supported by the driver out of total %u.\n",
263			 ARRAY_SIZE(chromeos_acpi_all_groups) - 2, chromeos_acpi_gpio_groups);
264	return 0;
265}
266
267static const struct acpi_device_id chromeos_device_ids[] = {
268	{ "GGL0001", 0 },
269	{ "GOOG0016", 0 },
270	{}
271};
272MODULE_DEVICE_TABLE(acpi, chromeos_device_ids);
273
274static struct platform_driver chromeos_acpi_device_driver = {
275	.probe = chromeos_acpi_device_probe,
276	.driver = {
277		.name = KBUILD_MODNAME,
278		.dev_groups = chromeos_acpi_all_groups,
279		.acpi_match_table = chromeos_device_ids,
280	}
281};
282module_platform_driver(chromeos_acpi_device_driver);
283
284MODULE_AUTHOR("Muhammad Usama Anjum <usama.anjum@collabora.com>");
285MODULE_LICENSE("GPL");
286MODULE_DESCRIPTION("ChromeOS specific ACPI extensions");
287