mfd: Convert wm8350 IRQ handlers to irq_handler_t

This is done as simple code transformation, the semantics of the
IRQ API provided by the core are are still very different to those
of genirq (mainly with regard to masking).

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

4 files changed, 45 insertions, 25 deletions

diff --git a/drivers/mfd/wm8350-irq.c b/drivers/mfd/wm8350-irq.c
index d9abfc94c685..2ea2b8b4c72a 100644
--- a/drivers/mfd/wm8350-irq.c
+++ b/drivers/mfd/wm8350-irq.c
@@ -371,7 +371,7 @@ static void wm8350_irq_call_handler(struct wm8350 *wm8350, int irq)
         mutex_lock(&wm8350->irq_mutex);
 
         if (wm8350->irq[irq].handler)
-                wm8350->irq[irq].handler(wm8350, irq, wm8350->irq[irq].data);
+                wm8350->irq[irq].handler(irq, wm8350->irq[irq].data);
         else {
                 dev_err(wm8350->dev, "irq %d nobody cared. now masked.\n",
                         irq);
@@ -431,8 +431,8 @@ static irqreturn_t wm8350_irq(int irq, void *irq_data)
 }
 
 int wm8350_register_irq(struct wm8350 *wm8350, int irq,
-                        void (*handler) (struct wm8350 *, int, void *),
-                        void *data)
+                        irq_handler_t handler, unsigned long flags,
+                        const char *name, void *data)
 {
         if (irq < 0 || irq > WM8350_NUM_IRQ || !handler)
                 return -EINVAL;
diff --git a/drivers/power/wm8350_power.c b/drivers/power/wm8350_power.c
index 28b0299c0043..6e634cf7fc14 100644
--- a/drivers/power/wm8350_power.c
+++ b/drivers/power/wm8350_power.c
@@ -184,8 +184,9 @@ static ssize_t charger_state_show(struct device *dev,
 
 static DEVICE_ATTR(charger_state, 0444, charger_state_show, NULL);
 
-static void wm8350_charger_handler(struct wm8350 *wm8350, int irq, void *data)
+static irqreturn_t wm8350_charger_handler(int irq, void *data)
 {
+        struct wm8350 *wm8350 = data;
         struct wm8350_power *power = &wm8350->power;
         struct wm8350_charger_policy *policy = power->policy;
 
@@ -238,6 +239,8 @@ static void wm8350_charger_handler(struct wm8350 *wm8350, int irq, void *data)
         default:
                 dev_err(wm8350->dev, "Unknown interrupt %d\n", irq);
         }
+
+        return IRQ_HANDLED;
 }
 
 /*********************************************************************
@@ -387,45 +390,53 @@ static void wm8350_init_charger(struct wm8350 *wm8350)
 {
         /* register our interest in charger events */
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0, "Battery hot", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0, "Battery cold", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0, "Battery fail", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Charger timeout", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_TO);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Charge end", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_END);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Charge start", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_START);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Fast charge ready", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Battery <3.9V", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Battery <3.1V", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0,
+                            "Battery <2.85V", wm8350);
+
         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
 
         /* and supply change events */
         wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0, "USB", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
         wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0, "Wall", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
         wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
-                            wm8350_charger_handler, NULL);
+                            wm8350_charger_handler, 0, "Battery", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
 }
 
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index 768bd0e5b48b..8c289fd4add2 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -1330,9 +1330,10 @@ static struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
          },
 };
 
-static void pmic_uv_handler(struct wm8350 *wm8350, int irq, void *data)
+static irqreturn_t pmic_uv_handler(int irq, void *data)
 {
         struct regulator_dev *rdev = (struct regulator_dev *)data;
+        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
 
         mutex_lock(&rdev->mutex);
         if (irq == WM8350_IRQ_CS1 || irq == WM8350_IRQ_CS2)
@@ -1344,6 +1345,8 @@ static void pmic_uv_handler(struct wm8350 *wm8350, int irq, void *data)
                                               REGULATOR_EVENT_UNDER_VOLTAGE,
                                               wm8350);
         mutex_unlock(&rdev->mutex);
+
+        return IRQ_HANDLED;
 }
 
 static int wm8350_regulator_probe(struct platform_device *pdev)
@@ -1388,7 +1391,7 @@ static int wm8350_regulator_probe(struct platform_device *pdev)
 
         /* register regulator IRQ */
         ret = wm8350_register_irq(wm8350, wm8350_reg[pdev->id].irq,
-                                  pmic_uv_handler, rdev);
+                                  pmic_uv_handler, 0, "UV", rdev);
         if (ret < 0) {
                 regulator_unregister(rdev);
                 dev_err(&pdev->dev, "failed to register regulator %s IRQ\n",
diff --git a/drivers/rtc/rtc-wm8350.c b/drivers/rtc/rtc-wm8350.c
index c91edc572eb6..56e56e552813 100644
--- a/drivers/rtc/rtc-wm8350.c
+++ b/drivers/rtc/rtc-wm8350.c
@@ -315,9 +315,9 @@ static int wm8350_rtc_update_irq_enable(struct device *dev,
         return 0;
 }
 
-static void wm8350_rtc_alarm_handler(struct wm8350 *wm8350, int irq,
-                                     void *data)
+static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data)
 {
+        struct wm8350 *wm8350 = data;
         struct rtc_device *rtc = wm8350->rtc.rtc;
         int ret;
 
@@ -330,14 +330,18 @@ static void wm8350_rtc_alarm_handler(struct wm8350 *wm8350, int irq,
                 dev_err(&(wm8350->rtc.pdev->dev),
                         "Failed to disable alarm: %d\n", ret);
         }
+
+        return IRQ_HANDLED;
 }
 
-static void wm8350_rtc_update_handler(struct wm8350 *wm8350, int irq,
-                                      void *data)
+static irqreturn_t wm8350_rtc_update_handler(int irq, void *data)
 {
+        struct wm8350 *wm8350 = data;
         struct rtc_device *rtc = wm8350->rtc.rtc;
 
         rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF);
+
+        return IRQ_HANDLED;
 }
 
 static const struct rtc_class_ops wm8350_rtc_ops = {
@@ -459,10 +463,12 @@ static int wm8350_rtc_probe(struct platform_device *pdev)
         wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_PER);
 
         wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC,
-                            wm8350_rtc_update_handler, NULL);
+                            wm8350_rtc_update_handler, 0,
+                            "RTC Seconds", wm8350);
 
         wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM,
-                            wm8350_rtc_alarm_handler, NULL);
+                            wm8350_rtc_alarm_handler, 0,
+                            "RTC Alarm", wm8350);
         wm8350_unmask_irq(wm8350, WM8350_IRQ_RTC_ALM);
 
         return 0;