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

  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
125	/* For now, report failure to transition to S0ix with a warning. */
126	if (ret >= 0 && ec_dev->host_sleep_v1 &&
127	    (sleep_event == HOST_SLEEP_EVENT_S0IX_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 slp_s0 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
179	ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
180	if (!ec_dev->din)
181		return -ENOMEM;
182
183	ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
184	if (!ec_dev->dout)
185		return -ENOMEM;
186
187	mutex_init(&ec_dev->lock);
188
189	err = cros_ec_query_all(ec_dev);
190	if (err) {
191		dev_err(dev, "Cannot identify the EC: error %d\n", err);
192		return err;
193	}
194
195	if (ec_dev->irq > 0) {
196		err = devm_request_threaded_irq(dev, ec_dev->irq,
197						ec_irq_handler,
198						ec_irq_thread,
199						IRQF_TRIGGER_LOW | IRQF_ONESHOT,
200						"chromeos-ec", ec_dev);
201		if (err) {
202			dev_err(dev, "Failed to request IRQ %d: %d",
203				ec_dev->irq, err);
204			return err;
205		}
206	}
207
208	/* Register a platform device for the main EC instance */
209	ec_dev->ec = platform_device_register_data(ec_dev->dev, "cros-ec-dev",
210					PLATFORM_DEVID_AUTO, &ec_p,
211					sizeof(struct cros_ec_platform));
212	if (IS_ERR(ec_dev->ec)) {
213		dev_err(ec_dev->dev,
214			"Failed to create CrOS EC platform device\n");
215		return PTR_ERR(ec_dev->ec);
216	}
217
218	if (ec_dev->max_passthru) {
219		/*
220		 * Register a platform device for the PD behind the main EC.
221		 * We make the following assumptions:
222		 * - behind an EC, we have a pd
223		 * - only one device added.
224		 * - the EC is responsive at init time (it is not true for a
225		 *   sensor hub).
226		 */
227		ec_dev->pd = platform_device_register_data(ec_dev->dev,
228					"cros-ec-dev",
229					PLATFORM_DEVID_AUTO, &pd_p,
230					sizeof(struct cros_ec_platform));
231		if (IS_ERR(ec_dev->pd)) {
232			dev_err(ec_dev->dev,
233				"Failed to create CrOS PD platform device\n");
234			platform_device_unregister(ec_dev->ec);
235			return PTR_ERR(ec_dev->pd);
236		}
237	}
238
239	if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
240		err = devm_of_platform_populate(dev);
241		if (err) {
242			platform_device_unregister(ec_dev->pd);
243			platform_device_unregister(ec_dev->ec);
244			dev_err(dev, "Failed to register sub-devices\n");
245			return err;
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			return err;
268	}
269
270	dev_info(dev, "Chrome EC device registered\n");
271
 
 
 
 
 
 
 
272	return 0;
 
 
 
 
273}
274EXPORT_SYMBOL(cros_ec_register);
275
276/**
277 * cros_ec_unregister() - Remove a ChromeOS EC.
278 * @ec_dev: Device to unregister.
279 *
280 * Call this to deregister a ChromeOS EC, then clean up any private data.
281 *
282 * Return: 0 on success or negative error code.
283 */
284int cros_ec_unregister(struct cros_ec_device *ec_dev)
285{
286	if (ec_dev->pd)
287		platform_device_unregister(ec_dev->pd);
288	platform_device_unregister(ec_dev->ec);
289
290	return 0;
291}
292EXPORT_SYMBOL(cros_ec_unregister);
293
294#ifdef CONFIG_PM_SLEEP
295/**
296 * cros_ec_suspend() - Handle a suspend operation for the ChromeOS EC device.
297 * @ec_dev: Device to suspend.
298 *
299 * This can be called by drivers to handle a suspend event.
300 *
301 * Return: 0 on success or negative error code.
302 */
303int cros_ec_suspend(struct cros_ec_device *ec_dev)
304{
305	struct device *dev = ec_dev->dev;
306	int ret;
307	u8 sleep_event;
308
309	sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
310		      HOST_SLEEP_EVENT_S3_SUSPEND :
311		      HOST_SLEEP_EVENT_S0IX_SUSPEND;
312
313	ret = cros_ec_sleep_event(ec_dev, sleep_event);
314	if (ret < 0)
315		dev_dbg(ec_dev->dev, "Error %d sending suspend event to ec",
316			ret);
317
318	if (device_may_wakeup(dev))
319		ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
 
 
320
321	disable_irq(ec_dev->irq);
322	ec_dev->was_wake_device = ec_dev->wake_enabled;
323	ec_dev->suspended = true;
324
325	return 0;
326}
327EXPORT_SYMBOL(cros_ec_suspend);
328
329static void cros_ec_report_events_during_suspend(struct cros_ec_device *ec_dev)
330{
 
 
331	while (ec_dev->mkbp_event_supported &&
332	       cros_ec_get_next_event(ec_dev, NULL, NULL) > 0)
333		blocking_notifier_call_chain(&ec_dev->event_notifier,
334					     1, ec_dev);
 
 
 
 
335}
336
337/**
338 * cros_ec_resume() - Handle a resume operation for the ChromeOS EC device.
339 * @ec_dev: Device to resume.
340 *
341 * This can be called by drivers to handle a resume event.
342 *
343 * Return: 0 on success or negative error code.
344 */
345int cros_ec_resume(struct cros_ec_device *ec_dev)
346{
347	int ret;
348	u8 sleep_event;
349
350	ec_dev->suspended = false;
351	enable_irq(ec_dev->irq);
352
353	sleep_event = (!IS_ENABLED(CONFIG_ACPI) || pm_suspend_via_firmware()) ?
354		      HOST_SLEEP_EVENT_S3_RESUME :
355		      HOST_SLEEP_EVENT_S0IX_RESUME;
356
357	ret = cros_ec_sleep_event(ec_dev, sleep_event);
358	if (ret < 0)
359		dev_dbg(ec_dev->dev, "Error %d sending resume event to ec",
360			ret);
361
362	if (ec_dev->wake_enabled) {
363		disable_irq_wake(ec_dev->irq);
364		ec_dev->wake_enabled = 0;
365	}
366	/*
367	 * Let the mfd devices know about events that occur during
368	 * suspend. This way the clients know what to do with them.
369	 */
370	cros_ec_report_events_during_suspend(ec_dev);
371
372
373	return 0;
374}
375EXPORT_SYMBOL(cros_ec_resume);
376
377#endif
378
379MODULE_LICENSE("GPL");
380MODULE_DESCRIPTION("ChromeOS EC core driver");