[mirror_ubuntu-bionic-kernel.git] / drivers / staging / iio / adc / ad7887_core.c

/*
 * AD7887 SPI ADC driver
 *
 * Copyright 2010-2011 Analog Devices Inc.
 *
 * Licensed under the GPL-2.
 */

#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/spi/spi.h>
#include <linux/regulator/consumer.h>
#include <linux/err.h>
#include <linux/module.h>

#include "../iio.h"
#include "../sysfs.h"
#include "../ring_generic.h"


#include "ad7887.h"

static int ad7887_scan_direct(struct ad7887_state *st, unsigned ch)
{
	int ret = spi_sync(st->spi, &st->msg[ch]);
	if (ret)
		return ret;

	return (st->data[(ch * 2)] << 8) | st->data[(ch * 2) + 1];
}

static int ad7887_read_raw(struct iio_dev *dev_info,
			   struct iio_chan_spec const *chan,
			   int *val,
			   int *val2,
			   long m)
{
	int ret;
	struct ad7887_state *st = iio_priv(dev_info);
	unsigned int scale_uv;

	switch (m) {
	case 0:
		mutex_lock(&dev_info->mlock);
		if (iio_ring_enabled(dev_info))
			ret = ad7887_scan_from_ring(st, 1 << chan->address);
		else
			ret = ad7887_scan_direct(st, chan->address);
		mutex_unlock(&dev_info->mlock);

		if (ret < 0)
			return ret;
		*val = (ret >> st->chip_info->channel[0].scan_type.shift) &
			RES_MASK(st->chip_info->channel[0].scan_type.realbits);
		return IIO_VAL_INT;
	case (1 << IIO_CHAN_INFO_SCALE_SHARED):
		scale_uv = (st->int_vref_mv * 1000)
			>> st->chip_info->channel[0].scan_type.realbits;
		*val =  scale_uv/1000;
		*val2 = (scale_uv%1000)*1000;
		return IIO_VAL_INT_PLUS_MICRO;
	}
	return -EINVAL;
}


static const struct ad7887_chip_info ad7887_chip_info_tbl[] = {
	/*
	 * More devices added in future
	 */
	[ID_AD7887] = {
		.channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
				       (1 << IIO_CHAN_INFO_SCALE_SHARED),
				       1, 1, IIO_ST('u', 12, 16, 0), 0),

		.channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
				       (1 << IIO_CHAN_INFO_SCALE_SHARED),
				       0, 0, IIO_ST('u', 12, 16, 0), 0),

		.channel[2] = IIO_CHAN_SOFT_TIMESTAMP(2),
		.int_vref_mv = 2500,
	},
};

static const struct iio_info ad7887_info = {
	.read_raw = &ad7887_read_raw,
	.driver_module = THIS_MODULE,
};

