1 files changed, 177 insertions, 77 deletions

diff --git a/drivers/mfd/wm831x-auxadc.c b/drivers/mfd/wm831x-auxadc.c
index 2fc9531b243..87210954a06 100644
--- a/drivers/mfd/wm831x-auxadc.c
+++ b/drivers/mfd/wm831x-auxadc.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 #include <linux/mfd/core.h>
 #include <linux/slab.h>
+#include <linux/list.h>
 
 #include <linux/mfd/wm831x/core.h>
 #include <linux/mfd/wm831x/pdata.h>
@@ -25,19 +26,139 @@
 #include <linux/mfd/wm831x/otp.h>
 #include <linux/mfd/wm831x/regulator.h>
 
-/**
- * wm831x_auxadc_read: Read a value from the WM831x AUXADC
- *
- * @wm831x: Device to read from.
- * @input: AUXADC input to read.
- */
-int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
+struct wm831x_auxadc_req {
+        struct list_head list;
+        enum wm831x_auxadc input;
+        int val;
+        struct completion done;
+};
+
+static int wm831x_auxadc_read_irq(struct wm831x *wm831x,
+                                  enum wm831x_auxadc input)
 {
-        int ret, src, irq_masked, timeout;
+        struct wm831x_auxadc_req *req;
+        int ret;
+        bool ena = false;
+
+        req = kzalloc(sizeof(*req), GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+
+        init_completion(&req->done);
+        req->input = input;
+        req->val = -ETIMEDOUT;
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        /* Enqueue the request */
+        list_add(&req->list, &wm831x->auxadc_pending);
+
+        ena = !wm831x->auxadc_active;
+
+        if (ena) {
+                ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                                      WM831X_AUX_ENA, WM831X_AUX_ENA);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n",
+                                ret);
+                        goto out;
+                }
+        }
+
+        /* Enable the conversion if not already running */
+        if (!(wm831x->auxadc_active & (1 << input))) {
+                ret = wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
+                                      1 << input, 1 << input);
+                if (ret != 0) {
+                        dev_err(wm831x->dev,
+                                "Failed to set AUXADC source: %d\n", ret);
+                        goto out;
+                }
+
+                wm831x->auxadc_active |= 1 << input;
+        }
+
+        /* We convert at the fastest rate possible */
+        if (ena) {
+                ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                                      WM831X_AUX_CVT_ENA |
+                                      WM831X_AUX_RATE_MASK,
+                                      WM831X_AUX_CVT_ENA |
+                                      WM831X_AUX_RATE_MASK);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "Failed to start AUXADC: %d\n",
+                                ret);
+                        goto out;
+                }
+        }
+
+        mutex_unlock(&wm831x->auxadc_lock);
+
+        /* Wait for an interrupt */
+        wait_for_completion_timeout(&req->done, msecs_to_jiffies(500));
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        list_del(&req->list);
+        ret = req->val;
+
+out:
+        mutex_unlock(&wm831x->auxadc_lock);
+
+        kfree(req);
+
+        return ret;
+}
+
+static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
+{
+        struct wm831x *wm831x = irq_data;
+        struct wm831x_auxadc_req *req;
+        int ret, input, val;
+
+        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
+        if (ret < 0) {
+                dev_err(wm831x->dev,
+                        "Failed to read AUXADC data: %d\n", ret);
+                return IRQ_NONE;
+        }
+
+        input = ((ret & WM831X_AUX_DATA_SRC_MASK)
+                 >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
+
+        if (input == 14)
+                input = WM831X_AUX_CAL;
 
-        /* Are we using the interrupt? */
-        irq_masked = wm831x_reg_read(wm831x, WM831X_INTERRUPT_STATUS_1_MASK);
-        irq_masked &= WM831X_AUXADC_DATA_EINT;
+        val = ret & WM831X_AUX_DATA_MASK;
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        /* Disable this conversion, we're about to complete all users */
+        wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
+                        1 << input, 0);
+        wm831x->auxadc_active &= ~(1 << input);
+
+        /* Turn off the entire convertor if idle */
+        if (!wm831x->auxadc_active)
+                wm831x_reg_write(wm831x, WM831X_AUXADC_CONTROL, 0);
+
+        /* Wake up any threads waiting for this request */
+        list_for_each_entry(req, &wm831x->auxadc_pending, list) {
+                if (req->input == input) {
+                        req->val = val;
+                        complete(&req->done);
+                }
+        }
+
+        mutex_unlock(&wm831x->auxadc_lock);
+
+        return IRQ_HANDLED;
+}
+
+static int wm831x_auxadc_read_polled(struct wm831x *wm831x,
+                                     enum wm831x_auxadc input)
+{
+        int ret, src, timeout;
 
         mutex_lock(&wm831x->auxadc_lock);
 
@@ -57,9 +178,6 @@ int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
                 goto out;
         }
 
-        /* Clear any notification from a very late arriving interrupt */
-        try_wait_for_completion(&wm831x->auxadc_done);
-
         ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
                               WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
         if (ret < 0) {
@@ -67,59 +185,42 @@ int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
                 goto disable;
         }
 
