Now that we have our own irq_chip, all children can use traditional
request_threaded_irq().

While at that, also remove so functions which became unused.

Tested-by: Aaro Koskinen <aaro.koski...@iki.fi>
Signed-off-by: Felipe Balbi <ba...@ti.com>
---
 drivers/mfd/menelaus.c | 161 +++++++++++++++----------------------------------
 1 file changed, 50 insertions(+), 111 deletions(-)

diff --git a/drivers/mfd/menelaus.c b/drivers/mfd/menelaus.c
index 838d6bf..232d037 100644
--- a/drivers/mfd/menelaus.c
+++ b/drivers/mfd/menelaus.c
@@ -175,7 +175,6 @@ struct menelaus_chip {
        u8                      mask1, mask2;
        u8                      ack1, ack2;
 
-       void                    (*handlers[16])(struct menelaus_chip *);
        void                    (*mmc_callback)(void *data, u8 mask);
        void                    *mmc_callback_data;
 
@@ -209,42 +208,6 @@ static int menelaus_read_reg(struct menelaus_chip *m, int 
reg)
        return val;
 }
 
-static int menelaus_enable_irq(struct menelaus_chip *m, int irq)
-{
-       if (irq > 7) {
-               irq -= 8;
-               m->mask2 &= ~(1 << irq);
-               return menelaus_write_reg(m, MENELAUS_INT_MASK2,
-                               m->mask2);
-       } else {
-               m->mask1 &= ~(1 << irq);
-               return menelaus_write_reg(m, MENELAUS_INT_MASK1,
-                               m->mask1);
-       }
-}
-
-static int menelaus_disable_irq(struct menelaus_chip *m, int irq)
-{
-       if (irq > 7) {
-               irq -= 8;
-               m->mask2 |= (1 << irq);
-               return menelaus_write_reg(m, MENELAUS_INT_MASK2,
-                               m->mask2);
-       } else {
-               m->mask1 |= (1 << irq);
-               return menelaus_write_reg(m, MENELAUS_INT_MASK1,
-                               m->mask1);
-       }
-}
-
-static int menelaus_ack_irq(struct menelaus_chip *m, int irq)
-{
-       if (irq > 7)
-               return menelaus_write_reg(m, MENELAUS_INT_ACK2, 1 << (irq - 8));
-       else
-               return menelaus_write_reg(m, MENELAUS_INT_ACK1, 1 << irq);
-}
-
 static void menelaus_irq_ack(struct irq_data *data)
 {
        struct menelaus_chip *m = irq_data_get_irq_chip_data(data);
@@ -322,47 +285,15 @@ static struct irq_chip menelaus_irq_chip = {
        .irq_bus_sync_unlock = menelaus_irq_bus_sync_unlock,
 };
 
-/* Adds a handler for an interrupt. Does not run in interrupt context */
-static int menelaus_add_irq_work(struct menelaus_chip *m, int irq,
-               void (*handler)(struct menelaus_chip *))
-{
-       int ret = 0;
-
-       mutex_lock(&m->lock);
-       m->handlers[irq] = handler;
-       ret = menelaus_enable_irq(m, irq);
-       mutex_unlock(&m->lock);
-
-       return ret;
-}
-
-/* Removes handler for an interrupt */
-static int menelaus_remove_irq_work(struct menelaus_chip *m, int irq)
-{
-       int ret = 0;
-
-       mutex_lock(&m->lock);
-       ret = menelaus_disable_irq(m, irq);
-       m->handlers[irq] = NULL;
-       mutex_unlock(&m->lock);
-
-       return ret;
-}
-
-/*
- * Gets scheduled when a card detect interrupt happens. Note that in some cases
- * this line is wired to card cover switch rather than the card detect switch
- * in each slot. In this case the cards are not seen by menelaus.
- * FIXME: Add handling for D1 too
- */
-static void menelaus_mmc_cd_work(struct menelaus_chip *m)
+static irqreturn_t menelaus_mmc_cd_irq(int irq, void *_m)
 {
-       int reg;
+       struct menelaus_chip *m = _m;
        unsigned char card_mask = 0;
+       int reg;
 
        reg = menelaus_read_reg(m, MENELAUS_MCT_PIN_ST);
        if (reg < 0)
-               return;
+               return IRQ_NONE;
 
        if (!(reg & 0x1))
                card_mask |= MCT_PIN_ST_S1_CD_ST;
@@ -373,6 +304,8 @@ static void menelaus_mmc_cd_work(struct menelaus_chip *m)
        if (m->mmc_callback)
                m->mmc_callback(m->mmc_callback_data,
                                          card_mask);
+
+       return IRQ_HANDLED;
 }
 
 /*
@@ -504,20 +437,25 @@ int menelaus_register_mmc_callback(void (*callback)(void 
*data, u8 card_mask),
 
        m->mmc_callback_data = data;
        m->mmc_callback = callback;
-       ret = menelaus_add_irq_work(m, MENELAUS_MMC_S1CD_IRQ,
-                                   menelaus_mmc_cd_work);
+
+       ret = request_threaded_irq(MENELAUS_MMC_S1CD_IRQ + m->irq_base,
+                       NULL, menelaus_mmc_cd_irq, IRQF_ONESHOT,
+                       "mmc_s1cd", m);
        if (ret < 0)
                return ret;
-       ret = menelaus_add_irq_work(m, MENELAUS_MMC_S2CD_IRQ,
-                                   menelaus_mmc_cd_work);
+       ret = request_threaded_irq(MENELAUS_MMC_S2CD_IRQ + m->irq_base,
+                       NULL, menelaus_mmc_cd_irq, IRQF_ONESHOT,
+                       "mmc_s2cd", m);
        if (ret < 0)
                return ret;
-       ret = menelaus_add_irq_work(m, MENELAUS_MMC_S1D1_IRQ,
-                                   menelaus_mmc_cd_work);
+       ret = request_threaded_irq(MENELAUS_MMC_S1D1_IRQ + m->irq_base,
+                       NULL, menelaus_mmc_cd_irq, IRQF_ONESHOT,
+                       "mmc_s1d1", m);
        if (ret < 0)
                return ret;
-       ret = menelaus_add_irq_work(m, MENELAUS_MMC_S2D1_IRQ,
-                                   menelaus_mmc_cd_work);
+       ret = request_threaded_irq(MENELAUS_MMC_S2D1_IRQ + m->irq_base,
+                       NULL, menelaus_mmc_cd_irq, IRQF_ONESHOT,
+                       "mmc_s2d1", m);
 
        return ret;
 }
@@ -527,10 +465,10 @@ void menelaus_unregister_mmc_callback(void)
 {
        struct menelaus_chip *m = the_menelaus;
 
-       menelaus_remove_irq_work(m, MENELAUS_MMC_S1CD_IRQ);
-       menelaus_remove_irq_work(m, MENELAUS_MMC_S2CD_IRQ);
-       menelaus_remove_irq_work(m, MENELAUS_MMC_S1D1_IRQ);
-       menelaus_remove_irq_work(m, MENELAUS_MMC_S2D1_IRQ);
+       free_irq(MENELAUS_MMC_S1CD_IRQ + m->irq_base, m);
+       free_irq(MENELAUS_MMC_S2CD_IRQ + m->irq_base, m);
+       free_irq(MENELAUS_MMC_S1D1_IRQ + m->irq_base, m);
+       free_irq(MENELAUS_MMC_S2D1_IRQ + m->irq_base, m);
 
        m->mmc_callback = NULL;
        m->mmc_callback_data = NULL;
@@ -899,7 +837,6 @@ out:
 static irqreturn_t menelaus_irq(int irq, void *_menelaus)
 {
        struct menelaus_chip *m = _menelaus;
-       void (*handler)(struct menelaus_chip *m);
        unsigned long isr;
        unsigned long i;
 
@@ -909,14 +846,9 @@ static irqreturn_t menelaus_irq(int irq, void *_menelaus)
                & ~m->mask1;
 
        for_each_set_bit(i, &isr, 16) {
-               mutex_lock(&m->lock);
-               menelaus_disable_irq(m, i);
-               menelaus_ack_irq(m, i);
-               handler = m->handlers[i];
-               if (handler)
-                       handler(m);
-               menelaus_enable_irq(m, i);
-               mutex_unlock(&m->lock);
+               int irq = i + m->irq_base;
+
+               handle_nested_irq(irq);
        }
 
        return IRQ_HANDLED;
@@ -1131,18 +1063,19 @@ static int menelaus_set_alarm(struct device *dev, 
struct rtc_wkalrm *w)
 
 #ifdef CONFIG_RTC_INTF_DEV
 
-static void menelaus_rtc_update_work(struct menelaus_chip *m)
+static irqreturn_t menelaus_rtc_update_irq(int irq, void *_m)
 {
-       /* report 1/sec update */
-       local_irq_disable();
+       struct menelaus_chip *m = _m;
+
        rtc_update_irq(m->rtc, 1, RTC_IRQF | RTC_UF);
-       local_irq_enable();
+
+       return IRQ_HANDLED;
 }
 
 static int menelaus_ioctl(struct device *dev, unsigned cmd, unsigned long arg)
 {
        struct menelaus_chip *m = dev_get_drvdata(dev);
-       int     status;
+       int     status = 0;
 
        if (m->client->irq <= 0)
                return -ENOIOCTLCMD;
@@ -1163,18 +1096,18 @@ static int menelaus_ioctl(struct device *dev, unsigned 
cmd, unsigned long arg)
        case RTC_UIE_ON:
                if (m->uie)
                        return 0;
-               status = menelaus_remove_irq_work(m, MENELAUS_RTCTMR_IRQ);
-               status = menelaus_add_irq_work(m, MENELAUS_RTCTMR_IRQ,
-                               menelaus_rtc_update_work);
+               free_irq(MENELAUS_RTCTMR_IRQ + m->irq_base, m);
+               status = request_threaded_irq(MENELAUS_RTCTMR_IRQ + m->irq_base,
+                               NULL, menelaus_rtc_update_irq, IRQF_ONESHOT,
+                               "rtc-timer", m);
                if (status == 0)
                        m->uie = 1;
                return status;
        case RTC_UIE_OFF:
                if (!m->uie)
                        return 0;
-               status = menelaus_remove_irq_work(m, MENELAUS_RTCTMR_IRQ);
-               if (status == 0)
-                       m->uie = 0;
+               free_irq(MENELAUS_RTCTMR_IRQ + m->irq_base, m);
+               m->uie = 0;
                return status;
        default:
                return -ENOIOCTLCMD;
@@ -1196,16 +1129,18 @@ static const struct rtc_class_ops menelaus_rtc_ops = {
        .set_alarm              = menelaus_set_alarm,
 };
 
-static void menelaus_rtc_alarm_work(struct menelaus_chip *m)
+static irqreturn_t menelaus_rtc_alarm_irq(int irq, void *_m)
 {
+       struct menelaus_chip *m = _m;
+
        /* report alarm */
-       local_irq_disable();
        rtc_update_irq(m->rtc, 1, RTC_IRQF | RTC_AF);
-       local_irq_enable();
 
        /* then disable it; alarms are oneshot */
        m->rtc_control &= ~RTC_CTRL_AL_EN;
        menelaus_write_reg(m, MENELAUS_RTC_CTRL, m->rtc_control);
+
+       return IRQ_HANDLED;
 }
 
 static inline void menelaus_rtc_init(struct menelaus_chip *m)
@@ -1220,8 +1155,12 @@ static inline void menelaus_rtc_init(struct 
menelaus_chip *m)
 
        /* support RTC alarm; it can issue wakeups */
        if (alarm) {
-               if (menelaus_add_irq_work(m, MENELAUS_RTCALM_IRQ,
-                               menelaus_rtc_alarm_work) < 0) {
+               int ret;
+
+               ret = request_threaded_irq(MENELAUS_RTCALM_IRQ + m->irq_base,
+                               NULL, menelaus_rtc_alarm_irq, IRQF_ONESHOT,
+                               "rtc-alarm", m);
+               if (ret < 0) {
                        dev_err(&m->client->dev, "can't handle RTC alarm\n");
                        return;
                }
@@ -1247,7 +1186,7 @@ static inline void menelaus_rtc_init(struct menelaus_chip 
*m)
                        &menelaus_rtc_ops, THIS_MODULE);
        if (IS_ERR(m->rtc)) {
                if (alarm) {
-                       menelaus_remove_irq_work(m, MENELAUS_RTCALM_IRQ);
+                       free_irq(MENELAUS_RTCALM_IRQ + m->irq_base, m);
                        device_init_wakeup(&m->client->dev, 0);
                }
                dev_err(&m->client->dev, "can't register RTC: %d\n",
-- 
1.8.4.GIT

--
To unsubscribe from this list: send the line "unsubscribe linux-omap" in
the body of a message to majord...@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to