/*
 *  mxc6225.c - Linux kernel modules for Detection Sensor  
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/i2c.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/device.h>
#include "../init-input.h"

//#include <mach/system.h>
//#include <mach/hardware.h>
#undef CONFIG_HAS_EARLYSUSPEND
#undef CONFIG_PM

#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/earlysuspend.h>
#endif

#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_PM)
#include <linux/pm.h>
#endif

/*
 * Defines
 */
#define assert(expr)\
	if (!(expr)) {\
		printk(KERN_ERR "Assertion failed! %s,%d,%s,%s\n",\
			__FILE__, __LINE__, __func__, #expr);\
	}

#define MXC622X_DRV_NAME	"mxc622x"
#define SENSOR_NAME 		MXC622X_DRV_NAME


#define POLL_INTERVAL_MAX	500
#define POLL_INTERVAL		50
#define INPUT_FUZZ	2
#define INPUT_FLAT	2

#define MXC622X_REG_CTRL		0x04
#define MXC622X_REG_DATA		0x00

/* MXC622X control bit */
#define MXC622X_CTRL_PWRON		0x00	/* power on */
#define MXC622X_CTRL_PWRDN		0x80	/* power donw */


#define MODE_CHANGE_DELAY_MS 100

static struct device *hwmon_dev;
static struct i2c_client *mxc622x_i2c_client;
static struct input_polled_dev *mxc622x_idev;
static struct sensor_config_info gsensor_info = {
	.input_type = GSENSOR_TYPE,
};

struct mxc622x_data_s {
        atomic_t enable;
        struct i2c_client       *client;
        struct input_polled_dev *pollDev; 
        struct mutex interval_mutex; 
    
#ifdef CONFIG_HAS_EARLYSUSPEND
	struct early_suspend early_suspend;
	volatile int suspend_indator;
#endif
} mxc622x_data;

static int filter_flag;

/* Addresses to scan */
static const unsigned short normal_i2c[] = {0x15,I2C_CLIENT_END};

enum {
	DEBUG_INIT = 1U << 0,
	DEBUG_CONTROL_INFO = 1U << 1,
	DEBUG_DATA_INFO = 1U << 2,
	DEBUG_SUSPEND = 1U << 3,
};
static u32 debug_mask = 0x0;
#define dprintk(level_mask, fmt, arg...)	if (unlikely(debug_mask & level_mask)) \
	printk(KERN_DEBUG fmt , ## arg)

module_param_named(debug_mask, debug_mask, int, S_IRUGO | S_IWUSR | S_IWGRP);

#ifdef CONFIG_HAS_EARLYSUSPEND
static void mxc622x_early_suspend(struct early_suspend *h);
static void mxc622x_late_resume(struct early_suspend *h);
#endif


#if 0
//Function as i2c_master_send, and return 1 if operation is successful. 
static int i2c_write_bytes(struct i2c_client *client, uint8_t *data, uint16_t len)
{
	struct i2c_msg msg;
	int ret=-1;
	
	msg.flags = !I2C_M_RD;
	msg.addr = client->addr;
	msg.len = len;
	msg.buf = data;		
	
	ret=i2c_transfer(client->adapter, &msg,1);
	return ret;
}

static bool gsensor_i2c_test(struct i2c_client * client)
{
	int ret, retry;
	uint8_t test_data[1] = { 0 };	//only write a data address.
	
	for(retry=0; retry < 2; retry++)
	{
		ret =i2c_write_bytes(client, test_data, 1);	//Test i2c.
		if (ret == 1)
			break;
		msleep(5);
	}
	
	return ret==1 ? true : false;
}
#endif

/**
 * gsensor_detect - Device detection callback for automatic device creation
 * return value:  
 *                    = 0; success;
 *                    < 0; err
 */
int gsensor_detect(struct i2c_client *client, struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = client->adapter;

        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
    
	    if(gsensor_info.twi_id == adapter->nr){
                dprintk(DEBUG_INIT, "%s: addr= %x\n",__func__,client->addr);
/*
            ret = gsensor_i2c_test(client);
        	if(!ret){
        		pr_info("%s:I2C connection might be something wrong or maybe the other gsensor equipment! \n",__func__);
        		return -ENODEV;
        	}else
*/
			{           	    
            	    dprintk(DEBUG_INIT, "I2C connection sucess!\n");
            	    strlcpy(info->type, SENSOR_NAME, I2C_NAME_SIZE);
    		        return 0;	
	        }

	}else{
		return -ENODEV;
	}
}
static ssize_t mxc622x_delay_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct i2c_client *client = mxc622x_i2c_client;
	struct mxc622x_data_s *mxc622x = NULL;

	mxc622x = i2c_get_clientdata(client);
	return sprintf(buf, "%d\n", mxc622x->pollDev->poll_interval);
}

static ssize_t mxc622x_delay_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	unsigned long data;
	int error;
	struct i2c_client *client       = mxc622x_i2c_client;
	struct mxc622x_data_s *mxc622x  = NULL;

        mxc622x    = i2c_get_clientdata(client);
        dprintk(DEBUG_INIT, "delay store %d\n", __LINE__);

	error = strict_strtoul(buf, 10, &data);
	if (error)
		return error;
		
	if (data > POLL_INTERVAL_MAX)
		data = POLL_INTERVAL_MAX;
    
        mutex_lock(&mxc622x->interval_mutex);
        mxc622x->pollDev->poll_interval = data;
        mutex_unlock(&mxc622x->interval_mutex);

	return count;
}

