1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Driver for an envelope detector using a DAC and a comparator
4 *
5 * Copyright (C) 2016 Axentia Technologies AB
6 *
7 * Author: Peter Rosin <peda@axentia.se>
8 */
9
10/*
11 * The DAC is used to find the peak level of an alternating voltage input
12 * signal by a binary search using the output of a comparator wired to
13 * an interrupt pin. Like so:
14 *                           _
15 *                          | \
16 *     input +------>-------|+ \
17 *                          |   \
18 *            .-------.     |    }---.
19 *            |       |     |   /    |
20 *            |    dac|-->--|- /     |
21 *            |       |     |_/      |
22 *            |       |              |
23 *            |       |              |
24 *            |    irq|------<-------'
25 *            |       |
26 *            '-------'
27 */
28
29#include <linux/completion.h>
30#include <linux/device.h>
31#include <linux/err.h>
32#include <linux/kernel.h>
33#include <linux/module.h>
34#include <linux/mutex.h>
35#include <linux/iio/consumer.h>
36#include <linux/iio/iio.h>
37#include <linux/iio/sysfs.h>
38#include <linux/interrupt.h>
39#include <linux/irq.h>
40#include <linux/of.h>
41#include <linux/of_device.h>
42#include <linux/platform_device.h>
43#include <linux/spinlock.h>
44#include <linux/workqueue.h>
45
46struct envelope {
47	spinlock_t comp_lock; /* protects comp */
48	int comp;
49
50	struct mutex read_lock; /* protects everything else */
51
52	int comp_irq;
53	u32 comp_irq_trigger;
54	u32 comp_irq_trigger_inv;
55
56	struct iio_channel *dac;
57	struct delayed_work comp_timeout;
58
59	unsigned int comp_interval;
60	bool invert;
61	u32 dac_max;
62
63	int high;
64	int level;
65	int low;
66
67	struct completion done;
68};
69
70/*
71 * The envelope_detector_comp_latch function works together with the compare
72 * interrupt service routine below (envelope_detector_comp_isr) as a latch
73 * (one-bit memory) for if the interrupt has triggered since last calling
74 * this function.
75 * The ..._comp_isr function disables the interrupt so that the cpu does not
76 * need to service a possible interrupt flood from the comparator when no-one
77 * cares anyway, and this ..._comp_latch function reenables them again if
78 * needed.
79 */
80static int envelope_detector_comp_latch(struct envelope *env)
81{
82	int comp;
83
84	spin_lock_irq(&env->comp_lock);
85	comp = env->comp;
86	env->comp = 0;
87	spin_unlock_irq(&env->comp_lock);
88
89	if (!comp)
90		return 0;
91
92	/*
93	 * The irq was disabled, and is reenabled just now.
94	 * But there might have been a pending irq that
95	 * happened while the irq was disabled that fires
96	 * just as the irq is reenabled. That is not what
97	 * is desired.
98	 */
99	enable_irq(env->comp_irq);
100
101	/* So, synchronize this possibly pending irq... */
102	synchronize_irq(env->comp_irq);
103
104	/* ...and redo the whole dance. */
105	spin_lock_irq(&env->comp_lock);
106	comp = env->comp;
107	env->comp = 0;
108	spin_unlock_irq(&env->comp_lock);
109
110	if (comp)
111		enable_irq(env->comp_irq);
112
113	return 1;
114}
115
116static irqreturn_t envelope_detector_comp_isr(int irq, void *ctx)
117{
118	struct envelope *env = ctx;
119
120	spin_lock(&env->comp_lock);
121	env->comp = 1;
122	disable_irq_nosync(env->comp_irq);
123	spin_unlock(&env->comp_lock);
124
125	return IRQ_HANDLED;
126}
127
128static void envelope_detector_setup_compare(struct envelope *env)
129{
130	int ret;
131
132	/*
133	 * Do a binary search for the peak input level, and stop
134	 * when that level is "trapped" between two adjacent DAC
135	 * values.
136	 * When invert is active, use the midpoint floor so that
137	 * env->level ends up as env->low when the termination
138	 * criteria below is fulfilled, and use the midpoint
139	 * ceiling when invert is not active so that env->level
140	 * ends up as env->high in that case.
141	 */
142	env->level = (env->high + env->low + !env->invert) / 2;
143
144	if (env->high == env->low + 1) {
145		complete(&env->done);
146		return;
147	}
148
149	/* Set a "safe" DAC level (if there is such a thing)... */
150	ret = iio_write_channel_raw(env->dac, env->invert ? 0 : env->dac_max);
151	if (ret < 0)
152		goto err;
153
154	/* ...clear the comparison result... */
155	envelope_detector_comp_latch(env);
156
157	/* ...set the real DAC level... */
158	ret = iio_write_channel_raw(env->dac, env->level);
159	if (ret < 0)
160		goto err;
161
162	/* ...and wait for a bit to see if the latch catches anything. */
163	schedule_delayed_work(&env->comp_timeout,
164			      msecs_to_jiffies(env->comp_interval));
165	return;
166
167err:
168	env->level = ret;
169	complete(&env->done);
170}
171
172static void envelope_detector_timeout(struct work_struct *work)
173{
174	struct envelope *env = container_of(work, struct envelope,
175					    comp_timeout.work);
176
177	/* Adjust low/high depending on the latch content... */
178	if (!envelope_detector_comp_latch(env) ^ !env->invert)
179		env->low = env->level;
180	else
181		env->high = env->level;
182
183	/* ...and continue the search. */
184	envelope_detector_setup_compare(env);
185}
186
187static int envelope_detector_read_raw(struct iio_dev *indio_dev,
188				      struct iio_chan_spec const *chan,
189				      int *val, int *val2, long mask)
190{
191	struct envelope *env = iio_priv(indio_dev);
192	int ret;
193
194	switch (mask) {
195	case IIO_CHAN_INFO_RAW:
196		/*
197		 * When invert is active, start with high=max+1 and low=0
198		 * since we will end up with the low value when the
199		 * termination criteria is fulfilled (rounding down). And
200		 * start with high=max and low=-1 when invert is not active
201		 * since we will end up with the high value in that case.
202		 * This ensures that the returned value in both cases are
203		 * in the same range as the DAC and is a value that has not
204		 * triggered the comparator.
205		 */
206		mutex_lock(&env->read_lock);
207		env->high = env->dac_max + env->invert;
208		env->low = -1 + env->invert;
209		envelope_detector_setup_compare(env);
210		wait_for_completion(&env->done);
211		if (env->level < 0) {
212			ret = env->level;
213			goto err_unlock;
214		}
215		*val = env->invert ? env->dac_max - env->level : env->level;
216		mutex_unlock(&env->read_lock);
217
218		return IIO_VAL_INT;
219
220	case IIO_CHAN_INFO_SCALE:
221		return iio_read_channel_scale(env->dac, val, val2);
222	}
223
224	return -EINVAL;
225
226err_unlock:
227	mutex_unlock(&env->read_lock);
228	return ret;
229}
230
231static ssize_t envelope_show_invert(struct iio_dev *indio_dev,
232				    uintptr_t private,
233				    struct iio_chan_spec const *ch, char *buf)
234{
235	struct envelope *env = iio_priv(indio_dev);
236
237	return sprintf(buf, "%u\n", env->invert);
238}
239
240static ssize_t envelope_store_invert(struct iio_dev *indio_dev,
241				     uintptr_t private,
242				     struct iio_chan_spec const *ch,
243				     const char *buf, size_t len)
244{
245	struct envelope *env = iio_priv(indio_dev);
246	unsigned long invert;
247	int ret;
248	u32 trigger;
249
250	ret = kstrtoul(buf, 0, &invert);
251	if (ret < 0)
252		return ret;
253	if (invert > 1)
254		return -EINVAL;
255
256	trigger = invert ? env->comp_irq_trigger_inv : env->comp_irq_trigger;
257
258	mutex_lock(&env->read_lock);
259	if (invert != env->invert)
260		ret = irq_set_irq_type(env->comp_irq, trigger);
261	if (!ret) {
262		env->invert = invert;
263		ret = len;
264	}
265	mutex_unlock(&env->read_lock);
266
267	return ret;
268}
269
270static ssize_t envelope_show_comp_interval(struct iio_dev *indio_dev,
271					   uintptr_t private,
272					   struct iio_chan_spec const *ch,
273					   char *buf)
274{
275	struct envelope *env = iio_priv(indio_dev);
276
277	return sprintf(buf, "%u\n", env->comp_interval);
278}
279
280static ssize_t envelope_store_comp_interval(struct iio_dev *indio_dev,
281					    uintptr_t private,
282					    struct iio_chan_spec const *ch,
283					    const char *buf, size_t len)
284{
285	struct envelope *env = iio_priv(indio_dev);
286	unsigned long interval;
287	int ret;
288
289	ret = kstrtoul(buf, 0, &interval);
290	if (ret < 0)
291		return ret;
292	if (interval > 1000)
293		return -EINVAL;
294
295	mutex_lock(&env->read_lock);
296	env->comp_interval = interval;
297	mutex_unlock(&env->read_lock);
298
299	return len;
300}
301
302static const struct iio_chan_spec_ext_info envelope_detector_ext_info[] = {
303	{ .name = "invert",
304	  .read = envelope_show_invert,
305	  .write = envelope_store_invert, },
306	{ .name = "compare_interval",
307	  .read = envelope_show_comp_interval,
308	  .write = envelope_store_comp_interval, },
309	{ /* sentinel */ }
310};
311
312static const struct iio_chan_spec envelope_detector_iio_channel = {
313	.type = IIO_ALTVOLTAGE,
314	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
315			    | BIT(IIO_CHAN_INFO_SCALE),
316	.ext_info = envelope_detector_ext_info,
317	.indexed = 1,
318};
319
320static const struct iio_info envelope_detector_info = {
321	.read_raw = &envelope_detector_read_raw,
322};
323
324static int envelope_detector_probe(struct platform_device *pdev)
325{
326	struct device *dev = &pdev->dev;
327	struct iio_dev *indio_dev;
328	struct envelope *env;
329	enum iio_chan_type type;
330	int ret;
331
332	indio_dev = devm_iio_device_alloc(dev, sizeof(*env));
333	if (!indio_dev)
334		return -ENOMEM;
335
336	platform_set_drvdata(pdev, indio_dev);
337	env = iio_priv(indio_dev);
338	env->comp_interval = 50; /* some sensible default? */
339
340	spin_lock_init(&env->comp_lock);
341	mutex_init(&env->read_lock);
342	init_completion(&env->done);
343	INIT_DELAYED_WORK(&env->comp_timeout, envelope_detector_timeout);
344
345	indio_dev->name = dev_name(dev);
346	indio_dev->info = &envelope_detector_info;
347	indio_dev->channels = &envelope_detector_iio_channel;
348	indio_dev->num_channels = 1;
349
350	env->dac = devm_iio_channel_get(dev, "dac");
351	if (IS_ERR(env->dac))
352		return dev_err_probe(dev, PTR_ERR(env->dac),
353				     "failed to get dac input channel\n");
354
355	env->comp_irq = platform_get_irq_byname(pdev, "comp");
356	if (env->comp_irq < 0)
357		return env->comp_irq;
358
359	ret = devm_request_irq(dev, env->comp_irq, envelope_detector_comp_isr,
360			       0, "envelope-detector", env);
361	if (ret)
362		return dev_err_probe(dev, ret, "failed to request interrupt\n");
363
364	env->comp_irq_trigger = irq_get_trigger_type(env->comp_irq);
365	if (env->comp_irq_trigger & IRQF_TRIGGER_RISING)
366		env->comp_irq_trigger_inv |= IRQF_TRIGGER_FALLING;
367	if (env->comp_irq_trigger & IRQF_TRIGGER_FALLING)
368		env->comp_irq_trigger_inv |= IRQF_TRIGGER_RISING;
369	if (env->comp_irq_trigger & IRQF_TRIGGER_HIGH)
370		env->comp_irq_trigger_inv |= IRQF_TRIGGER_LOW;
371	if (env->comp_irq_trigger & IRQF_TRIGGER_LOW)
372		env->comp_irq_trigger_inv |= IRQF_TRIGGER_HIGH;
373
374	ret = iio_get_channel_type(env->dac, &type);
375	if (ret < 0)
376		return ret;
377
378	if (type != IIO_VOLTAGE) {
379		dev_err(dev, "dac is of the wrong type\n");
380		return -EINVAL;
381	}
382
383	ret = iio_read_max_channel_raw(env->dac, &env->dac_max);
384	if (ret < 0) {
385		dev_err(dev, "dac does not indicate its raw maximum value\n");
386		return ret;
387	}
388
389	return devm_iio_device_register(dev, indio_dev);
390}
391
392static const struct of_device_id envelope_detector_match[] = {
393	{ .compatible = "axentia,tse850-envelope-detector", },
394	{ /* sentinel */ }
395};
396MODULE_DEVICE_TABLE(of, envelope_detector_match);
397
398static struct platform_driver envelope_detector_driver = {
399	.probe = envelope_detector_probe,
400	.driver = {
401		.name = "iio-envelope-detector",
402		.of_match_table = envelope_detector_match,
403	},
404};
405module_platform_driver(envelope_detector_driver);
406
407MODULE_DESCRIPTION("Envelope detector using a DAC and a comparator");
408MODULE_AUTHOR("Peter Rosin <peda@axentia.se>");
409MODULE_LICENSE("GPL v2");
410