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
wm831x_auxadc_read_irq(struct wm831x * wm831x,enum wm831x_auxadc input)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 ret = req->val;
102
103 out:
104 list_del(&req->list);
105 mutex_unlock(&wm831x->auxadc_lock);
106
107 kfree(req);
108
109 return ret;
110 }
111
wm831x_auxadc_irq(int irq,void * irq_data)112 static irqreturn_t wm831x_auxadc_irq(int irq, void *irq_data)
113 {
114 struct wm831x *wm831x = irq_data;
115 struct wm831x_auxadc_req *req;
116 int ret, input, val;
117
118 ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
119 if (ret < 0) {
120 dev_err(wm831x->dev,
121 "Failed to read AUXADC data: %d\n", ret);
122 return IRQ_NONE;
123 }
124
125 input = ((ret & WM831X_AUX_DATA_SRC_MASK)
126 >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
127
128 if (input == 14)
129 input = WM831X_AUX_CAL;
130
131 val = ret & WM831X_AUX_DATA_MASK;
132
133 mutex_lock(&wm831x->auxadc_lock);
134
135 /* Disable this conversion, we're about to complete all users */
136 wm831x_set_bits(wm831x, WM831X_AUXADC_SOURCE,
137 1 << input, 0);
138 wm831x->auxadc_active &= ~(1 << input);
139
140 /* Turn off the entire convertor if idle */
141 if (!wm831x->auxadc_active)
142 wm831x_reg_write(wm831x, WM831X_AUXADC_CONTROL, 0);
143
144 /* Wake up any threads waiting for this request */
145 list_for_each_entry(req, &wm831x->auxadc_pending, list) {
146 if (req->input == input) {
147 req->val = val;
148 complete(&req->done);
149 }
150 }
151
152 mutex_unlock(&wm831x->auxadc_lock);
153
154 return IRQ_HANDLED;
155 }
156
wm831x_auxadc_read_polled(struct wm831x * wm831x,enum wm831x_auxadc input)157 static int wm831x_auxadc_read_polled(struct wm831x *wm831x,
158 enum wm831x_auxadc input)
159 {
160 int ret, src, timeout;
161
162 mutex_lock(&wm831x->auxadc_lock);
163
164 ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
165 WM831X_AUX_ENA, WM831X_AUX_ENA);
166 if (ret < 0) {
167 dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n", ret);
168 goto out;
169 }
170
171 /* We force a single source at present */
172 src = input;
173 ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
174 1 << src);
175 if (ret < 0) {
176 dev_err(wm831x->dev, "Failed to set AUXADC source: %d\n", ret);
177 goto out;
178 }
179
180 ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
181 WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
182 if (ret < 0) {
183 dev_err(wm831x->dev, "Failed to start AUXADC: %d\n", ret);
184 goto disable;
185 }
186
187 /* If we're not using interrupts then poll the
188 * interrupt status register */
189 timeout = 5;
190 while (timeout) {
191 msleep(1);
192
193 ret = wm831x_reg_read(wm831x,
194 WM831X_INTERRUPT_STATUS_1);
195 if (ret < 0) {
196 dev_err(wm831x->dev,
197 "ISR 1 read failed: %d\n", ret);
198 goto disable;
199 }
200
201 /* Did it complete? */
202 if (ret & WM831X_AUXADC_DATA_EINT) {
203 wm831x_reg_write(wm831x,
204 WM831X_INTERRUPT_STATUS_1,
205 WM831X_AUXADC_DATA_EINT);
206 break;
207 } else {
208 dev_err(wm831x->dev,
209 "AUXADC conversion timeout\n");
210 ret = -EBUSY;
211 goto disable;
212 }
213 }
214
215 ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
216 if (ret < 0) {
217 dev_err(wm831x->dev,
218 "Failed to read AUXADC data: %d\n", ret);
219 goto disable;
220 }
221
222 src = ((ret & WM831X_AUX_DATA_SRC_MASK)
223 >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
224
225 if (src == 14)
226 src = WM831X_AUX_CAL;
227
228 if (src != input) {
229 dev_err(wm831x->dev, "Data from source %d not %d\n",
230 src, input);
231 ret = -EINVAL;
232 } else {
233 ret &= WM831X_AUX_DATA_MASK;
234 }
235
236 disable:
237 wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
238 out:
239 mutex_unlock(&wm831x->auxadc_lock);
240 return ret;
241 }
242
243 /**
244 * wm831x_auxadc_read: Read a value from the WM831x AUXADC
245 *
246 * @wm831x: Device to read from.
247 * @input: AUXADC input to read.
248 */
wm831x_auxadc_read(struct wm831x * wm831x,enum wm831x_auxadc input)249 int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
250 {
251 return wm831x->auxadc_read(wm831x, input);
252 }
253 EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
254
255 /**
256 * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
257 *
258 * @wm831x: Device to read from.
259 * @input: AUXADC input to read.
260 */
wm831x_auxadc_read_uv(struct wm831x * wm831x,enum wm831x_auxadc input)261 int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
262 {
263 int ret;
264
265 ret = wm831x_auxadc_read(wm831x, input);
266 if (ret < 0)
267 return ret;
268
269 ret *= 1465;
270
271 return ret;
272 }
273 EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
274
wm831x_auxadc_init(struct wm831x * wm831x)275 void wm831x_auxadc_init(struct wm831x *wm831x)
276 {
277 int ret;
278
279 mutex_init(&wm831x->auxadc_lock);
280 INIT_LIST_HEAD(&wm831x->auxadc_pending);
281
282 if (wm831x->irq) {
283 wm831x->auxadc_read = wm831x_auxadc_read_irq;
284
285 ret = request_threaded_irq(wm831x_irq(wm831x,
286 WM831X_IRQ_AUXADC_DATA),
287 NULL, wm831x_auxadc_irq,
288 IRQF_ONESHOT,
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 }
300