/*
 * VTL CTP driver
 *
 * Copyright (C) 2013 VTL Corporation.
 *
 * 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.
 *
 * 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 St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/version.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/gpio.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/of_gpio.h>
#include <linux/vmalloc.h>


#include "vtl_ts.h"
#include "chip.h"
#include "apk.h"
#include "tp_fw.h"


#define		TS_THREAD_PRIO		90
static DECLARE_WAIT_QUEUE_HEAD(waiter);
//static struct task_struct *ts_thread = NULL;
static unsigned char thread_syn_flag =0;


// ****************************************************************************
// Globel or static variables
// ****************************************************************************
static struct ts_driver	g_driver;
static int vtl_first_init_flag = 1;
struct ts_info	g_ts = {
	.driver = &g_driver,
	.debug  = DEBUG_ENABLE,
};
struct ts_info	*pg_ts = &g_ts;

static struct i2c_device_id vtl_ts_id[] = {
	{ DRIVER_NAME, 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c,vtl_ts_id);


/*
static struct i2c_board_info i2c_info[] = {
	{
		I2C_BOARD_INFO(DRIVER_NAME, 0x01),
		.platform_data = NULL,
	},
};
*/


// ****************************************************************************
// Function declaration
// ****************************************************************************
unsigned char *gtpfw;
static int vtl_ts_config(struct ts_info *ts)
{
	struct device *dev = &ts->driver->client->dev;
	//struct ts_config_info *ts_config_info;	
	int err;
	struct device_node *np = dev->of_node;
	enum of_gpio_flags rst_flags;
	unsigned long irq_flags;
	int val;
	gtpfw = tp_fw;


	DEBUG();
	/* ts config */
	ts->config_info.touch_point_number = TOUCH_POINT_NUM;
	if(dev->platform_data !=NULL)
	{	
		return -1;
	}
	else
	{
		
		if (of_property_read_u32(np, "screen_max_x", &val)) {
			dev_err(&ts->driver->client->dev, "no screen_max_x defined\n");
			return -EINVAL;
		}
		ts->config_info.screen_max_x = val;

		if (of_property_read_u32(np, "screen_max_y", &val)) {
			dev_err(&ts->driver->client->dev, "no screen_max_y defined\n");
			return -EINVAL;
		}
		ts->config_info.screen_max_y = val;

        if (of_property_read_u32(np, "xy_swap", &val)) {
			val = 0;
        }
        ts->config_info.xy_swap = val;

        if (of_property_read_u32(np, "x_reverse", &val)) {
			val = 0;
        }
        ts->config_info.x_reverse = val;

        if (of_property_read_u32(np, "y_reverse", &val)) {
			val = 0;
        }
        ts->config_info.y_reverse = val;

        if (of_property_read_u32(np, "x_mul", &val)) {
			val = 1;
        }
        ts->config_info.x_mul = val;

        if (of_property_read_u32(np, "y_mul", &val)) {
			val = 1;
        }
        ts->config_info.y_mul = val;


		if (of_property_read_u32(np, "bin_ver", &val)) {
            val = 0;
        }
		ts->config_info.bin_ver = val;
		printk("--->>> vtl_ts : xy_swap %d, x_reverse %d, y_reverse %d, x_mul %d, y_mul %d, bin_ver %d\n",
				ts->config_info.xy_swap, 
				ts->config_info.x_reverse, ts->config_info.y_reverse, 
				ts->config_info.x_mul, ts->config_info.y_mul, 
				ts->config_info.bin_ver);
		printk("the screen_x is %d , screen_y is %d \n",ts->config_info.screen_max_x,ts->config_info.screen_max_y);
		
		ts->config_info.irq_gpio_number = of_get_named_gpio_flags(np, "irq_gpio_number", 0, (enum of_gpio_flags *)&irq_flags);
		ts->config_info.rst_gpio_number = of_get_named_gpio_flags(np, "rst_gpio_number", 0, &rst_flags);

	}
	
	ts->config_info.irq_number = gpio_to_irq(ts->config_info.irq_gpio_number);/* IRQ config*/
	
	err = gpio_request(ts->config_info.rst_gpio_number, "vtl_ts_rst");
	if ( err ) {
		return -EIO;
	}
	gpio_direction_output(ts->config_info.rst_gpio_number, 1);
	//gpio_set_value(ts->config_info.rst_gpio_number, 1);

	return 0;
}


