1 files changed, 337 insertions, 0 deletions
diff --git a/drivers/iio/imu/adis.c b/drivers/iio/imu/adis.c
new file mode 100644
index 000000000000..8259b774078f
--- /dev/null
+++ b/drivers/iio/imu/adis.c
@@ -0,0 +1,337 @@
+/*
+ * 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)
+/**
+ * adis_write_reg_8() - Write single byte to a register
+ * @adis: The adis device
+ * @reg: The address of the register to be written
+ * @val: The value to write
+ */
+int adis_write_reg_8(struct adis *adis, unsigned int reg, uint8_t val)
+{
+        int ret;
+        mutex_lock(&adis->txrx_lock);
+        adis->tx[0] = ADIS_WRITE_REG(reg);
+        adis->tx[1] = val;
+        ret = spi_write(adis->spi, adis->tx, 2);
+        mutex_unlock(&adis->txrx_lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(adis_write_reg_8);
+/**
+ * adis_write_reg_16() - Write 2 bytes to a pair of registers
+ * @adis: The adis device
+ * @reg: The address of the lower of the two registers
+ * @val: Value to be written
+ */
+int adis_write_reg_16(struct adis *adis, unsigned int reg, uint16_t value)
+{
+        int ret;
+        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,
+                        .delay_usecs = adis->data->write_delay,
+                },
+        };
+        mutex_lock(&adis->txrx_lock);
+        adis->tx[0] = ADIS_WRITE_REG(reg);
+        adis->tx[1] = value & 0xff;
+        adis->tx[2] = ADIS_WRITE_REG(reg + 1);
+        adis->tx[3] = (value >> 8) & 0xff;
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfers[0], &msg);
+        spi_message_add_tail(&xfers[1], &msg);
+        ret = spi_sync(adis->spi, &msg);
+        mutex_unlock(&adis->txrx_lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(adis_write_reg_16);
+/**
+ * adis_read_reg_16() - 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_16(struct adis *adis, unsigned int reg, uint16_t *val)
+{
+        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->read_delay,
+                }, {
+                        .rx_buf = adis->rx,
+                        .bits_per_word = 8,
+                        .len = 2,
+                        .delay_usecs = adis->data->read_delay,
+                },
+        };
+        mutex_lock(&adis->txrx_lock);
+        adis->tx[0] = ADIS_READ_REG(reg);
+        adis->tx[1] = 0;
+        spi_message_init(&msg);
+        spi_message_add_tail(&xfers[0], &msg);
+        spi_message_add_tail(&xfers[1], &msg);
+        ret = spi_sync(adis->spi, &msg);
+        if (ret) {
+                dev_err(&adis->spi->dev, "Failed to read 16 bit register 0x%02X: %d\n",
+                                reg, ret);
+                goto error_ret;
+        }
+        *val = get_unaligned_be16(adis->rx);
+error_ret:
+        mutex_unlock(&adis->txrx_lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(adis_read_reg_16);
+/**
+ * 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;
+        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);
+        return adis_check_status(adis);
+}
+/**
+ * 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);
+        uint16_t val16;
+        int ret;
+        mutex_lock(&indio_dev->mlock);
+        ret = adis_read_reg_16(adis, chan->address, &val16);
+        if (ret)
+                goto err_unlock;
+        if (val16 & error_mask) {
+                ret = adis_check_status(adis);
+                if (ret)
+                        goto err_unlock;
+        }
+        if (chan->scan_type.sign == 's')
+                *val = sign_extend32(val16, chan->scan_type.realbits - 1);
+        else
+                *val = val16 & ((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);
+        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");

diff --git a/drivers/iio/imu/adis.c b/drivers/iio/imu/adis.c new file mode 100644 index 000000000000..8259b774078f --- /dev/null +++ b/drivers/iio/imu/adis.c
@@ -0,0 +1,337 @@
	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>
	23	#include <linux/iio/imu/adis.h>
	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
	30	/**
	31	* adis_write_reg_8() - Write single byte to a register
	32	* @adis: The adis device
	33	* @reg: The address of the register to be written
	34	* @val: The value to write
	35	*/
	36	int adis_write_reg_8(struct adis *adis, unsigned int reg, uint8_t val)
	37	{
	38	int ret;
	39
	40	mutex_lock(&adis->txrx_lock);
	41	adis->tx[0] = ADIS_WRITE_REG(reg);
	42	adis->tx[1] = val;
	43
	44	ret = spi_write(adis->spi, adis->tx, 2);
	45	mutex_unlock(&adis->txrx_lock);
	46
	47	return ret;
	48	}
	49	EXPORT_SYMBOL_GPL(adis_write_reg_8);
	50
	51	/**
	52	* adis_write_reg_16() - Write 2 bytes to a pair of registers
	53	* @adis: The adis device
	54	* @reg: The address of the lower of the two registers
	55	* @val: Value to be written
	56	*/
	57	int adis_write_reg_16(struct adis *adis, unsigned int reg, uint16_t value)
	58	{
	59	int ret;
	60	struct spi_message msg;
	61	struct spi_transfer xfers[] = {
	62	{
	63	.tx_buf = adis->tx,
	64	.bits_per_word = 8,
	65	.len = 2,
	66	.cs_change = 1,
	67	.delay_usecs = adis->data->write_delay,
	68	}, {
	69	.tx_buf = adis->tx + 2,
	70	.bits_per_word = 8,
	71	.len = 2,
	72	.delay_usecs = adis->data->write_delay,
	73	},
	74	};
	75
	76	mutex_lock(&adis->txrx_lock);
	77	adis->tx[0] = ADIS_WRITE_REG(reg);
	78	adis->tx[1] = value & 0xff;
	79	adis->tx[2] = ADIS_WRITE_REG(reg + 1);
	80	adis->tx[3] = (value >> 8) & 0xff;
	81
	82	spi_message_init(&msg);
	83	spi_message_add_tail(&xfers[0], &msg);
	84	spi_message_add_tail(&xfers[1], &msg);
	85	ret = spi_sync(adis->spi, &msg);
	86	mutex_unlock(&adis->txrx_lock);
	87
	88	return ret;
	89	}
	90	EXPORT_SYMBOL_GPL(adis_write_reg_16);
	91
	92	/**
	93	* adis_read_reg_16() - read 2 bytes from a 16-bit register
	94	* @adis: The adis device
	95	* @reg: The address of the lower of the two registers
	96	* @val: The value read back from the device
	97	*/
	98	int adis_read_reg_16(struct adis adis, unsigned int reg, uint16_t val)
	99	{
	100	struct spi_message msg;
	101	int ret;
	102	struct spi_transfer xfers[] = {
	103	{
	104	.tx_buf = adis->tx,
	105	.bits_per_word = 8,
	106	.len = 2,
	107	.cs_change = 1,
	108	.delay_usecs = adis->data->read_delay,
	109	}, {
	110	.rx_buf = adis->rx,
	111	.bits_per_word = 8,
	112	.len = 2,
	113	.delay_usecs = adis->data->read_delay,
	114	},
	115	};
	116
	117	mutex_lock(&adis->txrx_lock);
	118	adis->tx[0] = ADIS_READ_REG(reg);
	119	adis->tx[1] = 0;
	120
	121	spi_message_init(&msg);
	122	spi_message_add_tail(&xfers[0], &msg);
	123	spi_message_add_tail(&xfers[1], &msg);
	124	ret = spi_sync(adis->spi, &msg);
	125	if (ret) {
	126	dev_err(&adis->spi->dev, "Failed to read 16 bit register 0x%02X: %d\n",
	127	reg, ret);
	128	goto error_ret;
	129	}
	130	*val = get_unaligned_be16(adis->rx);
	131
	132	error_ret:
	133	mutex_unlock(&adis->txrx_lock);
	134	return ret;
	135	}
	136	EXPORT_SYMBOL_GPL(adis_read_reg_16);
	137
	138	/**
	139	* adis_enable_irq() - Enable or disable data ready IRQ
	140	* @adis: The adis device
	141	* @enable: Whether to enable the IRQ
	142	*
	143	* Returns 0 on success, negative error code otherwise
	144	*/
	145	int adis_enable_irq(struct adis *adis, bool enable)
	146	{
	147	int ret = 0;
	148	uint16_t msc;
	149
	150	ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);
	151	if (ret)
	152	goto error_ret;
	153
	154	msc \|= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;
	155	msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;
	156	if (enable)
	157	msc \|= ADIS_MSC_CTRL_DATA_RDY_EN;
	158	else
	159	msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;
	160
	161	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);
	162
	163	error_ret:
	164	return ret;
	165	}
	166	EXPORT_SYMBOL(adis_enable_irq);
	167
	168	/**
	169	* adis_check_status() - Check the device for error conditions
	170	* @adis: The adis device
	171	*
	172	* Returns 0 on success, a negative error code otherwise
	173	*/
	174	int adis_check_status(struct adis *adis)
	175	{
	176	uint16_t status;
	177	int ret;
	178	int i;
	179
	180	ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status);
	181	if (ret < 0)
	182	return ret;
	183
	184	status &= adis->data->status_error_mask;
	185
	186	if (status == 0)
	187	return 0;
	188
	189	for (i = 0; i < 16; ++i) {
	190	if (status & BIT(i)) {
	191	dev_err(&adis->spi->dev, "%s.\n",
	192	adis->data->status_error_msgs[i]);
	193	}
	194	}
	195
	196	return -EIO;
	197	}
	198	EXPORT_SYMBOL_GPL(adis_check_status);
	199
	200	/**
	201	* adis_reset() - Reset the device
	202	* @adis: The adis device
	203	*
	204	* Returns 0 on success, a negative error code otherwise
	205	*/
	206	int adis_reset(struct adis *adis)
	207	{
	208	int ret;
	209
	210	ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg,
	211	ADIS_GLOB_CMD_SW_RESET);
	212	if (ret)
	213	dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret);
	214
	215	return ret;
	216	}
	217	EXPORT_SYMBOL_GPL(adis_reset);
	218
	219	static int adis_self_test(struct adis *adis)
	220	{
	221	int ret;
	222
	223	ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg,
	224	adis->data->self_test_mask);
	225	if (ret) {
	226	dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n",
	227	ret);
	228	return ret;
	229	}
	230
	231	msleep(adis->data->startup_delay);
	232
	233	return adis_check_status(adis);
	234	}
	235
	236	/**
	237	* adis_inital_startup() - Performs device self-test
	238	* @adis: The adis device
	239	*
	240	* Returns 0 if the device is operational, a negative error code otherwise.
	241	*
	242	* This function should be called early on in the device initialization sequence
	243	* to ensure that the device is in a sane and known state and that it is usable.
	244	*/
	245	int adis_initial_startup(struct adis *adis)
	246	{
	247	int ret;
	248
	249	ret = adis_self_test(adis);
	250	if (ret) {
	251	dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n");
	252	adis_reset(adis);
	253	msleep(adis->data->startup_delay);
	254	ret = adis_self_test(adis);
	255	if (ret) {
	256	dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n");
	257	return ret;
	258	}
	259	}
	260
	261	return 0;
	262	}
	263	EXPORT_SYMBOL_GPL(adis_initial_startup);
	264
	265	/**
	266	* adis_single_conversion() - Performs a single sample conversion
	267	* @indio_dev: The IIO device
	268	* @chan: The IIO channel
	269	* @error_mask: Mask for the error bit
	270	* @val: Result of the conversion
	271	*
	272	* Returns IIO_VAL_INT on success, a negative error code otherwise.
	273	*
	274	* The function performs a single conversion on a given channel and post
	275	* processes the value accordingly to the channel spec. If a error_mask is given
	276	* the function will check if the mask is set in the returned raw value. If it
	277	* is set the function will perform a self-check. If the device does not report
	278	* a error bit in the channels raw value set error_mask to 0.
	279	*/
	280	int adis_single_conversion(struct iio_dev *indio_dev,
	281	const struct iio_chan_spec chan, unsigned int error_mask, int val)
	282	{
	283	struct adis *adis = iio_device_get_drvdata(indio_dev);
	284	uint16_t val16;
	285	int ret;
	286
	287	mutex_lock(&indio_dev->mlock);
	288
	289	ret = adis_read_reg_16(adis, chan->address, &val16);
	290	if (ret)
	291	goto err_unlock;
	292
	293	if (val16 & error_mask) {
	294	ret = adis_check_status(adis);
	295	if (ret)
	296	goto err_unlock;
	297	}
	298
	299	if (chan->scan_type.sign == 's')
	300	*val = sign_extend32(val16, chan->scan_type.realbits - 1);
	301	else
	302	*val = val16 & ((1 << chan->scan_type.realbits) - 1);
	303
	304	ret = IIO_VAL_INT;
	305	err_unlock:
	306	mutex_unlock(&indio_dev->mlock);
	307	return ret;
	308	}
	309	EXPORT_SYMBOL_GPL(adis_single_conversion);
	310
	311	/**
	312	* adis_init() - Initialize adis device structure
	313	* @adis: The adis device
	314	* @indio_dev: The iio device
	315	* @spi: The spi device
	316	* @data: Chip specific data
	317	*
	318	* Returns 0 on success, a negative error code otherwise.
	319	*
	320	* This function must be called, before any other adis helper function may be
	321	* called.
	322	*/
	323	int adis_init(struct adis adis, struct iio_dev indio_dev,
	324	struct spi_device spi, const struct adis_data data)
	325	{
	326	mutex_init(&adis->txrx_lock);
	327	adis->spi = spi;
	328	adis->data = data;
	329	iio_device_set_drvdata(indio_dev, adis);
	330
	331	return adis_enable_irq(adis, false);
	332	}
	333	EXPORT_SYMBOL_GPL(adis_init);
	334
	335	MODULE_LICENSE("GPL");
	336	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	337	MODULE_DESCRIPTION("Common library code for ADIS16XXX devices");