/*
 *
 * Copyright (C) 2011-2015 Freescale Semiconductor, Inc.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/irq.h>
#include <linux/platform_device.h>
#include <linux/input-polldev.h>
#include <linux/hwmon.h>
#include <linux/input.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
#include <linux/of.h>
#include <linux/pm.h>
#include <linux/regulator/consumer.h>

#define ABS_STATUS ABS_WHEEL

#define MAG3110_DRV_NAME       "mag3110"
#define MAG3110_ID              0xC4
#define MAG3110_XYZ_DATA_LEN    6
#define MAG3110_STATUS_ZYXDR    0x08

#define MAG3110_AC_MASK         (0x01)
#define MAG3110_AC_OFFSET       0
#define MAG3110_DR_MODE_MASK    (0x7 << 5)
#define MAG3110_DR_MODE_OFFSET  5
#define MAG3110_IRQ_USED        1

#define POLL_INTERVAL_MAX       500
#define POLL_INTERVAL_MIN       1
#define POLL_INTERVAL           100
/* if sensor is standby ,set POLL_STOP_TIME to slow down the poll */
#define POLL_STOP_TIME          200

#define INT_TIMEOUT   1000
/* register enum for mag3110 registers */
enum {
	MAG3110_DR_STATUS = 0x00,
	MAG3110_OUT_X_MSB,
	MAG3110_OUT_X_LSB,
	MAG3110_OUT_Y_MSB,
	MAG3110_OUT_Y_LSB,
	MAG3110_OUT_Z_MSB,
	MAG3110_OUT_Z_LSB,
	MAG3110_WHO_AM_I,

	MAG3110_OFF_X_MSB,
	MAG3110_OFF_X_LSB,
	MAG3110_OFF_Y_MSB,
	MAG3110_OFF_Y_LSB,
	MAG3110_OFF_Z_MSB,
	MAG3110_OFF_Z_LSB,

	MAG3110_DIE_TEMP,

	MAG3110_CTRL_REG1 = 0x10,
	MAG3110_CTRL_REG2,
};
enum {
	MAG_STANDBY,
	MAG_ACTIVED
};
struct mag3110_data_axis {
	short x;
	short y;
	short z;
};

struct mag3110_data {
	struct i2c_client *client;
	struct input_polled_dev *poll_dev;
    /* mag3110 calibrated data report input dev */
	struct input_dev *cal_input;
	struct mutex data_lock;
	wait_queue_head_t waitq;
	bool data_ready;
	u8 ctl_reg1;
	int active;
	int position;
};
static short mag3110_position_setting[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  } },

};

/*!
 * This function do one mag3110 register read.
 */
static int mag3110_data_convert(int position,
	   struct mag3110_data_axis *axis_data)
{
	short rawdata[3], data[3];
	int i, j;

	if (position < 0 || position > 7)
		position = 0;
	rawdata[0] = axis_data->x;
	rawdata[1] = axis_data->y;
	rawdata[2] = axis_data->z;
	for (i = 0; i < 3; i++) {
		data[i] = 0;
		for (j = 0; j < 3; j++)
			data[i] += rawdata[j] * mag3110_position_setting[position][i][j];
	}
	axis_data->x = data[0];
	axis_data->y = data[1];
	axis_data->z = data[2];
	return 0;
}
static int mag3110_read_reg(struct i2c_client *client, u8 reg)
{
	return i2c_smbus_read_byte_data(client, reg);
}

/*!
 * This function do one mag3110 register write.
 */
static int mag3110_write_reg(struct i2c_client *client, u8 reg, char value)
{
	int ret;

	ret = i2c_smbus_write_byte_data(client, reg, value);
	if (ret < 0)
		dev_err(&client->dev, "i2c write failed\n");
	return ret;
}

/*!
 * This function do multiple mag3110 registers read.
 */
static int mag3110_read_block_data(struct i2c_client *client, u8 reg,
				   int count, u8 *addr)
{
	if (i2c_smbus_read_i2c_block_data
		    (client, reg, count, addr) < count) {
		dev_err(&client->dev, "i2c block read failed\n");
		return -1;
	}

	return count;
}

/*
 * Initialization function
 */