static ssize_t mxc622x_enable_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct i2c_client *client       = mxc622x_i2c_client;
	struct mxc622x_data_s *mxc622x  = NULL;

	mxc622x    = i2c_get_clientdata(client);

	return sprintf(buf, "%d\n",atomic_read(&mxc622x_data.enable));

}

static ssize_t mxc622x_enable_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	unsigned long data;
	int error;

	error = strict_strtoul(buf, 10, &data);
	
	if(error) {
		pr_err("%s strict_strtoul error\n", __FUNCTION__);
		goto exit;
	}

	if(data) {
		error = i2c_smbus_write_byte_data(mxc622x_i2c_client, MXC622X_REG_CTRL,MXC622X_CTRL_PWRON);
		atomic_set(&mxc622x_data.enable, 1);
		assert(error==0);
		filter_flag = 0;
		mxc622x_idev->input->open(mxc622x_idev->input);
	} else {
	        mxc622x_idev->input->close(mxc622x_idev->input);
	        atomic_set(&mxc622x_data.enable, 0);
		error = i2c_smbus_write_byte_data(mxc622x_i2c_client, MXC622X_REG_CTRL,MXC622X_CTRL_PWRDN);
		assert(error==0);
	}

	return count;

exit:
	return error;
}


static DEVICE_ATTR(enable, S_IRUSR|S_IRGRP|S_IWUSR|S_IWGRP,
		mxc622x_enable_show, mxc622x_enable_store);

static DEVICE_ATTR(delay, S_IRUSR|S_IRGRP|S_IWUSR|S_IWGRP,
		mxc622x_delay_show,  mxc622x_delay_store);

static struct attribute *mxc622x_attributes[] = {
	&dev_attr_enable.attr,
	&dev_attr_delay.attr,
	NULL
};

static struct attribute_group mxc622x_attribute_group = {
	.attrs = mxc622x_attributes
};

