Re: [PATCH 01/11] staging:iio: Add common ADIS library

[Jonathan Cameron <jic23@kernel.org>]

On 11/13/2012 01:28 PM, Lars-Peter Clausen wrote:
> A lot of the devices from the ADIS family use the same methods for accessing
> registers, sampling data and trigger handling. They also have similar register
> layout for the control registers.
> 
> This patch adds a common library for these devices. The library implements
> functions for reading and writing registers as buffer and trigger management. It
> also provides a set functions for accessing the control registers and for
> running the devices internal self-test. Having this common library code will
> allow us to remove a lot of duplicated code.

Excellent work. This series is exactly what I like to see. Nicely broken up with
one step per patch.  I kept reading this and thinking 'why is he still using that?'
only to notice the drivers you are working with are using the old methods / buffer,
and that you change over to the more recent method with the cleanup patches at the end.
(exactly as it should be done even if I am usually too lazy to do it myself sometimes ;)

So far all I've found is an 'a' where it should be an 'an'.  I think I'll just
ignore that ;)


> 
> Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
> ---
>  drivers/staging/iio/imu/Kconfig        |  13 ++
>  drivers/staging/iio/imu/Makefile       |   5 +
>  drivers/staging/iio/imu/adis.c         | 338 +++++++++++++++++++++++++++++++++
>  drivers/staging/iio/imu/adis.h         | 178 +++++++++++++++++
>  drivers/staging/iio/imu/adis_buffer.c  | 200 +++++++++++++++++++
>  drivers/staging/iio/imu/adis_trigger.c |  90 +++++++++
>  6 files changed, 824 insertions(+)
>  create mode 100644 drivers/staging/iio/imu/adis.c
>  create mode 100644 drivers/staging/iio/imu/adis.h
>  create mode 100644 drivers/staging/iio/imu/adis_buffer.c
>  create mode 100644 drivers/staging/iio/imu/adis_trigger.c
> 
> diff --git a/drivers/staging/iio/imu/Kconfig b/drivers/staging/iio/imu/Kconfig
> index 2c2f47d..89b9f25 100644
> --- a/drivers/staging/iio/imu/Kconfig
> +++ b/drivers/staging/iio/imu/Kconfig
> @@ -15,3 +15,16 @@ config ADIS16400
>  	  (adis16400 series also have magnetometers).
>  
>  endmenu
> +
> +config IIO_ADIS_LIB
> +	tristate
> +	help
> +	  A set of IO helper functions for the Analog Devices ADIS* device family.
> +
> +config IIO_ADIS_LIB_BUFFER
> +	bool
> +	select IIO_TRIGGER
> +	select IIO_SW_RING
> +	help
> +	  A set of buffer helper functions for the Analog Devices ADIS* device
> +	  family.
> diff --git a/drivers/staging/iio/imu/Makefile b/drivers/staging/iio/imu/Makefile
> index 3400a13..65dafba 100644
> --- a/drivers/staging/iio/imu/Makefile
> +++ b/drivers/staging/iio/imu/Makefile
> @@ -5,3 +5,8 @@
>  adis16400-y             := adis16400_core.o
>  adis16400-$(CONFIG_IIO_BUFFER) += adis16400_ring.o adis16400_trigger.o
>  obj-$(CONFIG_ADIS16400) += adis16400.o
> +
> +adis_lib-y += adis.o
> +adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_trigger.o
> +adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
> +obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
> diff --git a/drivers/staging/iio/imu/adis.c b/drivers/staging/iio/imu/adis.c
> new file mode 100644
> index 0000000..0bd21022
> --- /dev/null
> +++ b/drivers/staging/iio/imu/adis.c
> @@ -0,0 +1,338 @@
> +/*
> + * 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 "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/staging/iio/imu/adis.h b/drivers/staging/iio/imu/adis.h
> new file mode 100644
> index 0000000..c84da7a
> --- /dev/null
> +++ b/drivers/staging/iio/imu/adis.h
> @@ -0,0 +1,178 @@
> +/*
> + * Common library for ADIS16XXX devices
> + *
> + * Copyright 2012 Analog Devices Inc.
> + *   Author: Lars-Peter Clausen <lars@metafoo.de>
> + *
> + * Licensed under the GPL-2 or later.
> + */
> +
> +#ifndef __IIO_ADIS_H__
> +#define __IIO_ADIS_H__
> +
> +#include <linux/spi/spi.h>
> +#include <linux/interrupt.h>
> +#include <linux/iio/types.h>
> +
> +#define ADIS_WRITE_REG(reg) (0x80 | (reg))
> +#define ADIS_READ_REG(reg) (reg)
> +
> +/**
> + * struct adis_data - ADIS chip variant specific data
> + * @read_delay: SPI delay for read operations in us
> + * @write_delay: SPI delay for write operations in us
> + * @glob_cmd_reg: Register address of the GLOB_CMD register
> + * @msc_ctrl_reg: Register address of the MSC_CTRL register
> + * @diag_stat_reg: Register address of the DIAG_STAT register
> + * @status_error_msgs: Array of error messgaes
> + * @status_error_mask:
> + */
> +struct adis_data {
> +	unsigned int read_delay;
> +	unsigned int write_delay;
> +
> +	unsigned int glob_cmd_reg;
> +	unsigned int msc_ctrl_reg;
> +	unsigned int diag_stat_reg;
> +
> +	unsigned int self_test_mask;
> +	unsigned int startup_delay;
> +
> +	const char * const *status_error_msgs;
> +	unsigned int status_error_mask;
> +};
> +
> +struct adis {
> +	struct spi_device	*spi;
> +	struct iio_trigger	*trig;
> +
> +	const struct adis_data	*data;
> +
> +	struct mutex		txrx_lock;
> +	struct spi_message	msg;
> +	struct spi_transfer	*xfer;
> +	void			*buffer;
> +
> +	uint8_t			tx[8] ____cacheline_aligned;
> +	uint8_t			rx[4];
> +};
> +
> +int adis_init(struct adis *adis, struct iio_dev *indio_dev,
> +	struct spi_device *spi, const struct adis_data *data);
> +int adis_reset(struct adis *adis);
> +
> +int adis_write_reg_8(struct adis *adis, unsigned int reg, uint8_t val);
> +int adis_write_reg_16(struct adis *adis, unsigned int reg, uint16_t val);
> +int adis_read_reg_16(struct adis *adis, unsigned int reg, uint16_t *val);
> +
> +int adis_enable_irq(struct adis *adis, bool enable);
> +int adis_check_status(struct adis *adis);
> +
> +int adis_initial_startup(struct adis *adis);
> +
> +int adis_single_conversion(struct iio_dev *indio_dev,
> +	const struct iio_chan_spec *chan, unsigned int error_mask,
> +	int *val);
> +
> +#define ADIS_VOLTAGE_CHAN(addr, si, chan, name, bits) { \
> +	.type = IIO_VOLTAGE, \
> +	.indexed = 1, \
> +	.channel = (chan), \
> +	.extend_name = name, \
> +	.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
> +		IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
> +	.address = (addr), \
> +	.scan_index = (si), \
> +	.scan_type = { \
> +		.sign = 'u', \
> +		.realbits = (bits), \
> +		.storagebits = 16, \
> +	}, \
> +}
> +
> +#define ADIS_SUPPLY_CHAN(addr, si, bits) \
> +	ADIS_VOLTAGE_CHAN(addr, si, 0, "supply", bits)
> +
> +#define ADIS_AUX_ADC_CHAN(addr, si, bits) \
> +	ADIS_VOLTAGE_CHAN(addr, si, 1, NULL, bits)
> +
> +#define ADIS_TEMP_CHAN(addr, si, bits) { \
> +	.type = IIO_TEMP, \
> +	.indexed = 1, \
> +	.channel = 0, \
> +	.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
> +		IIO_CHAN_INFO_SCALE_SEPARATE_BIT | \
> +		IIO_CHAN_INFO_OFFSET_SEPARATE_BIT, \
> +	.address = (addr), \
> +	.scan_index = (si), \
> +	.scan_type = { \
> +		.sign = 'u', \
> +		.realbits = (bits), \
> +		.storagebits = 16, \
> +	}, \
> +}
> +
> +#define ADIS_MOD_CHAN(_type, mod, addr, si, info, bits) { \
> +	.type = (_type), \
> +	.modified = 1, \
> +	.channel2 = IIO_MOD_ ## mod, \
> +	.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
> +		 IIO_CHAN_INFO_SCALE_SHARED_BIT | \
> +		 info, \
> +	.address = (addr), \
> +	.scan_index = (si), \
> +	.scan_type = { \
> +		.sign = 's', \
> +		.realbits = (bits), \
> +		.storagebits = 16, \
> +	}, \
> +}
> +
> +#define ADIS_ACCEL_CHAN(mod, addr, si, info, bits) \
> +	ADIS_MOD_CHAN(IIO_ACCEL, mod, addr, si, info, bits)
> +
> +#define ADIS_GYRO_CHAN(mod, addr, si, info, bits) \
> +	ADIS_MOD_CHAN(IIO_ANGL_VEL, mod, addr, si, info, bits)
> +
> +#define ADIS_INCLI_CHAN(mod, addr, si, info, bits) \
> +	ADIS_MOD_CHAN(IIO_INCLI, mod, addr, si, info, bits)
> +
> +#define ADIS_ROT_CHAN(mod, addr, si, info, bits) \
> +	ADIS_MOD_CHAN(IIO_ROT, mod, addr, si, info, bits)
> +
> +#ifdef CONFIG_IIO_ADIS_LIB_BUFFER
> +
> +int adis_setup_buffer_and_trigger(struct adis *adis,
> +	struct iio_dev *indio_dev, irqreturn_t (*trigger_handler)(int, void *));
> +void adis_cleanup_buffer_and_trigger(struct adis *adis,
> +	struct iio_dev *indio_dev);
> +
> +int adis_probe_trigger(struct adis *adis, struct iio_dev *indio_dev);
> +void adis_remove_trigger(struct adis *adis);
> +
> +#else /* CONFIG_IIO_BUFFER */
> +
> +static inline int adis_setup_buffer_and_trigger(struct adis *adis,
> +	struct iio_dev *indio_dev, irqreturn_t (*trigger_handler)(int, void *))
> +{
> +	return 0;
> +}
> +
> +static inline void adis_cleanup_buffer_and_trigger(struct adis *adis,
> +	struct iio_dev *indio_dev)
> +{
> +}
> +
> +static inline int adis_probe_trigger(struct adis *adis,
> +	struct iio_dev *indio_dev)
> +{
> +	return 0;
> +}
> +
> +static inline void adis_remove_trigger(struct adis *adis)
> +{
> +}
> +
> +#endif /* CONFIG_IIO_BUFFER */
> +
> +#endif
> diff --git a/drivers/staging/iio/imu/adis_buffer.c b/drivers/staging/iio/imu/adis_buffer.c
> new file mode 100644
> index 0000000..47bdea0
> --- /dev/null
> +++ b/drivers/staging/iio/imu/adis_buffer.c
> @@ -0,0 +1,200 @@
> +#include <linux/export.h>
> +#include <linux/interrupt.h>
> +#include <linux/mutex.h>
> +#include <linux/kernel.h>
> +#include <linux/spi/spi.h>
> +#include <linux/slab.h>
> +
> +#include <linux/iio/iio.h>
> +#include <linux/iio/buffer.h>
> +#include "../ring_sw.h"
> +#include <linux/iio/trigger_consumer.h>
> +
> +#include  "adis.h"
> +
> +#define ADIS_MAX_OUTPUTS 12
> +
> +static int adis_read_buffer_data(struct adis *adis, struct iio_dev *indio_dev)
> +{
> +	int n_outputs = indio_dev->num_channels;
> +	struct spi_transfer xfers[ADIS_MAX_OUTPUTS + 1];
> +	struct spi_message msg;
> +	int ret;
> +	int i;
> +
> +	mutex_lock(&adis->txrx_lock);
> +
> +	spi_message_init(&msg);
> +
> +	memset(xfers, 0, sizeof(xfers));
> +	for (i = 0; i <= n_outputs; i++) {
> +		xfers[i].bits_per_word = 8;
> +		xfers[i].cs_change = 1;
> +		xfers[i].len = 2;
> +		xfers[i].delay_usecs = adis->data->read_delay;
> +		if (i < n_outputs) {
> +			xfers[i].tx_buf = adis->tx + 2 * i;
> +			adis->tx[2 * i] = indio_dev->channels[i].address;
> +			adis->tx[2 * i + 1] = 0;
> +		}
> +		if (i >= 1)
> +			xfers[i].rx_buf = adis->rx + 2 * (i - 1);
> +		spi_message_add_tail(&xfers[i], &msg);
> +	}
> +
> +	ret = spi_sync(adis->spi, &msg);
> +	if (ret)
> +		dev_err(&adis->spi->dev, "Failed to read data: %d", ret);
> +
> +	mutex_unlock(&adis->txrx_lock);
> +
> +	return ret;
> +}
> +
> +static irqreturn_t adis_trigger_handler(int irq, void *p)
> +{
> +	struct iio_poll_func *pf = p;
> +	struct iio_dev *indio_dev = pf->indio_dev;
> +	struct adis *adis = iio_device_get_drvdata(indio_dev);
> +	u16 *data;
> +	int i = 0;
> +
> +	data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
> +	if (data == NULL) {
> +		dev_err(&adis->spi->dev, "Failed to allocate memory.");
> +		return -ENOMEM;
> +	}
> +
> +	if (!bitmap_empty(indio_dev->active_scan_mask, indio_dev->masklength)
> +	    && adis_read_buffer_data(adis, indio_dev) >= 0)
> +		for (; i < bitmap_weight(indio_dev->active_scan_mask,
> +					 indio_dev->masklength); i++)
> +			data[i] = be16_to_cpup((__be16 *)&(adis->rx[i*2]));
> +
> +	/* Guaranteed to be aligned with 8 byte boundary */
> +	if (indio_dev->scan_timestamp)
> +		*((s64 *)(PTR_ALIGN(data, sizeof(s64)))) = pf->timestamp;
> +
> +	iio_push_to_buffers(indio_dev, (u8 *)data);
> +
> +	iio_trigger_notify_done(indio_dev->trig);
> +	kfree(data);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static const struct iio_buffer_setup_ops adis_buffer_setup_ops = {
> +	.preenable = &iio_sw_buffer_preenable,
> +	.postenable = &iio_triggered_buffer_postenable,
> +	.predisable = &iio_triggered_buffer_predisable,
> +};
> +
> +static int adis_buffer_setup(struct iio_dev *indio_dev,
> +	irqreturn_t (*trigger_handler)(int, void *))
> +{
> +	int ret = 0;
> +	struct iio_buffer *buffer;
> +
> +	if (!trigger_handler)
> +		trigger_handler = &adis_trigger_handler;
> +
> +	buffer = iio_sw_rb_allocate(indio_dev);
> +	if (!buffer) {
> +		ret = -ENOMEM;
> +		return ret;
> +	}
> +
> +	indio_dev->buffer = buffer;
> +	indio_dev->setup_ops = &adis_buffer_setup_ops;
> +
> +	indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
> +						 trigger_handler,
> +						 IRQF_ONESHOT,
> +						 indio_dev,
> +						 "%s_consumer%d",
> +						 indio_dev->name,
> +						 indio_dev->id);
> +	if (indio_dev->pollfunc == NULL) {
> +		ret = -ENOMEM;
> +		goto error_iio_sw_rb_free;
> +	}
> +
> +	indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
> +	return 0;
> +
> +error_iio_sw_rb_free:
> +	iio_sw_rb_free(indio_dev->buffer);
> +	return ret;
> +}
> +
> +static void adis_buffer_cleanup(struct iio_dev *indio_dev)
> +{
> +	iio_dealloc_pollfunc(indio_dev->pollfunc);
> +	iio_sw_rb_free(indio_dev->buffer);
> +}
> +
> +/**
> + * adis_setup_buffer_and_trigger() - Sets up buffer and trigger for the adis device
> + * @adis: The adis device.
> + * @indio_dev: The IIO device.
> + * @trigger_handler: Optional trigger handler, may be NULL.
> + *
> + * Returns 0 on success, a negative error code otherwise.
> + *
> + * This function sets up the buffer and trigger for a adis devices.  If
> + * 'trigger_handler' is NULL the default trigger handler will be used. The
> + * default trigger handler will simply read the registers assigned to the
> + * currently active channels.
> + *
> + * adis_cleanup_buffer_and_trigger() should be called to free the resources
> + * allocated by this function.
> + */
> +int adis_setup_buffer_and_trigger(struct adis *adis, struct iio_dev *indio_dev,
> +	irqreturn_t (*trigger_handler)(int, void *))
> +{
> +	int ret;
> +
> +	ret = adis_buffer_setup(indio_dev, trigger_handler);
> +	if (ret)
> +		return ret;
> +
> +	ret = iio_buffer_register(indio_dev,
> +				  indio_dev->channels,
> +				  indio_dev->num_channels);
> +	if (ret) {
> +		dev_err(&adis->spi->dev, "Failed to initialize buffer %d\n",
> +			ret);
> +		goto error_unreg_buffer_funcs;
> +	}
> +
> +	if (adis->spi->irq) {
> +		ret = adis_probe_trigger(adis, indio_dev);
> +		if (ret)
> +			goto error_uninitialize_buffer;
> +	}
> +	return 0;
> +
> +error_uninitialize_buffer:
> +	iio_buffer_unregister(indio_dev);
> +error_unreg_buffer_funcs:
> +	adis_buffer_cleanup(indio_dev);
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(adis_setup_buffer_and_trigger);
> +
> +/**
> + * adis_cleanup_buffer_and_trigger() - Free buffer and trigger resources
> + * @adis: The adis device.
> + * @indio_dev: The IIO device.
> + *
> + * Frees resources allocated by adis_setup_buffer_and_trigger()
> + */
> +void adis_cleanup_buffer_and_trigger(struct adis *adis,
> +	struct iio_dev *indio_dev)
> +{
> +	if (adis->spi->irq)
> +		adis_remove_trigger(adis);
> +	iio_buffer_unregister(indio_dev);
> +	adis_buffer_cleanup(indio_dev);
> +}
> +EXPORT_SYMBOL_GPL(adis_cleanup_buffer_and_trigger);
> diff --git a/drivers/staging/iio/imu/adis_trigger.c b/drivers/staging/iio/imu/adis_trigger.c
> new file mode 100644
> index 0000000..3e89b2e
> --- /dev/null
> +++ b/drivers/staging/iio/imu/adis_trigger.c
> @@ -0,0 +1,90 @@
> +/*
> + * 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/interrupt.h>
> +#include <linux/kernel.h>
> +#include <linux/spi/spi.h>
> +#include <linux/export.h>
> +
> +#include <linux/iio/iio.h>
> +#include <linux/iio/trigger.h>
> +
> +#include "adis.h"
> +
> +static int adis_data_rdy_trigger_set_state(struct iio_trigger *trig,
> +						bool state)
> +{
> +	struct adis *adis = trig->private_data;
> +
> +	return adis_enable_irq(adis, state);
> +}
> +
> +static const struct iio_trigger_ops adis_trigger_ops = {
> +	.owner = THIS_MODULE,
> +	.set_trigger_state = &adis_data_rdy_trigger_set_state,
> +};
> +
> +/**
> + * adis_probe_trigger() - Sets up trigger for a adis device
> + * @adis: The adis device
> + * @indio_dev: The IIO device
> + *
> + * Returns 0 on success or a negative error code
> + *
> + * adis_remove_trigger() should be used to free the trigger.
> + */
> +int adis_probe_trigger(struct adis *adis, struct iio_dev *indio_dev)
> +{
> +	int ret;
> +
> +	adis->trig = iio_trigger_alloc("%s-dev%d", indio_dev->name,
> +					indio_dev->id);
> +	if (adis->trig == NULL)
> +		return -ENOMEM;
> +
> +	ret = request_irq(adis->spi->irq,
> +			  &iio_trigger_generic_data_rdy_poll,
> +			  IRQF_TRIGGER_RISING,
> +			  indio_dev->name,
> +			  adis->trig);
> +	if (ret)
> +		goto error_free_trig;
> +
> +	adis->trig->dev.parent = &adis->spi->dev;
> +	adis->trig->ops = &adis_trigger_ops;
> +	adis->trig->private_data = adis;
> +	ret = iio_trigger_register(adis->trig);
> +
> +	indio_dev->trig = adis->trig;
> +	if (ret)
> +		goto error_free_irq;
> +
> +	return 0;
> +
> +error_free_irq:
> +	free_irq(adis->spi->irq, adis->trig);
> +error_free_trig:
> +	iio_trigger_free(adis->trig);
> +	return ret;
> +}
> +EXPORT_SYMBOL_GPL(adis_probe_trigger);
> +
> +/**
> + * adis_remove_trigger() - Remove trigger for a adis devices
> + * @adis: The adis device
> + *
> + * Removes the trigger previously registered with adis_probe_trigger().
> + */
> +void adis_remove_trigger(struct adis *adis)
> +{
> +	iio_trigger_unregister(adis->trig);
> +	free_irq(adis->spi->irq, adis->trig);
> +	iio_trigger_free(adis->trig);
> +}
> +EXPORT_SYMBOL_GPL(adis_remove_trigger);
>