13 files changed, 97 insertions, 81 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,
diff --git a/drivers/pinctrl/pinctrl-adi2.c b/drivers/pinctrl/pinctrl-adi2.c
index 7a39562c3e42..94138bca1f2e 100644
--- a/drivers/pinctrl/pinctrl-adi2.c
+++ b/drivers/pinctrl/pinctrl-adi2.c
@@ -324,6 +324,7 @@ static unsigned int adi_gpio_irq_startup(struct irq_data *d)
 
         if (!port) {
                 pr_err("GPIO IRQ %d :Not exist\n", d->irq);
+                /* FIXME: negative return code will be ignored */
                 return -ENODEV;
         }
 
diff --git a/drivers/pinctrl/pinctrl-baytrail.c b/drivers/pinctrl/pinctrl-baytrail.c
index 665b96bc0c3a..9a4abd9cc878 100644
--- a/drivers/pinctrl/pinctrl-baytrail.c
+++ b/drivers/pinctrl/pinctrl-baytrail.c
@@ -371,23 +371,23 @@ static void byt_irq_mask(struct irq_data *d)
 {
 }
 
-static unsigned int byt_irq_startup(struct irq_data *d)
+static int byt_irq_reqres(struct irq_data *d)
 {
         struct byt_gpio *vg = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&vg->chip, irqd_to_hwirq(d)))
+        if (gpio_lock_as_irq(&vg->chip, irqd_to_hwirq(d))) {
                 dev_err(vg->chip.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         irqd_to_hwirq(d));
-        byt_irq_unmask(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void byt_irq_shutdown(struct irq_data *d)
+static void byt_irq_relres(struct irq_data *d)
 {
         struct byt_gpio *vg = irq_data_get_irq_chip_data(d);
 
-        byt_irq_mask(d);
         gpio_unlock_as_irq(&vg->chip, irqd_to_hwirq(d));
 }
 
@@ -396,8 +396,8 @@ static struct irq_chip byt_irqchip = {
         .irq_mask = byt_irq_mask,
         .irq_unmask = byt_irq_unmask,
         .irq_set_type = byt_irq_type,
-        .irq_startup = byt_irq_startup,
-        .irq_shutdown = byt_irq_shutdown,
+        .irq_request_resources = byt_irq_reqres,
+        .irq_release_resources = byt_irq_relres,
 };
 
 static void byt_gpio_irq_init_hw(struct byt_gpio *vg)
diff --git a/drivers/pinctrl/pinctrl-msm.c b/drivers/pinctrl/pinctrl-msm.c
index ef2bf3126da6..81ecd6ba4169 100644
--- a/drivers/pinctrl/pinctrl-msm.c
+++ b/drivers/pinctrl/pinctrl-msm.c
@@ -805,23 +805,22 @@ static int msm_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
         return 0;
 }
 
-static unsigned int msm_gpio_irq_startup(struct irq_data *d)
+static int msm_gpio_irq_reqres(struct irq_data *d)
 {
         struct msm_pinctrl *pctrl = irq_data_get_irq_chip_data(d);
 
         if (gpio_lock_as_irq(&pctrl->chip, d->hwirq)) {
                 dev_err(pctrl->dev, "unable to lock HW IRQ %lu for IRQ\n",
                         d->hwirq);
+                return -EINVAL;
         }
-        msm_gpio_irq_unmask(d);
         return 0;
 }
 
-static void msm_gpio_irq_shutdown(struct irq_data *d)
+static void msm_gpio_irq_relres(struct irq_data *d)
 {
         struct msm_pinctrl *pctrl = irq_data_get_irq_chip_data(d);
 
-        msm_gpio_irq_mask(d);
         gpio_unlock_as_irq(&pctrl->chip, d->hwirq);
 }
 
@@ -832,8 +831,8 @@ static struct irq_chip msm_gpio_irq_chip = {
         .irq_ack        = msm_gpio_irq_ack,
         .irq_set_type   = msm_gpio_irq_set_type,
         .irq_set_wake   = msm_gpio_irq_set_wake,
-        .irq_startup    = msm_gpio_irq_startup,
-        .irq_shutdown   = msm_gpio_irq_shutdown,
+        .irq_request_resources = msm_gpio_irq_reqres,
+        .irq_release_resources = msm_gpio_irq_relres,
 };
 
 static void msm_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
diff --git a/drivers/pinctrl/pinctrl-nomadik.c b/drivers/pinctrl/pinctrl-nomadik.c
index 53a11114927f..2ea3f3738eab 100644
--- a/drivers/pinctrl/pinctrl-nomadik.c
+++ b/drivers/pinctrl/pinctrl-nomadik.c
@@ -848,10 +848,6 @@ static unsigned int nmk_gpio_irq_startup(struct irq_data *d)
 {
         struct nmk_gpio_chip *nmk_chip = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&nmk_chip->chip, d->hwirq))