static int __devinit ad7887_probe(struct spi_device *spi)
{
	struct ad7887_platform_data *pdata = spi->dev.platform_data;
	struct ad7887_state *st;
	int ret, voltage_uv = 0, regdone = 0;
	struct iio_dev *indio_dev = iio_allocate_device(sizeof(*st));

	if (indio_dev == NULL)
		return -ENOMEM;

	st = iio_priv(indio_dev);

	st->reg = regulator_get(&spi->dev, "vcc");
	if (!IS_ERR(st->reg)) {
		ret = regulator_enable(st->reg);
		if (ret)
			goto error_put_reg;

		voltage_uv = regulator_get_voltage(st->reg);
	}

	st->chip_info =
		&ad7887_chip_info_tbl[spi_get_device_id(spi)->driver_data];

	spi_set_drvdata(spi, indio_dev);
	st->spi = spi;

	/* Estabilish that the iio_dev is a child of the spi device */
	indio_dev->dev.parent = &spi->dev;
	indio_dev->name = spi_get_device_id(spi)->name;
	indio_dev->info = &ad7887_info;
	indio_dev->modes = INDIO_DIRECT_MODE;

	/* Setup default message */

	st->tx_cmd_buf[0] = AD7887_CH_AIN0 | AD7887_PM_MODE4 |
			    ((pdata && pdata->use_onchip_ref) ?
			    0 : AD7887_REF_DIS);

	st->xfer[0].rx_buf = &st->data[0];
	st->xfer[0].tx_buf = &st->tx_cmd_buf[0];
	st->xfer[0].len = 2;

	spi_message_init(&st->msg[AD7887_CH0]);
	spi_message_add_tail(&st->xfer[0], &st->msg[AD7887_CH0]);

	if (pdata && pdata->en_dual) {
		st->tx_cmd_buf[0] |= AD7887_DUAL | AD7887_REF_DIS;

		st->tx_cmd_buf[2] = AD7887_CH_AIN1 | AD7887_DUAL |
				    AD7887_REF_DIS | AD7887_PM_MODE4;
		st->tx_cmd_buf[4] = AD7887_CH_AIN0 | AD7887_DUAL |
				    AD7887_REF_DIS | AD7887_PM_MODE4;
		st->tx_cmd_buf[6] = AD7887_CH_AIN1 | AD7887_DUAL |
				    AD7887_REF_DIS | AD7887_PM_MODE4;

		st->xfer[1].rx_buf = &st->data[0];
		st->xfer[1].tx_buf = &st->tx_cmd_buf[2];
		st->xfer[1].len = 2;

		st->xfer[2].rx_buf = &st->data[2];
		st->xfer[2].tx_buf = &st->tx_cmd_buf[4];
		st->xfer[2].len = 2;

		spi_message_init(&st->msg[AD7887_CH0_CH1]);
		spi_message_add_tail(&st->xfer[1], &st->msg[AD7887_CH0_CH1]);
		spi_message_add_tail(&st->xfer[2], &st->msg[AD7887_CH0_CH1]);

		st->xfer[3].rx_buf = &st->data[0];
		st->xfer[3].tx_buf = &st->tx_cmd_buf[6];
		st->xfer[3].len = 2;

		spi_message_init(&st->msg[AD7887_CH1]);
		spi_message_add_tail(&st->xfer[3], &st->msg[AD7887_CH1]);

		if (pdata && pdata->vref_mv)
			st->int_vref_mv = pdata->vref_mv;
		else if (voltage_uv)
			st->int_vref_mv = voltage_uv / 1000;
		else
			dev_warn(&spi->dev, "reference voltage unspecified\n");

		indio_dev->channels = st->chip_info->channel;
		indio_dev->num_channels = 3;
	} else {
		if (pdata && pdata->vref_mv)
			st->int_vref_mv = pdata->vref_mv;
		else if (pdata && pdata->use_onchip_ref)
			st->int_vref_mv = st->chip_info->int_vref_mv;
		else
			dev_warn(&spi->dev, "reference voltage unspecified\n");

		indio_dev->channels = &st->chip_info->channel[1];
		indio_dev->num_channels = 2;
	}

	ret = ad7887_register_ring_funcs_and_init(indio_dev);
	if (ret)
		goto error_disable_reg;

	ret = iio_device_register(indio_dev);
	if (ret)
		goto error_disable_reg;
	regdone = 1;

	ret = iio_ring_buffer_register_ex(indio_dev, 0,
					  indio_dev->channels,
					  indio_dev->num_channels);
	if (ret)
		goto error_cleanup_ring;
	return 0;

error_cleanup_ring:
	ad7887_ring_cleanup(indio_dev);
error_disable_reg:
	if (!IS_ERR(st->reg))
		regulator_disable(st->reg);
error_put_reg:
	if (!IS_ERR(st->reg))
		regulator_put(st->reg);
	if (regdone)
		iio_device_unregister(indio_dev);
	else
		iio_free_device(indio_dev);

	return ret;
}

static int ad7887_remove(struct spi_device *spi)
{
	struct iio_dev *indio_dev = spi_get_drvdata(spi);
	struct ad7887_state *st = iio_priv(indio_dev);

	iio_ring_buffer_unregister(indio_dev);
	ad7887_ring_cleanup(indio_dev);
	if (!IS_ERR(st->reg)) {
		regulator_disable(st->reg);
		regulator_put(st->reg);
	}
	iio_device_unregister(indio_dev);

	return 0;
}

static const struct spi_device_id ad7887_id[] = {
	{"ad7887", ID_AD7887},
	{}
};

