1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * ChromeOS EC multi-function device
4 *
5 * Copyright (C) 2012 Google, Inc
6 *
7 * The ChromeOS EC multi function device is used to mux all the requests
8 * to the EC device for its multiple features: keyboard controller,
9 * battery charging and regulator control, firmware update.
10 */
11
12#include <linux/of_platform.h>
13#include <linux/interrupt.h>
14#include <linux/slab.h>
15#include <linux/module.h>
16#include <linux/platform_data/cros_ec_commands.h>
17#include <linux/platform_data/cros_ec_proto.h>
18#include <linux/suspend.h>
19
20#include "cros_ec.h"
21
22#define CROS_EC_DEV_EC_INDEX 0
23#define CROS_EC_DEV_PD_INDEX 1
24
25static struct cros_ec_platform ec_p = {
26	.ec_name = CROS_EC_DEV_NAME,
27	.cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_EC_INDEX),
28};
29
30static struct cros_ec_platform pd_p = {
31	.ec_name = CROS_EC_DEV_PD_NAME,
32	.cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX),
33};
34
35static irqreturn_t ec_irq_handler(int irq, void *data)
36{
37	struct cros_ec_device *ec_dev = data;
38
39	ec_dev->last_event_time = cros_ec_get_time_ns();
40
41	return IRQ_WAKE_THREAD;
42}
43
44/**
45 * cros_ec_handle_event() - process and forward pending events on EC
46 * @ec_dev: Device with events to process.
47 *
48 * Call this function in a loop when the kernel is notified that the EC has
49 * pending events.
50 *
51 * Return: true if more events are still pending and this function should be
52 * called again.
53 */
54bool cros_ec_handle_event(struct cros_ec_device *ec_dev)
55{
56	bool wake_event;
57	bool ec_has_more_events;
58	int ret;
59
60	ret = cros_ec_get_next_event(ec_dev, &wake_event, &ec_has_more_events);
61
62	/*
63	 * Signal only if wake host events or any interrupt if
64	 * cros_ec_get_next_event() returned an error (default value for
65	 * wake_event is true)
66	 */
67	if (wake_event && device_may_wakeup(ec_dev->dev))
68		pm_wakeup_event(ec_dev->dev, 0);
69
70	if (ret > 0)
71		blocking_notifier_call_chain(&ec_dev->event_notifier,
72					     0, ec_dev);
73
74	return ec_has_more_events;
75}
76EXPORT_SYMBOL(cros_ec_handle_event);
77
78static irqreturn_t ec_irq_thread(int irq, void *data)
79{
80	struct cros_ec_device *ec_dev = data;
81	bool ec_has_more_events;
82
83	do {
84		ec_has_more_events = cros_ec_handle_event(ec_dev);
85	} while (ec_has_more_events);
86
87	return IRQ_HANDLED;
88}
89
90static int cros_ec_sleep_event(struct cros_ec_device *ec_dev, u8 sleep_event)
91{
92	int ret;
93	struct {
94		struct cros_ec_command msg;
95		union {
96			struct ec_params_host_sleep_event req0;
97			struct ec_params_host_sleep_event_v1 req1;
98			struct ec_response_host_sleep_event_v1 resp1;
99		} u;
100	} __packed buf;
101
102	memset(&buf, 0, sizeof(buf));
103
104	if (ec_dev->host_sleep_v1) {
105		buf.u.req1.sleep_event = sleep_event;
106		buf.u.req1.suspend_params.sleep_timeout_ms =
107				EC_HOST_SLEEP_TIMEOUT_DEFAULT;
108
109		buf.msg.outsize = sizeof(buf.u.req1);
110		if ((sleep_event == HOST_SLEEP_EVENT_S3_RESUME) ||
111		    (sleep_event == HOST_SLEEP_EVENT_S0IX_RESUME))
112			buf.msg.insize = sizeof(buf.u.resp1);
113
114		buf.msg.version = 1;
115
116	} else {
117		buf.u.req0.sleep_event = sleep_event;
118		buf.msg.outsize = sizeof(buf.u.req0);
119	}
120
121	buf.msg.command = EC_CMD_HOST_SLEEP_EVENT;
122
123	ret = cros_ec_cmd_xfer_status(ec_dev, &buf.msg);
124	/* Report failure to transition to system wide suspend with a warning. */
125	if (ret >= 0 && ec_dev->host_sleep_v1 &&
126	    (sleep_event == HOST_SLEEP_EVENT_S0IX_RESUME ||
127	     sleep_event == HOST_SLEEP_EVENT_S3_RESUME)) {
128		ec_dev->last_resume_result =
129			buf.u.resp1.resume_response.sleep_transitions;
130
131		WARN_ONCE(buf.u.resp1.resume_response.sleep_transitions &
132			  EC_HOST_RESUME_SLEEP_TIMEOUT,
133			  "EC detected sleep transition timeout. Total sleep transitions: %d",
134			  buf.u.resp1.resume_response.sleep_transitions &
135			  EC_HOST_RESUME_SLEEP_TRANSITIONS_MASK);
136	}
137
138	return ret;
139}
140
141static int cros_ec_ready_event(struct notifier_block *nb,
142			       unsigned long queued_during_suspend,
143			       void *_notify)
144{
145	struct cros_ec_device *ec_dev = container_of(nb, struct cros_ec_device,
146						     notifier_ready);
147	u32 host_event = cros_ec_get_host_event(ec_dev);
148
149	if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_INTERFACE_READY)) {
150		mutex_lock(&ec_dev->lock);
151		cros_ec_query_all(ec_dev);
152		mutex_unlock(&ec_dev->lock);
153		return NOTIFY_OK;
154	}
155
156	return NOTIFY_DONE;
157}
158
159/**
160 * cros_ec_register() - Register a new ChromeOS EC, using the provided info.
161 * @ec_dev: Device to register.
162 *
163 * Before calling this, allocate a pointer to a new device and then fill
164 * in all the fields up to the --private-- marker.
165 *
166 * Return: 0 on success or negative error code.
167 */
168int cros_ec_register(struct cros_ec_device *ec_dev)
169{
170	struct device *dev = ec_dev->dev;
171	int err = 0;
172
173	BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
174
175	ec_dev->max_request = sizeof(struct ec_params_hello);
176	ec_dev->max_response = sizeof(struct ec_response_get_protocol_info);
177	ec_dev->max_passthru = 0;
178	ec_dev->ec = NULL;
179	ec_dev->pd = NULL;
180
181	ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
182	if (!ec_dev->din)
183		return -ENOMEM;
184
185	ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
186	if (!ec_dev->dout)
187		return -ENOMEM;
188
189	mutex_init(&ec_dev->lock);
190
191	err = cros_ec_query_all(ec_dev);
192	if (err) {
193		dev_err(dev, "Cannot identify the EC: error %d\n", err);
194		return err;
195	}
196
197	if (ec_dev->irq > 0) {
198		err = devm_request_threaded_irq(dev, ec_dev->irq,
199						ec_irq_handler,
200						ec_irq_thread,
201						IRQF_TRIGGER_LOW | IRQF_ONESHOT,
202						"chromeos-ec", ec_dev);
203		if (err) {
204			dev_err(dev, "Failed to request IRQ %d: %d",
205				ec_dev->irq, err);
206			return err;
207		}
208	}
209
210	/* Register a platform device for the main EC instance */
211	ec_dev->ec = platform_device_register_data(ec_dev->dev, "cros-ec-dev",
212					PLATFORM_DEVID_AUTO, &ec_p,
213					sizeof(struct cros_ec_platform));
214	if (IS_ERR(ec_dev->ec)) {
215		dev_err(ec_dev->dev,
216			"Failed to create CrOS EC platform device\n");
217		return PTR_ERR(ec_dev->ec);
218	}
219
220	if (ec_dev->max_passthru) {
221		/*
222		 * Register a platform device for the PD behind the main EC.
223		 * We make the following assumptions:
224		 * - behind an EC, we have a pd
225		 * - only one device added.
226		 * - the EC is responsive at init time (it is not true for a
227		 *   sensor hub).
228		 */
229		ec_dev->pd = platform_device_register_data(ec_dev->dev,
230					"cros-ec-dev",
231					PLATFORM_DEVID_AUTO, &pd_p,
232					sizeof(struct cros_ec_platform));
233		if (IS_ERR(ec_dev->pd)) {
234			dev_err(ec_dev->dev,
235				"Failed to create CrOS PD platform device\n");
236			err = PTR_ERR(ec_dev->pd);
237			goto exit;
238		}
239	}
240
241	if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
242		err = devm_of_platform_populate(dev);
243		if (err) {
244			dev_err(dev, "Failed to register sub-devices\n");
245			goto exit;
246		}
247	}
248
249	/*
250	 * Clear sleep event - this will fail harmlessly on platforms that
251	 * don't implement the sleep event host command.
252	 */
253	err = cros_ec_sleep_event(ec_dev, 0);
254	if (err < 0)
255		dev_dbg(ec_dev->dev, "Error %d clearing sleep event to ec",
256			err);
257
258	if (ec_dev->mkbp_event_supported) {
259		/*
260		 * Register the notifier for EC_HOST_EVENT_INTERFACE_READY
261		 * event.
262		 */
263		ec_dev->notifier_ready.notifier_call = cros_ec_ready_event;
264		err = blocking_notifier_chain_register(&ec_dev->event_notifier,
265						      &ec_dev->notifier_ready);
266		if (err)
267			goto exit;
268	}
269
270	dev_info(dev, "Chrome EC device registered\n");
271
272	return 0;
273exit:
274	platform_device_unregister(ec_dev->ec);
275	platform_device_unregister(ec_dev->pd);
276	return err;
277}
278EXPORT_SYMBOL(cros_ec_register);
279
280/**
281 * cros_ec_unregister() - Remove a ChromeOS EC.
282 * @ec_dev: Device to unregister.
283 *
284 * Call this to deregister a ChromeOS EC, then clean up any private data.
285 *
286 * Return: 0 on success or negative error code.
287 */
288int cros_ec_unregister(struct cros_ec_device *ec_dev)
289{
290	if (ec_dev->pd)
291		platform_device_unregister(ec_dev->pd);
292	platform_device_unregister(ec_dev->ec);
293
294	return 0;
295}
296EXPORT_SYMBOL(cros_ec_unregister);
297
298#ifdef CONFIG_PM_SLEEP
299/**
300 * cros_ec_suspend() - Handle a suspend operation for the ChromeOS EC device.
301 * @ec_dev: Device to suspend.
302 *
303 * This can be called by drivers to handle a suspend event.
304 *
305 * Return: 0 on success or negative error code.
306 */
307int cros_ec_suspend(struct cros_ec_device *ec_dev)
308{
309	struct device *dev = ec_dev->dev;
310	int ret;
311	u8 sleep_event;
312
313	sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
314		      HOST_SLEEP_EVENT_S3_SUSPEND :
315		      HOST_SLEEP_EVENT_S0IX_SUSPEND;
316
317	ret = cros_ec_sleep_event(ec_dev, sleep_event);
318	if (ret < 0)
319		dev_dbg(ec_dev->dev, "Error %d sending suspend event to ec",
320			ret);
321
322	if (device_may_wakeup(dev))
323		ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
324
325	disable_irq(ec_dev->irq);
326	ec_dev->was_wake_device = ec_dev->wake_enabled;
327	ec_dev->suspended = true;
328
329	return 0;
330}
331EXPORT_SYMBOL(cros_ec_suspend);
332
333static void cros_ec_report_events_during_suspend(struct cros_ec_device *ec_dev)
334{
335	bool wake_event;
336
337	while (ec_dev->mkbp_event_supported &&
338	       cros_ec_get_next_event(ec_dev, &wake_event, NULL) > 0) {
339		blocking_notifier_call_chain(&ec_dev->event_notifier,
340					     1, ec_dev);
341
342		if (wake_event && device_may_wakeup(ec_dev->dev))
343			pm_wakeup_event(ec_dev->dev, 0);
344	}
345}
346
347/**
348 * cros_ec_resume() - Handle a resume operation for the ChromeOS EC device.
349 * @ec_dev: Device to resume.
350 *
351 * This can be called by drivers to handle a resume event.
352 *
353 * Return: 0 on success or negative error code.
354 */
355int cros_ec_resume(struct cros_ec_device *ec_dev)
356{
357	int ret;
358	u8 sleep_event;
359
360	ec_dev->suspended = false;
361	enable_irq(ec_dev->irq);
362
363	sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
364		      HOST_SLEEP_EVENT_S3_RESUME :
365		      HOST_SLEEP_EVENT_S0IX_RESUME;
366
367	ret = cros_ec_sleep_event(ec_dev, sleep_event);
368	if (ret < 0)
369		dev_dbg(ec_dev->dev, "Error %d sending resume event to ec",
370			ret);
371
372	if (ec_dev->wake_enabled) {
373		disable_irq_wake(ec_dev->irq);
374		ec_dev->wake_enabled = 0;
375	}
376	/*
377	 * Let the mfd devices know about events that occur during
378	 * suspend. This way the clients know what to do with them.
379	 */
380	cros_ec_report_events_during_suspend(ec_dev);
381
382
383	return 0;
384}
385EXPORT_SYMBOL(cros_ec_resume);
386
387#endif
388
389MODULE_LICENSE("GPL");
390MODULE_DESCRIPTION("ChromeOS EC core driver");
391