Commit a9d26f00 authored by Barry Song's avatar Barry Song Committed by Greg Kroah-Hartman
Browse files

staging:iio:imu ADIS16400 and ADIS16405 driver 



Signed-off-by: default avatarManuel Stahl <manuel.stahl@iis.fraunhofer.de>
Signed-off-by: default avatarBarry Song <Barry.Song@analog.com>
Acked-by: default avatarJonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 1e3864e6

drivers/staging/iio/imu/Kconfig

+10 −0
Original line number Diff line number Diff line
@@ -12,3 +12,13 @@ config ADIS16300 
	help

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

	  of freedom inertial sensor.



config ADIS16400

	tristate "Analog Devices ADIS16400/5 IMU SPI driver"

 	depends on SPI

	select IIO_SW_RING

	select IIO_RING_BUFFER

	select IIO_TRIGGER

 	help

 	  Say yes here to build support for Analog Devices adis16400/5 triaxial

 	  inertial sensor with Magnetometer.
 
 No newline at end of file

drivers/staging/iio/imu/Makefile

+4 −0
Original line number Diff line number Diff line
@@ -4,3 +4,7 @@ 
adis16300-y             := adis16300_core.o

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

obj-$(CONFIG_ADIS16300) += adis16300.o



adis16400-y             := adis16400_core.o

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

obj-$(CONFIG_ADIS16400) += adis16400.o
 
 No newline at end of file

drivers/staging/iio/imu/adis16400.h

0 → 100644
+238 −0
Original line number Diff line number Diff line 
/*

 * adis16400.h	support Analog Devices ADIS16400

 *		3d 18g accelerometers,

 *		3d gyroscopes,

 *		3d 2.5gauss magnetometers via SPI

 *

 * Copyright (c) 2009 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>

 * Copyright (c) 2007 Jonathan Cameron <jic23@cam.ac.uk>

 *

 * Loosely based upon lis3l02dq.h

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */



#ifndef SPI_ADIS16400_H_

#define SPI_ADIS16400_H_



#define ADIS16400_STARTUP_DELAY	220 /* 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_SUPPLY_OUT 0x02 /* Power supply measurement */

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

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

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

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

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

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

#define ADIS16400_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */

#define ADIS16400_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */

#define ADIS16400_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */

#define ADIS16400_TEMP_OUT  0x16 /* Temperature output */

#define ADIS16400_AUX_ADC   0x18 /* Auxiliary ADC measurement */



/* Calibration parameters */

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

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

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

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

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

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

#define ADIS16400_XMAGN_HIF 0x26 /* X-axis magnetometer, hard-iron factor */

#define ADIS16400_YMAGN_HIF 0x28 /* Y-axis magnetometer, hard-iron factor */

#define ADIS16400_ZMAGN_HIF 0x2A /* Z-axis magnetometer, hard-iron factor */

#define ADIS16400_XMAGN_SIF 0x2C /* X-axis magnetometer, soft-iron factor */

#define ADIS16400_YMAGN_SIF 0x2E /* Y-axis magnetometer, soft-iron factor */

#define ADIS16400_ZMAGN_SIF 0x30 /* Z-axis magnetometer, soft-iron factor */



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

#define ADIS16400_MSC_CTRL  0x34 /* Miscellaneous control */

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

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

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

#define ADIS16400_DIAG_STAT 0x3C /* System status */



/* Alarm functions */

#define ADIS16400_GLOB_CMD  0x3E /* System command */

#define ADIS16400_ALM_MAG1  0x40 /* Alarm 1 amplitude threshold */

#define ADIS16400_ALM_MAG2  0x42 /* Alarm 2 amplitude threshold */

#define ADIS16400_ALM_SMPL1 0x44 /* Alarm 1 sample size */

#define ADIS16400_ALM_SMPL2 0x46 /* Alarm 2 sample size */

#define ADIS16400_ALM_CTRL  0x48 /* Alarm control */

