mfd: Convert wm831x to irq_domain

The modern idiom is to use irq_domain to allocate interrupts. This is
useful partly to allow further infrastructure to be based on the domains
and partly because it makes it much easier to allocate virtual interrupts
to devices as we don't need to allocate a contiguous range of interrupt
numbers.

Convert the wm831x driver over to this infrastructure, using a legacy
IRQ mapping if an irq_base is specified in platform data and otherwise
using a linear mapping, always registering the interrupts even if they
won't ever be used. Only boards which need to use the GPIOs as
interrupts should need to use an irq_base.

This means that we can't use the MFD irq_base management since the
unless we're using an explicit irq_base from platform data we can't rely
on a linear mapping of interrupts.  Instead we need to map things via
the irq_domain - provide a conveniencem function wm831x_irq() to save a
small amount of typing when doing so. Looking at this I couldn't clearly
see anything the MFD core could do to make this nicer.

Since we're not supporting device tree yet there's no meaningful
advantage if we don't do this conversion in one, the fact that the
interrupt resources are used for repeated IP blocks makes accessor
functions for the irq_domain more trouble to do than they're worth.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

12 files changed, 123 insertions, 83 deletions

diff --git a/drivers/gpio/gpio-wm831x.c b/drivers/gpio/gpio-wm831x.c
index deb949e75ec1..e56a2165641c 100644
--- a/drivers/gpio/gpio-wm831x.c
+++ b/drivers/gpio/gpio-wm831x.c
@@ -102,10 +102,8 @@ static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
         struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
         struct wm831x *wm831x = wm831x_gpio->wm831x;
 
-        if (!wm831x->irq_base)
-                return -EINVAL;
-
-        return wm831x->irq_base + WM831X_IRQ_GPIO_1 + offset;
+        return irq_create_mapping(wm831x->irq_domain,
+                                  WM831X_IRQ_GPIO_1 + offset);
 }
 
 static int wm831x_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
diff --git a/drivers/input/misc/wm831x-on.c b/drivers/input/misc/wm831x-on.c
index 47f18d6bce46..6790a812a1db 100644
--- a/drivers/input/misc/wm831x-on.c
+++ b/drivers/input/misc/wm831x-on.c
@@ -73,7 +73,7 @@ static int __devinit wm831x_on_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_on *wm831x_on;
-        int irq = platform_get_irq(pdev, 0);
+        int irq = wm831x_irq(wm831x, platform_get_irq(pdev, 0));
         int ret;
 
         wm831x_on = kzalloc(sizeof(struct wm831x_on), GFP_KERNEL);
diff --git a/drivers/input/touchscreen/wm831x-ts.c b/drivers/input/touchscreen/wm831x-ts.c
index 4bc851a9dc3d..e83410721e38 100644
--- a/drivers/input/touchscreen/wm831x-ts.c
+++ b/drivers/input/touchscreen/wm831x-ts.c
@@ -260,15 +260,16 @@ static __devinit int wm831x_ts_probe(struct platform_device *pdev)
          * If we have a direct IRQ use it, otherwise use the interrupt
          * from the WM831x IRQ controller.
          */
+        wm831x_ts->data_irq = wm831x_irq(wm831x,
+                                         platform_get_irq_byname(pdev,
+                                                                 "TCHDATA"));
         if (pdata && pdata->data_irq)
                 wm831x_ts->data_irq = pdata->data_irq;
-        else
-                wm831x_ts->data_irq = platform_get_irq_byname(pdev, "TCHDATA");
 
+        wm831x_ts->pd_irq = wm831x_irq(wm831x,
+                                       platform_get_irq_byname(pdev, "TCHPD"));
         if (pdata && pdata->pd_irq)
                 wm831x_ts->pd_irq = pdata->pd_irq;
-        else
-                wm831x_ts->pd_irq = platform_get_irq_byname(pdev, "TCHPD");
 
         if (pdata)
                 wm831x_ts->pressure = pdata->pressure;
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index a0e1b834af61..8325c44c04c6 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -496,6 +496,7 @@ config MFD_WM831X_I2C
         select MFD_CORE
         select MFD_WM831X
         select REGMAP_I2C
+        select IRQ_DOMAIN
         depends on I2C=y && GENERIC_HARDIRQS
         help
           Support for the Wolfson Microelecronics WM831x and WM832x PMICs
