staging:iio:adis16400: Use adis library (cd888a17) · Commits · e / devices / android_kernel_teracube_2e

drivers/staging/iio/imu/Kconfig

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -6,8 +6,8 @@ menu "Inertial measurement units"
	config ADIS16400		config ADIS16400
	tristate "Analog Devices ADIS16400 and similar IMU SPI driver"		tristate "Analog Devices ADIS16400 and similar IMU SPI driver"
	depends on SPI		depends on SPI
	select IIO_SW_RING if IIO_BUFFER		select IIO_ADIS_LIB
	select IIO_TRIGGER if IIO_BUFFER		select IIO_ADIS_LIB_BUFFER if IIO_BUFFER
	help		help
	Say yes here to build support for Analog Devices adis16300, adis16344,		Say yes here to build support for Analog Devices adis16300, adis16344,
	adis16350, adis16354, adis16355, adis16360, adis16362, adis16364,		adis16350, adis16354, adis16355, adis16360, adis16362, adis16364,

drivers/staging/iio/imu/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -3,5 +3,5 @@
	#		#

	adis16400-y := adis16400_core.o		adis16400-y := adis16400_core.o
	adis16400-$(CONFIG_IIO_BUFFER) += adis16400_ring.o adis16400_trigger.o		adis16400-$(CONFIG_IIO_BUFFER) += adis16400_ring.o
	obj-$(CONFIG_ADIS16400) += adis16400.o		obj-$(CONFIG_ADIS16400) += adis16400.o

drivers/staging/iio/imu/adis16400.h

+44 −65