#define ADIS16400_AUX_DAC   0x4A /* Auxiliary DAC data */



#define ADIS16400_PRODUCT_ID 0x56 /* Product identifier */

#define ADIS16400_PRODUCT_ID_DEFAULT 0x4015	/* Datasheet says 0x4105, I get 0x4015 */



#define ADIS16400_ERROR_ACTIVE			(1<<14)

#define ADIS16400_NEW_DATA			(1<<14)



/* MSC_CTRL */

#define ADIS16400_MSC_CTRL_MEM_TEST		(1<<11)

#define ADIS16400_MSC_CTRL_INT_SELF_TEST	(1<<10)

#define ADIS16400_MSC_CTRL_NEG_SELF_TEST	(1<<9)

#define ADIS16400_MSC_CTRL_POS_SELF_TEST	(1<<8)

#define ADIS16400_MSC_CTRL_GYRO_BIAS		(1<<7)

#define ADIS16400_MSC_CTRL_ACCL_ALIGN		(1<<6)

#define ADIS16400_MSC_CTRL_DATA_RDY_EN		(1<<2)

#define ADIS16400_MSC_CTRL_DATA_RDY_POL_HIGH	(1<<1)

#define ADIS16400_MSC_CTRL_DATA_RDY_DIO2	(1<<0)



/* SMPL_PRD */

#define ADIS16400_SMPL_PRD_TIME_BASE	(1<<7)

#define ADIS16400_SMPL_PRD_DIV_MASK	0x7F



/* DIAG_STAT */

#define ADIS16400_DIAG_STAT_ZACCL_FAIL	(1<<15)

#define ADIS16400_DIAG_STAT_YACCL_FAIL	(1<<14)

#define ADIS16400_DIAG_STAT_XACCL_FAIL	(1<<13)

#define ADIS16400_DIAG_STAT_XGYRO_FAIL	(1<<12)

#define ADIS16400_DIAG_STAT_YGYRO_FAIL	(1<<11)

#define ADIS16400_DIAG_STAT_ZGYRO_FAIL	(1<<10)

#define ADIS16400_DIAG_STAT_ALARM2	(1<<9)

#define ADIS16400_DIAG_STAT_ALARM1	(1<<8)

#define ADIS16400_DIAG_STAT_FLASH_CHK	(1<<6)

#define ADIS16400_DIAG_STAT_SELF_TEST	(1<<5)

#define ADIS16400_DIAG_STAT_OVERFLOW	(1<<4)

#define ADIS16400_DIAG_STAT_SPI_FAIL	(1<<3)

#define ADIS16400_DIAG_STAT_FLASH_UPT	(1<<2)

#define ADIS16400_DIAG_STAT_POWER_HIGH	(1<<1)

#define ADIS16400_DIAG_STAT_POWER_LOW	(1<<0)



/* GLOB_CMD */

#define ADIS16400_GLOB_CMD_SW_RESET	(1<<7)

#define ADIS16400_GLOB_CMD_P_AUTO_NULL	(1<<4)

#define ADIS16400_GLOB_CMD_FLASH_UPD	(1<<3)

#define ADIS16400_GLOB_CMD_DAC_LATCH	(1<<2)

#define ADIS16400_GLOB_CMD_FAC_CALIB	(1<<1)

#define ADIS16400_GLOB_CMD_AUTO_NULL	(1<<0)



/* SLP_CNT */

#define ADIS16400_SLP_CNT_POWER_OFF	(1<<8)



#define ADIS16400_MAX_TX 24

#define ADIS16400_MAX_RX 24



#define ADIS16400_SPI_SLOW	(u32)(300 * 1000)

#define ADIS16400_SPI_BURST	(u32)(1000 * 1000)

#define ADIS16400_SPI_FAST	(u32)(2000 * 1000)



/**

 * struct adis16400_state - device instance specific data

 * @us:			actual spi_device

 * @work_trigger_to_ring: bh for triggered event handling

 * @work_cont_thresh: CLEAN

 * @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:			recieve buffer

 * @buf_lock:		mutex to protect tx and rx

 **/