@@ -508,6 +509,7 @@ config MFD_WM831X_SPI
         select MFD_CORE
         select MFD_WM831X
         select REGMAP_SPI
+        select IRQ_DOMAIN
         depends on SPI_MASTER && GENERIC_HARDIRQS
         help
           Support for the Wolfson Microelecronics WM831x and WM832x PMICs
diff --git a/drivers/mfd/wm831x-auxadc.c b/drivers/mfd/wm831x-auxadc.c
index 87210954a066..6ee3018d8653 100644
--- a/drivers/mfd/wm831x-auxadc.c
+++ b/drivers/mfd/wm831x-auxadc.c
@@ -280,11 +280,11 @@ void wm831x_auxadc_init(struct wm831x *wm831x)
         mutex_init(&wm831x->auxadc_lock);
         INIT_LIST_HEAD(&wm831x->auxadc_pending);
 
-        if (wm831x->irq && wm831x->irq_base) {
+        if (wm831x->irq) {
                 wm831x->auxadc_read = wm831x_auxadc_read_irq;
 
-                ret = request_threaded_irq(wm831x->irq_base +
-                                           WM831X_IRQ_AUXADC_DATA,
+                ret = request_threaded_irq(wm831x_irq(wm831x,
+                                                      WM831X_IRQ_AUXADC_DATA),
                                            NULL, wm831x_auxadc_irq, 0,
                                            "auxadc", wm831x);
                 if (ret < 0) {
diff --git a/drivers/mfd/wm831x-core.c b/drivers/mfd/wm831x-core.c
index 476e4d31a823..946698fd2dc6 100644
--- a/drivers/mfd/wm831x-core.c
+++ b/drivers/mfd/wm831x-core.c
@@ -1813,27 +1813,27 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
         case WM8310:
                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8310_devs, ARRAY_SIZE(wm8310_devs),
-                                      NULL, wm831x->irq_base);
+                                      NULL, 0);
                 break;
 
         case WM8311:
                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8311_devs, ARRAY_SIZE(wm8311_devs),
-                                      NULL, wm831x->irq_base);
+                                      NULL, 0);
                 if (!pdata || !pdata->disable_touch)
                         mfd_add_devices(wm831x->dev, wm831x_num,
                                         touch_devs, ARRAY_SIZE(touch_devs),
-                                        NULL, wm831x->irq_base);
+                                        NULL, 0);
                 break;
 
         case WM8312:
                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8312_devs, ARRAY_SIZE(wm8312_devs),
-                                      NULL, wm831x->irq_base);
+                                      NULL, 0);
                 if (!pdata || !pdata->disable_touch)
                         mfd_add_devices(wm831x->dev, wm831x_num,
                                         touch_devs, ARRAY_SIZE(touch_devs),
-                                        NULL, wm831x->irq_base);
+                                        NULL, 0);
                 break;
 
         case WM8320:
@@ -1842,7 +1842,7 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
         case WM8326:
                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       wm8320_devs, ARRAY_SIZE(wm8320_devs),
-                                      NULL, wm831x->irq_base);
+                                      NULL, 0);
                 break;
 
         default:
@@ -1867,7 +1867,7 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
         if (ret & WM831X_XTAL_ENA) {
                 ret = mfd_add_devices(wm831x->dev, wm831x_num,
                                       rtc_devs, ARRAY_SIZE(rtc_devs),
-                                      NULL, wm831x->irq_base);
+                                      NULL, 0);
                 if (ret != 0) {
                         dev_err(wm831x->dev, "Failed to add RTC: %d\n", ret);
                         goto err_irq;
@@ -1880,7 +1880,7 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
                 /* Treat errors as non-critical */
                 ret = mfd_add_devices(wm831x->dev, wm831x_num, backlight_devs,
                                       ARRAY_SIZE(backlight_devs), NULL,
-                                      wm831x->irq_base);
+                                      0);
                 if (ret < 0)
                         dev_err(wm831x->dev, "Failed to add backlight: %d\n",
                                 ret);
