[deliverable/linux.git] / drivers / iio / imu / adis.c

/*
 * Common library for ADIS16XXX devices
 *
 * Copyright 2012 Analog Devices Inc.
 *   Author: Lars-Peter Clausen <lars@metafoo.de>
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/spi/spi.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/module.h>
#include <asm/unaligned.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/buffer.h>
#include <linux/iio/imu/adis.h>

#define ADIS_MSC_CTRL_DATA_RDY_EN	BIT(2)
#define ADIS_MSC_CTRL_DATA_RDY_POL_HIGH	BIT(1)
#define ADIS_MSC_CTRL_DATA_RDY_DIO2	BIT(0)
#define ADIS_GLOB_CMD_SW_RESET		BIT(7)

int adis_write_reg(struct adis *adis, unsigned int reg,
	unsigned int value, unsigned int size)
{
	unsigned int page = reg / ADIS_PAGE_SIZE;
	int ret, i;
	struct spi_message msg;
	struct spi_transfer xfers[] = {
		{
			.tx_buf = adis->tx,
			.bits_per_word = 8,
			.len = 2,
			.cs_change = 1,
			.delay_usecs = adis->data->write_delay,
		}, {
			.tx_buf = adis->tx + 2,
			.bits_per_word = 8,
			.len = 2,
			.cs_change = 1,
			.delay_usecs = adis->data->write_delay,
		}, {
			.tx_buf = adis->tx + 4,
			.bits_per_word = 8,
			.len = 2,
			.cs_change = 1,
			.delay_usecs = adis->data->write_delay,
		}, {
			.tx_buf = adis->tx + 6,
			.bits_per_word = 8,
			.len = 2,
			.delay_usecs = adis->data->write_delay,
		}, {
			.tx_buf = adis->tx + 8,
			.bits_per_word = 8,
			.len = 2,
			.delay_usecs = adis->data->write_delay,
		},
	};

	mutex_lock(&adis->txrx_lock);

	spi_message_init(&msg);

	if (adis->current_page != page) {
		adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
		adis->tx[1] = page;
		spi_message_add_tail(&xfers[0], &msg);
	}

	switch (size) {
	case 4:
		adis->tx[8] = ADIS_WRITE_REG(reg + 3);
		adis->tx[9] = (value >> 24) & 0xff;
		adis->tx[6] = ADIS_WRITE_REG(reg + 2);
		adis->tx[7] = (value >> 16) & 0xff;
	case 2:
		adis->tx[4] = ADIS_WRITE_REG(reg + 1);
		adis->tx[5] = (value >> 8) & 0xff;
	case 1:
		adis->tx[2] = ADIS_WRITE_REG(reg);
		adis->tx[3] = value & 0xff;
		break;
	default:
		ret = -EINVAL;
		goto out_unlock;
	}

	xfers[size].cs_change = 0;

	for (i = 1; i <= size; i++)
		spi_message_add_tail(&xfers[i], &msg);

	ret = spi_sync(adis->spi, &msg);
	if (ret) {
		dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n",
				reg, ret);
	} else {
		adis->current_page = page;
	}

out_unlock:
	mutex_unlock(&adis->txrx_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(adis_write_reg);

/**
 * adis_read_reg() - read 2 bytes from a 16-bit register
 * @adis: The adis device
 * @reg: The address of the lower of the two registers
 * @val: The value read back from the device
 */
