Initial file dump from open source releaseHEADmaster

11 files changed, 2605 insertions, 0 deletions

diff --git a/drivers/iio/magnetometer/inv_compass/Kconfig b/drivers/iio/magnetometer/inv_compass/Kconfig
new file mode 100644
index 00000000..ea1ef709
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/Kconfig
@@ -0,0 +1,25 @@
+#
+# Kconfig for Invensense IIO compass drivers of 3rd party compass devices.
+#
+
+# Yamaha YAS530/YAS532/YAS533
+config INV_YAS53X_IIO
+    tristate "Invensense IIO driver for Yamaha YAS530/YAS532/YAS533 compass"
+    depends on I2C && SYSFS && IIO && IIO_KFIFO_BUF
+    default n
+    help
+      This driver supports the Yamaha YAS530/YAS532/YAS533. It is the Invensense
+      implementation of YAS53x series compass devices.
+      This driver can be built as a module. The module will be called
+      inv_yas53x_iio.
+
+# Aichi AMI306
+config INV_AMI306_IIO
+    tristate "Invensense IIO driver for Aichi AMI306 compass"
+    depends on I2C && SYSFS && IIO && IIO_KFIFO_BUF
+    default n
+    help
+      This driver supports the Aichi AMI306 compass. It is the Invensense 
+      IIO implementation for the AMI306 compass device. 
+      This driver can be built as a module. The module will be called
+      inv-ami306-iio.
diff --git a/drivers/iio/magnetometer/inv_compass/Makefile b/drivers/iio/magnetometer/inv_compass/Makefile
new file mode 100644
index 00000000..adc7dd93
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/Makefile
@@ -0,0 +1,25 @@
+#
+# Makefile for Invensense IIO compass drivers of 3rd party compass devices.
+#
+
+# Yamaha YAS530/YAS532/YAS533
+obj-$(CONFIG_INV_YAS53X_IIO) += inv_yas53x.o
+
+inv_yas53x-objs := inv_yas53x_core.o
+inv_yas53x-objs += inv_yas53x_ring.o
+inv_yas53x-objs += inv_yas53x_trigger.o
+
+CFLAGS_inv_yas53x_core.o    += -Idrivers/staging/iio
+CFLAGS_inv_yas53x_ring.o    += -Idrivers/staging/iio
+CFLAGS_inv_yas53x_trigger.o += -Idrivers/staging/iio
+
+# Aichi AMI306
+obj-$(CONFIG_INV_AMI306_IIO) += inv-ami306-iio.o
+
+inv-ami306-iio-objs := inv_ami306_core.o
+inv-ami306-iio-objs += inv_ami306_ring.o
+inv-ami306-iio-objs += inv_ami306_trigger.o
+
+CFLAGS_inv_ami306_core.o    += -Idrivers/staging/iio
+CFLAGS_inv_ami306_ring.o    += -Idrivers/staging/iio
+CFLAGS_inv_ami306_trigger.o += -Idrivers/staging/iio
diff --git a/drivers/iio/magnetometer/inv_compass/README b/drivers/iio/magnetometer/inv_compass/README
new file mode 100644
index 00000000..c5445e5b
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/README
@@ -0,0 +1,176 @@
+Kernel driver
+Author: Invensense <http://invensense.com>
+
+Table of Contents:
+==================
+- Description
+- Integrating the Driver in the Linux Kernel
+- Board and Platform Data
+    > Platform Data
+- Board File Modifications for compass
+    > AMI306
+    > YAS530/532/533
+- IIO Subsystem
+    > Communicating with the Driver in Userspace
+- Streaming Data to an Userspace Application
+- Test Applications
+    > Running Test Applications with AMI306 or YAS53x
+
+Description
+===========
+This document describes how to install the Invensense device driver for AMI306 
+and YAS53x series compass chip into a Linux kernel. The Invensense driver 
+currently supports the following sensors:
+- AMI306
+- YAS530
+- YAS532
+- YAS533
+
+Please refer to the appropriate product specification 
+document for further information regarding the slave address.
+
+The following files are included in this package:
+- Kconfig
+- Makefile
+- inv_ami306_core.c
+- inv_ami306_ring.c
+- inv_ami306_trigger.c
+- inv_ami306_iio.h
+- inv_yas53x_core.c
+- inv_yas53x_ring.c
+- inv_yas53x_trigger.c
+- inv_yas53x_iio.h
+
+Integrating the Driver in the Linux Kernel
+==========================================
+Please add the files as follows:
+- Add all above files to drivers/staging/iio/magnetometer/inv_compass
+(another directory is acceptable, but this is the recommended destination)
+
+In order to see the driver in menuconfig when building the kernel, please
+make modifications as shown below:
+
+    modify "drivers/staging/iio/magnetometer/Kconfig" with:
+    >> source "drivers/staging/iio/magnetometer/inv_compass/Kconfig"
+
+    modify "drivers/staging/iio/magnetometer/Makefile" with:
+    >> obj-y += inv_compass/
+
+
+Board and Platform Data
+=======================
+In order to recognize the Invensense device on the I2C bus, the board file must 
+be modified.
+The i2c_board_info instance must be defined as shown below. 
+
+Platform Data
+-------------
+The platform data (orientation matrix and secondary bus configurations) must be 
+modified as show below, according to your particular platform configuration. 
+
+Board File Modifications for Secondary I2C Configuration
+========================================================
+For the Panda Board, the board file can be found at 
+arch/arm/mach-omap2/board-omap4panda.c.
+Please modify the pertinent baord file in your system according to the examples 
+shown below:
+
+AMI306
+-------------------------------------------------
+static struct mpu_platform_data compass_data = {
+        .orientation = {   0,  0,  1,
+                           0,  1,  0,
+                           1,  0,  0 },
+};
+
+static struct i2c_board_info __initdata chip_board_info[] = {
+        {
+                I2C_BOARD_INFO("ami306", 0x0E),
+                .platform_data = &compass_data,
+        },
+};
+
+YAS53x(Use YAS532 as an example)
+-------------------------------------------------
+static struct mpu_platform_data compass_data = {
+        .orientation = {   0,  -1, 0,
+                           1,  0,  0,
+                           0,  0,  1 },
+};
+
+static struct i2c_board_info __initdata compass_board_info[] = {
+        {
+                I2C_BOARD_INFO("yas532", 0x2E),
+                .platform_data = &compass_data,
+        },
+};
+
+IIO subsystem
+=============
+A successful installation will create the following two new directories under 
+/sys/bus/iio/devices: 
+    - iio:device0
+    - trigger0
+
+Also, a new file, "iio:device0", will be created in the /dev/ diretory.
+(if you have more than one IIO device, the file will be named "iio:deviceX", 
+where X is a number)
+
+
+Communicating with the Driver in Userspace
+------------------------------------------
+The driver generates several files in sysfs upon installation. 
+These files are used to communicate with the driver. The files can be found 
+at /sys/bus/iio/devices/iio:device0 (or ../iio:deviceX as shown above).
+
+A brief description of the pertinent files for each Invensense device is shown 
+below:
+
+AMI306
+--------
+compass_matrix (read-only)
+--show the orientation matrix obtained from the board file.
+
+sampling_frequency(read and write)
+--show and change the sampling rate of the sensor.
+
+YAS53x
+---------------------
+YAS53x has all the attributes AMI306 has. It has one more additional attribute:
+
+overunderflow(read-only)
+--value 1 shows an overflow or underflow happens. Need to write into it to make
+  it zero.
+
+Streaming Data to an Userspace Application
+==========================================
+When streaming data to an userspace application, we recommend that you access
+compass data via /dev/iio:device0.
+
+Please follow the steps below to read data at a constant rate from the driver:
+
+1. Write the desired output rate to sampling_frequency.
+2. Write 1 to enable to turn on the event.
+3. Read /dev/iio:device0 to get a string of gyro/accel/compass data.
+4. Parse this string to obtain each compass element.
+
+Test Applications
+=================
+A test application is located under software/simple_apps/mpu_iio.
+This application is stand-alone in that it cannot be run concurrently with other
+entities trying to access the device node(s) or sysfs entries; in particular,
+the 
+
+Running Test Applications 
+---------------------------------------------------------
+To run test applications with AMI306 or YAS53x devices, 
+please use the following commands:
+
+1. for ami306:
+   mpu_iio -n ami306 -c 10 -l 3
+
+2. for yas532:
+   mpu_iio -n yas532 -c 10 -l 3
+
+Please use mpu_iio.c and iio_utils.h as example code for your development 
+purposes.
diff --git a/drivers/iio/magnetometer/inv_compass/inv_ami306_core.c b/drivers/iio/magnetometer/inv_compass/inv_ami306_core.c
new file mode 100644
index 00000000..612ba72b
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_ami306_core.c
@@ -0,0 +1,570 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup  DRIVERS
+ *  @brief       Hardware drivers.
+ *
+ *  @{
+ *      @file    inv_ami306_core.c
+ *      @brief   Invensense implementation for AMI306
+ *      @details This driver currently works for the AMI306
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+
+#include "inv_ami306_iio.h"
+#include "sysfs.h"
+#include "inv_test/inv_counters.h"
+
+static unsigned char late_initialize = true;
+
+s32 i2c_write(const struct i2c_client *client,
+		u8 command, u8 length, const u8 *values)
+{
+	INV_I2C_INC_COMPASSWRITE(3);
+	return i2c_smbus_write_i2c_block_data(client, command, length, values);
+}
+
+s32 i2c_read(const struct i2c_client *client,
+		u8 command, u8 length, u8 *values)
+{
+	INV_I2C_INC_COMPASSWRITE(3);
+	INV_I2C_INC_COMPASSREAD(length);
+	return i2c_smbus_read_i2c_block_data(client, command, length, values);
+}
+
+static int ami306_read_param(struct inv_ami306_state_s *st)
+{
+	int result = 0;
+	unsigned char regs[AMI_PARAM_LEN];
+	struct ami_sensor_parametor *param = &st->param;
+
+	result = i2c_read(st->i2c, REG_AMI_SENX,
+			AMI_PARAM_LEN, regs);
+	if (result < 0)
+		return result;
+
+	/* Little endian 16 bit registers */
+	param->m_gain.x = le16_to_cpup((__le16 *)(&regs[0]));
+	param->m_gain.y = le16_to_cpup((__le16 *)(&regs[2]));
+	param->m_gain.z = le16_to_cpup((__le16 *)(&regs[4]));
+
+	param->m_interference.xy = regs[7];
+	param->m_interference.xz = regs[6];
+	param->m_interference.yx = regs[9];
+	param->m_interference.yz = regs[8];
+	param->m_interference.zx = regs[11];
+	param->m_interference.zy = regs[10];
+
+	param->m_offset.x = AMI_STANDARD_OFFSET;
+	param->m_offset.y = AMI_STANDARD_OFFSET;
+	param->m_offset.z = AMI_STANDARD_OFFSET;
+
+	param->m_gain_cor.x = AMI_GAIN_COR_DEFAULT;
+	param->m_gain_cor.y = AMI_GAIN_COR_DEFAULT;
+	param->m_gain_cor.z = AMI_GAIN_COR_DEFAULT;
+
+	return 0;
+}
+
+static int ami306_write_offset(const struct i2c_client *client,
+				unsigned char *fine)
+{
+	int result = 0;
+	unsigned char dat[3];
+	dat[0] = (0x7f & fine[0]);
+	dat[1] = 0;
+	result = i2c_write(client, REG_AMI_OFFX, 2, dat);
+	dat[0] = (0x7f & fine[1]);
+	dat[1] = 0;
+	result = i2c_write(client, REG_AMI_OFFY, 2, dat);
+	dat[0] = (0x7f & fine[2]);
+	dat[1] = 0;
+	result = i2c_write(client, REG_AMI_OFFZ, 2, dat);
+
+	return result;
+}
+
+static int ami306_wait_data_ready(struct inv_ami306_state_s *st,
+				unsigned long usecs, unsigned long times)
+{
+	int result = 0;
+	unsigned char buf;
+
+	for (; 0 < times; --times) {
+		udelay(usecs);
+		result = i2c_read(st->i2c, REG_AMI_STA1, 1, &buf);
+		if (result < 0)
+			return INV_ERROR_COMPASS_DATA_NOT_READY;
+		if (buf & AMI_STA1_DRDY_BIT)
+			return 0;
+		else if (buf & AMI_STA1_DOR_BIT)
+			return INV_ERROR_COMPASS_DATA_OVERFLOW;
+	}
+
+	return INV_ERROR_COMPASS_DATA_NOT_READY;
+}
+int ami306_read_raw_data(struct inv_ami306_state_s *st,
+			short dat[3])
+{
+	int result;
+	unsigned char buf[6];
+	result = i2c_read(st->i2c, REG_AMI_DATAX, sizeof(buf), buf);
+	if (result < 0)
+		return result;
+	dat[0] = le16_to_cpup((__le16 *)(&buf[0]));
+	dat[1] = le16_to_cpup((__le16 *)(&buf[2]));
+	dat[2] = le16_to_cpup((__le16 *)(&buf[4]));
+
+	return 0;
+}
+
+#define AMI_WAIT_DATAREADY_RETRY                3       /* retry times */
+#define AMI_DRDYWAIT                            800     /* u(micro) sec */
+static int ami306_force_measurement(struct inv_ami306_state_s *st,
+					short ver[3])
+{
+	int result;
+	int status;
+	char buf;
+	buf = AMI_CTRL3_FORCE_BIT;
+	result = i2c_write(st->i2c, REG_AMI_CTRL3, 1, &buf);
+	if (result < 0)
+		return result;
+
+	result = ami306_wait_data_ready(st,
+			AMI_DRDYWAIT, AMI_WAIT_DATAREADY_RETRY);
+	if (result && result != INV_ERROR_COMPASS_DATA_OVERFLOW)
+		return result;
+	/*  READ DATA X,Y,Z */
+	status = ami306_read_raw_data(st, ver);
+	if (status)
+		return status;
+
+	return result;
+}
+
+static int ami306_initial_b0_adjust(struct inv_ami306_state_s *st)
+{
+	int result;
+	unsigned char fine[3] = { 0 };
+	short data[3];
+	int diff[3] = { 0x7fff, 0x7fff, 0x7fff };
+	int fn = 0;
+	int ax = 0;
+	unsigned char buf[3];
+
+	buf[0] = AMI_CTRL2_DREN;
+	result = i2c_write(st->i2c, REG_AMI_CTRL2, 1, buf);
+	if (result)
+		return result;
+
+	buf[0] = AMI_CTRL4_HS & 0xFF;
+	buf[1] = (AMI_CTRL4_HS >> 8) & 0xFF;
+	result = i2c_write(st->i2c, REG_AMI_CTRL4, 2, buf);
+	if (result < 0)
+		return result;
+
+	for (fn = 0; fn < AMI_FINE_MAX; ++fn) { /* fine 0 -> 95 */
+		fine[0] = fine[1] = fine[2] = fn;
+		result = ami306_write_offset(st->i2c, fine);
+		if (result)
+			return result;
+
+		result = ami306_force_measurement(st, data);
+		if (result)
+			return result;
+
+		for (ax = 0; ax < 3; ax++) {
+			/* search point most close to zero. */
+			if (diff[ax] > abs(data[ax])) {
+				st->fine[ax] = fn;
+				diff[ax] = abs(data[ax]);
+			}
+		}
+	}
+	result = ami306_write_offset(st->i2c, st->fine);
+	if (result)
+		return result;
+
+	/* Software Reset */
+	buf[0] = AMI_CTRL3_SRST_BIT;
+	result = i2c_write(st->i2c, REG_AMI_CTRL3, 1, buf);
+	if (result < 0)
+		return result;
+	else
+		return 0;
+}
+
+static int ami306_start_sensor(struct inv_ami306_state_s *st)
+{
+	int result = 0;
+	unsigned char buf[2];
+
+	/* Step 1 */
+	buf[0] = (AMI_CTRL1_PC1 | AMI_CTRL1_FS1_FORCE);
+	result = i2c_write(st->i2c, REG_AMI_CTRL1, 1, buf);
+	if (result < 0)
+		return result;
+	/* Step 2 */
+	buf[0] = AMI_CTRL2_DREN;
+	result = i2c_write(st->i2c, REG_AMI_CTRL2, 1, buf);
+	if (result < 0)
+		return result;
+	/* Step 3 */
+	buf[0] = (AMI_CTRL4_HS & 0xFF);
+	buf[1] = (AMI_CTRL4_HS >> 8) & 0xFF;
+
+	result = i2c_write(st->i2c, REG_AMI_CTRL4, 2, buf);
+	if (result < 0)
+		return result;
+
+	/* Step 4 */
+	result = ami306_write_offset(st->i2c, st->fine);
+
+	return result;
+}
+
+int set_ami306_enable(struct iio_dev *indio_dev, int state)
+{
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+	int result;
+	char buf;
+
+	buf = (AMI_CTRL1_PC1 | AMI_CTRL1_FS1_FORCE);
+	result = i2c_write(st->i2c, REG_AMI_CTRL1, 1, &buf);
+	if (result < 0)
+		return result;
+
+	result =  ami306_read_param(st);
+	if (result)
+		return result;
+	if (late_initialize) {
+		result = ami306_initial_b0_adjust(st);
+		if (result)
+			return result;
+		late_initialize = false;
+	}
+	result = ami306_start_sensor(st);
+	if (result)
+		return result;
+	buf = AMI_CTRL3_FORCE_BIT;
+	st->timestamp = iio_get_time_ns();
+	result = i2c_write(st->i2c, REG_AMI_CTRL3, 1, &buf);
+	if (result)
+		return result;
+
+	return 0;
+}
+
+/**
+ *  ami306_read_raw() - read raw method.
+ */
+static int ami306_read_raw(struct iio_dev *indio_dev,
+			      struct iio_chan_spec const *chan,
+			      int *val,
+			      int *val2,
+			      long mask) {
+	struct inv_ami306_state_s  *st = iio_priv(indio_dev);
+
+	switch (mask) {
+	case 0:
+		if (!(iio_buffer_enabled(indio_dev)))
+			return -EINVAL;
+		if (chan->type == IIO_MAGN) {
+			*val = st->compass_data[chan->channel2 - IIO_MOD_X];
+			return IIO_VAL_INT;
+		}
+
+		return -EINVAL;
+	case IIO_CHAN_INFO_SCALE:
+		if (chan->type == IIO_MAGN) {
+			*val = AMI_SCALE;
+			return IIO_VAL_INT;
+		}
+		return -EINVAL;
+	default:
+		return -EINVAL;
+	}
+}
+
+/**
+ * inv_compass_matrix_show() - show orientation matrix
+ */
+static ssize_t inv_compass_matrix_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	signed char *m;
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+	m = st->plat_data.orientation;
+	return sprintf(buf,
+	"%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
+		m[0],  m[1],  m[2],  m[3], m[4], m[5], m[6], m[7], m[8]);
+}
+
+static ssize_t ami306_rate_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	unsigned long data;
+	int error;
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+
+	error = kstrtoul(buf, 10, &data);
+	if (error)
+		return error;
+	if (0 == data)
+		return -EINVAL;
+	/* transform rate to delay in ms */
+	data = 1000 / data;
+	if (data > AMI_MAX_DELAY)
+		data = AMI_MAX_DELAY;
+	if (data < AMI_MIN_DELAY)
+		data = AMI_MIN_DELAY;
+	st->delay = data;
+	return count;
+}
+
+static ssize_t ami306_rate_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+	/* transform delay in ms to rate */
+	return sprintf(buf, "%d\n", 1000 / st->delay);
+}
+
+
+static void ami306_work_func(struct work_struct *work)
+{
+	struct inv_ami306_state_s *st =
+		container_of((struct delayed_work *)work,
+			struct inv_ami306_state_s, work);
+	struct iio_dev *indio_dev = iio_priv_to_dev(st);
+	unsigned long delay = msecs_to_jiffies(st->delay);
+
+	mutex_lock(&indio_dev->mlock);
+	if (!(iio_buffer_enabled(indio_dev)))
+		goto error_ret;
+
+	st->timestamp = iio_get_time_ns();
+	schedule_delayed_work(&st->work, delay);
+	inv_read_ami306_fifo(indio_dev);
+	INV_I2C_INC_COMPASSIRQ();
+
+error_ret:
+	mutex_unlock(&indio_dev->mlock);
+}
+
+static const struct iio_chan_spec compass_channels[] = {
+	{
+		.type = IIO_MAGN,
+		.modified = 1,
+		.channel2 = IIO_MOD_X,
+		.info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT,
+		.scan_index = INV_AMI306_SCAN_MAGN_X,
+		.scan_type = IIO_ST('s', 16, 16, 0)
+	}, {
+		.type = IIO_MAGN,
+		.modified = 1,
+		.channel2 = IIO_MOD_Y,
+		.info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT,
+		.scan_index = INV_AMI306_SCAN_MAGN_Y,
+		.scan_type = IIO_ST('s', 16, 16, 0)
+	}, {
+		.type = IIO_MAGN,
+		.modified = 1,
+		.channel2 = IIO_MOD_Z,
+		.info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT,
+		.scan_index = INV_AMI306_SCAN_MAGN_Z,
+		.scan_type = IIO_ST('s', 16, 16, 0)
+	},
+	IIO_CHAN_SOFT_TIMESTAMP(INV_AMI306_SCAN_TIMESTAMP)
+};
+
+static DEVICE_ATTR(compass_matrix, S_IRUGO, inv_compass_matrix_show, NULL);
+static DEVICE_ATTR(sampling_frequency, S_IRUGO | S_IWUSR, ami306_rate_show,
+		ami306_rate_store);
+
+static struct attribute *inv_ami306_attributes[] = {
+	&dev_attr_compass_matrix.attr,
+	&dev_attr_sampling_frequency.attr,
+	NULL,
+};
+static const struct attribute_group inv_attribute_group = {
+	.name = "ami306",
+	.attrs = inv_ami306_attributes
+};
+
+static const struct iio_info ami306_info = {
+	.driver_module = THIS_MODULE,
+	.read_raw = &ami306_read_raw,
+	.attrs = &inv_attribute_group,
+};
+
+/*constant IIO attribute */
+/**
+ *  inv_ami306_probe() - probe function.
+ */
+static int inv_ami306_probe(struct i2c_client *client,
+	const struct i2c_device_id *id)
+{
+	struct inv_ami306_state_s *st;
+	struct iio_dev *indio_dev;
+	int result;
+	char data;
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		result = -ENODEV;
+		goto out_no_free;
+	}
+	indio_dev = iio_allocate_device(sizeof(*st));
+	if (indio_dev == NULL) {
+		result =  -ENOMEM;
+		goto out_no_free;
+	}
+	st = iio_priv(indio_dev);
+	st->i2c = client;
+	st->plat_data =
+		*(struct mpu_platform_data *)dev_get_platdata(&client->dev);
+	st->delay = 10;
+
+	/* Make state variables available to all _show and _store functions. */
+	i2c_set_clientdata(client, indio_dev);
+	result = i2c_read(st->i2c, REG_AMI_WIA, 1, &data);
+	if (result < 0)
+		goto out_free;
+	if (data != DATA_WIA)
+		goto out_free;
+
+	indio_dev->dev.parent = &client->dev;
+	indio_dev->name = id->name;
+	indio_dev->channels = compass_channels;
+	indio_dev->num_channels = ARRAY_SIZE(compass_channels);
+	indio_dev->info = &ami306_info;
+	indio_dev->modes = INDIO_DIRECT_MODE;
+	indio_dev->currentmode = INDIO_DIRECT_MODE;
+
+	result = inv_ami306_configure_ring(indio_dev);
+	if (result)
+		goto out_free;
+	result = iio_buffer_register(indio_dev, indio_dev->channels,
+					indio_dev->num_channels);
+	if (result)
+		goto out_unreg_ring;
+	result = inv_ami306_probe_trigger(indio_dev);
+	if (result)
+		goto out_remove_ring;
+
+	result = iio_device_register(indio_dev);
+	if (result)
+		goto out_remove_trigger;
+	INIT_DELAYED_WORK(&st->work, ami306_work_func);
+	pr_info("%s: Probe name %s\n", __func__, id->name);
+	return 0;
+out_remove_trigger:
+	if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
+		inv_ami306_remove_trigger(indio_dev);
+out_remove_ring:
+	iio_buffer_unregister(indio_dev);
+out_unreg_ring:
+	inv_ami306_unconfigure_ring(indio_dev);
+out_free:
+	iio_free_device(indio_dev);
+out_no_free:
+	dev_err(&client->adapter->dev, "%s failed %d\n", __func__, result);
+	return -EIO;
+}
+
+/**
+ *  inv_ami306_remove() - remove function.
+ */
+static int inv_ami306_remove(struct i2c_client *client)
+{
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+	cancel_delayed_work_sync(&st->work);
+	iio_device_unregister(indio_dev);
+	inv_ami306_remove_trigger(indio_dev);
+	iio_buffer_unregister(indio_dev);
+	inv_ami306_unconfigure_ring(indio_dev);
+	iio_free_device(indio_dev);
+
+	dev_info(&client->adapter->dev, "inv-ami306-iio module removed.\n");
+	return 0;
+}
+static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
+/* device id table is used to identify what device can be
+ * supported by this driver
+ */
+static const struct i2c_device_id inv_ami306_id[] = {
+	{"ami306", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, inv_ami306_id);
+
+static struct i2c_driver inv_ami306_driver = {
+	.class = I2C_CLASS_HWMON,
+	.probe		=	inv_ami306_probe,
+	.remove		=	inv_ami306_remove,
+	.id_table	=	inv_ami306_id,
+	.driver = {
+		.owner	=	THIS_MODULE,
+		.name	=	"inv-ami306-iio",
+	},
+	.address_list = normal_i2c,
+};
+
+static int __init inv_ami306_init(void)
+{
+	int result = i2c_add_driver(&inv_ami306_driver);
+	if (result) {
+		pr_err("%s failed\n", __func__);
+		return result;
+	}
+	return 0;
+}
+
+static void __exit inv_ami306_exit(void)
+{
+	i2c_del_driver(&inv_ami306_driver);
+}
+
+module_init(inv_ami306_init);
+module_exit(inv_ami306_exit);
+
+MODULE_AUTHOR("Invensense Corporation");
+MODULE_DESCRIPTION("Invensense device driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("inv-ami306-iio");
+/**
+ *  @}
+ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_ami306_iio.h b/drivers/iio/magnetometer/inv_compass/inv_ami306_iio.h
new file mode 100644
index 00000000..fa4f4ee1
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_ami306_iio.h
@@ -0,0 +1,159 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup DRIVERS
+ *  @brief      Hardware drivers.
+ *
+ *  @{
+ *      @file  inv_ami306_iio.h
+ *      @brief Struct definitions for the Invensense implementation
+ *              of ami306 driver.
+ */
+
+#ifndef _INV_GYRO_H_
+#define _INV_GYRO_H_
+
+#include <linux/i2c.h>
+#include <linux/kfifo.h>
+#include <linux/miscdevice.h>
+#include <linux/input.h>
+#include <linux/spinlock.h>
+#include <linux/mpu.h>
+
+#include "iio.h"
+#include "buffer.h"
+#include "trigger.h"
+
+/** axis sensitivity(gain) calibration parameter information  */
+struct ami_vector3d {
+	signed short x;                 /**< X-axis  */
+	signed short y;                 /**< Y-axis  */
+	signed short z;                 /**< Z-axis  */
+};
+
+/** axis interference information  */
+struct ami_interference {
+	/**< Y-axis magnetic field for X-axis correction value  */
+	signed short xy;
+	/**< Z-axis magnetic field for X-axis correction value  */
+	signed short xz;
+	/**< X-axis magnetic field for Y-axis correction value  */
+	signed short yx;
+	/**< Z-axis magnetic field for Y-axis correction value  */
+	signed short yz;
+	/**< X-axis magnetic field for Z-axis correction value  */
+	signed short zx;
+	/**< Y-axis magnetic field for Z-axis correction value  */
+	signed short zy;
+};
+
+/** sensor calibration Parameter information  */
+struct ami_sensor_parametor {
+	/**< geomagnetic field sensor gain  */
+	struct ami_vector3d m_gain;
+	/**< geomagnetic field sensor gain correction parameter  */
+	struct ami_vector3d m_gain_cor;
+	/**< geomagnetic field sensor offset  */
+	struct ami_vector3d m_offset;
+	/**< geomagnetic field sensor axis interference parameter */
+	struct ami_interference m_interference;
+};
+
+/**
+ *  struct inv_ami306_state_s - Driver state variables.
+ *  @plat_data:         board file platform data.
+ *  @i2c:		i2c client handle.
+ *  @trig:              not used. for compatibility.
+ *  @param:             ami specific sensor data.
+ *  @work:              work data structure.
+ *  @delay:             delay between each scheduled work.
+ *  @fine:               fine tunign parameters.
+ *  @compass_data:      compass data store.
+ *  @timestamp:         time stamp.
+ */
+struct inv_ami306_state_s {
+	struct mpu_platform_data plat_data;
+	struct i2c_client *i2c;
+	struct iio_trigger  *trig;
+	struct ami_sensor_parametor param;
+	struct delayed_work work;
+	int delay;
+	s8 fine[3];
+	short compass_data[3];
+	s64 timestamp;
+};
+/* scan element definition */
+enum inv_mpu_scan {
+	INV_AMI306_SCAN_MAGN_X,
+	INV_AMI306_SCAN_MAGN_Y,
+	INV_AMI306_SCAN_MAGN_Z,
+	INV_AMI306_SCAN_TIMESTAMP,
+};
+
+#define REG_AMI_WIA                     0x0f
+#define REG_AMI_DATAX                   0x10
+#define REG_AMI_STA1                    0x18
+#define REG_AMI_CTRL1                   0x1b
+#define REG_AMI_CTRL2                   0x1c
+#define REG_AMI_CTRL3                   0x1d
+#define REG_AMI_B0X                     0x20
+#define REG_AMI_B0Y                     0x22
+#define REG_AMI_B0Z                     0x24
+#define REG_AMI_CTRL5                   0x40
+#define REG_AMI_CTRL4                   0x5c
+#define REG_AMI_TEMP                    0x60
+#define REG_AMI_SENX                    0x96
+#define REG_AMI_OFFX                    0x6c
+#define REG_AMI_OFFY                    0x72
+#define REG_AMI_OFFZ                    0x78
+
+
+#define DATA_WIA                        0x46
+#define AMI_CTRL1_PC1                   0x80
+#define AMI_CTRL1_FS1_FORCE             0x02
+#define AMI_CTRL1_ODR1                  0x10
+#define AMI_CTRL2_DREN                  0x08
+#define AMI_CTRL2_DRP                   0x04
+#define AMI_CTRL3_FORCE_BIT             0x40
+#define AMI_CTRL3_B0_LO_BIT             0x10
+#define AMI_CTRL3_SRST_BIT              0x80
+#define AMI_CTRL4_HS                    0xa07e
+#define AMI_CTRL4_AB                    0x0001
+#define AMI_STA1_DRDY_BIT               0x40
+#define AMI_STA1_DOR_BIT                0x20
+
+#define AMI_PARAM_LEN                   12
+#define AMI_STANDARD_OFFSET             0x800
+#define AMI_GAIN_COR_DEFAULT            1000
+#define AMI_FINE_MAX			96
+#define AMI_MAX_DELAY                   1000
+#define AMI_MIN_DELAY                   10
+#define AMI_SCALE                       (5461 * (1<<15))
+
+#define INV_ERROR_COMPASS_DATA_OVERFLOW  (-1)
+#define INV_ERROR_COMPASS_DATA_NOT_READY (-2)
+
+
+int inv_ami306_configure_ring(struct iio_dev *indio_dev);
+void inv_ami306_unconfigure_ring(struct iio_dev *indio_dev);
+int inv_ami306_probe_trigger(struct iio_dev *indio_dev);
+void inv_ami306_remove_trigger(struct iio_dev *indio_dev);
+int set_ami306_enable(struct iio_dev *indio_dev, int state);
+int ami306_read_raw_data(struct inv_ami306_state_s *st,
+				short dat[3]);
+int inv_read_ami306_fifo(struct iio_dev *indio_dev);
+
+#endif  /* #ifndef _INV_GYRO_H_ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_ami306_ring.c b/drivers/iio/magnetometer/inv_compass/inv_ami306_ring.c
new file mode 100644
index 00000000..ed91cf49
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_ami306_ring.c
@@ -0,0 +1,163 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup  DRIVERS
+ *  @brief       Hardware drivers.
+ *
+ *  @{
+ *      @file    inv_ami306_ring.c
+ *      @brief   Invensense implementation for AMI306
+ *      @details This driver currently works for the AMI306
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+
+#include "iio.h"
+#include "kfifo_buf.h"
+#include "trigger_consumer.h"
+#include "sysfs.h"
+
+#include "inv_ami306_iio.h"
+
+static int put_scan_to_buf(struct iio_dev *indio_dev, unsigned char *d,
+				short *s, int scan_index) {
+	struct iio_buffer *ring = indio_dev->buffer;
+	int st;
+	int i, d_ind;
+	d_ind = 0;
+	for (i = 0; i < 3; i++) {
+		st = iio_scan_mask_query(indio_dev, ring, scan_index + i);
+		if (st) {
+			memcpy(&d[d_ind], &s[i], sizeof(s[i]));
+			d_ind += sizeof(s[i]);
+		}
+	}
+	return d_ind;
+}
+
+/**
+ *  inv_read_fifo() - Transfer data from FIFO to ring buffer.
+ */
+int inv_read_ami306_fifo(struct iio_dev *indio_dev)
+{
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+	struct iio_buffer *ring = indio_dev->buffer;
+	int result, status, d_ind;
+	char b;
+	char *tmp;
+	s64 tmp_buf[2];
+
+	result = i2c_smbus_read_i2c_block_data(st->i2c, REG_AMI_STA1, 1, &b);
+	if (result < 0)
+		goto end_session;
+	if (b & AMI_STA1_DRDY_BIT) {
+		status = ami306_read_raw_data(st, st->compass_data);
+		if (status) {
+			pr_err("error reading raw\n");
+			goto end_session;
+		}
+		tmp = (unsigned char *)tmp_buf;
+		d_ind = put_scan_to_buf(indio_dev, tmp, st->compass_data,
+						INV_AMI306_SCAN_MAGN_X);
+		if (ring->scan_timestamp)
+			tmp_buf[(d_ind + 7)/8] = st->timestamp;
+		ring->access->store_to(indio_dev->buffer, tmp, st->timestamp);
+	} else if (b & AMI_STA1_DOR_BIT)
+		pr_err("not ready\n");
+end_session:
+	b = AMI_CTRL3_FORCE_BIT;
+	result = i2c_smbus_write_i2c_block_data(st->i2c, REG_AMI_CTRL3, 1, &b);
+
+	return IRQ_HANDLED;
+}
+
+void inv_ami306_unconfigure_ring(struct iio_dev *indio_dev)
+{
+	iio_kfifo_free(indio_dev->buffer);
+};
+static int inv_ami306_postenable(struct iio_dev *indio_dev)
+{
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+	struct iio_buffer *ring = indio_dev->buffer;
+	int result;
+
+	/* when all the outputs are disabled, even though buffer/enable is on,
+	   do nothing */
+	if (!(iio_scan_mask_query(indio_dev, ring, INV_AMI306_SCAN_MAGN_X) ||
+	    iio_scan_mask_query(indio_dev, ring, INV_AMI306_SCAN_MAGN_Y) ||
+	    iio_scan_mask_query(indio_dev, ring, INV_AMI306_SCAN_MAGN_Z)))
+		return 0;
+
+	result = set_ami306_enable(indio_dev, true);
+	if (result)
+		return result;
+	schedule_delayed_work(&st->work, msecs_to_jiffies(st->delay));
+
+	return 0;
+}
+
+static int inv_ami306_predisable(struct iio_dev *indio_dev)
+{
+	struct iio_buffer *ring = indio_dev->buffer;
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+
+	cancel_delayed_work_sync(&st->work);
+	clear_bit(INV_AMI306_SCAN_MAGN_X, ring->scan_mask);
+	clear_bit(INV_AMI306_SCAN_MAGN_Y, ring->scan_mask);
+	clear_bit(INV_AMI306_SCAN_MAGN_Z, ring->scan_mask);
+
+	return 0;
+}
+
+static const struct iio_buffer_setup_ops inv_ami306_ring_setup_ops = {
+	.preenable = &iio_sw_buffer_preenable,
+	.postenable = &inv_ami306_postenable,
+	.predisable = &inv_ami306_predisable,
+};
+
+int inv_ami306_configure_ring(struct iio_dev *indio_dev)
+{
+	int ret = 0;
+	struct iio_buffer *ring;
+
+	ring = iio_kfifo_allocate(indio_dev);
+	if (!ring) {
+		ret = -ENOMEM;
+		return ret;
+	}
+	indio_dev->buffer = ring;
+	/* setup ring buffer */
+	ring->scan_timestamp = true;
+	indio_dev->setup_ops = &inv_ami306_ring_setup_ops;
+
+	indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
+	return 0;
+}
+/**
+ *  @}
+ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_ami306_trigger.c b/drivers/iio/magnetometer/inv_compass/inv_ami306_trigger.c
new file mode 100644
index 00000000..f7fe59ef
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_ami306_trigger.c
@@ -0,0 +1,90 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup  DRIVERS
+ *  @brief       Hardware drivers.
+ *
+ *  @{
+ *      @file    inv_ami306_trigger.c
+ *      @brief   Invensense implementation for AMI306
+ *      @details This driver currently works for the AMI306
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+
+#include "iio.h"
+#include "sysfs.h"
+#include "trigger.h"
+#include "inv_ami306_iio.h"
+
+static const struct iio_trigger_ops inv_ami306_trigger_ops = {
+	.owner = THIS_MODULE,
+};
+
+int inv_ami306_probe_trigger(struct iio_dev *indio_dev)
+{
+	int ret;
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+
+	st->trig = iio_allocate_trigger("%s-dev%d",
+					indio_dev->name,
+					indio_dev->id);
+	if (st->trig == NULL) {
+		ret = -ENOMEM;
+		goto error_ret;
+	}
+	/* select default trigger */
+	st->trig->dev.parent = &st->i2c->dev;
+	st->trig->private_data = indio_dev;
+	st->trig->ops = &inv_ami306_trigger_ops;
+	ret = iio_trigger_register(st->trig);
+
+	/* select default trigger */
+	indio_dev->trig = st->trig;
+	if (ret)
+		goto error_free_trig;
+
+	return 0;
+
+error_free_trig:
+	iio_free_trigger(st->trig);
+error_ret:
+	return ret;
+}
+
+void inv_ami306_remove_trigger(struct iio_dev *indio_dev)
+{
+	struct inv_ami306_state_s *st = iio_priv(indio_dev);
+
+	iio_trigger_unregister(st->trig);
+	iio_free_trigger(st->trig);
+}
+/**
+ *  @}
+ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_yas53x_core.c b/drivers/iio/magnetometer/inv_compass/inv_yas53x_core.c
new file mode 100644
index 00000000..6af420bb
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_yas53x_core.c
@@ -0,0 +1,969 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup  DRIVERS
+ *  @brief       Hardware drivers.
+ *
+ *  @{
+ *      @file    inv_yas53x_core.c
+ *      @brief   Invensense implementation for yas530/yas532/yas533.
+ *      @details This driver currently works for yas530/yas532/yas533.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+
+#include "inv_yas53x_iio.h"
+#include "sysfs.h"
+#include "inv_test/inv_counters.h"
+
+/* -------------------------------------------------------------------------- */
+static int Cx, Cy1, Cy2;
+static int /*a1, */ a2, a3, a4, a5, a6, a7, a8, a9;
+static int k;
+
+static u8 dx, dy1, dy2;
+static u8 d2, d3, d4, d5, d6, d7, d8, d9, d0;
+static u8 dck, ver;
+
+/**
+ *  inv_serial_read() - Read one or more bytes from the device registers.
+ *  @st:	Device driver instance.
+ *  @reg:	First device register to be read from.
+ *  @length:	Number of bytes to read.
+ *  @data:	Data read from device.
+ *  NOTE: The slave register will not increment when reading from the FIFO.
+ */
+int inv_serial_read(struct inv_compass_state *st, u8 reg, u16 length, u8 *data)
+{
+	int result;
+	INV_I2C_INC_COMPASSWRITE(3);
+	INV_I2C_INC_COMPASSREAD(length);
+	result = i2c_smbus_read_i2c_block_data(st->client, reg, length, data);
+	if (result != length) {
+		if (result < 0)
+			return result;
+		else
+			return -EINVAL;
+	} else {
+		return 0;
+	}
+}
+
+/**
+ *  inv_serial_single_write() - Write a byte to a device register.
+ *  @st:	Device driver instance.
+ *  @reg:	Device register to be written to.
+ *  @data:	Byte to write to device.
+ */
+int inv_serial_single_write(struct inv_compass_state *st, u8 reg, u8 data)
+{
+	u8 d[1];
+	d[0] = data;
+	INV_I2C_INC_COMPASSWRITE(3);
+
+	return i2c_smbus_write_i2c_block_data(st->client, reg, 1, d);
+}
+
+static int set_hardware_offset(struct inv_compass_state *st,
+			       char offset_x, char offset_y1, char offset_y2)
+{
+	char data;
+	int result = 0;
+
+	data = offset_x & 0x3f;
+	result = inv_serial_single_write(st, YAS530_REGADDR_OFFSET_X, data);
+	if (result)
+		return result;
+
+	data = offset_y1 & 0x3f;
+	result = inv_serial_single_write(st, YAS530_REGADDR_OFFSET_Y1, data);
+	if (result)
+		return result;
+
+	data = offset_y2 & 0x3f;
+	result = inv_serial_single_write(st, YAS530_REGADDR_OFFSET_Y2, data);
+	return result;
+}
+
+static int set_measure_command(struct inv_compass_state *st)
+{
+	int result = 0;
+	result = inv_serial_single_write(st,
+					 YAS530_REGADDR_MEASURE_COMMAND, 0x01);
+	return result;
+}
+
+static int measure_normal(struct inv_compass_state *st,
+			  int *busy, unsigned short *t,
+			  unsigned short *x, unsigned short *y1,
+			  unsigned short *y2)
+{
+	int result;
+	ktime_t sleeptime;
+	result = set_measure_command(st);
+	sleeptime = ktime_set(0, 2 * NSEC_PER_MSEC);
+	set_current_state(TASK_UNINTERRUPTIBLE);
+	schedule_hrtimeout(&sleeptime, HRTIMER_MODE_REL);
+
+	result = st->read_data(st, busy, t, x, y1, y2);
+
+	return result;
+}
+
+static int measure_int(struct inv_compass_state *st,
+			  int *busy, unsigned short *t,
+			  unsigned short *x, unsigned short *y1,
+			  unsigned short *y2)
+{
+	int result;
+	if (st->first_read_after_reset) {
+		st->first_read_after_reset = 0;
+		result = 1;
+	} else {
+		result = st->read_data(st, busy, t, x, y1, y2);
+	}
+	result |= set_measure_command(st);
+
+	return result;
+}
+
+static int yas530_read_data(struct inv_compass_state *st,
+			  int *busy, u16 *t, u16 *x, u16 *y1, u16 *y2)
+{
+	u8 data[8];
+	u16 b, to, xo, y1o, y2o;
+	int result;
+
+	result = inv_serial_read(st,
+				 YAS530_REGADDR_MEASURE_DATA, 8, data);
+	if (result)
+		return result;
+
+	b = (data[0] >> 7) & 0x01;
+	to = (s16)(((data[0] << 2) & 0x1fc) | ((data[1] >> 6) & 0x03));
+	xo = (s16)(((data[2] << 5) & 0xfe0) | ((data[3] >> 3) & 0x1f));
+	y1o = (s16)(((data[4] << 5) & 0xfe0) | ((data[5] >> 3) & 0x1f));
+	y2o = (s16)(((data[6] << 5) & 0xfe0) | ((data[7] >> 3) & 0x1f));
+
+	*busy = b;
+	*t = to;
+	*x = xo;
+	*y1 = y1o;
+	*y2 = y2o;
+
+	return 0;
+}
+
+static int yas532_533_read_data(struct inv_compass_state *st,
+			  int *busy, u16 *t, u16 *x, u16 *y1, u16 *y2)
+{
+	u8 data[8];
+	u16 b, to, xo, y1o, y2o;
+	int result;
+
+	result = inv_serial_read(st,
+				 YAS530_REGADDR_MEASURE_DATA, 8, data);
+	if (result)
+		return result;
+
+	b = (data[0] >> 7) & 0x01;
+	to = (s16)((((s32)data[0] << 3) & 0x3f8) | ((data[1] >> 5) & 0x07));
+	xo = (s16)((((s32)data[2] << 6) & 0x1fc0) | ((data[3] >> 2) & 0x3f));
+	y1o = (s16)((((s32)data[4] << 6) & 0x1fc0) | ((data[5] >> 2) & 0x3f));
+	y2o = (s16)((((s32)data[6] << 6) & 0x1fc0) | ((data[7] >> 2) & 0x3f));
+
+	*busy = b;
+	*t = to;
+	*x = xo;
+	*y1 = y1o;
+	*y2 = y2o;
+
+	return 0;
+}
+
+static int check_offset(struct inv_compass_state *st,
+			char offset_x, char offset_y1, char offset_y2,
+			int *flag_x, int *flag_y1, int *flag_y2)
+{
+	int result;
+	int busy;
+	short t, x, y1, y2;
+
+	result = set_hardware_offset(st, offset_x, offset_y1, offset_y2);
+	if (result)
+		return result;
+	result = measure_normal(st, &busy, &t, &x, &y1, &y2);
+	if (result)
+		return result;
+	*flag_x = 0;
+	*flag_y1 = 0;
+	*flag_y2 = 0;
+
+	if (x > st->center)
+		*flag_x = 1;
+	if (y1 > st->center)
+		*flag_y1 = 1;
+	if (y2 > st->center)
+		*flag_y2 = 1;
+	if (x < st->center)
+		*flag_x = -1;
+	if (y1 < st->center)
+		*flag_y1 = -1;
+	if (y2 < st->center)
+		*flag_y2 = -1;
+
+	return result;
+}
+
+static int measure_and_set_offset(struct inv_compass_state *st,
+				  char *offset)
+{
+	int i;
+	int result = 0;
+	char offset_x = 0, offset_y1 = 0, offset_y2 = 0;
+	int flag_x = 0, flag_y1 = 0, flag_y2 = 0;
+	static const int correct[5] = {16, 8, 4, 2, 1};
+
+	for (i = 0; i < 5; i++) {
+		result = check_offset(st,
+				      offset_x, offset_y1, offset_y2,
+				      &flag_x, &flag_y1, &flag_y2);
+		if (result)
+			return result;
+		if (flag_x)
+			offset_x += flag_x * correct[i];
+		if (flag_y1)
+			offset_y1 += flag_y1 * correct[i];
+		if (flag_y2)
+			offset_y2 += flag_y2 * correct[i];
+	}
+
+	result = set_hardware_offset(st, offset_x, offset_y1, offset_y2);
+	if (result)
+		return result;
+	offset[0] = offset_x;
+	offset[1] = offset_y1;
+	offset[2] = offset_y2;
+
+	return result;
+}
+
+static void coordinate_conversion(short x, short y1, short y2, short t,
+				  int *xo, int *yo, int *zo)
+{
+	int sx, sy1, sy2, sy, sz;
+	int hx, hy, hz;
+
+	sx = x - (Cx * t) / 100;
+	sy1 = y1 - (Cy1 * t) / 100;
+	sy2 = y2 - (Cy2 * t) / 100;
+
+	sy = sy1 - sy2;
+	sz = -sy1 - sy2;
+
+	hx = k * ((100 * sx + a2 * sy + a3 * sz) / 10);
+	hy = k * ((a4 * sx + a5 * sy + a6 * sz) / 10);
+	hz = k * ((a7 * sx + a8 * sy + a9 * sz) / 10);
+
+	*xo = hx;
+	*yo = hy;
+	*zo = hz;
+}
+
+static int get_cal_data_yas532_533(struct inv_compass_state *st)
+{
+	u8 data[YAS_YAS532_533_CAL_DATA_SIZE];
+	int result;
+
+	result = inv_serial_read(st, YAS530_REGADDR_CAL,
+				YAS_YAS532_533_CAL_DATA_SIZE, data);
+	if (result)
+		return result;
+	/* CAL data Second Read */
+	result = inv_serial_read(st, YAS530_REGADDR_CAL,
+				YAS_YAS532_533_CAL_DATA_SIZE, data);
+	if (result)
+		return result;
+
+	dx = data[0];
+	dy1 = data[1];
+	dy2 = data[2];
+	d2 = (data[3] >> 2) & 0x03f;
+	d3 = (u8)(((data[3] << 2) & 0x0c) | ((data[4] >> 6) & 0x03));
+	d4 = (u8)(data[4] & 0x3f);
+	d5 = (data[5] >> 2) & 0x3f;
+	d6 = (u8)(((data[5] << 4) & 0x30) | ((data[6] >> 4) & 0x0f));
+	d7 = (u8)(((data[6] << 3) & 0x78) | ((data[7] >> 5) & 0x07));
+	d8 = (u8)(((data[7] << 1) & 0x3e) | ((data[8] >> 7) & 0x01));
+	d9 = (u8)(((data[8] << 1) & 0xfe) | ((data[9] >> 7) & 0x01));
+	d0 = (u8)((data[9] >> 2) & 0x1f);
+	dck = (u8)(((data[9] << 1) & 0x06) | ((data[10] >> 7) & 0x01));
+	ver = (u8)((data[13]) & 0x01);
+
+	Cx  = dx * 10 - 1280;
+	Cy1 = dy1 * 10 - 1280;
+	Cy2 = dy2 * 10 - 1280;
+	a2  = d2 - 32;
+	a3  = d3 - 8;
+	a4  = d4 - 32;
+	a5  = d5 + 38;
+	a6  = d6 - 32;
+	a7  = d7 - 64;
+	a8  = d8 - 32;
+	a9  = d9;
+	k   = d0;
+
+	return 0;
+}
+
+static int get_cal_data_yas530(struct inv_compass_state *st)
+{
+	u8 data[YAS_YAS530_CAL_DATA_SIZE];
+	int result;
+	/* CAL data read */
+	result = inv_serial_read(st, YAS530_REGADDR_CAL,
+				YAS_YAS530_CAL_DATA_SIZE, data);
+	if (result)
+		return result;
+	/* CAL data Second Read */
+	result = inv_serial_read(st, YAS530_REGADDR_CAL,
+				YAS_YAS530_CAL_DATA_SIZE, data);
+	if (result)
+		return result;
+	/*Cal data */
+	dx = data[0];
+	dy1 = data[1];
+	dy2 = data[2];
+	d2 = (data[3] >> 2) & 0x03f;
+	d3 = ((data[3] << 2) & 0x0c) | ((data[4] >> 6) & 0x03);
+	d4 = data[4] & 0x3f;
+	d5 = (data[5] >> 2) & 0x3f;
+	d6 = ((data[5] << 4) & 0x30) | ((data[6] >> 4) & 0x0f);
+	d7 = ((data[6] << 3) & 0x78) | ((data[7] >> 5) & 0x07);
+	d8 = ((data[7] << 1) & 0x3e) | ((data[8] >> 7) & 0x01);
+	d9 = ((data[8] << 1) & 0xfe) | ((data[9] >> 7) & 0x01);
+	d0 = (data[9] >> 2) & 0x1f;
+	dck = ((data[9] << 1) & 0x06) | ((data[10] >> 7) & 0x01);
+	ver = (u8)((data[15]) & 0x03);
+
+	/*Correction Data */
+	Cx = (int)dx * 6 - 768;
+	Cy1 = (int)dy1 * 6 - 768;
+	Cy2 = (int)dy2 * 6 - 768;
+	a2 = (int)d2 - 32;
+	a3 = (int)d3 - 8;
+	a4 = (int)d4 - 32;
+	a5 = (int)d5 + 38;
+	a6 = (int)d6 - 32;
+	a7 = (int)d7 - 64;
+	a8 = (int)d8 - 32;
+	a9 = (int)d9;
+	k = (int)d0 + 10;
+
+	return 0;
+}
+
+
+static void thresh_filter_init(struct yas_thresh_filter *thresh_filter,
+				int threshold)
+{
+	thresh_filter->threshold = threshold;
+	thresh_filter->last = 0;
+}
+
+static void
+adaptive_filter_init(struct yas_adaptive_filter *adap_filter, int len,
+		int noise)
+{
+	int i;
+
+	adap_filter->num = 0;
+	adap_filter->index = 0;
+	adap_filter->filter_noise = noise;
+	adap_filter->filter_len = len;
+
+	for (i = 0; i < adap_filter->filter_len; ++i)
+		adap_filter->sequence[i] = 0;
+}
+
+static void yas_init_adap_filter(struct inv_compass_state *st)
+{
+	struct yas_filter *f;
+	int i;
+	int noise[] = {YAS_MAG_DEFAULT_FILTER_NOISE_X,
+			YAS_MAG_DEFAULT_FILTER_NOISE_Y,
+			YAS_MAG_DEFAULT_FILTER_NOISE_Z};
+
+	f = &st->filter;
+	f->filter_len = YAS_MAG_DEFAULT_FILTER_LEN;
+	for (i = 0; i < 3; i++)
+		f->filter_noise[i] = noise[i];
+
+	for (i = 0; i < 3; i++) {
+		adaptive_filter_init(&f->adap_filter[i], f->filter_len,
+				f->filter_noise[i]);
+		thresh_filter_init(&f->thresh_filter[i], f->filter_thresh);
+	}
+}
+
+int yas53x_resume(struct inv_compass_state *st)
+{
+	int result = 0;
+
+	unsigned char dummyData = 0x00;
+	unsigned char read_reg[1];
+
+	/* =============================================== */
+
+	/* Step 1 - Test register initialization */
+	dummyData = 0x00;
+	result = inv_serial_single_write(st,
+					 YAS530_REGADDR_TEST1, dummyData);
+	if (result)
+		return result;
+	result =
+	    inv_serial_single_write(st,
+				    YAS530_REGADDR_TEST2, dummyData);
+	if (result)
+		return result;
+	/* Device ID read  */
+	result = inv_serial_read(st,
+				 YAS530_REGADDR_DEVICE_ID, 1, read_reg);
+
+	/*Step 2 Read the CAL register */
+	st->get_cal_data(st);
+
+	/*Obtain the [49:47] bits */
+	dck &= 0x07;
+
+	/*Step 3 : Storing the CONFIG with the CLK value */
+	dummyData = 0x00 | (dck << 2);
+	result = inv_serial_single_write(st,
+					 YAS530_REGADDR_CONFIG, dummyData);
+	if (result)
+		return result;
+	/*Step 4 : Set Acquisition Interval Register */
+	dummyData = 0x00;
+	result = inv_serial_single_write(st,
+					 YAS530_REGADDR_MEASURE_INTERVAL,
+					 dummyData);
+	if (result)
+		return result;
+
+	/*Step 5 : Reset Coil */
+	dummyData = 0x00;
+	result = inv_serial_single_write(st,
+					 YAS530_REGADDR_ACTUATE_INIT_COIL,
+					 dummyData);
+	if (result)
+		return result;
+	/* Offset Measurement and Set */
+	result = measure_and_set_offset(st, st->offset);
+	if (result)
+		return result;
+	st->first_measure_after_reset = 1;
+	st->first_read_after_reset = 1;
+	st->reset_timer = 0;
+
+	yas_init_adap_filter(st);
+
+	return result;
+}
+
+static int inv_check_range(struct inv_compass_state *st, s16 x, s16 y1, s16 y2)
+{
+	int result = 0;
+
+	if (x == 0)
+		result |= 0x01;
+	if (x == st->overflow_bound)
+		result |= 0x02;
+	if (y1 == 0)
+		result |= 0x04;
+	if (y1 == st->overflow_bound)
+		result |= 0x08;
+	if (y2 == 0)
+		result |= 0x10;
+	if (y2 == st->overflow_bound)
+		result |= 0x20;
+
+	return result;
+}
+static int square(int data)
+{
+	return data * data;
+}
+
+static int
+adaptive_filter_filter(struct yas_adaptive_filter *adap_filter, int in)
+{
+	int avg, sum;
+	int i;
+
+	if (adap_filter->filter_len == 0)
+		return in;
+	if (adap_filter->num < adap_filter->filter_len) {
+		adap_filter->sequence[adap_filter->index++] = in / 100;
+		adap_filter->num++;
+		return in;
+	}
+	if (adap_filter->filter_len <= adap_filter->index)
+		adap_filter->index = 0;
+	adap_filter->sequence[adap_filter->index++] = in / 100;
+
+	avg = 0;
+	for (i = 0; i < adap_filter->filter_len; i++)
+		avg += adap_filter->sequence[i];
+	avg /= adap_filter->filter_len;
+
+	sum = 0;
+	for (i = 0; i < adap_filter->filter_len; i++)
+		sum += square(avg - adap_filter->sequence[i]);
+	sum /= adap_filter->filter_len;
+
+	if (sum <= adap_filter->filter_noise)
+		return avg * 100;
+
+	return ((in/100 - avg) * (sum - adap_filter->filter_noise) / sum + avg)
+		* 100;
+}
+
+static int
+thresh_filter_filter(struct yas_thresh_filter *thresh_filter, int in)
+{
+	if (in < thresh_filter->last - thresh_filter->threshold
+			|| thresh_filter->last
+			+ thresh_filter->threshold < in) {
+		thresh_filter->last = in;
+		return in;
+	} else {
+		return thresh_filter->last;
+	}
+}
+
+static void
+filter_filter(struct yas_filter *d, int *orig, int *filtered)
+{
+	int i;
+
+	for (i = 0; i < 3; i++) {
+		filtered[i] = adaptive_filter_filter(&d->adap_filter[i],
+				orig[i]);
+		filtered[i] = thresh_filter_filter(&d->thresh_filter[i],
+				filtered[i]);
+	}
+}
+
+int yas53x_read(struct inv_compass_state *st, short rawfixed[3],
+				int *overunderflow)
+{
+	int result = 0;
+
+	int busy, i, ov;
+	short t, x, y1, y2;
+	s32 xyz[3], disturb[3];
+
+	result = measure_int(st, &busy, &t, &x, &y1, &y2);
+	if (result)
+		return result;
+	if (busy)
+		return -1;
+	coordinate_conversion(x, y1, y2, t, &xyz[0], &xyz[1], &xyz[2]);
+	filter_filter(&st->filter, xyz, xyz);
+	for (i = 0; i < 3; i++)
+		rawfixed[i] = (short)(xyz[i] / 100);
+
+	if (st->first_measure_after_reset) {
+		for (i = 0; i < 3; i++)
+			st->base_compass_data[i] = rawfixed[i];
+		st->first_measure_after_reset = 0;
+	}
+	ov = 0;
+	for (i = 0; i < 3; i++) {
+		disturb[i] = abs(st->base_compass_data[i] - rawfixed[i]);
+		if (disturb[i] > YAS_MAG_DISTURBURNCE_THRESHOLD)
+			ov = 1;
+	}
+	if (ov)
+		st->reset_timer += st->delay;
+	else
+		st->reset_timer = 0;
+
+	if (st->reset_timer > YAS_RESET_COIL_TIME_THRESHOLD)
+		*overunderflow = (1<<8);
+	else
+		*overunderflow = 0;
+	*overunderflow |= inv_check_range(st, x, y1, y2);
+
+	return 0;
+}
+
+/**
+ *  yas53x_read_raw() - read raw method.
+ */
+static int yas53x_read_raw(struct iio_dev *indio_dev,
+			      struct iio_chan_spec const *chan,
+			      int *val,
+			      int *val2,
+			      long mask) {
+	struct inv_compass_state  *st = iio_priv(indio_dev);
+
+	switch (mask) {
+	case 0:
+		if (!(iio_buffer_enabled(indio_dev)))
+			return -EINVAL;
+		if (chan->type == IIO_MAGN) {
+			*val = st->compass_data[chan->channel2 - IIO_MOD_X];
+			return IIO_VAL_INT;
+		}
+
+		return -EINVAL;
+	case IIO_CHAN_INFO_SCALE:
+		if (chan->type == IIO_MAGN) {
+			*val = YAS530_SCALE;
+			return IIO_VAL_INT;
+		}
+		return -EINVAL;
+	default:
+		return -EINVAL;
+	}
+}
+
+/**
+ * inv_compass_matrix_show() - show orientation matrix
+ */
+static ssize_t inv_compass_matrix_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	signed char *m;
+	struct inv_compass_state *st = iio_priv(indio_dev);
+	m = st->plat_data.orientation;
+	return sprintf(buf,
+	"%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
+		m[0],  m[1],  m[2],  m[3], m[4], m[5], m[6], m[7], m[8]);
+}
+
+static ssize_t yas53x_rate_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	u32 data;
+	int error;
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	struct inv_compass_state *st = iio_priv(indio_dev);
+
+	error = kstrtoint(buf, 10, &data);
+	if (error)
+		return error;
+	if (0 == data)
+		return -EINVAL;
+	/* transform rate to delay in ms */
+	data = MSEC_PER_SEC / data;
+
+	if (data > YAS530_MAX_DELAY)
+		data = YAS530_MAX_DELAY;
+	if (data < YAS530_MIN_DELAY)
+		data = YAS530_MIN_DELAY;
+	st->delay = data;
+
+	return count;
+}
+
+static ssize_t yas53x_rate_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	struct inv_compass_state *st = iio_priv(indio_dev);
+	/* transform delay in ms to rate */
+	return sprintf(buf, "%d\n", (int)MSEC_PER_SEC / st->delay);
+}
+
+static ssize_t yas53x_overunderflow_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf, size_t count)
+{
+	u32 data;
+	int error;
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	struct inv_compass_state *st = iio_priv(indio_dev);
+
+	error = kstrtoint(buf, 10, &data);
+	if (error)
+		return error;
+	if (data)
+		return -EINVAL;
+	st->overunderflow = data;
+
+	return count;
+}
+
+static ssize_t yas53x_overunderflow_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
+	struct inv_compass_state *st = iio_priv(indio_dev);
+
+	return sprintf(buf, "%d\n", st->overunderflow);
+}
+
+void set_yas53x_enable(struct iio_dev *indio_dev, bool enable)
+{
+	struct inv_compass_state *st = iio_priv(indio_dev);
+
+	yas_init_adap_filter(st);
+	st->first_measure_after_reset = 1;
+	st->first_read_after_reset = 1;
+	schedule_delayed_work(&st->work, msecs_to_jiffies(st->delay));
+}
+
+static void yas53x_work_func(struct work_struct *work)
+{
+	struct inv_compass_state *st =
+		container_of((struct delayed_work *)work,
+			struct inv_compass_state, work);
+	struct iio_dev *indio_dev = iio_priv_to_dev(st);
+	u32 delay = msecs_to_jiffies(st->delay);
+
+	mutex_lock(&indio_dev->mlock);
+	if (!(iio_buffer_enabled(indio_dev)))
+		goto error_ret;
+
+	schedule_delayed_work(&st->work, delay);
+	inv_read_yas53x_fifo(indio_dev);
+	INV_I2C_INC_COMPASSIRQ();
+
+error_ret:
+	mutex_unlock(&indio_dev->mlock);
+}
+
+static const struct iio_chan_spec compass_channels[] = {
+	{
+		.type = IIO_MAGN,
+		.modified = 1,
+		.channel2 = IIO_MOD_X,
+		.info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT,
+		.scan_index = INV_YAS53X_SCAN_MAGN_X,
+		.scan_type = IIO_ST('s', 16, 16, 0)
+	}, {
+		.type = IIO_MAGN,
+		.modified = 1,
+		.channel2 = IIO_MOD_Y,
+		.info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT,
+		.scan_index = INV_YAS53X_SCAN_MAGN_Y,
+		.scan_type = IIO_ST('s', 16, 16, 0)
+	}, {
+		.type = IIO_MAGN,
+		.modified = 1,
+		.channel2 = IIO_MOD_Z,
+		.info_mask = IIO_CHAN_INFO_SCALE_SHARED_BIT,
+		.scan_index = INV_YAS53X_SCAN_MAGN_Z,
+		.scan_type = IIO_ST('s', 16, 16, 0)
+	},
+	IIO_CHAN_SOFT_TIMESTAMP(INV_YAS53X_SCAN_TIMESTAMP)
+};
+
+static DEVICE_ATTR(compass_matrix, S_IRUGO, inv_compass_matrix_show, NULL);
+static DEVICE_ATTR(sampling_frequency, S_IRUGO | S_IWUSR, yas53x_rate_show,
+		yas53x_rate_store);
+static DEVICE_ATTR(overunderflow, S_IRUGO | S_IWUSR,
+		yas53x_overunderflow_show, yas53x_overunderflow_store);
+
+static struct attribute *inv_yas53x_attributes[] = {
+	&dev_attr_compass_matrix.attr,
+	&dev_attr_sampling_frequency.attr,
+	&dev_attr_overunderflow.attr,
+	NULL,
+};
+static const struct attribute_group inv_attribute_group = {
+	.name = "yas53x",
+	.attrs = inv_yas53x_attributes
+};
+
+static const struct iio_info yas53x_info = {
+	.driver_module = THIS_MODULE,
+	.read_raw = &yas53x_read_raw,
+	.attrs = &inv_attribute_group,
+};
+
+/*constant IIO attribute */
+/**
+ *  inv_yas53x_probe() - probe function.
+ */
+static int inv_yas53x_probe(struct i2c_client *client,
+	const struct i2c_device_id *id)
+{
+	struct inv_compass_state *st;
+	struct iio_dev *indio_dev;
+	int result;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		result = -ENODEV;
+		goto out_no_free;
+	}
+	indio_dev = iio_allocate_device(sizeof(*st));
+	if (indio_dev == NULL) {
+		result =  -ENOMEM;
+		goto out_no_free;
+	}
+	st = iio_priv(indio_dev);
+	st->client = client;
+	st->plat_data =
+		*(struct mpu_platform_data *)dev_get_platdata(&client->dev);
+	st->delay = 10;
+
+	i2c_set_clientdata(client, indio_dev);
+
+	if (!strcmp(id->name, "yas530")) {
+		st->read_data    = yas530_read_data;
+		st->get_cal_data = get_cal_data_yas530;
+		st->overflow_bound = YAS_YAS530_DATA_OVERFLOW;
+		st->center     = YAS_YAS530_DATA_CENTER;
+		st->filter.filter_thresh = YAS530_MAG_DEFAULT_FILTER_THRESH;
+	} else {
+		st->read_data    = yas532_533_read_data;
+		st->get_cal_data = get_cal_data_yas532_533;
+		st->overflow_bound = YAS_YAS532_533_DATA_OVERFLOW;
+		st->center     = YAS_YAS532_533_DATA_CENTER;
+		st->filter.filter_thresh = YAS532_MAG_DEFAULT_FILTER_THRESH;
+	}
+	st->upper_bound = st->center + (st->center >> 1);
+	st->lower_bound = (st->center >> 1);
+
+	result = yas53x_resume(st);
+	if (result)
+		goto out_free;
+
+	indio_dev->dev.parent = &client->dev;
+	indio_dev->name = id->name;
+	indio_dev->channels = compass_channels;
+	indio_dev->num_channels = ARRAY_SIZE(compass_channels);
+	indio_dev->info = &yas53x_info;
+	indio_dev->modes = INDIO_DIRECT_MODE;
+	indio_dev->currentmode = INDIO_DIRECT_MODE;
+
+	result = inv_yas53x_configure_ring(indio_dev);
+	if (result)
+		goto out_free;
+	result = iio_buffer_register(indio_dev, indio_dev->channels,
+					indio_dev->num_channels);
+	if (result)
+		goto out_unreg_ring;
+	result = inv_yas53x_probe_trigger(indio_dev);
+	if (result)
+		goto out_remove_ring;
+
+	result = iio_device_register(indio_dev);
+	if (result)
+		goto out_remove_trigger;
+	INIT_DELAYED_WORK(&st->work, yas53x_work_func);
+	pr_info("%s: Probe name %s\n", __func__, id->name);
+
+	return 0;
+out_remove_trigger:
+	if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
+		inv_yas53x_remove_trigger(indio_dev);
+out_remove_ring:
+	iio_buffer_unregister(indio_dev);
+out_unreg_ring:
+	inv_yas53x_unconfigure_ring(indio_dev);
+out_free:
+	iio_free_device(indio_dev);
+out_no_free:
+	dev_err(&client->adapter->dev, "%s failed %d\n", __func__, result);
+	return -EIO;
+}
+
+/**
+ *  inv_yas53x_remove() - remove function.
+ */
+static int inv_yas53x_remove(struct i2c_client *client)
+{
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	struct inv_compass_state *st = iio_priv(indio_dev);
+	cancel_delayed_work_sync(&st->work);
+	iio_device_unregister(indio_dev);
+	inv_yas53x_remove_trigger(indio_dev);
+	iio_buffer_unregister(indio_dev);
+	inv_yas53x_unconfigure_ring(indio_dev);
+	iio_free_device(indio_dev);
+
+	dev_info(&client->adapter->dev, "inv_yas53x_iio module removed.\n");
+	return 0;
+}
+static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
+/* device id table is used to identify what device can be
+ * supported by this driver
+ */
+static const struct i2c_device_id inv_yas53x_id[] = {
+	{"yas530", 0},
+	{"yas532", 0},
+	{"yas533", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, inv_yas53x_id);
+
+static struct i2c_driver inv_yas53x_driver = {
+	.class = I2C_CLASS_HWMON,
+	.probe		=	inv_yas53x_probe,
+	.remove		=	inv_yas53x_remove,
+	.id_table	=	inv_yas53x_id,
+	.driver = {
+		.owner	=	THIS_MODULE,
+		.name	=	"inv_yas53x_iio",
+	},
+	.address_list = normal_i2c,
+};
+
+static int __init inv_yas53x_init(void)
+{
+	int result = i2c_add_driver(&inv_yas53x_driver);
+	if (result) {
+		pr_err("%s failed\n", __func__);
+		return result;
+	}
+	return 0;
+}
+
+static void __exit inv_yas53x_exit(void)
+{
+	i2c_del_driver(&inv_yas53x_driver);
+}
+
+module_init(inv_yas53x_init);
+module_exit(inv_yas53x_exit);
+
+MODULE_AUTHOR("Invensense Corporation");
+MODULE_DESCRIPTION("Invensense device driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("inv_yas53x_iio");
+/**
+ *  @}
+ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_yas53x_iio.h b/drivers/iio/magnetometer/inv_compass/inv_yas53x_iio.h
new file mode 100644
index 00000000..92bf0af7
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_yas53x_iio.h
@@ -0,0 +1,172 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup DRIVERS
+ *  @brief      Hardware drivers.
+ *
+ *  @{
+ *      @file  inv_yas53x_iio.h
+ *      @brief Struct definitions for the Invensense implementation
+ *              of yas53x driver.
+ */
+
+#ifndef _INV_GYRO_H_
+#define _INV_GYRO_H_
+
+#include <linux/i2c.h>
+#include <linux/kfifo.h>
+#include <linux/miscdevice.h>
+#include <linux/input.h>
+#include <linux/spinlock.h>
+#include <linux/mpu.h>
+
+#include "iio.h"
+#include "buffer.h"
+#include "trigger.h"
+
+#define YAS_MAG_MAX_FILTER_LEN			30
+struct yas_adaptive_filter {
+	int num;
+	int index;
+	int filter_len;
+	int filter_noise;
+	int sequence[YAS_MAG_MAX_FILTER_LEN];
+};
+
+struct yas_thresh_filter {
+	int threshold;
+	int last;
+};
+
+struct yas_filter {
+	int filter_len;
+	int filter_thresh;
+	int filter_noise[3];
+	struct yas_adaptive_filter adap_filter[3];
+	struct yas_thresh_filter thresh_filter[3];
+};
+
+/**
+ *  struct inv_compass_state - Driver state variables.
+ *  @plat_data:         mpu platform data from board file.
+ *  @client:		i2c client handle.
+ *  @chan_info:         channel information.
+ *  @trig:              IIO trigger.
+ *  @work:              work structure.
+ *  @delay:             delay to schedule the next work.
+ *  @overflow_bound:    bound to determine overflow.
+ *  @center:            center of the measurement.
+ *  @compass_data[3]:   compass data store.
+ *  @offset[3]:         yas530 specific data.
+ *  @base_compass_data[3]: first measure data after reset.
+ *  @first_measure_after_reset:1: flag for first measurement after reset.
+ *  @first_read_after_reset:1: flag for first read after reset.
+ *  @reset_timer: timer to accumulate overflow conditions.
+ *  @overunderflow:1:     overflow and underflow flag.
+ *  @filter: filter data structure.
+ *  @read_data:         function pointer of reading data from device.
+ *  @get_cal_data: function pointer of reading cal data.
+ */
+struct inv_compass_state {
+	struct mpu_platform_data plat_data;
+	struct i2c_client *client;
+	struct iio_trigger  *trig;
+	struct delayed_work work;
+	s16 delay;
+	s16 overflow_bound;
+	s16 upper_bound;
+	s16 lower_bound;
+	s16 center;
+	s16 compass_data[3];
+	s8 offset[3];
+	s16 base_compass_data[3];
+	u8 first_measure_after_reset:1;
+	u8 first_read_after_reset:1;
+	u8 overunderflow:1;
+	s32 reset_timer;
+	struct yas_filter filter;
+	int (*read_data)(struct inv_compass_state *st,
+			  int *, u16 *, u16 *, u16 *, u16 *);
+	int (*get_cal_data)(struct inv_compass_state *);
+};
+
+/* scan element definition */
+enum inv_mpu_scan {
+	INV_YAS53X_SCAN_MAGN_X,
+	INV_YAS53X_SCAN_MAGN_Y,
+	INV_YAS53X_SCAN_MAGN_Z,
+	INV_YAS53X_SCAN_TIMESTAMP,
+};
+
+#define YAS530_REGADDR_DEVICE_ID          0x80
+#define YAS530_REGADDR_ACTUATE_INIT_COIL  0x81
+#define YAS530_REGADDR_MEASURE_COMMAND    0x82
+#define YAS530_REGADDR_CONFIG             0x83
+#define YAS530_REGADDR_MEASURE_INTERVAL   0x84
+#define YAS530_REGADDR_OFFSET_X           0x85
+#define YAS530_REGADDR_OFFSET_Y1          0x86
+#define YAS530_REGADDR_OFFSET_Y2          0x87
+#define YAS530_REGADDR_TEST1              0x88
+#define YAS530_REGADDR_TEST2              0x89
+#define YAS530_REGADDR_CAL                0x90
+#define YAS530_REGADDR_MEASURE_DATA       0xb0
+
+#define YAS530_MAX_DELAY                  200
+#define YAS530_MIN_DELAY                  5
+#define YAS530_SCALE                      107374182L
+
+#define YAS_YAS530_VERSION_A		0	/* YAS530  (MS-3E Aver) */
+#define YAS_YAS530_VERSION_B		1	/* YAS530B (MS-3E Bver) */
+#define YAS_YAS530_VERSION_A_COEF	380
+#define YAS_YAS530_VERSION_B_COEF	550
+#define YAS_YAS530_DATA_CENTER		2048
+#define YAS_YAS530_DATA_OVERFLOW	4095
+#define YAS_YAS530_CAL_DATA_SIZE        16
+
+/*filter related defines */
+#define YAS_MAG_DEFAULT_FILTER_NOISE_X          144 /* sd: 1200 nT */
+#define YAS_MAG_DEFAULT_FILTER_NOISE_Y          144 /* sd: 1200 nT */
+#define YAS_MAG_DEFAULT_FILTER_NOISE_Z          144 /* sd: 1200 nT */
+#define YAS_MAG_DEFAULT_FILTER_LEN              20
+
+#define YAS530_MAG_DEFAULT_FILTER_THRESH        100
+#define YAS532_MAG_DEFAULT_FILTER_THRESH        300
+
+#define YAS_YAS532_533_VERSION_AB	0 /* YAS532_533AB (MS-3R/3F ABver) */
+#define YAS_YAS532_533_VERSION_AC	1 /* YAS532_533AC (MS-3R/3F ACver) */
+#define YAS_YAS532_533_VERSION_AB_COEF	1800
+#define YAS_YAS532_533_VERSION_AC_COEF	900
+#define YAS_YAS532_533_DATA_CENTER      4096
+#define YAS_YAS532_533_DATA_OVERFLOW	8190
+#define YAS_YAS532_533_CAL_DATA_SIZE    14
+
+#define YAS_MAG_DISTURBURNCE_THRESHOLD  1600
+#define YAS_RESET_COIL_TIME_THRESHOLD   3000
+
+#define INV_ERROR_COMPASS_DATA_OVERFLOW  (-1)
+#define INV_ERROR_COMPASS_DATA_NOT_READY (-2)
+
+int inv_yas53x_configure_ring(struct iio_dev *indio_dev);
+void inv_yas53x_unconfigure_ring(struct iio_dev *indio_dev);
+int inv_yas53x_probe_trigger(struct iio_dev *indio_dev);
+void inv_yas53x_remove_trigger(struct iio_dev *indio_dev);
+void set_yas53x_enable(struct iio_dev *indio_dev, bool enable);
+void inv_read_yas53x_fifo(struct iio_dev *indio_dev);
+int yas53x_read(struct inv_compass_state *st, short rawfixed[3],
+				s32 *overunderflow);
+int yas53x_resume(struct inv_compass_state *st);
+
+#endif  /* #ifndef _INV_GYRO_H_ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_yas53x_ring.c b/drivers/iio/magnetometer/inv_compass/inv_yas53x_ring.c
new file mode 100644
index 00000000..efcf49c6
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_yas53x_ring.c
@@ -0,0 +1,165 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup  DRIVERS
+ *  @brief       Hardware drivers.
+ *
+ *  @{
+ *      @file    inv_yas53x_ring.c
+ *      @brief   Invensense implementation for yas530/yas532/yas533.
+ *      @details This driver currently works for the yas530/yas532/yas533.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+
+#include "iio.h"
+#include "kfifo_buf.h"
+#include "trigger_consumer.h"
+#include "sysfs.h"
+
+#include "inv_yas53x_iio.h"
+
+static s64 get_time_ns(void)
+{
+	struct timespec ts;
+	ktime_get_ts(&ts);
+
+	return timespec_to_ns(&ts);
+}
+
+static int put_scan_to_buf(struct iio_dev *indio_dev, unsigned char *d,
+				short *s, int scan_index)
+{
+	struct iio_buffer *ring = indio_dev->buffer;
+	int st;
+	int i, d_ind;
+
+	d_ind = 0;
+	for (i = 0; i < 3; i++) {
+		st = iio_scan_mask_query(indio_dev, ring, scan_index + i);
+		if (st) {
+			memcpy(&d[d_ind], &s[i], sizeof(s[i]));
+			d_ind += sizeof(s[i]);
+		}
+	}
+
+	return d_ind;
+}
+
+/**
+ *  inv_read_yas53x_fifo() - Transfer data from FIFO to ring buffer.
+ */
+void inv_read_yas53x_fifo(struct iio_dev *indio_dev)
+{
+	struct inv_compass_state *st = iio_priv(indio_dev);
+	struct iio_buffer *ring = indio_dev->buffer;
+	int d_ind;
+	s32 overunderflow;
+	s8 *tmp;
+	s64 tmp_buf[2];
+
+	if (!yas53x_read(st, st->compass_data, &overunderflow)) {
+		tmp = (u8 *)tmp_buf;
+		d_ind = put_scan_to_buf(indio_dev, tmp, st->compass_data,
+						INV_YAS53X_SCAN_MAGN_X);
+		if (ring->scan_timestamp)
+			tmp_buf[(d_ind + 7) / 8] = get_time_ns();
+		ring->access->store_to(indio_dev->buffer, tmp, 0);
+
+		if (overunderflow) {
+			yas53x_resume(st);
+			if (!st->overunderflow)
+				st->overunderflow = 1;
+		}
+	}
+}
+
+void inv_yas53x_unconfigure_ring(struct iio_dev *indio_dev)
+{
+	iio_kfifo_free(indio_dev->buffer);
+};
+
+static int inv_yas53x_postenable(struct iio_dev *indio_dev)
+{
+	struct inv_compass_state *st = iio_priv(indio_dev);
+	struct iio_buffer *ring = indio_dev->buffer;
+
+	/* when all the outputs are disabled, even though buffer/enable is on,
+	   do nothing */
+	if (!(iio_scan_mask_query(indio_dev, ring, INV_YAS53X_SCAN_MAGN_X) ||
+	    iio_scan_mask_query(indio_dev, ring, INV_YAS53X_SCAN_MAGN_Y) ||
+	    iio_scan_mask_query(indio_dev, ring, INV_YAS53X_SCAN_MAGN_Z)))
+		return 0;
+
+	set_yas53x_enable(indio_dev, true);
+	schedule_delayed_work(&st->work,
+		msecs_to_jiffies(st->delay));
+
+	return 0;
+}
+
+static int inv_yas53x_predisable(struct iio_dev *indio_dev)
+{
+	struct inv_compass_state *st = iio_priv(indio_dev);
+	struct iio_buffer *ring = indio_dev->buffer;
+
+	cancel_delayed_work_sync(&st->work);
+	clear_bit(INV_YAS53X_SCAN_MAGN_X, ring->scan_mask);
+	clear_bit(INV_YAS53X_SCAN_MAGN_Y, ring->scan_mask);
+	clear_bit(INV_YAS53X_SCAN_MAGN_Z, ring->scan_mask);
+
+	return 0;
+}
+
+static const struct iio_buffer_setup_ops inv_yas53x_ring_setup_ops = {
+	.preenable = &iio_sw_buffer_preenable,
+	.postenable = &inv_yas53x_postenable,
+	.predisable = &inv_yas53x_predisable,
+};
+
+int inv_yas53x_configure_ring(struct iio_dev *indio_dev)
+{
+	int ret = 0;
+	struct iio_buffer *ring;
+
+	ring = iio_kfifo_allocate(indio_dev);
+	if (!ring) {
+		ret = -ENOMEM;
+		return ret;
+	}
+	indio_dev->buffer = ring;
+	/* setup ring buffer */
+	ring->scan_timestamp = true;
+	indio_dev->setup_ops = &inv_yas53x_ring_setup_ops;
+
+	indio_dev->modes |= INDIO_BUFFER_TRIGGERED;
+	return 0;
+}
+/**
+ *  @}
+ */
+
diff --git a/drivers/iio/magnetometer/inv_compass/inv_yas53x_trigger.c b/drivers/iio/magnetometer/inv_compass/inv_yas53x_trigger.c
new file mode 100644
index 00000000..a20ce2ba
--- /dev/null
+++ b/drivers/iio/magnetometer/inv_compass/inv_yas53x_trigger.c
@@ -0,0 +1,91 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+*/
+
+/**
+ *  @addtogroup  DRIVERS
+ *  @brief       Hardware drivers.
+ *
+ *  @{
+ *      @file    inv_yas53x_trigger.c
+ *      @brief   Invensense implementation for yas530/yas532/yas533
+ *      @details This driver currently works for the yas530/yas532/yas533
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/sysfs.h>
+#include <linux/jiffies.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/kfifo.h>
+#include <linux/poll.h>
+#include <linux/miscdevice.h>
+#include <linux/spinlock.h>
+
+#include "iio.h"
+#include "sysfs.h"
+#include "trigger.h"
+
+#include "inv_yas53x_iio.h"
+
+static const struct iio_trigger_ops inv_yas53x_trigger_ops = {
+	.owner = THIS_MODULE,
+};
+
+int inv_yas53x_probe_trigger(struct iio_dev *indio_dev)
+{
+	int ret;
+	struct inv_compass_state *st = iio_priv(indio_dev);
+
+	st->trig = iio_allocate_trigger("%s-dev%d",
+					indio_dev->name,
+					indio_dev->id);
+	if (st->trig == NULL) {
+		ret = -ENOMEM;
+		goto error_ret;
+	}
+	/* select default trigger */
+	st->trig->dev.parent = &st->client->dev;
+	st->trig->private_data = indio_dev;
+	st->trig->ops = &inv_yas53x_trigger_ops;
+	ret = iio_trigger_register(st->trig);
+
+	/* select default trigger */
+	indio_dev->trig = st->trig;
+	if (ret)
+		goto error_free_trig;
+
+	return 0;
+
+error_free_trig:
+	iio_free_trigger(st->trig);
+error_ret:
+	return ret;
+}
+
+void inv_yas53x_remove_trigger(struct iio_dev *indio_dev)
+{
+	struct inv_compass_state *st = iio_priv(indio_dev);
+
+	iio_trigger_unregister(st->trig);
+	iio_free_trigger(st->trig);
+}
+/**
+ *  @}
+ */
+