struct adis16400_state {

	struct spi_device		*us;

	struct work_struct		work_trigger_to_ring;

	struct iio_work_cont		work_cont_thresh;

	s64				last_timestamp;

	struct iio_dev			*indio_dev;

	struct iio_trigger		*trig;

	u8				*tx;

	u8				*rx;

	struct mutex			buf_lock;

};



int adis16400_spi_write_reg_8(struct device *dev,

			      u8 reg_address,

			      u8 val);



int adis16400_spi_read_burst(struct device *dev, u8 *rx);



int adis16400_spi_read_sequence(struct device *dev,

				      u8 *tx, u8 *rx, int num);



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



int adis16400_reset(struct device *dev);



int adis16400_stop_device(struct device *dev);



int adis16400_check_status(struct device *dev);



#ifdef CONFIG_IIO_RING_BUFFER

/* At the moment triggers are only used for ring buffer

 * filling. This may change!

 */



enum adis16400_scan {

	ADIS16400_SCAN_SUPPLY,

	ADIS16400_SCAN_GYRO_X,

	ADIS16400_SCAN_GYRO_Y,

	ADIS16400_SCAN_GYRO_Z,

	ADIS16400_SCAN_ACC_X,

	ADIS16400_SCAN_ACC_Y,

	ADIS16400_SCAN_ACC_Z,

	ADIS16400_SCAN_MAGN_X,

	ADIS16400_SCAN_MAGN_Y,

	ADIS16400_SCAN_MAGN_Z,

	ADIS16400_SCAN_TEMP,

	ADIS16400_SCAN_ADC_0

};



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,

				      struct device_attribute *attr,

				      char *buf);





int adis16400_configure_ring(struct iio_dev *indio_dev);

void adis16400_unconfigure_ring(struct iio_dev *indio_dev);



int adis16400_initialize_ring(struct iio_ring_buffer *ring);

void adis16400_uninitialize_ring(struct iio_ring_buffer *ring);

#else /* CONFIG_IIO_RING_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

adis16400_read_data_from_ring(struct device *dev,

			      struct device_attribute *attr,

			      char *buf)

{

	return 0;

}



static int adis16400_configure_ring(struct iio_dev *indio_dev)

{

	return 0;

}



static inline void adis16400_unconfigure_ring(struct iio_dev *indio_dev)

{

}



static inline int adis16400_initialize_ring(struct iio_ring_buffer *ring)

{

	return 0;

}



static inline void adis16400_uninitialize_ring(struct iio_ring_buffer *ring)

{

}



#endif /* CONFIG_IIO_RING_BUFFER */

#endif /* SPI_ADIS16400_H_ */

drivers/staging/iio/imu/adis16400_core.c

0 → 100644
+849 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/iio/imu/adis16400_ring.c

0 → 100644
+245 −0
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/sysfs.h>

#include <linux/list.h>



#include "../iio.h"

#include "../sysfs.h"

#include "../ring_sw.h"

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

#include "../trigger.h"

#include "adis16400.h"



/**

 * combine_8_to_16() utility function to munge to u8s into u16

 **/

static inline u16 combine_8_to_16(u8 lower, u8 upper)

{

	u16 _lower = lower;

	u16 _upper = upper;

	return _lower | (_upper << 8);

}



static IIO_SCAN_EL_C(supply, ADIS16400_SCAN_SUPPLY, IIO_SIGNED(14),

		     ADIS16400_SUPPLY_OUT, NULL);



static IIO_SCAN_EL_C(gyro_x, ADIS16400_SCAN_GYRO_X, IIO_SIGNED(14),

		     ADIS16400_XGYRO_OUT, NULL);

static IIO_SCAN_EL_C(gyro_y, ADIS16400_SCAN_GYRO_Y, IIO_SIGNED(14),

		     ADIS16400_YGYRO_OUT, NULL);