@@ -1909,8 +1909,7 @@ void wm831x_device_exit(struct wm831x *wm831x)
 {
         wm831x_otp_exit(wm831x);
         mfd_remove_devices(wm831x->dev);
-        if (wm831x->irq_base)
-                free_irq(wm831x->irq_base + WM831X_IRQ_AUXADC_DATA, wm831x);
+        free_irq(wm831x_irq(wm831x, WM831X_IRQ_AUXADC_DATA), wm831x);
         wm831x_irq_exit(wm831x);
 }
 
diff --git a/drivers/mfd/wm831x-irq.c b/drivers/mfd/wm831x-irq.c
index 2be9628074bd..ecc9d6d62fad 100644
--- a/drivers/mfd/wm831x-irq.c
+++ b/drivers/mfd/wm831x-irq.c
@@ -18,6 +18,7 @@
 #include <linux/irq.h>
 #include <linux/mfd/core.h>
 #include <linux/interrupt.h>
+#include <linux/irqdomain.h>
 
 #include <linux/mfd/wm831x/core.h>
 #include <linux/mfd/wm831x/pdata.h>
@@ -328,7 +329,7 @@ static inline int irq_data_to_status_reg(struct wm831x_irq_data *irq_data)
 static inline struct wm831x_irq_data *irq_to_wm831x_irq(struct wm831x *wm831x,
                                                         int irq)
 {
-        return &wm831x_irqs[irq - wm831x->irq_base];
+        return &wm831x_irqs[irq];
 }
 
 static void wm831x_irq_lock(struct irq_data *data)
@@ -374,7 +375,7 @@ static void wm831x_irq_enable(struct irq_data *data)
 {
         struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
         struct wm831x_irq_data *irq_data = irq_to_wm831x_irq(wm831x,
-                                                             data->irq);
+                                                             data->hwirq);
 
         wm831x->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
 }
@@ -383,7 +384,7 @@ static void wm831x_irq_disable(struct irq_data *data)
 {
         struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
         struct wm831x_irq_data *irq_data = irq_to_wm831x_irq(wm831x,
-                                                             data->irq);
+                                                             data->hwirq);
 
         wm831x->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
 }
@@ -393,7 +394,7 @@ static int wm831x_irq_set_type(struct irq_data *data, unsigned int type)
         struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
         int irq;
 
-        irq = data->irq - wm831x->irq_base;
+        irq = data->hwirq;
 
         if (irq < WM831X_IRQ_GPIO_1 || irq > WM831X_IRQ_GPIO_11) {
                 /* Ignore internal-only IRQs */
@@ -469,9 +470,11 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
          * descriptors.
          */
         if (primary & WM831X_TCHPD_INT)
-                handle_nested_irq(wm831x->irq_base + WM831X_IRQ_TCHPD);
+                handle_nested_irq(irq_find_mapping(wm831x->irq_domain,
+                                                   WM831X_IRQ_TCHPD));
         if (primary & WM831X_TCHDATA_INT)
-                handle_nested_irq(wm831x->irq_base + WM831X_IRQ_TCHDATA);
+                handle_nested_irq(irq_find_mapping(wm831x->irq_domain,
+                                                   WM831X_IRQ_TCHDATA));
         primary &= ~(WM831X_TCHDATA_EINT | WM831X_TCHPD_EINT);
 
         for (i = 0; i < ARRAY_SIZE(wm831x_irqs); i++) {
@@ -507,7 +510,8 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
                 }
 
                 if (*status & wm831x_irqs[i].mask)
-                        handle_nested_irq(wm831x->irq_base + i);
+                        handle_nested_irq(irq_find_mapping(wm831x->irq_domain,
+                                                           i));
 
                 /* Simulate an edge triggered IRQ by polling the input
                  * status.  This is sucky but improves interoperability.
@@ -516,7 +520,8 @@ static irqreturn_t wm831x_irq_thread(int irq, void *data)
                     wm831x->gpio_level[i - WM831X_IRQ_GPIO_1]) {
                         ret = wm831x_reg_read(wm831x, WM831X_GPIO_LEVEL);
                         while (ret & 1 << (i - WM831X_IRQ_GPIO_1)) {
-                                handle_nested_irq(wm831x->irq_base + i);
+                                handle_nested_irq(irq_find_mapping(wm831x->irq_domain,
+                                                                   i));
                                 ret = wm831x_reg_read(wm831x,
                                                       WM831X_GPIO_LEVEL);
                         }
@@ -527,10 +532,34 @@ out:
         return IRQ_HANDLED;
 }
 
+static int wm831x_irq_map(struct irq_domain *h, unsigned int virq,
+                          irq_hw_number_t hw)
+{
+        irq_set_chip_data(virq, h->host_data);
+        irq_set_chip_and_handler(virq, &wm831x_irq_chip, handle_edge_irq);
+        irq_set_nested_thread(virq, 1);
+
+        /* ARM needs us to explicitly flag the IRQ as valid
+         * and will set them noprobe when we do so. */
+#ifdef CONFIG_ARM
+        set_irq_flags(virq, IRQF_VALID);
+#else
+        irq_set_noprobe(virq);
+#endif
+
+        return 0;
+}
+
+static struct irq_domain_ops wm831x_irq_domain_ops = {
+        .map    = wm831x_irq_map,
+        .xlate  = irq_domain_xlate_twocell,
+};
+
 int wm831x_irq_init(struct wm831x *wm831x, int irq)
 {
         struct wm831x_pdata *pdata = wm831x->dev->platform_data;
-        int i, cur_irq, ret;
+        struct irq_domain *domain;
+        int i, ret, irq_base;
 
         mutex_init(&wm831x->irq_lock);
 
@@ -543,18 +572,33 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
         }
 
         /* Try to dynamically allocate IRQs if no base is specified */
