Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 70987b81 authored by Jonathan Cameron's avatar Jonathan Cameron Committed by Greg Kroah-Hartman
Browse files

staging:iio:imu remove old adis16350. Support now in adis16400 driver. 



Signed-off-by: default avatarJonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 2a29a90b

drivers/staging/iio/imu/Kconfig

+0 −9
Original line number Diff line number Diff line
@@ -12,15 +12,6 @@ config ADIS16300 
	  Say yes here to build support for Analog Devices adis16300 four degrees

	  of freedom inertial sensor.



config ADIS16350

	tristate "Analog Devices ADIS16350/54/55/60/62/64/65 IMU SPI driver"

	depends on SPI

	select IIO_TRIGGER if IIO_RING_BUFFER

	select IIO_SW_RING if IIO_RING_BUFFER

	help

	  Say yes here to build support for Analog Devices adis16350/54/55/60/62/64/65

	  high precision tri-axis inertial sensor.



config ADIS16400

	tristate "Analog Devices ADIS16400 and similar IMU SPI driver"

	depends on SPI

drivers/staging/iio/imu/Makefile

+0 −4
Original line number Diff line number Diff line
@@ -6,10 +6,6 @@ adis16300-y := adis16300_core.o 
adis16300-$(CONFIG_IIO_RING_BUFFER) += adis16300_ring.o adis16300_trigger.o

obj-$(CONFIG_ADIS16300) += adis16300.o



adis16350-y             := adis16350_core.o

adis16350-$(CONFIG_IIO_RING_BUFFER) += adis16350_ring.o adis16350_trigger.o

obj-$(CONFIG_ADIS16350) += adis16350.o



adis16400-y             := adis16400_core.o

adis16400-$(CONFIG_IIO_RING_BUFFER) += adis16400_ring.o adis16400_trigger.o

obj-$(CONFIG_ADIS16400) += adis16400.o

drivers/staging/iio/imu/adis16350.h

deleted100644 → 0
+0 −177
Original line number Diff line number Diff line 
#ifndef SPI_ADIS16350_H_

#define SPI_ADIS16350_H_



#define ADIS16350_STARTUP_DELAY	220 /* ms */



#define ADIS16350_READ_REG(a)    a

#define ADIS16350_WRITE_REG(a) ((a) | 0x80)



#define ADIS16350_FLASH_CNT  0x00 /* Flash memory write count */

#define ADIS16350_SUPPLY_OUT 0x02 /* Power supply measurement */

#define ADIS16350_XGYRO_OUT 0x04 /* X-axis gyroscope output */

#define ADIS16350_YGYRO_OUT 0x06 /* Y-axis gyroscope output */

#define ADIS16350_ZGYRO_OUT 0x08 /* Z-axis gyroscope output */

#define ADIS16350_XACCL_OUT 0x0A /* X-axis accelerometer output */

#define ADIS16350_YACCL_OUT 0x0C /* Y-axis accelerometer output */

#define ADIS16350_ZACCL_OUT 0x0E /* Z-axis accelerometer output */

#define ADIS16350_XTEMP_OUT 0x10 /* X-axis gyroscope temperature measurement */

#define ADIS16350_YTEMP_OUT 0x12 /* Y-axis gyroscope temperature measurement */

#define ADIS16350_ZTEMP_OUT 0x14 /* Z-axis gyroscope temperature measurement */

#define ADIS16350_AUX_ADC   0x16 /* Auxiliary ADC measurement */



/* Calibration parameters */

#define ADIS16350_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */

#define ADIS16350_YGYRO_OFF 0x1C /* Y-axis gyroscope bias offset factor */

#define ADIS16350_ZGYRO_OFF 0x1E /* Z-axis gyroscope bias offset factor */

#define ADIS16350_XACCL_OFF 0x20 /* X-axis acceleration bias offset factor */

#define ADIS16350_YACCL_OFF 0x22 /* Y-axis acceleration bias offset factor */

#define ADIS16350_ZACCL_OFF 0x24 /* Z-axis acceleration bias offset factor */



#define ADIS16350_GPIO_CTRL 0x32 /* Auxiliary digital input/output control */

#define ADIS16350_MSC_CTRL  0x34 /* Miscellaneous control */

#define ADIS16350_SMPL_PRD  0x36 /* Internal sample period (rate) control */

#define ADIS16350_SENS_AVG  0x38 /* Dynamic range and digital filter control */

