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->data;
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->data;
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->data);
150 if (ret < 0)
151 goto out;
152
153 switch (size) {
154 case 4:
155 *val = get_unaligned_be32(sigma_delta->data);
156 break;
157 case 3:
158 *val = get_unaligned_be24(&sigma_delta->data[0]);
159 break;
160 case 2:
161 *val = get_unaligned_be16(sigma_delta->data);
162 break;
163 case 1:
164 *val = sigma_delta->data[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 unsigned int reg_size;
399 unsigned int data_reg;
400 uint8_t data[16];
401
402 memset(data, 0x00, 16);
403
404 reg_size = indio_dev->channels[0].scan_type.realbits +
405 indio_dev->channels[0].scan_type.shift;
406 reg_size = DIV_ROUND_UP(reg_size, 8);
407
408 if (sigma_delta->info->data_reg != 0)
409 data_reg = sigma_delta->info->data_reg;
410 else
411 data_reg = AD_SD_REG_DATA;
412
413 switch (reg_size) {
414 case 4:
415 case 2:
416 case 1:
417 ad_sd_read_reg_raw(sigma_delta, data_reg, reg_size, &data[0]);
418 break;
419 case 3:
420
421
422 ad_sd_read_reg_raw(sigma_delta, data_reg, reg_size, &data[1]);
423 break;
424 }
425
426 iio_push_to_buffers_with_timestamp(indio_dev, data, pf->timestamp);
427
428 iio_trigger_notify_done(indio_dev->trig);
429 sigma_delta->irq_dis = false;
430 enable_irq(sigma_delta->spi->irq);
431
432 return IRQ_HANDLED;
433}
434
435static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = {
436 .postenable = &ad_sd_buffer_postenable,
437 .postdisable = &ad_sd_buffer_postdisable,
438 .validate_scan_mask = &iio_validate_scan_mask_onehot,
439};
440
441static irqreturn_t ad_sd_data_rdy_trig_poll(int irq, void *private)
442{
443 struct ad_sigma_delta *sigma_delta = private;
444
445 complete(&sigma_delta->completion);
446 disable_irq_nosync(irq);
447 sigma_delta->irq_dis = true;
448 iio_trigger_poll(sigma_delta->trig);
449
450 return IRQ_HANDLED;
451}
452
453
454
455
456
457
458
459
460
461int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)
462{
463 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
464
465 if (sigma_delta->trig != trig)
466 return -EINVAL;
467
468 return 0;
469}
470EXPORT_SYMBOL_GPL(ad_sd_validate_trigger);
471
472static const struct iio_trigger_ops ad_sd_trigger_ops = {
473};
474
475static int ad_sd_probe_trigger(struct iio_dev *indio_dev)
476{
477 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
478 int ret;
479
480 sigma_delta->trig = iio_trigger_alloc("%s-dev%d", indio_dev->name,
481 indio_dev->id);
482 if (sigma_delta->trig == NULL) {
483 ret = -ENOMEM;
484 goto error_ret;
485 }
486 sigma_delta->trig->ops = &ad_sd_trigger_ops;
487 init_completion(&sigma_delta->completion);
488
489 ret = request_irq(sigma_delta->spi->irq,
490 ad_sd_data_rdy_trig_poll,
491 sigma_delta->info->irq_flags,
492 indio_dev->name,
493 sigma_delta);
494 if (ret)
495 goto error_free_trig;
496
497 if (!sigma_delta->irq_dis) {
498 sigma_delta->irq_dis = true;
499 disable_irq_nosync(sigma_delta->spi->irq);
500 }
501 sigma_delta->trig->dev.parent = &sigma_delta->spi->dev;
502 iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta);
503
504 ret = iio_trigger_register(sigma_delta->trig);
505 if (ret)
506 goto error_free_irq;
507
508
509 indio_dev->trig = iio_trigger_get(sigma_delta->trig);
510
511 return 0;
512
513error_free_irq:
514 free_irq(sigma_delta->spi->irq, sigma_delta);
515error_free_trig:
516 iio_trigger_free(sigma_delta->trig);
517error_ret:
518 return ret;
519}
520
521static void ad_sd_remove_trigger(struct iio_dev *indio_dev)
522{
523 struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
524
525 iio_trigger_unregister(sigma_delta->trig);
526 free_irq(sigma_delta->spi->irq, sigma_delta);
527 iio_trigger_free(sigma_delta->trig);
528}
529
530
531
532
533
534int ad_sd_setup_buffer_and_trigger(struct iio_dev *indio_dev)
535{
536 int ret;
537
538 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
539 &ad_sd_trigger_handler, &ad_sd_buffer_setup_ops);
540 if (ret)
541 return ret;
542
543 ret = ad_sd_probe_trigger(indio_dev);
544 if (ret) {
545 iio_triggered_buffer_cleanup(indio_dev);
546 return ret;
547 }
548
549 return 0;
550}
551EXPORT_SYMBOL_GPL(ad_sd_setup_buffer_and_trigger);
552
553
554
555
556
557void ad_sd_cleanup_buffer_and_trigger(struct iio_dev *indio_dev)
558{
559 ad_sd_remove_trigger(indio_dev);
560 iio_triggered_buffer_cleanup(indio_dev);
561}
562EXPORT_SYMBOL_GPL(ad_sd_cleanup_buffer_and_trigger);
563
564
565
566
567
568
569
570
571
572
573
574int ad_sd_init(struct ad_sigma_delta *sigma_delta, struct iio_dev *indio_dev,
575 struct spi_device *spi, const struct ad_sigma_delta_info *info)
576{
577 sigma_delta->spi = spi;
578 sigma_delta->info = info;
579 iio_device_set_drvdata(indio_dev, sigma_delta);
580
581 return 0;
582}
583EXPORT_SYMBOL_GPL(ad_sd_init);
584
585MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
586MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs");
587MODULE_LICENSE("GPL v2");
588