-        if (!pdata || !pdata->irq_base)
-                wm831x->irq_base = -1;
+        if (pdata && pdata->irq_base) {
+                irq_base = irq_alloc_descs(pdata->irq_base, 0,
+                                           WM831X_NUM_IRQS, 0);
+                if (irq_base < 0) {
+                        dev_warn(wm831x->dev, "Failed to allocate IRQs: %d\n",
+                                 irq_base);
+                        irq_base = 0;
+                }
+        } else {
+                irq_base = 0;
+        }
+
+        if (irq_base)
+                domain = irq_domain_add_legacy(wm831x->dev->of_node,
+                                               ARRAY_SIZE(wm831x_irqs),
+                                               irq_base, 0,
+                                               &wm831x_irq_domain_ops,
+                                               wm831x);
         else
-                wm831x->irq_base = pdata->irq_base;
+                domain = irq_domain_add_linear(wm831x->dev->of_node,
+                                               ARRAY_SIZE(wm831x_irqs),
+                                               &wm831x_irq_domain_ops,
+                                               wm831x);
 
-        wm831x->irq_base = irq_alloc_descs(wm831x->irq_base, 0,
-                                           WM831X_NUM_IRQS, 0);
-        if (wm831x->irq_base < 0) {
-                dev_warn(wm831x->dev, "Failed to allocate IRQs: %d\n",
-                         wm831x->irq_base);
-                wm831x->irq_base = 0;
-                return 0;
+        if (!domain) {
+                dev_warn(wm831x->dev, "Failed to allocate IRQ domain\n");
+                return -EINVAL;
         }
 
         if (pdata && pdata->irq_cmos)
@@ -566,24 +610,7 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
                         WM831X_IRQ_OD, i);
 
         wm831x->irq = irq;