static int report_abs(void)
{
	s8 xyz[2] = {0x00}; 
	s16 x, y, z = 0;
	int ret;

	 
	ret = i2c_smbus_write_byte_data(mxc622x_i2c_client, 0x04, 0x02);
	assert(ret==0);
	
	memset(&xyz,0,sizeof(xyz));
	ret=i2c_smbus_read_i2c_block_data(mxc622x_i2c_client, 0x00, 2,xyz);
	if(ret < 2)
	{
	    printk("read data error!\n");
	}

	x = ((xyz[0] ) << 8) >> 8;
	y = ((xyz[1] ) << 8) >> 8;
    
	if ((x == 0) || (y == 0)) {
	    return 0;
	}

/* To filter some wrong data  */
	if (filter_flag < 3) {
		filter_flag++;
		return 0;
	}

	dprintk(DEBUG_DATA_INFO, "x= 0x%hx, y = 0x%hx, z = 0x%hx\n", x, y, z);
	input_report_abs(mxc622x_idev->input, ABS_X, x);
	input_report_abs(mxc622x_idev->input, ABS_Y, y);
	/*input_report_abs(mxc622x_idev->input, ABS_Z, z);*/
     
	input_sync(mxc622x_idev->input);
	return 1;
}

static void mxc622x_dev_poll(struct input_polled_dev *dev)
{
#ifdef CONFIG_HAS_EARLYSUSPEND
	if(0 == mxc622x_data.suspend_indator){
		report_abs();
	}
#else
	report_abs();
#endif
} 

/*
 * I2C init/probing/exit functions
 */

static int mxc622x_probe(struct i2c_client *client,
				   const struct i2c_device_id *id)
{
	int result;
	struct i2c_adapter *adapter;
        struct mxc622x_data_s* data = &mxc622x_data;
 
	dprintk(DEBUG_INIT, "mxc622x probe\n");
	mxc622x_i2c_client = client;
	adapter = to_i2c_adapter(client->dev.parent);
 	result = i2c_check_functionality(adapter,
 					 I2C_FUNC_SMBUS_BYTE |
 					 I2C_FUNC_SMBUS_BYTE_DATA);
	assert(result);


	hwmon_dev = hwmon_device_register(&client->dev);
	assert(!(IS_ERR(hwmon_dev)));

	dprintk(DEBUG_INIT, "build time %s %s\n", __DATE__, __TIME__);
  
	/*input poll device register */
	mxc622x_idev = input_allocate_polled_device();
	if (!mxc622x_idev) {
		dev_err(&client->dev, "alloc poll device failed!\n");
		result = -ENOMEM;
		return result;
	}
	mxc622x_idev->poll = mxc622x_dev_poll;
	mxc622x_idev->poll_interval = POLL_INTERVAL;
	mxc622x_idev->poll_interval_max = POLL_INTERVAL_MAX;
	mxc622x_idev->input->name = MXC622X_DRV_NAME;
	mxc622x_idev->input->id.bustype = BUS_I2C;
	mxc622x_idev->input->evbit[0] = BIT_MASK(EV_ABS);
        mutex_init(&data->interval_mutex);

	input_set_abs_params(mxc622x_idev->input, ABS_X, -128, 128, 0, 0);
	input_set_abs_params(mxc622x_idev->input, ABS_Y, -128, 128, 0, 0);
	input_set_abs_params(mxc622x_idev->input, ABS_Z, -128, 128, 0, 0);
	
	result = input_register_polled_device(mxc622x_idev);
	if (result) {
		dev_err(&client->dev, "register poll device failed!\n");
		return result;
	}
	result = sysfs_create_group(&mxc622x_idev->input->dev.kobj, &mxc622x_attribute_group);

	if(result) {
		dev_err(&client->dev, "create sys failed\n");
	}

        data->client  = client;
        data->pollDev = mxc622x_idev;
	i2c_set_clientdata(client, data);

#ifdef CONFIG_HAS_EARLYSUSPEND
	mxc622x_data.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	mxc622x_data.early_suspend.suspend = mxc622x_early_suspend;
	mxc622x_data.early_suspend.resume = mxc622x_late_resume;
	register_early_suspend(&mxc622x_data.early_suspend);
	mxc622x_data.suspend_indator = 0;
#endif

	return result;
}