static struct spi_driver ad7887_driver = {
	.driver = {
		.name	= "ad7887",
		.bus	= &spi_bus_type,
		.owner	= THIS_MODULE,
	},
	.probe		= ad7887_probe,
	.remove		= __devexit_p(ad7887_remove),
	.id_table	= ad7887_id,
};

static int __init ad7887_init(void)
{
	return spi_register_driver(&ad7887_driver);
}
module_init(ad7887_init);

static void __exit ad7887_exit(void)
{
	spi_unregister_driver(&ad7887_driver);
}
module_exit(ad7887_exit);

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("Analog Devices AD7887 ADC");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("spi:ad7887");
Commit	Line	Data
2b4756aa MH	1	/*
	2	* AD7887 SPI ADC driver
	3	*
596d0609	4	* Copyright 2010-2011 Analog Devices Inc.
2b4756aa	5	*
596d0609	6	* Licensed under the GPL-2.
2b4756aa MH	7	*/
2b4756aa MH	8
2b4756aa MH	9	#include <linux/device.h>
	10	#include <linux/kernel.h>
	11	#include <linux/slab.h>
	12	#include <linux/sysfs.h>
2b4756aa MH	13	#include <linux/spi/spi.h>
	14	#include <linux/regulator/consumer.h>
	15	#include <linux/err.h>
99c97852	16	#include <linux/module.h>
2b4756aa MH	17
	18	#include "../iio.h"
	19	#include "../sysfs.h"
	20	#include "../ring_generic.h"
cdf38709	21
2b4756aa MH	22
	23	#include "ad7887.h"
	24
	25	static int ad7887_scan_direct(struct ad7887_state *st, unsigned ch)
	26	{
	27	int ret = spi_sync(st->spi, &st->msg[ch]);
	28	if (ret)
	29	return ret;
	30
	31	return (st->data[(ch * 2)] << 8) \| st->data[(ch * 2) + 1];
	32	}
	33
596d0609 MH	34	static int ad7887_read_raw(struct iio_dev *dev_info,
	35	struct iio_chan_spec const *chan,
	36	int *val,
	37	int *val2,
	38	long m)
2b4756aa	39	{
2b4756aa	40	int ret;
f490f42b	41	struct ad7887_state *st = iio_priv(dev_info);
596d0609	42	unsigned int scale_uv;
2b4756aa	43
596d0609 MH	44	switch (m) {
	45	case 0:
	46	mutex_lock(&dev_info->mlock);
	47	if (iio_ring_enabled(dev_info))
	48	ret = ad7887_scan_from_ring(st, 1 << chan->address);
	49	else
	50	ret = ad7887_scan_direct(st, chan->address);
	51	mutex_unlock(&dev_info->mlock);
	52
	53	if (ret < 0)
	54	return ret;
	55	*val = (ret >> st->chip_info->channel[0].scan_type.shift) &
	56	RES_MASK(st->chip_info->channel[0].scan_type.realbits);
	57	return IIO_VAL_INT;
	58	case (1 << IIO_CHAN_INFO_SCALE_SHARED):
	59	scale_uv = (st->int_vref_mv * 1000)
	60	>> st->chip_info->channel[0].scan_type.realbits;
	61	*val = scale_uv/1000;
	62	val2 = (scale_uv%1000)1000;
	63	return IIO_VAL_INT_PLUS_MICRO;
	64	}
	65	return -EINVAL;
2b4756aa MH	66	}
2b4756aa MH	67
2b4756aa MH	68
	69	static const struct ad7887_chip_info ad7887_chip_info_tbl[] = {
	70	/*
	71	* More devices added in future
	72	*/
	73	[ID_AD7887] = {
596d0609 MH	74	.channel[0] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0,
	75	(1 << IIO_CHAN_INFO_SCALE_SHARED),
	76	1, 1, IIO_ST('u', 12, 16, 0), 0),
	77
	78	.channel[1] = IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0,
	79	(1 << IIO_CHAN_INFO_SCALE_SHARED),
	80	0, 0, IIO_ST('u', 12, 16, 0), 0),
	81
	82	.channel[2] = IIO_CHAN_SOFT_TIMESTAMP(2),
2b4756aa MH	83	.int_vref_mv = 2500,
	84	},
	85	};
	86
