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

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

staging: iio: adis16240 driver 



Signed-off-by: default avatarBarry Song <Barry.Song@analog.com>
Signed-off-by: default avatarJonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 671ece14

drivers/staging/iio/accel/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -12,6 +12,15 @@ config ADIS16209 
         Say yes here to build support for Analog Devices adis16209 dual-axis digital inclinometer

	 and accelerometer.



config ADIS16240

       tristate "Analog Devices ADIS16240 Programmable Impact Sensor and Recorder"

       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 adis16240 programmable

	 impact Sensor and recorder.



config KXSD9

	tristate "Kionix KXSD9 Accelerometer Driver"

	depends on SPI

drivers/staging/iio/accel/Makefile

+4 −0
Original line number Diff line number Diff line
@@ -5,6 +5,10 @@ adis16209-y := adis16209_core.o 
adis16209-$(CONFIG_IIO_RING_BUFFER) += adis16209_ring.o adis16209_trigger.o

obj-$(CONFIG_ADIS16209) += adis16209.o



adis16240-y             := adis16240_core.o

adis16240-$(CONFIG_IIO_RING_BUFFER) += adis16240_ring.o adis16240_trigger.o

obj-$(CONFIG_ADIS16240) += adis16240.o



obj-$(CONFIG_KXSD9)	+= kxsd9.o



lis3l02dq-y		:= lis3l02dq_core.o

drivers/staging/iio/accel/adis16240.h

0 → 100644
+218 −0
Original line number Diff line number Diff line 
#ifndef SPI_ADIS16240_H_

#define SPI_ADIS16240_H_



#define ADIS16240_STARTUP_DELAY	220 /* ms */



#define ADIS16240_READ_REG(a)    a

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



/* Flash memory write count */

#define ADIS16240_FLASH_CNT      0x00

/* Output, power supply */

#define ADIS16240_SUPPLY_OUT     0x02

/* Output, x-axis accelerometer */

#define ADIS16240_XACCL_OUT      0x04

/* Output, y-axis accelerometer */

#define ADIS16240_YACCL_OUT      0x06

/* Output, z-axis accelerometer */

#define ADIS16240_ZACCL_OUT      0x08

/* Output, auxiliary ADC input */

#define ADIS16240_AUX_ADC        0x0A

/* Output, temperature */

#define ADIS16240_TEMP_OUT       0x0C

/* Output, x-axis acceleration peak */

#define ADIS16240_XPEAK_OUT      0x0E

/* Output, y-axis acceleration peak */

#define ADIS16240_YPEAK_OUT      0x10

/* Output, z-axis acceleration peak */

#define ADIS16240_ZPEAK_OUT      0x12

/* Output, sum-of-squares acceleration peak */

#define ADIS16240_XYZPEAK_OUT    0x14

/* Output, Capture Buffer 1, X and Y acceleration */

#define ADIS16240_CAPT_BUF1      0x16

/* Output, Capture Buffer 2, Z acceleration */

#define ADIS16240_CAPT_BUF2      0x18

/* Diagnostic, error flags */

#define ADIS16240_DIAG_STAT      0x1A

/* Diagnostic, event counter */

#define ADIS16240_EVNT_CNTR      0x1C

/* Diagnostic, check sum value from firmware test */

#define ADIS16240_CHK_SUM        0x1E

/* Calibration, x-axis acceleration offset adjustment */

#define ADIS16240_XACCL_OFF      0x20

/* Calibration, y-axis acceleration offset adjustment */

#define ADIS16240_YACCL_OFF      0x22

/* Calibration, z-axis acceleration offset adjustment */

#define ADIS16240_ZACCL_OFF      0x24

/* Clock, hour and minute */

#define ADIS16240_CLK_TIME       0x2E

/* Clock, month and day */

#define ADIS16240_CLK_DATE       0x30

/* Clock, year */

#define ADIS16240_CLK_YEAR       0x32

/* Wake-up setting, hour and minute */

#define ADIS16240_WAKE_TIME      0x34

/* Wake-up setting, month and day */

#define ADIS16240_WAKE_DATE      0x36

/* Alarm 1 amplitude threshold */