#define ADIS16350_SLP_CNT   0x3A /* Sleep mode control */

#define ADIS16350_DIAG_STAT 0x3C /* System status */



/* Alarm functions */

#define ADIS16350_GLOB_CMD  0x3E /* System command */

#define ADIS16350_ALM_MAG1  0x26 /* Alarm 1 amplitude threshold */

#define ADIS16350_ALM_MAG2  0x28 /* Alarm 2 amplitude threshold */

#define ADIS16350_ALM_SMPL1 0x2A /* Alarm 1 sample size */

#define ADIS16350_ALM_SMPL2 0x2C /* Alarm 2 sample size */

#define ADIS16350_ALM_CTRL  0x2E /* Alarm control */

#define ADIS16350_AUX_DAC   0x30 /* Auxiliary DAC data */



#define ADIS16350_ERROR_ACTIVE			(1<<14)

#define ADIS16350_NEW_DATA			(1<<15)



/* MSC_CTRL */

#define ADIS16350_MSC_CTRL_MEM_TEST		(1<<11)

#define ADIS16350_MSC_CTRL_INT_SELF_TEST	(1<<10)

#define ADIS16350_MSC_CTRL_NEG_SELF_TEST	(1<<9)

#define ADIS16350_MSC_CTRL_POS_SELF_TEST	(1<<8)

#define ADIS16350_MSC_CTRL_GYRO_BIAS		(1<<7)

#define ADIS16350_MSC_CTRL_ACCL_ALIGN		(1<<6)

#define ADIS16350_MSC_CTRL_DATA_RDY_EN		(1<<2)

#define ADIS16350_MSC_CTRL_DATA_RDY_POL_HIGH	(1<<1)

#define ADIS16350_MSC_CTRL_DATA_RDY_DIO2	(1<<0)



/* SMPL_PRD */

#define ADIS16350_SMPL_PRD_TIME_BASE	(1<<7)

#define ADIS16350_SMPL_PRD_DIV_MASK	0x7F



/* DIAG_STAT */

#define ADIS16350_DIAG_STAT_ZACCL_FAIL	(1<<15)

#define ADIS16350_DIAG_STAT_YACCL_FAIL	(1<<14)

#define ADIS16350_DIAG_STAT_XACCL_FAIL	(1<<13)

#define ADIS16350_DIAG_STAT_XGYRO_FAIL	(1<<12)

#define ADIS16350_DIAG_STAT_YGYRO_FAIL	(1<<11)

#define ADIS16350_DIAG_STAT_ZGYRO_FAIL	(1<<10)

#define ADIS16350_DIAG_STAT_ALARM2	(1<<9)

#define ADIS16350_DIAG_STAT_ALARM1	(1<<8)

#define ADIS16350_DIAG_STAT_FLASH_CHK	(1<<6)

#define ADIS16350_DIAG_STAT_SELF_TEST	(1<<5)

#define ADIS16350_DIAG_STAT_OVERFLOW	(1<<4)

#define ADIS16350_DIAG_STAT_SPI_FAIL	(1<<3)

#define ADIS16350_DIAG_STAT_FLASH_UPT	(1<<2)

#define ADIS16350_DIAG_STAT_POWER_HIGH	(1<<1)

#define ADIS16350_DIAG_STAT_POWER_LOW	(1<<0)



/* GLOB_CMD */

#define ADIS16350_GLOB_CMD_SW_RESET	(1<<7)

#define ADIS16350_GLOB_CMD_P_AUTO_NULL	(1<<4)

#define ADIS16350_GLOB_CMD_FLASH_UPD	(1<<3)

#define ADIS16350_GLOB_CMD_DAC_LATCH	(1<<2)

#define ADIS16350_GLOB_CMD_FAC_CALIB	(1<<1)

#define ADIS16350_GLOB_CMD_AUTO_NULL	(1<<0)



/* SLP_CNT */

#define ADIS16350_SLP_CNT_POWER_OFF	(1<<8)



#define ADIS16350_MAX_TX 24

#define ADIS16350_MAX_RX 24



#define ADIS16350_SPI_SLOW	(u32)(300 * 1000)

#define ADIS16350_SPI_BURST	(u32)(1000 * 1000)

#define ADIS16350_SPI_FAST	(u32)(2000 * 1000)