static int mxc622x_remove(struct i2c_client *client)
{
	int result;
        result = i2c_smbus_write_byte_data(mxc622x_i2c_client, MXC622X_REG_CTRL, MXC622X_CTRL_PWRDN);
	assert(result==0);
	hwmon_device_unregister(hwmon_dev);
	#ifdef CONFIG_HAS_EARLYSUSPEND	
	  unregister_early_suspend(&mxc622x_data.early_suspend);
	#endif
	sysfs_remove_group(&mxc622x_idev->input->dev.kobj, &mxc622x_attribute_group);
	input_unregister_polled_device(mxc622x_idev);
	input_free_polled_device(mxc622x_idev);
	i2c_set_clientdata(mxc622x_i2c_client, NULL);	

	return result;
}

#ifdef CONFIG_HAS_EARLYSUSPEND
static void mxc622x_early_suspend(struct early_suspend *h)
{
	int result;
	dprintk(DEBUG_SUSPEND, "mxc6225 early suspend\n");
	mxc622x_data.suspend_indator = 1;
	result = i2c_smbus_write_byte_data(mxc622x_i2c_client, MXC622X_REG_CTRL, MXC622X_CTRL_PWRDN);
	assert(result==0);
	return;
}

static void mxc622x_late_resume(struct early_suspend *h)
{
	int result;
	dprintk(DEBUG_SUSPEND, "mxc6225 late resume\n");
	mxc622x_data.suspend_indator = 0;
	result = i2c_smbus_write_byte_data(mxc622x_i2c_client, MXC622X_REG_CTRL, MXC622X_CTRL_PWRON);
	assert(result==0);
	return;
}
#endif /* CONFIG_HAS_EARLYSUSPEND */

static const struct i2c_device_id mxc622x_id[] = {
	{ MXC622X_DRV_NAME, 1 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, mxc622x_id);

static struct i2c_driver mxc622x_driver = {
	.class = I2C_CLASS_HWMON,
	.driver = {
		.name	= MXC622X_DRV_NAME,
		.owner	= THIS_MODULE,
		.of_match_table = "allwinner,mxc622x",
	},
	.probe	= mxc622x_probe,
	.remove	= mxc622x_remove,
	.id_table = mxc622x_id,
	.address_list	= normal_i2c,
};

static int __init mxc622x_init(void)
{
	int ret = -1;
	dprintk(DEBUG_INIT, "======%s=========. \n", __func__);
	
	if(input_fetch_sysconfig_para(&(gsensor_info.input_type))){
		printk("%s: err.\n", __func__);
		return -1;
	}else{
		ret = input_init_platform_resource(&(gsensor_info.input_type));
		if (0 != ret){
			printk("%s:ctp_ops.init_platform_resource err. \n", __func__);
		}
	}
	
	if(gsensor_info.sensor_used == 0){
		printk("*** used set to 0 !\n");
		printk("*** if use sensor,please put the sys_config.fex gsensor_used set to 1. \n");
		return 0;
	}
	
	input_set_power_enable(&(gsensor_info.input_type),1);

	mxc622x_driver.detect = gsensor_detect;


	ret = i2c_add_driver(&mxc622x_driver);
	if (ret < 0) {
		printk(KERN_INFO "add mxc622x i2c driver failed\n");
		return -ENODEV;
	}
	dprintk(DEBUG_INIT, "add mxc622x i2c driver\n");

	return ret;
}

static void __exit mxc622x_exit(void)
{
	printk(KERN_INFO "remove mxc622x i2c driver.\n");
	i2c_del_driver(&mxc622x_driver);
	input_set_power_enable(&(gsensor_info.input_type),0);
}

MODULE_AUTHOR("yin");
MODULE_DESCRIPTION("mxc622x Sensor driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.1");

module_init(mxc622x_init);
module_exit(mxc622x_exit);