#define ADIS16240_ALM_MAG1       0x38

/* Alarm 2 amplitude threshold */

#define ADIS16240_ALM_MAG2       0x3A

/* Alarm control */

#define ADIS16240_ALM_CTRL       0x3C

/* Capture, external trigger control */

#define ADIS16240_XTRIG_CTRL     0x3E

/* Capture, address pointer */

#define ADIS16240_CAPT_PNTR      0x40

/* Capture, configuration and control */

#define ADIS16240_CAPT_CTRL      0x42

/* General-purpose digital input/output control */

#define ADIS16240_GPIO_CTRL      0x44

/* Miscellaneous control */

#define ADIS16240_MSC_CTRL       0x46

/* Internal sample period (rate) control */

#define ADIS16240_SMPL_PRD       0x48

/* System command */

#define ADIS16240_GLOB_CMD       0x4A



#define ADIS16240_OUTPUTS        6



/* MSC_CTRL */

/* Enables sum-of-squares output (XYZPEAK_OUT) */

#define ADIS16240_MSC_CTRL_XYZPEAK_OUT_EN	(1 << 15)

/* Enables peak tracking output (XPEAK_OUT, YPEAK_OUT, and ZPEAK_OUT) */

#define ADIS16240_MSC_CTRL_X_Y_ZPEAK_OUT_EN	(1 << 14)

/* Self-test enable: 1 = apply electrostatic force, 0 = disabled */

#define ADIS16240_MSC_CTRL_SELF_TEST_EN	        (1 << 8)

/* Data-ready enable: 1 = enabled, 0 = disabled */

#define ADIS16240_MSC_CTRL_DATA_RDY_EN	        (1 << 2)

/* Data-ready polarity: 1 = active high, 0 = active low */

#define ADIS16240_MSC_CTRL_ACTIVE_HIGH	        (1 << 1)

/* Data-ready line selection: 1 = DIO2, 0 = DIO1 */

#define ADIS16240_MSC_CTRL_DATA_RDY_DIO2	(1 << 0)



/* DIAG_STAT */

/* Alarm 2 status: 1 = alarm active, 0 = alarm inactive */

#define ADIS16240_DIAG_STAT_ALARM2      (1<<9)

/* Alarm 1 status: 1 = alarm active, 0 = alarm inactive */

#define ADIS16240_DIAG_STAT_ALARM1      (1<<8)

/* Capture buffer full: 1 = capture buffer is full */

#define ADIS16240_DIAG_STAT_CPT_BUF_FUL (1<<7)

/* Flash test, checksum flag: 1 = mismatch, 0 = match */

#define ADIS16240_DIAG_STAT_CHKSUM      (1<<6)

/* Power-on, self-test flag: 1 = failure, 0 = pass */

#define ADIS16240_DIAG_STAT_PWRON_FAIL  (1<<5)

/* Power-on self-test: 1 = in-progress, 0 = complete */

#define ADIS16240_DIAG_STAT_PWRON_BUSY  (1<<4)

/* SPI communications failure */

#define ADIS16240_DIAG_STAT_SPI_FAIL	(1<<3)

/* Flash update failure */

#define ADIS16240_DIAG_STAT_FLASH_UPT	(1<<2)

/* Power supply above 3.625 V */

#define ADIS16240_DIAG_STAT_POWER_HIGH	(1<<1)

 /* Power supply below 3.15 V */

#define ADIS16240_DIAG_STAT_POWER_LOW	(1<<0)



/* GLOB_CMD */

#define ADIS16240_GLOB_CMD_RESUME	(1<<8)

#define ADIS16240_GLOB_CMD_SW_RESET	(1<<7)

#define ADIS16240_GLOB_CMD_STANDBY	(1<<2)



#define ADIS16240_ERROR_ACTIVE          (1<<14)



#define ADIS16240_MAX_TX 24

#define ADIS16240_MAX_RX 24



/**

 * struct adis16240_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 adis16240_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 adis16240_set_irq(struct device *dev, bool enable);



#ifdef CONFIG_IIO_RING_BUFFER

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

 * filling. This may change!

 */