/**

 * struct adis16350_state - device instance specific data

 * @us:			actual spi_device

 * @work_trigger_to_ring: bh for triggered event handling

 * @inter:		used to check if new interrupt has been triggered

 * @last_timestamp:	passing timestamp from th to bh of interrupt handler

 * @indio_dev:		industrial I/O device structure

 * @trig:		data ready trigger registered with iio

 * @tx:			transmit buffer

 * @rx:			receive buffer

 * @buf_lock:		mutex to protect tx and rx

 **/

struct adis16350_state {

	struct spi_device		*us;

	struct work_struct		work_trigger_to_ring;

	s64				last_timestamp;

	struct iio_dev			*indio_dev;

	struct iio_trigger		*trig;

	u8				*tx;

	u8				*rx;

	struct mutex			buf_lock;

};



int adis16350_set_irq(struct device *dev, bool enable);



#ifdef CONFIG_IIO_RING_BUFFER



#define ADIS16350_SCAN_SUPPLY	0

#define ADIS16350_SCAN_GYRO_X	1

#define ADIS16350_SCAN_GYRO_Y	2

#define ADIS16350_SCAN_GYRO_Z	3

#define ADIS16350_SCAN_ACC_X	4

#define ADIS16350_SCAN_ACC_Y	5

#define ADIS16350_SCAN_ACC_Z	6

#define ADIS16350_SCAN_TEMP_X	7

#define ADIS16350_SCAN_TEMP_Y	8

#define ADIS16350_SCAN_TEMP_Z	9

#define ADIS16350_SCAN_ADC_0	10



void adis16350_remove_trigger(struct iio_dev *indio_dev);

int adis16350_probe_trigger(struct iio_dev *indio_dev);



ssize_t adis16350_read_data_from_ring(struct device *dev,

				      struct device_attribute *attr,

				      char *buf);





int adis16350_configure_ring(struct iio_dev *indio_dev);

void adis16350_unconfigure_ring(struct iio_dev *indio_dev);



#else /* CONFIG_IIO_RING_BUFFER */



static inline void adis16350_remove_trigger(struct iio_dev *indio_dev)

{

}



static inline int adis16350_probe_trigger(struct iio_dev *indio_dev)

{

	return 0;

}



static inline ssize_t

adis16350_read_data_from_ring(struct device *dev,

			      struct device_attribute *attr,

			      char *buf)

{

	return 0;

}



static inline int adis16350_configure_ring(struct iio_dev *indio_dev)

{

	return 0;

}



static inline void adis16350_unconfigure_ring(struct iio_dev *indio_dev)

{

}

#endif /* CONFIG_IIO_RING_BUFFER */

#endif /* SPI_ADIS16350_H_ */

drivers/staging/iio/imu/adis16350_core.c

deleted100644 → 0
+0 −733

File deleted.

Preview size limit exceeded, changes collapsed.

drivers/staging/iio/imu/adis16350_ring.c

deleted100644 → 0
+0 −236
Original line number Diff line number Diff line 
#include <linux/interrupt.h>

#include <linux/irq.h>

#include <linux/gpio.h>

#include <linux/workqueue.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/list.h>



#include "../iio.h"

#include "../sysfs.h"

#include "../ring_sw.h"

#include "../accel/accel.h"

#include "../trigger.h"

#include "adis16350.h"



static IIO_SCAN_EL_C(in0_supply, ADIS16350_SCAN_SUPPLY,

		ADIS16350_SUPPLY_OUT, NULL);

static IIO_CONST_ATTR_SCAN_EL_TYPE(in0_supply, u, 12, 16);



static IIO_SCAN_EL_C(gyro_x, ADIS16350_SCAN_GYRO_X, ADIS16350_XGYRO_OUT, NULL);

static IIO_SCAN_EL_C(gyro_y, ADIS16350_SCAN_GYRO_Y, ADIS16350_YGYRO_OUT, NULL);

static IIO_SCAN_EL_C(gyro_z, ADIS16350_SCAN_GYRO_Z, ADIS16350_ZGYRO_OUT, NULL);

static IIO_CONST_ATTR_SCAN_EL_TYPE(gyro, s, 14, 16);



static IIO_SCAN_EL_C(accel_x, ADIS16350_SCAN_ACC_X, ADIS16350_XACCL_OUT, NULL);

static IIO_SCAN_EL_C(accel_y, ADIS16350_SCAN_ACC_Y, ADIS16350_YACCL_OUT, NULL);