-
-        /* Register them with genirq */
-        for (cur_irq = wm831x->irq_base;
-             cur_irq < ARRAY_SIZE(wm831x_irqs) + wm831x->irq_base;
-             cur_irq++) {
-                irq_set_chip_data(cur_irq, wm831x);
-                irq_set_chip_and_handler(cur_irq, &wm831x_irq_chip,
-                                         handle_edge_irq);
-                irq_set_nested_thread(cur_irq, 1);
-
-                /* ARM needs us to explicitly flag the IRQ as valid
-                 * and will set them noprobe when we do so. */
-#ifdef CONFIG_ARM
-                set_irq_flags(cur_irq, IRQF_VALID);
-#else
-                irq_set_noprobe(cur_irq);
-#endif
-        }
+        wm831x->irq_domain = domain;
 
         if (irq) {
                 /* Try to flag /IRQ as a wake source; there are a number of
diff --git a/drivers/power/wm831x_power.c b/drivers/power/wm831x_power.c
index 987332b71d8d..fc1ad9551182 100644
--- a/drivers/power/wm831x_power.c
+++ b/drivers/power/wm831x_power.c
@@ -565,7 +565,7 @@ static __devinit int wm831x_power_probe(struct platform_device *pdev)
                             goto err_usb;
         }
 
-        irq = platform_get_irq_byname(pdev, "SYSLO");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO"));
         ret = request_threaded_irq(irq, NULL, wm831x_syslo_irq,
                                    IRQF_TRIGGER_RISING, "System power low",
                                    power);
@@ -575,7 +575,7 @@ static __devinit int wm831x_power_probe(struct platform_device *pdev)
                 goto err_battery;
         }
 
-        irq = platform_get_irq_byname(pdev, "PWR SRC");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "PWR SRC"));
         ret = request_threaded_irq(irq, NULL, wm831x_pwr_src_irq,
                                    IRQF_TRIGGER_RISING, "Power source",
                                    power);
@@ -586,7 +586,9 @@ static __devinit int wm831x_power_probe(struct platform_device *pdev)
         }
 
         for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
-                irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
+                irq = wm831x_irq(wm831x,
+                                 platform_get_irq_byname(pdev,
+                                                         wm831x_bat_irqs[i]));
                 ret = request_threaded_irq(irq, NULL, wm831x_bat_irq,
                                            IRQF_TRIGGER_RISING,
                                            wm831x_bat_irqs[i],
@@ -606,10 +608,10 @@ err_bat_irq:
                 irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
                 free_irq(irq, power);
         }
-        irq = platform_get_irq_byname(pdev, "PWR SRC");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "PWR SRC"));
         free_irq(irq, power);
 err_syslo:
-        irq = platform_get_irq_byname(pdev, "SYSLO");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO"));
         free_irq(irq, power);
 err_battery:
         if (power->have_battery)
@@ -626,17 +628,20 @@ err_kmalloc:
 static __devexit int wm831x_power_remove(struct platform_device *pdev)
 {
         struct wm831x_power *wm831x_power = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = wm831x_power->wm831x;
         int irq, i;
 
         for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
-                irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
+                irq = wm831x_irq(wm831x, 
+                                 platform_get_irq_byname(pdev,
+                                                         wm831x_bat_irqs[i]));
                 free_irq(irq, wm831x_power);
         }
 
-        irq = platform_get_irq_byname(pdev, "PWR SRC");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "PWR SRC"));
         free_irq(irq, wm831x_power);
 
-        irq = platform_get_irq_byname(pdev, "SYSLO");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "SYSLO"));
         free_irq(irq, wm831x_power);
 
         if (wm831x_power->have_battery)
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index ff810e787eac..33b2f20a2932 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -565,7 +565,7 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        irq = platform_get_irq_byname(pdev, "UV");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
         ret = request_threaded_irq(irq, NULL, wm831x_dcdc_uv_irq,
                                    IRQF_TRIGGER_RISING, dcdc->name, dcdc);
         if (ret != 0) {
@@ -574,7 +574,7 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
                 goto err_regulator;
         }
 
-        irq = platform_get_irq_byname(pdev, "HC");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "HC"));
         ret = request_threaded_irq(irq, NULL, wm831x_dcdc_oc_irq,
                                    IRQF_TRIGGER_RISING, dcdc->name, dcdc);
         if (ret != 0) {
@@ -588,7 +588,8 @@ static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
         return 0;
 
 err_uv:
-        free_irq(platform_get_irq_byname(pdev, "UV"), dcdc);
+        free_irq(wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")),
+                 dcdc);
 err_regulator:
         regulator_unregister(dcdc->regulator);
 err:
@@ -600,11 +601,14 @@ err:
 static __devexit int wm831x_buckv_remove(struct platform_device *pdev)
 {
         struct wm831x_dcdc *dcdc = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = dcdc->wm831x;
 
         platform_set_drvdata(pdev, NULL);
 
-        free_irq(platform_get_irq_byname(pdev, "HC"), dcdc);
-        free_irq(platform_get_irq_byname(pdev, "UV"), dcdc);
+        free_irq(wm831x_irq(wm831x, platform_get_irq_byname(pdev, "HC")),
+                            dcdc);
+        free_irq(wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")),
+                            dcdc);
         regulator_unregister(dcdc->regulator);
         if (dcdc->dvs_gpio)
                 gpio_free(dcdc->dvs_gpio);
@@ -758,7 +762,7 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        irq = platform_get_irq_byname(pdev, "UV");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
         ret = request_threaded_irq(irq, NULL, wm831x_dcdc_uv_irq,
                                    IRQF_TRIGGER_RISING, dcdc->name, dcdc);
         if (ret != 0) {
@@ -783,7 +787,8 @@ static __devexit int wm831x_buckp_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        free_irq(platform_get_irq_byname(pdev, "UV"), dcdc);
+        free_irq(wm831x_irq(dcdc->wm831x, platform_get_irq_byname(pdev, "UV")),
+                            dcdc);
         regulator_unregister(dcdc->regulator);
 
         return 0;
@@ -883,7 +888,7 @@ static __devinit int wm831x_boostp_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        irq = platform_get_irq_byname(pdev, "UV");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
         ret = request_threaded_irq(irq, NULL, wm831x_dcdc_uv_irq,
                                    IRQF_TRIGGER_RISING, dcdc->name,
                                    dcdc);
@@ -910,7 +915,8 @@ static __devexit int wm831x_boostp_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        free_irq(platform_get_irq_byname(pdev, "UV"), dcdc);
+        free_irq(wm831x_irq(dcdc->wm831x, platform_get_irq_byname(pdev, "UV")),
+                 dcdc);
         regulator_unregister(dcdc->regulator);
         kfree(dcdc);
 
diff --git a/drivers/regulator/wm831x-isink.c b/drivers/regulator/wm831x-isink.c
index b414e09c5620..1596947f603f 100644
--- a/drivers/regulator/wm831x-isink.c
+++ b/drivers/regulator/wm831x-isink.c
@@ -198,7 +198,7 @@ static __devinit int wm831x_isink_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        irq = platform_get_irq(pdev, 0);
+        irq = wm831x_irq(wm831x, platform_get_irq(pdev, 0));
         ret = request_threaded_irq(irq, NULL, wm831x_isink_irq,
                                    IRQF_TRIGGER_RISING, isink->name, isink);
         if (ret != 0) {
@@ -223,7 +223,7 @@ static __devexit int wm831x_isink_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        free_irq(platform_get_irq(pdev, 0), isink);
+        free_irq(wm831x_irq(isink->wm831x, platform_get_irq(pdev, 0)), isink);
 
         regulator_unregister(isink->regulator);
 
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index 641e9f6499d1..b09ba05ada6d 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -359,7 +359,7 @@ static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        irq = platform_get_irq_byname(pdev, "UV");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
         ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
                                    IRQF_TRIGGER_RISING, ldo->name,
                                    ldo);
@@ -385,7 +385,8 @@ static __devexit int wm831x_gp_ldo_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        free_irq(platform_get_irq_byname(pdev, "UV"), ldo);
+        free_irq(wm831x_irq(ldo->wm831x,
+                            platform_get_irq_byname(pdev, "UV")), ldo);
         regulator_unregister(ldo->regulator);
 
         return 0;
@@ -624,7 +625,7 @@ static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
                 goto err;
         }
 
-        irq = platform_get_irq_byname(pdev, "UV");
+        irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
         ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
                                    IRQF_TRIGGER_RISING, ldo->name, ldo);
         if (ret != 0) {
@@ -647,7 +648,8 @@ static __devexit int wm831x_aldo_remove(struct platform_device *pdev)
 {
         struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
 
-        free_irq(platform_get_irq_byname(pdev, "UV"), ldo);
+        free_irq(wm831x_irq(ldo->wm831x, platform_get_irq_byname(pdev, "UV")),
+                 ldo);
         regulator_unregister(ldo->regulator);
 
         return 0;
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
index 3b6e6a67e765..59c6245e0421 100644
--- a/drivers/rtc/rtc-wm831x.c
+++ b/drivers/rtc/rtc-wm831x.c
@@ -396,7 +396,7 @@ static int wm831x_rtc_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
         struct wm831x_rtc *wm831x_rtc;
-        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+        int alm_irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "ALM"));
         int ret = 0;
 
         wm831x_rtc = devm_kzalloc(&pdev->dev, sizeof(*wm831x_rtc), GFP_KERNEL);