6fe8135f JC	87	static const struct iio_info ad7887_info = {
	88	.read_raw = &ad7887_read_raw,
	89	.driver_module = THIS_MODULE,
	90	};
	91
2b4756aa MH	92	static int __devinit ad7887_probe(struct spi_device *spi)
	93	{
	94	struct ad7887_platform_data *pdata = spi->dev.platform_data;
	95	struct ad7887_state *st;
f39e086a MH	96	int ret, voltage_uv = 0, regdone = 0;
f39e086a MH	97	struct iio_dev indio_dev = iio_allocate_device(sizeof(st));
2b4756aa	98
f39e086a MH	99	if (indio_dev == NULL)
	100	return -ENOMEM;
	101
	102	st = iio_priv(indio_dev);
2b4756aa MH	103
	104	st->reg = regulator_get(&spi->dev, "vcc");
	105	if (!IS_ERR(st->reg)) {
	106	ret = regulator_enable(st->reg);
	107	if (ret)
	108	goto error_put_reg;
	109
	110	voltage_uv = regulator_get_voltage(st->reg);
	111	}
	112
	113	st->chip_info =
	114	&ad7887_chip_info_tbl[spi_get_device_id(spi)->driver_data];
	115
f39e086a	116	spi_set_drvdata(spi, indio_dev);
2b4756aa MH	117	st->spi = spi;
2b4756aa MH	118
2b4756aa	119	/* Estabilish that the iio_dev is a child of the spi device */
f39e086a MH	120	indio_dev->dev.parent = &spi->dev;
f39e086a MH	121	indio_dev->name = spi_get_device_id(spi)->name;
6fe8135f	122	indio_dev->info = &ad7887_info;
f39e086a	123	indio_dev->modes = INDIO_DIRECT_MODE;
2b4756aa MH	124
	125	/* Setup default message */
	126
	127	st->tx_cmd_buf[0] = AD7887_CH_AIN0 \| AD7887_PM_MODE4 \|
	128	((pdata && pdata->use_onchip_ref) ?
	129	0 : AD7887_REF_DIS);
	130
	131	st->xfer[0].rx_buf = &st->data[0];
	132	st->xfer[0].tx_buf = &st->tx_cmd_buf[0];
	133	st->xfer[0].len = 2;
	134
	135	spi_message_init(&st->msg[AD7887_CH0]);
	136	spi_message_add_tail(&st->xfer[0], &st->msg[AD7887_CH0]);
	137
	138	if (pdata && pdata->en_dual) {
	139	st->tx_cmd_buf[0] \|= AD7887_DUAL \| AD7887_REF_DIS;
	140
	141	st->tx_cmd_buf[2] = AD7887_CH_AIN1 \| AD7887_DUAL \|
	142	AD7887_REF_DIS \| AD7887_PM_MODE4;
	143	st->tx_cmd_buf[4] = AD7887_CH_AIN0 \| AD7887_DUAL \|
	144	AD7887_REF_DIS \| AD7887_PM_MODE4;
	145	st->tx_cmd_buf[6] = AD7887_CH_AIN1 \| AD7887_DUAL \|
	146	AD7887_REF_DIS \| AD7887_PM_MODE4;
	147
	148	st->xfer[1].rx_buf = &st->data[0];
	149	st->xfer[1].tx_buf = &st->tx_cmd_buf[2];
	150	st->xfer[1].len = 2;
	151
	152	st->xfer[2].rx_buf = &st->data[2];
	153	st->xfer[2].tx_buf = &st->tx_cmd_buf[4];
	154	st->xfer[2].len = 2;
	155
	156	spi_message_init(&st->msg[AD7887_CH0_CH1]);
	157	spi_message_add_tail(&st->xfer[1], &st->msg[AD7887_CH0_CH1]);
	158	spi_message_add_tail(&st->xfer[2], &st->msg[AD7887_CH0_CH1]);
	159
	160	st->xfer[3].rx_buf = &st->data[0];
	161	st->xfer[3].tx_buf = &st->tx_cmd_buf[6];
	162	st->xfer[3].len = 2;
	163
	164	spi_message_init(&st->msg[AD7887_CH1]);
	165	spi_message_add_tail(&st->xfer[3], &st->msg[AD7887_CH1]);
	166
2b4756aa MH	167	if (pdata && pdata->vref_mv)
	168	st->int_vref_mv = pdata->vref_mv;
	169	else if (voltage_uv)
	170	st->int_vref_mv = voltage_uv / 1000;
	171	else
	172	dev_warn(&spi->dev, "reference voltage unspecified\n");
	173
f39e086a MH	174	indio_dev->channels = st->chip_info->channel;
f39e086a MH	175	indio_dev->num_channels = 3;
2b4756aa MH	176	} else {
	177	if (pdata && pdata->vref_mv)
	178	st->int_vref_mv = pdata->vref_mv;
	179	else if (pdata && pdata->use_onchip_ref)
	180	st->int_vref_mv = st->chip_info->int_vref_mv;
	181	else
	182	dev_warn(&spi->dev, "reference voltage unspecified\n");
2b4756aa	183
f39e086a MH	184	indio_dev->channels = &st->chip_info->channel[1];
f39e086a MH	185	indio_dev->num_channels = 2;
596d0609	186	}
2b4756aa	187
f39e086a	188	ret = ad7887_register_ring_funcs_and_init(indio_dev);
2b4756aa	189	if (ret)
f39e086a	190	goto error_disable_reg;
2b4756aa	191
f39e086a	192	ret = iio_device_register(indio_dev);
2b4756aa	193	if (ret)
f39e086a MH	194	goto error_disable_reg;
f39e086a MH	195	regdone = 1;
2b4756aa	196
1aa04278	197	ret = iio_ring_buffer_register_ex(indio_dev, 0,
f39e086a MH	198	indio_dev->channels,
f39e086a MH	199	indio_dev->num_channels);
2b4756aa MH	200	if (ret)
	201	goto error_cleanup_ring;
	202	return 0;
	203
	204	error_cleanup_ring:
f39e086a	205	ad7887_ring_cleanup(indio_dev);
2b4756aa MH	206	error_disable_reg:
	207	if (!IS_ERR(st->reg))
	208	regulator_disable(st->reg);
	209	error_put_reg:
	210	if (!IS_ERR(st->reg))
	211	regulator_put(st->reg);
f39e086a MH	212	if (regdone)
	213	iio_device_unregister(indio_dev);
	214	else
	215	iio_free_device(indio_dev);
	216
2b4756aa MH	217	return ret;
	218	}
	219
	220	static int ad7887_remove(struct spi_device *spi)
	221	{
f39e086a MH	222	struct iio_dev *indio_dev = spi_get_drvdata(spi);
	223	struct ad7887_state *st = iio_priv(indio_dev);
	224
1aa04278	225	iio_ring_buffer_unregister(indio_dev);
2b4756aa	226	ad7887_ring_cleanup(indio_dev);
2b4756aa MH	227	if (!IS_ERR(st->reg)) {
	228	regulator_disable(st->reg);
	229	regulator_put(st->reg);
	230	}
f39e086a MH	231	iio_device_unregister(indio_dev);
f39e086a MH	232
2b4756aa MH	233	return 0;
	234	}
	235
	236	static const struct spi_device_id ad7887_id[] = {
	237	{"ad7887", ID_AD7887},
	238	{}
	239	};
	240
	241	static struct spi_driver ad7887_driver = {
	242	.driver = {
	243	.name = "ad7887",
	244	.bus = &spi_bus_type,
	245	.owner = THIS_MODULE,
	246	},
	247	.probe = ad7887_probe,
	248	.remove = __devexit_p(ad7887_remove),
	249	.id_table = ad7887_id,
	250	};
	251
	252	static int __init ad7887_init(void)
	253	{
	254	return spi_register_driver(&ad7887_driver);
	255	}
	256	module_init(ad7887_init);
	257
	258	static void __exit ad7887_exit(void)
	259	{
	260	spi_unregister_driver(&ad7887_driver);
	261	}
	262	module_exit(ad7887_exit);
	263
	264	MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
	265	MODULE_DESCRIPTION("Analog Devices AD7887 ADC");
	266	MODULE_LICENSE("GPL v2");
	267	MODULE_ALIAS("spi:ad7887");