1/*
2 * AD7298 SPI ADC driver
3 *
4 * Copyright 2011 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2.
7 */
8
9#include <linux/device.h>
10#include <linux/kernel.h>
11#include <linux/slab.h>
12#include <linux/sysfs.h>
13#include <linux/spi/spi.h>
14#include <linux/regulator/consumer.h>
15#include <linux/err.h>
16#include <linux/delay.h>
17#include <linux/module.h>
18#include <linux/interrupt.h>
19#include <linux/bitops.h>
20
21#include <linux/iio/iio.h>
22#include <linux/iio/sysfs.h>
23#include <linux/iio/buffer.h>
24#include <linux/iio/trigger_consumer.h>
25#include <linux/iio/triggered_buffer.h>
26
27#include <linux/platform_data/ad7298.h>
28
29#define AD7298_WRITE	BIT(15) /* write to the control register */
30#define AD7298_REPEAT	BIT(14) /* repeated conversion enable */
31#define AD7298_CH(x)	BIT(13 - (x)) /* channel select */
32#define AD7298_TSENSE	BIT(5) /* temperature conversion enable */
33#define AD7298_EXTREF	BIT(2) /* external reference enable */
34#define AD7298_TAVG	BIT(1) /* temperature sensor averaging enable */
35#define AD7298_PDD	BIT(0) /* partial power down enable */
36
37#define AD7298_MAX_CHAN		8
38#define AD7298_INTREF_mV	2500
39
40#define AD7298_CH_TEMP		9
41
42struct ad7298_state {
43	struct spi_device		*spi;
44	struct regulator		*reg;
45	unsigned			ext_ref;
46	struct spi_transfer		ring_xfer[10];
47	struct spi_transfer		scan_single_xfer[3];
48	struct spi_message		ring_msg;
49	struct spi_message		scan_single_msg;
50	/*
51	 * DMA (thus cache coherency maintenance) requires the
52	 * transfer buffers to live in their own cache lines.
53	 */
54	__be16				rx_buf[12] ____cacheline_aligned;
55	__be16				tx_buf[2];
56};
57
58#define AD7298_V_CHAN(index)						\
59	{								\
60		.type = IIO_VOLTAGE,					\
61		.indexed = 1,						\
62		.channel = index,					\
63		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
64		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),	\
65		.address = index,					\
66		.scan_index = index,					\
67		.scan_type = {						\
68			.sign = 'u',					\
69			.realbits = 12,					\
70			.storagebits = 16,				\
71			.endianness = IIO_BE,				\
72		},							\
73	}
74
75static const struct iio_chan_spec ad7298_channels[] = {
76	{
77		.type = IIO_TEMP,
78		.indexed = 1,
79		.channel = 0,
80		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
81			BIT(IIO_CHAN_INFO_SCALE) |
82			BIT(IIO_CHAN_INFO_OFFSET),
83		.address = AD7298_CH_TEMP,
84		.scan_index = -1,
85		.scan_type = {
86			.sign = 's',
87			.realbits = 32,
88			.storagebits = 32,
89		},
90	},
91	AD7298_V_CHAN(0),
92	AD7298_V_CHAN(1),
93	AD7298_V_CHAN(2),
94	AD7298_V_CHAN(3),
95	AD7298_V_CHAN(4),
96	AD7298_V_CHAN(5),
97	AD7298_V_CHAN(6),
98	AD7298_V_CHAN(7),
99	IIO_CHAN_SOFT_TIMESTAMP(8),
100};
101
102/**
103 * ad7298_update_scan_mode() setup the spi transfer buffer for the new scan mask
104 **/
105static int ad7298_update_scan_mode(struct iio_dev *indio_dev,
106	const unsigned long *active_scan_mask)
107{
108	struct ad7298_state *st = iio_priv(indio_dev);
109	int i, m;
110	unsigned short command;
111	int scan_count;
112
113	/* Now compute overall size */
114	scan_count = bitmap_weight(active_scan_mask, indio_dev->masklength);
115
116	command = AD7298_WRITE | st->ext_ref;
117
118	for (i = 0, m = AD7298_CH(0); i < AD7298_MAX_CHAN; i++, m >>= 1)
119		if (test_bit(i, active_scan_mask))
120			command |= m;
121
122	st->tx_buf[0] = cpu_to_be16(command);
123
124	/* build spi ring message */
125	st->ring_xfer[0].tx_buf = &st->tx_buf[0];
126	st->ring_xfer[0].len = 2;
127	st->ring_xfer[0].cs_change = 1;
128	st->ring_xfer[1].tx_buf = &st->tx_buf[1];
129	st->ring_xfer[1].len = 2;
130	st->ring_xfer[1].cs_change = 1;
131
132	spi_message_init(&st->ring_msg);
133	spi_message_add_tail(&st->ring_xfer[0], &st->ring_msg);
134	spi_message_add_tail(&st->ring_xfer[1], &st->ring_msg);
135
136	for (i = 0; i < scan_count; i++) {
137		st->ring_xfer[i + 2].rx_buf = &st->rx_buf[i];
138		st->ring_xfer[i + 2].len = 2;
139		st->ring_xfer[i + 2].cs_change = 1;
140		spi_message_add_tail(&st->ring_xfer[i + 2], &st->ring_msg);
141	}
142	/* make sure last transfer cs_change is not set */
143	st->ring_xfer[i + 1].cs_change = 0;
144
145	return 0;
146}
147
148/**
149 * ad7298_trigger_handler() bh of trigger launched polling to ring buffer
150 *
151 * Currently there is no option in this driver to disable the saving of
152 * timestamps within the ring.
153 **/
154static irqreturn_t ad7298_trigger_handler(int irq, void *p)
155{
156	struct iio_poll_func *pf = p;
157	struct iio_dev *indio_dev = pf->indio_dev;
158	struct ad7298_state *st = iio_priv(indio_dev);
159	int b_sent;
160
161	b_sent = spi_sync(st->spi, &st->ring_msg);
162	if (b_sent)
163		goto done;
164
165	iio_push_to_buffers_with_timestamp(indio_dev, st->rx_buf,
166		iio_get_time_ns());
167
168done:
169	iio_trigger_notify_done(indio_dev->trig);
170
171	return IRQ_HANDLED;
172}
173
174static int ad7298_scan_direct(struct ad7298_state *st, unsigned ch)
175{
176	int ret;
177	st->tx_buf[0] = cpu_to_be16(AD7298_WRITE | st->ext_ref |
178				   (AD7298_CH(0) >> ch));
179
180	ret = spi_sync(st->spi, &st->scan_single_msg);
181	if (ret)
182		return ret;
183
184	return be16_to_cpu(st->rx_buf[0]);
185}
186
187static int ad7298_scan_temp(struct ad7298_state *st, int *val)
188{
189	int ret;
190	__be16 buf;
191
192	buf = cpu_to_be16(AD7298_WRITE | AD7298_TSENSE |
193			  AD7298_TAVG | st->ext_ref);
194
195	ret = spi_write(st->spi, (u8 *)&buf, 2);
196	if (ret)
197		return ret;
198
199	buf = cpu_to_be16(0);
200
201	ret = spi_write(st->spi, (u8 *)&buf, 2);
202	if (ret)
203		return ret;
204
205	usleep_range(101, 1000); /* sleep > 100us */
206
207	ret = spi_read(st->spi, (u8 *)&buf, 2);
208	if (ret)
209		return ret;
210
211	*val = sign_extend32(be16_to_cpu(buf), 11);
212
213	return 0;
214}
215
216static int ad7298_get_ref_voltage(struct ad7298_state *st)
217{
218	int vref;
219
220	if (st->ext_ref) {
221		vref = regulator_get_voltage(st->reg);
222		if (vref < 0)
223			return vref;
224
225		return vref / 1000;
226	} else {
227		return AD7298_INTREF_mV;
228	}
229}
230
231static int ad7298_read_raw(struct iio_dev *indio_dev,
232			   struct iio_chan_spec const *chan,
233			   int *val,
234			   int *val2,
235			   long m)
236{
237	int ret;
238	struct ad7298_state *st = iio_priv(indio_dev);
239
240	switch (m) {
241	case IIO_CHAN_INFO_RAW:
242		mutex_lock(&indio_dev->mlock);
243		if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
244			ret = -EBUSY;
245		} else {
246			if (chan->address == AD7298_CH_TEMP)
247				ret = ad7298_scan_temp(st, val);
248			else
249				ret = ad7298_scan_direct(st, chan->address);
250		}
251		mutex_unlock(&indio_dev->mlock);
252
253		if (ret < 0)
254			return ret;
255
256		if (chan->address != AD7298_CH_TEMP)
257			*val = ret & GENMASK(chan->scan_type.realbits - 1, 0);
258
259		return IIO_VAL_INT;
260	case IIO_CHAN_INFO_SCALE:
261		switch (chan->type) {
262		case IIO_VOLTAGE:
263			*val = ad7298_get_ref_voltage(st);
264			*val2 = chan->scan_type.realbits;
265			return IIO_VAL_FRACTIONAL_LOG2;
266		case IIO_TEMP:
267			*val = ad7298_get_ref_voltage(st);
268			*val2 = 10;
269			return IIO_VAL_FRACTIONAL;
270		default:
271			return -EINVAL;
272		}
273	case IIO_CHAN_INFO_OFFSET:
274		*val = 1093 - 2732500 / ad7298_get_ref_voltage(st);
275		return IIO_VAL_INT;
276	}
277	return -EINVAL;
278}
279
280static const struct iio_info ad7298_info = {
281	.read_raw = &ad7298_read_raw,
282	.update_scan_mode = ad7298_update_scan_mode,
283	.driver_module = THIS_MODULE,
284};
285
286static int ad7298_probe(struct spi_device *spi)
287{
288	struct ad7298_platform_data *pdata = spi->dev.platform_data;
289	struct ad7298_state *st;
290	struct iio_dev *indio_dev;
291	int ret;
292
293	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
294	if (indio_dev == NULL)
295		return -ENOMEM;
296
297	st = iio_priv(indio_dev);
298
299	if (pdata && pdata->ext_ref)
300		st->ext_ref = AD7298_EXTREF;
301
302	if (st->ext_ref) {
303		st->reg = devm_regulator_get(&spi->dev, "vref");
304		if (IS_ERR(st->reg))
305			return PTR_ERR(st->reg);
306
307		ret = regulator_enable(st->reg);
308		if (ret)
309			return ret;
310	}
311
312	spi_set_drvdata(spi, indio_dev);
313
314	st->spi = spi;
315
316	indio_dev->name = spi_get_device_id(spi)->name;
317	indio_dev->dev.parent = &spi->dev;
318	indio_dev->modes = INDIO_DIRECT_MODE;
319	indio_dev->channels = ad7298_channels;
320	indio_dev->num_channels = ARRAY_SIZE(ad7298_channels);
321	indio_dev->info = &ad7298_info;
322
323	/* Setup default message */
324
325	st->scan_single_xfer[0].tx_buf = &st->tx_buf[0];
326	st->scan_single_xfer[0].len = 2;
327	st->scan_single_xfer[0].cs_change = 1;
328	st->scan_single_xfer[1].tx_buf = &st->tx_buf[1];
329	st->scan_single_xfer[1].len = 2;
330	st->scan_single_xfer[1].cs_change = 1;
331	st->scan_single_xfer[2].rx_buf = &st->rx_buf[0];
332	st->scan_single_xfer[2].len = 2;
333
334	spi_message_init(&st->scan_single_msg);
335	spi_message_add_tail(&st->scan_single_xfer[0], &st->scan_single_msg);
336	spi_message_add_tail(&st->scan_single_xfer[1], &st->scan_single_msg);
337	spi_message_add_tail(&st->scan_single_xfer[2], &st->scan_single_msg);
338
339	ret = iio_triggered_buffer_setup(indio_dev, NULL,
340			&ad7298_trigger_handler, NULL);
341	if (ret)
342		goto error_disable_reg;
343
344	ret = iio_device_register(indio_dev);
345	if (ret)
346		goto error_cleanup_ring;
347
348	return 0;
349
350error_cleanup_ring:
351	iio_triggered_buffer_cleanup(indio_dev);
352error_disable_reg:
353	if (st->ext_ref)
354		regulator_disable(st->reg);
355
356	return ret;
357}
358
359static int ad7298_remove(struct spi_device *spi)
360{
361	struct iio_dev *indio_dev = spi_get_drvdata(spi);
362	struct ad7298_state *st = iio_priv(indio_dev);
363
364	iio_device_unregister(indio_dev);
365	iio_triggered_buffer_cleanup(indio_dev);
366	if (st->ext_ref)
367		regulator_disable(st->reg);
368
369	return 0;
370}
371
372static const struct spi_device_id ad7298_id[] = {
373	{"ad7298", 0},
374	{}
375};
376MODULE_DEVICE_TABLE(spi, ad7298_id);
377
378static struct spi_driver ad7298_driver = {
379	.driver = {
380		.name	= "ad7298",
381		.owner	= THIS_MODULE,
382	},
383	.probe		= ad7298_probe,
384	.remove		= ad7298_remove,
385	.id_table	= ad7298_id,
386};
387module_spi_driver(ad7298_driver);
388
389MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
390MODULE_DESCRIPTION("Analog Devices AD7298 ADC");
391MODULE_LICENSE("GPL v2");
392