1
2
3
4
5
6
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/spi/spi.h>
14#include <linux/err.h>
15#include <linux/module.h>
16
17#include <linux/iio/iio.h>
18#include <linux/iio/sysfs.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#include <linux/iio/adc/ad_sigma_delta.h>
24
25#include <asm/unaligned.h>
26
27
28#define AD_SD_COMM_CHAN_MASK 0x3
29
30#define AD_SD_REG_COMM 0x00
31#define AD_SD_REG_DATA 0x03
32
33
34
35
36
37
38
39void ad_sd_set_comm(struct ad_sigma_delta *sigma_delta, uint8_t comm)
40{
41
42
43 sigma_delta->comm = comm & AD_SD_COMM_CHAN_MASK;
44}
45EXPORT_SYMBOL_GPL(ad_sd_set_comm);
46
47
48
49
50
51
52
53
54
55
56
57int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg,
58 unsigned int size, unsigned int val)
59{
60 uint8_t *data = sigma_delta->tx_buf;
61 struct spi_transfer t = {
62 .tx_buf = data,
63 .len = size + 1,
64 .cs_change = sigma_delta->keep_cs_asserted,
65 };
66 struct spi_message m;
67 int ret;
68
69 data[0] = (reg << sigma_delta->info->addr_shift) | sigma_delta->comm;
70
71 switch (size) {
72 case 3:
73 put_unaligned_be24(val, &data[1]);
74 break;
75 case 2:
76 put_unaligned_be16(val, &data[1]);
77 break;
78 case 1:
79 data[1] = val;
80 break;
81 case 0:
82 break;
83 default:
84 return -EINVAL;
85 }
86
87 spi_message_init(&m);
88 spi_message_add_tail(&t, &m);
89
90 if (sigma_delta->bus_locked)
91 ret = spi_sync_locked(sigma_delta->spi, &m);
92 else
93 ret = spi_sync(sigma_delta->spi, &m);
94
95 return ret;
96}
97EXPORT_SYMBOL_GPL(ad_sd_write_reg);
98
99static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta,
100 unsigned int reg, unsigned int size, uint8_t *val)
101{
102 uint8_t *data = sigma_delta->tx_buf;
103 int ret;
104 struct spi_transfer t[] = {
105 {
106 .tx_buf = data,
107 .len = 1,
108 }, {
109 .rx_buf = val,
110 .len = size,
111 .cs_change = sigma_delta->bus_locked,
112 },
113 };
114 struct spi_message m;
115
116 spi_message_init(&m);
117
118 if (sigma_delta->info->has_registers) {
119 data[0] = reg << sigma_delta->info->addr_shift;
120 data[0] |= sigma_delta->info->read_mask;
121 data[0] |= sigma_delta->comm;
122 spi_message_add_tail(&t[0], &m);
123 }
124 spi_message_add_tail(&t[1], &m);
125
126 if (sigma_delta->bus_locked)
127 ret = spi_sync_locked(sigma_delta->spi, &m);
128 else
129 ret = spi_sync(sigma_delta->spi, &m);
130
131 return ret;
132}
133
134
135
136
137
138
139
140
141
142
143
144int ad_sd_read_reg(struct ad_sigma_delta *sigma_delta,
145 unsigned int reg, unsigned int size, unsigned int *val)
146{
147 int ret;
148
149 ret = ad_sd_read_reg_raw(sigma_delta, reg, size, sigma_delta->rx_buf);
150 if (ret < 0)
151 goto out;
152
153 switch (size) {
154 case 4:
155 *val = get_unaligned_be32(sigma_delta->rx_buf);
156 break;
157 case 3:
158 *val = get_unaligned_be24(sigma_delta->rx_buf);
159 break;
160 case 2:
161 *val = get_unaligned_be16(sigma_delta->rx_buf);
162 break;
163 case 1:
164 *val = sigma_delta->rx_buf[0];
165 break;
166 default:
167 ret = -EINVAL;
168 break;
169 }
170
171out:
172 return ret;
173}
174EXPORT_SYMBOL_GPL(ad_sd_read_reg);
175
176
177
178
179
180
181
182
183
184int ad_sd_reset(struct ad_sigma_delta *sigma_delta,
185 unsigned int reset_length)
186{
187 uint8_t *buf;
188 unsigned int size;
189 int ret;
190
191 size = DIV_ROUND_UP(reset_length, 8);
192 buf = kcalloc(size, sizeof(*buf), GFP_KERNEL);
193 if (!buf)
194 return -ENOMEM;
195
196 memset(buf, 0xff, size);
197 ret = spi_write(sigma_delta->spi, buf, size);
198 kfree(buf);
199
200 return ret;
201}
202EXPORT_SYMBOL_GPL(ad_sd_reset);
203
204int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
205 unsigned int mode, unsigned int channel)
206{
207 int ret;
208 unsigned long timeout;
209
210 ret = ad_sigma_delta_set_channel(sigma_delta, channel);
211 if (ret)
212 return ret;
213
214 spi_bus_lock(sigma_delta->spi->master);
215 sigma_delta->bus_locked = true;
216 sigma_delta->keep_cs_asserted = true;
217 reinit_completion(&sigma_delta->completion);
218
219 ret = ad_sigma_delta_set_mode(sigma_delta, mode);
220 if (ret < 0)
221 goto out;
222
223 sigma_delta->irq_dis = false;
224 enable_irq(sigma_delta->spi->irq);
225 timeout = wait_for_completion_timeout(&sigma_delta->completion, 2 * HZ);
226 if (timeout == 0) {
227 sigma_delta->irq_dis = true;
228 disable_irq_nosync(sigma_delta->spi->irq);
229 ret = -EIO;
230 } else {
231 ret = 0;
232 }
233out:
234 sigma_delta->keep_cs_asserted = false;
235 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
236 sigma_delta->bus_locked = false;
237 spi_bus_unlock(sigma_delta->spi->master);
238
239 return ret;
240}
241EXPORT_SYMBOL_GPL(ad_sd_calibrate);
242
243
244
245
246
247
248
249
250
251int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta,
252 const struct ad_sd_calib_data *cb, unsigned int n)
253{
254 unsigned int i;
255 int ret;
256
257 for (i = 0; i < n; i++) {
258 ret = ad_sd_calibrate(sigma_delta, cb[i].mode, cb[i].channel);
259 if (ret)
260 return ret;
261 }
262
263 return 0;
264}
265EXPORT_SYMBOL_GPL(ad_sd_calibrate_all);
266
267
268
269
270
271
272
273
274
275int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
276 const struct iio_chan_spec *chan, int *val)
277{
278 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
279 unsigned int sample, raw_sample;
280 unsigned int data_reg;
281 int ret = 0;
282
283 if (iio_buffer_enabled(indio_dev))
284 return -EBUSY;
285
286 mutex_lock(&indio_dev->mlock);
287 ad_sigma_delta_set_channel(sigma_delta, chan->address);
288
289 spi_bus_lock(sigma_delta->spi->master);
290 sigma_delta->bus_locked = true;
291 sigma_delta->keep_cs_asserted = true;
292 reinit_completion(&sigma_delta->completion);
293
294 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE);
295
296 sigma_delta->irq_dis = false;
297 enable_irq(sigma_delta->spi->irq);
298 ret = wait_for_completion_interruptible_timeout(
299 &sigma_delta->completion, HZ);
300
301 if (ret == 0)
302 ret = -EIO;
303 if (ret < 0)
304 goto out;
305
306 if (sigma_delta->info->data_reg != 0)
307 data_reg = sigma_delta->info->data_reg;
308 else
309 data_reg = AD_SD_REG_DATA;
310
311 ret = ad_sd_read_reg(sigma_delta, data_reg,
312 DIV_ROUND_UP(chan->scan_type.realbits + chan->scan_type.shift, 8),
313 &raw_sample);
314
315out:
316 if (!sigma_delta->irq_dis) {
317 disable_irq_nosync(sigma_delta->spi->irq);
318 sigma_delta->irq_dis = true;
319 }
320
321 sigma_delta->keep_cs_asserted = false;
322 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
323 sigma_delta->bus_locked = false;
324 spi_bus_unlock(sigma_delta->spi->master);
325 mutex_unlock(&indio_dev->mlock);
326
327 if (ret)
328 return ret;
329
330 sample = raw_sample >> chan->scan_type.shift;
331 sample &= (1 << chan->scan_type.realbits) - 1;
332 *val = sample;
333
334 ret = ad_sigma_delta_postprocess_sample(sigma_delta, raw_sample);
335 if (ret)
336 return ret;
337
338 return IIO_VAL_INT;
339}
340EXPORT_SYMBOL_GPL(ad_sigma_delta_single_conversion);
341
342static int ad_sd_buffer_postenable(struct iio_dev *indio_dev)
343{
344 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
345 unsigned int channel;
346 int ret;
347
348 channel = find_first_bit(indio_dev->active_scan_mask,
349 indio_dev->masklength);
350 ret = ad_sigma_delta_set_channel(sigma_delta,
351 indio_dev->channels[channel].address);
352 if (ret)
353 return ret;
354
355 spi_bus_lock(sigma_delta->spi->master);
356 sigma_delta->bus_locked = true;
357 sigma_delta->keep_cs_asserted = true;
358
359 ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS);
360 if (ret)
361 goto err_unlock;
362
363 sigma_delta->irq_dis = false;
364 enable_irq(sigma_delta->spi->irq);
365
366 return 0;
367
368err_unlock:
369 spi_bus_unlock(sigma_delta->spi->master);
370
371 return ret;
372}
373
374static int ad_sd_buffer_postdisable(struct iio_dev *indio_dev)
375{
376 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
377
378 reinit_completion(&sigma_delta->completion);
379 wait_for_completion_timeout(&sigma_delta->completion, HZ);
380
381 if (!sigma_delta->irq_dis) {
382 disable_irq_nosync(sigma_delta->spi->irq);
383 sigma_delta->irq_dis = true;
384 }
385
386 sigma_delta->keep_cs_asserted = false;
387 ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
388
389 sigma_delta->bus_locked = false;
390 return spi_bus_unlock(sigma_delta->spi->master);
391}
392
393static irqreturn_t ad_sd_trigger_handler(int irq, void *p)
394{
395 struct iio_poll_func *pf = p;
396 struct iio_dev *indio_dev = pf->indio_dev;
397 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
398 uint8_t *data = sigma_delta->rx_buf;
399 unsigned int reg_size;
400 unsigned int data_reg;
401
402 reg_size = indio_dev->channels[0].scan_type.realbits +
403 indio_dev->channels[0].scan_type.shift;
404 reg_size = DIV_ROUND_UP(reg_size, 8);
405
406 if (sigma_delta->info->data_reg != 0)
407 data_reg = sigma_delta->info->data_reg;
408 else
409 data_reg = AD_SD_REG_DATA;
410
411 switch (reg_size) {
412 case 4:
413 case 2:
414 case 1:
415 ad_sd_read_reg_raw(sigma_delta, data_reg, reg_size, &data[0]);
416 break;
417 case 3:
418
419
420 ad_sd_read_reg_raw(sigma_delta, data_reg, reg_size, &data[1]);
421 break;
422 }
423
424 iio_push_to_buffers_with_timestamp(indio_dev, data, pf->timestamp);
425
426 iio_trigger_notify_done(indio_dev->trig);
427 sigma_delta->irq_dis = false;
428 enable_irq(sigma_delta->spi->irq);
429
430 return IRQ_HANDLED;
431}
432
433static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = {
434 .postenable = &ad_sd_buffer_postenable,
435 .postdisable = &ad_sd_buffer_postdisable,
436 .validate_scan_mask = &iio_validate_scan_mask_onehot,
437};
438
439static irqreturn_t ad_sd_data_rdy_trig_poll(int irq, void *private)
440{
441 struct ad_sigma_delta *sigma_delta = private;
442
443 complete(&sigma_delta->completion);
444 disable_irq_nosync(irq);
445 sigma_delta->irq_dis = true;
446 iio_trigger_poll(sigma_delta->trig);
447
448 return IRQ_HANDLED;
449}
450
451
452
453
454
455
456
457
458
459int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)
460{
461 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
462
463 if (sigma_delta->trig != trig)
464 return -EINVAL;
465
466 return 0;
467}
468EXPORT_SYMBOL_GPL(ad_sd_validate_trigger);
469
470static const struct iio_trigger_ops ad_sd_trigger_ops = {
471};
472
473static int devm_ad_sd_probe_trigger(struct device *dev, struct iio_dev *indio_dev)
474{
475 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
476 int ret;
477
478 if (dev != &sigma_delta->spi->dev) {
479 dev_err(dev, "Trigger parent should be '%s', got '%s'\n",
480 dev_name(dev), dev_name(&sigma_delta->spi->dev));
481 return -EFAULT;
482 }
483
484 sigma_delta->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
485 iio_device_id(indio_dev));
486 if (sigma_delta->trig == NULL)
487 return -ENOMEM;
488
489 sigma_delta->trig->ops = &ad_sd_trigger_ops;
490 init_completion(&sigma_delta->completion);
491
492 sigma_delta->irq_dis = true;
493 ret = devm_request_irq(dev, sigma_delta->spi->irq,
494 ad_sd_data_rdy_trig_poll,
495 sigma_delta->info->irq_flags | IRQF_NO_AUTOEN,
496 indio_dev->name,
497 sigma_delta);
498 if (ret)
499 return ret;
500
501 iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta);
502
503 ret = devm_iio_trigger_register(dev, sigma_delta->trig);
504 if (ret)
505 return ret;
506
507
508 indio_dev->trig = iio_trigger_get(sigma_delta->trig);
509
510 return 0;
511}
512
513
514
515
516
517
518int devm_ad_sd_setup_buffer_and_trigger(struct device *dev, struct iio_dev *indio_dev)
519{
520 int ret;
521
522 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
523 &iio_pollfunc_store_time,
524 &ad_sd_trigger_handler,
525 &ad_sd_buffer_setup_ops);
526 if (ret)
527 return ret;
528
529 return devm_ad_sd_probe_trigger(dev, indio_dev);
530}
531EXPORT_SYMBOL_GPL(devm_ad_sd_setup_buffer_and_trigger);
532
533
534
535
536
537
538
539
540
541
542
543int ad_sd_init(struct ad_sigma_delta *sigma_delta, struct iio_dev *indio_dev,
544 struct spi_device *spi, const struct ad_sigma_delta_info *info)
545{
546 sigma_delta->spi = spi;
547 sigma_delta->info = info;
548 iio_device_set_drvdata(indio_dev, sigma_delta);
549
550 return 0;
551}
552EXPORT_SYMBOL_GPL(ad_sd_init);
553
554MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
555MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs");
556MODULE_LICENSE("GPL v2");
557