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 Original line Diff line number Diff line
@@ -12,15 +12,6 @@ config ADIS16300 
	  Say yes here to build support for Analog Devices adis16300 four degrees

	  Say yes here to build support for Analog Devices adis16300 four degrees

	  of freedom inertial sensor.

	  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

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

drivers/staging/iio/imu/Makefile

+0 −4
Original line number Original line 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

adis16300-$(CONFIG_IIO_RING_BUFFER) += adis16300_ring.o adis16300_trigger.o

obj-$(CONFIG_ADIS16300) += adis16300.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-y             := adis16400_core.o

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

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

obj-$(CONFIG_ADIS16400) += adis16400.o
 
obj-$(CONFIG_ADIS16400) += adis16400.o

drivers/staging/iio/imu/adis16350.h

deleted100644 → 0
+0 −177
Original line number Original line 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 Original line 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;

}