Original line number	Original line	Diff line number	Diff line
	@@ -17,12 +17,11 @@
	#ifndef SPI_ADIS16400_H_		#ifndef SPI_ADIS16400_H_
	#define SPI_ADIS16400_H_		#define SPI_ADIS16400_H_

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

	#define ADIS16400_STARTUP_DELAY 290 /* ms */		#define ADIS16400_STARTUP_DELAY 290 /* ms */
	#define ADIS16400_MTEST_DELAY 90 /* ms */		#define ADIS16400_MTEST_DELAY 90 /* ms */

	#define ADIS16400_READ_REG(a) a
	#define ADIS16400_WRITE_REG(a) ((a) \| 0x80)

	#define ADIS16400_FLASH_CNT 0x00 /* Flash memory write count */		#define ADIS16400_FLASH_CNT 0x00 /* Flash memory write count */
	#define ADIS16400_SUPPLY_OUT 0x02 /* Power supply measurement */		#define ADIS16400_SUPPLY_OUT 0x02 /* Power supply measurement */
	#define ADIS16400_XGYRO_OUT 0x04 /* X-axis gyroscope output */		#define ADIS16400_XGYRO_OUT 0x04 /* X-axis gyroscope output */
	@@ -96,21 +95,21 @@
	#define ADIS16400_SMPL_PRD_DIV_MASK 0x7F		#define ADIS16400_SMPL_PRD_DIV_MASK 0x7F

	/* DIAG_STAT */		/* DIAG_STAT */
	#define ADIS16400_DIAG_STAT_ZACCL_FAIL (1<<15)		#define ADIS16400_DIAG_STAT_ZACCL_FAIL 15
	#define ADIS16400_DIAG_STAT_YACCL_FAIL (1<<14)		#define ADIS16400_DIAG_STAT_YACCL_FAIL 14
	#define ADIS16400_DIAG_STAT_XACCL_FAIL (1<<13)		#define ADIS16400_DIAG_STAT_XACCL_FAIL 13
	#define ADIS16400_DIAG_STAT_XGYRO_FAIL (1<<12)		#define ADIS16400_DIAG_STAT_XGYRO_FAIL 12
	#define ADIS16400_DIAG_STAT_YGYRO_FAIL (1<<11)		#define ADIS16400_DIAG_STAT_YGYRO_FAIL 11
	#define ADIS16400_DIAG_STAT_ZGYRO_FAIL (1<<10)		#define ADIS16400_DIAG_STAT_ZGYRO_FAIL 10
	#define ADIS16400_DIAG_STAT_ALARM2 (1<<9)		#define ADIS16400_DIAG_STAT_ALARM2 9
	#define ADIS16400_DIAG_STAT_ALARM1 (1<<8)		#define ADIS16400_DIAG_STAT_ALARM1 8
	#define ADIS16400_DIAG_STAT_FLASH_CHK (1<<6)		#define ADIS16400_DIAG_STAT_FLASH_CHK 6
	#define ADIS16400_DIAG_STAT_SELF_TEST (1<<5)		#define ADIS16400_DIAG_STAT_SELF_TEST 5
	#define ADIS16400_DIAG_STAT_OVERFLOW (1<<4)		#define ADIS16400_DIAG_STAT_OVERFLOW 4
	#define ADIS16400_DIAG_STAT_SPI_FAIL (1<<3)		#define ADIS16400_DIAG_STAT_SPI_FAIL 3
	#define ADIS16400_DIAG_STAT_FLASH_UPT (1<<2)		#define ADIS16400_DIAG_STAT_FLASH_UPT 2
	#define ADIS16400_DIAG_STAT_POWER_HIGH (1<<1)		#define ADIS16400_DIAG_STAT_POWER_HIGH 1
	#define ADIS16400_DIAG_STAT_POWER_LOW (1<<0)		#define ADIS16400_DIAG_STAT_POWER_LOW 0

	/* GLOB_CMD */		/* GLOB_CMD */
	#define ADIS16400_GLOB_CMD_SW_RESET (1<<7)		#define ADIS16400_GLOB_CMD_SW_RESET (1<<7)
	@@ -126,9 +125,6 @@
	#define ADIS16334_RATE_DIV_SHIFT 8		#define ADIS16334_RATE_DIV_SHIFT 8
	#define ADIS16334_RATE_INT_CLK BIT(0)		#define ADIS16334_RATE_INT_CLK BIT(0)

	#define ADIS16400_MAX_TX 24
	#define ADIS16400_MAX_RX 24

	#define ADIS16400_SPI_SLOW (u32)(300 * 1000)		#define ADIS16400_SPI_SLOW (u32)(300 * 1000)
	#define ADIS16400_SPI_BURST (u32)(1000 * 1000)		#define ADIS16400_SPI_BURST (u32)(1000 * 1000)
	#define ADIS16400_SPI_FAST (u32)(2000 * 1000)		#define ADIS16400_SPI_FAST (u32)(2000 * 1000)
	@@ -137,6 +133,8 @@
	#define ADIS16400_NO_BURST BIT(1)		#define ADIS16400_NO_BURST BIT(1)
	#define ADIS16400_HAS_SLOW_MODE BIT(2)		#define ADIS16400_HAS_SLOW_MODE BIT(2)

			struct adis16400_state;

	struct adis16400_chip_info {		struct adis16400_chip_info {
	const struct iio_chan_spec *channels;		const struct iio_chan_spec *channels;
	const int num_channels;		const int num_channels;
	@@ -145,58 +143,47 @@ struct adis16400_chip_info {
	unsigned int accel_scale_micro;		unsigned int accel_scale_micro;
	int temp_scale_nano;		int temp_scale_nano;
	int temp_offset;		int temp_offset;
	int (set_freq)(struct iio_dev indio_dev, unsigned int freq);		int (set_freq)(struct adis16400_state st, unsigned int freq);
	int (get_freq)(struct iio_dev indio_dev);		int (get_freq)(struct adis16400_state st);
	};		};

	/**		/**
	* struct adis16400_state - device instance specific data		* struct adis16400_state - device instance specific data
	* @us: actual spi_device		* @variant: chip variant info
	* @trig: data ready trigger registered with iio
	* @tx: transmit buffer
	* @rx: receive buffer
	* @buf_lock: mutex to protect tx and rx
	* @filt_int: integer part of requested filter frequency		* @filt_int: integer part of requested filter frequency
			* @adis: adis device
	**/		**/
	struct adis16400_state {		struct adis16400_state {
	struct spi_device *us;
	struct iio_trigger *trig;
	struct mutex buf_lock;
	struct adis16400_chip_info *variant;		struct adis16400_chip_info *variant;
	int filt_int;		int filt_int;

	u8 tx[ADIS16400_MAX_TX] ____cacheline_aligned;		struct adis adis;
	u8 rx[ADIS16400_MAX_RX] ____cacheline_aligned;
	};		};

	int adis16400_set_irq(struct iio_dev *indio_dev, bool enable);

	/* At the moment triggers are only used for ring buffer		/* At the moment triggers are only used for ring buffer
	* filling. This may change!		* filling. This may change!
	*/		*/

	#define ADIS16400_SCAN_SUPPLY 0		enum {
	#define ADIS16400_SCAN_GYRO_X 1		ADIS16400_SCAN_SUPPLY,
	#define ADIS16400_SCAN_GYRO_Y 2		ADIS16400_SCAN_GYRO_X,
	#define ADIS16400_SCAN_GYRO_Z 3		ADIS16400_SCAN_GYRO_Y,
	#define ADIS16400_SCAN_ACC_X 4		ADIS16400_SCAN_GYRO_Z,
	#define ADIS16400_SCAN_ACC_Y 5		ADIS16400_SCAN_ACC_X,
	#define ADIS16400_SCAN_ACC_Z 6		ADIS16400_SCAN_ACC_Y,
	#define ADIS16400_SCAN_MAGN_X 7		ADIS16400_SCAN_ACC_Z,
	#define ADIS16350_SCAN_TEMP_X 7		ADIS16400_SCAN_MAGN_X,
	#define ADIS16400_SCAN_MAGN_Y 8		ADIS16400_SCAN_MAGN_Y,
	#define ADIS16350_SCAN_TEMP_Y 8		ADIS16400_SCAN_MAGN_Z,
	#define ADIS16400_SCAN_MAGN_Z 9		ADIS16350_SCAN_TEMP_X,
	#define ADIS16350_SCAN_TEMP_Z 9		ADIS16350_SCAN_TEMP_Y,
	#define ADIS16400_SCAN_TEMP 10		ADIS16350_SCAN_TEMP_Z,
	#define ADIS16350_SCAN_ADC_0 10		ADIS16300_SCAN_INCLI_X,
	#define ADIS16400_SCAN_ADC_0 11		ADIS16300_SCAN_INCLI_Y,
	#define ADIS16300_SCAN_INCLI_X 12		ADIS16400_SCAN_ADC,
	#define ADIS16300_SCAN_INCLI_Y 13		};

	#ifdef CONFIG_IIO_BUFFER		#ifdef CONFIG_IIO_BUFFER
	void adis16400_remove_trigger(struct iio_dev *indio_dev);
	int adis16400_probe_trigger(struct iio_dev *indio_dev);

	ssize_t adis16400_read_data_from_ring(struct device *dev,		ssize_t adis16400_read_data_from_ring(struct device *dev,
	struct device_attribute *attr,		struct device_attribute *attr,
	@@ -208,15 +195,6 @@ void adis16400_unconfigure_ring(struct iio_dev *indio_dev);

	#else /* CONFIG_IIO_BUFFER */		#else /* CONFIG_IIO_BUFFER */

	static inline void adis16400_remove_trigger(struct iio_dev *indio_dev)
	{
	}

	static inline int adis16400_probe_trigger(struct iio_dev *indio_dev)
	{
	return 0;
	}

	static inline ssize_t		static inline ssize_t
	adis16400_read_data_from_ring(struct device *dev,		adis16400_read_data_from_ring(struct device *dev,
	struct device_attribute *attr,		struct device_attribute *attr,
	@@ -235,4 +213,5 @@ static inline void adis16400_unconfigure_ring(struct iio_dev *indio_dev)
	}		}

	#endif /* CONFIG_IIO_BUFFER */		#endif /* CONFIG_IIO_BUFFER */

	#endif /* SPI_ADIS16400_H_ */		#endif /* SPI_ADIS16400_H_ */

drivers/staging/iio/imu/adis16400_core.c

+148 −387

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/iio/imu/adis16400_ring.c

+30 −29

Original line number	Original line	Diff line number	Diff line
	@@ -9,6 +9,7 @@
	#include <linux/iio/iio.h>		#include <linux/iio/iio.h>
	#include "../ring_sw.h"		#include "../ring_sw.h"
	#include <linux/iio/trigger_consumer.h>		#include <linux/iio/trigger_consumer.h>

	#include "adis16400.h"		#include "adis16400.h"

	/**		/**
	@@ -20,12 +21,12 @@ static int adis16400_spi_read_burst(struct iio_dev indio_dev, u8 rx)
	{		{
	struct spi_message msg;		struct spi_message msg;
	struct adis16400_state *st = iio_priv(indio_dev);		struct adis16400_state *st = iio_priv(indio_dev);
	u32 old_speed_hz = st->us->max_speed_hz;		u32 old_speed_hz = st->adis.spi->max_speed_hz;
	int ret;		int ret;

	struct spi_transfer xfers[] = {		struct spi_transfer xfers[] = {
	{		{
	.tx_buf = st->tx,		.tx_buf = st->adis.tx,
	.bits_per_word = 8,		.bits_per_word = 8,
	.len = 2,		.len = 2,
	}, {		}, {
	@@ -35,39 +36,39 @@ static int adis16400_spi_read_burst(struct iio_dev indio_dev, u8 rx)
	},		},
	};		};

	mutex_lock(&st->buf_lock);		mutex_lock(&st->adis.txrx_lock);
	st->tx[0] = ADIS16400_READ_REG(ADIS16400_GLOB_CMD);		st->adis.tx[0] = ADIS_READ_REG(ADIS16400_GLOB_CMD);
	st->tx[1] = 0;		st->adis.tx[1] = 0;

	spi_message_init(&msg);		spi_message_init(&msg);
	spi_message_add_tail(&xfers[0], &msg);		spi_message_add_tail(&xfers[0], &msg);
	spi_message_add_tail(&xfers[1], &msg);		spi_message_add_tail(&xfers[1], &msg);

	st->us->max_speed_hz = min(ADIS16400_SPI_BURST, old_speed_hz);		st->adis.spi->max_speed_hz = min(ADIS16400_SPI_BURST, old_speed_hz);
	spi_setup(st->us);		spi_setup(st->adis.spi);

	ret = spi_sync(st->us, &msg);		ret = spi_sync(st->adis.spi, &msg);
	if (ret)		if (ret)
	dev_err(&st->us->dev, "problem when burst reading");		dev_err(&st->adis.spi->dev, "problem when burst reading");

	st->us->max_speed_hz = old_speed_hz;		st->adis.spi->max_speed_hz = old_speed_hz;
	spi_setup(st->us);		spi_setup(st->adis.spi);
	mutex_unlock(&st->buf_lock);		mutex_unlock(&st->adis.txrx_lock);
	return ret;		return ret;
	}		}

	static const u16 read_all_tx_array[] = {		static const u16 read_all_tx_array[] = {
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_SUPPLY_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_SUPPLY_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_XGYRO_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_XGYRO_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_YGYRO_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_YGYRO_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_ZGYRO_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_ZGYRO_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_XACCL_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_XACCL_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_YACCL_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_YACCL_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_ZACCL_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_ZACCL_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16350_XTEMP_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16350_XTEMP_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16350_YTEMP_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16350_YTEMP_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16350_ZTEMP_OUT)),		cpu_to_be16(ADIS_READ_REG(ADIS16350_ZTEMP_OUT)),
	cpu_to_be16(ADIS16400_READ_REG(ADIS16400_AUX_ADC)),		cpu_to_be16(ADIS_READ_REG(ADIS16400_AUX_ADC)),
	};		};

	static int adis16350_spi_read_all(struct iio_dev indio_dev, u8 rx)		static int adis16350_spi_read_all(struct iio_dev indio_dev, u8 rx)
	@@ -100,7 +101,7 @@ static int adis16350_spi_read_all(struct iio_dev indio_dev, u8 rx)
	for (j = 0; j < scan_count + 1; j++)		for (j = 0; j < scan_count + 1; j++)
	spi_message_add_tail(&xfers[j], &msg);		spi_message_add_tail(&xfers[j], &msg);

	ret = spi_sync(st->us, &msg);		ret = spi_sync(st->adis.spi, &msg);
	kfree(xfers);		kfree(xfers);

	return ret;		return ret;
	@@ -123,26 +124,26 @@ static irqreturn_t adis16400_trigger_handler(int irq, void *p)
	indio_dev->masklength);		indio_dev->masklength);
	data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);		data = kmalloc(indio_dev->scan_bytes, GFP_KERNEL);
	if (data == NULL) {		if (data == NULL) {
	dev_err(&st->us->dev, "memory alloc failed in ring bh");		dev_err(&st->adis.spi->dev, "memory alloc failed in ring bh");
	goto done;		goto done;
	}		}

	if (scan_count) {		if (scan_count) {
	if (st->variant->flags & ADIS16400_NO_BURST) {		if (st->variant->flags & ADIS16400_NO_BURST) {
	ret = adis16350_spi_read_all(indio_dev, st->rx);		ret = adis16350_spi_read_all(indio_dev, st->adis.rx);
	if (ret < 0)		if (ret < 0)
	goto done;		goto done;
	for (; i < scan_count; i++)		for (; i < scan_count; i++)
	data[i] = (s16 )(st->rx + i*2);		data[i] = (s16 )(st->adis.rx + i*2);
	} else {		} else {
	ret = adis16400_spi_read_burst(indio_dev, st->rx);		ret = adis16400_spi_read_burst(indio_dev, st->adis.rx);
	if (ret < 0)		if (ret < 0)
	goto done;		goto done;
	for (; i < scan_count; i++) {		for (; i < scan_count; i++) {
	j = __ffs(mask);		j = __ffs(mask);
	mask &= ~(1 << j);		mask &= ~(1 << j);
	data[i] = be16_to_cpup(		data[i] = be16_to_cpup(
	(__be16 )&(st->rx[j2]));		(__be16 )&(st->adis.rx[j2]));
	}		}
	}		}
	}		}