1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * UART interface for ChromeOS Embedded Controller
4  *
5  * Copyright 2020-2022 Google LLC.
6  */
7 
8 #include <linux/acpi.h>
9 #include <linux/delay.h>
10 #include <linux/errno.h>
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/platform_data/cros_ec_proto.h>
16 #include <linux/serdev.h>
17 #include <linux/slab.h>
18 #include <uapi/linux/sched/types.h>
19 
20 #include "cros_ec.h"
21 
22 /*
23  * EC sends contiguous bytes of response packet on UART AP RX.
24  * TTY driver in AP accumulates incoming bytes and calls the registered callback
25  * function. Byte count can range from 1 to MAX bytes supported by EC.
26  * This driver should wait for long time for all callbacks to be processed.
27  * Considering the worst case scenario, wait for 500 msec. This timeout should
28  * account for max latency and some additional guard time.
29  * Best case: Entire packet is received in ~200 ms, wait queue will be released
30  * and packet will be processed.
31  * Worst case: TTY driver sends bytes in multiple callbacks. In this case this
32  * driver will wait for ~1 sec beyond which it will timeout.
33  * This timeout value should not exceed ~500 msec because in case if
34  * EC_CMD_REBOOT_EC sent, high level driver should be able to intercept EC
35  * in RO.
36  */
37 #define EC_MSG_DEADLINE_MS		500
38 
39 /**
40  * struct response_info - Encapsulate EC response related
41  *			information for passing between function
42  *			cros_ec_uart_pkt_xfer() and cros_ec_uart_rx_bytes()
43  *			callback.
44  * @data:		Copy the data received from EC here.
45  * @max_size:		Max size allocated for the @data buffer. If the
46  *			received data exceeds this value, we log an error.
47  * @size:		Actual size of data received from EC. This is also
48  *			used to accumulate byte count with response is received
49  *			in dma chunks.
50  * @exp_len:		Expected bytes of response from EC including header.
51  * @status:		Re-init to 0 before sending a cmd. Updated to 1 when
52  *			a response is successfully received, or an error number
53  *			on failure.
54  * @wait_queue:	Wait queue EC response where the cros_ec sends request
55  *			to EC and waits
56  */
57 struct response_info {
58 	void *data;
59 	size_t max_size;
60 	size_t size;
61 	size_t exp_len;
62 	int status;
63 	wait_queue_head_t wait_queue;
64 };
65 
66 /**
67  * struct cros_ec_uart - information about a uart-connected EC
68  *
69  * @serdev:		serdev uart device we are connected to.
70  * @baudrate:		UART baudrate of attached EC device.
71  * @flowcontrol:	UART flowcontrol of attached device.
72  * @irq:		Linux IRQ number of associated serial device.
73  * @response:		Response info passing between cros_ec_uart_pkt_xfer()
74  *			and cros_ec_uart_rx_bytes()
75  */
76 struct cros_ec_uart {
77 	struct serdev_device *serdev;
78 	u32 baudrate;
79 	u8 flowcontrol;
80 	u32 irq;
81 	struct response_info response;
82 };
83 
cros_ec_uart_rx_bytes(struct serdev_device * serdev,const u8 * data,size_t count)84 static int cros_ec_uart_rx_bytes(struct serdev_device *serdev,
85 				 const u8 *data,
86 				 size_t count)
87 {
88 	struct ec_host_response *host_response;
89 	struct cros_ec_device *ec_dev = serdev_device_get_drvdata(serdev);
90 	struct cros_ec_uart *ec_uart = ec_dev->priv;
91 	struct response_info *resp = &ec_uart->response;
92 
93 	/* Check if bytes were sent out of band */
94 	if (!resp->data) {
95 		/* Discard all bytes */
96 		dev_warn(ec_dev->dev, "Bytes received out of band, dropping them.\n");
97 		return count;
98 	}
99 
100 	/*
101 	 * Check if incoming bytes + resp->size is greater than allocated
102 	 * buffer in din by cros_ec. This will ensure that if EC sends more
103 	 * bytes than max_size, waiting process will be notified with an error.
104 	 */
105 	if (resp->size + count > resp->max_size) {
106 		resp->status = -EMSGSIZE;
107 		wake_up(&resp->wait_queue);
108 		return count;
109 	}
110 
111 	memcpy(resp->data + resp->size, data, count);
112 
113 	resp->size += count;
114 
115 	/* Read data_len if we received response header and if exp_len was not read before. */
116 	if (resp->size >= sizeof(*host_response) && resp->exp_len == 0) {
117 		host_response = (struct ec_host_response *)resp->data;
118 		resp->exp_len = host_response->data_len + sizeof(*host_response);
119 	}
120 
121 	/* If driver received response header and payload from EC, wake up the wait queue. */
122 	if (resp->size >= sizeof(*host_response) && resp->size == resp->exp_len) {
123 		resp->status = 1;
124 		wake_up(&resp->wait_queue);
125 	}
126 
127 	return count;
128 }
129 
cros_ec_uart_pkt_xfer(struct cros_ec_device * ec_dev,struct cros_ec_command * ec_msg)130 static int cros_ec_uart_pkt_xfer(struct cros_ec_device *ec_dev,
131 				 struct cros_ec_command *ec_msg)
132 {
133 	struct cros_ec_uart *ec_uart = ec_dev->priv;
134 	struct serdev_device *serdev = ec_uart->serdev;
135 	struct response_info *resp = &ec_uart->response;
136 	struct ec_host_response *host_response;
137 	unsigned int len;
138 	int ret, i;
139 	u8 sum;
140 
141 	len = cros_ec_prepare_tx(ec_dev, ec_msg);
142 	dev_dbg(ec_dev->dev, "Prepared len=%d\n", len);
143 
144 	/* Setup for incoming response */
145 	resp->data = ec_dev->din;
146 	resp->max_size = ec_dev->din_size;
147 	resp->size = 0;
148 	resp->exp_len = 0;
149 	resp->status = 0;
150 
151 	ret = serdev_device_write_buf(serdev, ec_dev->dout, len);
152 	if (ret < 0 || ret < len) {
153 		dev_err(ec_dev->dev, "Unable to write data\n");
154 		if (ret >= 0)
155 			ret = -EIO;
156 		goto exit;
157 	}
158 
159 	ret = wait_event_timeout(resp->wait_queue, resp->status,
160 				 msecs_to_jiffies(EC_MSG_DEADLINE_MS));
161 	if (ret == 0) {
162 		dev_warn(ec_dev->dev, "Timed out waiting for response.\n");
163 		ret = -ETIMEDOUT;
164 		goto exit;
165 	}
166 
167 	if (resp->status < 0) {
168 		ret = resp->status;
169 		dev_warn(ec_dev->dev, "Error response received: %d\n", ret);
170 		goto exit;
171 	}
172 
173 	host_response = (struct ec_host_response *)ec_dev->din;
174 	ec_msg->result = host_response->result;
175 
176 	if (host_response->data_len > ec_msg->insize) {
177 		dev_err(ec_dev->dev, "Resp too long (%d bytes, expected %d)\n",
178 			host_response->data_len, ec_msg->insize);
179 		ret = -ENOSPC;
180 		goto exit;
181 	}
182 
183 	/* Validate checksum */
184 	sum = 0;
185 	for (i = 0; i < sizeof(*host_response) + host_response->data_len; i++)
186 		sum += ec_dev->din[i];
187 
188 	if (sum) {
189 		dev_err(ec_dev->dev, "Bad packet checksum calculated %x\n", sum);
190 		ret = -EBADMSG;
191 		goto exit;
192 	}
193 
194 	memcpy(ec_msg->data, ec_dev->din + sizeof(*host_response), host_response->data_len);
195 
196 	ret = host_response->data_len;
197 
198 exit:
199 	/* Invalidate response buffer to guard against out of band rx data */
200 	resp->data = NULL;
201 
202 	if (ec_msg->command == EC_CMD_REBOOT_EC)
203 		msleep(EC_REBOOT_DELAY_MS);
204 
205 	return ret;
206 }
207 
cros_ec_uart_resource(struct acpi_resource * ares,void * data)208 static int cros_ec_uart_resource(struct acpi_resource *ares, void *data)
209 {
210 	struct cros_ec_uart *ec_uart = data;
211 	struct acpi_resource_uart_serialbus *sb = &ares->data.uart_serial_bus;
212 
213 	if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS &&
214 	    sb->type == ACPI_RESOURCE_SERIAL_TYPE_UART) {
215 		ec_uart->baudrate = sb->default_baud_rate;
216 		dev_dbg(&ec_uart->serdev->dev, "Baudrate %d\n", ec_uart->baudrate);
217 
218 		ec_uart->flowcontrol = sb->flow_control;
219 		dev_dbg(&ec_uart->serdev->dev, "Flow control %d\n", ec_uart->flowcontrol);
220 	}
221 
222 	return 0;
223 }
224 
cros_ec_uart_acpi_probe(struct cros_ec_uart * ec_uart)225 static int cros_ec_uart_acpi_probe(struct cros_ec_uart *ec_uart)
226 {
227 	int ret;
228 	LIST_HEAD(resources);
229 	struct acpi_device *adev = ACPI_COMPANION(&ec_uart->serdev->dev);
230 
231 	ret = acpi_dev_get_resources(adev, &resources, cros_ec_uart_resource, ec_uart);
232 	if (ret < 0)
233 		return ret;
234 
235 	acpi_dev_free_resource_list(&resources);
236 
237 	/* Retrieve GpioInt and translate it to Linux IRQ number */
238 	ret = acpi_dev_gpio_irq_get(adev, 0);
239 	if (ret < 0)
240 		return ret;
241 
242 	ec_uart->irq = ret;
243 	dev_dbg(&ec_uart->serdev->dev, "IRQ number %d\n", ec_uart->irq);
244 
245 	return 0;
246 }
247 
248 static const struct serdev_device_ops cros_ec_uart_client_ops = {
249 	.receive_buf = cros_ec_uart_rx_bytes,
250 };
251 
cros_ec_uart_probe(struct serdev_device * serdev)252 static int cros_ec_uart_probe(struct serdev_device *serdev)
253 {
254 	struct device *dev = &serdev->dev;
255 	struct cros_ec_device *ec_dev;
256 	struct cros_ec_uart *ec_uart;
257 	int ret;
258 
259 	ec_uart = devm_kzalloc(dev, sizeof(*ec_uart), GFP_KERNEL);
260 	if (!ec_uart)
261 		return -ENOMEM;
262 
263 	ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);
264 	if (!ec_dev)
265 		return -ENOMEM;
266 
267 	serdev_device_set_drvdata(serdev, ec_dev);
268 	init_waitqueue_head(&ec_uart->response.wait_queue);
269 
270 	ec_uart->serdev = serdev;
271 
272 	ret = cros_ec_uart_acpi_probe(ec_uart);
273 	if (ret < 0) {
274 		dev_err(dev, "Failed to get ACPI info (%d)", ret);
275 		return ret;
276 	}
277 
278 	/* Initialize ec_dev for cros_ec  */
279 	ec_dev->phys_name = dev_name(dev);
280 	ec_dev->dev = dev;
281 	ec_dev->priv = ec_uart;
282 	ec_dev->irq = ec_uart->irq;
283 	ec_dev->cmd_xfer = NULL;
284 	ec_dev->pkt_xfer = cros_ec_uart_pkt_xfer;
285 	ec_dev->din_size = sizeof(struct ec_host_response) +
286 			   sizeof(struct ec_response_get_protocol_info);
287 	ec_dev->dout_size = sizeof(struct ec_host_request);
288 
289 	serdev_device_set_client_ops(serdev, &cros_ec_uart_client_ops);
290 
291 	ret = devm_serdev_device_open(dev, serdev);
292 	if (ret) {
293 		dev_err(dev, "Unable to open UART device");
294 		return ret;
295 	}
296 
297 	ret = serdev_device_set_baudrate(serdev, ec_uart->baudrate);
298 	if (ret < 0) {
299 		dev_err(dev, "Failed to set up host baud rate (%d)", ret);
300 		return ret;
301 	}
302 
303 	serdev_device_set_flow_control(serdev, ec_uart->flowcontrol);
304 
305 	return cros_ec_register(ec_dev);
306 }
307 
cros_ec_uart_remove(struct serdev_device * serdev)308 static void cros_ec_uart_remove(struct serdev_device *serdev)
309 {
310 	struct cros_ec_device *ec_dev = serdev_device_get_drvdata(serdev);
311 
312 	cros_ec_unregister(ec_dev);
313 };
314 
cros_ec_uart_suspend(struct device * dev)315 static int __maybe_unused cros_ec_uart_suspend(struct device *dev)
316 {
317 	struct cros_ec_device *ec_dev = dev_get_drvdata(dev);
318 
319 	return cros_ec_suspend(ec_dev);
320 }
321 
cros_ec_uart_resume(struct device * dev)322 static int __maybe_unused cros_ec_uart_resume(struct device *dev)
323 {
324 	struct cros_ec_device *ec_dev = dev_get_drvdata(dev);
325 
326 	return cros_ec_resume(ec_dev);
327 }
328 
329 static SIMPLE_DEV_PM_OPS(cros_ec_uart_pm_ops, cros_ec_uart_suspend,
330 			 cros_ec_uart_resume);
331 
332 static const struct of_device_id cros_ec_uart_of_match[] = {
333 	{ .compatible = "google,cros-ec-uart" },
334 	{}
335 };
336 MODULE_DEVICE_TABLE(of, cros_ec_uart_of_match);
337 
338 #ifdef CONFIG_ACPI
339 static const struct acpi_device_id cros_ec_uart_acpi_id[] = {
340 	{ "GOOG0019", 0 },
341 	{}
342 };
343 
344 MODULE_DEVICE_TABLE(acpi, cros_ec_uart_acpi_id);
345 #endif
346 
347 static struct serdev_device_driver cros_ec_uart_driver = {
348 	.driver	= {
349 		.name	= "cros-ec-uart",
350 		.acpi_match_table = ACPI_PTR(cros_ec_uart_acpi_id),
351 		.of_match_table = cros_ec_uart_of_match,
352 		.pm	= &cros_ec_uart_pm_ops,
353 	},
354 	.probe		= cros_ec_uart_probe,
355 	.remove		= cros_ec_uart_remove,
356 };
357 
358 module_serdev_device_driver(cros_ec_uart_driver);
359 
360 MODULE_LICENSE("GPL");
361 MODULE_DESCRIPTION("UART interface for ChromeOS Embedded Controller");
362 MODULE_AUTHOR("Bhanu Prakash Maiya <bhanumaiya@chromium.org>");
363