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>

diff --git a/drivers/mfd/wm8350-irq.c b/drivers/mfd/wm8350-irq.c
index d9abfc94c6853e342db826236cf6170285b231c4..2ea2b8b4c72aba1e4efb27c495f0c3474d00eb9a 100644 (file)
--- 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 28b0299c0043694cf19bed7d3bc97b8289db2873..6e634cf7fc141da8a2e8fea120fb4d4ca44b7a00 100644 (file)
--- 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 768bd0e5b48bdd00293796554807fb2523ecc01d..8c289fd4add2955ac041524604d002fe2e9b8d40 100644 (file)
--- 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 c91edc572eb609f3c78449099fabf04d0e76af8d..56e56e552813a0e1c08459cbb9f7baf31de07f30 100644 (file)
--- 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;

diff --git a/include/linux/mfd/wm8350/core.h b/include/linux/mfd/wm8350/core.h
index ffce508a910955aaf406de414ace08b20c92f0cc..43868899bf4915a56779089651c9532ac1ecf2ec 100644 (file)
--- a/include/linux/mfd/wm8350/core.h
+++ b/include/linux/mfd/wm8350/core.h
@@ -15,7 +15,7 @@
 
 #include <linux/kernel.h>
 #include <linux/mutex.h>
-#include <linux/workqueue.h>
+#include <linux/interrupt.h>
 
 #include <linux/mfd/wm8350/audio.h>
 #include <linux/mfd/wm8350/gpio.h>
@@ -601,7 +601,7 @@ extern const u16 wm8352_mode3_defaults[];
 struct wm8350;
 
 struct wm8350_irq {
-       void (*handler) (struct wm8350 *, int, void *);
+       irq_handler_t handler;
        void *data;
 };
 
@@ -678,8 +678,8 @@ int wm8350_block_write(struct wm8350 *wm8350, int reg, int size, u16 *src);
  * WM8350 internal interrupts
  */
 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);
 int wm8350_free_irq(struct wm8350 *wm8350, int irq);
 int wm8350_mask_irq(struct wm8350 *wm8350, int irq);
 int wm8350_unmask_irq(struct wm8350 *wm8350, int irq);

diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index f82125d9e85a750e0aefd4d9d3ed7db9f7e30ecb..17a327d67fd5c84471b9b17c506df622a46f8290 100644 (file)
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -1340,9 +1340,10 @@ static int wm8350_resume(struct platform_device *pdev)
        return 0;
 }
 
-static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
+static irqreturn_t wm8350_hp_jack_handler(int irq, void *data)
 {
        struct wm8350_data *priv = data;
+       struct wm8350 *wm8350 = priv->codec.control_data;
        u16 reg;
        int report;
        int mask;
@@ -1365,7 +1366,7 @@ static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
 
        if (!jack->jack) {
                dev_warn(wm8350->dev, "Jack interrupt called with no jack\n");
-               return;
+               return IRQ_NONE;
        }
 
        /* Debounce */
@@ -1378,6 +1379,8 @@ static void wm8350_hp_jack_handler(struct wm8350 *wm8350, int irq, void *data)
                report = 0;
 
        snd_soc_jack_report(jack->jack, report, jack->report);
+
+       return IRQ_HANDLED;
 }
 
 /**
@@ -1421,7 +1424,7 @@ int wm8350_hp_jack_detect(struct snd_soc_codec *codec, enum wm8350_jack which,
        wm8350_set_bits(wm8350, WM8350_JACK_DETECT, ena);
 
        /* Sync status */
-       wm8350_hp_jack_handler(wm8350, irq, priv);
+       wm8350_hp_jack_handler(irq, priv);
 
        wm8350_unmask_irq(wm8350, irq);
 
@@ -1485,9 +1488,11 @@ static int wm8350_probe(struct platform_device *pdev)
        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L);
        wm8350_mask_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R);
        wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_L,
-                           wm8350_hp_jack_handler, priv);
+                           wm8350_hp_jack_handler, 0, "Left jack detect",
+                           priv);
        wm8350_register_irq(wm8350, WM8350_IRQ_CODEC_JCK_DET_R,
-                           wm8350_hp_jack_handler, priv);
+                           wm8350_hp_jack_handler, 0, "Right jack detect",
+                           priv);
 
        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
        if (ret < 0) {