1 // SPDX-License-Identifier: GPL-2.0
3 * AD7091RX Analog to Digital converter driver
5 * Copyright 2014-2019 Analog Devices Inc.
8 #include <linux/bitops.h>
9 #include <linux/bitfield.h>
10 #include <linux/iio/events.h>
11 #include <linux/iio/iio.h>
12 #include <linux/interrupt.h>
13 #include <linux/module.h>
14 #include <linux/regmap.h>
15 #include <linux/regulator/consumer.h>
17 #include "ad7091r-base.h"
19 #define AD7091R_REG_RESULT 0
20 #define AD7091R_REG_CHANNEL 1
21 #define AD7091R_REG_CONF 2
22 #define AD7091R_REG_ALERT 3
23 #define AD7091R_REG_CH_LOW_LIMIT(ch) ((ch) * 3 + 4)
24 #define AD7091R_REG_CH_HIGH_LIMIT(ch) ((ch) * 3 + 5)
25 #define AD7091R_REG_CH_HYSTERESIS(ch) ((ch) * 3 + 6)
27 /* AD7091R_REG_RESULT */
28 #define AD7091R_REG_RESULT_CH_ID(x) (((x) >> 13) & 0x3)
29 #define AD7091R_REG_RESULT_CONV_RESULT(x) ((x) & 0xfff)
31 /* AD7091R_REG_CONF */
32 #define AD7091R_REG_CONF_ALERT_EN BIT(4)
33 #define AD7091R_REG_CONF_AUTO BIT(8)
34 #define AD7091R_REG_CONF_CMD BIT(10)
36 #define AD7091R_REG_CONF_MODE_MASK \
37 (AD7091R_REG_CONF_AUTO | AD7091R_REG_CONF_CMD)
42 AD7091R_MODE_AUTOCYCLE,
45 struct ad7091r_state {
48 struct regulator *vref;
49 const struct ad7091r_chip_info *chip_info;
50 enum ad7091r_mode mode;
51 struct mutex lock; /*lock to prevent concurent reads */
54 const struct iio_event_spec ad7091r_events[] = {
56 .type = IIO_EV_TYPE_THRESH,
57 .dir = IIO_EV_DIR_RISING,
58 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
59 BIT(IIO_EV_INFO_ENABLE),
62 .type = IIO_EV_TYPE_THRESH,
63 .dir = IIO_EV_DIR_FALLING,
64 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
65 BIT(IIO_EV_INFO_ENABLE),
68 .type = IIO_EV_TYPE_THRESH,
69 .dir = IIO_EV_DIR_EITHER,
70 .mask_separate = BIT(IIO_EV_INFO_HYSTERESIS),
73 EXPORT_SYMBOL_NS_GPL(ad7091r_events, IIO_AD7091R);
75 static int ad7091r_set_mode(struct ad7091r_state *st, enum ad7091r_mode mode)
80 case AD7091R_MODE_SAMPLE:
83 case AD7091R_MODE_COMMAND:
84 conf = AD7091R_REG_CONF_CMD;
86 case AD7091R_MODE_AUTOCYCLE:
87 conf = AD7091R_REG_CONF_AUTO;
93 ret = regmap_update_bits(st->map, AD7091R_REG_CONF,
94 AD7091R_REG_CONF_MODE_MASK, conf);
103 static int ad7091r_set_channel(struct ad7091r_state *st, unsigned int channel)
108 /* AD7091R_REG_CHANNEL specified which channels to be converted */
109 ret = regmap_write(st->map, AD7091R_REG_CHANNEL,
110 BIT(channel) | (BIT(channel) << 8));
115 * There is a latency of one conversion before the channel conversion
116 * sequence is updated
118 return regmap_read(st->map, AD7091R_REG_RESULT, &dummy);
121 static int ad7091r_read_one(struct iio_dev *iio_dev,
122 unsigned int channel, unsigned int *read_val)
124 struct ad7091r_state *st = iio_priv(iio_dev);
128 ret = ad7091r_set_channel(st, channel);
132 ret = regmap_read(st->map, AD7091R_REG_RESULT, &val);
136 if (AD7091R_REG_RESULT_CH_ID(val) != channel)
139 *read_val = AD7091R_REG_RESULT_CONV_RESULT(val);
144 static int ad7091r_read_raw(struct iio_dev *iio_dev,
145 struct iio_chan_spec const *chan,
146 int *val, int *val2, long m)
148 struct ad7091r_state *st = iio_priv(iio_dev);
149 unsigned int read_val;
152 mutex_lock(&st->lock);
155 case IIO_CHAN_INFO_RAW:
156 if (st->mode != AD7091R_MODE_COMMAND) {
161 ret = ad7091r_read_one(iio_dev, chan->channel, &read_val);
169 case IIO_CHAN_INFO_SCALE:
171 ret = regulator_get_voltage(st->vref);
177 *val = st->chip_info->vref_mV;
180 *val2 = chan->scan_type.realbits;
181 ret = IIO_VAL_FRACTIONAL_LOG2;
190 mutex_unlock(&st->lock);
194 static int ad7091r_read_event_config(struct iio_dev *indio_dev,
195 const struct iio_chan_spec *chan,
196 enum iio_event_type type,
197 enum iio_event_direction dir)
199 struct ad7091r_state *st = iio_priv(indio_dev);
203 case IIO_EV_DIR_RISING:
204 ret = regmap_read(st->map,
205 AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
209 return val != AD7091R_HIGH_LIMIT;
210 case IIO_EV_DIR_FALLING:
211 ret = regmap_read(st->map,
212 AD7091R_REG_CH_LOW_LIMIT(chan->channel),
216 return val != AD7091R_LOW_LIMIT;
222 static int ad7091r_write_event_config(struct iio_dev *indio_dev,
223 const struct iio_chan_spec *chan,
224 enum iio_event_type type,
225 enum iio_event_direction dir, int state)
227 struct ad7091r_state *st = iio_priv(indio_dev);
230 return regmap_set_bits(st->map, AD7091R_REG_CONF,
231 AD7091R_REG_CONF_ALERT_EN);
234 * Set thresholds either to 0 or to 2^12 - 1 as appropriate to
235 * prevent alerts and thus disable event generation.
238 case IIO_EV_DIR_RISING:
239 return regmap_write(st->map,
240 AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
242 case IIO_EV_DIR_FALLING:
243 return regmap_write(st->map,
244 AD7091R_REG_CH_LOW_LIMIT(chan->channel),
252 static int ad7091r_read_event_value(struct iio_dev *indio_dev,
253 const struct iio_chan_spec *chan,
254 enum iio_event_type type,
255 enum iio_event_direction dir,
256 enum iio_event_info info, int *val, int *val2)
258 struct ad7091r_state *st = iio_priv(indio_dev);
262 case IIO_EV_INFO_VALUE:
264 case IIO_EV_DIR_RISING:
265 ret = regmap_read(st->map,
266 AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
271 case IIO_EV_DIR_FALLING:
272 ret = regmap_read(st->map,
273 AD7091R_REG_CH_LOW_LIMIT(chan->channel),
281 case IIO_EV_INFO_HYSTERESIS:
282 ret = regmap_read(st->map,
283 AD7091R_REG_CH_HYSTERESIS(chan->channel),
293 static int ad7091r_write_event_value(struct iio_dev *indio_dev,
294 const struct iio_chan_spec *chan,
295 enum iio_event_type type,
296 enum iio_event_direction dir,
297 enum iio_event_info info, int val, int val2)
299 struct ad7091r_state *st = iio_priv(indio_dev);
302 case IIO_EV_INFO_VALUE:
304 case IIO_EV_DIR_RISING:
305 return regmap_write(st->map,
306 AD7091R_REG_CH_HIGH_LIMIT(chan->channel),
308 case IIO_EV_DIR_FALLING:
309 return regmap_write(st->map,
310 AD7091R_REG_CH_LOW_LIMIT(chan->channel),
315 case IIO_EV_INFO_HYSTERESIS:
316 return regmap_write(st->map,
317 AD7091R_REG_CH_HYSTERESIS(chan->channel),
324 static const struct iio_info ad7091r_info = {
325 .read_raw = ad7091r_read_raw,
326 .read_event_config = &ad7091r_read_event_config,
327 .write_event_config = &ad7091r_write_event_config,
328 .read_event_value = &ad7091r_read_event_value,
329 .write_event_value = &ad7091r_write_event_value,
332 static irqreturn_t ad7091r_event_handler(int irq, void *private)
334 struct iio_dev *iio_dev = private;
335 struct ad7091r_state *st = iio_priv(iio_dev);
336 unsigned int i, read_val;
338 s64 timestamp = iio_get_time_ns(iio_dev);
340 ret = regmap_read(st->map, AD7091R_REG_ALERT, &read_val);
344 for (i = 0; i < st->chip_info->num_channels; i++) {
345 if (read_val & BIT(i * 2))
346 iio_push_event(iio_dev,
347 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i,
349 IIO_EV_DIR_RISING), timestamp);
350 if (read_val & BIT(i * 2 + 1))
351 iio_push_event(iio_dev,
352 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i,
354 IIO_EV_DIR_FALLING), timestamp);
360 static void ad7091r_remove(void *data)
362 struct ad7091r_state *st = data;
364 regulator_disable(st->vref);
367 int ad7091r_probe(struct device *dev, const char *name,
368 const struct ad7091r_chip_info *chip_info,
369 struct regmap *map, int irq)
371 struct iio_dev *iio_dev;
372 struct ad7091r_state *st;
375 iio_dev = devm_iio_device_alloc(dev, sizeof(*st));
379 st = iio_priv(iio_dev);
381 st->chip_info = chip_info;
384 iio_dev->name = name;
385 iio_dev->info = &ad7091r_info;
386 iio_dev->modes = INDIO_DIRECT_MODE;
388 iio_dev->num_channels = chip_info->num_channels;
389 iio_dev->channels = chip_info->channels;
392 ret = regmap_update_bits(st->map, AD7091R_REG_CONF,
393 AD7091R_REG_CONF_ALERT_EN, BIT(4));
397 ret = devm_request_threaded_irq(dev, irq, NULL,
398 ad7091r_event_handler,
399 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name, iio_dev);
404 st->vref = devm_regulator_get_optional(dev, "vref");
405 if (IS_ERR(st->vref)) {
406 if (PTR_ERR(st->vref) == -EPROBE_DEFER)
407 return -EPROBE_DEFER;
410 /* Enable internal vref */
411 ret = regmap_set_bits(st->map, AD7091R_REG_CONF,
412 AD7091R_REG_CONF_INT_VREF);
414 return dev_err_probe(st->dev, ret,
415 "Error on enable internal reference\n");
417 ret = regulator_enable(st->vref);
420 ret = devm_add_action_or_reset(dev, ad7091r_remove, st);
425 /* Use command mode by default to convert only desired channels*/
426 ret = ad7091r_set_mode(st, AD7091R_MODE_COMMAND);
430 return devm_iio_device_register(dev, iio_dev);
432 EXPORT_SYMBOL_NS_GPL(ad7091r_probe, IIO_AD7091R);
434 static bool ad7091r_writeable_reg(struct device *dev, unsigned int reg)
437 case AD7091R_REG_RESULT:
438 case AD7091R_REG_ALERT:
445 static bool ad7091r_volatile_reg(struct device *dev, unsigned int reg)
448 case AD7091R_REG_RESULT:
449 case AD7091R_REG_ALERT:
456 const struct regmap_config ad7091r_regmap_config = {
459 .writeable_reg = ad7091r_writeable_reg,
460 .volatile_reg = ad7091r_volatile_reg,
462 EXPORT_SYMBOL_NS_GPL(ad7091r_regmap_config, IIO_AD7091R);
464 MODULE_AUTHOR("Beniamin Bia <beniamin.bia@analog.com>");
465 MODULE_DESCRIPTION("Analog Devices AD7091Rx multi-channel converters");
466 MODULE_LICENSE("GPL v2");