enum adis16240_scan {

	ADIS16240_SCAN_SUPPLY,

	ADIS16240_SCAN_ACC_X,

	ADIS16240_SCAN_ACC_Y,

	ADIS16240_SCAN_ACC_Z,

	ADIS16240_SCAN_AUX_ADC,

	ADIS16240_SCAN_TEMP,

};



void adis16240_remove_trigger(struct iio_dev *indio_dev);

int adis16240_probe_trigger(struct iio_dev *indio_dev);



ssize_t adis16240_read_data_from_ring(struct device *dev,

				      struct device_attribute *attr,

				      char *buf);





int adis16240_configure_ring(struct iio_dev *indio_dev);

void adis16240_unconfigure_ring(struct iio_dev *indio_dev);



int adis16240_initialize_ring(struct iio_ring_buffer *ring);

void adis16240_uninitialize_ring(struct iio_ring_buffer *ring);

#else /* CONFIG_IIO_RING_BUFFER */



static inline void adis16240_remove_trigger(struct iio_dev *indio_dev)

{

}



static inline int adis16240_probe_trigger(struct iio_dev *indio_dev)

{

	return 0;

}



static inline ssize_t

adis16240_read_data_from_ring(struct device *dev,

			      struct device_attribute *attr,

			      char *buf)

{

	return 0;

}



static int adis16240_configure_ring(struct iio_dev *indio_dev)

{

	return 0;

}



static inline void adis16240_unconfigure_ring(struct iio_dev *indio_dev)

{

}



static inline int adis16240_initialize_ring(struct iio_ring_buffer *ring)

{

	return 0;

}



static inline void adis16240_uninitialize_ring(struct iio_ring_buffer *ring)

{

}



#endif /* CONFIG_IIO_RING_BUFFER */

#endif /* SPI_ADIS16240_H_ */

drivers/staging/iio/accel/adis16240_core.c

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

 * ADIS16240 Programmable Impact Sensor and Recorder driver

 *

 * Copyright 2010 Analog Devices Inc.

 *

 * Licensed under the GPL-2 or later.

 */



#include <linux/interrupt.h>

#include <linux/irq.h>

#include <linux/gpio.h>

#include <linux/delay.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 "accel.h"

#include "../adc/adc.h"



#include "adis16240.h"



#define DRIVER_NAME		"adis16240"



static int adis16240_check_status(struct device *dev);



/**

 * adis16240_spi_write_reg_8() - write single byte to a register

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

 * @reg_address: the address of the register to be written

 * @val: the value to write

 **/

static int adis16240_spi_write_reg_8(struct device *dev,

		u8 reg_address,

		u8 val)

{

	int ret;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct adis16240_state *st = iio_dev_get_devdata(indio_dev);



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADIS16240_WRITE_REG(reg_address);

	st->tx[1] = val;



	ret = spi_write(st->us, st->tx, 2);

	mutex_unlock(&st->buf_lock);



	return ret;

}



/**

 * adis16240_spi_write_reg_16() - write 2 bytes to a pair of registers

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

 * @reg_address: the address of the lower of the two registers. Second register

 *               is assumed to have address one greater.

 * @val: value to be written

 **/

static int adis16240_spi_write_reg_16(struct device *dev,

		u8 lower_reg_address,

		u16 value)

{

	int ret;

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct adis16240_state *st = iio_dev_get_devdata(indio_dev);

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 2,

			.cs_change = 1,

			.delay_usecs = 25,

		}, {

			.tx_buf = st->tx + 2,

			.bits_per_word = 8,

			.len = 2,

			.cs_change = 1,

			.delay_usecs = 25,

		},

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADIS16240_WRITE_REG(lower_reg_address);

	st->tx[1] = value & 0xFF;

	st->tx[2] = ADIS16240_WRITE_REG(lower_reg_address + 1);

	st->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(st->us, &msg);

	mutex_unlock(&st->buf_lock);



	return ret;

}



/**

 * adis16240_spi_read_reg_16() - read 2 bytes from a 16-bit register

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

 * @reg_address: the address of the lower of the two registers. Second register

 *               is assumed to have address one greater.

 * @val: somewhere to pass back the value read

 **/

