1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * iio/adc/ad799x.c
4 * Copyright (C) 2010-2011 Michael Hennerich, Analog Devices Inc.
5 *
6 * based on iio/adc/max1363
7 * Copyright (C) 2008-2010 Jonathan Cameron
8 *
9 * based on linux/drivers/i2c/chips/max123x
10 * Copyright (C) 2002-2004 Stefan Eletzhofer
11 *
12 * based on linux/drivers/acron/char/pcf8583.c
13 * Copyright (C) 2000 Russell King
14 *
15 * ad799x.c
16 *
17 * Support for ad7991, ad7995, ad7999, ad7992, ad7993, ad7994, ad7997,
18 * ad7998 and similar chips.
19 */
20
21#include <linux/interrupt.h>
22#include <linux/device.h>
23#include <linux/kernel.h>
24#include <linux/sysfs.h>
25#include <linux/i2c.h>
26#include <linux/regulator/consumer.h>
27#include <linux/slab.h>
28#include <linux/types.h>
29#include <linux/err.h>
30#include <linux/module.h>
31#include <linux/mutex.h>
32#include <linux/bitops.h>
33
34#include <linux/iio/iio.h>
35#include <linux/iio/sysfs.h>
36#include <linux/iio/events.h>
37#include <linux/iio/buffer.h>
38#include <linux/iio/trigger_consumer.h>
39#include <linux/iio/triggered_buffer.h>
40
41#define AD799X_CHANNEL_SHIFT 4
42
43/*
44 * AD7991, AD7995 and AD7999 defines
45 */
46
47#define AD7991_REF_SEL 0x08
48#define AD7991_FLTR 0x04
49#define AD7991_BIT_TRIAL_DELAY 0x02
50#define AD7991_SAMPLE_DELAY 0x01
51
52/*
53 * AD7992, AD7993, AD7994, AD7997 and AD7998 defines
54 */
55
56#define AD7998_FLTR BIT(3)
57#define AD7998_ALERT_EN BIT(2)
58#define AD7998_BUSY_ALERT BIT(1)
59#define AD7998_BUSY_ALERT_POL BIT(0)
60
61#define AD7998_CONV_RES_REG 0x0
62#define AD7998_ALERT_STAT_REG 0x1
63#define AD7998_CONF_REG 0x2
64#define AD7998_CYCLE_TMR_REG 0x3
65
66#define AD7998_DATALOW_REG(x) ((x) * 3 + 0x4)
67#define AD7998_DATAHIGH_REG(x) ((x) * 3 + 0x5)
68#define AD7998_HYST_REG(x) ((x) * 3 + 0x6)
69
70#define AD7998_CYC_MASK GENMASK(2, 0)
71#define AD7998_CYC_DIS 0x0
72#define AD7998_CYC_TCONF_32 0x1
73#define AD7998_CYC_TCONF_64 0x2
74#define AD7998_CYC_TCONF_128 0x3
75#define AD7998_CYC_TCONF_256 0x4
76#define AD7998_CYC_TCONF_512 0x5
77#define AD7998_CYC_TCONF_1024 0x6
78#define AD7998_CYC_TCONF_2048 0x7
79
80#define AD7998_ALERT_STAT_CLEAR 0xFF
81
82/*
83 * AD7997 and AD7997 defines
84 */
85
86#define AD7997_8_READ_SINGLE BIT(7)
87#define AD7997_8_READ_SEQUENCE (BIT(6) | BIT(5) | BIT(4))
88
89enum {
90 ad7991,
91 ad7995,
92 ad7999,
93 ad7992,
94 ad7993,
95 ad7994,
96 ad7997,
97 ad7998
98};
99
100/**
101 * struct ad799x_chip_config - chip specific information
102 * @channel: channel specification
103 * @default_config: device default configuration
104 * @info: pointer to iio_info struct
105 */
106struct ad799x_chip_config {
107 const struct iio_chan_spec channel[9];
108 u16 default_config;
109 const struct iio_info *info;
110};
111
112/**
113 * struct ad799x_chip_info - chip specific information
114 * @num_channels: number of channels
115 * @noirq_config: device configuration w/o IRQ
116 * @irq_config: device configuration w/IRQ
117 */
118struct ad799x_chip_info {
119 int num_channels;
120 const struct ad799x_chip_config noirq_config;
121 const struct ad799x_chip_config irq_config;
122};
123
124struct ad799x_state {
125 struct i2c_client *client;
126 const struct ad799x_chip_config *chip_config;
127 struct regulator *reg;
128 struct regulator *vref;
129 /* lock to protect against multiple access to the device */
130 struct mutex lock;
131 unsigned id;
132 u16 config;
133
134 u8 *rx_buf;
135 unsigned int transfer_size;
136};
137
138static int ad799x_write_config(struct ad799x_state *st, u16 val)
139{
140 switch (st->id) {
141 case ad7997:
142 case ad7998:
143 return i2c_smbus_write_word_swapped(client: st->client, AD7998_CONF_REG,
144 value: val);
145 case ad7992:
146 case ad7993:
147 case ad7994:
148 return i2c_smbus_write_byte_data(client: st->client, AD7998_CONF_REG,
149 value: val);
150 default:
151 /* Will be written when doing a conversion */
152 st->config = val;
153 return 0;
154 }
155}
156
157static int ad799x_read_config(struct ad799x_state *st)
158{
159 switch (st->id) {
160 case ad7997:
161 case ad7998:
162 return i2c_smbus_read_word_swapped(client: st->client, AD7998_CONF_REG);
163 case ad7992:
164 case ad7993:
165 case ad7994:
166 return i2c_smbus_read_byte_data(client: st->client, AD7998_CONF_REG);
167 default:
168 /* No readback support */
169 return st->config;
170 }
171}
172
173static int ad799x_update_config(struct ad799x_state *st, u16 config)
174{
175 int ret;
176
177 ret = ad799x_write_config(st, val: config);
178 if (ret < 0)
179 return ret;
180 ret = ad799x_read_config(st);
181 if (ret < 0)
182 return ret;
183 st->config = ret;
184
185 return 0;
186}
187
188static irqreturn_t ad799x_trigger_handler(int irq, void *p)
189{
190 struct iio_poll_func *pf = p;
191 struct iio_dev *indio_dev = pf->indio_dev;
192 struct ad799x_state *st = iio_priv(indio_dev);
193 int b_sent;
194 u8 cmd;
195
196 switch (st->id) {
197 case ad7991:
198 case ad7995:
199 case ad7999:
200 cmd = st->config |
201 (*indio_dev->active_scan_mask << AD799X_CHANNEL_SHIFT);
202 break;
203 case ad7992:
204 case ad7993:
205 case ad7994:
206 cmd = (*indio_dev->active_scan_mask << AD799X_CHANNEL_SHIFT) |
207 AD7998_CONV_RES_REG;
208 break;
209 case ad7997:
210 case ad7998:
211 cmd = AD7997_8_READ_SEQUENCE | AD7998_CONV_RES_REG;
212 break;
213 default:
214 cmd = 0;
215 }
216
217 b_sent = i2c_smbus_read_i2c_block_data(client: st->client,
218 command: cmd, length: st->transfer_size, values: st->rx_buf);
219 if (b_sent < 0)
220 goto out;
221
222 iio_push_to_buffers_with_timestamp(indio_dev, data: st->rx_buf,
223 timestamp: iio_get_time_ns(indio_dev));
224out:
225 iio_trigger_notify_done(trig: indio_dev->trig);
226
227 return IRQ_HANDLED;
228}
229
230static int ad799x_update_scan_mode(struct iio_dev *indio_dev,
231 const unsigned long *scan_mask)
232{
233 struct ad799x_state *st = iio_priv(indio_dev);
234
235 kfree(objp: st->rx_buf);
236 st->rx_buf = kmalloc(size: indio_dev->scan_bytes, GFP_KERNEL);
237 if (!st->rx_buf)
238 return -ENOMEM;
239
240 st->transfer_size = bitmap_weight(src: scan_mask, nbits: indio_dev->masklength) * 2;
241
242 switch (st->id) {
243 case ad7992:
244 case ad7993:
245 case ad7994:
246 case ad7997:
247 case ad7998:
248 st->config &= ~(GENMASK(7, 0) << AD799X_CHANNEL_SHIFT);
249 st->config |= (*scan_mask << AD799X_CHANNEL_SHIFT);
250 return ad799x_write_config(st, val: st->config);
251 default:
252 return 0;
253 }
254}
255
256static int ad799x_scan_direct(struct ad799x_state *st, unsigned ch)
257{
258 u8 cmd;
259
260 switch (st->id) {
261 case ad7991:
262 case ad7995:
263 case ad7999:
264 cmd = st->config | (BIT(ch) << AD799X_CHANNEL_SHIFT);
265 break;
266 case ad7992:
267 case ad7993:
268 case ad7994:
269 cmd = BIT(ch) << AD799X_CHANNEL_SHIFT;
270 break;
271 case ad7997:
272 case ad7998:
273 cmd = (ch << AD799X_CHANNEL_SHIFT) | AD7997_8_READ_SINGLE;
274 break;
275 default:
276 return -EINVAL;
277 }
278
279 return i2c_smbus_read_word_swapped(client: st->client, command: cmd);
280}
281
282static int ad799x_read_raw(struct iio_dev *indio_dev,
283 struct iio_chan_spec const *chan,
284 int *val,
285 int *val2,
286 long m)
287{
288 int ret;
289 struct ad799x_state *st = iio_priv(indio_dev);
290
291 switch (m) {
292 case IIO_CHAN_INFO_RAW:
293 ret = iio_device_claim_direct_mode(indio_dev);
294 if (ret)
295 return ret;
296 mutex_lock(&st->lock);
297 ret = ad799x_scan_direct(st, ch: chan->scan_index);
298 mutex_unlock(lock: &st->lock);
299 iio_device_release_direct_mode(indio_dev);
300
301 if (ret < 0)
302 return ret;
303 *val = (ret >> chan->scan_type.shift) &
304 GENMASK(chan->scan_type.realbits - 1, 0);
305 return IIO_VAL_INT;
306 case IIO_CHAN_INFO_SCALE:
307 if (st->vref)
308 ret = regulator_get_voltage(regulator: st->vref);
309 else
310 ret = regulator_get_voltage(regulator: st->reg);
311
312 if (ret < 0)
313 return ret;
314 *val = ret / 1000;
315 *val2 = chan->scan_type.realbits;
316 return IIO_VAL_FRACTIONAL_LOG2;
317 }
318 return -EINVAL;
319}
320static const unsigned int ad7998_frequencies[] = {
321 [AD7998_CYC_DIS] = 0,
322 [AD7998_CYC_TCONF_32] = 15625,
323 [AD7998_CYC_TCONF_64] = 7812,
324 [AD7998_CYC_TCONF_128] = 3906,
325 [AD7998_CYC_TCONF_512] = 976,
326 [AD7998_CYC_TCONF_1024] = 488,
327 [AD7998_CYC_TCONF_2048] = 244,
328};
329
330static ssize_t ad799x_read_frequency(struct device *dev,
331 struct device_attribute *attr,
332 char *buf)
333{
334 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
335 struct ad799x_state *st = iio_priv(indio_dev);
336
337 int ret = i2c_smbus_read_byte_data(client: st->client, AD7998_CYCLE_TMR_REG);
338 if (ret < 0)
339 return ret;
340
341 return sprintf(buf, fmt: "%u\n", ad7998_frequencies[ret & AD7998_CYC_MASK]);
342}
343
344static ssize_t ad799x_write_frequency(struct device *dev,
345 struct device_attribute *attr,
346 const char *buf,
347 size_t len)
348{
349 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
350 struct ad799x_state *st = iio_priv(indio_dev);
351
352 long val;
353 int ret, i;
354
355 ret = kstrtol(s: buf, base: 10, res: &val);
356 if (ret)
357 return ret;
358
359 mutex_lock(&st->lock);
360
361 ret = i2c_smbus_read_byte_data(client: st->client, AD7998_CYCLE_TMR_REG);
362 if (ret < 0)
363 goto error_ret_mutex;
364 /* Wipe the bits clean */
365 ret &= ~AD7998_CYC_MASK;
366
367 for (i = 0; i < ARRAY_SIZE(ad7998_frequencies); i++)
368 if (val == ad7998_frequencies[i])
369 break;
370 if (i == ARRAY_SIZE(ad7998_frequencies)) {
371 ret = -EINVAL;
372 goto error_ret_mutex;
373 }
374
375 ret = i2c_smbus_write_byte_data(client: st->client, AD7998_CYCLE_TMR_REG,
376 value: ret | i);
377 if (ret < 0)
378 goto error_ret_mutex;
379 ret = len;
380
381error_ret_mutex:
382 mutex_unlock(lock: &st->lock);
383
384 return ret;
385}
386
387static int ad799x_read_event_config(struct iio_dev *indio_dev,
388 const struct iio_chan_spec *chan,
389 enum iio_event_type type,
390 enum iio_event_direction dir)
391{
392 struct ad799x_state *st = iio_priv(indio_dev);
393
394 if (!(st->config & AD7998_ALERT_EN))
395 return 0;
396
397 if ((st->config >> AD799X_CHANNEL_SHIFT) & BIT(chan->scan_index))
398 return 1;
399
400 return 0;
401}
402
403static int ad799x_write_event_config(struct iio_dev *indio_dev,
404 const struct iio_chan_spec *chan,
405 enum iio_event_type type,
406 enum iio_event_direction dir,
407 int state)
408{
409 struct ad799x_state *st = iio_priv(indio_dev);
410 int ret;
411
412 ret = iio_device_claim_direct_mode(indio_dev);
413 if (ret)
414 return ret;
415
416 mutex_lock(&st->lock);
417
418 if (state)
419 st->config |= BIT(chan->scan_index) << AD799X_CHANNEL_SHIFT;
420 else
421 st->config &= ~(BIT(chan->scan_index) << AD799X_CHANNEL_SHIFT);
422
423 if (st->config >> AD799X_CHANNEL_SHIFT)
424 st->config |= AD7998_ALERT_EN;
425 else
426 st->config &= ~AD7998_ALERT_EN;
427
428 ret = ad799x_write_config(st, val: st->config);
429 mutex_unlock(lock: &st->lock);
430 iio_device_release_direct_mode(indio_dev);
431 return ret;
432}
433
434static unsigned int ad799x_threshold_reg(const struct iio_chan_spec *chan,
435 enum iio_event_direction dir,
436 enum iio_event_info info)
437{
438 switch (info) {
439 case IIO_EV_INFO_VALUE:
440 if (dir == IIO_EV_DIR_FALLING)
441 return AD7998_DATALOW_REG(chan->channel);
442 else
443 return AD7998_DATAHIGH_REG(chan->channel);
444 case IIO_EV_INFO_HYSTERESIS:
445 return AD7998_HYST_REG(chan->channel);
446 default:
447 return -EINVAL;
448 }
449
450 return 0;
451}
452
453static int ad799x_write_event_value(struct iio_dev *indio_dev,
454 const struct iio_chan_spec *chan,
455 enum iio_event_type type,
456 enum iio_event_direction dir,
457 enum iio_event_info info,
458 int val, int val2)
459{
460 int ret;
461 struct ad799x_state *st = iio_priv(indio_dev);
462
463 if (val < 0 || val > GENMASK(chan->scan_type.realbits - 1, 0))
464 return -EINVAL;
465
466 ret = i2c_smbus_write_word_swapped(client: st->client,
467 command: ad799x_threshold_reg(chan, dir, info),
468 value: val << chan->scan_type.shift);
469
470 return ret;
471}
472
473static int ad799x_read_event_value(struct iio_dev *indio_dev,
474 const struct iio_chan_spec *chan,
475 enum iio_event_type type,
476 enum iio_event_direction dir,
477 enum iio_event_info info,
478 int *val, int *val2)
479{
480 int ret;
481 struct ad799x_state *st = iio_priv(indio_dev);
482
483 ret = i2c_smbus_read_word_swapped(client: st->client,
484 command: ad799x_threshold_reg(chan, dir, info));
485 if (ret < 0)
486 return ret;
487 *val = (ret >> chan->scan_type.shift) &
488 GENMASK(chan->scan_type.realbits - 1, 0);
489
490 return IIO_VAL_INT;
491}
492
493static irqreturn_t ad799x_event_handler(int irq, void *private)
494{
495 struct iio_dev *indio_dev = private;
496 struct ad799x_state *st = iio_priv(indio_dev: private);
497 int i, ret;
498
499 ret = i2c_smbus_read_byte_data(client: st->client, AD7998_ALERT_STAT_REG);
500 if (ret <= 0)
501 goto done;
502
503 if (i2c_smbus_write_byte_data(client: st->client, AD7998_ALERT_STAT_REG,
504 AD7998_ALERT_STAT_CLEAR) < 0)
505 goto done;
506
507 for (i = 0; i < 8; i++) {
508 if (ret & BIT(i))
509 iio_push_event(indio_dev,
510 ev_code: i & 0x1 ?
511 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
512 (i >> 1),
513 IIO_EV_TYPE_THRESH,
514 IIO_EV_DIR_RISING) :
515 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
516 (i >> 1),
517 IIO_EV_TYPE_THRESH,
518 IIO_EV_DIR_FALLING),
519 timestamp: iio_get_time_ns(indio_dev));
520 }
521
522done:
523 return IRQ_HANDLED;
524}
525
526static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
527 ad799x_read_frequency,
528 ad799x_write_frequency);
529static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("15625 7812 3906 1953 976 488 244 0");
530
531static struct attribute *ad799x_event_attributes[] = {
532 &iio_dev_attr_sampling_frequency.dev_attr.attr,
533 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
534 NULL,
535};
536
537static const struct attribute_group ad799x_event_attrs_group = {
538 .attrs = ad799x_event_attributes,
539};
540
541static const struct iio_info ad7991_info = {
542 .read_raw = &ad799x_read_raw,
543 .update_scan_mode = ad799x_update_scan_mode,
544};
545
546static const struct iio_info ad7993_4_7_8_noirq_info = {
547 .read_raw = &ad799x_read_raw,
548 .update_scan_mode = ad799x_update_scan_mode,
549};
550
551static const struct iio_info ad7993_4_7_8_irq_info = {
552 .read_raw = &ad799x_read_raw,
553 .event_attrs = &ad799x_event_attrs_group,
554 .read_event_config = &ad799x_read_event_config,
555 .write_event_config = &ad799x_write_event_config,
556 .read_event_value = &ad799x_read_event_value,
557 .write_event_value = &ad799x_write_event_value,
558 .update_scan_mode = ad799x_update_scan_mode,
559};
560
561static const struct iio_event_spec ad799x_events[] = {
562 {
563 .type = IIO_EV_TYPE_THRESH,
564 .dir = IIO_EV_DIR_RISING,
565 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
566 BIT(IIO_EV_INFO_ENABLE),
567 }, {
568 .type = IIO_EV_TYPE_THRESH,
569 .dir = IIO_EV_DIR_FALLING,
570 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
571 BIT(IIO_EV_INFO_ENABLE),
572 }, {
573 .type = IIO_EV_TYPE_THRESH,
574 .dir = IIO_EV_DIR_EITHER,
575 .mask_separate = BIT(IIO_EV_INFO_HYSTERESIS),
576 },
577};
578
579#define _AD799X_CHANNEL(_index, _realbits, _ev_spec, _num_ev_spec) { \
580 .type = IIO_VOLTAGE, \
581 .indexed = 1, \
582 .channel = (_index), \
583 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
584 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
585 .scan_index = (_index), \
586 .scan_type = { \
587 .sign = 'u', \
588 .realbits = (_realbits), \
589 .storagebits = 16, \
590 .shift = 12 - (_realbits), \
591 .endianness = IIO_BE, \
592 }, \
593 .event_spec = _ev_spec, \
594 .num_event_specs = _num_ev_spec, \
595}
596
597#define AD799X_CHANNEL(_index, _realbits) \
598 _AD799X_CHANNEL(_index, _realbits, NULL, 0)
599
600#define AD799X_CHANNEL_WITH_EVENTS(_index, _realbits) \
601 _AD799X_CHANNEL(_index, _realbits, ad799x_events, \
602 ARRAY_SIZE(ad799x_events))
603
604static const struct ad799x_chip_info ad799x_chip_info_tbl[] = {
605 [ad7991] = {
606 .num_channels = 5,
607 .noirq_config = {
608 .channel = {
609 AD799X_CHANNEL(0, 12),
610 AD799X_CHANNEL(1, 12),
611 AD799X_CHANNEL(2, 12),
612 AD799X_CHANNEL(3, 12),
613 IIO_CHAN_SOFT_TIMESTAMP(4),
614 },
615 .info = &ad7991_info,
616 },
617 },
618 [ad7995] = {
619 .num_channels = 5,
620 .noirq_config = {
621 .channel = {
622 AD799X_CHANNEL(0, 10),
623 AD799X_CHANNEL(1, 10),
624 AD799X_CHANNEL(2, 10),
625 AD799X_CHANNEL(3, 10),
626 IIO_CHAN_SOFT_TIMESTAMP(4),
627 },
628 .info = &ad7991_info,
629 },
630 },
631 [ad7999] = {
632 .num_channels = 5,
633 .noirq_config = {
634 .channel = {
635 AD799X_CHANNEL(0, 8),
636 AD799X_CHANNEL(1, 8),
637 AD799X_CHANNEL(2, 8),
638 AD799X_CHANNEL(3, 8),
639 IIO_CHAN_SOFT_TIMESTAMP(4),
640 },
641 .info = &ad7991_info,
642 },
643 },
644 [ad7992] = {
645 .num_channels = 3,
646 .noirq_config = {
647 .channel = {
648 AD799X_CHANNEL(0, 12),
649 AD799X_CHANNEL(1, 12),
650 IIO_CHAN_SOFT_TIMESTAMP(3),
651 },
652 .info = &ad7993_4_7_8_noirq_info,
653 },
654 .irq_config = {
655 .channel = {
656 AD799X_CHANNEL_WITH_EVENTS(0, 12),
657 AD799X_CHANNEL_WITH_EVENTS(1, 12),
658 IIO_CHAN_SOFT_TIMESTAMP(3),
659 },
660 .default_config = AD7998_ALERT_EN | AD7998_BUSY_ALERT,
661 .info = &ad7993_4_7_8_irq_info,
662 },
663 },
664 [ad7993] = {
665 .num_channels = 5,
666 .noirq_config = {
667 .channel = {
668 AD799X_CHANNEL(0, 10),
669 AD799X_CHANNEL(1, 10),
670 AD799X_CHANNEL(2, 10),
671 AD799X_CHANNEL(3, 10),
672 IIO_CHAN_SOFT_TIMESTAMP(4),
673 },
674 .info = &ad7993_4_7_8_noirq_info,
675 },
676 .irq_config = {
677 .channel = {
678 AD799X_CHANNEL_WITH_EVENTS(0, 10),
679 AD799X_CHANNEL_WITH_EVENTS(1, 10),
680 AD799X_CHANNEL_WITH_EVENTS(2, 10),
681 AD799X_CHANNEL_WITH_EVENTS(3, 10),
682 IIO_CHAN_SOFT_TIMESTAMP(4),
683 },
684 .default_config = AD7998_ALERT_EN | AD7998_BUSY_ALERT,
685 .info = &ad7993_4_7_8_irq_info,
686 },
687 },
688 [ad7994] = {
689 .num_channels = 5,
690 .noirq_config = {
691 .channel = {
692 AD799X_CHANNEL(0, 12),
693 AD799X_CHANNEL(1, 12),
694 AD799X_CHANNEL(2, 12),
695 AD799X_CHANNEL(3, 12),
696 IIO_CHAN_SOFT_TIMESTAMP(4),
697 },
698 .info = &ad7993_4_7_8_noirq_info,
699 },
700 .irq_config = {
701 .channel = {
702 AD799X_CHANNEL_WITH_EVENTS(0, 12),
703 AD799X_CHANNEL_WITH_EVENTS(1, 12),
704 AD799X_CHANNEL_WITH_EVENTS(2, 12),
705 AD799X_CHANNEL_WITH_EVENTS(3, 12),
706 IIO_CHAN_SOFT_TIMESTAMP(4),
707 },
708 .default_config = AD7998_ALERT_EN | AD7998_BUSY_ALERT,
709 .info = &ad7993_4_7_8_irq_info,
710 },
711 },
712 [ad7997] = {
713 .num_channels = 9,
714 .noirq_config = {
715 .channel = {
716 AD799X_CHANNEL(0, 10),
717 AD799X_CHANNEL(1, 10),
718 AD799X_CHANNEL(2, 10),
719 AD799X_CHANNEL(3, 10),
720 AD799X_CHANNEL(4, 10),
721 AD799X_CHANNEL(5, 10),
722 AD799X_CHANNEL(6, 10),
723 AD799X_CHANNEL(7, 10),
724 IIO_CHAN_SOFT_TIMESTAMP(8),
725 },
726 .info = &ad7993_4_7_8_noirq_info,
727 },
728 .irq_config = {
729 .channel = {
730 AD799X_CHANNEL_WITH_EVENTS(0, 10),
731 AD799X_CHANNEL_WITH_EVENTS(1, 10),
732 AD799X_CHANNEL_WITH_EVENTS(2, 10),
733 AD799X_CHANNEL_WITH_EVENTS(3, 10),
734 AD799X_CHANNEL(4, 10),
735 AD799X_CHANNEL(5, 10),
736 AD799X_CHANNEL(6, 10),
737 AD799X_CHANNEL(7, 10),
738 IIO_CHAN_SOFT_TIMESTAMP(8),
739 },
740 .default_config = AD7998_ALERT_EN | AD7998_BUSY_ALERT,
741 .info = &ad7993_4_7_8_irq_info,
742 },
743 },
744 [ad7998] = {
745 .num_channels = 9,
746 .noirq_config = {
747 .channel = {
748 AD799X_CHANNEL(0, 12),
749 AD799X_CHANNEL(1, 12),
750 AD799X_CHANNEL(2, 12),
751 AD799X_CHANNEL(3, 12),
752 AD799X_CHANNEL(4, 12),
753 AD799X_CHANNEL(5, 12),
754 AD799X_CHANNEL(6, 12),
755 AD799X_CHANNEL(7, 12),
756 IIO_CHAN_SOFT_TIMESTAMP(8),
757 },
758 .info = &ad7993_4_7_8_noirq_info,
759 },
760 .irq_config = {
761 .channel = {
762 AD799X_CHANNEL_WITH_EVENTS(0, 12),
763 AD799X_CHANNEL_WITH_EVENTS(1, 12),
764 AD799X_CHANNEL_WITH_EVENTS(2, 12),
765 AD799X_CHANNEL_WITH_EVENTS(3, 12),
766 AD799X_CHANNEL(4, 12),
767 AD799X_CHANNEL(5, 12),
768 AD799X_CHANNEL(6, 12),
769 AD799X_CHANNEL(7, 12),
770 IIO_CHAN_SOFT_TIMESTAMP(8),
771 },
772 .default_config = AD7998_ALERT_EN | AD7998_BUSY_ALERT,
773 .info = &ad7993_4_7_8_irq_info,
774 },
775 },
776};
777
778static int ad799x_probe(struct i2c_client *client)
779{
780 const struct i2c_device_id *id = i2c_client_get_device_id(client);
781 int ret;
782 int extra_config = 0;
783 struct ad799x_state *st;
784 struct iio_dev *indio_dev;
785 const struct ad799x_chip_info *chip_info =
786 &ad799x_chip_info_tbl[id->driver_data];
787
788 indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*st));
789 if (indio_dev == NULL)
790 return -ENOMEM;
791
792 st = iio_priv(indio_dev);
793 /* this is only used for device removal purposes */
794 i2c_set_clientdata(client, data: indio_dev);
795
796 st->id = id->driver_data;
797 if (client->irq > 0 && chip_info->irq_config.info)
798 st->chip_config = &chip_info->irq_config;
799 else
800 st->chip_config = &chip_info->noirq_config;
801
802 /* TODO: Add pdata options for filtering and bit delay */
803
804 st->reg = devm_regulator_get(dev: &client->dev, id: "vcc");
805 if (IS_ERR(ptr: st->reg))
806 return PTR_ERR(ptr: st->reg);
807 ret = regulator_enable(regulator: st->reg);
808 if (ret)
809 return ret;
810
811 /* check if an external reference is supplied */
812 st->vref = devm_regulator_get_optional(dev: &client->dev, id: "vref");
813
814 if (IS_ERR(ptr: st->vref)) {
815 if (PTR_ERR(ptr: st->vref) == -ENODEV) {
816 st->vref = NULL;
817 dev_info(&client->dev, "Using VCC reference voltage\n");
818 } else {
819 ret = PTR_ERR(ptr: st->vref);
820 goto error_disable_reg;
821 }
822 }
823
824 if (st->vref) {
825 /*
826 * Use external reference voltage if supported by hardware.
827 * This is optional if voltage / regulator present, use VCC otherwise.
828 */
829 if ((st->id == ad7991) || (st->id == ad7995) || (st->id == ad7999)) {
830 dev_info(&client->dev, "Using external reference voltage\n");
831 extra_config |= AD7991_REF_SEL;
832 ret = regulator_enable(regulator: st->vref);
833 if (ret)
834 goto error_disable_reg;
835 } else {
836 st->vref = NULL;
837 dev_warn(&client->dev, "Supplied reference not supported\n");
838 }
839 }
840
841 st->client = client;
842
843 indio_dev->name = id->name;
844 indio_dev->info = st->chip_config->info;
845
846 indio_dev->modes = INDIO_DIRECT_MODE;
847 indio_dev->channels = st->chip_config->channel;
848 indio_dev->num_channels = chip_info->num_channels;
849
850 ret = ad799x_update_config(st, config: st->chip_config->default_config | extra_config);
851 if (ret)
852 goto error_disable_vref;
853
854 ret = iio_triggered_buffer_setup(indio_dev, NULL,
855 &ad799x_trigger_handler, NULL);
856 if (ret)
857 goto error_disable_vref;
858
859 if (client->irq > 0) {
860 ret = devm_request_threaded_irq(dev: &client->dev,
861 irq: client->irq,
862 NULL,
863 thread_fn: ad799x_event_handler,
864 IRQF_TRIGGER_FALLING |
865 IRQF_ONESHOT,
866 devname: client->name,
867 dev_id: indio_dev);
868 if (ret)
869 goto error_cleanup_ring;
870 }
871
872 mutex_init(&st->lock);
873
874 ret = iio_device_register(indio_dev);
875 if (ret)
876 goto error_cleanup_ring;
877
878 return 0;
879
880error_cleanup_ring:
881 iio_triggered_buffer_cleanup(indio_dev);
882error_disable_vref:
883 if (st->vref)
884 regulator_disable(regulator: st->vref);
885error_disable_reg:
886 regulator_disable(regulator: st->reg);
887
888 return ret;
889}
890
891static void ad799x_remove(struct i2c_client *client)
892{
893 struct iio_dev *indio_dev = i2c_get_clientdata(client);
894 struct ad799x_state *st = iio_priv(indio_dev);
895
896 iio_device_unregister(indio_dev);
897
898 iio_triggered_buffer_cleanup(indio_dev);
899 if (st->vref)
900 regulator_disable(regulator: st->vref);
901 regulator_disable(regulator: st->reg);
902 kfree(objp: st->rx_buf);
903}
904
905static int ad799x_suspend(struct device *dev)
906{
907 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
908 struct ad799x_state *st = iio_priv(indio_dev);
909
910 if (st->vref)
911 regulator_disable(regulator: st->vref);
912 regulator_disable(regulator: st->reg);
913
914 return 0;
915}
916
917static int ad799x_resume(struct device *dev)
918{
919 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
920 struct ad799x_state *st = iio_priv(indio_dev);
921 int ret;
922
923 ret = regulator_enable(regulator: st->reg);
924 if (ret) {
925 dev_err(dev, "Unable to enable vcc regulator\n");
926 return ret;
927 }
928
929 if (st->vref) {
930 ret = regulator_enable(regulator: st->vref);
931 if (ret) {
932 regulator_disable(regulator: st->reg);
933 dev_err(dev, "Unable to enable vref regulator\n");
934 return ret;
935 }
936 }
937
938 /* resync config */
939 ret = ad799x_update_config(st, config: st->config);
940 if (ret) {
941 if (st->vref)
942 regulator_disable(regulator: st->vref);
943 regulator_disable(regulator: st->reg);
944 return ret;
945 }
946
947 return 0;
948}
949
950static DEFINE_SIMPLE_DEV_PM_OPS(ad799x_pm_ops, ad799x_suspend, ad799x_resume);
951
952static const struct i2c_device_id ad799x_id[] = {
953 { "ad7991", ad7991 },
954 { "ad7995", ad7995 },
955 { "ad7999", ad7999 },
956 { "ad7992", ad7992 },
957 { "ad7993", ad7993 },
958 { "ad7994", ad7994 },
959 { "ad7997", ad7997 },
960 { "ad7998", ad7998 },
961 {}
962};
963
964MODULE_DEVICE_TABLE(i2c, ad799x_id);
965
966static struct i2c_driver ad799x_driver = {
967 .driver = {
968 .name = "ad799x",
969 .pm = pm_sleep_ptr(&ad799x_pm_ops),
970 },
971 .probe = ad799x_probe,
972 .remove = ad799x_remove,
973 .id_table = ad799x_id,
974};
975module_i2c_driver(ad799x_driver);
976
977MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
978MODULE_DESCRIPTION("Analog Devices AD799x ADC");
979MODULE_LICENSE("GPL v2");
980

source code of linux/drivers/iio/adc/ad799x.c