Input: synaptics-rmi4 - move IRQ handling to rmi_driver

The attn IRQ is related to the chip, rather than the transport, so move
all handling of interrupts to the core driver. This also makes sure that
there are no races between interrupts and availability of the resources
used by the core driver.

Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>

diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c
index 06feede3ce1701458a2a7a23339e6091995e18b4..4f8d19794b018a9ffa139b11bbe5b02aecfbbcd7 100644 (file)
--- a/drivers/input/rmi4/rmi_driver.c
+++ b/drivers/input/rmi4/rmi_driver.c
@@ -17,6 +17,7 @@
 #include <linux/bitmap.h>
 #include <linux/delay.h>
 #include <linux/fs.h>
+#include <linux/irq.h>
 #include <linux/kconfig.h>
 #include <linux/pm.h>
 #include <linux/slab.h>
@@ -136,7 +137,7 @@ static void process_one_interrupt(struct rmi_driver_data *data,
        }
 }
 
-int rmi_process_interrupt_requests(struct rmi_device *rmi_dev)
+static int rmi_process_interrupt_requests(struct rmi_device *rmi_dev)
 {
        struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
        struct device *dev = &rmi_dev->dev;
@@ -181,7 +182,42 @@ int rmi_process_interrupt_requests(struct rmi_device *rmi_dev)
 
        return 0;
 }