static int mag3110_init_client(struct i2c_client *client)
{
	int val, ret;

	/* enable automatic resets */
	val = 0x80;
	ret = mag3110_write_reg(client, MAG3110_CTRL_REG2, val);

	/* set default data rate to 10HZ */
	val = mag3110_read_reg(client, MAG3110_CTRL_REG1);
	val |= (0x0 << MAG3110_DR_MODE_OFFSET);
	ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, val);

	return ret;
}

/***************************************************************
*
* read sensor data from mag3110
*
***************************************************************/
static int mag3110_read_data(struct i2c_client *client,
		struct mag3110_data_axis *pdata)
{
	struct mag3110_data *mag = i2c_get_clientdata(client);
	u8 tmp_data[MAG3110_XYZ_DATA_LEN];

	if (!mag || mag->active == MAG_STANDBY)
		return -EINVAL;
#if MAG3110_IRQ_USED
	if (!wait_event_interruptible_timeout
		    (mag->waitq, mag->data_ready != 0,
		    msecs_to_jiffies(INT_TIMEOUT))) {
		dev_dbg(&mag->client->dev, "interrupt not received\n");
		return -ETIME;
	}
#endif
	mag->data_ready = 0;
	if (mag3110_read_block_data(client,
				    MAG3110_OUT_X_MSB,
					MAG3110_XYZ_DATA_LEN, tmp_data) < 0)
		return -1;
	pdata->x = ((tmp_data[0] << 8) & 0xff00) | tmp_data[1];
	pdata->y = ((tmp_data[2] << 8) & 0xff00) | tmp_data[3];
	pdata->z = ((tmp_data[4] << 8) & 0xff00) | tmp_data[5];

	return 0;
}

static void mag3110_report_data(struct mag3110_data *mag)
{

	struct input_polled_dev *poll_dev = mag->poll_dev;
	struct input_dev *idev = poll_dev->input;
	struct mag3110_data_axis data;

	mutex_lock(&mag->data_lock);
	if (mag3110_read_data(mag->client, &data) != 0) {
		poll_dev->poll_interval = POLL_STOP_TIME;
		goto out;
	} else if (poll_dev->poll_interval == POLL_STOP_TIME)
		poll_dev->poll_interval = POLL_INTERVAL;
	mag3110_data_convert(mag->position, &data);
	idev = mag->poll_dev->input;
	input_report_abs(idev, ABS_X, data.x);
	input_report_abs(idev, ABS_Y, data.y);
	input_report_abs(idev, ABS_Z, data.z);
	input_sync(idev);
out:
	mutex_unlock(&mag->data_lock);
}

static void mag3110_dev_poll(struct input_polled_dev *dev)
{
	struct mag3110_data * mag = (struct mag3110_data *)dev->private;

	mag3110_report_data(mag);
}

#if MAG3110_IRQ_USED
static irqreturn_t mag3110_irq_handler(int irq, void *dev)
{
	struct mag3110_data *mag = (struct mag3110_data *)dev;

	mag->data_ready = 1;
	wake_up_interruptible(&mag->waitq);

	return IRQ_HANDLED;
}
#endif
static int mag3110_reigister_caldata_input(struct mag3110_data *mag)
{
	struct input_dev *idev;
	struct i2c_client *client = mag->client;
	int ret;

	idev = input_allocate_device();
	if (!idev) {
		dev_err(&client->dev, "alloc calibrated data device error\n");
		return -EINVAL;
	}
	idev->name = "eCompass";
	idev->id.bustype = BUS_I2C;
	idev->evbit[0] = BIT_MASK(EV_ABS);
	input_set_abs_params(idev, ABS_X, -15000, 15000, 0, 0);
	input_set_abs_params(idev, ABS_Y, -15000, 15000, 0, 0);
	input_set_abs_params(idev, ABS_Z, -15000, 15000, 0, 0);
	input_set_abs_params(idev, ABS_RX,         0, 36000, 0, 0);
	input_set_abs_params(idev, ABS_RY, -18000, 18000, 0, 0);
	input_set_abs_params(idev, ABS_RZ, -9000,  9000, 0, 0);
	input_set_abs_params(idev, ABS_STATUS, 0,     3, 0, 0);
	ret = input_register_device(idev);
	if (ret) {
		dev_err(&client->dev, "register poll device failed!\n");
		return -EINVAL;
	}
	mag->cal_input = idev;
	return 0;
}
static int mag3110_unreigister_caldata_input(struct mag3110_data *mag)
{
	struct input_dev *idev = mag->cal_input;

	if (idev) {
		input_unregister_device(idev);
		input_free_device(idev);
	}
	mag->cal_input = NULL;
	return 0;
}
static ssize_t mag3110_enable_show(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct input_polled_dev *poll_dev = dev_get_drvdata(dev);
	struct mag3110_data *mag = (struct mag3110_data *)(poll_dev->private);
	struct i2c_client *client = mag->client;
	int val;

	mutex_lock(&mag->data_lock);
	val = mag3110_read_reg(client, MAG3110_CTRL_REG1);
	val &= MAG3110_AC_MASK;
	mutex_unlock(&mag->data_lock);
	return sprintf(buf, "%d\n", val);
}

