ti-adc108s102.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * TI ADC108S102 SPI ADC driver
  4 *
  5 * Copyright (c) 2013-2015 Intel Corporation.
  6 * Copyright (c) 2017 Siemens AG
  7 *
  8 * This IIO device driver is designed to work with the following
  9 * analog to digital converters from Texas Instruments:
 10 *  ADC108S102
 11 *  ADC128S102
 12 * The communication with ADC chip is via the SPI bus (mode 3).
 13 */
 14
 15#include <linux/acpi.h>
 16#include <linux/iio/iio.h>
 17#include <linux/iio/buffer.h>
 18#include <linux/iio/types.h>
 19#include <linux/iio/triggered_buffer.h>
 20#include <linux/iio/trigger_consumer.h>
 21#include <linux/interrupt.h>
 22#include <linux/module.h>
 23#include <linux/mod_devicetable.h>
 24#include <linux/property.h>
 25#include <linux/regulator/consumer.h>
 26#include <linux/spi/spi.h>
 27
 28/*
 29 * In case of ACPI, we use the hard-wired 5000 mV of the Galileo and IOT2000
 30 * boards as default for the reference pin VA. Device tree users encode that
 31 * via the vref-supply regulator.
 32 */
 33#define ADC108S102_VA_MV_ACPI_DEFAULT	5000
 34
 35/*
 36 * Defining the ADC resolution being 12 bits, we can use the same driver for
 37 * both ADC108S102 (10 bits resolution) and ADC128S102 (12 bits resolution)
 38 * chips. The ADC108S102 effectively returns a 12-bit result with the 2
 39 * least-significant bits unset.
 40 */
 41#define ADC108S102_BITS		12
 42#define ADC108S102_MAX_CHANNELS	8
 43
 44/*
 45 * 16-bit SPI command format:
 46 *   [15:14] Ignored
 47 *   [13:11] 3-bit channel address
 48 *   [10:0]  Ignored
 49 */
 50#define ADC108S102_CMD(ch)		((u16)(ch) << 11)
 51
 52/*
 53 * 16-bit SPI response format:
 54 *   [15:12] Zeros
 55 *   [11:0]  12-bit ADC sample (for ADC108S102, [1:0] will always be 0).
 56 */
 57#define ADC108S102_RES_DATA(res)	((u16)res & GENMASK(11, 0))
 58
 59struct adc108s102_state {
 60	struct spi_device		*spi;
 61	u32				va_millivolt;
 62	/* SPI transfer used by triggered buffer handler*/
 63	struct spi_transfer		ring_xfer;
 64	/* SPI transfer used by direct scan */
 65	struct spi_transfer		scan_single_xfer;
 66	/* SPI message used by ring_xfer SPI transfer */
 67	struct spi_message		ring_msg;
 68	/* SPI message used by scan_single_xfer SPI transfer */
 69	struct spi_message		scan_single_msg;
 70
 71	/*
 72	 * SPI message buffers:
 73	 *  tx_buf: |C0|C1|C2|C3|C4|C5|C6|C7|XX|
 74	 *  rx_buf: |XX|R0|R1|R2|R3|R4|R5|R6|R7|tt|tt|tt|tt|
 75	 *
 76	 *  tx_buf: 8 channel read commands, plus 1 dummy command
 77	 *  rx_buf: 1 dummy response, 8 channel responses
 78	 */
 79	__be16				rx_buf[9] __aligned(IIO_DMA_MINALIGN);
 80	__be16				tx_buf[9] __aligned(IIO_DMA_MINALIGN);
 81};
 82
 83#define ADC108S102_V_CHAN(index)					\
 84	{								\
 85		.type = IIO_VOLTAGE,					\
 86		.indexed = 1,						\
 87		.channel = index,					\
 88		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |		\
 89			BIT(IIO_CHAN_INFO_SCALE),			\
 90		.address = index,					\
 91		.scan_index = index,					\
 92		.scan_type = {						\
 93			.sign = 'u',					\
 94			.realbits = ADC108S102_BITS,			\
 95			.storagebits = 16,				\
 96			.endianness = IIO_BE,				\
 97		},							\
 98	}
 99