struct ts_info	* vtl_ts_get_object(void)
{
	DEBUG();
	
	return pg_ts;
}
#if 0
static void vtl_ts_free_gpio(void)
{
	struct ts_info *ts;
	ts =pg_ts;
	DEBUG();
	
	gpio_free(ts->config_info.rst_gpio_number);	
}
#endif

void vtl_ts_hw_reset(void)
{
	struct ts_info *ts;	
	ts =pg_ts;
	DEBUG();

	//gpio_set_value(ts->config_info.rst_gpio_number, 1);
	//msleep(10);
	gpio_set_value(ts->config_info.rst_gpio_number, 0);
	msleep(50);
	gpio_set_value(ts->config_info.rst_gpio_number, 1);
	//msleep(250);
	msleep(5);
	chip_solfware_reset(ts->driver->client);//20140306
}

static void vtl_ts_wakeup(void)
{
	struct ts_info *ts;	
	ts =pg_ts;
	DEBUG();

	gpio_set_value(ts->config_info.rst_gpio_number, 0);
	//msleep(50);
	msleep(20);
	gpio_set_value(ts->config_info.rst_gpio_number, 1);
	msleep(5);
	chip_solfware_reset(ts->driver->client);//20140306
}

static irqreturn_t vtl_ts_irq(int irq, void *dev)
{
	struct ts_info *ts;	
	ts =pg_ts;
		
	DEBUG();
	
	disable_irq_nosync(ts->config_info.irq_number);// Disable ts interrupt
	thread_syn_flag=1; 
	wake_up_interruptible(&waiter);
	
	return IRQ_HANDLED;
}


static int vtl_ts_read_xy_data(struct ts_info *ts)
{
	struct i2c_msg msgs;
	int ret;
		
	DEBUG();

	msgs.addr = ts->driver->client->addr;
	msgs.flags = 0x01;  // 0x00: write 0x01:read 
	msgs.len = sizeof(ts->xy_data.buf);
	msgs.buf = ts->xy_data.buf;
//	msgs.scl_rate = TS_I2C_SPEED; ///only for rockchip platform
	ret = i2c_transfer( ts->driver->client->adapter, &msgs, 1);
	if(ret != 1){
		printk("___%s:i2c read xy_data err___\n",__func__);
		return -1;
	}
	return 0;
#if 0
	ret = vtl_ts_i2c_read(client,client->addr,ts->xy_data.buf,sizeof(ts->xy_data.buf));
	if(ret){
		printk("___%s:i2c read err___\n",__func__);
		return -1;
	}
	return 0;
#endif
}

static void vtl_ts_report_xy_coord(struct ts_info *ts)
{
	int id;
	int sync;
	int x, y;
	unsigned int press;
	unsigned char touch_point_number;
	static unsigned int release = 0;
	struct input_dev *input_dev;
	union ts_xy_data *xy_data;
	
	DEBUG();

	xy_data = &ts->xy_data;
	input_dev = ts->driver->input_dev;
	touch_point_number = ts->config_info.touch_point_number;
	
	
	
	/* report points */
	sync = 0;  press = 0;
	for ( id = 0; id <touch_point_number; id++ ) //down
	{
		if ((xy_data->point[id].xhi != 0xFF) && (xy_data->point[id].yhi != 0xFF) &&
		     ( (xy_data->point[id].status == 1) || (xy_data->point[id].status == 2))) 
		{

/*
			printk("--->>> vtl_ts report: xy_swap %d, x_reverse %d, y_reverse %d, x_mul %d, y_mul %d, bin_ver %d\n",
					ts->config_info.xy_swap, 
					ts->config_info.x_reverse, ts->config_info.y_reverse, 
					ts->config_info.x_mul, ts->config_info.y_mul, 
					ts->config_info.bin_ver);
*/
		
			if (ts->config_info.xy_swap == 1) {
				x = (xy_data->point[id].yhi<<4)|(xy_data->point[id].ylo&0xF);
				y = (xy_data->point[id].xhi<<4)|(xy_data->point[id].xlo&0xF);
			} else {
				x = (xy_data->point[id].xhi<<4)|(xy_data->point[id].xlo&0xF);
		 		y = (xy_data->point[id].yhi<<4)|(xy_data->point[id].ylo&0xF);
			}
			if (ts->config_info.x_reverse)
				x = ts->config_info.screen_max_x - x;
			if (ts->config_info.y_reverse)
				y = ts->config_info.screen_max_y - y;

			x = ts->config_info.x_mul*x;
			y = ts->config_info.x_mul*y;

		//#if(DEBUG_ENABLE)
		//if((ts->debug)||(DEBUG_ENABLE)){
		if(ts->debug){
			printk("id = %d,status = %d,X = %d,Y = %d\n",xy_data->point[id].id,xy_data->point[id].status,x,y);
			//XY_DEBUG(xy_data->point[id].id,xy_data->point[id].status,x,y);
		}
		//#endif	
			input_mt_slot(input_dev, xy_data->point[id].id - 1);
			input_report_abs(input_dev, ABS_MT_TRACKING_ID, xy_data->point[id].id-1);
			//input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, true);
			input_report_abs(input_dev, ABS_MT_POSITION_X, x);
			input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
			input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, 1);
			input_report_abs(input_dev, ABS_MT_WIDTH_MAJOR, 1);
	
			press |= 0x01 << (xy_data->point[id].id - 1);
			sync = 1;
		
		}
		
	}
	release &= (release ^ press);//release point flag

	for ( id = 0; id < touch_point_number; id++ ) //up
	{
		if ( release & (0x01<<id) ) 
		{
			input_mt_slot(input_dev, id);
			input_report_abs(input_dev, ABS_MT_TRACKING_ID, -1);
			sync = 1;
		}
	}

	release = press;
	if(sync)
	{
		input_sync(input_dev);
	}
}