int adis_read_reg(struct adis *adis, unsigned int reg,
	unsigned int *val, unsigned int size)
{
	unsigned int page = reg / ADIS_PAGE_SIZE;
	struct spi_message msg;
	int ret;
	struct spi_transfer xfers[] = {
		{
			.tx_buf = adis->tx,
			.bits_per_word = 8,
			.len = 2,
			.cs_change = 1,
			.delay_usecs = adis->data->write_delay,
		}, {
			.tx_buf = adis->tx + 2,
			.bits_per_word = 8,
			.len = 2,
			.cs_change = 1,
			.delay_usecs = adis->data->read_delay,
		}, {
			.tx_buf = adis->tx + 4,
			.rx_buf = adis->rx,
			.bits_per_word = 8,
			.len = 2,
			.cs_change = 1,
			.delay_usecs = adis->data->read_delay,
		}, {
			.rx_buf = adis->rx + 2,
			.bits_per_word = 8,
			.len = 2,
			.delay_usecs = adis->data->read_delay,
		},
	};

	mutex_lock(&adis->txrx_lock);
	spi_message_init(&msg);

	if (adis->current_page != page) {
		adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
		adis->tx[1] = page;
		spi_message_add_tail(&xfers[0], &msg);
	}

	switch (size) {
	case 4:
		adis->tx[2] = ADIS_READ_REG(reg + 2);
		adis->tx[3] = 0;
		spi_message_add_tail(&xfers[1], &msg);
	case 2:
		adis->tx[4] = ADIS_READ_REG(reg);
		adis->tx[5] = 0;
		spi_message_add_tail(&xfers[2], &msg);
		spi_message_add_tail(&xfers[3], &msg);
		break;
	default:
		ret = -EINVAL;
		goto out_unlock;
	}

	ret = spi_sync(adis->spi, &msg);
	if (ret) {
		dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n",
				reg, ret);
		goto out_unlock;
	} else {
		adis->current_page = page;
	}

	switch (size) {
	case 4:
		*val = get_unaligned_be32(adis->rx);
		break;
	case 2:
		*val = get_unaligned_be16(adis->rx + 2);
		break;
	}

out_unlock:
	mutex_unlock(&adis->txrx_lock);

	return ret;
}
EXPORT_SYMBOL_GPL(adis_read_reg);

#ifdef CONFIG_DEBUG_FS

int adis_debugfs_reg_access(struct iio_dev *indio_dev,
	unsigned int reg, unsigned int writeval, unsigned int *readval)
{
	struct adis *adis = iio_device_get_drvdata(indio_dev);

	if (readval) {
		uint16_t val16;
		int ret;

		ret = adis_read_reg_16(adis, reg, &val16);
		*readval = val16;

		return ret;
	} else {
		return adis_write_reg_16(adis, reg, writeval);
	}
}
EXPORT_SYMBOL(adis_debugfs_reg_access);

#endif

/**
 * adis_enable_irq() - Enable or disable data ready IRQ
 * @adis: The adis device
 * @enable: Whether to enable the IRQ
 *
 * Returns 0 on success, negative error code otherwise
 */
int adis_enable_irq(struct adis *adis, bool enable)
{
	int ret = 0;
	uint16_t msc;

	if (adis->data->enable_irq)
		return adis->data->enable_irq(adis, enable);

	ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
	if (ret)
		goto error_ret;

	msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;
	msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;
	if (enable)
		msc |= ADIS_MSC_CTRL_DATA_RDY_EN;
	else
		msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;

	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);

error_ret:
	return ret;
}
EXPORT_SYMBOL(adis_enable_irq);

/**
 * adis_check_status() - Check the device for error conditions
 * @adis: The adis device
 *
 * Returns 0 on success, a negative error code otherwise
 */
int adis_check_status(struct adis *adis)
{
	uint16_t status;
	int ret;
	int i;

	ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status);
	if (ret < 0)
		return ret;

	status &= adis->data->status_error_mask;

	if (status == 0)
		return 0;

	for (i = 0; i < 16; ++i) {
		if (status & BIT(i)) {
			dev_err(&adis->spi->dev, "%s.\n",
				adis->data->status_error_msgs[i]);
		}
	}

	return -EIO;
}
EXPORT_SYMBOL_GPL(adis_check_status);

/**
 * adis_reset() - Reset the device
 * @adis: The adis device
 *
 * Returns 0 on success, a negative error code otherwise
 */
int adis_reset(struct adis *adis)
{
	int ret;

	ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg,
			ADIS_GLOB_CMD_SW_RESET);
	if (ret)
		dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret);

	return ret;
}
EXPORT_SYMBOL_GPL(adis_reset);

