Upload 4 files

ais328dq.h

@@ -0,0 +1,145 @@
+/* Copyright (C) 2014 STMicroelectronics
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * File Name		: ais328dq.h
+ * Authors		: VMA - Volume Mems & Analog Division
+ *			: Matteo Dameno (matteo.dameno@st.com)
+ *			: Author is willing to be considered the contact
+ *			: and update point for the driver.
+ * Version		: V 1.0.1
+ * Date			: 2012/10/07
+ * Description		: AIS328DQ 3D accelerometer sensor LDD
+ *
+ */
+
+#ifndef __AIS328DQ_H__
+#define __AIS328DQ_H__
+
+#define AIS328DQ_ACC_I2C_SAD_L		(0x18)
+#define AIS328DQ_ACC_I2C_SAD_H		(0x19)
+#define	AIS328DQ_ACC_DEV_NAME	"ais328dq_acc"
+
+
+
+/************************************************/
+/* 	Accelerometer section defines	 	*/
+/************************************************/
+
+/* Accelerometer Sensor Full Scale */
+#define AIS328DQ_ACC_FS_MASK		0x30
+#define AIS328DQ_ACC_G_2G 		0x00
+#define AIS328DQ_ACC_G_4G 		0x10
+#define AIS328DQ_ACC_G_8G 		0x30
+
+/* Accelerometer Sensor Operating Mode */
+#define AIS328DQ_ACC_ENABLE		0x01
+#define AIS328DQ_ACC_DISABLE		0x00
+#define AIS328DQ_ACC_PM_NORMAL		0x20
+#define AIS328DQ_ACC_PM_OFF		AIS328DQ_ACC_DISABLE
+
+#ifdef __KERNEL__
+
+#if defined(CONFIG_INPUT_AIS328DQ_SPI) || \
+    defined(CONFIG_INPUT_AIS328DQ_SPI_MODULE)
+#define AIS328DQ_RX_MAX_LENGTH	500
+#define AIS328DQ_TX_MAX_LENGTH	500
+
+struct ais328dq_transfer_buffer {
+	u8 rx_buf[AIS328DQ_RX_MAX_LENGTH];
+	u8 tx_buf[AIS328DQ_TX_MAX_LENGTH] ____cacheline_aligned;
+};
+#endif
+
+struct ais328dq_transfer_function {
+	int (*write)(struct device *dev, u8 reg_addr, int len, u8 *data);
+	int (*read)(struct device *dev, u8 addr, int len, u8 *data);
+};
+struct ais328dq_acc_platform_data {
+
+	int poll_interval;
+	int min_interval;
+
+	u8 g_range;
+
+	u8 axis_map_x;
+	u8 axis_map_y;
+	u8 axis_map_z;
+
+	u8 negate_x;
+	u8 negate_y;
+	u8 negate_z;
+
+	int (*init)(void);
+	void (*exit)(void);
+	int (*power_on)(void);
+	int (*power_off)(void);
+
+	/* set gpio_int[1,2] either to the choosen gpio pin number or to -EINVAL
+	 * if leaved unconnected
+	 */
+	int gpio_int1;
+	int gpio_int2;
+};
+
+#define	RESUME_ENTRIES		12
+
+struct ais328dq_acc_data {
+	const char *name;
+	struct device *dev;
+	u16 bus_type;
+	struct ais328dq_acc_platform_data *pdata;
+
+	struct mutex lock;
+	s64 timestamp, delta_ts;
+	struct hrtimer hr_timer;
+	struct workqueue_struct *work_queue;
+	struct work_struct poll_work;
+	struct input_dev *input_dev;
+
+	int hw_initialized;
+	/* hw_working=-1 means not tested yet */
+	int hw_working;
+	int selftest_enabled;
+
+	atomic_t enabled;
+
+	u8 sensitivity;
+
+	u8 resume_state[RESUME_ENTRIES];
+
+	int irq1;
+	struct work_struct irq1_work;
+	struct workqueue_struct *irq1_work_queue;
+	int irq2;
+	struct work_struct irq2_work;
+	struct workqueue_struct *irq2_work_queue;
+
+#ifdef AIS328DQ_DEBUG
+	u8 reg_addr;
+#endif
+#if defined(CONFIG_INPUT_AIS328DQ_SPI) || \
+    defined(CONFIG_INPUT_AIS328DQ_SPI_MODULE)
+	struct ais328dq_transfer_buffer tb;
+#endif
+	struct ais328dq_transfer_function *tf;
+};
+
+int ais328dq_acc_probe(struct ais328dq_acc_data *acc);
+int ais328dq_acc_remove(struct ais328dq_acc_data *acc);
+int ais328dq_acc_enable(struct ais328dq_acc_data *acc);
+int ais328dq_acc_disable(struct ais328dq_acc_data *acc);
+
+#endif /* __KERNEL__ */
+
+#endif  /* __AIS328DQ_H__ */

ais328dq_acc.c