int vtl_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
	struct ts_info *ts;	
	unsigned char i;
	ts =pg_ts;
	DEBUG();
	if(ts->config_info.ctp_used)
	{
		vtl_first_init_flag = 0;
		disable_irq(ts->config_info.irq_number);
		chip_enter_sleep_mode();
	
		for(i=0;i<ts->config_info.touch_point_number;i++)
		{
			input_mt_slot(ts->driver->input_dev,i);
			input_report_abs(ts->driver->input_dev, ABS_MT_TRACKING_ID, -1);
			//input_mt_report_slot_state(ts->driver->input_dev, MT_TOOL_FINGER, false);
		}
		input_sync(ts->driver->input_dev);
	}
	return 0;
}

int vtl_ts_resume(struct i2c_client *client)
{
	struct ts_info *ts;
	unsigned char i;	
	ts =pg_ts;

	DEBUG();
	if(ts->config_info.ctp_used)
	{
		/* Hardware reset */
		//vtl_ts_hw_reset();
		vtl_ts_wakeup();
		for(i=0;i<ts->config_info.touch_point_number;i++)
		{
			input_mt_slot(ts->driver->input_dev,i);
			input_report_abs(ts->driver->input_dev, ABS_MT_TRACKING_ID, -1);
			//input_mt_report_slot_state(ts->driver->input_dev, MT_TOOL_FINGER, false);
		}
		input_sync(ts->driver->input_dev);
		if(vtl_first_init_flag==0)
			enable_irq(ts->config_info.irq_number);
	}
	return 0;
}

static int vtl_ts_early_suspend(struct tp_device *tp)
{
	struct ts_info *ts;	
	ts =pg_ts;

	DEBUG();

	vtl_ts_suspend(ts->driver->client, PMSG_SUSPEND);

	return 0;
}

static int vtl_ts_early_resume(struct tp_device *tp)
{
	struct ts_info *ts;	
	ts =pg_ts;
	DEBUG();

	vtl_ts_resume(ts->driver->client);

	return 0;
}

static void vtl_ts_remove(struct i2c_client *client)
{
	struct ts_info *ts;	
	ts =pg_ts;

	DEBUG();

	free_irq(ts->config_info.irq_number, ts);   
	gpio_free(ts->config_info.rst_gpio_number);
	//vtl_ts_free_gpio();

	//#ifdef CONFIG_HAS_EARLYSUSPEND
	//unregister_early_suspend(&ts->driver->early_suspend);
	tp_unregister_fb(&ts->tp);
	//#endif
	if(ts->driver->input_dev != NULL)
	{
		input_unregister_device(ts->driver->input_dev);
	}

	if ( ts->driver->proc_entry != NULL ){
		remove_proc_entry(DRIVER_NAME, NULL);
	}
	
	if(ts->driver->ts_thread != NULL)
	{
		printk("___kthread stop start___\n");
		thread_syn_flag=1; 
		wake_up_interruptible(&waiter);
		kthread_stop(ts->driver->ts_thread);
		ts->driver->ts_thread = NULL;
		printk("___kthread stop end___\n");
	}
}