-                dev_err(nmk_chip->chip.dev,
-                        "unable to lock HW IRQ %lu for IRQ\n",
-                        d->hwirq);
         clk_enable(nmk_chip->clk);
         nmk_gpio_irq_unmask(d);
         return 0;
@@ -863,6 +859,25 @@ static void nmk_gpio_irq_shutdown(struct irq_data *d)
 
         nmk_gpio_irq_mask(d);
         clk_disable(nmk_chip->clk);
+}
+
+static int nmk_gpio_irq_reqres(struct irq_data *d)
+{
+        struct nmk_gpio_chip *nmk_chip = irq_data_get_irq_chip_data(d);
+
+        if (gpio_lock_as_irq(&nmk_chip->chip, d->hwirq)) {
+                dev_err(nmk_chip->chip.dev,
+                        "unable to lock HW IRQ %lu for IRQ\n",
+                        d->hwirq);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static void nmk_gpio_irq_relres(struct irq_data *d)
+{
+        struct nmk_gpio_chip *nmk_chip = irq_data_get_irq_chip_data(d);
+
         gpio_unlock_as_irq(&nmk_chip->chip, d->hwirq);
 }
 
@@ -875,6 +890,8 @@ static struct irq_chip nmk_gpio_irq_chip = {
         .irq_set_wake   = nmk_gpio_irq_set_wake,
         .irq_startup    = nmk_gpio_irq_startup,
         .irq_shutdown   = nmk_gpio_irq_shutdown,
+        .irq_request_resources = nmk_gpio_irq_reqres,
+        .irq_release_resources = nmk_gpio_irq_relres,
         .flags          = IRQCHIP_MASK_ON_SUSPEND,
 };
 
diff --git a/drivers/pinctrl/sirf/pinctrl-sirf.c b/drivers/pinctrl/sirf/pinctrl-sirf.c
index 617a4916b50f..3ce6e258bc80 100644
--- a/drivers/pinctrl/sirf/pinctrl-sirf.c
+++ b/drivers/pinctrl/sirf/pinctrl-sirf.c
@@ -594,23 +594,23 @@ static int sirfsoc_gpio_irq_type(struct irq_data *d, unsigned type)
         return 0;
 }
 
-static unsigned int sirfsoc_gpio_irq_startup(struct irq_data *d)
+static int sirfsoc_gpio_irq_reqres(struct irq_data *d)
 {
         struct sirfsoc_gpio_bank *bank = irq_data_get_irq_chip_data(d);
 
-        if (gpio_lock_as_irq(&bank->chip.gc, d->hwirq % SIRFSOC_GPIO_BANK_SIZE))
+        if (gpio_lock_as_irq(&bank->chip.gc, d->hwirq % SIRFSOC_GPIO_BANK_SIZE)) {
                 dev_err(bank->chip.gc.dev,
                         "unable to lock HW IRQ %lu for IRQ\n",
                         d->hwirq);
-        sirfsoc_gpio_irq_unmask(d);
+                return -EINVAL;
+        }
         return 0;
 }
 
-static void sirfsoc_gpio_irq_shutdown(struct irq_data *d)
+static void sirfsoc_gpio_irq_relres(struct irq_data *d)
 {
         struct sirfsoc_gpio_bank *bank = irq_data_get_irq_chip_data(d);
 
-        sirfsoc_gpio_irq_mask(d);
         gpio_unlock_as_irq(&bank->chip.gc, d->hwirq % SIRFSOC_GPIO_BANK_SIZE);
 }
 
@@ -620,8 +620,8 @@ static struct irq_chip sirfsoc_irq_chip = {
         .irq_mask = sirfsoc_gpio_irq_mask,
         .irq_unmask = sirfsoc_gpio_irq_unmask,
         .irq_set_type = sirfsoc_gpio_irq_type,
-        .irq_startup = sirfsoc_gpio_irq_startup,
-        .irq_shutdown = sirfsoc_gpio_irq_shutdown,
+        .irq_request_resources = sirfsoc_gpio_irq_reqres,
+        .irq_release_resources = sirfsoc_gpio_irq_relres,
 };
 
 static void sirfsoc_gpio_handle_irq(unsigned int irq, struct irq_desc *desc)