Merge branch 'parisc-4.9-1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller...

[cascardo/linux.git] / drivers / mfd / cros_ec.c

diff --git a/drivers/mfd/cros_ec.c b/drivers/mfd/cros_ec.c
index 0eee635..abd8342 100644 (file)
--- a/drivers/mfd/cros_ec.c
+++ b/drivers/mfd/cros_ec.c
@@ -23,6 +23,7 @@
 #include <linux/module.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/cros_ec.h>
+#include <asm/unaligned.h>
 
 #define CROS_EC_DEV_EC_INDEX 0
 #define CROS_EC_DEV_PD_INDEX 1
@@ -49,11 +50,28 @@ static const struct mfd_cell ec_pd_cell = {
        .pdata_size = sizeof(pd_p),
 };
 
+static irqreturn_t ec_irq_thread(int irq, void *data)
+{
+       struct cros_ec_device *ec_dev = data;
+       int ret;
+
+       if (device_may_wakeup(ec_dev->dev))
+               pm_wakeup_event(ec_dev->dev, 0);
+
+       ret = cros_ec_get_next_event(ec_dev);
+       if (ret > 0)
+               blocking_notifier_call_chain(&ec_dev->event_notifier,
+                                            0, ec_dev);
+       return IRQ_HANDLED;
+}
+
 int cros_ec_register(struct cros_ec_device *ec_dev)
 {
        struct device *dev = ec_dev->dev;
        int err = 0;
 
+       BLOCKING_INIT_NOTIFIER_HEAD(&ec_dev->event_notifier);
+
        ec_dev->max_request = sizeof(struct ec_params_hello);
        ec_dev->max_response = sizeof(struct ec_response_get_protocol_info);
        ec_dev->max_passthru = 0;
@@ -70,13 +88,24 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
 
        cros_ec_query_all(ec_dev);
 
+       if (ec_dev->irq) {
+               err = request_threaded_irq(ec_dev->irq, NULL, ec_irq_thread,
+                                          IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                          "chromeos-ec", ec_dev);
+               if (err) {
+                       dev_err(dev, "Failed to request IRQ %d: %d",
+                               ec_dev->irq, err);
+                       return err;
+               }
+       }
+
        err = mfd_add_devices(ec_dev->dev, PLATFORM_DEVID_AUTO, &ec_cell, 1,
                              NULL, ec_dev->irq, NULL);
        if (err) {
                dev_err(dev,
                        "Failed to register Embedded Controller subdevice %d\n",
                        err);
-               return err;
+               goto fail_mfd;
        }
 
        if (ec_dev->max_passthru) {
@@ -94,7 +123,7 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
                        dev_err(dev,
                                "Failed to register Power Delivery subdevice %d\n",
                                err);
-                       return err;
+                       goto fail_mfd;
                }
        }
 
@@ -103,13 +132,18 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
                if (err) {
                        mfd_remove_devices(dev);
                        dev_err(dev, "Failed to register sub-devices\n");
-                       return err;
+                       goto fail_mfd;
                }
        }
 
        dev_info(dev, "Chrome EC device registered\n");
 
        return 0;
+
+fail_mfd:
+       if (ec_dev->irq)
+               free_irq(ec_dev->irq, ec_dev);
+       return err;
 }
 EXPORT_SYMBOL(cros_ec_register);
 
@@ -136,13 +170,31 @@ int cros_ec_suspend(struct cros_ec_device *ec_dev)
 }
 EXPORT_SYMBOL(cros_ec_suspend);
 
+static void cros_ec_drain_events(struct cros_ec_device *ec_dev)
+{
+       while (cros_ec_get_next_event(ec_dev) > 0)
+               blocking_notifier_call_chain(&ec_dev->event_notifier,
+                                            1, ec_dev);
+}
+
 int cros_ec_resume(struct cros_ec_device *ec_dev)
 {
        enable_irq(ec_dev->irq);
 
+       /*
+        * In some cases, we need to distinguish between events that occur
+        * during suspend if the EC is not a wake source. For example,
+        * keypresses during suspend should be discarded if it does not wake
+        * the system.
+        *
+        * If the EC is not a wake source, drain the event queue and mark them
+        * as "queued during suspend".
+        */
        if (ec_dev->wake_enabled) {
                disable_irq_wake(ec_dev->irq);
                ec_dev->wake_enabled = 0;
+       } else {
+               cros_ec_drain_events(ec_dev);
        }
 
        return 0;