static int vtl_ts_init_input_dev(struct ts_info *ts)
{
	struct input_dev *input_dev;
	struct device *dev;	
	int err;

	DEBUG();

	
	dev = &ts->driver->client->dev;
	
	/* allocate input device */
	ts->driver->input_dev = input_allocate_device();
	if ( ts->driver->input_dev == NULL ) {
		dev_err(dev, "Unable to allocate input device for device %s.\n", DRIVER_NAME);
		return -1;
	}
		
	input_dev = ts->driver->input_dev;

	input_dev->name = DRIVER_NAME;
    	input_dev->id.bustype = BUS_I2C;
    	input_dev->id.vendor  = 0xaaaa;
    	input_dev->id.product = 0x5555;
    	input_dev->id.version = 0x0001; 
	
	/* config input device */
	__set_bit(EV_SYN, input_dev->evbit);
	__set_bit(EV_KEY, input_dev->evbit);
	__set_bit(EV_ABS, input_dev->evbit);

	
	//set_bit(BTN_TOUCH, input_dev->keybit);//20130923
	//set_bit(ABS_MT_POSITION_X, input_dev->absbit);//20130923
    	//set_bit(ABS_MT_POSITION_Y, input_dev->absbit);//20130923

	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
	
	input_mt_init_slots(input_dev, TOUCH_POINT_NUM,0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, ts->config_info.screen_max_x, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, ts->config_info.screen_max_y, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0,ts->config_info.touch_point_number, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);


	/* register input device */
	err = input_register_device(input_dev);
	if ( err ) {
		input_free_device(ts->driver->input_dev);
		ts->driver->input_dev = NULL;
		dev_err(dev, "Unable to register input device for device %s.\n", DRIVER_NAME);
		return -1;
	}
	
	return 0;
}


static int vtl_ts_handler(void *data)
{
	int ret;
	struct device *dev;
	struct ts_info *ts;
	//struct sched_param param = { .sched_priority = TS_THREAD_PRIO};
	DEBUG();
	//sched_setscheduler(current, SCHED_RR, &param);

	ts = (struct ts_info *)data;
	dev = &ts->driver->client->dev;


	/* Request platform resources (gpio/interrupt pins) */
	ret = vtl_ts_config(ts);
	if(ret){

		dev_err(dev, "VTL touch screen config Failed.\n");
		goto ERR_TS_CONFIG;
	}
	
	vtl_ts_hw_reset();


	ret = chip_init();
	if(ret){

		dev_err(dev, "vtl ts chip init failed.\n");
		goto ERR_CHIP_INIT;
	}

	/*init input dev*/
	ret = vtl_ts_init_input_dev(ts);
	if(ret){

		dev_err(dev, "init input dev failed.\n");
		goto ERR_INIT_INPUT;
	}

	/* Create Proc Entry File */
	#if 0
	ts->driver->proc_entry = create_proc_entry(DRIVER_NAME, 0666/*S_IFREG | S_IRUGO | S_IWUSR*/, NULL);
	if ( ts->driver->proc_entry == NULL ) {
		dev_err(dev, "Failed creating proc dir entry file.\n");
		goto ERR_PROC_ENTRY;
	}  else{
		ts->driver->proc_entry->proc_fops = &apk_fops;
	}
	#endif
	/* register early suspend */
//#ifdef CONFIG_HAS_EARLYSUSPEND
	//ts->driver->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	//ts->driver->early_suspend.suspend = vtl_ts_early_suspend;
	//ts->driver->early_suspend.resume = vtl_ts_early_resume;
	//register_early_suspend(&ts->driver->early_suspend);
	
	
//#endif

	/* Init irq */
	ret = request_irq(ts->config_info.irq_number, vtl_ts_irq, IRQF_TRIGGER_FALLING, DRIVER_NAME, ts);
	if ( ret ) {
		dev_err(dev, "Unable to request irq for device %s.\n", DRIVER_NAME);
		goto ERR_IRQ_REQ;
	}
	//disable_irq(pg_ts->config_info.irq_number);
	ts->config_info.ctp_used =1;
	
	ts->tp.tp_resume = vtl_ts_early_resume;
    ts->tp.tp_suspend = vtl_ts_early_suspend;
    tp_register_fb(&ts->tp);
	
	while (!kthread_should_stop())//while(1)
	{
		//set_current_state(TASK_INTERRUPTIBLE);	
		wait_event_interruptible(waiter, thread_syn_flag);
		thread_syn_flag = 0;
		//set_current_state(TASK_RUNNING);
		//printk("__state = %x_%x_\n",current->state,ts->driver->ts_thread->state);
		ret = vtl_ts_read_xy_data(ts);

		if(!ret){
			vtl_ts_report_xy_coord(ts);
		}
		else
		{
			printk("____read xy_data error___\n");
		}
		// Enable ts interrupt
		enable_irq(pg_ts->config_info.irq_number);
	}
	
	printk("vtl_ts_Kthread exit,%s(%d)\n",__func__,__LINE__);
	return 0;




ERR_IRQ_REQ:
	//#ifdef CONFIG_HAS_EARLYSUSPEND
	//unregister_early_suspend(&ts->driver->early_suspend);
	//#endif
	tp_unregister_fb(&ts->tp);
	if ( ts->driver->proc_entry ){
		remove_proc_entry(DRIVER_NAME, NULL); 
		ts->driver->proc_entry = NULL;
	}

/* ERR_PROC_ENTRY: */
	if(ts->driver->input_dev){
		input_unregister_device(ts->driver->input_dev);
		ts->driver->input_dev = NULL;
	}
ERR_INIT_INPUT:
ERR_CHIP_INIT:	
	gpio_free(ts->config_info.rst_gpio_number);
ERR_TS_CONFIG:
	ts->config_info.ctp_used =0;
	printk("vtl_ts_Kthread exit,%s(%d)\n",__func__,__LINE__);
	//do_exit(0);
	return 0;
}