static ssize_t mag3110_enable_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct input_polled_dev *poll_dev = dev_get_drvdata(dev);
	struct mag3110_data *mag = (struct mag3110_data *)(poll_dev->private);
	struct i2c_client *client = mag->client;
	int reg, ret, enable;
	u8 tmp_data[MAG3110_XYZ_DATA_LEN];

	enable = simple_strtoul(buf, NULL, 10);
	mutex_lock(&mag->data_lock);
	client = mag->client;
	reg = mag3110_read_reg(client, MAG3110_CTRL_REG1);
	if (enable &&  mag->active == MAG_STANDBY) {
		reg |= MAG3110_AC_MASK;
		ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg);
		if (!ret)
			mag->active = MAG_ACTIVED;
		printk(KERN_INFO"mag3110 set active\n");
	} else if (!enable && mag->active == MAG_ACTIVED) {
		reg &= ~MAG3110_AC_MASK;
		ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg);
		if (!ret)
			mag->active = MAG_STANDBY;
		printk(KERN_INFO"mag3110 set inactive\n");

	}

	if (mag->active == MAG_ACTIVED) {
		msleep(100);
		/* Read out MSB data to clear interrupt flag automatically */
		mag3110_read_block_data(client, MAG3110_OUT_X_MSB,
					MAG3110_XYZ_DATA_LEN, tmp_data);
	}
	mutex_unlock(&mag->data_lock);
	return count;
}

static DEVICE_ATTR(enable, S_IWUSR | S_IRUGO,
		   mag3110_enable_show, mag3110_enable_store);

static ssize_t mag3110_dr_mode_show(struct device *dev,
				    struct device_attribute *attr, char *buf)
{
	struct input_polled_dev *poll_dev = dev_get_drvdata(dev);
	struct mag3110_data *mag = (struct mag3110_data *)(poll_dev->private);
	struct i2c_client *client = mag->client;
	int val;

