Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * AD7170/AD7171 and AD7780/AD7781 SPI ADC driver
4 *
5 * Copyright 2011 Analog Devices Inc.
6 * Copyright 2019 Renato Lui Geh
7 */
8
9#include <linux/interrupt.h>
10#include <linux/device.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
13#include <linux/sysfs.h>
14#include <linux/spi/spi.h>
15#include <linux/regulator/consumer.h>
16#include <linux/err.h>
17#include <linux/sched.h>
18#include <linux/gpio/consumer.h>
19#include <linux/module.h>
20#include <linux/bits.h>
21
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24#include <linux/iio/adc/ad_sigma_delta.h>
25
26#define AD7780_RDY BIT(7)
27#define AD7780_FILTER BIT(6)
28#define AD7780_ERR BIT(5)
29#define AD7780_ID1 BIT(4)
30#define AD7780_ID0 BIT(3)
31#define AD7780_GAIN BIT(2)
32
33#define AD7170_ID 0
34#define AD7171_ID 1
35#define AD7780_ID 1
36#define AD7781_ID 0
37
38#define AD7780_ID_MASK (AD7780_ID0 | AD7780_ID1)
39
40#define AD7780_PATTERN_GOOD 1
41#define AD7780_PATTERN_MASK GENMASK(1, 0)
42
43#define AD7170_PATTERN_GOOD 5
44#define AD7170_PATTERN_MASK GENMASK(2, 0)
45
46#define AD7780_GAIN_MIDPOINT 64
47#define AD7780_FILTER_MIDPOINT 13350
48
49static const unsigned int ad778x_gain[2] = { 1, 128 };
50static const unsigned int ad778x_odr_avail[2] = { 10000, 16700 };
51
52struct ad7780_chip_info {
53 struct iio_chan_spec channel;
54 unsigned int pattern_mask;
55 unsigned int pattern;
56 bool is_ad778x;
57};
58
59struct ad7780_state {
60 const struct ad7780_chip_info *chip_info;
61 struct regulator *reg;
62 struct gpio_desc *powerdown_gpio;
63 struct gpio_desc *gain_gpio;
64 struct gpio_desc *filter_gpio;
65 unsigned int gain;
66 unsigned int odr;
67 unsigned int int_vref_mv;
68
69 struct ad_sigma_delta sd;
70};
71
72enum ad7780_supported_device_ids {
73 ID_AD7170,
74 ID_AD7171,
75 ID_AD7780,
76 ID_AD7781,
77};
78
79static struct ad7780_state *ad_sigma_delta_to_ad7780(struct ad_sigma_delta *sd)
80{
81 return container_of(sd, struct ad7780_state, sd);
82}
83
84static int ad7780_set_mode(struct ad_sigma_delta *sigma_delta,
85 enum ad_sigma_delta_mode mode)
86{
87 struct ad7780_state *st = ad_sigma_delta_to_ad7780(sigma_delta);
88 unsigned int val;
89
90 switch (mode) {
91 case AD_SD_MODE_SINGLE:
92 case AD_SD_MODE_CONTINUOUS:
93 val = 1;
94 break;
95 default:
96 val = 0;
97 break;
98 }
99
100 gpiod_set_value(st->powerdown_gpio, val);
101
102 return 0;
103}
104
105static int ad7780_read_raw(struct iio_dev *indio_dev,
106 struct iio_chan_spec const *chan,
107 int *val,
108 int *val2,
109 long m)
110{
111 struct ad7780_state *st = iio_priv(indio_dev);
112 int voltage_uv;
113
114 switch (m) {
115 case IIO_CHAN_INFO_RAW:
116 return ad_sigma_delta_single_conversion(indio_dev, chan, val);
117 case IIO_CHAN_INFO_SCALE:
118 voltage_uv = regulator_get_voltage(st->reg);
119 if (voltage_uv < 0)
120 return voltage_uv;
121 voltage_uv /= 1000;
122 *val = voltage_uv * st->gain;
123 *val2 = chan->scan_type.realbits - 1;
124 st->int_vref_mv = voltage_uv;
125 return IIO_VAL_FRACTIONAL_LOG2;
126 case IIO_CHAN_INFO_OFFSET:
127 *val = -(1 << (chan->scan_type.realbits - 1));
128 return IIO_VAL_INT;
129 case IIO_CHAN_INFO_SAMP_FREQ:
130 *val = st->odr;
131 return IIO_VAL_INT;
132 default:
133 break;
134 }
135
136 return -EINVAL;
137}
138
139static int ad7780_write_raw(struct iio_dev *indio_dev,
140 struct iio_chan_spec const *chan,
141 int val,
142 int val2,
143 long m)
144{
145 struct ad7780_state *st = iio_priv(indio_dev);
146 const struct ad7780_chip_info *chip_info = st->chip_info;
147 unsigned long long vref;
148 unsigned int full_scale, gain;
149
150 if (!chip_info->is_ad778x)
151 return -EINVAL;
152
153 switch (m) {
154 case IIO_CHAN_INFO_SCALE:
155 if (val != 0)
156 return -EINVAL;
157
158 vref = st->int_vref_mv * 1000000LL;
159 full_scale = 1 << (chip_info->channel.scan_type.realbits - 1);
160 gain = DIV_ROUND_CLOSEST_ULL(vref, full_scale);
161 gain = DIV_ROUND_CLOSEST(gain, val2);
162 st->gain = gain;
163 if (gain < AD7780_GAIN_MIDPOINT)
164 gain = 0;
165 else
166 gain = 1;
167 gpiod_set_value(st->gain_gpio, gain);
168 break;
169 case IIO_CHAN_INFO_SAMP_FREQ:
170 if (1000*val + val2/1000 < AD7780_FILTER_MIDPOINT)
171 val = 0;
172 else
173 val = 1;
174 st->odr = ad778x_odr_avail[val];
175 gpiod_set_value(st->filter_gpio, val);
176 break;
177 default:
178 break;
179 }
180
181 return 0;
182}
183
184static int ad7780_postprocess_sample(struct ad_sigma_delta *sigma_delta,
185 unsigned int raw_sample)
186{
187 struct ad7780_state *st = ad_sigma_delta_to_ad7780(sigma_delta);
188 const struct ad7780_chip_info *chip_info = st->chip_info;
189
190 if ((raw_sample & AD7780_ERR) ||
191 ((raw_sample & chip_info->pattern_mask) != chip_info->pattern))
192 return -EIO;
193
194 if (chip_info->is_ad778x) {
195 st->gain = ad778x_gain[raw_sample & AD7780_GAIN];
196 st->odr = ad778x_odr_avail[raw_sample & AD7780_FILTER];
197 }
198
199 return 0;
200}
201
202static const struct ad_sigma_delta_info ad7780_sigma_delta_info = {
203 .set_mode = ad7780_set_mode,
204 .postprocess_sample = ad7780_postprocess_sample,
205 .has_registers = false,
206};
207
208#define AD7780_CHANNEL(bits, wordsize) \
209 AD_SD_CHANNEL(1, 0, 0, bits, 32, (wordsize) - (bits))
210#define AD7170_CHANNEL(bits, wordsize) \
211 AD_SD_CHANNEL_NO_SAMP_FREQ(1, 0, 0, bits, 32, (wordsize) - (bits))
212
213static const struct ad7780_chip_info ad7780_chip_info_tbl[] = {
214 [ID_AD7170] = {
215 .channel = AD7170_CHANNEL(12, 24),
216 .pattern = AD7170_PATTERN_GOOD,
217 .pattern_mask = AD7170_PATTERN_MASK,
218 .is_ad778x = false,
219 },
220 [ID_AD7171] = {
221 .channel = AD7170_CHANNEL(16, 24),
222 .pattern = AD7170_PATTERN_GOOD,
223 .pattern_mask = AD7170_PATTERN_MASK,
224 .is_ad778x = false,
225 },
226 [ID_AD7780] = {
227 .channel = AD7780_CHANNEL(24, 32),
228 .pattern = AD7780_PATTERN_GOOD,
229 .pattern_mask = AD7780_PATTERN_MASK,
230 .is_ad778x = true,
231 },
232 [ID_AD7781] = {
233 .channel = AD7780_CHANNEL(20, 32),
234 .pattern = AD7780_PATTERN_GOOD,
235 .pattern_mask = AD7780_PATTERN_MASK,
236 .is_ad778x = true,
237 },
238};
239
240static const struct iio_info ad7780_info = {
241 .read_raw = ad7780_read_raw,
242 .write_raw = ad7780_write_raw,
243};
244
245static int ad7780_init_gpios(struct device *dev, struct ad7780_state *st)
246{
247 int ret;
248
249 st->powerdown_gpio = devm_gpiod_get_optional(dev,
250 "powerdown",
251 GPIOD_OUT_LOW);
252 if (IS_ERR(st->powerdown_gpio)) {
253 ret = PTR_ERR(st->powerdown_gpio);
254 dev_err(dev, "Failed to request powerdown GPIO: %d\n", ret);
255 return ret;
256 }
257
258 if (!st->chip_info->is_ad778x)
259 return 0;
260
261
262 st->gain_gpio = devm_gpiod_get_optional(dev,
263 "adi,gain",
264 GPIOD_OUT_HIGH);
265 if (IS_ERR(st->gain_gpio)) {
266 ret = PTR_ERR(st->gain_gpio);
267 dev_err(dev, "Failed to request gain GPIO: %d\n", ret);
268 return ret;
269 }
270
271 st->filter_gpio = devm_gpiod_get_optional(dev,
272 "adi,filter",
273 GPIOD_OUT_HIGH);
274 if (IS_ERR(st->filter_gpio)) {
275 ret = PTR_ERR(st->filter_gpio);
276 dev_err(dev, "Failed to request filter GPIO: %d\n", ret);
277 return ret;
278 }
279
280 return 0;
281}
282
283static int ad7780_probe(struct spi_device *spi)
284{
285 struct ad7780_state *st;
286 struct iio_dev *indio_dev;
287 int ret;
288
289 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
290 if (!indio_dev)
291 return -ENOMEM;
292
293 st = iio_priv(indio_dev);
294 st->gain = 1;
295
296 ad_sd_init(&st->sd, indio_dev, spi, &ad7780_sigma_delta_info);
297
298 st->chip_info =
299 &ad7780_chip_info_tbl[spi_get_device_id(spi)->driver_data];
300
301 spi_set_drvdata(spi, indio_dev);
302
303 indio_dev->dev.parent = &spi->dev;
304 indio_dev->name = spi_get_device_id(spi)->name;
305 indio_dev->modes = INDIO_DIRECT_MODE;
306 indio_dev->channels = &st->chip_info->channel;
307 indio_dev->num_channels = 1;
308 indio_dev->info = &ad7780_info;
309
310 ret = ad7780_init_gpios(&spi->dev, st);
311 if (ret)
312 goto error_cleanup_buffer_and_trigger;
313
314 st->reg = devm_regulator_get(&spi->dev, "avdd");
315 if (IS_ERR(st->reg))
316 return PTR_ERR(st->reg);
317
318 ret = regulator_enable(st->reg);
319 if (ret) {
320 dev_err(&spi->dev, "Failed to enable specified AVdd supply\n");
321 return ret;
322 }
323
324 ret = ad_sd_setup_buffer_and_trigger(indio_dev);
325 if (ret)
326 goto error_disable_reg;
327
328 ret = iio_device_register(indio_dev);
329 if (ret)
330 goto error_cleanup_buffer_and_trigger;
331
332 return 0;
333
334error_cleanup_buffer_and_trigger:
335 ad_sd_cleanup_buffer_and_trigger(indio_dev);
336error_disable_reg:
337 regulator_disable(st->reg);
338
339 return ret;
340}
341
342static int ad7780_remove(struct spi_device *spi)
343{
344 struct iio_dev *indio_dev = spi_get_drvdata(spi);
345 struct ad7780_state *st = iio_priv(indio_dev);
346
347 iio_device_unregister(indio_dev);
348 ad_sd_cleanup_buffer_and_trigger(indio_dev);
349
350 regulator_disable(st->reg);
351
352 return 0;
353}
354
355static const struct spi_device_id ad7780_id[] = {
356 {"ad7170", ID_AD7170},
357 {"ad7171", ID_AD7171},
358 {"ad7780", ID_AD7780},
359 {"ad7781", ID_AD7781},
360 {}
361};
362MODULE_DEVICE_TABLE(spi, ad7780_id);
363
364static struct spi_driver ad7780_driver = {
365 .driver = {
366 .name = "ad7780",
367 },
368 .probe = ad7780_probe,
369 .remove = ad7780_remove,
370 .id_table = ad7780_id,
371};
372module_spi_driver(ad7780_driver);
373
374MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
375MODULE_DESCRIPTION("Analog Devices AD7780 and similar ADCs");
376MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * AD7170/AD7171 and AD7780/AD7781 SPI ADC driver
4 *
5 * Copyright 2011 Analog Devices Inc.
6 * Copyright 2019 Renato Lui Geh
7 */
8
9#include <linux/interrupt.h>
10#include <linux/device.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
13#include <linux/sysfs.h>
14#include <linux/spi/spi.h>
15#include <linux/regulator/consumer.h>
16#include <linux/err.h>
17#include <linux/sched.h>
18#include <linux/gpio/consumer.h>
19#include <linux/module.h>
20#include <linux/bits.h>
21
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24#include <linux/iio/adc/ad_sigma_delta.h>
25
26#define AD7780_RDY BIT(7)
27#define AD7780_FILTER BIT(6)
28#define AD7780_ERR BIT(5)
29#define AD7780_ID1 BIT(4)
30#define AD7780_ID0 BIT(3)
31#define AD7780_GAIN BIT(2)
32
33#define AD7170_ID 0
34#define AD7171_ID 1
35#define AD7780_ID 1
36#define AD7781_ID 0
37
38#define AD7780_ID_MASK (AD7780_ID0 | AD7780_ID1)
39
40#define AD7780_PATTERN_GOOD 1
41#define AD7780_PATTERN_MASK GENMASK(1, 0)
42
43#define AD7170_PATTERN_GOOD 5
44#define AD7170_PATTERN_MASK GENMASK(2, 0)
45
46#define AD7780_GAIN_MIDPOINT 64
47#define AD7780_FILTER_MIDPOINT 13350
48
49static const unsigned int ad778x_gain[2] = { 1, 128 };
50static const unsigned int ad778x_odr_avail[2] = { 10000, 16700 };
51
52struct ad7780_chip_info {
53 struct iio_chan_spec channel;
54 unsigned int pattern_mask;
55 unsigned int pattern;
56 bool is_ad778x;
57};
58
59struct ad7780_state {
60 const struct ad7780_chip_info *chip_info;
61 struct regulator *reg;
62 struct gpio_desc *powerdown_gpio;
63 struct gpio_desc *gain_gpio;
64 struct gpio_desc *filter_gpio;
65 unsigned int gain;
66 unsigned int odr;
67 unsigned int int_vref_mv;
68
69 struct ad_sigma_delta sd;
70};
71
72enum ad7780_supported_device_ids {
73 ID_AD7170,
74 ID_AD7171,
75 ID_AD7780,
76 ID_AD7781,
77};
78
79static struct ad7780_state *ad_sigma_delta_to_ad7780(struct ad_sigma_delta *sd)
80{
81 return container_of(sd, struct ad7780_state, sd);
82}
83
84static int ad7780_set_mode(struct ad_sigma_delta *sigma_delta,
85 enum ad_sigma_delta_mode mode)
86{
87 struct ad7780_state *st = ad_sigma_delta_to_ad7780(sigma_delta);
88 unsigned int val;
89
90 switch (mode) {
91 case AD_SD_MODE_SINGLE:
92 case AD_SD_MODE_CONTINUOUS:
93 val = 1;
94 break;
95 default:
96 val = 0;
97 break;
98 }
99
100 gpiod_set_value(st->powerdown_gpio, val);
101
102 return 0;
103}
104
105static int ad7780_read_raw(struct iio_dev *indio_dev,
106 struct iio_chan_spec const *chan,
107 int *val,
108 int *val2,
109 long m)
110{
111 struct ad7780_state *st = iio_priv(indio_dev);
112 int voltage_uv;
113
114 switch (m) {
115 case IIO_CHAN_INFO_RAW:
116 return ad_sigma_delta_single_conversion(indio_dev, chan, val);
117 case IIO_CHAN_INFO_SCALE:
118 voltage_uv = regulator_get_voltage(st->reg);
119 if (voltage_uv < 0)
120 return voltage_uv;
121 voltage_uv /= 1000;
122 *val = voltage_uv * st->gain;
123 *val2 = chan->scan_type.realbits - 1;
124 st->int_vref_mv = voltage_uv;
125 return IIO_VAL_FRACTIONAL_LOG2;
126 case IIO_CHAN_INFO_OFFSET:
127 *val = -(1 << (chan->scan_type.realbits - 1));
128 return IIO_VAL_INT;
129 case IIO_CHAN_INFO_SAMP_FREQ:
130 *val = st->odr;
131 return IIO_VAL_INT;
132 default:
133 break;
134 }
135
136 return -EINVAL;
137}
138
139static int ad7780_write_raw(struct iio_dev *indio_dev,
140 struct iio_chan_spec const *chan,
141 int val,
142 int val2,
143 long m)
144{
145 struct ad7780_state *st = iio_priv(indio_dev);
146 const struct ad7780_chip_info *chip_info = st->chip_info;
147 unsigned long long vref;
148 unsigned int full_scale, gain;
149
150 if (!chip_info->is_ad778x)
151 return -EINVAL;
152
153 switch (m) {
154 case IIO_CHAN_INFO_SCALE:
155 if (val != 0)
156 return -EINVAL;
157
158 vref = st->int_vref_mv * 1000000LL;
159 full_scale = 1 << (chip_info->channel.scan_type.realbits - 1);
160 gain = DIV_ROUND_CLOSEST_ULL(vref, full_scale);
161 gain = DIV_ROUND_CLOSEST(gain, val2);
162 st->gain = gain;
163 if (gain < AD7780_GAIN_MIDPOINT)
164 gain = 0;
165 else
166 gain = 1;
167 gpiod_set_value(st->gain_gpio, gain);
168 break;
169 case IIO_CHAN_INFO_SAMP_FREQ:
170 if (1000*val + val2/1000 < AD7780_FILTER_MIDPOINT)
171 val = 0;
172 else
173 val = 1;
174 st->odr = ad778x_odr_avail[val];
175 gpiod_set_value(st->filter_gpio, val);
176 break;
177 default:
178 break;
179 }
180
181 return 0;
182}
183
184static int ad7780_postprocess_sample(struct ad_sigma_delta *sigma_delta,
185 unsigned int raw_sample)
186{
187 struct ad7780_state *st = ad_sigma_delta_to_ad7780(sigma_delta);
188 const struct ad7780_chip_info *chip_info = st->chip_info;
189
190 if ((raw_sample & AD7780_ERR) ||
191 ((raw_sample & chip_info->pattern_mask) != chip_info->pattern))
192 return -EIO;
193
194 if (chip_info->is_ad778x) {
195 st->gain = ad778x_gain[raw_sample & AD7780_GAIN];
196 st->odr = ad778x_odr_avail[raw_sample & AD7780_FILTER];
197 }
198
199 return 0;
200}
201
202static const struct ad_sigma_delta_info ad7780_sigma_delta_info = {
203 .set_mode = ad7780_set_mode,
204 .postprocess_sample = ad7780_postprocess_sample,
205 .has_registers = false,
206 .irq_flags = IRQF_TRIGGER_LOW,
207};
208
209#define _AD7780_CHANNEL(_bits, _wordsize, _mask_all) \
210{ \
211 .type = IIO_VOLTAGE, \
212 .indexed = 1, \
213 .channel = 0, \
214 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
215 BIT(IIO_CHAN_INFO_OFFSET), \
216 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
217 .info_mask_shared_by_all = _mask_all, \
218 .scan_index = 1, \
219 .scan_type = { \
220 .sign = 'u', \
221 .realbits = (_bits), \
222 .storagebits = 32, \
223 .shift = (_wordsize) - (_bits), \
224 .endianness = IIO_BE, \
225 }, \
226}
227
228#define AD7780_CHANNEL(_bits, _wordsize) \
229 _AD7780_CHANNEL(_bits, _wordsize, BIT(IIO_CHAN_INFO_SAMP_FREQ))
230#define AD7170_CHANNEL(_bits, _wordsize) \
231 _AD7780_CHANNEL(_bits, _wordsize, 0)
232
233static const struct ad7780_chip_info ad7780_chip_info_tbl[] = {
234 [ID_AD7170] = {
235 .channel = AD7170_CHANNEL(12, 24),
236 .pattern = AD7170_PATTERN_GOOD,
237 .pattern_mask = AD7170_PATTERN_MASK,
238 .is_ad778x = false,
239 },
240 [ID_AD7171] = {
241 .channel = AD7170_CHANNEL(16, 24),
242 .pattern = AD7170_PATTERN_GOOD,
243 .pattern_mask = AD7170_PATTERN_MASK,
244 .is_ad778x = false,
245 },
246 [ID_AD7780] = {
247 .channel = AD7780_CHANNEL(24, 32),
248 .pattern = AD7780_PATTERN_GOOD,
249 .pattern_mask = AD7780_PATTERN_MASK,
250 .is_ad778x = true,
251 },
252 [ID_AD7781] = {
253 .channel = AD7780_CHANNEL(20, 32),
254 .pattern = AD7780_PATTERN_GOOD,
255 .pattern_mask = AD7780_PATTERN_MASK,
256 .is_ad778x = true,
257 },
258};
259
260static const struct iio_info ad7780_info = {
261 .read_raw = ad7780_read_raw,
262 .write_raw = ad7780_write_raw,
263};
264
265static int ad7780_init_gpios(struct device *dev, struct ad7780_state *st)
266{
267 int ret;
268
269 st->powerdown_gpio = devm_gpiod_get_optional(dev,
270 "powerdown",
271 GPIOD_OUT_LOW);
272 if (IS_ERR(st->powerdown_gpio)) {
273 ret = PTR_ERR(st->powerdown_gpio);
274 dev_err(dev, "Failed to request powerdown GPIO: %d\n", ret);
275 return ret;
276 }
277
278 if (!st->chip_info->is_ad778x)
279 return 0;
280
281
282 st->gain_gpio = devm_gpiod_get_optional(dev,
283 "adi,gain",
284 GPIOD_OUT_HIGH);
285 if (IS_ERR(st->gain_gpio)) {
286 ret = PTR_ERR(st->gain_gpio);
287 dev_err(dev, "Failed to request gain GPIO: %d\n", ret);
288 return ret;
289 }
290
291 st->filter_gpio = devm_gpiod_get_optional(dev,
292 "adi,filter",
293 GPIOD_OUT_HIGH);
294 if (IS_ERR(st->filter_gpio)) {
295 ret = PTR_ERR(st->filter_gpio);
296 dev_err(dev, "Failed to request filter GPIO: %d\n", ret);
297 return ret;
298 }
299
300 return 0;
301}
302
303static int ad7780_probe(struct spi_device *spi)
304{
305 struct ad7780_state *st;
306 struct iio_dev *indio_dev;
307 int ret;
308
309 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
310 if (!indio_dev)
311 return -ENOMEM;
312
313 st = iio_priv(indio_dev);
314 st->gain = 1;
315
316 ad_sd_init(&st->sd, indio_dev, spi, &ad7780_sigma_delta_info);
317
318 st->chip_info =
319 &ad7780_chip_info_tbl[spi_get_device_id(spi)->driver_data];
320
321 spi_set_drvdata(spi, indio_dev);
322
323 indio_dev->name = spi_get_device_id(spi)->name;
324 indio_dev->modes = INDIO_DIRECT_MODE;
325 indio_dev->channels = &st->chip_info->channel;
326 indio_dev->num_channels = 1;
327 indio_dev->info = &ad7780_info;
328
329 ret = ad7780_init_gpios(&spi->dev, st);
330 if (ret)
331 return ret;
332
333 st->reg = devm_regulator_get(&spi->dev, "avdd");
334 if (IS_ERR(st->reg))
335 return PTR_ERR(st->reg);
336
337 ret = regulator_enable(st->reg);
338 if (ret) {
339 dev_err(&spi->dev, "Failed to enable specified AVdd supply\n");
340 return ret;
341 }
342
343 ret = ad_sd_setup_buffer_and_trigger(indio_dev);
344 if (ret)
345 goto error_disable_reg;
346
347 ret = iio_device_register(indio_dev);
348 if (ret)
349 goto error_cleanup_buffer_and_trigger;
350
351 return 0;
352
353error_cleanup_buffer_and_trigger:
354 ad_sd_cleanup_buffer_and_trigger(indio_dev);
355error_disable_reg:
356 regulator_disable(st->reg);
357
358 return ret;
359}
360
361static int ad7780_remove(struct spi_device *spi)
362{
363 struct iio_dev *indio_dev = spi_get_drvdata(spi);
364 struct ad7780_state *st = iio_priv(indio_dev);
365
366 iio_device_unregister(indio_dev);
367 ad_sd_cleanup_buffer_and_trigger(indio_dev);
368
369 regulator_disable(st->reg);
370
371 return 0;
372}
373
374static const struct spi_device_id ad7780_id[] = {
375 {"ad7170", ID_AD7170},
376 {"ad7171", ID_AD7171},
377 {"ad7780", ID_AD7780},
378 {"ad7781", ID_AD7781},
379 {}
380};
381MODULE_DEVICE_TABLE(spi, ad7780_id);
382
383static struct spi_driver ad7780_driver = {
384 .driver = {
385 .name = "ad7780",
386 },
387 .probe = ad7780_probe,
388 .remove = ad7780_remove,
389 .id_table = ad7780_id,
390};
391module_spi_driver(ad7780_driver);
392
393MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
394MODULE_DESCRIPTION("Analog Devices AD7780 and similar ADCs");
395MODULE_LICENSE("GPL v2");