static int adis16240_spi_read_reg_16(struct device *dev,

		u8 lower_reg_address,

		u16 *val)

{

	struct spi_message msg;

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	struct adis16240_state *st = iio_dev_get_devdata(indio_dev);

	int ret;

	struct spi_transfer xfers[] = {

		{

			.tx_buf = st->tx,

			.bits_per_word = 8,

			.len = 2,

			.cs_change = 1,

			.delay_usecs = 25,

		}, {

			.rx_buf = st->rx,

			.bits_per_word = 8,

			.len = 2,

			.cs_change = 1,

			.delay_usecs = 25,

		},

	};



	mutex_lock(&st->buf_lock);

	st->tx[0] = ADIS16240_READ_REG(lower_reg_address);

	st->tx[1] = 0;

	st->tx[2] = 0;

	st->tx[3] = 0;



	spi_message_init(&msg);

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

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

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

	if (ret) {

		dev_err(&st->us->dev,

			"problem when reading 16 bit register 0x%02X",

			lower_reg_address);

		goto error_ret;

	}

	*val = (st->rx[0] << 8) | st->rx[1];



error_ret:

	mutex_unlock(&st->buf_lock);

	return ret;

}



static ssize_t adis16240_spi_read_signed(struct device *dev,

		struct device_attribute *attr,

		char *buf,

		unsigned bits)

{

	int ret;

	s16 val = 0;

	unsigned shift = 16 - bits;

	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);



	ret = adis16240_spi_read_reg_16(dev, this_attr->address, (u16 *)&val);

	if (ret)

		return ret;



	if (val & ADIS16240_ERROR_ACTIVE)

		adis16240_check_status(dev);



	val = ((s16)(val << shift) >> shift);

	return sprintf(buf, "%d\n", val);

}



static ssize_t adis16240_read_10bit_unsigned(struct device *dev,

		struct device_attribute *attr,

		char *buf)

{

	int ret;

	u16 val = 0;

	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);



	ret = adis16240_spi_read_reg_16(dev, this_attr->address, &val);

	if (ret)

		return ret;



	if (val & ADIS16240_ERROR_ACTIVE)

		adis16240_check_status(dev);



	return sprintf(buf, "%u\n", val & 0x03FF);

}



static ssize_t adis16240_read_10bit_signed(struct device *dev,

		struct device_attribute *attr,

		char *buf)

{

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	ssize_t ret;



	/* Take the iio_dev status lock */

	mutex_lock(&indio_dev->mlock);

	ret =  adis16240_spi_read_signed(dev, attr, buf, 10);

	mutex_unlock(&indio_dev->mlock);



	return ret;

}



static ssize_t adis16240_read_12bit_signed(struct device *dev,

		struct device_attribute *attr,

		char *buf)

{

	struct iio_dev *indio_dev = dev_get_drvdata(dev);

	ssize_t ret;



	/* Take the iio_dev status lock */

	mutex_lock(&indio_dev->mlock);

	ret =  adis16240_spi_read_signed(dev, attr, buf, 12);

	mutex_unlock(&indio_dev->mlock);



	return ret;

}



static ssize_t adis16240_write_16bit(struct device *dev,

		struct device_attribute *attr,

		const char *buf,

		size_t len)

{

	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);

	int ret;

	long val;



	ret = strict_strtol(buf, 10, &val);

	if (ret)

		goto error_ret;

	ret = adis16240_spi_write_reg_16(dev, this_attr->address, val);



error_ret:

	return ret ? ret : len;

}



static int adis16240_reset(struct device *dev)

{

	int ret;

	ret = adis16240_spi_write_reg_8(dev,

			ADIS16240_GLOB_CMD,

			ADIS16240_GLOB_CMD_SW_RESET);

	if (ret)

		dev_err(dev, "problem resetting device");



	return ret;

}



static ssize_t adis16240_write_reset(struct device *dev,

		struct device_attribute *attr,

		const char *buf, size_t len)