-        if (irq_masked) {
-                /* If we're not using interrupts then poll the
-                 * interrupt status register */
-                timeout = 5;
-                while (timeout) {
-                        msleep(1);
-
-                        ret = wm831x_reg_read(wm831x,
-                                              WM831X_INTERRUPT_STATUS_1);
-                        if (ret < 0) {
-                                dev_err(wm831x->dev,
-                                        "ISR 1 read failed: %d\n", ret);
-                                goto disable;
-                        }
-
-                        /* Did it complete? */
-                        if (ret & WM831X_AUXADC_DATA_EINT) {
-                                wm831x_reg_write(wm831x,
-                                                 WM831X_INTERRUPT_STATUS_1,
-                                                 WM831X_AUXADC_DATA_EINT);
-                                break;
-                        } else {
-                                dev_err(wm831x->dev,
-                                        "AUXADC conversion timeout\n");
-                                ret = -EBUSY;
-                                goto disable;
-                        }
-                }
+        /* If we're not using interrupts then poll the
+         * interrupt status register */
+        timeout = 5;
+        while (timeout) {
+                msleep(1);
 
-                ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
+                ret = wm831x_reg_read(wm831x,
+                                      WM831X_INTERRUPT_STATUS_1);
                 if (ret < 0) {
                         dev_err(wm831x->dev,
-                                "Failed to read AUXADC data: %d\n", ret);
+                                "ISR 1 read failed: %d\n", ret);
                         goto disable;
                 }
 
-                wm831x->auxadc_data = ret;
-
-        } else {
-                /* If we are using interrupts then wait for the
-                 * interrupt to complete.  Use an extremely long
-                 * timeout to handle situations with heavy load where
-                 * the notification of the interrupt may be delayed by
-                 * threaded IRQ handling. */
-                if (!wait_for_completion_timeout(&wm831x->auxadc_done,
-                                                 msecs_to_jiffies(500))) {
-                        dev_err(wm831x->dev, "Timed out waiting for AUXADC\n");
+                /* Did it complete? */
+                if (ret & WM831X_AUXADC_DATA_EINT) {
+                        wm831x_reg_write(wm831x,
+                                         WM831X_INTERRUPT_STATUS_1,
+                                         WM831X_AUXADC_DATA_EINT);
+                        break;
+                } else {
+                        dev_err(wm831x->dev,
+                                "AUXADC conversion timeout\n");
                         ret = -EBUSY;
                         goto disable;
                 }
         }
 
-        src = ((wm831x->auxadc_data & WM831X_AUX_DATA_SRC_MASK)
+        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
+        if (ret < 0) {
+                dev_err(wm831x->dev,
+                        "Failed to read AUXADC data: %d\n", ret);
+                goto disable;
+        }
+
+        src = ((ret & WM831X_AUX_DATA_SRC_MASK)
                >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
 
         if (src == 14)
@@ -130,7 +231,7 @@ int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
                         src, input);
                 ret = -EINVAL;
         } else {
-                ret = wm831x->auxadc_data & WM831X_AUX_DATA_MASK;
+                ret &= WM831X_AUX_DATA_MASK;
         }
 
 disable:
@@ -139,26 +240,18 @@ out:
         mutex_unlock(&wm831x->auxadc_lock);
         return ret;
 }
-EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
 
-static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
+/**
+ * wm831x_auxadc_read: Read a value from the WM831x AUXADC
+ *
+ * @wm831x: Device to read from.
+ * @input: AUXADC input to read.
+ */
+int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
 {
-        struct wm831x *wm831x = irq_data;
-        int ret;
-
-        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
-        if (ret < 0) {
-                dev_err(wm831x->dev,
-                        "Failed to read AUXADC data: %d\n", ret);
-                wm831x->auxadc_data = 0xffff;
-        } else {
-                wm831x->auxadc_data = ret;
-        }
-
-        complete(&wm831x->auxadc_done);
-
-        return IRQ_HANDLED;
+        return wm831x->auxadc_read(wm831x, input);
 }
+EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
 
 /**
  * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
@@ -185,15 +278,22 @@ void wm831x_auxadc_init(struct wm831x *wm831x)
         int ret;
 
         mutex_init(&wm831x->auxadc_lock);
-        init_completion(&wm831x->auxadc_done);
+        INIT_LIST_HEAD(&wm831x->auxadc_pending);
+
+        if (wm831x->irq && wm831x->irq_base) {
+                wm831x->auxadc_read = wm831x_auxadc_read_irq;
 
-        if (wm831x->irq_base) {
                 ret = request_threaded_irq(wm831x->irq_base +
                                            WM831X_IRQ_AUXADC_DATA,
                                            NULL, wm831x_auxadc_irq, 0,
                                            "auxadc", wm831x);
-                if (ret < 0)
+                if (ret < 0) {
                         dev_err(wm831x->dev, "AUXADC IRQ request failed: %d\n",
                                 ret);
+                        wm831x->auxadc_read = NULL;
+                }
         }
+
+        if (!wm831x->auxadc_read)
+                wm831x->auxadc_read = wm831x_auxadc_read_polled;
 }