static IIO_SCAN_EL_C(gyro_z, ADIS16400_SCAN_GYRO_Z, IIO_SIGNED(14),

		     ADIS16400_ZGYRO_OUT, NULL);



static IIO_SCAN_EL_C(accel_x, ADIS16400_SCAN_ACC_X, IIO_SIGNED(14),

		     ADIS16400_XACCL_OUT, NULL);

static IIO_SCAN_EL_C(accel_y, ADIS16400_SCAN_ACC_Y, IIO_SIGNED(14),

		     ADIS16400_YACCL_OUT, NULL);

static IIO_SCAN_EL_C(accel_z, ADIS16400_SCAN_ACC_Z, IIO_SIGNED(14),

		     ADIS16400_ZACCL_OUT, NULL);



static IIO_SCAN_EL_C(magn_x, ADIS16400_SCAN_MAGN_X, IIO_SIGNED(14),

		     ADIS16400_XMAGN_OUT, NULL);

static IIO_SCAN_EL_C(magn_y, ADIS16400_SCAN_MAGN_Y, IIO_SIGNED(14),

		     ADIS16400_YMAGN_OUT, NULL);

static IIO_SCAN_EL_C(magn_z, ADIS16400_SCAN_MAGN_Z, IIO_SIGNED(14),

		     ADIS16400_ZMAGN_OUT, NULL);



static IIO_SCAN_EL_C(temp, ADIS16400_SCAN_TEMP, IIO_SIGNED(12),

		     ADIS16400_TEMP_OUT, NULL);

static IIO_SCAN_EL_C(adc_0, ADIS16400_SCAN_ADC_0, IIO_SIGNED(12),

		     ADIS16400_AUX_ADC, NULL);



static IIO_SCAN_EL_TIMESTAMP(12);



static struct attribute *adis16400_scan_el_attrs[] = {

	&iio_scan_el_supply.dev_attr.attr,

	&iio_scan_el_gyro_x.dev_attr.attr,

	&iio_scan_el_gyro_y.dev_attr.attr,

	&iio_scan_el_gyro_z.dev_attr.attr,

	&iio_scan_el_accel_x.dev_attr.attr,

	&iio_scan_el_accel_y.dev_attr.attr,

	&iio_scan_el_accel_z.dev_attr.attr,

	&iio_scan_el_magn_x.dev_attr.attr,

	&iio_scan_el_magn_y.dev_attr.attr,

	&iio_scan_el_magn_z.dev_attr.attr,

	&iio_scan_el_temp.dev_attr.attr,

	&iio_scan_el_adc_0.dev_attr.attr,

	&iio_scan_el_timestamp.dev_attr.attr,

	NULL,

};



static struct attribute_group adis16400_scan_el_group = {

	.attrs = adis16400_scan_el_attrs,

	.name = "scan_elements",

};



/**

 * adis16400_poll_func_th() top half interrupt handler called by trigger

 * @private_data:	iio_dev

 **/

static void adis16400_poll_func_th(struct iio_dev *indio_dev)

{

	struct adis16400_state *st = iio_dev_get_devdata(indio_dev);

	st->last_timestamp = indio_dev->trig->timestamp;

	schedule_work(&st->work_trigger_to_ring);

	/* Indicate that this interrupt is being handled */



	/* Technically this is trigger related, but without this

	 * handler running there is currently no way for the interrupt

	 * to clear.

	 */

}