100static const struct iio_chan_spec adc108s102_channels[] = {
101	ADC108S102_V_CHAN(0),
102	ADC108S102_V_CHAN(1),
103	ADC108S102_V_CHAN(2),
104	ADC108S102_V_CHAN(3),
105	ADC108S102_V_CHAN(4),
106	ADC108S102_V_CHAN(5),
107	ADC108S102_V_CHAN(6),
108	ADC108S102_V_CHAN(7),
109	IIO_CHAN_SOFT_TIMESTAMP(8),
110};
111
112static int adc108s102_update_scan_mode(struct iio_dev *indio_dev,
113		unsigned long const *active_scan_mask)
114{
115	struct adc108s102_state *st = iio_priv(indio_dev);
116	unsigned int bit, cmds;
117
118	/*
119	 * Fill in the first x shorts of tx_buf with the number of channels
120	 * enabled for sampling by the triggered buffer.
121	 */
122	cmds = 0;
123	for_each_set_bit(bit, active_scan_mask, ADC108S102_MAX_CHANNELS)
124		st->tx_buf[cmds++] = cpu_to_be16(ADC108S102_CMD(bit));
125
126	/* One dummy command added, to clock in the last response */
127	st->tx_buf[cmds++] = 0x00;
128
129	/* build SPI ring message */
130	st->ring_xfer.tx_buf = &st->tx_buf[0];
131	st->ring_xfer.rx_buf = &st->rx_buf[0];
132	st->ring_xfer.len = cmds * sizeof(st->tx_buf[0]);
133
134	spi_message_init_with_transfers(&st->ring_msg, &st->ring_xfer, 1);
135
136	return 0;
137}
138
139static irqreturn_t adc108s102_trigger_handler(int irq, void *p)
140{
141	struct iio_poll_func *pf = p;
142	struct iio_dev *indio_dev = pf->indio_dev;
143	struct adc108s102_state *st = iio_priv(indio_dev);
144	int ret;
145
146	ret = spi_sync(st->spi, &st->ring_msg);
147	if (ret < 0)
148		goto out_notify;
149
150	/* Skip the dummy response in the first slot */
151	iio_push_to_buffers_with_ts_unaligned(indio_dev,
152					      &st->rx_buf[1],
153					      st->ring_xfer.len - sizeof(st->rx_buf[1]),
154					      iio_get_time_ns(indio_dev));
155
156out_notify:
157	iio_trigger_notify_done(indio_dev->trig);
158
159	return IRQ_HANDLED;
160}
161
162static int adc108s102_scan_direct(struct adc108s102_state *st, unsigned int ch)
163{
164	int ret;
165
166	st->tx_buf[0] = cpu_to_be16(ADC108S102_CMD(ch));
167	ret = spi_sync(st->spi, &st->scan_single_msg);
168	if (ret)
169		return ret;
170
171	/* Skip the dummy response in the first slot */
172	return be16_to_cpu(st->rx_buf[1]);
173}
174
175static int adc108s102_read_raw(struct iio_dev *indio_dev,
176			       struct iio_chan_spec const *chan,
177			       int *val, int *val2, long m)
178{
179	struct adc108s102_state *st = iio_priv(indio_dev);
180	int ret;
181
182	switch (m) {
183	case IIO_CHAN_INFO_RAW:
184		if (!iio_device_claim_direct(indio_dev))
185			return -EBUSY;
186
187		ret = adc108s102_scan_direct(st, chan->address);
188
189		iio_device_release_direct(indio_dev);
190
191		if (ret < 0)
192			return ret;
193
194		*val = ADC108S102_RES_DATA(ret);
195
196		return IIO_VAL_INT;
197	case IIO_CHAN_INFO_SCALE:
198		if (chan->type != IIO_VOLTAGE)
199			break;
200
201		*val = st->va_millivolt;
202		*val2 = chan->scan_type.realbits;
203
204		return IIO_VAL_FRACTIONAL_LOG2;
205	default:
206		break;
207	}
208
209	return -EINVAL;
210}
211
212static const struct iio_info adc108s102_info = {
213	.read_raw		= &adc108s102_read_raw,
214	.update_scan_mode	= &adc108s102_update_scan_mode,
215};
216
217static int adc108s102_probe(struct spi_device *spi)
218{
219	struct adc108s102_state *st;
220	struct iio_dev *indio_dev;
221	int ret;
222
223	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
224	if (!indio_dev)
225		return -ENOMEM;
226
227	st = iio_priv(indio_dev);
228
229	if (ACPI_COMPANION(&spi->dev)) {
230		st->va_millivolt = ADC108S102_VA_MV_ACPI_DEFAULT;
231	} else {
232		ret = devm_regulator_get_enable_read_voltage(&spi->dev, "vref");
233		if (ret < 0)
234			return dev_err_probe(&spi->dev, ret, "failed get vref voltage\n");
235
236		st->va_millivolt = ret / 1000;
237	}
238
239	st->spi = spi;
240
241	indio_dev->name = spi->modalias;
242	indio_dev->modes = INDIO_DIRECT_MODE;
243	indio_dev->channels = adc108s102_channels;
244	indio_dev->num_channels = ARRAY_SIZE(adc108s102_channels);
245	indio_dev->info = &adc108s102_info;
246
247	/* Setup default message */
248	st->scan_single_xfer.tx_buf = st->tx_buf;
249	st->scan_single_xfer.rx_buf = st->rx_buf;
250	st->scan_single_xfer.len = 2 * sizeof(st->tx_buf[0]);
251
252	spi_message_init_with_transfers(&st->scan_single_msg,
253					&st->scan_single_xfer, 1);
254
255	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
256					      &adc108s102_trigger_handler,
257					      NULL);
258	if (ret)
259		return ret;
260
261	ret = devm_iio_device_register(&spi->dev, indio_dev);
262	if (ret)
263		dev_err(&spi->dev, "Failed to register IIO device\n");
264	return ret;
265}
266
267static const struct of_device_id adc108s102_of_match[] = {
268	{ .compatible = "ti,adc108s102" },
269	{ }
270};
271MODULE_DEVICE_TABLE(of, adc108s102_of_match);
272
273static const struct acpi_device_id adc108s102_acpi_ids[] = {
274	{ "INT3495", 0 },
275	{ }
276};
277MODULE_DEVICE_TABLE(acpi, adc108s102_acpi_ids);
278
279static const struct spi_device_id adc108s102_id[] = {
280	{ "adc108s102", 0 },
281	{ }
282};
283MODULE_DEVICE_TABLE(spi, adc108s102_id);
284
285static struct spi_driver adc108s102_driver = {
286	.driver = {
287		.name   = "adc108s102",
288		.of_match_table = adc108s102_of_match,
289		.acpi_match_table = adc108s102_acpi_ids,
290	},
291	.probe		= adc108s102_probe,
292	.id_table	= adc108s102_id,
293};
294module_spi_driver(adc108s102_driver);
295
296MODULE_AUTHOR("Bogdan Pricop <bogdan.pricop@emutex.com>");
297MODULE_DESCRIPTION("Texas Instruments ADC108S102 and ADC128S102 driver");
298MODULE_LICENSE("GPL v2");