@@ -0,0 +1,1224 @@
+/* Copyright (C) 2016 STMicroelectronics
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *
+ * File Name		: ais328dq_acc.c
+ * Authors		: VMA - Volume Mems & Analog Division
+ *			: Matteo Dameno (matteo.dameno@st.com)
+ *			: Lorenzo Bianconi (lorenzo.bianconi@st.com)
+ *			: Author is willing to be considered the contact
+ *			: and update point for the driver.
+ * Version		: V 1.0.1
+ * Date			: 2016/05/27
+ * Description		: AIS328DQ 3D accelerometer sensor LDD
+ *
+ ******************************************************************************
+ * Revision 1.0.0 2011/03/02
+ *	first release
+ * Revision 1.0.1 2012/10/07
+ *	corrects default permissions on sysfs files
+ *****************************************************************************/
+
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/input.h>
+#include <linux/uaccess.h>
+#include <linux/workqueue.h>
+#include <linux/irq.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+
+#include "ais328dq.h"
+
+#define SENSITIVITY_2G		1	/**	mg/LSB	*/
+#define SENSITIVITY_4G		2	/**	mg/LSB	*/
+#define SENSITIVITY_8G		4	/**	mg/LSB	*/
+
+#define AXISDATA_REG		0x28
+#define WHOAMI_AIS328DQ_ACC	0x32	/*	Expctd content for WAI	*/
+
+/*	CONTROL REGISTERS ADDRESSES	*/
+#define WHO_AM_I		0x0F	/*	WhoAmI register		*/
+#define CTRL_REG1		0x20	/*				*/
+#define CTRL_REG2		0x21	/*				*/
+#define CTRL_REG3		0x22	/*				*/
+#define CTRL_REG4		0x23	/*				*/
+#define	CTRL_REG5		0x24	/*				*/
+
+#define	INT_CFG1		0x30	/*	interrupt 1 config	*/
+#define	INT_SRC1		0x31	/*	interrupt 1 source	*/
+#define	INT_THS1		0x32	/*	interrupt 1 threshold	*/
+#define	INT_DUR1		0x33	/*	interrupt 1 duration	*/
+
+#define	INT_CFG2		0x34	/*	interrupt 2 config	*/
+#define	INT_SRC2		0x35	/*	interrupt 2 source	*/
+#define	INT_THS2		0x36	/*	interrupt 2 threshold	*/
+#define	INT_DUR2		0x37	/*	interrupt 2 duration	*/
+/*	end CONTROL REGISTRES ADDRESSES	*/
+
+#define AIS328DQ_ACC_ENABLE_ALL_AXES	0x07
+#define AIS328DQ_SELFTEST_EN		0x02
+#define AIS328DQ_SELFTEST_DIS		0x00
+#define AIS328DQ_SELFTEST_POS		0x00
+#define AIS328DQ_SELFTEST_NEG		0x08
+
+#define AIS328DQ_ACC_BDU_EN		0x80
+
+/* Accelerometer output data rate  */
+#define AIS328DQ_ACC_ODRHALF		0x40	/* 0.5Hz output data rate */
+#define AIS328DQ_ACC_ODR1		0x60	/* 1Hz output data rate */
+#define AIS328DQ_ACC_ODR2		0x80	/* 2Hz output data rate */
+#define AIS328DQ_ACC_ODR5		0xA0	/* 5Hz output data rate */
+#define AIS328DQ_ACC_ODR10		0xC0	/* 10Hz output data rate */
+#define AIS328DQ_ACC_ODR50		0x00	/* 50Hz output data rate */
+#define AIS328DQ_ACC_ODR100		0x08	/* 100Hz output data rate */
+#define AIS328DQ_ACC_ODR400		0x10	/* 400Hz output data rate */
+#define AIS328DQ_ACC_ODR1000		0x18	/* 1000Hz output data rate */
+
+/* RESUME STATE INDICES */
+#define	RES_CTRL_REG1		0
+#define	RES_CTRL_REG2		1
+#define	RES_CTRL_REG3		2
+#define	RES_CTRL_REG4		3
+#define	RES_CTRL_REG5		4
+#define	RES_REFERENCE		5
+
+#define	RES_INT_CFG1		6
+#define	RES_INT_THS1		7
+#define	RES_INT_DUR1		8
+#define	RES_INT_CFG2		9
+#define	RES_INT_THS2		10
+#define	RES_INT_DUR2		11
+
+/* end RESUME STATE INDICES */
+
+#define INPUT_EVENT_TYPE		EV_MSC
+#define INPUT_EVENT_X			MSC_SERIAL
+#define INPUT_EVENT_Y			MSC_PULSELED
+#define INPUT_EVENT_Z			MSC_GESTURE
+#define INPUT_EVENT_TIME_MSB		MSC_SCAN
+#define INPUT_EVENT_TIME_LSB		MSC_MAX
+
+#define MS_TO_NS(x)	((x)*1000000L)
+
+static struct {
+	unsigned int cutoff_ms;
+	unsigned int mask;
+} ais328dq_acc_odr_table[] = {
+	{1, AIS328DQ_ACC_PM_NORMAL | AIS328DQ_ACC_ODR1000},
+	{3, AIS328DQ_ACC_PM_NORMAL | AIS328DQ_ACC_ODR400},
+	{10, AIS328DQ_ACC_PM_NORMAL | AIS328DQ_ACC_ODR100},
+	{20, AIS328DQ_ACC_PM_NORMAL | AIS328DQ_ACC_ODR50},
+	/* low power settings, max low pass filter cut-off freq */
+	{100, AIS328DQ_ACC_ODR10 | AIS328DQ_ACC_ODR1000},
+	{200, AIS328DQ_ACC_ODR5 | AIS328DQ_ACC_ODR1000},
+	{5000, AIS328DQ_ACC_ODR2 | AIS328DQ_ACC_ODR1000 },
+	{1000, AIS328DQ_ACC_ODR1 | AIS328DQ_ACC_ODR1000 },
+	{2000, AIS328DQ_ACC_ODRHALF | AIS328DQ_ACC_ODR1000 },
+};
+
+static struct ais328dq_acc_platform_data def_pdata = {
+	.poll_interval = 100,
+	.min_interval = 1,
+	.g_range = 2,
+
+	.axis_map_x = 0,
+	.axis_map_y = 1,
+	.axis_map_z = 2,
+
+	.gpio_int1 = -1,
+	.gpio_int2 = -1,
+};
+
+static inline s64 ais328dq_get_time_ns(void)
+{
+	return ktime_to_ns(ktime_get_boottime());
+}
+
+static int ais328dq_acc_hw_init(struct ais328dq_acc_data *acc)
+{
+	int err = -1;
+	u8 buf[4];
+
+	printk(KERN_INFO "%s: hw init start\n", AIS328DQ_ACC_DEV_NAME);
+
+	err = acc->tf->read(acc->dev, WHO_AM_I, 1, buf);
+	if (err < 0){
+		dev_warn(acc->dev, "Error reading WHO_AM_I: is device "
+			"available/working?\n");
+		goto err_firstread;
+	} else
+		acc->hw_working = 1;
+	if (buf[0] != WHOAMI_AIS328DQ_ACC) {
+		dev_err(acc->dev,
+			"device unknown. Expected: 0x%x,"
+			" Replies: 0x%x\n", WHOAMI_AIS328DQ_ACC, buf[0]);
+		err = -1; /* choose the right coded error */
+		goto err_unknown_device;
+	}
+
+	buf[0] = acc->resume_state[RES_CTRL_REG1];
+	err = acc->tf->write(acc->dev, CTRL_REG1, 1, buf);
+	if (err < 0)
+		goto err_resume_state;
+
+	buf[0] = acc->resume_state[RES_INT_THS1];
+	buf[1] = acc->resume_state[RES_INT_DUR1];
+	err = acc->tf->write(acc->dev, INT_THS1, 2, buf);
+	if (err < 0)
+		goto err_resume_state;
+
+	buf[0] = acc->resume_state[RES_INT_CFG1];
+	err = acc->tf->write(acc->dev, INT_CFG1, 1, buf);
+	if (err < 0)
+		goto err_resume_state;
+
+	buf[0] = acc->resume_state[RES_INT_THS2];
+	buf[1] = acc->resume_state[RES_INT_DUR2];
+	err = acc->tf->write(acc->dev, INT_THS2, 2, buf);
+	if (err < 0)
+		goto err_resume_state;
+
+	buf[0] = acc->resume_state[RES_INT_CFG2];
+	err = acc->tf->write(acc->dev, INT_CFG2, 1, buf);
+	if (err < 0)
+		goto err_resume_state;
+
+	buf[0] = acc->resume_state[RES_CTRL_REG2];
+	buf[1] = acc->resume_state[RES_CTRL_REG3];
+	buf[2] = acc->resume_state[RES_CTRL_REG4];
+	buf[3] = acc->resume_state[RES_CTRL_REG5];
+	err = acc->tf->write(acc->dev, CTRL_REG2, 4, buf);
+	if (err < 0)
+		goto err_resume_state;
+
+	acc->hw_initialized = 1;
+	printk(KERN_INFO "%s: hw init done\n", AIS328DQ_ACC_DEV_NAME);
+	return 0;
+
+err_firstread:
+	acc->hw_working = 0;
+err_unknown_device:
+err_resume_state:
+	acc->hw_initialized = 0;
+	dev_err(acc->dev, "hw init error 0x%x,0x%x: %d\n", buf[0],
+			buf[1], err);
+	return err;
+}
+
+static void ais328dq_acc_device_power_off(struct ais328dq_acc_data *acc)
+{
+	int err;
+	u8 buf[1] = {AIS328DQ_ACC_PM_OFF};
+
+	err = acc->tf->write(acc->dev, CTRL_REG1, 1, buf);
+	if (err < 0)
+		dev_err(acc->dev, "soft power off failed: %d\n", err);
+
+	if (acc->pdata->power_off) {
+		if(acc->pdata->gpio_int1 >= 0)
+			disable_irq_nosync(acc->irq1);
+		if(acc->pdata->gpio_int2 >= 0)
+			disable_irq_nosync(acc->irq2);
+		acc->pdata->power_off();
+		acc->hw_initialized = 0;
+	}
+	if (acc->hw_initialized) {
+		if(acc->pdata->gpio_int1 >= 0)
+			disable_irq_nosync(acc->irq1);
+		if(acc->pdata->gpio_int2 >= 0)
+			disable_irq_nosync(acc->irq2);
+		acc->hw_initialized = 0;
+	}
+
+}
+
+static int ais328dq_acc_device_power_on(struct ais328dq_acc_data *acc)
+{
+	int err = -1;
+
+	if (acc->pdata->power_on) {
+		err = acc->pdata->power_on();
+		if (err < 0) {
+			dev_err(acc->dev,
+					"power_on failed: %d\n", err);
+			return err;
+		}
+		if(acc->pdata->gpio_int1 >= 0)
+			enable_irq(acc->irq1);
+		if(acc->pdata->gpio_int2 >= 0)
+			enable_irq(acc->irq2);
+	}
+
+	if (!acc->hw_initialized) {
+		err = ais328dq_acc_hw_init(acc);
+		if (acc->hw_working == 1 && err < 0) {
+			ais328dq_acc_device_power_off(acc);
+			return err;
+		}
+	}
+
+	if (acc->hw_initialized) {
+		if(acc->pdata->gpio_int1 >= 0)
+			enable_irq(acc->irq1);
+		if(acc->pdata->gpio_int2 >= 0)
+			enable_irq(acc->irq2);
+	}
+	return 0;
+}
+
+static irqreturn_t ais328dq_acc_isr1(int irq, void *dev)
+{
+	struct ais328dq_acc_data *acc = dev;
+
+	disable_irq_nosync(irq);
+	queue_work(acc->irq1_work_queue, &acc->irq1_work);
+	printk(KERN_INFO "%s: isr1 queued\n", AIS328DQ_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+
+static irqreturn_t ais328dq_acc_isr2(int irq, void *dev)
+{
+	struct ais328dq_acc_data *acc = dev;
+
+	disable_irq_nosync(irq);
+	queue_work(acc->irq2_work_queue, &acc->irq2_work);
+	printk(KERN_INFO "%s: isr2 queued\n", AIS328DQ_ACC_DEV_NAME);
+
+	return IRQ_HANDLED;
+}
+
+static void ais328dq_acc_irq1_work_func(struct work_struct *work)
+{
+
+	struct ais328dq_acc_data *acc =
+	container_of(work, struct ais328dq_acc_data, irq1_work);
+	/* TODO  add interrupt service procedure.
+		 ie:ais328dq_acc_get_int1_source(acc); */
+	;
+	/*  */
+	enable_irq(acc->irq1);
+}
+
+static void ais328dq_acc_irq2_work_func(struct work_struct *work)
+{
+
+	struct ais328dq_acc_data *acc =
+	container_of(work, struct ais328dq_acc_data, irq2_work);
+	/* TODO  add interrupt service procedure.
+		 ie:ais328dq_acc_get_tap_source(acc); */
+	;
+	/*  */
+
+	enable_irq(acc->irq2);
+}
+
+int ais328dq_acc_update_g_range(struct ais328dq_acc_data *acc, u8 range)
+{
+	int err = -1;
+
+	u8 sensitivity;
+	u8 buf[1];
+	u8 updated_val;
+	u8 init_val;
+	u8 new_val, new_g_range;
+	u8 mask = AIS328DQ_ACC_FS_MASK;
+
+	switch (range) {
+	case 2:
+		new_g_range = AIS328DQ_ACC_G_2G;
+		sensitivity = SENSITIVITY_2G;
+		break;
+	case 4:
+		new_g_range = AIS328DQ_ACC_G_4G;
+		sensitivity = SENSITIVITY_4G;
+		break;
+	case 8:
+		new_g_range = AIS328DQ_ACC_G_8G;
+		sensitivity = SENSITIVITY_8G;
+		break;
+	default:
+		dev_err(acc->dev, "invalid g range requested: %u\n", range);
+		return -EINVAL;
+	}
+
+	/* Set configuration register 4, which contains g range setting
+	 *  NOTE: this is a straight overwrite because this driver does
+	 *  not use any of the other configuration bits in this
+	 *  register.  Should this become untrue, we will have to read
+	 *  out the value and only change the relevant bits --XX----
+	 *  (marked by X) */
+	err = acc->tf->read(acc->dev, CTRL_REG4, 1, buf);
+	if (err < 0)
+		goto error;
+
+	init_val = buf[0];
+	new_val = new_g_range;
+	updated_val = ((mask & new_val) | ((~mask) & init_val));
+
+	if (atomic_read(&acc->enabled)) {
+		buf[0] = updated_val;
+		err = acc->tf->write(acc->dev, CTRL_REG4, 1, buf);
+		if (err < 0)
+			goto error;
+	}
+
+	acc->resume_state[RES_CTRL_REG4] = updated_val;
+	acc->sensitivity = sensitivity;
+
+	return 0;
+
+error:
+	dev_err(acc->dev, "update g range failed 0x%x: %d\n",
+		buf[0], err);
+
+	return err;
+}
+
+int ais328dq_acc_update_odr(struct ais328dq_acc_data *acc,
+			    int poll_interval_ms)
+{
+	int err = -1;
+	int i;
+	u8 config[1];
+
+	/* Following, looks for the longest possible odr interval scrolling the
+	 * odr_table vector from the end (shortest interval) backward (longest
+	 * interval), to support the poll_interval requested by the system.
+	 * It must be the longest interval lower then the poll interval.*/
+	for (i = ARRAY_SIZE(ais328dq_acc_odr_table) - 1; i >= 0; i--) {
+		if (ais328dq_acc_odr_table[i].cutoff_ms <= poll_interval_ms)
+			break;
+	}
+
+	config[0] = ais328dq_acc_odr_table[i].mask;
+	config[0] |= AIS328DQ_ACC_ENABLE_ALL_AXES;
+
+	/* If device is currently enabled, we need to write new
+	 *  configuration out to it */
+	if (atomic_read(&acc->enabled)) {
+		err = acc->tf->write(acc->dev, CTRL_REG1, 1, config);
+		if (err < 0)
+			goto error;
+	}
+	acc->resume_state[RES_CTRL_REG1] = config[0];
+	acc->delta_ts = MS_TO_NS(poll_interval_ms);
+
+	return err;
+
+error:
+	dev_err(acc->dev, "update odr failed 0x%x: %d\n",
+		config[0], err);
+
+	return err;
+}
+
+static int ais328dq_acc_register_update(struct ais328dq_acc_data *acc,
+			u8 *buf, u8 reg_address, u8 mask, u8 new_bit_values)
+{
+	int err = -1;
+	u8 init_val;
+	u8 updated_val;
+	err = acc->tf->read(acc->dev, reg_address, 1, buf);
+	if (!(err < 0)) {
+		init_val = buf[1];
+		updated_val = ((mask & new_bit_values) | (~mask & init_val));
+		err = acc->tf->write(acc->dev, reg_address, 1, &updated_val);
+	}
+
+	return err;
+}
+
+
+
+static int ais328dq_acc_selftest(struct ais328dq_acc_data *acc, u8 enable)
+{
+	int err = -1;
+	u8 buf[2]={0x00,0x00};
+	char reg_address, mask, bit_values;
+
+	reg_address = CTRL_REG4;
+	mask = 0x0A;
+	if (enable > 0)
+		bit_values = AIS328DQ_SELFTEST_EN |
+						AIS328DQ_SELFTEST_POS;
+	else
+		bit_values = AIS328DQ_SELFTEST_DIS |
+						AIS328DQ_SELFTEST_POS;
+	if (atomic_read(&acc->enabled)) {
+		mutex_lock(&acc->lock);
+		err = ais328dq_acc_register_update(acc, buf, reg_address,
+				mask, bit_values);
+		acc->selftest_enabled = enable;
+		mutex_unlock(&acc->lock);
+		if (err < 0)
+			return err;
+		acc->resume_state[RES_CTRL_REG4] = ((mask & bit_values) |
+				( ~mask & acc->resume_state[RES_CTRL_REG4]));
+	}
+	return err;
+}
+
+static int ais328dq_acc_get_acceleration_data(struct ais328dq_acc_data *acc,
+					       int *xyz)
+{
+	int err = -1;
+	/* Data bytes from hardware xL, xH, yL, yH, zL, zH */
+	u8 acc_data[6];
+	/* x,y,z hardware data */
+	s16 hw_d[3] = { 0 };
+
+	err = acc->tf->read(acc->dev, AXISDATA_REG, 6, acc_data);
+	if (err < 0)
+		return err;
+
+	hw_d[0] = (((s16) ((acc_data[1] << 8) | acc_data[0])) >> 4);
+	hw_d[1] = (((s16) ((acc_data[3] << 8) | acc_data[2])) >> 4);
+	hw_d[2] = (((s16) ((acc_data[5] << 8) | acc_data[4])) >> 4);
+
+	hw_d[0] = hw_d[0] * acc->sensitivity;
+	hw_d[1] = hw_d[1] * acc->sensitivity;
+	hw_d[2] = hw_d[2] * acc->sensitivity;
+
+	xyz[0] = ((acc->pdata->negate_x) ? (-hw_d[acc->pdata->axis_map_x])
+		  : (hw_d[acc->pdata->axis_map_x]));
+	xyz[1] = ((acc->pdata->negate_y) ? (-hw_d[acc->pdata->axis_map_y])
+		  : (hw_d[acc->pdata->axis_map_y]));
+	xyz[2] = ((acc->pdata->negate_z) ? (-hw_d[acc->pdata->axis_map_z])
+		  : (hw_d[acc->pdata->axis_map_z]));
+
+	return err;
+}
+
+static void ais328dq_acc_report_values(struct ais328dq_acc_data *acc,
+					int *xyz)
+{
+	input_event(acc->input_dev, INPUT_EVENT_TYPE, INPUT_EVENT_X,
+		    xyz[0]);
+	input_event(acc->input_dev, INPUT_EVENT_TYPE, INPUT_EVENT_Y,
+		    xyz[1]);
+	input_event(acc->input_dev, INPUT_EVENT_TYPE, INPUT_EVENT_Z,
+		    xyz[2]);
+	input_event(acc->input_dev, INPUT_EVENT_TYPE, INPUT_EVENT_TIME_MSB,
+		    acc->timestamp >> 32);
+	input_event(acc->input_dev, INPUT_EVENT_TYPE, INPUT_EVENT_TIME_LSB,
+		    acc->timestamp & 0xffffffff);
+	input_sync(acc->input_dev);
+}
+
+int ais328dq_acc_enable(struct ais328dq_acc_data *acc)
+{
+	if (!atomic_cmpxchg(&acc->enabled, 0, 1)) {
+		int err;
+
+		mutex_lock(&acc->lock);
+		err = ais328dq_acc_device_power_on(acc);
+		if (err < 0) {
+			atomic_set(&acc->enabled, 0);
+			mutex_unlock(&acc->lock);
+			return err;
+		}
+
+		hrtimer_start(&acc->hr_timer, ktime_set(0, acc->delta_ts),
+			      HRTIMER_MODE_REL);
+
+		mutex_unlock(&acc->lock);
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(ais328dq_acc_enable);
+
+int ais328dq_acc_disable(struct ais328dq_acc_data *acc)
+{
+	if (atomic_cmpxchg(&acc->enabled, 1, 0)) {
+		mutex_lock(&acc->lock);
+		ais328dq_acc_device_power_off(acc);
+		mutex_unlock(&acc->lock);
+
+		cancel_work_sync(&acc->poll_work);
+		hrtimer_cancel(&acc->hr_timer);
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(ais328dq_acc_disable);
+
+static ssize_t read_single_reg(struct device *dev, char *buf, u8 reg)
+{
+	u8 data;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	int rc = 0;
+
+	mutex_lock(&acc->lock);
+	rc = acc->tf->read(acc->dev, reg, 1, &data);
+	mutex_unlock(&acc->lock);
+
+	/*TODO: error need to be managed */
+	return sprintf(buf, "0x%02x\n", data);
+
+}
+
+static int write_reg(struct device *dev, const char *buf, u8 reg)
+{
+	int rc = 0;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	u8 x[1];
+	unsigned long val;
+
+	if (kstrtoul(buf, 16, &val))
+		return -EINVAL;
+
+	mutex_lock(&acc->lock);
+	x[0] = val;
+	rc = acc->tf->write(acc->dev, reg, 1, x);
+	mutex_unlock(&acc->lock);
+
+	/*TODO: error need to be managed */
+	return rc;
+}
+
+static ssize_t attr_get_polling_rate(struct device *dev,
+				     struct device_attribute *attr,
+				     char *buf)
+{
+	int val;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	mutex_lock(&acc->lock);
+	val = acc->pdata->poll_interval;
+	mutex_unlock(&acc->lock);
+	return sprintf(buf, "%d\n", val);
+}
+
+static ssize_t attr_set_polling_rate(struct device *dev,
+				     struct device_attribute *attr,
+				     const char *buf, size_t size)
+{
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	unsigned long interval_ms;
+
+	if (kstrtoul(buf, 10, &interval_ms))
+		return -EINVAL;
+	if (!interval_ms)
+		return -EINVAL;
+	mutex_lock(&acc->lock);
+	acc->pdata->poll_interval = interval_ms;
+	ais328dq_acc_update_odr(acc, interval_ms);
+	mutex_unlock(&acc->lock);
+
+	return size;
+}
+
+static ssize_t attr_get_range(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	char range = 2;
+
+	mutex_lock(&acc->lock);
+	range = acc->pdata->g_range ;
+	mutex_unlock(&acc->lock);
+
+	return sprintf(buf, "%d\n", range);
+}
+
+static ssize_t attr_set_range(struct device *dev,
+			      struct device_attribute *attr,
+			      const char *buf, size_t size)
+{
+	int err;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	unsigned long val;
+
+	if (kstrtoul(buf, 10, &val))
+		return -EINVAL;
+
+	mutex_lock(&acc->lock);
+	err = ais328dq_acc_update_g_range(acc, val);
+	if (err == 0)
+		acc->pdata->g_range = val;
+	mutex_unlock(&acc->lock);
+
+	return !err ? size : err;
+}
+
+static ssize_t attr_get_enable(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	int val = atomic_read(&acc->enabled);
+	return sprintf(buf, "%d\n", val);
+}
+
+static ssize_t attr_set_enable(struct device *dev,
+			       struct device_attribute *attr,
+			       const char *buf, size_t size)
+{
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	unsigned long val;
+
+	if (kstrtoul(buf, 10, &val))
+		return -EINVAL;
+
+	if (val)
+		ais328dq_acc_enable(acc);
+	else
+		ais328dq_acc_disable(acc);
+
+	return size;
+}
+
+static ssize_t attr_get_selftest(struct device *dev,
+			       struct device_attribute *attr, char *buf)
+{
+	int val;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	mutex_lock(&acc->lock);
+	val = acc->selftest_enabled;
+	mutex_unlock(&acc->lock);
+	return sprintf(buf, "%d\n", val);
+}
+
+static ssize_t attr_set_selftest(struct device *dev,
+			       struct device_attribute *attr,
+			       const char *buf, size_t size)
+{
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	unsigned long val;
+
+	if (kstrtoul(buf, 10, &val))
+		return -EINVAL;
+
+	ais328dq_acc_selftest(acc, val);
+
+	return size;
+}
+
+static ssize_t attr_set_intconfig1(struct device *dev,
+		struct device_attribute *attr,	const char *buf, size_t size)
+{
+	return write_reg(dev, buf, INT_CFG1);
+}
+
+static ssize_t attr_get_intconfig1(struct device *dev,
+		struct device_attribute *attr,	char *buf)
+{
+	return read_single_reg(dev, buf, INT_CFG1);
+}
+
+static ssize_t attr_set_duration1(struct device *dev,
+		struct device_attribute *attr,	const char *buf, size_t size)
+{
+	return write_reg(dev, buf, INT_DUR1);
+}
+
+static ssize_t attr_get_duration1(struct device *dev,
+		struct device_attribute *attr,	char *buf)
+{
+	return read_single_reg(dev, buf, INT_DUR1);
+}
+
+static ssize_t attr_set_thresh1(struct device *dev,
+		struct device_attribute *attr,	const char *buf, size_t size)
+{
+	return write_reg(dev, buf, INT_THS1);
+}
+
+static ssize_t attr_get_thresh1(struct device *dev,
+		struct device_attribute *attr,	char *buf)
+{
+	return read_single_reg(dev, buf, INT_THS1);
+}
+
+static ssize_t attr_get_source1(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	return read_single_reg(dev, buf, INT_SRC1);
+}
+
+static ssize_t attr_set_intconfig2(struct device *dev,
+		struct device_attribute *attr,	const char *buf, size_t size)
+{
+	return write_reg(dev, buf, INT_CFG2);
+}
+
+static ssize_t attr_get_intconfig2(struct device *dev,
+		struct device_attribute *attr,	char *buf)
+{
+	return read_single_reg(dev, buf, INT_CFG2);
+}
+
+static ssize_t attr_set_duration2(struct device *dev,
+		struct device_attribute *attr,	const char *buf, size_t size)
+{
+	return write_reg(dev, buf, INT_DUR2);
+}
+
+static ssize_t attr_get_duration2(struct device *dev,
+		struct device_attribute *attr,	char *buf)
+{
+	return read_single_reg(dev, buf, INT_DUR2);
+}
+
+static ssize_t attr_set_thresh2(struct device *dev,
+		struct device_attribute *attr,	const char *buf, size_t size)
+{
+	return write_reg(dev, buf, INT_THS2);
+}
+
+static ssize_t attr_get_thresh2(struct device *dev,
+		struct device_attribute *attr,	char *buf)
+{
+	return read_single_reg(dev, buf, INT_THS2);
+}
+static ssize_t attr_get_source2(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	return read_single_reg(dev, buf, INT_SRC2);
+}
+
+
+
+
+#ifdef AIS328DQ_DEBUG
+/* PAY ATTENTION: These AIS328DQ_DEBUG funtions don't manage resume_state */
+static ssize_t attr_reg_set(struct device *dev, struct device_attribute *attr,
+				const char *buf, size_t size)
+{
+	int rc;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	u8 x[2];
+	unsigned long val;
+
+	if (kstrtoul(buf, 16, &val))
+		return -EINVAL;
+	mutex_lock(&acc->lock);
+	x[0] = val;
+	rc = acc->tf->write(acc->dev, acc->reg_addr, 1, x);
+	mutex_unlock(&acc->lock);
+
+	/*TODO: error need to be managed */
+	return size;
+}
+
+static ssize_t attr_reg_get(struct device *dev, struct device_attribute *attr,
+				char *buf)
+{
+	ssize_t ret;
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	int rc;
+	u8 data;
+
+	mutex_lock(&acc->lock);
+	err = acc->tf->read(acc->dev, acc->reg_addr, 1, &data);
+	mutex_unlock(&acc->lock);
+
+	/*TODO: error need to be managed */
+	ret = sprintf(buf, "0x%02x\n", data);
+	return ret;
+}
+
+static ssize_t attr_addr_set(struct device *dev, struct device_attribute *attr,
+				const char *buf, size_t size)
+{
+	struct ais328dq_acc_data *acc = dev_get_drvdata(dev);
+	unsigned long val;
+	if (kstrtoul(buf, 16, &val))
+		return -EINVAL;
+	mutex_lock(&acc->lock);
+	acc->reg_addr = val;
+	mutex_unlock(&acc->lock);
+	return size;
+}
+#endif
+
+static struct device_attribute attributes[] = {
+
+	__ATTR(pollrate_ms, 0664, attr_get_polling_rate, attr_set_polling_rate),
+	__ATTR(range, 0664, attr_get_range, attr_set_range),
+	__ATTR(enable_device, 0664, attr_get_enable, attr_set_enable),
+	__ATTR(enable_selftest, 0664, attr_get_selftest, attr_set_selftest),
+	__ATTR(int1_config, 0664, attr_get_intconfig1, attr_set_intconfig1),
+	__ATTR(int1_duration, 0664, attr_get_duration1, attr_set_duration1),
+	__ATTR(int1_threshold, 0664, attr_get_thresh1, attr_set_thresh1),
+	__ATTR(int1_source, 0444, attr_get_source1, NULL),
+	__ATTR(int2_config, 0664, attr_get_intconfig2, attr_set_intconfig2),
+	__ATTR(int2_duration, 0664, attr_get_duration2, attr_set_duration2),
+	__ATTR(int2_threshold, 0664, attr_get_thresh2, attr_set_thresh2),
+	__ATTR(int2_source, 0444, attr_get_source2, NULL),
+#ifdef AIS328DQ_DEBUG
+	__ATTR(reg_value, 0600, attr_reg_get, attr_reg_set),
+	__ATTR(reg_addr, 0200, NULL, attr_addr_set),
+#endif
+};
+
+static int create_sysfs_interfaces(struct device *dev)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(attributes); i++)
+		if (device_create_file(dev, attributes + i))
+			goto error;
+	return 0;
+
+error:
+	for ( ; i >= 0; i--)
+		device_remove_file(dev, attributes + i);
+	dev_err(dev, "%s:Unable to create interface\n", __func__);
+	return -1;
+}
+
+static int remove_sysfs_interfaces(struct device *dev)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(attributes); i++)
+		device_remove_file(dev, attributes + i);
+	return 0;
+}
+
+static enum hrtimer_restart ais328dq_timer_poll(struct hrtimer *timer)
+{
+	struct ais328dq_acc_data *acc;
+
+	acc = container_of((struct hrtimer *)timer, struct ais328dq_acc_data,
+			    hr_timer);
+
+	acc->timestamp = ais328dq_get_time_ns();
+
+	queue_work(acc->work_queue, &acc->poll_work);
+
+	return HRTIMER_NORESTART;
+}
+
+static void ais328dq_poll_work_func(struct work_struct *work)
+{
+	struct ais328dq_acc_data *acc;
+	int xyz[3] = { 0 };
+	int err;
+	s64 ts, delta;
+
+	acc = container_of((struct work_struct *)work,
+			    struct ais328dq_acc_data, poll_work);
+
+	ts = ais328dq_get_time_ns();
+	delta = acc->delta_ts - (ts - acc->timestamp);
+	hrtimer_start(&acc->hr_timer, ktime_set(0, delta),
+		      HRTIMER_MODE_REL);
+
+	mutex_lock(&acc->lock);
+	err = ais328dq_acc_get_acceleration_data(acc, xyz);
+	if (err < 0)
+		dev_err(acc->dev, "get_acceleration_data failed\n");
+	else
+		ais328dq_acc_report_values(acc, xyz);
+
+	mutex_unlock(&acc->lock);
+}
+
+static int ais328dq_acc_validate_pdata(struct ais328dq_acc_data *acc)
+{
+	acc->pdata->poll_interval = max(acc->pdata->poll_interval,
+					acc->pdata->min_interval);
+
+	if (acc->pdata->axis_map_x > 2 ||
+	    acc->pdata->axis_map_y > 2 || acc->pdata->axis_map_z > 2) {
+		dev_err(acc->dev,
+			"invalid axis_map value x:%u y:%u z%u\n",
+			acc->pdata->axis_map_x, acc->pdata->axis_map_y,
+			acc->pdata->axis_map_z);
+		return -EINVAL;
+	}
+
+	/* Only allow 0 and 1 for negation boolean flag */
+	if (acc->pdata->negate_x > 1 || acc->pdata->negate_y > 1 ||
+	    acc->pdata->negate_z > 1) {
+		dev_err(acc->dev,
+			"invalid negate value x:%u y:%u z:%u\n",
+			acc->pdata->negate_x, acc->pdata->negate_y,
+			acc->pdata->negate_z);
+		return -EINVAL;
+	}
+
+	/* Enforce minimum polling interval */
+	if (acc->pdata->poll_interval < acc->pdata->min_interval) {
+		dev_err(acc->dev, "minimum poll interval violated\n");
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int ais328dq_acc_input_init(struct ais328dq_acc_data *acc)
+{
+	int err;
+
+	acc->work_queue = create_workqueue("ais328dq_wq");
+	if (!acc->work_queue)
+		return -ENOMEM;
+
+	hrtimer_init(&acc->hr_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+	acc->hr_timer.function = &ais328dq_timer_poll;
+
+	INIT_WORK(&acc->poll_work, ais328dq_poll_work_func);
+
+	acc->input_dev = input_allocate_device();
+	if (!acc->input_dev) {
+		err = -ENOMEM;
+		dev_err(acc->dev, "input device allocation failed\n");
+		goto err0;
+	}
+
+	acc->input_dev->name = AIS328DQ_ACC_DEV_NAME;
+	acc->input_dev->id.bustype = acc->bus_type;
+	acc->input_dev->dev.parent = acc->dev;
+
+	input_set_drvdata(acc->input_dev, acc);
+
+	set_bit(INPUT_EVENT_TYPE, acc->input_dev->evbit);
+	set_bit(INPUT_EVENT_X, acc->input_dev->mscbit);
+	set_bit(INPUT_EVENT_Y, acc->input_dev->mscbit);
+	set_bit(INPUT_EVENT_Z, acc->input_dev->mscbit);
+	set_bit(INPUT_EVENT_TIME_MSB, acc->input_dev->mscbit);
+	set_bit(INPUT_EVENT_TIME_LSB, acc->input_dev->mscbit);
+
+
+	err = input_register_device(acc->input_dev);
+	if (err) {
+		dev_err(acc->dev,
+			"unable to register input device %s\n",
+			acc->input_dev->name);
+		goto err1;
+	}
+
+	return 0;
+
+err1:
+	input_free_device(acc->input_dev);
+err0:
+	return err;
+}
+
+static void ais328dq_acc_input_cleanup(struct ais328dq_acc_data *acc)
+{
+	if (acc->work_queue) {
+		flush_workqueue(acc->work_queue);
+		destroy_workqueue(acc->work_queue);
+		acc->work_queue = NULL;
+	}
+	input_unregister_device(acc->input_dev);
+	input_free_device(acc->input_dev);
+}
+
+int ais328dq_acc_probe(struct ais328dq_acc_data *acc)
+{
+	int err = -1;
+
+	if (acc->dev->platform_data == NULL) {
+		dev_info(acc->dev,
+			 "platform data is NULL. using default one.\n");
+		acc->dev->platform_data = &def_pdata;
+	}
+
+	mutex_init(&acc->lock);
+	mutex_lock(&acc->lock);
+
+	acc->pdata = kmalloc(sizeof(*acc->pdata), GFP_KERNEL);
+	if (acc->pdata == NULL) {
+		err = -ENOMEM;
+		dev_err(acc->dev,
+				"failed to allocate memory for pdata: %d\n",
+				err);
+		goto err_mutexunlock;
+	}
+
+	memcpy(acc->pdata, acc->dev->platform_data, sizeof(*acc->pdata));
+
+	err = ais328dq_acc_validate_pdata(acc);
+	if (err < 0) {
+		dev_err(acc->dev, "failed to validate platform data\n");
+		goto exit_kfree_pdata;
+	}
+
+	if (acc->pdata->init) {
+		err = acc->pdata->init();
+		if (err < 0) {
+			dev_err(acc->dev, "init failed: %d\n", err);
+			goto err_pdata_init;
+		}
+	}
+
+	if(acc->pdata->gpio_int1 >= 0){
+		acc->irq1 = gpio_to_irq(acc->pdata->gpio_int1);
+		printk(KERN_INFO "%s: %s has set irq1 to irq: %d "
+							"mapped on gpio:%d\n",
+		AIS328DQ_ACC_DEV_NAME, __func__, acc->irq1,
+							acc->pdata->gpio_int1);
+	}
+
+	if(acc->pdata->gpio_int2 >= 0){
+		acc->irq2 = gpio_to_irq(acc->pdata->gpio_int2);
+		printk(KERN_INFO "%s: %s has set irq2 to irq: %d "
+						"mapped on gpio:%d\n",
+			AIS328DQ_ACC_DEV_NAME, __func__, acc->irq2,
+							acc->pdata->gpio_int2);
+	}
+
+	memset(acc->resume_state, 0, ARRAY_SIZE(acc->resume_state));
+
+	acc->resume_state[RES_CTRL_REG1] = AIS328DQ_ACC_ENABLE_ALL_AXES;
+	acc->resume_state[RES_CTRL_REG4] = AIS328DQ_ACC_BDU_EN;
+
+	err = ais328dq_acc_device_power_on(acc);
+	if (err < 0) {
+		dev_err(acc->dev, "power on failed: %d\n", err);
+		goto err_pdata_init;
+	}
+
+	atomic_set(&acc->enabled, 1);
+
+	err = ais328dq_acc_update_g_range(acc, acc->pdata->g_range);
+	if (err < 0) {
+		dev_err(acc->dev, "update_g_range failed\n");
+		goto err_power_off;
+	}
+
+	err = ais328dq_acc_update_odr(acc, acc->pdata->poll_interval);
+	if (err < 0) {
+		dev_err(acc->dev, "update_odr failed\n");
+		goto err_power_off;
+	}
+
+	err = ais328dq_acc_input_init(acc);
+	if (err < 0) {
+		dev_err(acc->dev, "input init failed\n");
+		goto err_power_off;
+	}
+
+
+	err = create_sysfs_interfaces(acc->dev);
+	if (err < 0) {
+		dev_err(acc->dev,
+			"device AIS328DQ_ACC_DEV_NAME "
+						"sysfs register failed\n");
+		goto err_input_cleanup;
+	}
+
+	ais328dq_acc_device_power_off(acc);
+
+	/* As default, do not report information */
+	atomic_set(&acc->enabled, 0);
+
+	if(acc->pdata->gpio_int1 >= 0){
+		INIT_WORK(&acc->irq1_work, ais328dq_acc_irq1_work_func);
+		acc->irq1_work_queue =
+			create_singlethread_workqueue("ais328dq_acc_wq1");
+		if (!acc->irq1_work_queue) {
+			err = -ENOMEM;
+			dev_err(acc->dev,
+					"cannot create work queue1: %d\n", err);
+			goto err_remove_sysfs_int;
+		}
+		err = request_irq(acc->irq1, ais328dq_acc_isr1,
+			IRQF_TRIGGER_RISING, "ais328dq_acc_irq1", acc);
+		if (err < 0) {
+			dev_err(acc->dev, "request irq1 failed: %d\n", err);
+			goto err_destoyworkqueue1;
+		}
+		disable_irq_nosync(acc->irq1);
+	}
+
+	if(acc->pdata->gpio_int2 >= 0){
+		INIT_WORK(&acc->irq2_work, ais328dq_acc_irq2_work_func);
+		acc->irq2_work_queue =
+			create_singlethread_workqueue("ais328dq_acc_wq2");
+		if (!acc->irq2_work_queue) {
+			err = -ENOMEM;
+			dev_err(acc->dev,
+				"cannot create work queue2: %d\n", err);
+			goto err_free_irq1;
+		}
+		err = request_irq(acc->irq2, ais328dq_acc_isr2,
+			IRQF_TRIGGER_RISING, "ais328dq_acc_irq2", acc);
+		if (err < 0) {
+			dev_err(acc->dev, "request irq2 failed: %d\n", err);
+				goto err_destoyworkqueue2;
+		}
+		disable_irq_nosync(acc->irq2);
+	}
+
+	mutex_unlock(&acc->lock);
+
+	return 0;
+
+err_destoyworkqueue2:
+	if(acc->pdata->gpio_int2 >= 0)
+		destroy_workqueue(acc->irq2_work_queue);
+err_free_irq1:
+	free_irq(acc->irq1, acc);
+err_destoyworkqueue1:
+	if(acc->pdata->gpio_int1 >= 0)
+		destroy_workqueue(acc->irq1_work_queue);
+err_remove_sysfs_int:
+	remove_sysfs_interfaces(acc->dev);
+err_input_cleanup:
+	ais328dq_acc_input_cleanup(acc);
+err_power_off:
+	ais328dq_acc_device_power_off(acc);
+err_pdata_init:
+	if (acc->pdata->exit)
+		acc->pdata->exit();
+exit_kfree_pdata:
+	kfree(acc->pdata);
+err_mutexunlock:
+	mutex_unlock(&acc->lock);
+
+	return err;
+}
+EXPORT_SYMBOL(ais328dq_acc_probe);
+
+int ais328dq_acc_remove(struct ais328dq_acc_data *acc)
+{
+	if (acc->pdata->gpio_int1 >= 0){
+		free_irq(acc->irq1, acc);
+		gpio_free(acc->pdata->gpio_int1);
+		destroy_workqueue(acc->irq1_work_queue);
+	}
+
+	if (acc->pdata->gpio_int2 >= 0){
+		free_irq(acc->irq2, acc);
+		gpio_free(acc->pdata->gpio_int2);
+		destroy_workqueue(acc->irq2_work_queue);
+	}
+
+	ais328dq_acc_input_cleanup(acc);
+	ais328dq_acc_device_power_off(acc);
+	remove_sysfs_interfaces(acc->dev);
+
+	if (acc->pdata->exit)
+		acc->pdata->exit();
+	kfree(acc->pdata);
+
+	return 0;
+}
+EXPORT_SYMBOL(ais328dq_acc_remove);
+
+MODULE_DESCRIPTION("ais328dq accelerometer sysfs driver");
+MODULE_AUTHOR("Matteo Dameno, STMicroelectronics");
+MODULE_AUTHOR("Lorenzo Bianconi, STMicroelectronics");
+MODULE_LICENSE("GPL v2");
+

ais328dq_i2c.c

@@ -0,0 +1,203 @@
+/******************** (C) COPYRIGHT 2016 STMicroelectronics ********************
+*
+* File Name	: ais328dq_i2c.c
+* Authors	: AMS - Motion Mems Division - Application Team - Application Team
+*		: Lorenzo Bianconi <lorenzo.bianconi@st.com>
+*		: Author is willing to be considered the contact and update
+* Version	: V.1.0.0
+* Date		: 2016/May/27
+*
+********************************************************************************
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License version 2 as
+* published by the Free Software Foundation.
+*
+* THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES
+* OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE
+* PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT.
+* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
+* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
+* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
+* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
+*
+*******************************************************************************/
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/types.h>
+#include <linux/input.h>
+#include <linux/delay.h>
+
+#include "ais328dq.h"
+
+#define I2C_AUTO_INCREMENT	0x80
+#define I2C_RETRIES		5
+#define I2C_RETRY_DELAY		5
+
+static int ais328dq_i2c_read(struct device *dev, u8 reg_addr,
+			     int len, u8 *data)
+{
+	int err = 0, tries = 0;
+	struct i2c_msg msg[2];
+	struct i2c_client *client = to_i2c_client(dev);
+
+	reg_addr |= ((len > 1) ? I2C_AUTO_INCREMENT : 0);
+
+	msg[0].addr = client->addr;
+	msg[0].flags = client->flags & I2C_M_TEN;
+	msg[0].len = 1;
+	msg[0].buf = &reg_addr;
+
+	msg[1].addr = client->addr;
+	msg[1].flags = (client->flags &I2C_M_TEN) | I2C_M_RD;
+	msg[1].len = len;
+	msg[1].buf = data;
+
+	do {
+		err = i2c_transfer(client->adapter, msg, 2);
+		if (err != 2)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while (err != 2 && ++tries < I2C_RETRIES);
+
+	return (err != 2) ? -EIO : err;
+}
+
+static int ais328dq_i2c_write(struct device *dev, u8 reg_addr,
+			      int len, u8 *data)
+{
+	int err = 0, tries = 0;
+	u8 send[len + 1];
+	struct i2c_msg msg;
+	struct i2c_client *client = to_i2c_client(dev);
+
+	reg_addr |= ((len > 1) ? I2C_AUTO_INCREMENT : 0);
+	send[0] = reg_addr;
+	memcpy(&send[1], data, len * sizeof(u8));
+	len++;
+
+	msg.addr = client->addr;
+	msg.flags = client->flags & I2C_M_TEN;
+	msg.len = len;
+	msg.buf = send;
+
+	do {
+		err = i2c_transfer(client->adapter, &msg, 1);
+		if (err != 1)
+			msleep_interruptible(I2C_RETRY_DELAY);
+	} while (err != 1 && ++tries < I2C_RETRIES);
+
+	return (err != 1) ? -EIO : err;
+}
+
+static struct ais328dq_transfer_function ais328dq_tf_i2c = {
+	.write = ais328dq_i2c_write,
+	.read = ais328dq_i2c_read,
+};
+
+static int ais328dq_i2c_probe(struct i2c_client *client,
+			      const struct i2c_device_id *id)
+{
+	int err;
+	struct ais328dq_acc_data *acc;
+
+	acc = kmalloc(sizeof(struct ais328dq_acc_data), GFP_KERNEL);
+	if (!acc)
+		return -ENOMEM;
+
+	acc->dev = &client->dev;
+	acc->name = client->name;
+	acc->bus_type = BUS_I2C;
+	acc->tf = &ais328dq_tf_i2c;
+	i2c_set_clientdata(client, acc);
+
+	err = ais328dq_acc_probe(acc);
+	if (err < 0)
+		goto free_data;
+
+	return 0;
+
+free_data:
+	kfree(acc);
+	return err;
+}
+
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
+static void ais328dq_i2c_remove(struct i2c_client *client)
+{
+	struct ais328dq_acc_data *acc = i2c_get_clientdata(client);
+
+	ais328dq_acc_remove(acc);
+	kfree(acc);
+}
+#else
+static int ais328dq_i2c_remove(struct i2c_client *client)
+{
+	struct ais328dq_acc_data *acc = i2c_get_clientdata(client);
+
+	ais328dq_acc_remove(acc);
+	kfree(acc);
+
+	return 0;
+}
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+static int ais328dq_suspend(struct device *dev)
+{
+	struct ais328dq_acc_data *acc = i2c_get_clientdata(to_i2c_client(dev));
+
+	return ais328dq_acc_disable(acc);
+}
+
+static int ais328dq_resume(struct device *dev)
+{
+	struct ais328dq_acc_data *acc = i2c_get_clientdata(to_i2c_client(dev));
+
+	return ais328dq_acc_enable(acc);
+}
+
+static SIMPLE_DEV_PM_OPS(ais328dq_pm_ops,
+			ais328dq_suspend,
+			ais328dq_resume);
+
+#define AIS328DQ_PM_OPS		(&ais328dq_pm_ops)
+#else /* CONFIG_PM_SLEEP */
+#define AIS328DQ_PM_OPS		NULL
+#endif /* CONFIG_PM_SLEEP */
+
+static const struct i2c_device_id ais328dq_ids[] = {
+	{ AIS328DQ_ACC_DEV_NAME, 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, ais328dq_ids);
+
+#ifdef CONFIG_OF
+static const struct of_device_id ais328dq_id_table[] = {
+	{ .compatible = "st,ais328dq", },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, ais328dq_id_table);
+#endif
+
+static struct i2c_driver ais328dq_i2c_driver = {
+	.driver = {
+		.owner = THIS_MODULE,
+		.name = AIS328DQ_ACC_DEV_NAME,
+		.pm = AIS328DQ_PM_OPS,
+#ifdef CONFIG_OF
+		.of_match_table = ais328dq_id_table,
+#endif
+	},
+	.remove = ais328dq_i2c_remove,
+	.probe = ais328dq_i2c_probe,
+	.id_table = ais328dq_ids,
+};
+
+module_i2c_driver(ais328dq_i2c_driver);
+
+MODULE_DESCRIPTION("STMicroelectronics ais328dq i2c driver");
+MODULE_AUTHOR("Lorenzo Bianconi");
+MODULE_LICENSE("GPL v2");

ais328dq_spi.c

@@ -0,0 +1,215 @@
+/*
+ * STMicroelectronics ais328dq_spi driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+#include <linux/slab.h>
+#include <linux/spi/spi.h>
+#include <linux/input.h>
+#include <linux/module.h>
+#include <linux/version.h>
+
+#include "ais328dq.h"
+
+#define SENSORS_SPI_READ	0x80
+#define SPI_AUTO_INCREMENT	0x40
+
+/* XXX: caller must hold cdata->lock */
+static int ais328dq_spi_read(struct device *device, u8 addr,
+				    int len, u8 *data)
+{
+	int err;
+	struct spi_message msg;
+	struct spi_device *spi = to_spi_device(device);
+	struct ais328dq_acc_data *acc = spi_get_drvdata(spi);
+
+	struct spi_transfer xfers[] = {
+		{
+			.tx_buf = acc->tb.tx_buf,
+			.bits_per_word = 8,
+			.len = 1,
+		},
+		{
+			.rx_buf = acc->tb.rx_buf,
+			.bits_per_word = 8,
+			.len = len,
+		}
+	};
+
+	if (len > 1)
+		addr |= SPI_AUTO_INCREMENT;
+
+	acc->tb.tx_buf[0] = addr | SENSORS_SPI_READ;
+
+	spi_message_init(&msg);
+	spi_message_add_tail(&xfers[0], &msg);
+	spi_message_add_tail(&xfers[1], &msg);
+
+	err = spi_sync(spi, &msg);
+	if (err)
+		return err;
+
+	memcpy(data, acc->tb.rx_buf, len * sizeof(u8));
+
+	return len;
+}
+
+/* XXX: caller must hold cdata->lock */
+static int ais328dq_spi_write(struct device *device, u8 addr,
+				     int len, u8 *data)
+{
+	struct spi_message msg;
+	struct spi_device *spi = to_spi_device(device);
+	struct ais328dq_acc_data *acc = spi_get_drvdata(spi);
+
+	struct spi_transfer xfers = {
+		.tx_buf = acc->tb.tx_buf,
+		.bits_per_word = 8,
+		.len = len + 1,
+	};
+
+	if (len >= AIS328DQ_TX_MAX_LENGTH)
+		return -ENOMEM;
+
+	if (len > 1)
+		addr |= SPI_AUTO_INCREMENT;
+
+	acc->tb.tx_buf[0] = addr;
+
+	memcpy(&acc->tb.tx_buf[1], data, len);
+
+	spi_message_init(&msg);
+	spi_message_add_tail(&xfers, &msg);
+	return spi_sync(spi, &msg);
+}
+
+static struct ais328dq_transfer_function ais328dq_spi_tf = {
+	.write = ais328dq_spi_write,
+	.read = ais328dq_spi_read,
+};
+
+#ifdef CONFIG_PM_SLEEP
+static int ais328dq_resume(struct device *device)
+{
+	struct spi_device *spi = to_spi_device(device);
+	struct ais328dq_acc_data *acc = spi_get_drvdata(spi);
+
+	return ais328dq_acc_enable(acc);
+}
+
+static int ais328dq_suspend(struct device *device)
+{
+	struct spi_device *spi = to_spi_device(device);
+	struct ais328dq_acc_data *acc = spi_get_drvdata(spi);
+
+	return ais328dq_acc_disable(acc);
+}
+
+static SIMPLE_DEV_PM_OPS(ais328dq_pm_ops,
+			ais328dq_suspend,
+			ais328dq_resume);
+
+#define AIS328DQ_PM_OPS		(&ais328dq_pm_ops)
+#else /* CONFIG_PM_SLEEP */
+#define AIS328DQ_PM_OPS		NULL
+#endif /* CONFIG_PM_SLEEP */
+
+static int ais328dq_spi_probe(struct spi_device *spi)
+{
+	int err;
+	struct ais328dq_acc_data *acc;
+
+#ifdef AIS328DQ_DEBUG
+	dev_info(&spi->dev, "probe start.\n");
+#endif
+
+	/* Alloc Common data structure */
+	acc = kzalloc(sizeof(struct ais328dq_acc_data), GFP_KERNEL);
+	if (!acc) {
+		dev_err(&spi->dev, "failed to allocate module data\n");
+		return -ENOMEM;
+	}
+
+	acc->name = spi->modalias;
+	acc->bus_type = BUS_SPI;
+	acc->tf = &ais328dq_spi_tf;
+	acc->dev = &spi->dev;
+	spi_set_drvdata(spi, acc);
+
+	mutex_init(&acc->lock);
+
+	err = ais328dq_acc_probe(acc);
+	if (err < 0) {
+		kfree(acc);
+		return err;
+	}
+
+	return 0;
+}
+
+#if KERNEL_VERSION(5, 18, 0) <= LINUX_VERSION_CODE
+static void ais328dq_spi_remove(struct spi_device *spi)
+{
+	struct ais328dq_acc_data *acc = spi_get_drvdata(spi);
+
+#ifdef AIS328DQ_DEBUG
+	dev_info(acc->dev, "driver removing\n");
+#endif
+
+	ais328dq_acc_remove(acc);
+	kfree(acc);
+}
+#else
+static int ais328dq_spi_remove(struct spi_device *spi)
+{
+	struct ais328dq_acc_data *acc = spi_get_drvdata(spi);
+
+#ifdef AIS328DQ_DEBUG
+	dev_info(acc->dev, "driver removing\n");
+#endif
+
+	ais328dq_acc_remove(acc);
+	kfree(acc);
+
+	return 0;
+}
+#endif
+
+static const struct spi_device_id ais328dq_spi_id[] = {
+	{ "ais328dq", 0 },
+	{ },
+};
+MODULE_DEVICE_TABLE(spi, ais328dq_spi_id);
+
+#ifdef CONFIG_OF
+static const struct of_device_id ais328dq_spi_id_table[] = {
+	{ .compatible = "st,ais328dq" },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, ais328dq_spi_id_table);
+#endif /* CONFIG_OF */
+
+static struct spi_driver ais328dq_spi_driver = {
+	.driver = {
+		.owner = THIS_MODULE,
+		.name = "ais328dq_spi",
+		.pm = AIS328DQ_PM_OPS,
+#ifdef CONFIG_OF
+		.of_match_table = ais328dq_spi_id_table,
+#endif /* CONFIG_OF */
+	},
+	.probe = ais328dq_spi_probe,
+	.remove = ais328dq_spi_remove,
+	.id_table = ais328dq_spi_id,
+};
+
+module_spi_driver(ais328dq_spi_driver);
+
+MODULE_DESCRIPTION("ais328dq acc spi driver");
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
+MODULE_LICENSE("GPL v2");
+