static IIO_SCAN_EL_C(accel_z, ADIS16350_SCAN_ACC_Z, ADIS16350_ZACCL_OUT, NULL);

static IIO_CONST_ATTR_SCAN_EL_TYPE(accel, s, 14, 16);



static IIO_SCAN_EL_C(temp_x, ADIS16350_SCAN_TEMP_X, ADIS16350_XTEMP_OUT, NULL);

static IIO_SCAN_EL_C(temp_y, ADIS16350_SCAN_TEMP_Y, ADIS16350_YTEMP_OUT, NULL);

static IIO_SCAN_EL_C(temp_z, ADIS16350_SCAN_TEMP_Z, ADIS16350_ZTEMP_OUT, NULL);

static IIO_CONST_ATTR_SCAN_EL_TYPE(temp, s, 12, 16);



static IIO_SCAN_EL_C(in1, ADIS16350_SCAN_ADC_0, ADIS16350_AUX_ADC, NULL);

static IIO_CONST_ATTR_SCAN_EL_TYPE(in1, u, 12, 16);



static IIO_SCAN_EL_TIMESTAMP(11);

static IIO_CONST_ATTR_SCAN_EL_TYPE(timestamp, s, 64, 64);



static struct attribute *adis16350_scan_el_attrs[] = {

	&iio_scan_el_in0_supply.dev_attr.attr,

	&iio_const_attr_in0_supply_index.dev_attr.attr,

	&iio_const_attr_in0_supply_type.dev_attr.attr,

	&iio_scan_el_gyro_x.dev_attr.attr,

	&iio_const_attr_gyro_x_index.dev_attr.attr,

	&iio_scan_el_gyro_y.dev_attr.attr,

	&iio_const_attr_gyro_y_index.dev_attr.attr,

	&iio_scan_el_gyro_z.dev_attr.attr,

	&iio_const_attr_gyro_z_index.dev_attr.attr,

	&iio_const_attr_gyro_type.dev_attr.attr,

	&iio_scan_el_accel_x.dev_attr.attr,

	&iio_const_attr_accel_x_index.dev_attr.attr,

	&iio_scan_el_accel_y.dev_attr.attr,

	&iio_const_attr_accel_y_index.dev_attr.attr,

	&iio_scan_el_accel_z.dev_attr.attr,

	&iio_const_attr_accel_z_index.dev_attr.attr,

	&iio_const_attr_accel_type.dev_attr.attr,

	&iio_scan_el_temp_x.dev_attr.attr,

	&iio_const_attr_temp_x_index.dev_attr.attr,

	&iio_scan_el_temp_y.dev_attr.attr,

	&iio_const_attr_temp_y_index.dev_attr.attr,

	&iio_scan_el_temp_z.dev_attr.attr,

	&iio_const_attr_temp_z_index.dev_attr.attr,

	&iio_const_attr_temp_type.dev_attr.attr,

	&iio_scan_el_in1.dev_attr.attr,

	&iio_const_attr_in1_index.dev_attr.attr,

	&iio_const_attr_in1_type.dev_attr.attr,

	&iio_scan_el_timestamp.dev_attr.attr,

	&iio_const_attr_timestamp_index.dev_attr.attr,

	&iio_const_attr_timestamp_type.dev_attr.attr,

	NULL,

};



static struct attribute_group adis16350_scan_el_group = {

	.attrs = adis16350_scan_el_attrs,

	.name = "scan_elements",

};



/**

 * adis16350_poll_func_th() top half interrupt handler called by trigger

 * @private_data:	iio_dev

 **/

static void adis16350_poll_func_th(struct iio_dev *indio_dev, s64 time)

{

	struct adis16350_state *st = iio_dev_get_devdata(indio_dev);

	st->last_timestamp = time;

	schedule_work(&st->work_trigger_to_ring);

}



/**

 * adis16350_spi_read_burst() - read all data registers

 * @dev: device associated with child of actual device (iio_dev or iio_trig)

 * @rx: somewhere to pass back the value read (min size is 24 bytes)

 **/

static int adis16350_spi_read_burst(struct device *dev, u8 *rx)

