max1118.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * MAX1117/MAX1118/MAX1119 8-bit, dual-channel ADCs driver
  4 *
  5 * Copyright (c) 2017 Akinobu Mita <akinobu.mita@gmail.com>
  6 *
  7 * Datasheet: https://datasheets.maximintegrated.com/en/ds/MAX1117-MAX1119.pdf
  8 *
  9 * SPI interface connections
 10 *
 11 * SPI                MAXIM
 12 * Master  Direction  MAX1117/8/9
 13 * ------  ---------  -----------
 14 * nCS        -->     CNVST
 15 * SCK        -->     SCLK
 16 * MISO       <--     DOUT
 17 * ------  ---------  -----------
 18 */
 19
 20#include <linux/module.h>
 21#include <linux/mod_devicetable.h>
 22#include <linux/spi/spi.h>
 23#include <linux/iio/iio.h>
 24#include <linux/iio/buffer.h>
 25#include <linux/iio/triggered_buffer.h>
 26#include <linux/iio/trigger_consumer.h>
 27#include <linux/regulator/consumer.h>
 28
 29enum max1118_id {
 30	max1117,
 31	max1118,
 32	max1119,
 33};
 34
 35struct max1118 {
 36	struct spi_device *spi;
 37	struct mutex lock;
 38	struct regulator *reg;
 39	/* Ensure natural alignment of buffer elements */
 40	struct {
 41		u8 channels[2];
 42		aligned_s64 ts;
 43	} scan;
 44
 45	u8 data __aligned(IIO_DMA_MINALIGN);
 46};
 47
 48#define MAX1118_CHANNEL(ch)						\
 49	{								\
 50		.type = IIO_VOLTAGE,					\
 51		.indexed = 1,						\
 52		.channel = (ch),					\
 53		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
 54		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),	\
 55		.scan_index = ch,					\
 56		.scan_type = {						\
 57			.sign = 'u',					\
 58			.realbits = 8,					\
 59			.storagebits = 8,				\
 60		},							\
 61	}
 62
 63static const struct iio_chan_spec max1118_channels[] = {
 64	MAX1118_CHANNEL(0),
 65	MAX1118_CHANNEL(1),
 66	IIO_CHAN_SOFT_TIMESTAMP(2),
 67};
 68
 69static int max1118_read(struct iio_dev *indio_dev, int channel)
 70{
 71	struct max1118 *adc = iio_priv(indio_dev);
 72	struct spi_transfer xfers[] = {
 73		/*
 74		 * To select CH1 for conversion, CNVST pin must be brought high
 75		 * and low for a second time.
 76		 */
 77		{
 78			.len = 0,
 79			.delay = {	/* > CNVST Low Time 100 ns */
 80				.value = 1,
 81				.unit = SPI_DELAY_UNIT_USECS
 82			},
 83			.cs_change = 1,
 84		},
 85		/*
 86		 * The acquisition interval begins with the falling edge of
 87		 * CNVST.  The total acquisition and conversion process takes
 88		 * <7.5us.
 89		 */
 90		{
 91			.len = 0,
 92			.delay = {
 93				.value = 8,
 94				.unit = SPI_DELAY_UNIT_USECS
 95			},
 96		},
 97		{
 98			.rx_buf = &adc->data,
 99			.len = 1,
100		},
101	};
102	int ret;
103
104	if (channel == 0)
105		ret = spi_sync_transfer(adc->spi, xfers + 1, 2);
106	else
107		ret = spi_sync_transfer(adc->spi, xfers, 3);
108
109	if (ret)
110		return ret;
111
112	return adc->data;
113}
114
115static int max1118_get_vref_mV(struct iio_dev *indio_dev)
116{
117	struct max1118 *adc = iio_priv(indio_dev);
118	const struct spi_device_id *id = spi_get_device_id(adc->spi);
119	int vref_uV;
120
121	switch (id->driver_data) {
122	case max1117:
123		return 2048;
124	case max1119:
125		return 4096;
126	case max1118:
127		vref_uV = regulator_get_voltage(adc->reg);
128		if (vref_uV < 0)
129			return vref_uV;
130		return vref_uV / 1000;
131	}
132
133	return -ENODEV;
134}
135
136static int max1118_read_raw(struct iio_dev *indio_dev,
137			struct iio_chan_spec const *chan,
138			int *val, int *val2, long mask)
139{
140	struct max1118 *adc = iio_priv(indio_dev);
141
142	switch (mask) {
143	case IIO_CHAN_INFO_RAW:
144		mutex_lock(&adc->lock);
145		*val = max1118_read(indio_dev, chan->channel);
146		mutex_unlock(&adc->lock);
147		if (*val < 0)
148			return *val;
149
150		return IIO_VAL_INT;
151	case IIO_CHAN_INFO_SCALE:
152		*val = max1118_get_vref_mV(indio_dev);
153		if (*val < 0)
154			return *val;
155		*val2 = 8;
156
157		return IIO_VAL_FRACTIONAL_LOG2;
158	}
159
160	return -EINVAL;
161}
162
163static const struct iio_info max1118_info = {
164	.read_raw = max1118_read_raw,
165};
166
167static irqreturn_t max1118_trigger_handler(int irq, void *p)
168{
169	struct iio_poll_func *pf = p;
170	struct iio_dev *indio_dev = pf->indio_dev;
171	struct max1118 *adc = iio_priv(indio_dev);
172	int scan_index;
173	int i = 0;
174
175	mutex_lock(&adc->lock);
176
177	iio_for_each_active_channel(indio_dev, scan_index) {
178		const struct iio_chan_spec *scan_chan =
179				&indio_dev->channels[scan_index];
180		int ret = max1118_read(indio_dev, scan_chan->channel);
181
182		if (ret < 0) {
183			dev_warn(&adc->spi->dev,
184				"failed to get conversion data\n");
185			goto out;
186		}
187
188		adc->scan.channels[i] = ret;
189		i++;
190	}
191	iio_push_to_buffers_with_ts(indio_dev, &adc->scan, sizeof(adc->scan),
192				    iio_get_time_ns(indio_dev));
193out:
194	mutex_unlock(&adc->lock);
195
196	iio_trigger_notify_done(indio_dev->trig);
197
198	return IRQ_HANDLED;
199}
200
201static void max1118_reg_disable(void *reg)
202{
203	regulator_disable(reg);
204}
205
206static int max1118_probe(struct spi_device *spi)
207{
208	struct iio_dev *indio_dev;
209	struct max1118 *adc;
210	const struct spi_device_id *id = spi_get_device_id(spi);
211	int ret;
212
213	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*adc));
214	if (!indio_dev)
215		return -ENOMEM;
216
217	adc = iio_priv(indio_dev);
218	adc->spi = spi;
219	mutex_init(&adc->lock);
220
221	if (id->driver_data == max1118) {
222		adc->reg = devm_regulator_get(&spi->dev, "vref");
223		if (IS_ERR(adc->reg))
224			return dev_err_probe(&spi->dev, PTR_ERR(adc->reg),
225					     "failed to get vref regulator\n");
226		ret = regulator_enable(adc->reg);
227		if (ret)
228			return ret;
229
230		ret = devm_add_action_or_reset(&spi->dev, max1118_reg_disable,
231					       adc->reg);
232		if (ret)
233			return ret;
234
235	}
236
237	indio_dev->name = spi_get_device_id(spi)->name;
238	indio_dev->info = &max1118_info;
239	indio_dev->modes = INDIO_DIRECT_MODE;
240	indio_dev->channels = max1118_channels;
241	indio_dev->num_channels = ARRAY_SIZE(max1118_channels);
242
243	/*
244	 * To reinitiate a conversion on CH0, it is necessary to allow for a
245	 * conversion to be complete and all of the data to be read out.  Once
246	 * a conversion has been completed, the MAX1117/MAX1118/MAX1119 will go
247	 * into AutoShutdown mode until the next conversion is initiated.
248	 */
249	max1118_read(indio_dev, 0);
250
251	ret = devm_iio_triggered_buffer_setup(&spi->dev, indio_dev, NULL,
252					      max1118_trigger_handler, NULL);
253	if (ret)
254		return ret;
255
256	return devm_iio_device_register(&spi->dev, indio_dev);
257}
258
259static const struct spi_device_id max1118_id[] = {
260	{ "max1117", max1117 },
261	{ "max1118", max1118 },
262	{ "max1119", max1119 },
263	{ }
264};
265MODULE_DEVICE_TABLE(spi, max1118_id);
266
267static const struct of_device_id max1118_dt_ids[] = {
268	{ .compatible = "maxim,max1117" },
269	{ .compatible = "maxim,max1118" },
270	{ .compatible = "maxim,max1119" },
271	{ }
272};
273MODULE_DEVICE_TABLE(of, max1118_dt_ids);
274
275static struct spi_driver max1118_spi_driver = {
276	.driver = {
277		.name = "max1118",
278		.of_match_table = max1118_dt_ids,
279	},
280	.probe = max1118_probe,
281	.id_table = max1118_id,
282};
283module_spi_driver(max1118_spi_driver);
284
285MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
286MODULE_DESCRIPTION("MAXIM MAX1117/MAX1118/MAX1119 ADCs driver");
287MODULE_LICENSE("GPL v2");