-EXPORT_SYMBOL_GPL(rmi_process_interrupt_requests);
+
+static irqreturn_t rmi_irq_fn(int irq, void *dev_id)
+{
+       struct rmi_device *rmi_dev = dev_id;
+       int ret;
+
+       ret = rmi_process_interrupt_requests(rmi_dev);
+       if (ret)
+               rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev,
+                       "Failed to process interrupt request: %d\n", ret);
+
+       return IRQ_HANDLED;
+}
+
+static int rmi_irq_init(struct rmi_device *rmi_dev)
+{
+       struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
+       int irq_flags = irq_get_trigger_type(pdata->irq);
+       int ret;
+
+       if (!irq_flags)
+               irq_flags = IRQF_TRIGGER_LOW;
+
+       ret = devm_request_threaded_irq(&rmi_dev->dev, pdata->irq, NULL,
+                                       rmi_irq_fn, irq_flags | IRQF_ONESHOT,
+                                       dev_name(rmi_dev->xport->dev),
+                                       rmi_dev);
+       if (ret < 0) {
+               dev_err(&rmi_dev->dev, "Failed to register interrupt %d\n",
+                       pdata->irq);
+
+               return ret;
+       }
+
+       return 0;
+}
 
 static int suspend_one_function(struct rmi_function *fn)
 {
@@ -802,8 +838,10 @@ static int rmi_create_function(struct rmi_device *rmi_dev,
        return error;
 }
 
-int rmi_driver_suspend(struct rmi_device *rmi_dev)
+int rmi_driver_suspend(struct rmi_device *rmi_dev, bool enable_wake)
 {
+       struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
+       int irq = pdata->irq;
        int retval = 0;
 
        retval = rmi_suspend_functions(rmi_dev);
@@ -811,14 +849,33 @@ int rmi_driver_suspend(struct rmi_device *rmi_dev)
                dev_warn(&rmi_dev->dev, "Failed to suspend functions: %d\n",
                        retval);
 
+       disable_irq(irq);
+       if (enable_wake && device_may_wakeup(rmi_dev->xport->dev)) {
+               retval = enable_irq_wake(irq);
+               if (!retval)
+                       dev_warn(&rmi_dev->dev,
+                                "Failed to enable irq for wake: %d\n",
+                                retval);
+       }
        return retval;
 }
 EXPORT_SYMBOL_GPL(rmi_driver_suspend);
 
-int rmi_driver_resume(struct rmi_device *rmi_dev)
+int rmi_driver_resume(struct rmi_device *rmi_dev, bool clear_wake)
 {
+       struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
+       int irq = pdata->irq;
        int retval;
 
+       enable_irq(irq);
+       if (clear_wake && device_may_wakeup(rmi_dev->xport->dev)) {
+               retval = disable_irq_wake(irq);
+               if (!retval)
+                       dev_warn(&rmi_dev->dev,
+                                "Failed to disable irq for wake: %d\n",
+                                retval);
+       }
+
        retval = rmi_resume_functions(rmi_dev);
        if (retval)
                dev_warn(&rmi_dev->dev, "Failed to suspend functions: %d\n",
@@ -831,6 +888,10 @@ EXPORT_SYMBOL_GPL(rmi_driver_resume);
 static int rmi_driver_remove(struct device *dev)
 {
        struct rmi_device *rmi_dev = to_rmi_device(dev);
+       struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
+       int irq = pdata->irq;
+
+       disable_irq(irq);
 
        rmi_free_function_list(rmi_dev);
 
@@ -1050,6 +1111,10 @@ static int rmi_driver_probe(struct device *dev)
                }
        }
 
+       retval = rmi_irq_init(rmi_dev);
+       if (retval < 0)
+               goto err_destroy_functions;
+
        if (data->f01_container->dev.driver)
                /* Driver already bound, so enable ATTN now. */
                return enable_sensor(rmi_dev);

diff --git a/drivers/input/rmi4/rmi_i2c.c b/drivers/input/rmi4/rmi_i2c.c
index 6f2e0e4f0296999885a40e382bc319ba15fc0253..64a548822da4530c688fa6b3cc4feb383a6f3d9c 100644 (file)
--- a/drivers/input/rmi4/rmi_i2c.c
+++ b/drivers/input/rmi4/rmi_i2c.c
@@ -9,7 +9,6 @@
 
 #include <linux/i2c.h>
 #include <linux/rmi.h>
-#include <linux/irq.h>
 #include <linux/of.h>
 #include <linux/delay.h>
 #include <linux/regulator/consumer.h>
@@ -35,8 +34,6 @@ struct rmi_i2c_xport {
        struct mutex page_mutex;
        int page;
 
-       int irq;
-
        u8 *tx_buf;
        size_t tx_buf_size;
 
@@ -177,42 +174,6 @@ static const struct rmi_transport_ops rmi_i2c_ops = {
        .read_block     = rmi_i2c_read_block,
 };
 
-static irqreturn_t rmi_i2c_irq(int irq, void *dev_id)
-{
-       struct rmi_i2c_xport *rmi_i2c = dev_id;
-       struct rmi_device *rmi_dev = rmi_i2c->xport.rmi_dev;
-       int ret;
-
-       ret = rmi_process_interrupt_requests(rmi_dev);
-       if (ret)
-               rmi_dbg(RMI_DEBUG_XPORT, &rmi_dev->dev,
-                       "Failed to process interrupt request: %d\n", ret);
-
-       return IRQ_HANDLED;
-}
-
-static int rmi_i2c_init_irq(struct i2c_client *client)
-{
-       struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
-       int irq_flags = irqd_get_trigger_type(irq_get_irq_data(rmi_i2c->irq));
-       int ret;
-
-       if (!irq_flags)
-               irq_flags = IRQF_TRIGGER_LOW;
-
-       ret = devm_request_threaded_irq(&client->dev, rmi_i2c->irq, NULL,
-                       rmi_i2c_irq, irq_flags | IRQF_ONESHOT, client->name,
-                       rmi_i2c);
-       if (ret < 0) {
-               dev_warn(&client->dev, "Failed to register interrupt %d\n",
-                       rmi_i2c->irq);
-
-               return ret;
-       }
-
-       return 0;
-}
-
 #ifdef CONFIG_OF
 static const struct of_device_id rmi_i2c_of_match[] = {
        { .compatible = "syna,rmi4-i2c" },
@@ -240,8 +201,7 @@ static int rmi_i2c_probe(struct i2c_client *client,
        if (!client->dev.of_node && client_pdata)
                *pdata = *client_pdata;
 
-       if (client->irq > 0)
-               rmi_i2c->irq = client->irq;
+       pdata->irq = client->irq;
 
        rmi_dbg(RMI_DEBUG_XPORT, &client->dev, "Probing %s.\n",
                        dev_name(&client->dev));
@@ -295,10 +255,6 @@ static int rmi_i2c_probe(struct i2c_client *client,
                return retval;
        }
 
-       retval = rmi_i2c_init_irq(client);
-       if (retval < 0)
-               return retval;
-
        dev_info(&client->dev, "registered rmi i2c driver at %#04x.\n",
                        client->addr);
        return 0;
@@ -322,18 +278,10 @@ static int rmi_i2c_suspend(struct device *dev)
        struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
        int ret;
 
-       ret = rmi_driver_suspend(rmi_i2c->xport.rmi_dev);
+       ret = rmi_driver_suspend(rmi_i2c->xport.rmi_dev, true);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 
-       disable_irq(rmi_i2c->irq);
-       if (device_may_wakeup(&client->dev)) {
-               ret = enable_irq_wake(rmi_i2c->irq);
-               if (!ret)
-                       dev_warn(dev, "Failed to enable irq for wake: %d\n",
-                               ret);
-       }
-
        regulator_bulk_disable(ARRAY_SIZE(rmi_i2c->supplies),
                               rmi_i2c->supplies);
 
@@ -353,15 +301,7 @@ static int rmi_i2c_resume(struct device *dev)
 
        msleep(rmi_i2c->startup_delay);
 
-       enable_irq(rmi_i2c->irq);
-       if (device_may_wakeup(&client->dev)) {
-               ret = disable_irq_wake(rmi_i2c->irq);
-               if (!ret)
-                       dev_warn(dev, "Failed to disable irq for wake: %d\n",
-                               ret);
-       }
-
-       ret = rmi_driver_resume(rmi_i2c->xport.rmi_dev);
+       ret = rmi_driver_resume(rmi_i2c->xport.rmi_dev, true);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 
@@ -376,12 +316,10 @@ static int rmi_i2c_runtime_suspend(struct device *dev)
        struct rmi_i2c_xport *rmi_i2c = i2c_get_clientdata(client);
        int ret;
 
-       ret = rmi_driver_suspend(rmi_i2c->xport.rmi_dev);
+       ret = rmi_driver_suspend(rmi_i2c->xport.rmi_dev, false);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 
-       disable_irq(rmi_i2c->irq);
-
        regulator_bulk_disable(ARRAY_SIZE(rmi_i2c->supplies),
                               rmi_i2c->supplies);
 
@@ -401,9 +339,7 @@ static int rmi_i2c_runtime_resume(struct device *dev)
 
        msleep(rmi_i2c->startup_delay);
 
-       enable_irq(rmi_i2c->irq);
-
-       ret = rmi_driver_resume(rmi_i2c->xport.rmi_dev);
+       ret = rmi_driver_resume(rmi_i2c->xport.rmi_dev, false);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 

diff --git a/drivers/input/rmi4/rmi_spi.c b/drivers/input/rmi4/rmi_spi.c
index 55bd1b34970c90a62005264e257ed774280cfd22..f3e9e488635cb0ed5d80f113794b0343e1be1c42 100644 (file)
--- a/drivers/input/rmi4/rmi_spi.c
+++ b/drivers/input/rmi4/rmi_spi.c
@@ -12,7 +12,6 @@
 #include <linux/rmi.h>
 #include <linux/slab.h>
 #include <linux/spi/spi.h>
-#include <linux/irq.h>
 #include <linux/of.h>
 #include "rmi_driver.h"
 
@@ -44,8 +43,6 @@ struct rmi_spi_xport {
        struct mutex page_mutex;
        int page;
 
-       int irq;
-
        u8 *rx_buf;
        u8 *tx_buf;
        int xfer_buf_size;
@@ -326,41 +323,6 @@ static const struct rmi_transport_ops rmi_spi_ops = {
        .read_block     = rmi_spi_read_block,
 };
 
-static irqreturn_t rmi_spi_irq(int irq, void *dev_id)
-{
-       struct rmi_spi_xport *rmi_spi = dev_id;
-       struct rmi_device *rmi_dev = rmi_spi->xport.rmi_dev;
-       int ret;
-
-       ret = rmi_process_interrupt_requests(rmi_dev);
-       if (ret)
-               rmi_dbg(RMI_DEBUG_XPORT, &rmi_dev->dev,
-                       "Failed to process interrupt request: %d\n", ret);
-
-       return IRQ_HANDLED;
-}
-
-static int rmi_spi_init_irq(struct spi_device *spi)
-{
-       struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
-       int irq_flags = irqd_get_trigger_type(irq_get_irq_data(rmi_spi->irq));
-       int ret;
-
-       if (!irq_flags)
-               irq_flags = IRQF_TRIGGER_LOW;
-
-       ret = devm_request_threaded_irq(&spi->dev, rmi_spi->irq, NULL,
-                       rmi_spi_irq, irq_flags | IRQF_ONESHOT,
-                       dev_name(&spi->dev), rmi_spi);
-       if (ret < 0) {
-               dev_warn(&spi->dev, "Failed to register interrupt %d\n",
-                       rmi_spi->irq);
-               return ret;
-       }
-
-       return 0;
-}
-
 #ifdef CONFIG_OF
 static int rmi_spi_of_probe(struct spi_device *spi,
                        struct rmi_device_platform_data *pdata)
@@ -433,8 +395,7 @@ static int rmi_spi_probe(struct spi_device *spi)
                return retval;
        }
 
-       if (spi->irq > 0)
-               rmi_spi->irq = spi->irq;
+       pdata->irq = spi->irq;
 
        rmi_spi->spi = spi;
        mutex_init(&rmi_spi->page_mutex);
@@ -465,10 +426,6 @@ static int rmi_spi_probe(struct spi_device *spi)
                return retval;
        }
 
-       retval = rmi_spi_init_irq(spi);
-       if (retval < 0)
-               return retval;
-
        dev_info(&spi->dev, "registered RMI SPI driver\n");
        return 0;
 }
@@ -489,17 +446,10 @@ static int rmi_spi_suspend(struct device *dev)
        struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
        int ret;
 
-       ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev);
+       ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, true);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 
-       disable_irq(rmi_spi->irq);
-       if (device_may_wakeup(&spi->dev)) {
-               ret = enable_irq_wake(rmi_spi->irq);
-               if (!ret)
-                       dev_warn(dev, "Failed to enable irq for wake: %d\n",
-                               ret);
-       }
        return ret;
 }
 