/* 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 adis16400_trigger_bh_to_ring(struct work_struct *work_s)

{

	struct adis16400_state *st

		= container_of(work_s, struct adis16400_state,

			       work_trigger_to_ring);



	int i = 0;

	s16 *data;

	size_t datasize = st->indio_dev

		->ring->access.get_bpd(st->indio_dev->ring);



	data = kmalloc(datasize , GFP_KERNEL);

	if (data == NULL) {

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

		return;

	}



	if (st->indio_dev->scan_count)

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

			for (; i < st->indio_dev->scan_count; i++) {

				data[i] = combine_8_to_16(st->rx[i*2+1],

							  st->rx[i*2]);

			}



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

	if (st->indio_dev->scan_timestamp)

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



	st->indio_dev->ring->access.store_to(st->indio_dev->ring,

					    (u8 *)data,

					    st->last_timestamp);



	iio_trigger_notify_done(st->indio_dev->trig);

	kfree(data);



	return;

}

/* in these circumstances is it better to go with unaligned packing and

 * deal with the cost?*/

static int adis16400_data_rdy_ring_preenable(struct iio_dev *indio_dev)

{

	size_t size;

	dev_dbg(&indio_dev->dev, "%s\n", __func__);

	/* Check if there are any scan elements enabled, if not fail*/

	if (!(indio_dev->scan_count || indio_dev->scan_timestamp))

		return -EINVAL;



	if (indio_dev->ring->access.set_bpd) {

		if (indio_dev->scan_timestamp)

			if (indio_dev->scan_count) /* Timestamp and data */

				size = 6*sizeof(s64);

			else /* Timestamp only  */

				size = sizeof(s64);

		else /* Data only */

			size = indio_dev->scan_count*sizeof(s16);

		indio_dev->ring->access.set_bpd(indio_dev->ring, size);

	}



	return 0;

}



static int adis16400_data_rdy_ring_postenable(struct iio_dev *indio_dev)

{

	return indio_dev->trig

		? iio_trigger_attach_poll_func(indio_dev->trig,

					       indio_dev->pollfunc)

		: 0;

}



static int adis16400_data_rdy_ring_predisable(struct iio_dev *indio_dev)

{

	return indio_dev->trig

		? iio_trigger_dettach_poll_func(indio_dev->trig,

						indio_dev->pollfunc)

		: 0;

}



void adis16400_unconfigure_ring(struct iio_dev *indio_dev)

{

	kfree(indio_dev->pollfunc);

	iio_sw_rb_free(indio_dev->ring);

}



int adis16400_configure_ring(struct iio_dev *indio_dev)

{

	int ret = 0;

	struct adis16400_state *st = indio_dev->dev_data;

	struct iio_ring_buffer *ring;

	INIT_WORK(&st->work_trigger_to_ring, adis16400_trigger_bh_to_ring);

	/* Set default scan mode */



	iio_scan_mask_set(indio_dev, iio_scan_el_supply.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_gyro_x.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_gyro_y.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_gyro_z.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_accel_x.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_accel_y.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_accel_z.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_magn_x.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_magn_y.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_magn_z.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_temp.number);

	iio_scan_mask_set(indio_dev, iio_scan_el_adc_0.number);

	indio_dev->scan_timestamp = true;



	indio_dev->scan_el_attrs = &adis16400_scan_el_group;



	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->preenable = &adis16400_data_rdy_ring_preenable;

	ring->postenable = &adis16400_data_rdy_ring_postenable;

	ring->predisable = &adis16400_data_rdy_ring_predisable;

	ring->owner = THIS_MODULE;



	indio_dev->pollfunc = kzalloc(sizeof(*indio_dev->pollfunc), GFP_KERNEL);

	if (indio_dev->pollfunc == NULL) {

		ret = -ENOMEM;

		goto error_iio_sw_rb_free;;

	}

	indio_dev->pollfunc->poll_func_main = &adis16400_poll_func_th;

	indio_dev->pollfunc->private_data = indio_dev;

	indio_dev->modes |= INDIO_RING_TRIGGERED;

	return 0;



error_iio_sw_rb_free:

	iio_sw_rb_free(indio_dev->ring);

	return ret;

}



int adis16400_initialize_ring(struct iio_ring_buffer *ring)

{

	return iio_ring_buffer_register(ring, 0);

}



void adis16400_uninitialize_ring(struct iio_ring_buffer *ring)

{

	iio_ring_buffer_unregister(ring);

}