{

	if (len < 1)

		return -EINVAL;

	switch (buf[0]) {

	case '1':

	case 'y':

	case 'Y':

		return adis16240_reset(dev);

	}

	return -EINVAL;

}



int adis16240_set_irq(struct device *dev, bool enable)

{

	int ret = 0;

	u16 msc;



	ret = adis16240_spi_read_reg_16(dev, ADIS16240_MSC_CTRL, &msc);

	if (ret)

		goto error_ret;



	msc |= ADIS16240_MSC_CTRL_ACTIVE_HIGH;

	msc &= ~ADIS16240_MSC_CTRL_DATA_RDY_DIO2;

	if (enable)

		msc |= ADIS16240_MSC_CTRL_DATA_RDY_EN;

	else

		msc &= ~ADIS16240_MSC_CTRL_DATA_RDY_EN;



	ret = adis16240_spi_write_reg_16(dev, ADIS16240_MSC_CTRL, msc);



error_ret:

	return ret;

}



static int adis16240_self_test(struct device *dev)

{

	int ret;

	ret = adis16240_spi_write_reg_16(dev,

			ADIS16240_MSC_CTRL,

			ADIS16240_MSC_CTRL_SELF_TEST_EN);

	if (ret) {

		dev_err(dev, "problem starting self test");

		goto err_ret;

	}



	msleep(ADIS16240_STARTUP_DELAY);



	adis16240_check_status(dev);



err_ret:

	return ret;

}



static int adis16240_check_status(struct device *dev)

{

	u16 status;

	int ret;



	ret = adis16240_spi_read_reg_16(dev, ADIS16240_DIAG_STAT, &status);



	if (ret < 0) {

		dev_err(dev, "Reading status failed\n");

		goto error_ret;

	}



	ret = status & 0x2F;

	if (status & ADIS16240_DIAG_STAT_PWRON_FAIL)

		dev_err(dev, "Power-on, self-test fail\n");

	if (status & ADIS16240_DIAG_STAT_SPI_FAIL)

		dev_err(dev, "SPI failure\n");

	if (status & ADIS16240_DIAG_STAT_FLASH_UPT)

		dev_err(dev, "Flash update failed\n");

	if (status & ADIS16240_DIAG_STAT_POWER_HIGH)

		dev_err(dev, "Power supply above 3.625V\n");

	if (status & ADIS16240_DIAG_STAT_POWER_LOW)

		dev_err(dev, "Power supply below 2.225V\n");



error_ret:

	return ret;

}



static int adis16240_initial_setup(struct adis16240_state *st)

{

	int ret;

	struct device *dev = &st->indio_dev->dev;



	/* Disable IRQ */

	ret = adis16240_set_irq(dev, false);

	if (ret) {

		dev_err(dev, "disable irq failed");

		goto err_ret;

	}



	/* Do self test */

	ret = adis16240_self_test(dev);

	if (ret) {

		dev_err(dev, "self test failure");

		goto err_ret;

	}



	/* Read status register to check the result */

	ret = adis16240_check_status(dev);

	if (ret) {

		adis16240_reset(dev);

		dev_err(dev, "device not playing ball -> reset");

		msleep(ADIS16240_STARTUP_DELAY);

		ret = adis16240_check_status(dev);

		if (ret) {

			dev_err(dev, "giving up");

			goto err_ret;

		}

	}



	printk(KERN_INFO DRIVER_NAME ": at CS%d (irq %d)\n",

			st->us->chip_select, st->us->irq);



err_ret:

	return ret;

}



static IIO_DEV_ATTR_IN_NAMED_RAW(supply, adis16240_read_10bit_unsigned,

		ADIS16240_SUPPLY_OUT);

static IIO_DEV_ATTR_IN_RAW(0, adis16240_read_10bit_signed,

		ADIS16240_AUX_ADC);

static IIO_CONST_ATTR(in_supply_scale, "0.00488");

static IIO_DEV_ATTR_ACCEL_X(adis16240_read_10bit_signed,

		ADIS16240_XACCL_OUT);

static IIO_DEVICE_ATTR(accel_x_peak_raw, S_IRUGO,

		       adis16240_read_10bit_signed, NULL,

		       ADIS16240_XPEAK_OUT);