@@ -509,15 +459,7 @@ static int rmi_spi_resume(struct device *dev)
        struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
        int ret;
 
-       enable_irq(rmi_spi->irq);
-       if (device_may_wakeup(&spi->dev)) {
-               ret = disable_irq_wake(rmi_spi->irq);
-               if (!ret)
-                       dev_warn(dev, "Failed to disable irq for wake: %d\n",
-                               ret);
-       }
-
-       ret = rmi_driver_resume(rmi_spi->xport.rmi_dev);
+       ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, true);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 
@@ -532,12 +474,10 @@ static int rmi_spi_runtime_suspend(struct device *dev)
        struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
        int ret;
 
-       ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev);
+       ret = rmi_driver_suspend(rmi_spi->xport.rmi_dev, false);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 
-       disable_irq(rmi_spi->irq);
-
        return 0;
 }
 
@@ -547,9 +487,7 @@ static int rmi_spi_runtime_resume(struct device *dev)
        struct rmi_spi_xport *rmi_spi = spi_get_drvdata(spi);
        int ret;
 
-       enable_irq(rmi_spi->irq);
-
-       ret = rmi_driver_resume(rmi_spi->xport.rmi_dev);
+       ret = rmi_driver_resume(rmi_spi->xport.rmi_dev, false);
        if (ret)
                dev_warn(dev, "Failed to resume device: %d\n", ret);
 