int vtl_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int err = -1;
	struct ts_info *ts;
	struct device *dev;

	DEBUG();

	ts = pg_ts;
	ts->driver->client = client;
	dev = &ts->driver->client->dev;
	
	/* Check I2C Functionality */
	err = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
	if ( !err ) {
		dev_err(dev, "Check I2C Functionality Failed.\n");
		return ENODEV;
	}
	

	//ts->driver->ts_thread = kthread_run(vtl_ts_handler, NULL, DRIVER_NAME);
	ts->driver->ts_thread = kthread_run(vtl_ts_handler, ts, DRIVER_NAME);
	if (IS_ERR(ts->driver->ts_thread)) {
		err = PTR_ERR(ts->driver->ts_thread);
		ts->driver->ts_thread = NULL;
		dev_err(dev, "failed to create kernel thread: %d\n", err);
		return -1;
		//goto ERR_CREATE_TS_THREAD;
	}

	printk("___%s() end____ \n", __func__);
	
	return 0;
	


}

static struct of_device_id vtl_ts_dt_ids[] = {
	{ .compatible = "ct,vtl_ts" },
	{ }
};

struct i2c_driver vtl_ts_driver  = {
	
	.driver = {
		.owner	= THIS_MODULE,
		.name	= DRIVER_NAME,
		.of_match_table = of_match_ptr(vtl_ts_dt_ids),
	},
	.id_table	= vtl_ts_id,
	.probe      	= vtl_ts_probe,
//#ifndef CONFIG_HAS_EARLYSUSPEND
	//.suspend	= vtl_ts_suspend,
	//.resume	    	= vtl_ts_resume,
//#endif
	.remove 	= vtl_ts_remove,
};



int __init vtl_ts_init(void)
{
	DEBUG();
	return i2c_add_driver(&vtl_ts_driver);
}

void __exit vtl_ts_exit(void)
{
	DEBUG();
	i2c_del_driver(&vtl_ts_driver);
}

module_init(vtl_ts_init);
module_exit(vtl_ts_exit);

MODULE_AUTHOR("yangdechu@vtl.com.cn");
MODULE_DESCRIPTION("VTL touchscreen driver for rockchip,V1.0");
MODULE_LICENSE("GPL");