	client = mag->client;
	val = (mag3110_read_reg(client, MAG3110_CTRL_REG1)
	       & MAG3110_DR_MODE_MASK) >> MAG3110_DR_MODE_OFFSET;

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

static ssize_t mag3110_dr_mode_store(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
{
	struct input_polled_dev *poll_dev = dev_get_drvdata(dev);
	struct mag3110_data *mag = (struct mag3110_data *)(poll_dev->private);
	struct i2c_client *client = mag->client;
	int reg, ret;
	unsigned long val;

	/* This must be done when mag3110 is disabled */
	if ((strict_strtoul(buf, 10, &val) < 0) || (val > 7))
		return -EINVAL;

	client = mag->client;
	reg = mag3110_read_reg(client, MAG3110_CTRL_REG1) &
	      ~MAG3110_DR_MODE_MASK;
	reg |= (val << MAG3110_DR_MODE_OFFSET);
	/* MAG3110_CTRL_REG1 bit 5-7: data rate mode */
	ret = mag3110_write_reg(client, MAG3110_CTRL_REG1, reg);
	if (ret < 0)
		return ret;

	return count;
}

static DEVICE_ATTR(dr_mode, S_IWUSR | S_IRUGO,
		   mag3110_dr_mode_show, mag3110_dr_mode_store);

static ssize_t mag3110_position_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct input_polled_dev *poll_dev = dev_get_drvdata(dev);
	struct mag3110_data *mag = (struct mag3110_data *)(poll_dev->private);
	int val;

	mutex_lock(&mag->data_lock);
	val = mag->position;
	mutex_unlock(&mag->data_lock);
	return sprintf(buf, "%d\n", val);
}
static ssize_t mag3110_position_store(struct device *dev,
				      struct device_attribute *attr,
				      const char *buf, size_t count)
{
	struct input_polled_dev *poll_dev = dev_get_drvdata(dev);
	struct mag3110_data *mag = (struct mag3110_data *)(poll_dev->private);
	int position;

	position = simple_strtoul(buf, NULL, 10);
	mutex_lock(&mag->data_lock);
	mag->position = position;
	mutex_unlock(&mag->data_lock);
	return count;
}
static DEVICE_ATTR(position, S_IWUSR | S_IRUGO,
		   mag3110_position_show, mag3110_position_store);

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

static const struct attribute_group mag3110_attr_group = {
	.attrs	= mag3110_attributes,
};

static int mag3110_probe(struct i2c_client *client,
				   const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter;
	struct input_dev *idev;
	struct mag3110_data *mag;
	struct regulator *vdd, *vdd_io;
	u32 irq_flag;
	struct irq_data *irq_data;
	struct device_node *of_node = client->dev.of_node;
	bool shared_irq;
	int ret = 0;
	u32 pos;
	vdd = devm_regulator_get(&client->dev, "vdd");
	if (!IS_ERR(vdd)) {
		ret = regulator_enable(vdd);
		if (ret) {
			dev_err(&client->dev, "vdd set voltage error\n");
			return ret;
		}
	}

	vdd_io = devm_regulator_get(&client->dev, "vddio");
	if (!IS_ERR(vdd_io)) {
		ret = regulator_enable(vdd_io);
		if (ret) {
			dev_err(&client->dev, "vddio set voltage error\n");
			return ret;
		}
	}
	adapter = to_i2c_adapter(client->dev.parent);
	if (!i2c_check_functionality(adapter,
				     I2C_FUNC_SMBUS_BYTE |
				     I2C_FUNC_SMBUS_BYTE_DATA |
				     I2C_FUNC_SMBUS_I2C_BLOCK))
		return -EIO;

	dev_info(&client->dev, "check mag3110 chip ID\n");
	ret = mag3110_read_reg(client, MAG3110_WHO_AM_I);

	if (MAG3110_ID != ret) {
		dev_err(&client->dev,
			"read chip ID 0x%x is not equal to 0x%x!\n", ret,
			MAG3110_ID);
		return -EINVAL;
	}
	mag = kzalloc(sizeof(struct mag3110_data), GFP_KERNEL);
	if (!mag)
		return -ENOMEM;
	mag->client = client;
	mag->active = MAG_STANDBY;
	ret = of_property_read_u32(of_node, "position", &pos);
	if (ret)
		pos = 2;
	mag->position = (int)pos;
	mutex_init(&mag->data_lock);
	i2c_set_clientdata(client, mag);
	/* Init queue */
	init_waitqueue_head(&mag->waitq);

	/*input poll device register */
	mag->poll_dev = input_allocate_polled_device();
	if (!mag->poll_dev) {
		dev_err(&client->dev, "alloc poll device failed!\n");
		ret = -ENOMEM;
		goto error_alloc_poll_dev;
	}
	mag->poll_dev->poll = mag3110_dev_poll;
	mag->poll_dev->poll_interval = POLL_STOP_TIME;
	mag->poll_dev->poll_interval_max = POLL_INTERVAL_MAX;
	mag->poll_dev->poll_interval_min = POLL_INTERVAL_MIN;
	mag->poll_dev->private = mag;
	idev = mag->poll_dev->input;
	idev->name = "FreescaleMagnetometer";
	idev->id.bustype = BUS_I2C;
	idev->evbit[0] = BIT_MASK(EV_ABS);
	input_set_abs_params(idev, ABS_X, -0x7fff, 0x7fff, 0, 0);
	input_set_abs_params(idev, ABS_Y, -0x7fff, 0x7fff, 0, 0);
	input_set_abs_params(idev, ABS_Z, -0x7fff, 0x7fff, 0, 0);
	ret = input_register_polled_device(mag->poll_dev);
	if (ret) {
		dev_err(&client->dev, "register poll device failed!\n");
		goto error_reg_poll_dev;
	}
	ret = mag3110_reigister_caldata_input(mag);
	if (ret < 0) {
		dev_err(&client->dev,
			"failed to register calibrated input device!\n");
		goto erorr_reg_caldev;
	}
	/*create device group in sysfs as user interface */
	ret = sysfs_create_group(&idev->dev.kobj, &mag3110_attr_group);
	if (ret) {
		dev_err(&client->dev, "create sysfs device file failed!\n");
		ret = -EINVAL;
		goto error_reg_sysfs;
	}

	/* set irq type to edge rising */
#if MAG3110_IRQ_USED
	shared_irq = of_property_read_bool(of_node, "shared-interrupt");
	if (client->irq) {
		irq_data = irq_get_irq_data(client->irq);
		irq_flag = irqd_get_trigger_type(irq_data);
		irq_flag |= IRQF_ONESHOT;
		if (shared_irq)
				irq_flag |= IRQF_SHARED;
		ret = request_irq(client->irq, mag3110_irq_handler,
			irq_flag, client->dev.driver->name, mag);
		if (ret < 0) {
			dev_err(&client->dev, "failed to register irq %d!\n",
					client->irq);
			goto error_reg_irq;
	}
	}
#endif
	/* Initialize mag3110 chip */

	mag3110_init_client(client);
	dev_info(&client->dev, "mag3110 is probed\n");
	return 0;
#if MAG3110_IRQ_USED
error_reg_irq:
	sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
#endif
error_reg_sysfs:
	mag3110_unreigister_caldata_input(mag);
erorr_reg_caldev:
	input_unregister_polled_device(mag->poll_dev);
error_reg_poll_dev:
	input_free_polled_device(mag->poll_dev);
error_alloc_poll_dev:
	kfree(mag);
	return ret;
}

static int mag3110_remove(struct i2c_client *client)
{
	struct mag3110_data *mag = i2c_get_clientdata(client);
	int ret;

	mag->ctl_reg1 = mag3110_read_reg(client, MAG3110_CTRL_REG1);
	ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
				mag->ctl_reg1 & ~MAG3110_AC_MASK);
	free_irq(client->irq, mag);
	input_unregister_polled_device(mag->poll_dev);
	input_free_polled_device(mag->poll_dev);
	sysfs_remove_group(&client->dev.kobj, &mag3110_attr_group);
	mag3110_unreigister_caldata_input(mag);
	kfree(mag);
	mag = NULL;