diff --git a/include/linux/rmi.h b/include/linux/rmi.h
index e0aca147600169a6fa67dcb3c7d5f7725a52a9d6..5944e6c2470d59d3f79719a51c4d3b690d9fe5b1 100644 (file)
--- a/include/linux/rmi.h
+++ b/include/linux/rmi.h
@@ -204,9 +204,11 @@ struct rmi_device_platform_data_spi {
  * @reset_delay_ms - after issuing a reset command to the touch sensor, the
  * driver waits a few milliseconds to give the firmware a chance to
  * to re-initialize.  You can override the default wait period here.
+ * @irq: irq associated with the attn gpio line, or negative
  */
 struct rmi_device_platform_data {
        int reset_delay_ms;
+       int irq;
 
        struct rmi_device_platform_data_spi spi_data;
 
@@ -352,8 +354,7 @@ struct rmi_driver_data {
 
 int rmi_register_transport_device(struct rmi_transport_dev *xport);
 void rmi_unregister_transport_device(struct rmi_transport_dev *xport);
-int rmi_process_interrupt_requests(struct rmi_device *rmi_dev);
 
-int rmi_driver_suspend(struct rmi_device *rmi_dev);
-int rmi_driver_resume(struct rmi_device *rmi_dev);
+int rmi_driver_suspend(struct rmi_device *rmi_dev, bool enable_wake);
+int rmi_driver_resume(struct rmi_device *rmi_dev, bool clear_wake);
 #endif