1// SPDX-License-Identifier: GPL-2.0
2/*
3 * UCSI ACPI driver
4 *
5 * Copyright (C) 2017, Intel Corporation
6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
7 */
8
9#include <linux/platform_device.h>
10#include <linux/module.h>
11#include <linux/acpi.h>
12#include <linux/dmi.h>
13
14#include "ucsi.h"
15
16#define UCSI_DSM_UUID		"6f8398c2-7ca4-11e4-ad36-631042b5008f"
17#define UCSI_DSM_FUNC_WRITE	1
18#define UCSI_DSM_FUNC_READ	2
19
20struct ucsi_acpi {
21	struct device *dev;
22	struct ucsi *ucsi;
23	void *base;
24	struct completion complete;
25	unsigned long flags;
26#define UCSI_ACPI_COMMAND_PENDING	1
27#define UCSI_ACPI_ACK_PENDING		2
28	guid_t guid;
29	u64 cmd;
30};
31
32static int ucsi_acpi_dsm(struct ucsi_acpi *ua, int func)
33{
34	union acpi_object *obj;
35
36	obj = acpi_evaluate_dsm(ACPI_HANDLE(ua->dev), &ua->guid, 1, func,
37				NULL);
38	if (!obj) {
39		dev_err(ua->dev, "%s: failed to evaluate _DSM %d\n",
40			__func__, func);
41		return -EIO;
42	}
43
44	ACPI_FREE(obj);
45	return 0;
46}
47
48static int ucsi_acpi_read(struct ucsi *ucsi, unsigned int offset,
49			  void *val, size_t val_len)
50{
51	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
52	int ret;
53
54	ret = ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_READ);
55	if (ret)
56		return ret;
57
58	memcpy(val, ua->base + offset, val_len);
59
60	return 0;
61}
62
63static int ucsi_acpi_async_write(struct ucsi *ucsi, unsigned int offset,
64				 const void *val, size_t val_len)
65{
66	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
67
68	memcpy(ua->base + offset, val, val_len);
69	ua->cmd = *(u64 *)val;
70
71	return ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_WRITE);
72}
73
74static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset,
75				const void *val, size_t val_len)
76{
77	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
78	bool ack = UCSI_COMMAND(*(u64 *)val) == UCSI_ACK_CC_CI;
79	int ret;
80
81	if (ack)
82		set_bit(UCSI_ACPI_ACK_PENDING, &ua->flags);
83	else
84		set_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags);
85
86	ret = ucsi_acpi_async_write(ucsi, offset, val, val_len);
87	if (ret)
88		goto out_clear_bit;
89
90	if (!wait_for_completion_timeout(&ua->complete, 5 * HZ))
91		ret = -ETIMEDOUT;
92
93out_clear_bit:
94	if (ack)
95		clear_bit(UCSI_ACPI_ACK_PENDING, &ua->flags);
96	else
97		clear_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags);
98
99	return ret;
100}
101
102static const struct ucsi_operations ucsi_acpi_ops = {
103	.read = ucsi_acpi_read,
104	.sync_write = ucsi_acpi_sync_write,
105	.async_write = ucsi_acpi_async_write
106};
107
108static int
109ucsi_zenbook_read(struct ucsi *ucsi, unsigned int offset, void *val, size_t val_len)
110{
111	struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
112	int ret;
113
114	if (offset == UCSI_VERSION || UCSI_COMMAND(ua->cmd) == UCSI_PPM_RESET) {
115		ret = ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_READ);
116		if (ret)
117			return ret;
118	}
119
120	memcpy(val, ua->base + offset, val_len);
121
122	return 0;
123}
124
125static const struct ucsi_operations ucsi_zenbook_ops = {
126	.read = ucsi_zenbook_read,
127	.sync_write = ucsi_acpi_sync_write,
128	.async_write = ucsi_acpi_async_write
129};
130
131static const struct dmi_system_id ucsi_acpi_quirks[] = {
132	{
133		.matches = {
134			DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
135			DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325UA_UM325UA"),
136		},
137		.driver_data = (void *)&ucsi_zenbook_ops,
138	},
139	{ }
140};
141
142static void ucsi_acpi_notify(acpi_handle handle, u32 event, void *data)
143{
144	struct ucsi_acpi *ua = data;
145	u32 cci;
146	int ret;
147
148	ret = ua->ucsi->ops->read(ua->ucsi, UCSI_CCI, &cci, sizeof(cci));
149	if (ret)
150		return;
151
152	if (UCSI_CCI_CONNECTOR(cci))
153		ucsi_connector_change(ua->ucsi, UCSI_CCI_CONNECTOR(cci));
154
155	if (cci & UCSI_CCI_ACK_COMPLETE &&
156	    test_bit(UCSI_ACPI_ACK_PENDING, &ua->flags))
157		complete(&ua->complete);
158	if (cci & UCSI_CCI_COMMAND_COMPLETE &&
159	    test_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags))
160		complete(&ua->complete);
161}
162
163static int ucsi_acpi_probe(struct platform_device *pdev)
164{
165	struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
166	const struct ucsi_operations *ops = &ucsi_acpi_ops;
167	const struct dmi_system_id *id;
168	struct ucsi_acpi *ua;
169	struct resource *res;
170	acpi_status status;
171	int ret;
172
173	if (adev->dep_unmet)
174		return -EPROBE_DEFER;
175
176	ua = devm_kzalloc(&pdev->dev, sizeof(*ua), GFP_KERNEL);
177	if (!ua)
178		return -ENOMEM;
179
180	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
181	if (!res) {
182		dev_err(&pdev->dev, "missing memory resource\n");
183		return -ENODEV;
184	}
185
186	ua->base = devm_memremap(&pdev->dev, res->start, resource_size(res), MEMREMAP_WB);
187	if (IS_ERR(ua->base))
188		return PTR_ERR(ua->base);
189
190	ret = guid_parse(UCSI_DSM_UUID, &ua->guid);
191	if (ret)
192		return ret;
193
194	init_completion(&ua->complete);
195	ua->dev = &pdev->dev;
196
197	id = dmi_first_match(ucsi_acpi_quirks);
198	if (id)
199		ops = id->driver_data;
200
201	ua->ucsi = ucsi_create(&pdev->dev, ops);
202	if (IS_ERR(ua->ucsi))
203		return PTR_ERR(ua->ucsi);
204
205	ucsi_set_drvdata(ua->ucsi, ua);
206
207	status = acpi_install_notify_handler(ACPI_HANDLE(&pdev->dev),
208					     ACPI_DEVICE_NOTIFY,
209					     ucsi_acpi_notify, ua);
210	if (ACPI_FAILURE(status)) {
211		dev_err(&pdev->dev, "failed to install notify handler\n");
212		ucsi_destroy(ua->ucsi);
213		return -ENODEV;
214	}
215
216	ret = ucsi_register(ua->ucsi);
217	if (ret) {
218		acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev),
219					   ACPI_DEVICE_NOTIFY,
220					   ucsi_acpi_notify);
221		ucsi_destroy(ua->ucsi);
222		return ret;
223	}
224
225	platform_set_drvdata(pdev, ua);
226
227	return 0;
228}
229
230static void ucsi_acpi_remove(struct platform_device *pdev)
231{
232	struct ucsi_acpi *ua = platform_get_drvdata(pdev);
233
234	ucsi_unregister(ua->ucsi);
235	ucsi_destroy(ua->ucsi);
236
237	acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev), ACPI_DEVICE_NOTIFY,
238				   ucsi_acpi_notify);
239}
240
241static int ucsi_acpi_resume(struct device *dev)
242{
243	struct ucsi_acpi *ua = dev_get_drvdata(dev);
244
245	return ucsi_resume(ua->ucsi);
246}
247
248static DEFINE_SIMPLE_DEV_PM_OPS(ucsi_acpi_pm_ops, NULL, ucsi_acpi_resume);
249
250static const struct acpi_device_id ucsi_acpi_match[] = {
251	{ "PNP0CA0", 0 },
252	{ },
253};
254MODULE_DEVICE_TABLE(acpi, ucsi_acpi_match);
255
256static struct platform_driver ucsi_acpi_platform_driver = {
257	.driver = {
258		.name = "ucsi_acpi",
259		.pm = pm_ptr(&ucsi_acpi_pm_ops),
260		.acpi_match_table = ACPI_PTR(ucsi_acpi_match),
261	},
262	.probe = ucsi_acpi_probe,
263	.remove_new = ucsi_acpi_remove,
264};
265
266module_platform_driver(ucsi_acpi_platform_driver);
267
268MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
269MODULE_LICENSE("GPL v2");
270MODULE_DESCRIPTION("UCSI ACPI driver");
271