1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * AD7766/AD7767 SPI ADC driver |
4 | * |
5 | * Copyright 2016 Analog Devices Inc. |
6 | */ |
7 | |
8 | #include <linux/clk.h> |
9 | #include <linux/delay.h> |
10 | #include <linux/device.h> |
11 | #include <linux/err.h> |
12 | #include <linux/gpio/consumer.h> |
13 | #include <linux/module.h> |
14 | #include <linux/regulator/consumer.h> |
15 | #include <linux/slab.h> |
16 | #include <linux/spi/spi.h> |
17 | |
18 | #include <linux/iio/iio.h> |
19 | #include <linux/iio/buffer.h> |
20 | #include <linux/iio/trigger.h> |
21 | #include <linux/iio/trigger_consumer.h> |
22 | #include <linux/iio/triggered_buffer.h> |
23 | |
24 | struct ad7766_chip_info { |
25 | unsigned int decimation_factor; |
26 | }; |
27 | |
28 | enum { |
29 | AD7766_SUPPLY_AVDD = 0, |
30 | AD7766_SUPPLY_DVDD = 1, |
31 | AD7766_SUPPLY_VREF = 2, |
32 | AD7766_NUM_SUPPLIES = 3 |
33 | }; |
34 | |
35 | struct ad7766 { |
36 | const struct ad7766_chip_info *chip_info; |
37 | struct spi_device *spi; |
38 | struct clk *mclk; |
39 | struct gpio_desc *pd_gpio; |
40 | struct regulator_bulk_data reg[AD7766_NUM_SUPPLIES]; |
41 | |
42 | struct iio_trigger *trig; |
43 | |
44 | struct spi_transfer xfer; |
45 | struct spi_message msg; |
46 | |
47 | /* |
48 | * DMA (thus cache coherency maintenance) may require the |
49 | * transfer buffers to live in their own cache lines. |
50 | * Make the buffer large enough for one 24 bit sample and one 64 bit |
51 | * aligned 64 bit timestamp. |
52 | */ |
53 | unsigned char data[ALIGN(3, sizeof(s64)) + sizeof(s64)] __aligned(IIO_DMA_MINALIGN); |
54 | }; |
55 | |
56 | /* |
57 | * AD7766 and AD7767 variations are interface compatible, the main difference is |
58 | * analog performance. Both parts will use the same ID. |
59 | */ |
60 | enum ad7766_device_ids { |
61 | ID_AD7766, |
62 | ID_AD7766_1, |
63 | ID_AD7766_2, |
64 | }; |
65 | |
66 | static irqreturn_t ad7766_trigger_handler(int irq, void *p) |
67 | { |
68 | struct iio_poll_func *pf = p; |
69 | struct iio_dev *indio_dev = pf->indio_dev; |
70 | struct ad7766 *ad7766 = iio_priv(indio_dev); |
71 | int ret; |
72 | |
73 | ret = spi_sync(spi: ad7766->spi, message: &ad7766->msg); |
74 | if (ret < 0) |
75 | goto done; |
76 | |
77 | iio_push_to_buffers_with_timestamp(indio_dev, data: ad7766->data, |
78 | timestamp: pf->timestamp); |
79 | done: |
80 | iio_trigger_notify_done(trig: indio_dev->trig); |
81 | |
82 | return IRQ_HANDLED; |
83 | } |
84 | |
85 | static int ad7766_preenable(struct iio_dev *indio_dev) |
86 | { |
87 | struct ad7766 *ad7766 = iio_priv(indio_dev); |
88 | int ret; |
89 | |
90 | ret = regulator_bulk_enable(ARRAY_SIZE(ad7766->reg), consumers: ad7766->reg); |
91 | if (ret < 0) { |
92 | dev_err(&ad7766->spi->dev, "Failed to enable supplies: %d\n" , |
93 | ret); |
94 | return ret; |
95 | } |
96 | |
97 | ret = clk_prepare_enable(clk: ad7766->mclk); |
98 | if (ret < 0) { |
99 | dev_err(&ad7766->spi->dev, "Failed to enable MCLK: %d\n" , ret); |
100 | regulator_bulk_disable(ARRAY_SIZE(ad7766->reg), consumers: ad7766->reg); |
101 | return ret; |
102 | } |
103 | |
104 | gpiod_set_value(desc: ad7766->pd_gpio, value: 0); |
105 | |
106 | return 0; |
107 | } |
108 | |
109 | static int ad7766_postdisable(struct iio_dev *indio_dev) |
110 | { |
111 | struct ad7766 *ad7766 = iio_priv(indio_dev); |
112 | |
113 | gpiod_set_value(desc: ad7766->pd_gpio, value: 1); |
114 | |
115 | /* |
116 | * The PD pin is synchronous to the clock, so give it some time to |
117 | * notice the change before we disable the clock. |
118 | */ |
119 | msleep(msecs: 20); |
120 | |
121 | clk_disable_unprepare(clk: ad7766->mclk); |
122 | regulator_bulk_disable(ARRAY_SIZE(ad7766->reg), consumers: ad7766->reg); |
123 | |
124 | return 0; |
125 | } |
126 | |
127 | static int ad7766_read_raw(struct iio_dev *indio_dev, |
128 | const struct iio_chan_spec *chan, int *val, int *val2, long info) |
129 | { |
130 | struct ad7766 *ad7766 = iio_priv(indio_dev); |
131 | struct regulator *vref = ad7766->reg[AD7766_SUPPLY_VREF].consumer; |
132 | int scale_uv; |
133 | |
134 | switch (info) { |
135 | case IIO_CHAN_INFO_SCALE: |
136 | scale_uv = regulator_get_voltage(regulator: vref); |
137 | if (scale_uv < 0) |
138 | return scale_uv; |
139 | *val = scale_uv / 1000; |
140 | *val2 = chan->scan_type.realbits; |
141 | return IIO_VAL_FRACTIONAL_LOG2; |
142 | case IIO_CHAN_INFO_SAMP_FREQ: |
143 | *val = clk_get_rate(clk: ad7766->mclk) / |
144 | ad7766->chip_info->decimation_factor; |
145 | return IIO_VAL_INT; |
146 | } |
147 | return -EINVAL; |
148 | } |
149 | |
150 | static const struct iio_chan_spec ad7766_channels[] = { |
151 | { |
152 | .type = IIO_VOLTAGE, |
153 | .indexed = 1, |
154 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), |
155 | .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), |
156 | .scan_type = { |
157 | .sign = 's', |
158 | .realbits = 24, |
159 | .storagebits = 32, |
160 | .endianness = IIO_BE, |
161 | }, |
162 | }, |
163 | IIO_CHAN_SOFT_TIMESTAMP(1), |
164 | }; |
165 | |
166 | static const struct ad7766_chip_info ad7766_chip_info[] = { |
167 | [ID_AD7766] = { |
168 | .decimation_factor = 8, |
169 | }, |
170 | [ID_AD7766_1] = { |
171 | .decimation_factor = 16, |
172 | }, |
173 | [ID_AD7766_2] = { |
174 | .decimation_factor = 32, |
175 | }, |
176 | }; |
177 | |
178 | static const struct iio_buffer_setup_ops ad7766_buffer_setup_ops = { |
179 | .preenable = &ad7766_preenable, |
180 | .postdisable = &ad7766_postdisable, |
181 | }; |
182 | |
183 | static const struct iio_info ad7766_info = { |
184 | .read_raw = &ad7766_read_raw, |
185 | }; |
186 | |
187 | static irqreturn_t ad7766_irq(int irq, void *private) |
188 | { |
189 | iio_trigger_poll(trig: private); |
190 | return IRQ_HANDLED; |
191 | } |
192 | |
193 | static int ad7766_set_trigger_state(struct iio_trigger *trig, bool enable) |
194 | { |
195 | struct ad7766 *ad7766 = iio_trigger_get_drvdata(trig); |
196 | |
197 | if (enable) |
198 | enable_irq(irq: ad7766->spi->irq); |
199 | else |
200 | disable_irq(irq: ad7766->spi->irq); |
201 | |
202 | return 0; |
203 | } |
204 | |
205 | static const struct iio_trigger_ops ad7766_trigger_ops = { |
206 | .set_trigger_state = ad7766_set_trigger_state, |
207 | .validate_device = iio_trigger_validate_own_device, |
208 | }; |
209 | |
210 | static int ad7766_probe(struct spi_device *spi) |
211 | { |
212 | const struct spi_device_id *id = spi_get_device_id(sdev: spi); |
213 | struct iio_dev *indio_dev; |
214 | struct ad7766 *ad7766; |
215 | int ret; |
216 | |
217 | indio_dev = devm_iio_device_alloc(parent: &spi->dev, sizeof_priv: sizeof(*ad7766)); |
218 | if (!indio_dev) |
219 | return -ENOMEM; |
220 | |
221 | ad7766 = iio_priv(indio_dev); |
222 | ad7766->chip_info = &ad7766_chip_info[id->driver_data]; |
223 | |
224 | ad7766->mclk = devm_clk_get(dev: &spi->dev, id: "mclk" ); |
225 | if (IS_ERR(ptr: ad7766->mclk)) |
226 | return PTR_ERR(ptr: ad7766->mclk); |
227 | |
228 | ad7766->reg[AD7766_SUPPLY_AVDD].supply = "avdd" ; |
229 | ad7766->reg[AD7766_SUPPLY_DVDD].supply = "dvdd" ; |
230 | ad7766->reg[AD7766_SUPPLY_VREF].supply = "vref" ; |
231 | |
232 | ret = devm_regulator_bulk_get(dev: &spi->dev, ARRAY_SIZE(ad7766->reg), |
233 | consumers: ad7766->reg); |
234 | if (ret) |
235 | return ret; |
236 | |
237 | ad7766->pd_gpio = devm_gpiod_get_optional(dev: &spi->dev, con_id: "powerdown" , |
238 | flags: GPIOD_OUT_HIGH); |
239 | if (IS_ERR(ptr: ad7766->pd_gpio)) |
240 | return PTR_ERR(ptr: ad7766->pd_gpio); |
241 | |
242 | indio_dev->name = spi_get_device_id(sdev: spi)->name; |
243 | indio_dev->modes = INDIO_DIRECT_MODE; |
244 | indio_dev->channels = ad7766_channels; |
245 | indio_dev->num_channels = ARRAY_SIZE(ad7766_channels); |
246 | indio_dev->info = &ad7766_info; |
247 | |
248 | if (spi->irq > 0) { |
249 | ad7766->trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d" , |
250 | indio_dev->name, |
251 | iio_device_id(indio_dev)); |
252 | if (!ad7766->trig) |
253 | return -ENOMEM; |
254 | |
255 | ad7766->trig->ops = &ad7766_trigger_ops; |
256 | iio_trigger_set_drvdata(trig: ad7766->trig, data: ad7766); |
257 | |
258 | /* |
259 | * The device generates interrupts as long as it is powered up. |
260 | * Some platforms might not allow the option to power it down so |
261 | * don't enable the interrupt to avoid extra load on the system |
262 | */ |
263 | ret = devm_request_irq(dev: &spi->dev, irq: spi->irq, handler: ad7766_irq, |
264 | IRQF_TRIGGER_FALLING | IRQF_NO_AUTOEN, |
265 | devname: dev_name(dev: &spi->dev), |
266 | dev_id: ad7766->trig); |
267 | if (ret < 0) |
268 | return ret; |
269 | |
270 | ret = devm_iio_trigger_register(dev: &spi->dev, trig_info: ad7766->trig); |
271 | if (ret) |
272 | return ret; |
273 | } |
274 | |
275 | ad7766->spi = spi; |
276 | |
277 | /* First byte always 0 */ |
278 | ad7766->xfer.rx_buf = &ad7766->data[1]; |
279 | ad7766->xfer.len = 3; |
280 | |
281 | spi_message_init(m: &ad7766->msg); |
282 | spi_message_add_tail(t: &ad7766->xfer, m: &ad7766->msg); |
283 | |
284 | ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, |
285 | &iio_pollfunc_store_time, &ad7766_trigger_handler, |
286 | &ad7766_buffer_setup_ops); |
287 | if (ret) |
288 | return ret; |
289 | |
290 | return devm_iio_device_register(&spi->dev, indio_dev); |
291 | } |
292 | |
293 | static const struct spi_device_id ad7766_id[] = { |
294 | {"ad7766" , ID_AD7766}, |
295 | {"ad7766-1" , ID_AD7766_1}, |
296 | {"ad7766-2" , ID_AD7766_2}, |
297 | {"ad7767" , ID_AD7766}, |
298 | {"ad7767-1" , ID_AD7766_1}, |
299 | {"ad7767-2" , ID_AD7766_2}, |
300 | {} |
301 | }; |
302 | MODULE_DEVICE_TABLE(spi, ad7766_id); |
303 | |
304 | static struct spi_driver ad7766_driver = { |
305 | .driver = { |
306 | .name = "ad7766" , |
307 | }, |
308 | .probe = ad7766_probe, |
309 | .id_table = ad7766_id, |
310 | }; |
311 | module_spi_driver(ad7766_driver); |
312 | |
313 | MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>" ); |
314 | MODULE_DESCRIPTION("Analog Devices AD7766 and AD7767 ADCs driver support" ); |
315 | MODULE_LICENSE("GPL v2" ); |
316 | |