mfd: Fix twl-core oops while calling twl_i2c_* for unbound driver
[linux-2.6.git] / drivers / mfd / wm831x-auxadc.c
1 /*
2  * wm831x-auxadc.c  --  AUXADC for Wolfson WM831x PMICs
3  *
4  * Copyright 2009-2011 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  *
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/delay.h>
18 #include <linux/mfd/core.h>
19 #include <linux/slab.h>
20 #include <linux/list.h>
21
22 #include <linux/mfd/wm831x/core.h>
23 #include <linux/mfd/wm831x/pdata.h>
24 #include <linux/mfd/wm831x/irq.h>
25 #include <linux/mfd/wm831x/auxadc.h>
26 #include <linux/mfd/wm831x/otp.h>
27 #include <linux/mfd/wm831x/regulator.h>
28
29 struct wm831x_auxadc_req {
30         struct list_head list;
31         enum wm831x_auxadc input;
32         int val;
33         struct completion done;
34 };
35
36 static int wm831x_auxadc_read_irq(struct wm831x *wm831x,
37                                   enum wm831x_auxadc input)
38 {
39         struct wm831x_auxadc_req *req;
40         int ret;
41         bool ena = false;
42
43         req = kzalloc(sizeof(*req), GFP_KERNEL);
44         if (!req)
45                 return -ENOMEM;
46
47         init_completion(&req->done);
48         req->input = input;
49         req->val = -ETIMEDOUT;
50
51         mutex_lock(&wm831x->auxadc_lock);
52
53         /* Enqueue the request */
54         list_add(&req->list, &wm831x->auxadc_pending);
55
56         ena = !wm831x->auxadc_active;
57
58         if (ena) {
59                 ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
60                                       WM831X_AUX_ENA, WM831X_AUX_ENA);
61                 if (ret != 0) {
62                         dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n",
63                                 ret);
64                         goto out;
65                 }
66         }
67
68         /* Enable the conversion if not already running */
69         if (!(wm831x->auxadc_active & (1 << input))) {
70                 ret = wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
71                                       1 << input, 1 << input);
72                 if (ret != 0) {
73                         dev_err(wm831x->dev,
74                                 "Failed to set AUXADC source: %d\n", ret);
75                         goto out;
76                 }
77
78                 wm831x->auxadc_active |= 1 << input;
79         }
80
81         /* We convert at the fastest rate possible */
82         if (ena) {
83                 ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
84                                       WM831X_AUX_CVT_ENA |
85                                       WM831X_AUX_RATE_MASK,
86                                       WM831X_AUX_CVT_ENA |
87                                       WM831X_AUX_RATE_MASK);
88                 if (ret != 0) {
89                         dev_err(wm831x->dev, "Failed to start AUXADC: %d\n",
90                                 ret);
91                         goto out;
92                 }
93         }
94
95         mutex_unlock(&wm831x->auxadc_lock);
96
97         /* Wait for an interrupt */
98         wait_for_completion_timeout(&req->done, msecs_to_jiffies(500));
99
100         mutex_lock(&wm831x->auxadc_lock);
101
102         list_del(&req->list);
103         ret = req->val;
104
105 out:
106         mutex_unlock(&wm831x->auxadc_lock);
107
108         kfree(req);
109
110         return ret;
111 }
112
113 static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
114 {
115         struct wm831x *wm831x = irq_data;
116         struct wm831x_auxadc_req *req;
117         int ret, input, val;
118
119         ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
120         if (ret < 0) {
121                 dev_err(wm831x->dev,
122                         "Failed to read AUXADC data: %d\n", ret);
123                 return IRQ_NONE;
124         }
125
126         input = ((ret & WM831X_AUX_DATA_SRC_MASK)
127                  >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
128
129         if (input == 14)
130                 input = WM831X_AUX_CAL;
131
132         val = ret & WM831X_AUX_DATA_MASK;
133
134         mutex_lock(&wm831x->auxadc_lock);
135
136         /* Disable this conversion, we're about to complete all users */
137         wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
138                         1 << input, 0);
139         wm831x->auxadc_active &= ~(1 << input);
140
141         /* Turn off the entire convertor if idle */
142         if (!wm831x->auxadc_active)
143                 wm831x_reg_write(wm831x, WM831X_AUXADC_CONTROL, 0);
144
145         /* Wake up any threads waiting for this request */
146         list_for_each_entry(req, &wm831x->auxadc_pending, list) {
147                 if (req->input == input) {
148                         req->val = val;
149                         complete(&req->done);
150                 }
151         }
152
153         mutex_unlock(&wm831x->auxadc_lock);
154
155         return IRQ_HANDLED;
156 }
157
158 static int wm831x_auxadc_read_polled(struct wm831x *wm831x,
159                                      enum wm831x_auxadc input)
160 {
161         int ret, src, timeout;
162
163         mutex_lock(&wm831x->auxadc_lock);
164
165         ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
166                               WM831X_AUX_ENA, WM831X_AUX_ENA);
167         if (ret < 0) {
168                 dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n", ret);
169                 goto out;
170         }
171
172         /* We force a single source at present */
173         src = input;
174         ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
175                                1 << src);
176         if (ret < 0) {
177                 dev_err(wm831x->dev, "Failed to set AUXADC source: %d\n", ret);
178                 goto out;
179         }
180
181         ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
182                               WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
183         if (ret < 0) {
184                 dev_err(wm831x->dev, "Failed to start AUXADC: %d\n", ret);
185                 goto disable;
186         }
187
188         /* If we're not using interrupts then poll the
189          * interrupt status register */
190         timeout = 5;
191         while (timeout) {
192                 msleep(1);
193
194                 ret = wm831x_reg_read(wm831x,
195                                       WM831X_INTERRUPT_STATUS_1);
196                 if (ret < 0) {
197                         dev_err(wm831x->dev,
198                                 "ISR 1 read failed: %d\n", ret);
199                         goto disable;
200                 }
201
202                 /* Did it complete? */
203                 if (ret & WM831X_AUXADC_DATA_EINT) {
204                         wm831x_reg_write(wm831x,
205                                          WM831X_INTERRUPT_STATUS_1,
206                                          WM831X_AUXADC_DATA_EINT);
207                         break;
208                 } else {
209                         dev_err(wm831x->dev,
210                                 "AUXADC conversion timeout\n");
211                         ret = -EBUSY;
212                         goto disable;
213                 }
214         }
215
216         ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
217         if (ret < 0) {
218                 dev_err(wm831x->dev,
219                         "Failed to read AUXADC data: %d\n", ret);
220                 goto disable;
221         }
222
223         src = ((ret & WM831X_AUX_DATA_SRC_MASK)
224                >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
225
226         if (src == 14)
227                 src = WM831X_AUX_CAL;
228
229         if (src != input) {
230                 dev_err(wm831x->dev, "Data from source %d not %d\n",
231                         src, input);
232                 ret = -EINVAL;
233         } else {
234                 ret &= WM831X_AUX_DATA_MASK;
235         }
236
237 disable:
238         wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
239 out:
240         mutex_unlock(&wm831x->auxadc_lock);
241         return ret;
242 }
243
244 /**
245  * wm831x_auxadc_read: Read a value from the WM831x AUXADC
246  *
247  * @wm831x: Device to read from.
248  * @input: AUXADC input to read.
249  */
250 int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
251 {
252         return wm831x->auxadc_read(wm831x, input);
253 }
254 EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
255
256 /**
257  * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
258  *
259  * @wm831x: Device to read from.
260  * @input: AUXADC input to read.
261  */
262 int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
263 {
264         int ret;
265
266         ret = wm831x_auxadc_read(wm831x, input);
267         if (ret < 0)
268                 return ret;
269
270         ret *= 1465;
271
272         return ret;
273 }
274 EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
275
276 void wm831x_auxadc_init(struct wm831x *wm831x)
277 {
278         int ret;
279
280         mutex_init(&wm831x->auxadc_lock);
281         INIT_LIST_HEAD(&wm831x->auxadc_pending);
282
283         if (wm831x->irq && wm831x->irq_base) {
284                 wm831x->auxadc_read = wm831x_auxadc_read_irq;
285
286                 ret = request_threaded_irq(wm831x->irq_base +
287                                            WM831X_IRQ_AUXADC_DATA,
288                                            NULL, wm831x_auxadc_irq, 0,
289                                            "auxadc", wm831x);
290                 if (ret < 0) {
291                         dev_err(wm831x->dev, "AUXADC IRQ request failed: %d\n",
292                                 ret);
293                         wm831x->auxadc_read = NULL;
294                 }
295         }
296
297         if (!wm831x->auxadc_read)
298                 wm831x->auxadc_read = wm831x_auxadc_read_polled;
299 }