gpio: switch drivers to use new callback

This switches all GPIO and pin control drivers with irqchips
that were using .startup() and .shutdown() callbacks to lock
GPIO lines for IRQ usage over to using the .request_resources()
and .release_resources() callbacks just introduced into the
irqchip vtable.

Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Jean-Jacques Hiblot <jjhiblot@traphandler.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

8 files changed, 56 insertions, 57 deletions

diff --git a/drivers/gpio/gpio-adnp.c b/drivers/gpio/gpio-adnp.c
index 6fc6206b38bd..b2239d678d01 100644
--- a/drivers/gpio/gpio-adnp.c
+++ b/drivers/gpio/gpio-adnp.c
@@ -408,24 +408,23 @@ static void adnp_irq_bus_unlock(struct irq_data *data)
         mutex_unlock(&adnp->irq_lock);
 }
 
-static unsigned int adnp_irq_startup(struct irq_data *data)
+static int adnp_irq_reqres(struct irq_data *data)
 {
         struct adnp *adnp = irq_data_get_irq_chip_data(data);
 
-        if (gpio_lock_as_irq(&adnp->gpio, data->hwirq))
+        if (gpio_lock_as_irq(&adnp->gpio, data->hwirq)) {
                 dev_err(adnp->gpio.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         data->hwirq);
-        /* Satisfy the .enable semantics by unmasking the line */
-        adnp_irq_unmask(data);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void adnp_irq_shutdown(struct irq_data *data)
+static void adnp_irq_relres(struct irq_data *data)
 {
         struct adnp *adnp = irq_data_get_irq_chip_data(data);
 
-        adnp_irq_mask(data);
         gpio_unlock_as_irq(&adnp->gpio, data->hwirq);
 }
 
@@ -436,8 +435,8 @@ static struct irq_chip adnp_irq_chip = {
         .irq_set_type = adnp_irq_set_type,
         .irq_bus_lock = adnp_irq_bus_lock,
         .irq_bus_sync_unlock = adnp_irq_bus_unlock,
-        .irq_startup = adnp_irq_startup,
-        .irq_shutdown = adnp_irq_shutdown,
+        .irq_request_resources = adnp_irq_reqres,
+        .irq_release_resources = adnp_irq_relres,
 };
 
 static int adnp_irq_map(struct irq_domain *domain, unsigned int irq,
diff --git a/drivers/gpio/gpio-bcm-kona.c b/drivers/gpio/gpio-bcm-kona.c
index 5622cfb8325a..3f6b33ce9bd4 100644
--- a/drivers/gpio/gpio-bcm-kona.c
+++ b/drivers/gpio/gpio-bcm-kona.c
@@ -466,23 +466,23 @@ static void bcm_kona_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
         chained_irq_exit(chip, desc);
 }
 
-static unsigned int bcm_kona_gpio_irq_startup(struct irq_data *d)
+static int bcm_kona_gpio_irq_reqres(struct irq_data *d)
 {
         struct bcm_kona_gpio *kona_gpio = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&kona_gpio->gpio_chip, d->hwirq))
+        if (gpio_lock_as_irq(&kona_gpio->gpio_chip, d->hwirq)) {
                 dev_err(kona_gpio->gpio_chip.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         d->hwirq);
-        bcm_kona_gpio_irq_unmask(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void bcm_kona_gpio_irq_shutdown(struct irq_data *d)
+static void bcm_kona_gpio_irq_relres(struct irq_data *d)
 {
         struct bcm_kona_gpio *kona_gpio = irq_data_get_irq_chip_data(d);
 
-        bcm_kona_gpio_irq_mask(d);
         gpio_unlock_as_irq(&kona_gpio->gpio_chip, d->hwirq);
 }
 
@@ -492,8 +492,8 @@ static struct irq_chip bcm_gpio_irq_chip = {
         .irq_mask = bcm_kona_gpio_irq_mask,
         .irq_unmask = bcm_kona_gpio_irq_unmask,
         .irq_set_type = bcm_kona_gpio_irq_set_type,
-        .irq_startup = bcm_kona_gpio_irq_startup,
-        .irq_shutdown = bcm_kona_gpio_irq_shutdown,
+        .irq_request_resources = bcm_kona_gpio_irq_reqres,
+        .irq_release_resources = bcm_kona_gpio_irq_relres,
 };
 
 static struct __initconst of_device_id bcm_kona_gpio_of_match[] = {
diff --git a/drivers/gpio/gpio-dwapb.c b/drivers/gpio/gpio-dwapb.c
index 2797fbb535d0..ed5711f77e2d 100644
--- a/drivers/gpio/gpio-dwapb.c
+++ b/drivers/gpio/gpio-dwapb.c
@@ -136,26 +136,26 @@ static void dwapb_irq_disable(struct irq_data *d)
         spin_unlock_irqrestore(&bgc->lock, flags);
 }
 
-static unsigned int dwapb_irq_startup(struct irq_data *d)
+static int dwapb_irq_reqres(struct irq_data *d)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
         struct bgpio_chip *bgc = &gpio->ports[0].bgc;
 
-        if (gpio_lock_as_irq(&bgc->gc, irqd_to_hwirq(d)))
+        if (gpio_lock_as_irq(&bgc->gc, irqd_to_hwirq(d))) {
                 dev_err(gpio->dev, "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
-        dwapb_irq_enable(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void dwapb_irq_shutdown(struct irq_data *d)
+static void dwapb_irq_relres(struct irq_data *d)
 {
         struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
         struct dwapb_gpio *gpio = igc->private;
         struct bgpio_chip *bgc = &gpio->ports[0].bgc;
 
-        dwapb_irq_disable(d);
         gpio_unlock_as_irq(&bgc->gc, irqd_to_hwirq(d));
 }
 
@@ -255,8 +255,8 @@ static void dwapb_configure_irqs(struct dwapb_gpio *gpio,
         ct->chip.irq_set_type = dwapb_irq_set_type;
         ct->chip.irq_enable = dwapb_irq_enable;
         ct->chip.irq_disable = dwapb_irq_disable;
-        ct->chip.irq_startup = dwapb_irq_startup;
-        ct->chip.irq_shutdown = dwapb_irq_shutdown;
+        ct->chip.irq_request_resources = dwapb_irq_reqres;
+        ct->chip.irq_release_resources = dwapb_irq_relres;
         ct->regs.ack = GPIO_PORTA_EOI;
         ct->regs.mask = GPIO_INTMASK;
 
diff --git a/drivers/gpio/gpio-em.c b/drivers/gpio/gpio-em.c
index 1e98a9873967..8765bd6f48e1 100644
--- a/drivers/gpio/gpio-em.c
+++ b/drivers/gpio/gpio-em.c
@@ -99,23 +99,23 @@ static void em_gio_irq_enable(struct irq_data *d)
         em_gio_write(p, GIO_IEN, BIT(irqd_to_hwirq(d)));
 }
 
-static unsigned int em_gio_irq_startup(struct irq_data *d)
+static int em_gio_irq_reqres(struct irq_data *d)
 {
         struct em_gio_priv *p = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&p->gpio_chip, irqd_to_hwirq(d)))
+        if (gpio_lock_as_irq(&p->gpio_chip, irqd_to_hwirq(d))) {
                 dev_err(p->gpio_chip.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
-        em_gio_irq_enable(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void em_gio_irq_shutdown(struct irq_data *d)
+static void em_gio_irq_relres(struct irq_data *d)
 {
         struct em_gio_priv *p = irq_data_get_irq_chip_data(d);
 
-        em_gio_irq_disable(d);
         gpio_unlock_as_irq(&p->gpio_chip, irqd_to_hwirq(d));
 }
 
@@ -359,8 +359,8 @@ static int em_gio_probe(struct platform_device *pdev)
         irq_chip->irq_mask = em_gio_irq_disable;
         irq_chip->irq_unmask = em_gio_irq_enable;
         irq_chip->irq_set_type = em_gio_irq_set_type;
-        irq_chip->irq_startup = em_gio_irq_startup;
-        irq_chip->irq_shutdown = em_gio_irq_shutdown;
+        irq_chip->irq_request_resources = em_gio_irq_reqres;
+        irq_chip->irq_release_resources = em_gio_irq_relres;
         irq_chip->flags = IRQCHIP_SKIP_SET_WAKE | IRQCHIP_MASK_ON_SUSPEND;
 
         p->irq_domain = irq_domain_add_simple(pdev->dev.of_node,
diff --git a/drivers/gpio/gpio-intel-mid.c b/drivers/gpio/gpio-intel-mid.c
index 3a34bb151fd4..118a6bf455d9 100644
--- a/drivers/gpio/gpio-intel-mid.c
+++ b/drivers/gpio/gpio-intel-mid.c
@@ -231,23 +231,23 @@ static void intel_mid_irq_mask(struct irq_data *d)
 {
 }
 
-static unsigned int intel_mid_irq_startup(struct irq_data *d)
+static int intel_mid_irq_reqres(struct irq_data *d)
 {
         struct intel_mid_gpio *priv = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&priv->chip, irqd_to_hwirq(d)))
+        if (gpio_lock_as_irq(&priv->chip, irqd_to_hwirq(d))) {
                 dev_err(priv->chip.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
-        intel_mid_irq_unmask(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void intel_mid_irq_shutdown(struct irq_data *d)
+static void intel_mid_irq_relres(struct irq_data *d)
 {
         struct intel_mid_gpio *priv = irq_data_get_irq_chip_data(d);
 
-        intel_mid_irq_mask(d);
         gpio_unlock_as_irq(&priv->chip, irqd_to_hwirq(d));
 }
 
@@ -256,8 +256,8 @@ static struct irq_chip intel_mid_irqchip = {
         .irq_mask       = intel_mid_irq_mask,
         .irq_unmask     = intel_mid_irq_unmask,
         .irq_set_type   = intel_mid_irq_type,
-        .irq_startup    = intel_mid_irq_startup,
-        .irq_shutdown   = intel_mid_irq_shutdown,
+        .irq_request_resources = intel_mid_irq_reqres,
+        .irq_release_resources = intel_mid_irq_relres,
 };
 
 static const struct intel_mid_gpio_ddata gpio_lincroft = {
diff --git a/drivers/gpio/gpio-lynxpoint.c b/drivers/gpio/gpio-lynxpoint.c
index 66b18535b5ae..41f79cb24a9e 100644
--- a/drivers/gpio/gpio-lynxpoint.c
+++ b/drivers/gpio/gpio-lynxpoint.c
@@ -301,23 +301,23 @@ static void lp_irq_disable(struct irq_data *d)
         spin_unlock_irqrestore(&lg->lock, flags);
 }
 
-static unsigned int lp_irq_startup(struct irq_data *d)
+static int lp_irq_reqres(struct irq_data *d)
 {
         struct lp_gpio *lg = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&lg->chip, irqd_to_hwirq(d)))
+        if (gpio_lock_as_irq(&lg->chip, irqd_to_hwirq(d))) {
                 dev_err(lg->chip.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
-        lp_irq_enable(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void lp_irq_shutdown(struct irq_data *d)
+static void lp_irq_relres(struct irq_data *d)
 {
         struct lp_gpio *lg = irq_data_get_irq_chip_data(d);
 
-        lp_irq_disable(d);
         gpio_unlock_as_irq(&lg->chip, irqd_to_hwirq(d));
 }
 
@@ -328,8 +328,8 @@ static struct irq_chip lp_irqchip = {
         .irq_enable = lp_irq_enable,
         .irq_disable = lp_irq_disable,
         .irq_set_type = lp_irq_type,
-        .irq_startup = lp_irq_startup,
-        .irq_shutdown = lp_irq_shutdown,
+        .irq_request_resources = lp_irq_reqres,
+        .irq_release_resources = lp_irq_relres,
         .flags = IRQCHIP_SKIP_SET_WAKE,
 };
 
diff --git a/drivers/gpio/gpio-mcp23s08.c b/drivers/gpio/gpio-mcp23s08.c
index e1734c114916..99a68310e7c0 100644
--- a/drivers/gpio/gpio-mcp23s08.c
+++ b/drivers/gpio/gpio-mcp23s08.c
@@ -440,24 +440,24 @@ static void mcp23s08_irq_bus_unlock(struct irq_data *data)
         mutex_unlock(&mcp->irq_lock);
 }
 
-static unsigned int mcp23s08_irq_startup(struct irq_data *data)
+static int mcp23s08_irq_reqres(struct irq_data *data)
 {
         struct mcp23s08 *mcp = irq_data_get_irq_chip_data(data);
 
-        if (gpio_lock_as_irq(&mcp->chip, data->hwirq))
+        if (gpio_lock_as_irq(&mcp->chip, data->hwirq)) {
                 dev_err(mcp->chip.dev,
                         "unable to lock HW IRQ %lu for IRQ usage\n",
                         data->hwirq);
+                return -EINVAL;
+        }
 
-        mcp23s08_irq_unmask(data);
         return 0;
 }
 
-static void mcp23s08_irq_shutdown(struct irq_data *data)
+static void mcp23s08_irq_relres(struct irq_data *data)
 {
         struct mcp23s08 *mcp = irq_data_get_irq_chip_data(data);
 
-        mcp23s08_irq_mask(data);
         gpio_unlock_as_irq(&mcp->chip, data->hwirq);
 }
 
@@ -468,8 +468,8 @@ static struct irq_chip mcp23s08_irq_chip = {
         .irq_set_type = mcp23s08_irq_set_type,
         .irq_bus_lock = mcp23s08_irq_bus_lock,
         .irq_bus_sync_unlock = mcp23s08_irq_bus_unlock,
-        .irq_startup = mcp23s08_irq_startup,
-        .irq_shutdown = mcp23s08_irq_shutdown,
+        .irq_request_resources = mcp23s08_irq_reqres,
+        .irq_release_resources = mcp23s08_irq_relres,
 };
 
 static int mcp23s08_irq_setup(struct mcp23s08 *mcp)
diff --git a/drivers/gpio/gpio-pl061.c b/drivers/gpio/gpio-pl061.c
index 391766e5aeed..d2a0ad5fc752 100644
--- a/drivers/gpio/gpio-pl061.c
+++ b/drivers/gpio/gpio-pl061.c
@@ -233,23 +233,23 @@ static void pl061_irq_unmask(struct irq_data *d)
         spin_unlock(&chip->lock);
 }
 
-static unsigned int pl061_irq_startup(struct irq_data *d)
+static int pl061_irq_reqres(struct irq_data *d)
 {
         struct pl061_gpio *chip = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&chip->gc, irqd_to_hwirq(d)))
+        if (gpio_lock_as_irq(&chip->gc, irqd_to_hwirq(d))) {
                 dev_err(chip->gc.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
-        pl061_irq_unmask(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void pl061_irq_shutdown(struct irq_data *d)
+static void pl061_irq_relres(struct irq_data *d)
 {
         struct pl061_gpio *chip = irq_data_get_irq_chip_data(d);
 
-        pl061_irq_mask(d);
         gpio_unlock_as_irq(&chip->gc, irqd_to_hwirq(d));
 }
 
@@ -258,8 +258,8 @@ static struct irq_chip pl061_irqchip = {
         .irq_mask       = pl061_irq_mask,
         .irq_unmask     = pl061_irq_unmask,
         .irq_set_type   = pl061_irq_type,
-        .irq_startup    = pl061_irq_startup,
-        .irq_shutdown   = pl061_irq_shutdown,
+        .irq_request_resources = pl061_irq_reqres,
+        .irq_release_resources = pl061_irq_relres,
 };
 
 static int pl061_irq_map(struct irq_domain *d, unsigned int irq,