static int adis_self_test(struct adis *adis)
{
	int ret;

	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg,
			adis->data->self_test_mask);
	if (ret) {
		dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n",
			ret);
		return ret;
	}

	msleep(adis->data->startup_delay);

	ret = adis_check_status(adis);

	if (adis->data->self_test_no_autoclear)
		adis_write_reg_16(adis, adis->data->msc_ctrl_reg, 0x00);

	return ret;
}

/**
 * adis_inital_startup() - Performs device self-test
 * @adis: The adis device
 *
 * Returns 0 if the device is operational, a negative error code otherwise.
 *
 * This function should be called early on in the device initialization sequence
 * to ensure that the device is in a sane and known state and that it is usable.
 */
int adis_initial_startup(struct adis *adis)
{
	int ret;

	ret = adis_self_test(adis);
	if (ret) {
		dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n");
		adis_reset(adis);
		msleep(adis->data->startup_delay);
		ret = adis_self_test(adis);
		if (ret) {
			dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n");
			return ret;
		}
	}

	return 0;
}
EXPORT_SYMBOL_GPL(adis_initial_startup);

/**
 * adis_single_conversion() - Performs a single sample conversion
 * @indio_dev: The IIO device
 * @chan: The IIO channel
 * @error_mask: Mask for the error bit
 * @val: Result of the conversion
 *
 * Returns IIO_VAL_INT on success, a negative error code otherwise.
 *
 * The function performs a single conversion on a given channel and post
 * processes the value accordingly to the channel spec. If a error_mask is given
 * the function will check if the mask is set in the returned raw value. If it
 * is set the function will perform a self-check. If the device does not report
 * a error bit in the channels raw value set error_mask to 0.
 */
int adis_single_conversion(struct iio_dev *indio_dev,
	const struct iio_chan_spec *chan, unsigned int error_mask, int *val)
{
	struct adis *adis = iio_device_get_drvdata(indio_dev);
	unsigned int uval;
	int ret;

	mutex_lock(&indio_dev->mlock);

	ret = adis_read_reg(adis, chan->address, &uval,
			chan->scan_type.storagebits / 8);
	if (ret)
		goto err_unlock;

	if (uval & error_mask) {
		ret = adis_check_status(adis);
		if (ret)
			goto err_unlock;
	}

	if (chan->scan_type.sign == 's')
		*val = sign_extend32(uval, chan->scan_type.realbits - 1);
	else
		*val = uval & ((1 << chan->scan_type.realbits) - 1);

	ret = IIO_VAL_INT;
err_unlock:
	mutex_unlock(&indio_dev->mlock);
	return ret;
}
EXPORT_SYMBOL_GPL(adis_single_conversion);

/**
 * adis_init() - Initialize adis device structure
 * @adis:	The adis device
 * @indio_dev:	The iio device
 * @spi:	The spi device
 * @data:	Chip specific data
 *
 * Returns 0 on success, a negative error code otherwise.
 *
 * This function must be called, before any other adis helper function may be
 * called.
 */
int adis_init(struct adis *adis, struct iio_dev *indio_dev,
	struct spi_device *spi, const struct adis_data *data)
{
	mutex_init(&adis->txrx_lock);
	adis->spi = spi;
	adis->data = data;
	iio_device_set_drvdata(indio_dev, adis);

	if (data->has_paging) {
		/* Need to set the page before first read/write */
		adis->current_page = -1;
	} else {
		/* Page will always be 0 */
		adis->current_page = 0;
	}

	return adis_enable_irq(adis, false);
}
EXPORT_SYMBOL_GPL(adis_init);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("Common library code for ADIS16XXX devices");
Commit	Line	Data
ccd2b52f LPC	1	/*
	2	* Common library for ADIS16XXX devices
	3	*
	4	* Copyright 2012 Analog Devices Inc.
	5	* Author: Lars-Peter Clausen <lars@metafoo.de>
	6	*
	7	* Licensed under the GPL-2 or later.
	8	*/
	9
	10	#include <linux/delay.h>
	11	#include <linux/mutex.h>
	12	#include <linux/device.h>
	13	#include <linux/kernel.h>
	14	#include <linux/spi/spi.h>
	15	#include <linux/slab.h>
	16	#include <linux/sysfs.h>
	17	#include <linux/module.h>
	18	#include <asm/unaligned.h>
	19
	20	#include <linux/iio/iio.h>
	21	#include <linux/iio/sysfs.h>
	22	#include <linux/iio/buffer.h>