static IIO_DEV_ATTR_ACCEL_Y(adis16240_read_10bit_signed,

		ADIS16240_YACCL_OUT);

static IIO_DEVICE_ATTR(accel_y_peak_raw, S_IRUGO,

		       adis16240_read_10bit_signed, NULL,

		       ADIS16240_YPEAK_OUT);

static IIO_DEV_ATTR_ACCEL_Z(adis16240_read_10bit_signed,

		ADIS16240_ZACCL_OUT);

static IIO_DEVICE_ATTR(accel_z_peak_raw, S_IRUGO,

		       adis16240_read_10bit_signed, NULL,

		       ADIS16240_ZPEAK_OUT);



static IIO_DEVICE_ATTR(accel_xyz_squared_peak_raw, S_IRUGO,

		       adis16240_read_12bit_signed, NULL,

		       ADIS16240_XYZPEAK_OUT);

static IIO_DEV_ATTR_ACCEL_X_OFFSET(S_IWUSR | S_IRUGO,

		adis16240_read_10bit_signed,

		adis16240_write_16bit,

		ADIS16240_XACCL_OFF);

static IIO_DEV_ATTR_ACCEL_Y_OFFSET(S_IWUSR | S_IRUGO,

		adis16240_read_10bit_signed,

		adis16240_write_16bit,

		ADIS16240_YACCL_OFF);

static IIO_DEV_ATTR_ACCEL_Z_OFFSET(S_IWUSR | S_IRUGO,

		adis16240_read_10bit_signed,

		adis16240_write_16bit,

		ADIS16240_ZACCL_OFF);

static IIO_DEV_ATTR_TEMP_RAW(adis16240_read_10bit_unsigned);

static IIO_CONST_ATTR(temp_scale, "0.244");



static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16240_write_reset, 0);



static IIO_CONST_ATTR_AVAIL_SAMP_FREQ("4096");



static IIO_CONST_ATTR(name, "adis16240");



static struct attribute *adis16240_event_attributes[] = {

	NULL

};



static struct attribute_group adis16240_event_attribute_group = {

	.attrs = adis16240_event_attributes,

};



static struct attribute *adis16240_attributes[] = {

	&iio_dev_attr_in_supply_raw.dev_attr.attr,

	&iio_const_attr_in_supply_scale.dev_attr.attr,

	&iio_dev_attr_in0_raw.dev_attr.attr,

	&iio_dev_attr_accel_x_raw.dev_attr.attr,

	&iio_dev_attr_accel_x_offset.dev_attr.attr,

	&iio_dev_attr_accel_x_peak_raw.dev_attr.attr,

	&iio_dev_attr_accel_y_raw.dev_attr.attr,

	&iio_dev_attr_accel_y_offset.dev_attr.attr,

	&iio_dev_attr_accel_y_peak_raw.dev_attr.attr,

	&iio_dev_attr_accel_z_raw.dev_attr.attr,

	&iio_dev_attr_accel_z_offset.dev_attr.attr,

	&iio_dev_attr_accel_z_peak_raw.dev_attr.attr,

	&iio_dev_attr_accel_xyz_squared_peak_raw.dev_attr.attr,

	&iio_dev_attr_temp_raw.dev_attr.attr,

	&iio_const_attr_temp_scale.dev_attr.attr,

	&iio_const_attr_available_sampling_frequency.dev_attr.attr,

	&iio_dev_attr_reset.dev_attr.attr,

	&iio_const_attr_name.dev_attr.attr,

	NULL

};



static const struct attribute_group adis16240_attribute_group = {

	.attrs = adis16240_attributes,

};



static int __devinit adis16240_probe(struct spi_device *spi)

