1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Support code for Analog Devices Sigma-Delta ADCs
4  *
5  * Copyright 2012 Analog Devices Inc.
6  *  Author: Lars-Peter Clausen <lars@metafoo.de>
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  * ad_sd_set_comm() - Set communications register
35  *
36  * @sigma_delta: The sigma delta device
37  * @comm: New value for the communications register
38  */
ad_sd_set_comm(struct ad_sigma_delta * sigma_delta,uint8_t comm)39 void ad_sd_set_comm(struct ad_sigma_delta *sigma_delta, uint8_t comm)
40 {
41 	/* Some variants use the lower two bits of the communications register
42 	 * to select the channel */
43 	sigma_delta->comm = comm & AD_SD_COMM_CHAN_MASK;
44 }
45 EXPORT_SYMBOL_GPL(ad_sd_set_comm);
46 
47 /**
48  * ad_sd_write_reg() - Write a register
49  *
50  * @sigma_delta: The sigma delta device
51  * @reg: Address of the register
52  * @size: Size of the register (0-3)
53  * @val: Value to write to the register
54  *
55  * Returns 0 on success, an error code otherwise.
56  **/
ad_sd_write_reg(struct ad_sigma_delta * sigma_delta,unsigned int reg,unsigned int size,unsigned int val)57 int 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 }
97 EXPORT_SYMBOL_GPL(ad_sd_write_reg);
98 
ad_sd_read_reg_raw(struct ad_sigma_delta * sigma_delta,unsigned int reg,unsigned int size,uint8_t * val)99 static 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  * ad_sd_read_reg() - Read a register
136  *
137  * @sigma_delta: The sigma delta device
138  * @reg: Address of the register
139  * @size: Size of the register (1-4)
140  * @val: Read value
141  *
142  * Returns 0 on success, an error code otherwise.
143  **/
ad_sd_read_reg(struct ad_sigma_delta * sigma_delta,unsigned int reg,unsigned int size,unsigned int * val)144 int 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 
171 out:
172 	return ret;
173 }
174 EXPORT_SYMBOL_GPL(ad_sd_read_reg);
175 
176 /**
177  * ad_sd_reset() - Reset the serial interface
178  *
179  * @sigma_delta: The sigma delta device
180  * @reset_length: Number of SCLKs with DIN = 1
181  *
182  * Returns 0 on success, an error code otherwise.
183  **/
ad_sd_reset(struct ad_sigma_delta * sigma_delta,unsigned int reset_length)184 int 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 }
202 EXPORT_SYMBOL_GPL(ad_sd_reset);
203 
ad_sd_calibrate(struct ad_sigma_delta * sigma_delta,unsigned int mode,unsigned int channel)204 int 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 	}
233 out:
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 }
241 EXPORT_SYMBOL_GPL(ad_sd_calibrate);
242 
243 /**
244  * ad_sd_calibrate_all() - Performs channel calibration
245  * @sigma_delta: The sigma delta device
246  * @cb: Array of channels and calibration type to perform
247  * @n: Number of items in cb
248  *
249  * Returns 0 on success, an error code otherwise.
250  **/
ad_sd_calibrate_all(struct ad_sigma_delta * sigma_delta,const struct ad_sd_calib_data * cb,unsigned int n)251 int 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 }
265 EXPORT_SYMBOL_GPL(ad_sd_calibrate_all);
266 
267 /**
268  * ad_sigma_delta_single_conversion() - Performs a single data conversion
269  * @indio_dev: The IIO device
270  * @chan: The conversion is done for this channel
271  * @val: Pointer to the location where to store the read value
272  *
273  * Returns: 0 on success, an error value otherwise.
274  */
ad_sigma_delta_single_conversion(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,int * val)275 int 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 
315 out:
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 }
340 EXPORT_SYMBOL_GPL(ad_sigma_delta_single_conversion);
341 
ad_sd_buffer_postenable(struct iio_dev * indio_dev)342 static 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 
368 err_unlock:
369 	spi_bus_unlock(sigma_delta->spi->master);
370 
371 	return ret;
372 }
373 
ad_sd_buffer_postdisable(struct iio_dev * indio_dev)374 static 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 
ad_sd_trigger_handler(int irq,void * p)393 static 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 		/* We store 24 bit samples in a 32 bit word. Keep the upper
419 		 * byte set to zero. */
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 
433 static 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 
ad_sd_data_rdy_trig_poll(int irq,void * private)439 static 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  * ad_sd_validate_trigger() - validate_trigger callback for ad_sigma_delta devices
453  * @indio_dev: The IIO device
454  * @trig: The new trigger
455  *
456  * Returns: 0 if the 'trig' matches the trigger registered by the ad_sigma_delta
457  * device, -EINVAL otherwise.
458  */
ad_sd_validate_trigger(struct iio_dev * indio_dev,struct iio_trigger * trig)459 int 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 }
468 EXPORT_SYMBOL_GPL(ad_sd_validate_trigger);
469 
470 static const struct iio_trigger_ops ad_sd_trigger_ops = {
471 };
472 
devm_ad_sd_probe_trigger(struct device * dev,struct iio_dev * indio_dev)473 static 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 	/* select default trigger */
508 	indio_dev->trig = iio_trigger_get(sigma_delta->trig);
509 
510 	return 0;
511 }
512 
513 /**
514  * devm_ad_sd_setup_buffer_and_trigger() - Device-managed buffer & trigger setup
515  * @dev: Device object to which to bind the life-time of the resources attached
516  * @indio_dev: The IIO device
517  */
devm_ad_sd_setup_buffer_and_trigger(struct device * dev,struct iio_dev * indio_dev)518 int 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 }
531 EXPORT_SYMBOL_GPL(devm_ad_sd_setup_buffer_and_trigger);
532 
533 /**
534  * ad_sd_init() - Initializes a ad_sigma_delta struct
535  * @sigma_delta: The ad_sigma_delta device
536  * @indio_dev: The IIO device which the Sigma Delta device is used for
537  * @spi: The SPI device for the ad_sigma_delta device
538  * @info: Device specific callbacks and options
539  *
540  * This function needs to be called before any other operations are performed on
541  * the ad_sigma_delta struct.
542  */
ad_sd_init(struct ad_sigma_delta * sigma_delta,struct iio_dev * indio_dev,struct spi_device * spi,const struct ad_sigma_delta_info * info)543 int 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 }
552 EXPORT_SYMBOL_GPL(ad_sd_init);
553 
554 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
555 MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs");
556 MODULE_LICENSE("GPL v2");
557