drivers/hwmon/mxc_mma8451.c - linux-imx - Git at Google

 /*
  *  mma8451.c - Linux kernel modules for 3-Axis Orientation/Motion
  *  Detection Sensor
  *
  *  Copyright (C) 2010-2014 Freescale Semiconductor, Inc. All Rights Reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  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.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */

 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/i2c.h>
 #include <linux/pm.h>
 #include <linux/mutex.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
 #include <linux/hwmon.h>
 #include <linux/input-polldev.h>
 #include <linux/of.h>
 #include <linux/regulator/consumer.h>

 #define MMA8451_I2C_ADDR	0x1C
 #define MMA8451_ID		0x1A
 #define MMA8452_ID		0x2A
 #define MMA8453_ID		0x3A

 #define POLL_INTERVAL_MIN	1
 #define POLL_INTERVAL_MAX	500
 #define POLL_INTERVAL		100	/* msecs */
 #define INPUT_FUZZ		32
 #define INPUT_FLAT		32
 #define MODE_CHANGE_DELAY_MS	100

 #define MMA8451_STATUS_ZYXDR	0x08
 #define MMA8451_BUF_SIZE	7
 #define DEFAULT_POSITION	0

 /* register enum for mma8451 registers */
 enum {
 	MMA8451_STATUS = 0x00,
 	MMA8451_OUT_X_MSB,
 	MMA8451_OUT_X_LSB,
 	MMA8451_OUT_Y_MSB,
 	MMA8451_OUT_Y_LSB,
 	MMA8451_OUT_Z_MSB,
 	MMA8451_OUT_Z_LSB,

 	MMA8451_F_SETUP = 0x09,
 	MMA8451_TRIG_CFG,
 	MMA8451_SYSMOD,
 	MMA8451_INT_SOURCE,
 	MMA8451_WHO_AM_I,
 	MMA8451_XYZ_DATA_CFG,
 	MMA8451_HP_FILTER_CUTOFF,

 	MMA8451_PL_STATUS,
 	MMA8451_PL_CFG,
 	MMA8451_PL_COUNT,
 	MMA8451_PL_BF_ZCOMP,
 	MMA8451_P_L_THS_REG,

 	MMA8451_FF_MT_CFG,
 	MMA8451_FF_MT_SRC,
 	MMA8451_FF_MT_THS,
 	MMA8451_FF_MT_COUNT,

 	MMA8451_TRANSIENT_CFG = 0x1D,
 	MMA8451_TRANSIENT_SRC,
 	MMA8451_TRANSIENT_THS,
 	MMA8451_TRANSIENT_COUNT,

 	MMA8451_PULSE_CFG,
 	MMA8451_PULSE_SRC,
 	MMA8451_PULSE_THSX,
 	MMA8451_PULSE_THSY,
 	MMA8451_PULSE_THSZ,
 	MMA8451_PULSE_TMLT,
 	MMA8451_PULSE_LTCY,
 	MMA8451_PULSE_WIND,

 	MMA8451_ASLP_COUNT,
 	MMA8451_CTRL_REG1,
 	MMA8451_CTRL_REG2,
 	MMA8451_CTRL_REG3,
 	MMA8451_CTRL_REG4,
 	MMA8451_CTRL_REG5,

 	MMA8451_OFF_X,
 	MMA8451_OFF_Y,
 	MMA8451_OFF_Z,

 	MMA8451_REG_END,
 };

 /* The sensitivity is represented in counts/g. In 2g mode the
 sensitivity is 1024 counts/g. In 4g mode the sensitivity is 512
 counts/g and in 8g mode the sensitivity is 256 counts/g.
  */
 enum {
 	MODE_2G = 0,
 	MODE_4G,
 	MODE_8G,
 };

 enum {
 	MMA_STANDBY = 0,
 	MMA_ACTIVED,
 };

 /* mma8451 status */
 struct mma8451_status {
 	u8 mode;
 	u8 ctl_reg1;
 	int active;
 	int position;
 };

 static struct mma8451_status mma_status;
 static struct input_polled_dev *mma8451_idev;
 static struct device *hwmon_dev;
 static struct i2c_client *mma8451_i2c_client;

 static int senstive_mode = MODE_2G;
 static int ACCHAL[8][3][3] = {
 	{ {0, -1, 0}, {1, 0, 0}, {0, 0, 1} },
 	{ {-1, 0, 0}, {0, -1, 0}, {0, 0, 1} },
 	{ {0, 1, 0}, {-1, 0, 0}, {0, 0, 1} },
 	{ {1, 0, 0}, {0, 1, 0}, {0, 0, 1} },

 	{ {0, -1, 0}, {-1, 0, 0}, {0, 0, -1} },
 	{ {-1, 0, 0}, {0, 1, 0}, {0, 0, -1} },
 	{ {0, 1, 0}, {1, 0, 0}, {0, 0, -1} },
 	{ {1, 0, 0}, {0, -1, 0}, {0, 0, -1} },
 };

 static DEFINE_MUTEX(mma8451_lock);
 static int mma8451_adjust_position(short *x, short *y, short *z)
 {
 	short rawdata[3], data[3];
 	int i, j;
 	int position = mma_status.position;
 	if (position < 0 || position > 7)
 		position = 0;
 	rawdata[0] = *x;
 	rawdata[1] = *y;
 	rawdata[2] = *z;
 	for (i = 0; i < 3; i++) {
 		data[i] = 0;
 		for (j = 0; j < 3; j++)
 			data[i] += rawdata[j] * ACCHAL[position][i][j];
 	}
 	*x = data[0];
 	*y = data[1];
 	*z = data[2];
 	return 0;
 }

 static int mma8451_change_mode(struct i2c_client *client, int mode)
 {
 	int result;

 	mma_status.ctl_reg1 = 0;
 	result = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1, 0);
 	if (result < 0)
 		goto out;
 	mma_status.active = MMA_STANDBY;

 	result = i2c_smbus_write_byte_data(client, MMA8451_XYZ_DATA_CFG,
 					   mode);
 	if (result < 0)
 		goto out;
 	mdelay(MODE_CHANGE_DELAY_MS);
 	mma_status.mode = mode;

 	return 0;
 out:
 	dev_err(&client->dev, "error when init mma8451:(%d)", result);
 	return result;
 }

 static int mma8451_read_data(short *x, short *y, short *z)
 {
 	u8 tmp_data[MMA8451_BUF_SIZE];
 	int ret;

 	ret = i2c_smbus_read_i2c_block_data(mma8451_i2c_client,
 					    MMA8451_OUT_X_MSB, 7, tmp_data);
 	if (ret < MMA8451_BUF_SIZE) {
 		dev_err(&mma8451_i2c_client->dev, "i2c block read failed\n");
 		return -EIO;
 	}

 	*x = ((tmp_data[0] << 8) & 0xff00) | tmp_data[1];
 	*y = ((tmp_data[2] << 8) & 0xff00) | tmp_data[3];
 	*z = ((tmp_data[4] << 8) & 0xff00) | tmp_data[5];
 	return 0;
 }

 static void report_abs(void)
 {
 	short x, y, z;
 	int result;
 	int retry = 3;

 	mutex_lock(&mma8451_lock);
 	if (mma_status.active == MMA_STANDBY)
 		goto out;
 	/* wait for the data ready */
 	do {
 		result = i2c_smbus_read_byte_data(mma8451_i2c_client,
 						  MMA8451_STATUS);
 		retry--;
 		msleep(1);
 	} while (!(result & MMA8451_STATUS_ZYXDR) && retry > 0);
 	if (retry == 0)
 		goto out;
 	if (mma8451_read_data(&x, &y, &z) != 0)
 		goto out;
 	mma8451_adjust_position(&x, &y, &z);
 	input_report_abs(mma8451_idev->input, ABS_X, x);
 	input_report_abs(mma8451_idev->input, ABS_Y, y);
 	input_report_abs(mma8451_idev->input, ABS_Z, z);
 	input_sync(mma8451_idev->input);
 out:
 	mutex_unlock(&mma8451_lock);
 }

 static void mma8451_dev_poll(struct input_polled_dev *dev)
 {
 	report_abs();
 }

 static ssize_t mma8451_enable_show(struct device *dev,
 				   struct device_attribute *attr, char *buf)
 {
 	struct i2c_client *client;
 	u8 val;
 	int enable;

 	mutex_lock(&mma8451_lock);
 	client = mma8451_i2c_client;
 	val = i2c_smbus_read_byte_data(client, MMA8451_CTRL_REG1);
 	if ((val & 0x01) && mma_status.active == MMA_ACTIVED)
 		enable = 1;
 	else
 		enable = 0;
 	mutex_unlock(&mma8451_lock);
 	return sprintf(buf, "%d\n", enable);
 }

 static ssize_t mma8451_enable_store(struct device *dev,
 				    struct device_attribute *attr,
 				    const char *buf, size_t count)
 {
 	struct i2c_client *client;
 	int ret;
 	unsigned long enable;
 	u8 val = 0;

 	ret = kstrtoul(buf, 10, &enable);
 	if (ret) {
 		dev_err(dev, "string transform error\n");
 		return ret;
 	}

 	mutex_lock(&mma8451_lock);
 	client = mma8451_i2c_client;
 	enable = (enable > 0) ? 1 : 0;
 	if (enable && mma_status.active == MMA_STANDBY) {
 		val = i2c_smbus_read_byte_data(client, MMA8451_CTRL_REG1);
 		ret =
 		    i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
 					      val | 0x01);
 		if (!ret)
 			mma_status.active = MMA_ACTIVED;

 	} else if (enable == 0 && mma_status.active == MMA_ACTIVED) {
 		val = i2c_smbus_read_byte_data(client, MMA8451_CTRL_REG1);
 		ret =
 		    i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
 					      val & 0xFE);
 		if (!ret)
 			mma_status.active = MMA_STANDBY;

 	}
 	mutex_unlock(&mma8451_lock);
 	return count;
 }

 static ssize_t mma8451_position_show(struct device *dev,
 				     struct device_attribute *attr, char *buf)
 {
 	int position = 0;
 	mutex_lock(&mma8451_lock);
 	position = mma_status.position;
 	mutex_unlock(&mma8451_lock);
 	return sprintf(buf, "%d\n", position);
 }

 static ssize_t mma8451_position_store(struct device *dev,
 				      struct device_attribute *attr,
 				      const char *buf, size_t count)
 {
 	unsigned long  position;
 	int ret;
 	ret = kstrtoul(buf, 10, &position);
 	if (ret) {
 		dev_err(dev, "string transform error\n");
 		return ret;
 	}

 	mutex_lock(&mma8451_lock);
 	mma_status.position = (int)position;
 	mutex_unlock(&mma8451_lock);
 	return count;
 }

 static ssize_t mma8451_scalemode_show(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
 	int mode = 0;
 	mutex_lock(&mma8451_lock);
 	mode = (int)mma_status.mode;
 	mutex_unlock(&mma8451_lock);

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

 static ssize_t mma8451_scalemode_store(struct device *dev,
 					struct device_attribute *attr,
 					const char *buf, size_t count)
 {
 	unsigned long  mode;
 	int ret, active_save;
 	struct i2c_client *client = mma8451_i2c_client;

 	ret = kstrtoul(buf, 10, &mode);
 	if (ret) {
 		dev_err(dev, "string transform error\n");
 		goto out;
 	}

 	if (mode > MODE_8G) {
 		dev_warn(dev, "not supported mode\n");
 		ret = count;
 		goto out;
 	}

 	mutex_lock(&mma8451_lock);
 	if (mode == mma_status.mode) {
 		ret = count;
 		goto out_unlock;
 	}

 	active_save = mma_status.active;
 	ret = mma8451_change_mode(client, mode);
 	if (ret)
 		goto out_unlock;

 	if (active_save == MMA_ACTIVED) {
 		ret = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1, 1);

 		if (ret)
 			goto out_unlock;
 		mma_status.active = active_save;
 	}

 out_unlock:
 	mutex_unlock(&mma8451_lock);
 out:
 	return ret;
 }

 static DEVICE_ATTR(enable, S_IWUSR | S_IRUGO,
 			mma8451_enable_show, mma8451_enable_store);
 static DEVICE_ATTR(position, S_IWUSR | S_IRUGO,
 			mma8451_position_show, mma8451_position_store);
 static DEVICE_ATTR(scalemode, S_IWUSR | S_IRUGO,
 			mma8451_scalemode_show, mma8451_scalemode_store);

 static struct attribute *mma8451_attributes[] = {
 	&dev_attr_enable.attr,
 	&dev_attr_position.attr,
 	&dev_attr_scalemode.attr,
 	NULL
 };

 static const struct attribute_group mma8451_attr_group = {
 	.attrs = mma8451_attributes,
 };

 static int mma8451_probe(struct i2c_client *client,
 				   const struct i2c_device_id *id)
 {
 	int result, client_id;
 	struct input_dev *idev;
 	struct i2c_adapter *adapter;
 	u32 pos;
 	struct device_node *of_node = client->dev.of_node;
 	struct regulator *vdd, *vdd_io;

 	mma8451_i2c_client = client;

 	vdd = devm_regulator_get(&client->dev, "vdd");
 	if (!IS_ERR(vdd)) {
 		result = regulator_enable(vdd);
 		if (result) {
 			dev_err(&client->dev, "vdd set voltage error\n");
 			return result;
 		}
 	}

 	vdd_io = devm_regulator_get(&client->dev, "vddio");
 	if (!IS_ERR(vdd_io)) {
 		result = regulator_enable(vdd_io);
 		if (result) {
 			dev_err(&client->dev, "vddio set voltage error\n");
 			return result;
 		}
 	}

 	adapter = to_i2c_adapter(client->dev.parent);
 	result = i2c_check_functionality(adapter,
 					 I2C_FUNC_SMBUS_BYTE |
 					 I2C_FUNC_SMBUS_BYTE_DATA);
 	if (!result)
 		goto err_out;

 	client_id = i2c_smbus_read_byte_data(client, MMA8451_WHO_AM_I);
 	if (client_id != MMA8451_ID && client_id != MMA8452_ID
 	    && client_id != MMA8453_ID) {
 		dev_err(&client->dev,
 			"read chip ID 0x%x is not equal to 0x%x or 0x%x!\n",
 			result, MMA8451_ID, MMA8452_ID);
 		result = -EINVAL;
 		goto err_out;
 	}

 	/* Initialize the MMA8451 chip */
 	result = mma8451_change_mode(client, senstive_mode);
 	if (result) {
 		dev_err(&client->dev,
 			"error when init mma8451 chip:(%d)\n", result);
 		goto err_out;
 	}

 	hwmon_dev = hwmon_device_register(&client->dev);
 	if (!hwmon_dev) {
 		result = -ENOMEM;
 		dev_err(&client->dev, "error when register hwmon device\n");
 		goto err_out;
 	}

 	mma8451_idev = input_allocate_polled_device();
 	if (!mma8451_idev) {
 		result = -ENOMEM;
 		dev_err(&client->dev, "alloc poll device failed!\n");
 		goto err_alloc_poll_device;
 	}
 	mma8451_idev->poll = mma8451_dev_poll;
 	mma8451_idev->poll_interval = POLL_INTERVAL;
 	mma8451_idev->poll_interval_min = POLL_INTERVAL_MIN;
 	mma8451_idev->poll_interval_max = POLL_INTERVAL_MAX;
 	idev = mma8451_idev->input;
 	idev->name = "mma845x";
 	idev->id.bustype = BUS_I2C;
 	idev->evbit[0] = BIT_MASK(EV_ABS);

 	input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
 	input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
 	input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);

 	result = input_register_polled_device(mma8451_idev);
 	if (result) {
 		dev_err(&client->dev, "register poll device failed!\n");
 		goto err_register_polled_device;
 	}
 	result = sysfs_create_group(&idev->dev.kobj, &mma8451_attr_group);
 	if (result) {
 		dev_err(&client->dev, "create device file failed!\n");
 		result = -EINVAL;
 		goto err_register_polled_device;
 	}

 	result = of_property_read_u32(of_node, "position", &pos);
 	if (result)
 		pos = DEFAULT_POSITION;
 	mma_status.position = (int)pos;

 	return 0;
 err_register_polled_device:
 	input_free_polled_device(mma8451_idev);
 err_alloc_poll_device:
 	hwmon_device_unregister(&client->dev);
 err_out:
 	return result;
 }

 static int mma8451_stop_chip(struct i2c_client *client)
 {
 	int ret = 0;
 	if (mma_status.active == MMA_ACTIVED) {
 		mma_status.ctl_reg1 = i2c_smbus_read_byte_data(client,
 							       MMA8451_CTRL_REG1);
 		ret = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
 						mma_status.ctl_reg1 & 0xFE);
 	}
 	return ret;
 }

 static int mma8451_remove(struct i2c_client *client)
 {
 	int ret;
 	ret = mma8451_stop_chip(client);
 	hwmon_device_unregister(hwmon_dev);

 	return ret;
 }

 #ifdef CONFIG_PM_SLEEP
 static int mma8451_suspend(struct device *dev)
 {
 	struct i2c_client *client = to_i2c_client(dev);

 	return mma8451_stop_chip(client);
 }

 static int mma8451_resume(struct device *dev)
 {
 	int ret = 0;
 	struct i2c_client *client = to_i2c_client(dev);
 	if (mma_status.active == MMA_ACTIVED)
 		ret = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
 						mma_status.ctl_reg1);
 	return ret;

 }
 #endif

 static const struct i2c_device_id mma8451_id[] = {
 	{"mma8451", 0},
 	{ /* sentinel */ }
 };

 MODULE_DEVICE_TABLE(i2c, mma8451_id);

 static SIMPLE_DEV_PM_OPS(mma8451_pm_ops, mma8451_suspend, mma8451_resume);
 static struct i2c_driver mma8451_driver = {
 	.driver = {
 		   .name = "mma8451",
 		   .owner = THIS_MODULE,
 		   .pm = &mma8451_pm_ops,
 		   },
 	.probe = mma8451_probe,
 	.remove = mma8451_remove,
 	.id_table = mma8451_id,
 };

 static int __init mma8451_init(void)
 {
 	/* register driver */
 	int res;

 	res = i2c_add_driver(&mma8451_driver);
 	if (res < 0) {
 		printk(KERN_INFO "add mma8451 i2c driver failed\n");
 		return -ENODEV;
 	}
 	return res;
 }

 static void __exit mma8451_exit(void)
 {
 	i2c_del_driver(&mma8451_driver);
 }

 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
 MODULE_DESCRIPTION("MMA8451 3-Axis Orientation/Motion Detection Sensor driver");
 MODULE_LICENSE("GPL");

 module_init(mma8451_init);
 module_exit(mma8451_exit);
	/*
	* mma8451.c - Linux kernel modules for 3-Axis Orientation/Motion
	* Detection Sensor
	*
	* Copyright (C) 2010-2014 Freescale Semiconductor, Inc. All Rights Reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* 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.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/

	#include <linux/module.h>
	#include <linux/init.h>
	#include <linux/slab.h>
	#include <linux/i2c.h>
	#include <linux/pm.h>
	#include <linux/mutex.h>
	#include <linux/delay.h>
	#include <linux/interrupt.h>
	#include <linux/irq.h>
	#include <linux/hwmon-sysfs.h>
	#include <linux/err.h>
	#include <linux/hwmon.h>
	#include <linux/input-polldev.h>
	#include <linux/of.h>
	#include <linux/regulator/consumer.h>

	#define MMA8451_I2C_ADDR 0x1C
	#define MMA8451_ID 0x1A
	#define MMA8452_ID 0x2A
	#define MMA8453_ID 0x3A

	#define POLL_INTERVAL_MIN 1
	#define POLL_INTERVAL_MAX 500
	#define POLL_INTERVAL 100 /* msecs */
	#define INPUT_FUZZ 32
	#define INPUT_FLAT 32
	#define MODE_CHANGE_DELAY_MS 100

	#define MMA8451_STATUS_ZYXDR 0x08
	#define MMA8451_BUF_SIZE 7
	#define DEFAULT_POSITION 0

	/* register enum for mma8451 registers */
	enum {
	MMA8451_STATUS = 0x00,
	MMA8451_OUT_X_MSB,
	MMA8451_OUT_X_LSB,
	MMA8451_OUT_Y_MSB,
	MMA8451_OUT_Y_LSB,
	MMA8451_OUT_Z_MSB,
	MMA8451_OUT_Z_LSB,

	MMA8451_F_SETUP = 0x09,
	MMA8451_TRIG_CFG,
	MMA8451_SYSMOD,
	MMA8451_INT_SOURCE,
	MMA8451_WHO_AM_I,
	MMA8451_XYZ_DATA_CFG,
	MMA8451_HP_FILTER_CUTOFF,

	MMA8451_PL_STATUS,
	MMA8451_PL_CFG,
	MMA8451_PL_COUNT,
	MMA8451_PL_BF_ZCOMP,
	MMA8451_P_L_THS_REG,

	MMA8451_FF_MT_CFG,
	MMA8451_FF_MT_SRC,
	MMA8451_FF_MT_THS,
	MMA8451_FF_MT_COUNT,

	MMA8451_TRANSIENT_CFG = 0x1D,
	MMA8451_TRANSIENT_SRC,
	MMA8451_TRANSIENT_THS,
	MMA8451_TRANSIENT_COUNT,

	MMA8451_PULSE_CFG,
	MMA8451_PULSE_SRC,
	MMA8451_PULSE_THSX,
	MMA8451_PULSE_THSY,
	MMA8451_PULSE_THSZ,
	MMA8451_PULSE_TMLT,
	MMA8451_PULSE_LTCY,
	MMA8451_PULSE_WIND,

	MMA8451_ASLP_COUNT,
	MMA8451_CTRL_REG1,
	MMA8451_CTRL_REG2,
	MMA8451_CTRL_REG3,
	MMA8451_CTRL_REG4,
	MMA8451_CTRL_REG5,

	MMA8451_OFF_X,
	MMA8451_OFF_Y,
	MMA8451_OFF_Z,

	MMA8451_REG_END,
	};

	/* The sensitivity is represented in counts/g. In 2g mode the
	sensitivity is 1024 counts/g. In 4g mode the sensitivity is 512
	counts/g and in 8g mode the sensitivity is 256 counts/g.
	*/
	enum {
	MODE_2G = 0,
	MODE_4G,
	MODE_8G,
	};

	enum {
	MMA_STANDBY = 0,
	MMA_ACTIVED,
	};

	/* mma8451 status */
	struct mma8451_status {
	u8 mode;
	u8 ctl_reg1;
	int active;
	int position;
	};

	static struct mma8451_status mma_status;
	static struct input_polled_dev *mma8451_idev;
	static struct device *hwmon_dev;
	static struct i2c_client *mma8451_i2c_client;

	static int senstive_mode = MODE_2G;
	static int ACCHAL[8][3][3] = {
	{ {0, -1, 0}, {1, 0, 0}, {0, 0, 1} },
	{ {-1, 0, 0}, {0, -1, 0}, {0, 0, 1} },
	{ {0, 1, 0}, {-1, 0, 0}, {0, 0, 1} },
	{ {1, 0, 0}, {0, 1, 0}, {0, 0, 1} },

	{ {0, -1, 0}, {-1, 0, 0}, {0, 0, -1} },
	{ {-1, 0, 0}, {0, 1, 0}, {0, 0, -1} },
	{ {0, 1, 0}, {1, 0, 0}, {0, 0, -1} },
	{ {1, 0, 0}, {0, -1, 0}, {0, 0, -1} },
	};

	static DEFINE_MUTEX(mma8451_lock);
	static int mma8451_adjust_position(short x, short y, short *z)
	{
	short rawdata[3], data[3];
	int i, j;
	int position = mma_status.position;
	if (position < 0 \|\| position > 7)
	position = 0;
	rawdata[0] = *x;
	rawdata[1] = *y;
	rawdata[2] = *z;
	for (i = 0; i < 3; i++) {
	data[i] = 0;
	for (j = 0; j < 3; j++)
	data[i] += rawdata[j] * ACCHAL[position][i][j];
	}
	*x = data[0];
	*y = data[1];
	*z = data[2];
	return 0;
	}

	static int mma8451_change_mode(struct i2c_client *client, int mode)
	{
	int result;

	mma_status.ctl_reg1 = 0;
	result = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1, 0);
	if (result < 0)
	goto out;
	mma_status.active = MMA_STANDBY;

	result = i2c_smbus_write_byte_data(client, MMA8451_XYZ_DATA_CFG,
	mode);
	if (result < 0)
	goto out;
	mdelay(MODE_CHANGE_DELAY_MS);
	mma_status.mode = mode;

	return 0;
	out:
	dev_err(&client->dev, "error when init mma8451:(%d)", result);
	return result;
	}

	static int mma8451_read_data(short x, short y, short *z)
	{
	u8 tmp_data[MMA8451_BUF_SIZE];
	int ret;

	ret = i2c_smbus_read_i2c_block_data(mma8451_i2c_client,
	MMA8451_OUT_X_MSB, 7, tmp_data);
	if (ret < MMA8451_BUF_SIZE) {
	dev_err(&mma8451_i2c_client->dev, "i2c block read failed\n");
	return -EIO;
	}

	*x = ((tmp_data[0] << 8) & 0xff00) \| tmp_data[1];
	*y = ((tmp_data[2] << 8) & 0xff00) \| tmp_data[3];
	*z = ((tmp_data[4] << 8) & 0xff00) \| tmp_data[5];
	return 0;
	}

	static void report_abs(void)
	{
	short x, y, z;
	int result;
	int retry = 3;

	mutex_lock(&mma8451_lock);
	if (mma_status.active == MMA_STANDBY)
	goto out;
	/* wait for the data ready */
	do {
	result = i2c_smbus_read_byte_data(mma8451_i2c_client,
	MMA8451_STATUS);
	retry--;
	msleep(1);
	} while (!(result & MMA8451_STATUS_ZYXDR) && retry > 0);
	if (retry == 0)
	goto out;
	if (mma8451_read_data(&x, &y, &z) != 0)
	goto out;
	mma8451_adjust_position(&x, &y, &z);
	input_report_abs(mma8451_idev->input, ABS_X, x);
	input_report_abs(mma8451_idev->input, ABS_Y, y);
	input_report_abs(mma8451_idev->input, ABS_Z, z);
	input_sync(mma8451_idev->input);
	out:
	mutex_unlock(&mma8451_lock);
	}

	static void mma8451_dev_poll(struct input_polled_dev *dev)
	{
	report_abs();
	}

	static ssize_t mma8451_enable_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct i2c_client *client;
	u8 val;
	int enable;

	mutex_lock(&mma8451_lock);
	client = mma8451_i2c_client;
	val = i2c_smbus_read_byte_data(client, MMA8451_CTRL_REG1);
	if ((val & 0x01) && mma_status.active == MMA_ACTIVED)
	enable = 1;
	else
	enable = 0;
	mutex_unlock(&mma8451_lock);
	return sprintf(buf, "%d\n", enable);
	}

	static ssize_t mma8451_enable_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	struct i2c_client *client;
	int ret;
	unsigned long enable;
	u8 val = 0;

	ret = kstrtoul(buf, 10, &enable);
	if (ret) {
	dev_err(dev, "string transform error\n");
	return ret;
	}

	mutex_lock(&mma8451_lock);
	client = mma8451_i2c_client;
	enable = (enable > 0) ? 1 : 0;
	if (enable && mma_status.active == MMA_STANDBY) {
	val = i2c_smbus_read_byte_data(client, MMA8451_CTRL_REG1);
	ret =
	i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
	val \| 0x01);
	if (!ret)
	mma_status.active = MMA_ACTIVED;

	} else if (enable == 0 && mma_status.active == MMA_ACTIVED) {
	val = i2c_smbus_read_byte_data(client, MMA8451_CTRL_REG1);
	ret =
	i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
	val & 0xFE);
	if (!ret)
	mma_status.active = MMA_STANDBY;

	}
	mutex_unlock(&mma8451_lock);
	return count;
	}

	static ssize_t mma8451_position_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	int position = 0;
	mutex_lock(&mma8451_lock);
	position = mma_status.position;
	mutex_unlock(&mma8451_lock);
	return sprintf(buf, "%d\n", position);
	}

	static ssize_t mma8451_position_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	unsigned long position;
	int ret;
	ret = kstrtoul(buf, 10, &position);
	if (ret) {
	dev_err(dev, "string transform error\n");
	return ret;
	}

	mutex_lock(&mma8451_lock);
	mma_status.position = (int)position;
	mutex_unlock(&mma8451_lock);
	return count;
	}

	static ssize_t mma8451_scalemode_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	int mode = 0;
	mutex_lock(&mma8451_lock);
	mode = (int)mma_status.mode;
	mutex_unlock(&mma8451_lock);

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

	static ssize_t mma8451_scalemode_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t count)
	{
	unsigned long mode;
	int ret, active_save;
	struct i2c_client *client = mma8451_i2c_client;

	ret = kstrtoul(buf, 10, &mode);
	if (ret) {
	dev_err(dev, "string transform error\n");
	goto out;
	}

	if (mode > MODE_8G) {
	dev_warn(dev, "not supported mode\n");
	ret = count;
	goto out;
	}

	mutex_lock(&mma8451_lock);
	if (mode == mma_status.mode) {
	ret = count;
	goto out_unlock;
	}

	active_save = mma_status.active;
	ret = mma8451_change_mode(client, mode);
	if (ret)
	goto out_unlock;

	if (active_save == MMA_ACTIVED) {
	ret = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1, 1);

	if (ret)
	goto out_unlock;
	mma_status.active = active_save;
	}

	out_unlock:
	mutex_unlock(&mma8451_lock);
	out:
	return ret;
	}

	static DEVICE_ATTR(enable, S_IWUSR \| S_IRUGO,
	mma8451_enable_show, mma8451_enable_store);
	static DEVICE_ATTR(position, S_IWUSR \| S_IRUGO,
	mma8451_position_show, mma8451_position_store);
	static DEVICE_ATTR(scalemode, S_IWUSR \| S_IRUGO,
	mma8451_scalemode_show, mma8451_scalemode_store);

	static struct attribute *mma8451_attributes[] = {
	&dev_attr_enable.attr,
	&dev_attr_position.attr,
	&dev_attr_scalemode.attr,
	NULL
	};

	static const struct attribute_group mma8451_attr_group = {
	.attrs = mma8451_attributes,
	};

	static int mma8451_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	int result, client_id;
	struct input_dev *idev;
	struct i2c_adapter *adapter;
	u32 pos;
	struct device_node *of_node = client->dev.of_node;
	struct regulator vdd, vdd_io;

	mma8451_i2c_client = client;

	vdd = devm_regulator_get(&client->dev, "vdd");
	if (!IS_ERR(vdd)) {
	result = regulator_enable(vdd);
	if (result) {
	dev_err(&client->dev, "vdd set voltage error\n");
	return result;
	}
	}

	vdd_io = devm_regulator_get(&client->dev, "vddio");
	if (!IS_ERR(vdd_io)) {
	result = regulator_enable(vdd_io);
	if (result) {
	dev_err(&client->dev, "vddio set voltage error\n");
	return result;
	}
	}

	adapter = to_i2c_adapter(client->dev.parent);
	result = i2c_check_functionality(adapter,
	I2C_FUNC_SMBUS_BYTE \|
	I2C_FUNC_SMBUS_BYTE_DATA);
	if (!result)
	goto err_out;

	client_id = i2c_smbus_read_byte_data(client, MMA8451_WHO_AM_I);
	if (client_id != MMA8451_ID && client_id != MMA8452_ID
	&& client_id != MMA8453_ID) {
	dev_err(&client->dev,
	"read chip ID 0x%x is not equal to 0x%x or 0x%x!\n",
	result, MMA8451_ID, MMA8452_ID);
	result = -EINVAL;
	goto err_out;
	}

	/* Initialize the MMA8451 chip */
	result = mma8451_change_mode(client, senstive_mode);
	if (result) {
	dev_err(&client->dev,
	"error when init mma8451 chip:(%d)\n", result);
	goto err_out;
	}

	hwmon_dev = hwmon_device_register(&client->dev);
	if (!hwmon_dev) {
	result = -ENOMEM;
	dev_err(&client->dev, "error when register hwmon device\n");
	goto err_out;
	}

	mma8451_idev = input_allocate_polled_device();
	if (!mma8451_idev) {
	result = -ENOMEM;
	dev_err(&client->dev, "alloc poll device failed!\n");
	goto err_alloc_poll_device;
	}
	mma8451_idev->poll = mma8451_dev_poll;
	mma8451_idev->poll_interval = POLL_INTERVAL;
	mma8451_idev->poll_interval_min = POLL_INTERVAL_MIN;
	mma8451_idev->poll_interval_max = POLL_INTERVAL_MAX;
	idev = mma8451_idev->input;
	idev->name = "mma845x";
	idev->id.bustype = BUS_I2C;
	idev->evbit[0] = BIT_MASK(EV_ABS);

	input_set_abs_params(idev, ABS_X, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
	input_set_abs_params(idev, ABS_Y, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);
	input_set_abs_params(idev, ABS_Z, -8192, 8191, INPUT_FUZZ, INPUT_FLAT);

	result = input_register_polled_device(mma8451_idev);
	if (result) {
	dev_err(&client->dev, "register poll device failed!\n");
	goto err_register_polled_device;
	}
	result = sysfs_create_group(&idev->dev.kobj, &mma8451_attr_group);
	if (result) {
	dev_err(&client->dev, "create device file failed!\n");
	result = -EINVAL;
	goto err_register_polled_device;
	}

	result = of_property_read_u32(of_node, "position", &pos);
	if (result)
	pos = DEFAULT_POSITION;
	mma_status.position = (int)pos;

	return 0;
	err_register_polled_device:
	input_free_polled_device(mma8451_idev);
	err_alloc_poll_device:
	hwmon_device_unregister(&client->dev);
	err_out:
	return result;
	}

	static int mma8451_stop_chip(struct i2c_client *client)
	{
	int ret = 0;
	if (mma_status.active == MMA_ACTIVED) {
	mma_status.ctl_reg1 = i2c_smbus_read_byte_data(client,
	MMA8451_CTRL_REG1);
	ret = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
	mma_status.ctl_reg1 & 0xFE);
	}
	return ret;
	}

	static int mma8451_remove(struct i2c_client *client)
	{
	int ret;
	ret = mma8451_stop_chip(client);
	hwmon_device_unregister(hwmon_dev);

	return ret;
	}

	#ifdef CONFIG_PM_SLEEP
	static int mma8451_suspend(struct device *dev)
	{
	struct i2c_client *client = to_i2c_client(dev);

	return mma8451_stop_chip(client);
	}

	static int mma8451_resume(struct device *dev)
	{
	int ret = 0;
	struct i2c_client *client = to_i2c_client(dev);
	if (mma_status.active == MMA_ACTIVED)
	ret = i2c_smbus_write_byte_data(client, MMA8451_CTRL_REG1,
	mma_status.ctl_reg1);
	return ret;

	}
	#endif

	static const struct i2c_device_id mma8451_id[] = {
	{"mma8451", 0},
	{ /* sentinel */ }
	};

	MODULE_DEVICE_TABLE(i2c, mma8451_id);

	static SIMPLE_DEV_PM_OPS(mma8451_pm_ops, mma8451_suspend, mma8451_resume);
	static struct i2c_driver mma8451_driver = {
	.driver = {
	.name = "mma8451",
	.owner = THIS_MODULE,
	.pm = &mma8451_pm_ops,
	},
	.probe = mma8451_probe,
	.remove = mma8451_remove,
	.id_table = mma8451_id,
	};

	static int __init mma8451_init(void)
	{
	/* register driver */
	int res;

	res = i2c_add_driver(&mma8451_driver);
	if (res < 0) {
	printk(KERN_INFO "add mma8451 i2c driver failed\n");
	return -ENODEV;
	}
	return res;
	}

	static void __exit mma8451_exit(void)
	{
	i2c_del_driver(&mma8451_driver);
	}

	MODULE_AUTHOR("Freescale Semiconductor, Inc.");
	MODULE_DESCRIPTION("MMA8451 3-Axis Orientation/Motion Detection Sensor driver");
	MODULE_LICENSE("GPL");

	module_init(mma8451_init);
	module_exit(mma8451_exit);