ec04cb04	23	#include <linux/iio/imu/adis.h>
ccd2b52f LPC	24
	25	#define ADIS_MSC_CTRL_DATA_RDY_EN BIT(2)
	26	#define ADIS_MSC_CTRL_DATA_RDY_POL_HIGH BIT(1)
	27	#define ADIS_MSC_CTRL_DATA_RDY_DIO2 BIT(0)
	28	#define ADIS_GLOB_CMD_SW_RESET BIT(7)
	29
57a1228a LPC	30	int adis_write_reg(struct adis *adis, unsigned int reg,
57a1228a LPC	31	unsigned int value, unsigned int size)
ccd2b52f	32	{
484a0bf0	33	unsigned int page = reg / ADIS_PAGE_SIZE;
57a1228a	34	int ret, i;
ccd2b52f LPC	35	struct spi_message msg;
	36	struct spi_transfer xfers[] = {
	37	{
	38	.tx_buf = adis->tx,
	39	.bits_per_word = 8,
	40	.len = 2,
	41	.cs_change = 1,
	42	.delay_usecs = adis->data->write_delay,
	43	}, {
	44	.tx_buf = adis->tx + 2,
	45	.bits_per_word = 8,
	46	.len = 2,
57a1228a LPC	47	.cs_change = 1,
	48	.delay_usecs = adis->data->write_delay,
	49	}, {
	50	.tx_buf = adis->tx + 4,
	51	.bits_per_word = 8,
	52	.len = 2,
	53	.cs_change = 1,
	54	.delay_usecs = adis->data->write_delay,
	55	}, {
	56	.tx_buf = adis->tx + 6,
	57	.bits_per_word = 8,
	58	.len = 2,
ccd2b52f	59	.delay_usecs = adis->data->write_delay,
484a0bf0 LPC	60	}, {
	61	.tx_buf = adis->tx + 8,
	62	.bits_per_word = 8,
	63	.len = 2,
	64	.delay_usecs = adis->data->write_delay,
ccd2b52f LPC	65	},
	66	};
	67
	68	mutex_lock(&adis->txrx_lock);
ccd2b52f LPC	69
ccd2b52f LPC	70	spi_message_init(&msg);
484a0bf0 LPC	71
	72	if (adis->current_page != page) {
	73	adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
	74	adis->tx[1] = page;
	75	spi_message_add_tail(&xfers[0], &msg);
	76	}
	77
57a1228a LPC	78	switch (size) {
57a1228a LPC	79	case 4:
484a0bf0 LPC	80	adis->tx[8] = ADIS_WRITE_REG(reg + 3);
	81	adis->tx[9] = (value >> 24) & 0xff;
	82	adis->tx[6] = ADIS_WRITE_REG(reg + 2);
	83	adis->tx[7] = (value >> 16) & 0xff;
57a1228a	84	case 2:
484a0bf0 LPC	85	adis->tx[4] = ADIS_WRITE_REG(reg + 1);
484a0bf0 LPC	86	adis->tx[5] = (value >> 8) & 0xff;
57a1228a	87	case 1:
484a0bf0 LPC	88	adis->tx[2] = ADIS_WRITE_REG(reg);
484a0bf0 LPC	89	adis->tx[3] = value & 0xff;
57a1228a LPC	90	break;
	91	default:
	92	ret = -EINVAL;
	93	goto out_unlock;
	94	}
	95
484a0bf0	96	xfers[size].cs_change = 0;
57a1228a	97
484a0bf0	98	for (i = 1; i <= size; i++)
57a1228a LPC	99	spi_message_add_tail(&xfers[i], &msg);
57a1228a LPC	100
ccd2b52f	101	ret = spi_sync(adis->spi, &msg);
57a1228a LPC	102	if (ret) {
	103	dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n",
	104	reg, ret);
484a0bf0 LPC	105	} else {
484a0bf0 LPC	106	adis->current_page = page;
57a1228a LPC	107	}
	108
	109	out_unlock:
ccd2b52f LPC	110	mutex_unlock(&adis->txrx_lock);
	111
	112	return ret;
	113	}
57a1228a	114	EXPORT_SYMBOL_GPL(adis_write_reg);
ccd2b52f LPC	115
ccd2b52f LPC	116	/**
57a1228a	117	* adis_read_reg() - read 2 bytes from a 16-bit register
ccd2b52f LPC	118	* @adis: The adis device
	119	* @reg: The address of the lower of the two registers
	120	* @val: The value read back from the device
	121	*/
57a1228a LPC	122	int adis_read_reg(struct adis *adis, unsigned int reg,
57a1228a LPC	123	unsigned int *val, unsigned int size)
ccd2b52f	124	{
484a0bf0	125	unsigned int page = reg / ADIS_PAGE_SIZE;
ccd2b52f LPC	126	struct spi_message msg;
	127	int ret;
	128	struct spi_transfer xfers[] = {
	129	{
	130	.tx_buf = adis->tx,
	131	.bits_per_word = 8,
	132	.len = 2,
	133	.cs_change = 1,
484a0bf0	134	.delay_usecs = adis->data->write_delay,
ccd2b52f	135	}, {
57a1228a	136	.tx_buf = adis->tx + 2,
484a0bf0 LPC	137	.bits_per_word = 8,
	138	.len = 2,
	139	.cs_change = 1,
	140	.delay_usecs = adis->data->read_delay,
	141	}, {
	142	.tx_buf = adis->tx + 4,
ccd2b52f LPC	143	.rx_buf = adis->rx,
	144	.bits_per_word = 8,
	145	.len = 2,
57a1228a LPC	146	.cs_change = 1,
	147	.delay_usecs = adis->data->read_delay,
	148	}, {
	149	.rx_buf = adis->rx + 2,
	150	.bits_per_word = 8,
	151	.len = 2,
ccd2b52f LPC	152	.delay_usecs = adis->data->read_delay,
	153	},
	154	};
	155
	156	mutex_lock(&adis->txrx_lock);
ccd2b52f	157	spi_message_init(&msg);
57a1228a	158
484a0bf0 LPC	159	if (adis->current_page != page) {
	160	adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID);
	161	adis->tx[1] = page;
	162	spi_message_add_tail(&xfers[0], &msg);
	163	}
	164
57a1228a LPC	165	switch (size) {
57a1228a LPC	166	case 4:
484a0bf0	167	adis->tx[2] = ADIS_READ_REG(reg + 2);
57a1228a LPC	168	adis->tx[3] = 0;
57a1228a LPC	169	spi_message_add_tail(&xfers[1], &msg);
484a0bf0 LPC	170	case 2:
	171	adis->tx[4] = ADIS_READ_REG(reg);
	172	adis->tx[5] = 0;
57a1228a	173	spi_message_add_tail(&xfers[2], &msg);
484a0bf0	174	spi_message_add_tail(&xfers[3], &msg);
57a1228a LPC	175	break;
	176	default:
	177	ret = -EINVAL;
	178	goto out_unlock;
	179	}
	180
ccd2b52f LPC	181	ret = spi_sync(adis->spi, &msg);
ccd2b52f LPC	182	if (ret) {
57a1228a	183	dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n",
ccd2b52f	184	reg, ret);
57a1228a	185	goto out_unlock;
484a0bf0 LPC	186	} else {
484a0bf0 LPC	187	adis->current_page = page;
ccd2b52f	188	}
ccd2b52f	189
57a1228a LPC	190	switch (size) {
	191	case 4:
	192	*val = get_unaligned_be32(adis->rx);
	193	break;
	194	case 2:
	195	*val = get_unaligned_be16(adis->rx + 2);
	196	break;
	197	}
	198
	199	out_unlock:
ccd2b52f	200	mutex_unlock(&adis->txrx_lock);
57a1228a	201
ccd2b52f LPC	202	return ret;
ccd2b52f LPC	203	}
57a1228a	204	EXPORT_SYMBOL_GPL(adis_read_reg);
ccd2b52f	205
78026a6f LPC	206	#ifdef CONFIG_DEBUG_FS
	207
	208	int adis_debugfs_reg_access(struct iio_dev *indio_dev,
	209	unsigned int reg, unsigned int writeval, unsigned int *readval)
	210	{
	211	struct adis *adis = iio_device_get_drvdata(indio_dev);
	212
	213	if (readval) {
	214	uint16_t val16;
	215	int ret;
	216
	217	ret = adis_read_reg_16(adis, reg, &val16);
	218	*readval = val16;
	219
	220	return ret;
	221	} else {
	222	return adis_write_reg_16(adis, reg, writeval);
	223	}
	224	}
	225	EXPORT_SYMBOL(adis_debugfs_reg_access);
	226
	227	#endif
	228
ccd2b52f LPC	229	/**
	230	* adis_enable_irq() - Enable or disable data ready IRQ
	231	* @adis: The adis device
	232	* @enable: Whether to enable the IRQ
	233	*
	234	* Returns 0 on success, negative error code otherwise
	235	*/
	236	int adis_enable_irq(struct adis *adis, bool enable)
	237	{
	238	int ret = 0;
	239	uint16_t msc;
	240
2f3abe6c LPC	241	if (adis->data->enable_irq)
	242	return adis->data->enable_irq(adis, enable);
	243
ccd2b52f LPC	244	ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
	245	if (ret)
	246	goto error_ret;
	247
	248	msc \|= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;
	249	msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;
	250	if (enable)
	251	msc \|= ADIS_MSC_CTRL_DATA_RDY_EN;
	252	else
	253	msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;
	254
	255	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);
	256
	257	error_ret:
	258	return ret;
	259	}
	260	EXPORT_SYMBOL(adis_enable_irq);
	261
	262	/**
	263	* adis_check_status() - Check the device for error conditions
	264	* @adis: The adis device
	265	*
	266	* Returns 0 on success, a negative error code otherwise
	267	*/
	268	int adis_check_status(struct adis *adis)
	269	{
	270	uint16_t status;
	271	int ret;
	272	int i;
	273
	274	ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status);
	275	if (ret < 0)
	276	return ret;
	277
	278	status &= adis->data->status_error_mask;
	279
	280	if (status == 0)
	281	return 0;
	282
	283	for (i = 0; i < 16; ++i) {
	284	if (status & BIT(i)) {
	285	dev_err(&adis->spi->dev, "%s.\n",
	286	adis->data->status_error_msgs[i]);
	287	}
	288	}
	289
	290	return -EIO;
	291	}
	292	EXPORT_SYMBOL_GPL(adis_check_status);
	293
	294	/**
	295	* adis_reset() - Reset the device
	296	* @adis: The adis device
	297	*
	298	* Returns 0 on success, a negative error code otherwise
	299	*/
	300	int adis_reset(struct adis *adis)
	301	{
	302	int ret;
	303
	304	ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg,
	305	ADIS_GLOB_CMD_SW_RESET);
	306	if (ret)
	307	dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret);
308
309	return ret;
310	}
311	EXPORT_SYMBOL_GPL(adis_reset);
312
313	static int adis_self_test(struct adis *adis)
314	{
315	int ret;
316
317	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg,
318	adis->data->self_test_mask);
319	if (ret) {
320	dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n",
321	ret);
322	return ret;
323	}
324
325	msleep(adis->data->startup_delay);
326
af8a4127 LPC	327	ret = adis_check_status(adis);
	328
	329	if (adis->data->self_test_no_autoclear)
	330	adis_write_reg_16(adis, adis->data->msc_ctrl_reg, 0x00);
	331
	332	return ret;