{

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct adis16350_state *st = iio_dev_get_devdata(indio_dev);

	u32 old_speed_hz = st->us->max_speed_hz;

	int ret;



	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 2,

			.cs_change = 0,

		}, {

			.rx_buf = rx,

			.bits_per_word = 8,

			.len = 22,

			.cs_change = 0,

		},

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADIS16350_READ_REG(ADIS16350_GLOB_CMD);

	st->tx[1] = 0;



	spi_message_init(&msg);

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

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



	st->us->max_speed_hz = ADIS16350_SPI_BURST;

	spi_setup(st->us);



	ret = spi_sync(st->us, &msg);

	if (ret)

		dev_err(&st->us->dev, "problem when burst reading");



	st->us->max_speed_hz = old_speed_hz;

	spi_setup(st->us);

	mutex_unlock(&st->buf_lock);

	return ret;

}



/* Whilst this makes a lot of calls to iio_sw_ring functions - it is to device

 * specific to be rolled into the core.

 */

static void adis16350_trigger_bh_to_ring(struct work_struct *work_s)

{

	struct adis16350_state *st

		= container_of(work_s, struct adis16350_state,

			       work_trigger_to_ring);

	struct iio_ring_buffer *ring = st->indio_dev->ring;



	int i = 0;

	s16 *data;

	size_t datasize = ring->access.get_bytes_per_datum(ring);



	data = kmalloc(datasize , GFP_KERNEL);

	if (data == NULL) {

		dev_err(&st->us->dev, "memory alloc failed in ring bh");

		return;

	}



	if (ring->scan_count)

		if (adis16350_spi_read_burst(&st->indio_dev->dev, st->rx) >= 0)

			for (; i < ring->scan_count; i++)

				data[i] = be16_to_cpup(

					(__be16 *)&(st->rx[i*2]));



	/* Guaranteed to be aligned with 8 byte boundary */

	if (ring->scan_timestamp)

		*((s64 *)(data + ((i + 3)/4)*4)) = st->last_timestamp;



	ring->access.store_to(ring,

			(u8 *)data,

			st->last_timestamp);



	iio_trigger_notify_done(st->indio_dev->trig);

	kfree(data);



	return;

}



void adis16350_unconfigure_ring(struct iio_dev *indio_dev)

{

	kfree(indio_dev->pollfunc);

	iio_sw_rb_free(indio_dev->ring);

}



int adis16350_configure_ring(struct iio_dev *indio_dev)

{

	int ret = 0;

	struct adis16350_state *st = indio_dev->dev_data;

	struct iio_ring_buffer *ring;

	INIT_WORK(&st->work_trigger_to_ring, adis16350_trigger_bh_to_ring);



	ring = iio_sw_rb_allocate(indio_dev);

	if (!ring) {

		ret = -ENOMEM;

		return ret;

	}

	indio_dev->ring = ring;

	/* Effectively select the ring buffer implementation */

	iio_ring_sw_register_funcs(&ring->access);

	ring->bpe = 2;

	ring->scan_el_attrs = &adis16350_scan_el_group;

	ring->scan_timestamp = true;

	ring->preenable = &iio_sw_ring_preenable;

	ring->postenable = &iio_triggered_ring_postenable;

	ring->predisable = &iio_triggered_ring_predisable;

	ring->owner = THIS_MODULE;



	/* Set default scan mode */

	iio_scan_mask_set(ring, iio_scan_el_in0_supply.number);

	iio_scan_mask_set(ring, iio_scan_el_gyro_x.number);

	iio_scan_mask_set(ring, iio_scan_el_gyro_y.number);

	iio_scan_mask_set(ring, iio_scan_el_gyro_z.number);

	iio_scan_mask_set(ring, iio_scan_el_accel_x.number);

	iio_scan_mask_set(ring, iio_scan_el_accel_y.number);

	iio_scan_mask_set(ring, iio_scan_el_accel_z.number);

	iio_scan_mask_set(ring, iio_scan_el_temp_x.number);

	iio_scan_mask_set(ring, iio_scan_el_temp_y.number);

	iio_scan_mask_set(ring, iio_scan_el_temp_z.number);

	iio_scan_mask_set(ring, iio_scan_el_in1.number);



	ret = iio_alloc_pollfunc(indio_dev, NULL, &adis16350_poll_func_th);

	if (ret)

		goto error_iio_sw_rb_free;



	indio_dev->modes |= INDIO_RING_TRIGGERED;

	return 0;



error_iio_sw_rb_free:

	iio_sw_rb_free(indio_dev->ring);

	return ret;

}