	return ret;
}

#ifdef CONFIG_PM
static int mag3110_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct mag3110_data *mag = i2c_get_clientdata(client);
	int ret = 0;

	if (mag->active == MAG_ACTIVED) {
		mag->ctl_reg1 = mag3110_read_reg(client, MAG3110_CTRL_REG1);
		ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
					mag->ctl_reg1 & ~MAG3110_AC_MASK);
	}
	return ret;
}

static int mag3110_resume(struct device *dev)
{
	int ret = 0;
	u8 tmp_data[MAG3110_XYZ_DATA_LEN];
	struct i2c_client *client = to_i2c_client(dev);
	struct mag3110_data *mag = i2c_get_clientdata(client);

	if (mag->active == MAG_ACTIVED) {
		ret = mag3110_write_reg(client, MAG3110_CTRL_REG1,
					mag->ctl_reg1);

		if (mag->ctl_reg1 & MAG3110_AC_MASK) {
			/* Read out MSB data to clear */
			/* interrupt flag automatically */
			mag3110_read_block_data(client, MAG3110_OUT_X_MSB,
						MAG3110_XYZ_DATA_LEN, tmp_data);
		}
	}
	return ret;
}

#else
#define mag3110_suspend        NULL
#define mag3110_resume         NULL
#endif                          /* CONFIG_PM */

static const struct i2c_device_id mag3110_id[] = {
	{ MAG3110_DRV_NAME, 0 },
	{}
};

MODULE_DEVICE_TABLE(i2c, mag3110_id);

static SIMPLE_DEV_PM_OPS(mag3110_pm_ops, mag3110_suspend, mag3110_resume);
static struct i2c_driver mag3110_driver = {
	.driver		= {
		.name	= MAG3110_DRV_NAME,
		.owner	= THIS_MODULE,
		.pm	= &mag3110_pm_ops,
	},
	.probe			= mag3110_probe,
	.remove			= mag3110_remove,
	.id_table		= mag3110_id,
};


module_i2c_driver(mag3110_driver);

MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("Freescale mag3110 3-axis magnetometer driver");
MODULE_LICENSE("GPL");