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