{

	int ret, regdone = 0;

	struct adis16240_state *st = kzalloc(sizeof *st, GFP_KERNEL);

	if (!st) {

		ret =  -ENOMEM;

		goto error_ret;

	}

	/* this is only used for removal purposes */

	spi_set_drvdata(spi, st);



	/* Allocate the comms buffers */

	st->rx = kzalloc(sizeof(*st->rx)*ADIS16240_MAX_RX, GFP_KERNEL);

	if (st->rx == NULL) {

		ret = -ENOMEM;

		goto error_free_st;

	}

	st->tx = kzalloc(sizeof(*st->tx)*ADIS16240_MAX_TX, GFP_KERNEL);

	if (st->tx == NULL) {

		ret = -ENOMEM;

		goto error_free_rx;

	}

	st->us = spi;

	mutex_init(&st->buf_lock);

	/* setup the industrialio driver allocated elements */

	st->indio_dev = iio_allocate_device();

	if (st->indio_dev == NULL) {

		ret = -ENOMEM;

		goto error_free_tx;

	}



	st->indio_dev->dev.parent = &spi->dev;

	st->indio_dev->num_interrupt_lines = 1;

	st->indio_dev->event_attrs = &adis16240_event_attribute_group;

	st->indio_dev->attrs = &adis16240_attribute_group;

	st->indio_dev->dev_data = (void *)(st);

	st->indio_dev->driver_module = THIS_MODULE;

	st->indio_dev->modes = INDIO_DIRECT_MODE;



	ret = adis16240_configure_ring(st->indio_dev);

	if (ret)

		goto error_free_dev;



	ret = iio_device_register(st->indio_dev);

	if (ret)

		goto error_unreg_ring_funcs;

	regdone = 1;



	ret = adis16240_initialize_ring(st->indio_dev->ring);

	if (ret) {

		printk(KERN_ERR "failed to initialize the ring\n");

		goto error_unreg_ring_funcs;

	}



	if (spi->irq) {

		ret = iio_register_interrupt_line(spi->irq,

				st->indio_dev,

				0,

				IRQF_TRIGGER_RISING,

				"adis16240");

		if (ret)

			goto error_uninitialize_ring;



		ret = adis16240_probe_trigger(st->indio_dev);

		if (ret)

			goto error_unregister_line;

	}



	/* Get the device into a sane initial state */

	ret = adis16240_initial_setup(st);

	if (ret)

		goto error_remove_trigger;

	return 0;



error_remove_trigger:

	adis16240_remove_trigger(st->indio_dev);

error_unregister_line:

	if (spi->irq)

		iio_unregister_interrupt_line(st->indio_dev, 0);

error_uninitialize_ring:

	adis16240_uninitialize_ring(st->indio_dev->ring);

error_unreg_ring_funcs:

	adis16240_unconfigure_ring(st->indio_dev);

error_free_dev:

	if (regdone)

		iio_device_unregister(st->indio_dev);

	else

		iio_free_device(st->indio_dev);

error_free_tx:

	kfree(st->tx);

error_free_rx:

	kfree(st->rx);

error_free_st:

	kfree(st);

error_ret:

	return ret;

}



static int adis16240_remove(struct spi_device *spi)

{

	struct adis16240_state *st = spi_get_drvdata(spi);

	struct iio_dev *indio_dev = st->indio_dev;



	flush_scheduled_work();



	adis16240_remove_trigger(indio_dev);

	if (spi->irq)

		iio_unregister_interrupt_line(indio_dev, 0);



	adis16240_uninitialize_ring(indio_dev->ring);

	iio_device_unregister(indio_dev);

	adis16240_unconfigure_ring(indio_dev);

	kfree(st->tx);

	kfree(st->rx);

	kfree(st);



	return 0;

}



static struct spi_driver adis16240_driver = {

	.driver = {

		.name = "adis16240",

		.owner = THIS_MODULE,

	},

	.probe = adis16240_probe,

	.remove = __devexit_p(adis16240_remove),

};



static __init int adis16240_init(void)

{

	return spi_register_driver(&adis16240_driver);

}

module_init(adis16240_init);



static __exit void adis16240_exit(void)

{

	spi_unregister_driver(&adis16240_driver);

}

module_exit(adis16240_exit);



MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");

MODULE_DESCRIPTION("Analog Devices Programmable Impact Sensor and Recorder");

MODULE_LICENSE("GPL v2");

drivers/staging/iio/accel/adis16240_ring.c

0 → 100644
+254 −0

File added.

Preview size limit exceeded, changes collapsed.