platform/chrome/cros_ec.c

36  * @data: (ec_dev) Device with events to process.
42 	struct cros_ec_device *ec_dev = data;
44 	ec_dev->last_event_time = cros_ec_get_time_ns();
51  * @ec_dev: Device with events to process.
59 static bool cros_ec_handle_event(struct cros_ec_device *ec_dev)
65 	ret = cros_ec_get_next_event(ec_dev, &wake_event, &ec_has_more_events);
72 	if (wake_event && device_may_wakeup(ec_dev->dev))
73 		pm_wakeup_event(ec_dev->dev, 0);
76 		blocking_notifier_call_chain(&ec_dev->event_notifier,
77 					     0, ec_dev);
85  * @data: (ec_dev) Device with events to process.
91 	struct cros_ec_device *ec_dev = data;
95 		ec_has_more_events = cros_ec_handle_event(ec_dev);
102 static int cros_ec_sleep_event(struct cros_ec_device *ec_dev, u8 sleep_event)
116 	if (ec_dev->host_sleep_v1) {
119 				ec_dev->suspend_timeout_ms;
135 	ret = cros_ec_cmd_xfer_status(ec_dev, &buf.msg);
137 	if (ret >= 0 && ec_dev->host_sleep_v1 &&
140 		ec_dev->last_resume_result =
157 	struct cros_ec_device *ec_dev = container_of(nb, struct cros_ec_device,
159 	u32 host_event = cros_ec_get_host_event(ec_dev);
162 		mutex_lock(&ec_dev->lock);
163 		cros_ec_query_all(ec_dev);
164 		mutex_unlock(&ec_dev->lock);
173  * @ec_dev: Device to register.
180 int cros_ec_register(struct cros_ec_device *ec_dev)
182 	struct device *dev = ec_dev->dev;
185 	BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
186 	BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->panic_notifier);
188 	ec_dev->max_request = sizeof(struct ec_params_hello);
189 	ec_dev->max_response = sizeof(struct ec_response_get_protocol_info);
190 	ec_dev->max_passthru = 0;
191 	ec_dev->ec = NULL;
192 	ec_dev->pd = NULL;
193 	ec_dev->suspend_timeout_ms = EC_HOST_SLEEP_TIMEOUT_DEFAULT;
195 	ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
196 	if (!ec_dev->din)
199 	ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
200 	if (!ec_dev->dout)
203 	lockdep_register_key(&ec_dev->lockdep_key);
204 	mutex_init(&ec_dev->lock);
205 	lockdep_set_class(&ec_dev->lock, &ec_dev->lockdep_key);
207 	err = cros_ec_query_all(ec_dev);
213 	if (ec_dev->irq > 0) {
214 		err = devm_request_threaded_irq(dev, ec_dev->irq,
218 						"chromeos-ec", ec_dev);
221 				ec_dev->irq, err);
227 	ec_dev->ec = platform_device_register_data(ec_dev->dev, "cros-ec-dev",
230 	if (IS_ERR(ec_dev->ec)) {
231 		dev_err(ec_dev->dev,
233 		err = PTR_ERR(ec_dev->ec);
237 	if (ec_dev->max_passthru) {
246 		ec_dev->pd = platform_device_register_data(ec_dev->dev,
250 		if (IS_ERR(ec_dev->pd)) {
251 			dev_err(ec_dev->dev,
253 			err = PTR_ERR(ec_dev->pd);
270 	err = cros_ec_sleep_event(ec_dev, 0);
272 		dev_dbg(ec_dev->dev, "Error %d clearing sleep event to ec\n",
275 	if (ec_dev->mkbp_event_supported) {
280 		ec_dev->notifier_ready.notifier_call = cros_ec_ready_event;
281 		err = blocking_notifier_chain_register(&ec_dev->event_notifier,
282 						      &ec_dev->notifier_ready);
293 	if (ec_dev->mkbp_event_supported)
294 		cros_ec_irq_thread(0, ec_dev);
298 	platform_device_unregister(ec_dev->ec);
299 	platform_device_unregister(ec_dev->pd);
300 	mutex_destroy(&ec_dev->lock);
301 	lockdep_unregister_key(&ec_dev->lockdep_key);
308  * @ec_dev: Device to unregister.
314 void cros_ec_unregister(struct cros_ec_device *ec_dev)
316 	platform_device_unregister(ec_dev->pd);
317 	platform_device_unregister(ec_dev->ec);
318 	mutex_destroy(&ec_dev->lock);
319 	lockdep_unregister_key(&ec_dev->lockdep_key);
324 static void cros_ec_send_suspend_event(struct cros_ec_device *ec_dev)
333 	ret = cros_ec_sleep_event(ec_dev, sleep_event);
335 		dev_dbg(ec_dev->dev, "Error %d sending suspend event to ec\n",
341  * @ec_dev: Device to suspend.
347 int cros_ec_suspend_prepare(struct cros_ec_device *ec_dev)
349 	cros_ec_send_suspend_event(ec_dev);
354 static void cros_ec_disable_irq(struct cros_ec_device *ec_dev)
356 	struct device *dev = ec_dev->dev;
358 		ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
360 		ec_dev->wake_enabled = false;
362 	disable_irq(ec_dev->irq);
363 	ec_dev->suspended = true;
368  * @ec_dev: Device to suspend.
374 int cros_ec_suspend_late(struct cros_ec_device *ec_dev)
376 	cros_ec_disable_irq(ec_dev);
383  * @ec_dev: Device to suspend.
389 int cros_ec_suspend(struct cros_ec_device *ec_dev)
391 	cros_ec_send_suspend_event(ec_dev);
392 	cros_ec_disable_irq(ec_dev);
397 static void cros_ec_report_events_during_suspend(struct cros_ec_device *ec_dev)
401 	while (ec_dev->mkbp_event_supported &&
402 	       cros_ec_get_next_event(ec_dev, &wake_event, NULL) > 0) {
403 		blocking_notifier_call_chain(&ec_dev->event_notifier,
404 					     1, ec_dev);
406 		if (wake_event && device_may_wakeup(ec_dev->dev))
407 			pm_wakeup_event(ec_dev->dev, 0);
411 static void cros_ec_send_resume_event(struct cros_ec_device *ec_dev)
420 	ret = cros_ec_sleep_event(ec_dev, sleep_event);
422 		dev_dbg(ec_dev->dev, "Error %d sending resume event to ec\n",
428  * @ec_dev: Device to resume.
432 void cros_ec_resume_complete(struct cros_ec_device *ec_dev)
434 	cros_ec_send_resume_event(ec_dev);
440 	cros_ec_report_events_during_suspend(ec_dev);
444 static void cros_ec_enable_irq(struct cros_ec_device *ec_dev)
446 	ec_dev->suspended = false;
447 	enable_irq(ec_dev->irq);
449 	if (ec_dev->wake_enabled)
450 		disable_irq_wake(ec_dev->irq);
455  * @ec_dev: Device to resume.
461 int cros_ec_resume_early(struct cros_ec_device *ec_dev)
463 	cros_ec_enable_irq(ec_dev);
470  * @ec_dev: Device to resume.
476 int cros_ec_resume(struct cros_ec_device *ec_dev)
478 	cros_ec_resume_early(ec_dev);
479 	cros_ec_resume_complete(ec_dev);