[deliverable/linux.git] / drivers / iio / adc / ti-adc161s626.c

/*
 * ti-adc161s626.c - Texas Instruments ADC161S626 1-channel differential ADC
 *
 * ADC Devices Supported:
 *  adc141s626 - 14-bit ADC
 *  adc161s626 - 16-bit ADC
 *
 * Copyright (C) 2016 Matt Ranostay <mranostay@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/spi/spi.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/iio/buffer.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>

#define TI_ADC_DRV_NAME	"ti-adc161s626"

enum {
	TI_ADC141S626,
	TI_ADC161S626,
};

static const struct iio_chan_spec ti_adc141s626_channels[] = {
	{
		.type = IIO_VOLTAGE,
		.channel = 0,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.scan_index = 0,
		.scan_type = {
			.sign = 's',
			.realbits = 14,
			.storagebits = 16,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(1),
};

static const struct iio_chan_spec ti_adc161s626_channels[] = {
	{
		.type = IIO_VOLTAGE,
		.channel = 0,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.scan_index = 0,
		.scan_type = {
			.sign = 's',
			.realbits = 16,
			.storagebits = 16,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(1),
};

struct ti_adc_data {
	struct iio_dev *indio_dev;
	struct spi_device *spi;
	u8 read_size;
	u8 shift;

	u8 buffer[16] ____cacheline_aligned;
};

static int ti_adc_read_measurement(struct ti_adc_data *data,
				   struct iio_chan_spec const *chan, int *val)
{
	int ret;

	switch (data->read_size) {
	case 2: {
		__be16 buf;

		ret = spi_read(data->spi, (void *) &buf, 2);
		if (ret)
			return ret;

		*val = be16_to_cpu(buf);
		break;
	}
	case 3: {
		__be32 buf;

		ret = spi_read(data->spi, (void *) &buf, 3);
		if (ret)
			return ret;

		*val = be32_to_cpu(buf) >> 8;
		break;
	}
	default:
		return -EINVAL;
	}

	*val = sign_extend32(*val >> data->shift, chan->scan_type.realbits - 1);

	return 0;
}

static irqreturn_t ti_adc_trigger_handler(int irq, void *private)
{
	struct iio_poll_func *pf = private;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct ti_adc_data *data = iio_priv(indio_dev);
	int ret;

	ret = ti_adc_read_measurement(data, &indio_dev->channels[0],
				     (int *) &data->buffer);
	if (!ret)
		iio_push_to_buffers_with_timestamp(indio_dev,
					data->buffer,
					iio_get_time_ns(indio_dev));

	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
}

static int ti_adc_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int *val, int *val2, long mask)
{
	struct ti_adc_data *data = iio_priv(indio_dev);
	int ret;

	if (mask != IIO_CHAN_INFO_RAW)
		return -EINVAL;

	ret = iio_device_claim_direct_mode(indio_dev);
	if (ret)
		return ret;

	ret = ti_adc_read_measurement(data, chan, val);
	iio_device_release_direct_mode(indio_dev);

	if (!ret)
		return IIO_VAL_INT;

	return 0;
}

static const struct iio_info ti_adc_info = {
	.driver_module = THIS_MODULE,
	.read_raw = ti_adc_read_raw,
};

static int ti_adc_probe(struct spi_device *spi)
{
	struct iio_dev *indio_dev;
	struct ti_adc_data *data;
	int ret;

	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;

	indio_dev->info = &ti_adc_info;
	indio_dev->dev.parent = &spi->dev;
	indio_dev->dev.of_node = spi->dev.of_node;
	indio_dev->name = TI_ADC_DRV_NAME;
	indio_dev->modes = INDIO_DIRECT_MODE;
	spi_set_drvdata(spi, indio_dev);

	data = iio_priv(indio_dev);
	data->spi = spi;

	switch (spi_get_device_id(spi)->driver_data) {
	case TI_ADC141S626:
		indio_dev->channels = ti_adc141s626_channels;
		indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels);
		data->shift = 0;
		data->read_size = 2;
		break;
	case TI_ADC161S626:
		indio_dev->channels = ti_adc161s626_channels;
		indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels);
		data->shift = 6;
		data->read_size = 3;
		break;
	}

	ret = iio_triggered_buffer_setup(indio_dev, NULL,
					 ti_adc_trigger_handler, NULL);
	if (ret)
		return ret;

	ret = iio_device_register(indio_dev);
	if (ret)
		goto error_unreg_buffer;

	return 0;

error_unreg_buffer:
	iio_triggered_buffer_cleanup(indio_dev);

	return ret;
}

static int ti_adc_remove(struct spi_device *spi)
{
	struct iio_dev *indio_dev = spi_get_drvdata(spi);

	iio_device_unregister(indio_dev);
	iio_triggered_buffer_cleanup(indio_dev);

	return 0;
}

static const struct of_device_id ti_adc_dt_ids[] = {
	{ .compatible = "ti,adc141s626", },
	{ .compatible = "ti,adc161s626", },
	{}
};
MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);

static const struct spi_device_id ti_adc_id[] = {
	{"adc141s626", TI_ADC141S626},
	{"adc161s626", TI_ADC161S626},
	{},
};
MODULE_DEVICE_TABLE(spi, ti_adc_id);

static struct spi_driver ti_adc_driver = {
	.driver = {
		.name	= TI_ADC_DRV_NAME,
		.of_match_table = of_match_ptr(ti_adc_dt_ids),
	},
	.probe		= ti_adc_probe,
	.remove		= ti_adc_remove,
	.id_table	= ti_adc_id,
};
module_spi_driver(ti_adc_driver);

MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC");
MODULE_LICENSE("GPL");
Commit	Line	Data
4d671b71 MR	1	/*
	2	* ti-adc161s626.c - Texas Instruments ADC161S626 1-channel differential ADC
	3	*
	4	* ADC Devices Supported:
	5	* adc141s626 - 14-bit ADC
	6	* adc161s626 - 16-bit ADC
	7	*
	8	* Copyright (C) 2016 Matt Ranostay <mranostay@gmail.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*/
	20
	21	#include <linux/module.h>
	22	#include <linux/init.h>
	23	#include <linux/err.h>
	24	#include <linux/spi/spi.h>
	25	#include <linux/iio/iio.h>
	26	#include <linux/iio/trigger.h>
	27	#include <linux/iio/buffer.h>
	28	#include <linux/iio/trigger_consumer.h>
	29	#include <linux/iio/triggered_buffer.h>
	30
	31	#define TI_ADC_DRV_NAME "ti-adc161s626"
	32
	33	enum {
	34	TI_ADC141S626,
	35	TI_ADC161S626,
	36	};
	37
	38	static const struct iio_chan_spec ti_adc141s626_channels[] = {
	39	{
	40	.type = IIO_VOLTAGE,
	41	.channel = 0,
	42	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	43	.scan_index = 0,
	44	.scan_type = {
	45	.sign = 's',
	46	.realbits = 14,
	47	.storagebits = 16,
	48	},
	49	},
	50	IIO_CHAN_SOFT_TIMESTAMP(1),
	51	};
	52
	53	static const struct iio_chan_spec ti_adc161s626_channels[] = {
	54	{
	55	.type = IIO_VOLTAGE,
	56	.channel = 0,
	57	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	58	.scan_index = 0,
	59	.scan_type = {
	60	.sign = 's',
	61	.realbits = 16,
	62	.storagebits = 16,
	63	},
	64	},
65	IIO_CHAN_SOFT_TIMESTAMP(1),
66	};
67
68	struct ti_adc_data {
69	struct iio_dev *indio_dev;
70	struct spi_device *spi;
71	u8 read_size;
72	u8 shift;
73
74	u8 buffer[16] ____cacheline_aligned;
75	};
76
77	static int ti_adc_read_measurement(struct ti_adc_data *data,
78	struct iio_chan_spec const chan, int val)
79	{
80	int ret;
81
82	switch (data->read_size) {
83	case 2: {
84	__be16 buf;
85
86	ret = spi_read(data->spi, (void *) &buf, 2);
87	if (ret)
88	return ret;
89
90	*val = be16_to_cpu(buf);
91	break;
92	}
93	case 3: {
94	__be32 buf;
95
96	ret = spi_read(data->spi, (void *) &buf, 3);
97	if (ret)
98	return ret;
99
100	*val = be32_to_cpu(buf) >> 8;
101	break;
102	}
103	default:
104	return -EINVAL;
105	}
106
107	val = sign_extend32(val >> data->shift, chan->scan_type.realbits - 1);
108
109	return 0;
110	}
111
112	static irqreturn_t ti_adc_trigger_handler(int irq, void *private)
113	{
114	struct iio_poll_func *pf = private;
115	struct iio_dev *indio_dev = pf->indio_dev;
116	struct ti_adc_data *data = iio_priv(indio_dev);
117	int ret;
118
119	ret = ti_adc_read_measurement(data, &indio_dev->channels[0],
120	(int *) &data->buffer);
121	if (!ret)
122	iio_push_to_buffers_with_timestamp(indio_dev,
123	data->buffer,
124	iio_get_time_ns(indio_dev));
125
126	iio_trigger_notify_done(indio_dev->trig);
127
128	return IRQ_HANDLED;
129	}
130
131	static int ti_adc_read_raw(struct iio_dev *indio_dev,
132	struct iio_chan_spec const *chan,
133	int val, int val2, long mask)
134	{
135	struct ti_adc_data *data = iio_priv(indio_dev);
136	int ret;
137
138	if (mask != IIO_CHAN_INFO_RAW)
139	return -EINVAL;
140
141	ret = iio_device_claim_direct_mode(indio_dev);
142	if (ret)
143	return ret;
144
145	ret = ti_adc_read_measurement(data, chan, val);
146	iio_device_release_direct_mode(indio_dev);
147
148	if (!ret)
149	return IIO_VAL_INT;
150
151	return 0;
152	}
153
154	static const struct iio_info ti_adc_info = {
155	.driver_module = THIS_MODULE,
156	.read_raw = ti_adc_read_raw,
157	};
158
159	static int ti_adc_probe(struct spi_device *spi)
160	{
161	struct iio_dev *indio_dev;
162	struct ti_adc_data *data;
163	int ret;
164
165	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
166	if (!indio_dev)
167	return -ENOMEM;
168
169	indio_dev->info = &ti_adc_info;
170	indio_dev->dev.parent = &spi->dev;
171	indio_dev->dev.of_node = spi->dev.of_node;
172	indio_dev->name = TI_ADC_DRV_NAME;
173	indio_dev->modes = INDIO_DIRECT_MODE;
174	spi_set_drvdata(spi, indio_dev);
175
176	data = iio_priv(indio_dev);
177	data->spi = spi;
178
179	switch (spi_get_device_id(spi)->driver_data) {
180	case TI_ADC141S626:
181	indio_dev->channels = ti_adc141s626_channels;
182	indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels);
183	data->shift = 0;
184	data->read_size = 2;
185	break;
186	case TI_ADC161S626:
187	indio_dev->channels = ti_adc161s626_channels;
188	indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels);
189	data->shift = 6;
190	data->read_size = 3;
191	break;
192	}
193
194	ret = iio_triggered_buffer_setup(indio_dev, NULL,
195	ti_adc_trigger_handler, NULL);
196	if (ret)
197	return ret;
198
199	ret = iio_device_register(indio_dev);
200	if (ret)
201	goto error_unreg_buffer;
202
203	return 0;
204
205	error_unreg_buffer:
206	iio_triggered_buffer_cleanup(indio_dev);
207
208	return ret;
209	}
210
211	static int ti_adc_remove(struct spi_device *spi)
212	{
213	struct iio_dev *indio_dev = spi_get_drvdata(spi);
214
215	iio_device_unregister(indio_dev);
216	iio_triggered_buffer_cleanup(indio_dev);
217
218	return 0;
219	}
220
221	static const struct of_device_id ti_adc_dt_ids[] = {
222	{ .compatible = "ti,adc141s626", },
223	{ .compatible = "ti,adc161s626", },
224	{}
225	};
226	MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
227
228	static const struct spi_device_id ti_adc_id[] = {
229	{"adc141s626", TI_ADC141S626},
230	{"adc161s626", TI_ADC161S626},
231	{},
232	};
233	MODULE_DEVICE_TABLE(spi, ti_adc_id);
234
235	static struct spi_driver ti_adc_driver = {
236	.driver = {
237	.name = TI_ADC_DRV_NAME,
238	.of_match_table = of_match_ptr(ti_adc_dt_ids),
239	},
240	.probe = ti_adc_probe,
241	.remove = ti_adc_remove,
242	.id_table = ti_adc_id,
243	};
244	module_spi_driver(ti_adc_driver);
245
246	MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
247	MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC");
248	MODULE_LICENSE("GPL");