ccd2b52f LPC	333	}
	334
	335	/**
	336	* adis_inital_startup() - Performs device self-test
	337	* @adis: The adis device
	338	*
	339	* Returns 0 if the device is operational, a negative error code otherwise.
	340	*
	341	* This function should be called early on in the device initialization sequence
	342	* to ensure that the device is in a sane and known state and that it is usable.
	343	*/
	344	int adis_initial_startup(struct adis *adis)
	345	{
	346	int ret;
	347
	348	ret = adis_self_test(adis);
	349	if (ret) {
	350	dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n");
	351	adis_reset(adis);
	352	msleep(adis->data->startup_delay);
	353	ret = adis_self_test(adis);
	354	if (ret) {
	355	dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n");
	356	return ret;
	357	}
	358	}
	359
	360	return 0;
	361	}
	362	EXPORT_SYMBOL_GPL(adis_initial_startup);
	363
	364	/**
	365	* adis_single_conversion() - Performs a single sample conversion
	366	* @indio_dev: The IIO device
	367	* @chan: The IIO channel
	368	* @error_mask: Mask for the error bit
	369	* @val: Result of the conversion
	370	*
	371	* Returns IIO_VAL_INT on success, a negative error code otherwise.
	372	*
	373	* The function performs a single conversion on a given channel and post
	374	* processes the value accordingly to the channel spec. If a error_mask is given
	375	* the function will check if the mask is set in the returned raw value. If it
	376	* is set the function will perform a self-check. If the device does not report
	377	* a error bit in the channels raw value set error_mask to 0.
	378	*/
	379	int adis_single_conversion(struct iio_dev *indio_dev,
	380	const struct iio_chan_spec chan, unsigned int error_mask, int val)
	381	{
	382	struct adis *adis = iio_device_get_drvdata(indio_dev);
57a1228a	383	unsigned int uval;
ccd2b52f LPC	384	int ret;
	385
	386	mutex_lock(&indio_dev->mlock);
	387
57a1228a LPC	388	ret = adis_read_reg(adis, chan->address, &uval,
57a1228a LPC	389	chan->scan_type.storagebits / 8);
ccd2b52f LPC	390	if (ret)
	391	goto err_unlock;
	392
57a1228a	393	if (uval & error_mask) {
ccd2b52f LPC	394	ret = adis_check_status(adis);
	395	if (ret)
	396	goto err_unlock;
	397	}
	398
	399	if (chan->scan_type.sign == 's')
57a1228a	400	*val = sign_extend32(uval, chan->scan_type.realbits - 1);
ccd2b52f	401	else
57a1228a	402	*val = uval & ((1 << chan->scan_type.realbits) - 1);
ccd2b52f LPC	403
	404	ret = IIO_VAL_INT;
	405	err_unlock:
	406	mutex_unlock(&indio_dev->mlock);
	407	return ret;
	408	}
	409	EXPORT_SYMBOL_GPL(adis_single_conversion);
	410
	411	/**
	412	* adis_init() - Initialize adis device structure
	413	* @adis: The adis device
	414	* @indio_dev: The iio device
	415	* @spi: The spi device
	416	* @data: Chip specific data
	417	*
	418	* Returns 0 on success, a negative error code otherwise.
	419	*
	420	* This function must be called, before any other adis helper function may be
	421	* called.
	422	*/
	423	int adis_init(struct adis adis, struct iio_dev indio_dev,
	424	struct spi_device spi, const struct adis_data data)
	425	{
	426	mutex_init(&adis->txrx_lock);
	427	adis->spi = spi;
	428	adis->data = data;
	429	iio_device_set_drvdata(indio_dev, adis);
	430
484a0bf0 LPC	431	if (data->has_paging) {
	432	/* Need to set the page before first read/write */
	433	adis->current_page = -1;
	434	} else {
	435	/* Page will always be 0 */
	436	adis->current_page = 0;
	437	}
	438
ccd2b52f LPC	439	return adis_enable_irq(adis, false);
	440	}
	441	EXPORT_SYMBOL_GPL(adis_init);
	442
	443	MODULE_LICENSE("GPL");
	444	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	445	MODULE_DESCRIPTION("Common library code for ADIS16XXX devices");