/*++
 
 Copyright (c) 2012-2022 ChipOne Technology (Beijing) Co., Ltd. All Rights Reserved.
 This PROPRIETARY SOFTWARE is the property of ChipOne Technology (Beijing) Co., Ltd. 
 and may contains trade secrets and/or other confidential information of ChipOne 
 Technology (Beijing) Co., Ltd. This file shall not be disclosed to any third party,
 in whole or in part, without prior written consent of ChipOne.  
 THIS PROPRIETARY SOFTWARE & ANY RELATED DOCUMENTATION ARE PROVIDED AS IS, 
 WITH ALL FAULTS, & WITHOUT WARRANTY OF ANY KIND. CHIPONE DISCLAIMS ALL EXPRESS OR 
 IMPLIED WARRANTIES.  
 
 File Name:    icn83xx.c
 Abstract:
               input driver.
 Author:       Zhimin Tian
 Date :        01,17,2013
 Version:      1.0
 History :
     2012,10,30, V0.1 first version  
 --*/

#include <linux/i2c/icn83xx.h>
#include <linux/notifier.h>


#if COMPILE_FW_WITH_DRIVER
#include "icn83xx_fw.h"
#endif

//static struct regulator *tp_regulator = NULL;
static struct i2c_client *this_client;
short log_rawdata[28][16] = {0,};
short log_diffdata[28][16] = {0,};

static char firmware[128] = {"/system/vendor/firmware/icn83xx.bin"};

//extern void atc260x_set_adjust_tp_para(void *ptr);
//extern int atc260x_get_charge_status();
static BLOCKING_NOTIFIER_HEAD(touch_key_notifier);

int register_touch_key_notifier(struct notifier_block *n)
{
	return blocking_notifier_chain_register(&touch_key_notifier, n);
}

int unregister_touch_key_notifier(struct notifier_block *n)
{
	return blocking_notifier_chain_unregister(&touch_key_notifier, n);
}

#if SUPPORT_SYSFS
static enum hrtimer_restart chipone_timer_func(struct hrtimer *timer);

static ssize_t icn83xx_show_update(struct device* cd,struct device_attribute *attr, char* buf);
static ssize_t icn83xx_store_update(struct device* cd, struct device_attribute *attr, const char* buf, size_t len);
static ssize_t icn83xx_show_process(struct device* cd,struct device_attribute *attr, char* buf);
static ssize_t icn83xx_store_process(struct device* cd, struct device_attribute *attr,const char* buf, size_t len);

static DEVICE_ATTR(update, S_IRUGO | S_IWUSR, icn83xx_show_update, icn83xx_store_update);
static DEVICE_ATTR(process, S_IRUGO | S_IWUSR, icn83xx_show_process, icn83xx_store_process);

static ssize_t icn83xx_show_process(struct device* cd,struct device_attribute *attr, char* buf)
{
    ssize_t ret = 0;
    sprintf(buf, "icn83xx process\n");
    ret = strlen(buf) + 1;
    return ret;
}

static ssize_t icn83xx_store_process(struct device* cd, struct device_attribute *attr,
               const char* buf, size_t len)
{
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    unsigned long on_off = simple_strtoul(buf, NULL, 10); 
    if(on_off == 0)
    {
        icn83xx_ts->work_mode = on_off;
    }
    else if((on_off == 1) || (on_off == 2))
    {
        if((icn83xx_ts->work_mode == 0) && (icn83xx_ts->use_irq == 1))
        {
            hrtimer_init(&icn83xx_ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
            icn83xx_ts->timer.function = chipone_timer_func;
            hrtimer_start(&icn83xx_ts->timer, ktime_set(CTP_START_TIMER/1000, (CTP_START_TIMER%1000)*1000000), HRTIMER_MODE_REL);
        }
        icn83xx_ts->work_mode = on_off;
    }
    return len;
}

static ssize_t icn83xx_show_update(struct device* cd,
                     struct device_attribute *attr, char* buf)
{
    ssize_t ret = 0;     
    sprintf(buf, "icn83xx firmware\n");
    //ret = strlen(buf) + 1;
    icn83xx_fw_update(firmware);
    return ret;
}

static ssize_t icn83xx_store_update(struct device* cd, struct device_attribute *attr, const char* buf, size_t len)
{
    int err=0;
    unsigned long on_off = simple_strtoul(buf, NULL, 10); 
    return len;
}

static int icn83xx_create_sysfs(struct i2c_client *client)
{
    int err;
    struct device *dev = &(client->dev);
    icn83xx_trace("%s: \n",__func__);    
    err = device_create_file(dev, &dev_attr_update);
    err = device_create_file(dev, &dev_attr_process);
    return err;
}

#endif

#if SUPPORT_PROC_FS

pack_head cmd_head;
static struct proc_dir_entry *icn83xx_proc_entry;
int  DATA_LENGTH = 0;
static int icn83xx_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
{
    int ret = 0;
    
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    proc_info("%s \n",__func__);  
    if(down_interruptible(&icn83xx_ts->sem))  
    {  
        return -1;   
    }     
    ret = copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
    if(ret)
    {
        proc_error("copy_from_user failed.\n");
        goto write_out;
    }  
    else
    {
        ret = CMD_HEAD_LENGTH;
    }
    
    proc_info("wr  :0x%02x.\n", cmd_head.wr);
    proc_info("flag:0x%02x.\n", cmd_head.flag);
    proc_info("circle  :%d.\n", (int)cmd_head.circle);
    proc_info("times   :%d.\n", (int)cmd_head.times);
    proc_info("retry   :%d.\n", (int)cmd_head.retry);
    proc_info("data len:%d.\n", (int)cmd_head.data_len);
    proc_info("addr len:%d.\n", (int)cmd_head.addr_len);
    proc_info("addr:0x%02x%02x.\n", cmd_head.addr[0], cmd_head.addr[1]);
    proc_info("len:%d.\n", (int)len);
    proc_info("data:0x%02x%02x.\n", buff[CMD_HEAD_LENGTH], buff[CMD_HEAD_LENGTH+1]);
    if (1 == cmd_head.wr)  // write iic
    {
        if(1 == cmd_head.addr_len)
        {
            ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
            if(ret)
            {
                proc_error("copy_from_user failed.\n");
                goto write_out;
            }
            ret = icn83xx_i2c_txdata(cmd_head.addr[0], &cmd_head.data[0], cmd_head.data_len);
            if (ret < 0) {
                proc_error("write iic failed! ret: %d\n", ret);
                goto write_out;
            }
            ret = cmd_head.data_len + CMD_HEAD_LENGTH;
            goto write_out;
        }
    }
    else if(3 == cmd_head.wr)
    {
        ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
        if(ret)
        {
            proc_error("copy_from_user failed.\n");
            goto write_out;
        }
        ret = cmd_head.data_len + CMD_HEAD_LENGTH;
        memset(firmware, 0, 128);
        memcpy(firmware, &cmd_head.data[0], cmd_head.data_len);
        proc_info("firmware : %s\n", firmware);
    }
    else if(5 == cmd_head.wr)
    {        
        icn83xx_update_status(1);  
        ret = kernel_thread(icn83xx_fw_update,firmware,CLONE_KERNEL);
        icn83xx_trace("the kernel_thread result is:%d\n", ret);    
    }
    else if(7 == cmd_head.wr)  //write reg
    { 
        if(2 == cmd_head.addr_len)
        {
            ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
            if(ret)
            {
                proc_error("copy_from_user failed.\n");
                goto write_out;
            }
            ret = icn83xx_writeReg((cmd_head.addr[0]<<8)|cmd_head.addr[1], cmd_head.data[0]);
            if (ret < 0) {
                proc_error("write reg failed! ret: %d\n", ret);
                goto write_out;
            }
            ret = cmd_head.data_len + CMD_HEAD_LENGTH;
            goto write_out;   

        }
    }

write_out:
    up(&icn83xx_ts->sem); 
    return len;
    
}
static int icn83xx_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )
{
    int i;
    int ret = 0;
    int data_len = 0;
    int len = 0;
    int loc = 0;
    char retvalue;
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    if(down_interruptible(&icn83xx_ts->sem))  
    {  
        return -1;   
    }     
    proc_info("%s: count:%d, off:%d, cmd_head.data_len: %d\n",__func__, count, off, cmd_head.data_len); 
    if (cmd_head.wr % 2)
    {
        ret = 0;
        goto read_out;
    }
    else if (0 == cmd_head.wr)   //read iic
    {
        if(1 == cmd_head.addr_len)
        {
            data_len = cmd_head.data_len;
            if(cmd_head.addr[0] == 0xff)
            {                
                page[0] = 83;
                proc_info("read ic type: %d\n", page[0]);
            }
            else
            {
                while(data_len>0)
                {
                    if (data_len > DATA_LENGTH)
                    {
                        len = DATA_LENGTH;
                    }
                    else
                    {
                        len = data_len;
                    }
                    data_len -= len;   
                    memset(&cmd_head.data[0], 0, len+1);
                    ret = icn83xx_i2c_rxdata(cmd_head.addr[0]+loc, &cmd_head.data[0], len);
                    //proc_info("cmd_head.data[0]: 0x%02x\n", cmd_head.data[0]);
                    //proc_info("cmd_head.data[1]: 0x%02x\n", cmd_head.data[1]);
                    if(ret < 0)
                    {
                        icn83xx_error("read iic failed: %d\n", ret);
                        goto read_out;
                    }
                    else
                    {
                        //proc_info("iic read out %d bytes, loc: %d\n", len, loc);
                        memcpy(&page[loc], &cmd_head.data[0], len);
                    }
                    loc += len;
                }
                proc_info("page[0]: 0x%02x\n", page[0]);
                proc_info("page[1]: 0x%02x\n", page[1]);
            }
        }
    }
    else if(2 == cmd_head.wr)  //read rawdata
    {
        //scan tp rawdata
        icn83xx_write_reg(4, 0x20); 
        mdelay(cmd_head.times);
        icn83xx_read_reg(2, &retvalue);
        while(retvalue != 1)
        {
            mdelay(cmd_head.times);
            icn83xx_read_reg(2, &retvalue);
        }            
  
        if(2 == cmd_head.addr_len)
        {
            for(i=0; i<cmd_head.addr[1]; i++)
            {
                icn83xx_write_reg(3, i);
                mdelay(cmd_head.times);
                ret = icn83xx_i2c_rxdata(128, &cmd_head.data[0], cmd_head.addr[0]*2);
                if (ret < 0) 
                {
                    icn83xx_error("read rawdata failed: %d\n", ret);            
                    goto read_out;           
                }
                else
                {
                    //proc_info("read rawdata out %d bytes, loc: %d\n", cmd_head.addr[0]*2, loc);                    
                    memcpy(&page[loc], &cmd_head.data[0], cmd_head.addr[0]*2);
                }
                loc += cmd_head.addr[0]*2;
            }  
            for(i=0; i<cmd_head.data_len; i=i+2)
            {
                swap_ab(page[i], page[i+1]);
            }
            //icn83xx_rawdatadump(&page[0], cmd_head.data_len/2, cmd_head.addr[0]);
        }

        //finish scan tp rawdata
        icn83xx_write_reg(2, 0x0); 

    }
    else if(4 == cmd_head.wr)  //get update status
    {
        page[0] = icn83xx_get_status();
    }
    else if(6 == cmd_head.wr)  //read reg
    {   
        if(2 == cmd_head.addr_len)
        {
            ret = icn83xx_readReg((cmd_head.addr[0]<<8)|cmd_head.addr[1], &cmd_head.data[0]);
            if (ret < 0) {
                proc_error("reg reg failed! ret: %d\n", ret);
                goto read_out;
            }
            page[0] = cmd_head.data[0];
            goto read_out;   
        }
    }
read_out:
    up(&icn83xx_ts->sem);   
    proc_info("%s out: %d, cmd_head.data_len: %d\n\n",__func__, count, cmd_head.data_len); 
    return cmd_head.data_len;
}

int init_proc_node()
{
    int i;
    memset(&cmd_head, 0, sizeof(cmd_head));
    cmd_head.data = NULL;

    i = 5;
    while ((!cmd_head.data) && i)
    {
        cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
        if (NULL != cmd_head.data)
        {
            break;
        }
        i--;
    }
    if (i)
    {
        //DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
        DATA_LENGTH = i * DATA_LENGTH_UINT;
        icn83xx_trace("alloc memory size:%d.\n", DATA_LENGTH);
    }
    else
    {
        proc_error("alloc for memory failed.\n");
        return 0;
    }

    icn83xx_proc_entry = create_proc_entry(ICN83XX_ENTRY_NAME, 0666, NULL);
    if (icn83xx_proc_entry == NULL)
    {
        proc_error("Couldn't create proc entry!\n");
        return 0;
    }
    else
    {
        icn83xx_trace("Create proc entry success!\n");
        icn83xx_proc_entry->write_proc = icn83xx_tool_write;
        icn83xx_proc_entry->read_proc = icn83xx_tool_read;
    }

    return 1;
}

void uninit_proc_node(void)
{
    kfree(cmd_head.data);
    cmd_head.data = NULL;
    remove_proc_entry(ICN83XX_ENTRY_NAME, NULL);
}
    
#endif


#if TOUCH_VIRTUAL_KEYS
static ssize_t virtual_keys_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
{
    return sprintf(buf,
     __stringify(EV_KEY) ":" __stringify(KEY_MENU) ":100:1030:50:60"
     ":" __stringify(EV_KEY) ":" __stringify(KEY_HOME) ":280:1030:50:60"
     ":" __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":470:1030:50:60"
     ":" __stringify(EV_KEY) ":" __stringify(KEY_SEARCH) ":900:1030:50:60"
     "\n");
}

static struct kobj_attribute virtual_keys_attr = {
    .attr = {
        .name = "virtualkeys.chipone-ts",
        .mode = S_IRUGO,
    },
    .show = &virtual_keys_show,
};

static struct attribute *properties_attrs[] = {
    &virtual_keys_attr.attr,
    NULL
};

static struct attribute_group properties_attr_group = {
    .attrs = properties_attrs,
};

static void icn83xx_ts_virtual_keys_init(void)
{
    int ret;
    struct kobject *properties_kobj;      
    properties_kobj = kobject_create_and_add("board_properties", NULL);
    if (properties_kobj)
        ret = sysfs_create_group(properties_kobj,
                     &properties_attr_group);
    if (!properties_kobj || ret)
        pr_err("failed to create board_properties\n");    
}
#endif

/* ---------------------------------------------------------------------
*
*   Chipone panel related driver
*
*
----------------------------------------------------------------------*/
/***********************************************************************************************
Name    :   icn83xx_ts_wakeup 
Input   :   void
Output  :   ret
function    : this function is used to wakeup tp
***********************************************************************************************/
void icn83xx_ts_wakeup(void)
{
}

/***********************************************************************************************
Name    :   icn83xx_ts_reset 
Input   :   void
Output  :   ret
function    : this function is used to reset tp, you should not delete it
***********************************************************************************************/
void icn83xx_ts_reset(void)
{
    //set reset func
    gpio_set_value_cansleep(CTP_RST_PORT, 0);
	msleep(20);
	gpio_set_value_cansleep(CTP_RST_PORT, 1);
    msleep(200);
}

/***********************************************************************************************
Name    :   icn83xx_irq_disable 
Input   :   void
Output  :   ret
function    : this function is used to disable irq
***********************************************************************************************/
void icn83xx_irq_disable(void)
{
    unsigned long irqflags;
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);

    spin_lock_irqsave(&icn83xx_ts->irq_lock, irqflags);
    if (!icn83xx_ts->irq_is_disable)
    {
        icn83xx_ts->irq_is_disable = 1; 
        disable_irq_nosync(icn83xx_ts->irq);
        //disable_irq(icn83xx_ts->irq);
    }
    spin_unlock_irqrestore(&icn83xx_ts->irq_lock, irqflags);
}

/***********************************************************************************************
Name    :   icn83xx_irq_enable 
Input   :   void
Output  :   ret
function    : this function is used to enable irq
***********************************************************************************************/
void icn83xx_irq_enable(void)
{
    unsigned long irqflags = 0;
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);

    spin_lock_irqsave(&icn83xx_ts->irq_lock, irqflags);
    if (icn83xx_ts->irq_is_disable) 
    {
        enable_irq(icn83xx_ts->irq);
        icn83xx_ts->irq_is_disable = 0; 
    }
    spin_unlock_irqrestore(&icn83xx_ts->irq_lock, irqflags);

}

/***********************************************************************************************
Name    :   icn83xx_prog_i2c_rxdata 
Input   :   addr
            *rxdata
            length
Output  :   ret
function    : read data from icn83xx, prog mode 
***********************************************************************************************/
int icn83xx_prog_i2c_rxdata(unsigned short addr, char *rxdata, int length)
{
    int ret = -1;
    int retries = 0;
#if 0   
    struct i2c_msg msgs[] = {   
        {
            .addr   = ICN83XX_PROG_IIC_ADDR,//this_client->addr,
            .flags  = I2C_M_RD,
            .len    = length,
            .buf    = rxdata,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
    };
        
    icn83xx_prog_i2c_txdata(addr, NULL, 0);
    while(retries < IIC_RETRY_NUM)
    {    
        ret = i2c_transfer(this_client->adapter, msgs, 1);
        if(ret == 1)break;
        retries++;
    }
    if (retries >= IIC_RETRY_NUM)
    {
        icn83xx_error("%s i2c read error: %d\n", __func__, ret); 
//        icn83xx_ts_reset();
    }    
#else
    unsigned char tmp_buf[2];
    struct i2c_msg msgs[] = {
        {
            .addr   = ICN83XX_PROG_IIC_ADDR,//this_client->addr,
            .flags  = 0,
            .len    = 2,
            .buf    = tmp_buf,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
        {
            .addr   = ICN83XX_PROG_IIC_ADDR,//this_client->addr,
            .flags  = I2C_M_RD,
            .len    = length,
            .buf    = rxdata,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
    };
    tmp_buf[0] = U16HIBYTE(addr);
    tmp_buf[1] = U16LOBYTE(addr);  

    while(retries < IIC_RETRY_NUM)
    {
        ret = i2c_transfer(this_client->adapter, msgs, 2);
        if(ret == 2)break;
        retries++;
        //printk("icn83xx_prog_i2c_rxdata: %d, ret: %d\n", retries, ret);
    }

    if (retries >= IIC_RETRY_NUM)
    {
        icn83xx_error("%s i2c read error: %d\n", __func__, ret); 
//        icn83xx_ts_reset();
    }
#endif      
    return ret;
}
/***********************************************************************************************
Name    :   icn83xx_prog_i2c_txdata 
Input   :   addr
            *rxdata
            length
Output  :   ret
function    : send data to icn83xx , prog mode
***********************************************************************************************/
int icn83xx_prog_i2c_txdata(unsigned short addr, char *txdata, int length)
{
    int ret = -1;
    char tmp_buf[128];
    int retries = 0; 
    struct i2c_msg msg[] = {
        {
            .addr   = ICN83XX_PROG_IIC_ADDR,//this_client->addr,
            .flags  = 0,
            .len    = length + 2,
            .buf    = tmp_buf,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
    };
    
    if (length > 125)
    {
        icn83xx_error("%s too big datalen = %d!\n", __func__, length);
        return -1;
    }
    
    tmp_buf[0] = U16HIBYTE(addr);
    tmp_buf[1] = U16LOBYTE(addr);

    if (length != 0 && txdata != NULL)
    {
        memcpy(&tmp_buf[2], txdata, length);
    }   
    
    while(retries < IIC_RETRY_NUM)
    {
        ret = i2c_transfer(this_client->adapter, msg, 1);
        if(ret > 0)break;
        retries++;
        //printk("icn83xx_prog_i2c_txdata: %d, ret: %d\n", retries, ret);
    }

    if (retries >= IIC_RETRY_NUM)
    {
        icn83xx_error("%s i2c write error: %d\n", __func__, ret); 
//        icn83xx_ts_reset();
    }
    return ret;
}
/***********************************************************************************************
Name    :   icn83xx_prog_write_reg
Input   :   addr -- address
            para -- parameter
Output  :   
function    :   write register of icn83xx, prog mode
***********************************************************************************************/
int icn83xx_prog_write_reg(unsigned short addr, char para)
{
    char buf[3];
    int ret = -1;

    buf[0] = para;
    ret = icn83xx_prog_i2c_txdata(addr, buf, 1);
    if (ret < 0) {
        icn83xx_error("write reg failed! %#x ret: %d\n", buf[0], ret);
        return -1;
    }
    
    return ret;
}


/***********************************************************************************************
Name    :   icn83xx_prog_read_reg 
Input   :   addr
            pdata
Output  :   
function    :   read register of icn83xx, prog mode
***********************************************************************************************/
int icn83xx_prog_read_reg(unsigned short addr, char *pdata)
{
    int ret = -1;
    ret = icn83xx_prog_i2c_rxdata(addr, pdata, 1);  
    return ret;    
}

/***********************************************************************************************
Name    :   icn83xx_i2c_rxdata 
Input   :   addr
            *rxdata
            length
Output  :   ret
function    : read data from icn83xx, normal mode   
***********************************************************************************************/
int icn83xx_i2c_rxdata(unsigned char addr, char *rxdata, int length)
{
    int ret = -1;
    int retries = 0;
#if 0
    struct i2c_msg msgs[] = {   
        {
            .addr   = this_client->addr,
            .flags  = I2C_M_RD,
            .len    = length,
            .buf    = rxdata,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
    };
        
    icn83xx_i2c_txdata(addr, NULL, 0);
    while(retries < IIC_RETRY_NUM)
    {

        ret = i2c_transfer(this_client->adapter, msgs, 1);
        if(ret == 1)break;
        retries++;
    }

    if (retries >= IIC_RETRY_NUM)
    {
        icn83xx_error("%s i2c read error: %d\n", __func__, ret); 
//        icn83xx_ts_reset();
    }

#else
    unsigned char tmp_buf[1];
    struct i2c_msg msgs[] = {
        {
            .addr   = this_client->addr,
            .flags  = 0,
            .len    = 1,
            .buf    = tmp_buf,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
        {
            .addr   = this_client->addr,
            .flags  = I2C_M_RD,
            .len    = length,
            .buf    = rxdata,
#if SUPPORT_ROCKCHIP            
            .scl_rate = ICN83XX_I2C_SCL,
#endif
        },
    };
    tmp_buf[0] = addr; 
    
    while(retries < IIC_RETRY_NUM)
    {
        ret = i2c_transfer(this_client->adapter, msgs, 2);
        if(ret == 2)break;
        retries++;
        //printk("icn83xx_i2c_rxdata: %d, ret: %d\n", retries, ret);
    }

    if (retries >= IIC_RETRY_NUM)
    {
        icn83xx_error("%s i2c read error: %d\n", __func__, ret); 
//        icn83xx_ts_reset();
    }    
#endif

    return ret;
}
/***********************************************************************************************
Name    :   icn83xx_i2c_txdata 
Input   :   addr
            *rxdata
            length
Output  :   ret
function    : send data to icn83xx , normal mode
***********************************************************************************************/
int icn83xx_i2c_txdata(unsigned char addr, char *txdata, int length)
{
    int ret = -1;
    unsigned char tmp_buf[128];
    int retries = 0;

    struct i2c_msg msg[] = {
        {
            .addr   = this_client->addr,
            .flags  = 0,
            .len    = length + 1,
            .buf    = tmp_buf,
#if SUPPORT_ROCKCHIP             
            .scl_rate = ICN83XX_I2C_SCL,
#endif            
        },
    };
    
    if (length > 125)
    {
        icn83xx_error("%s too big datalen = %d!\n", __func__, length);
        return -1;
    }
    
    tmp_buf[0] = addr;

    if (length != 0 && txdata != NULL)
    {
        memcpy(&tmp_buf[1], txdata, length);
    }   
    
    while(retries < IIC_RETRY_NUM)
    {
        ret = i2c_transfer(this_client->adapter, msg, 1);
        if(ret == 1)break;
        retries++;
        //printk("icn83xx_i2c_txdata: %d, ret: %d\n", retries, ret);
    }

    if (retries >= IIC_RETRY_NUM)
    {
        icn83xx_error("%s i2c write error: %d\n", __func__, ret); 
//        icn83xx_ts_reset();
    }

    return ret;
}

/***********************************************************************************************
Name    :   icn83xx_write_reg
Input   :   addr -- address
            para -- parameter
Output  :   
function    :   write register of icn83xx, normal mode
***********************************************************************************************/
int icn83xx_write_reg(unsigned char addr, char para)
{
    char buf[3];
    int ret = -1;

    buf[0] = para;
    ret = icn83xx_i2c_txdata(addr, buf, 1);
    if (ret < 0) {
        icn83xx_error("write reg failed! %#x ret: %d\n", buf[0], ret);
        return -1;
    }
    
    return ret;
}


/***********************************************************************************************
Name    :   icn83xx_read_reg 
Input   :   addr
            pdata
Output  :   
function    :   read register of icn83xx, normal mode
***********************************************************************************************/
int icn83xx_read_reg(unsigned char addr, char *pdata)
{
    int ret = -1;
    ret = icn83xx_i2c_rxdata(addr, pdata, 1);  
    return ret;    
}

#if SUPPORT_FW_UPDATE
/***********************************************************************************************
Name    :   icn83xx_log
Input   :   0: rawdata, 1: diff data
Output  :   err type
function    :   calibrate param
***********************************************************************************************/
int  icn83xx_log(char diff)
{
    char row = 0;
    char column = 0;
    int i, j;
    icn83xx_read_reg(160, &row);
    icn83xx_read_reg(161, &column);

    if(diff == 1)
    {
        icn83xx_readTP(row, column, &log_diffdata[0][0]);

        for(i=0; i<row; i++)
        {       
            for(j=0; j<column; j++)
            {
                log_diffdata[i][j] = log_diffdata[i][j] - log_rawdata[i][j];
            }
        }   
        icn83xx_rawdatadump(&log_diffdata[0][0], row*16, 16);
    }
    else
    {
        icn83xx_readTP(row, column, &log_rawdata[0][0]);    
        icn83xx_rawdatadump(&log_rawdata[0][0], row*16, 16);
    }
}
#endif

/***********************************************************************************************
Name    :   icn83xx_iic_test 
Input   :   void
Output  :   
function    : 0 success,
***********************************************************************************************/
static int icn83xx_iic_test(void)
{
    int  ret = -1;
    char value = 0;
    int  retry = 0;
    while(retry++ < 3)
    {        
        ret = icn83xx_read_reg(0, &value);
        if(ret > 0)
        {
            return ret;
        }
        icn83xx_error("iic test error! %d\n", retry);
        msleep(3);
    }
    return ret;    
}
/***********************************************************************************************
Name    :   icn83xx_ts_release 
Input   :   void
Output  :   
function    : touch release
***********************************************************************************************/
static void icn83xx_ts_release(void)
{
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    icn83xx_info("==icn83xx_ts_release ==\n");
    input_report_abs(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
    input_sync(icn83xx_ts->input_dev);
}

/***********************************************************************************************
Name    :   icn83xx_report_value_A
Input   :   void
Output  :   
function    : reprot touch ponit
***********************************************************************************************/
static void icn83xx_report_value_A(void)
{
    icn83xx_info("==icn83xx_report_value_A ==\n");
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    char buf[POINT_NUM*POINT_SIZE+3]={0};
    int ret = -1;
    int i;
#if TOUCH_VIRTUAL_KEYS
    unsigned char button;
    static unsigned char button_last;
#endif

    ret = icn83xx_i2c_rxdata(16, buf, POINT_NUM*POINT_SIZE+2);
    if (ret < 0) {
        icn83xx_error("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
        return ret;
    }
#if TOUCH_VIRTUAL_KEYS    
    button = buf[0];    
    icn83xx_info("%s: button=%d\n",__func__, button);

    if((button_last != 0) && (button == 0))
    {
        icn83xx_ts_release();
        button_last = button;
        return 1;       
    }
    if(button != 0)
    {
        switch(button)
        {
            case ICN_VIRTUAL_BUTTON_HOME:
                icn83xx_info("ICN_VIRTUAL_BUTTON_HOME down\n");
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, 200);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_X, 280);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_Y, 1030);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_WIDTH_MAJOR, 1);
				blocking_notifier_call_chain(
						&touch_key_notifier, 0, NULL);
                input_mt_sync(icn83xx_ts->input_dev);
                input_sync(icn83xx_ts->input_dev);
                break;
            case ICN_VIRTUAL_BUTTON_BACK:
                icn83xx_info("ICN_VIRTUAL_BUTTON_BACK down\n");
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, 200);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_X, 470);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_Y, 1030);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_WIDTH_MAJOR, 1);
				blocking_notifier_call_chain(
						&touch_key_notifier, 0, NULL);
                input_mt_sync(icn83xx_ts->input_dev);
                input_sync(icn83xx_ts->input_dev);                
                break;
            case ICN_VIRTUAL_BUTTON_MENU:
                icn83xx_info("ICN_VIRTUAL_BUTTON_MENU down\n");
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, 200);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_X, 100);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_Y, 1030);
                input_report_abs(icn83xx_ts->input_dev, ABS_MT_WIDTH_MAJOR, 1);
				blocking_notifier_call_chain(
						&touch_key_notifier, 0, NULL);
                input_mt_sync(icn83xx_ts->input_dev);
                input_sync(icn83xx_ts->input_dev);            
                break;                      
            default:
                icn83xx_info("other gesture\n");
                break;          
        }
        button_last = button;
        return 1;
    }        
#endif
 
    icn83xx_ts->point_num = buf[1];    
    if (icn83xx_ts->point_num == 0) {
        icn83xx_ts_release();
        return 1; 
    }   
    for(i=0;i<icn83xx_ts->point_num;i++){
        if(buf[8 + POINT_SIZE*i]  != 4) break ;
    }
    
    if(i == icn83xx_ts->point_num) {
        icn83xx_ts_release();
        return 1; 
    }   

    for(i=0; i<icn83xx_ts->point_num; i++)
    {
        icn83xx_ts->point_info[i].u8ID = buf[2 + POINT_SIZE*i];
        icn83xx_ts->point_info[i].u16PosX = (buf[3 + POINT_SIZE*i]<<8) + buf[4 + POINT_SIZE*i];
        icn83xx_ts->point_info[i].u16PosY = (buf[5 + POINT_SIZE*i]<<8) + buf[6 + POINT_SIZE*i];
        icn83xx_ts->point_info[i].u8Pressure = 200;//buf[7 + POINT_SIZE*i];
        icn83xx_ts->point_info[i].u8EventId = buf[8 + POINT_SIZE*i];    

        if(1 == icn83xx_ts->revert_x_flag)
        {
            icn83xx_ts->point_info[i].u16PosX = icn83xx_ts->screen_max_x- icn83xx_ts->point_info[i].u16PosX;
        }
        if(1 == icn83xx_ts->revert_y_flag)
        {
            icn83xx_ts->point_info[i].u16PosY = icn83xx_ts->screen_max_y- icn83xx_ts->point_info[i].u16PosY;
        }
        
        icn83xx_info("u8ID %d\n", icn83xx_ts->point_info[i].u8ID);
        icn83xx_info("u16PosX %d\n", icn83xx_ts->point_info[i].u16PosX);
        icn83xx_info("u16PosY %d\n", icn83xx_ts->point_info[i].u16PosY);
        icn83xx_info("u8Pressure %d\n", icn83xx_ts->point_info[i].u8Pressure);
        icn83xx_info("u8EventId %d\n", icn83xx_ts->point_info[i].u8EventId);  


        input_report_abs(icn83xx_ts->input_dev, ABS_MT_TRACKING_ID, icn83xx_ts->point_info[i].u8ID);    
        input_report_abs(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, icn83xx_ts->point_info[i].u8Pressure);
        input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_X, icn83xx_ts->point_info[i].u16PosX);
        input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_Y, icn83xx_ts->point_info[i].u16PosY);
        input_report_abs(icn83xx_ts->input_dev, ABS_MT_WIDTH_MAJOR, 1);
        input_mt_sync(icn83xx_ts->input_dev);
        icn83xx_point_info("point: %d ===x = %d,y = %d, press = %d ====\n",i, icn83xx_ts->point_info[i].u16PosX,icn83xx_ts->point_info[i].u16PosY, icn83xx_ts->point_info[i].u8Pressure);
    }

    input_sync(icn83xx_ts->input_dev);
  
}
/***********************************************************************************************
Name    :   icn83xx_report_value_B
Input   :   void
Output  :   
function    : reprot touch ponit
***********************************************************************************************/
#if CTP_REPORT_PROTOCOL
static void icn83xx_report_value_B(void)
{
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    char buf[POINT_NUM*POINT_SIZE+3]={0};
    static unsigned char finger_last[POINT_NUM + 1]={0};
    unsigned char  finger_current[POINT_NUM + 1] = {0};
    unsigned int position = 0;
	int reported = 0;
    int temp = 0;
    int ret = -1;
    
    
    ret = icn83xx_i2c_rxdata(16, buf, POINT_NUM*POINT_SIZE+2);
    if (ret < 0) {
        icn83xx_error("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
        return ret;
    }
	
    icn83xx_ts->point_num = buf[1];
	icn83xx_info("==icn83xx_report_value_B icn83xx_ts->point_num = %d ==\n", icn83xx_ts->point_num);
    if(icn83xx_ts->point_num > 0)
    {
        for(position = 0; position<icn83xx_ts->point_num; position++)
        {       
            temp = buf[2 + POINT_SIZE*position] + 1;
            finger_current[temp] = 1;
            icn83xx_ts->point_info[temp].u8ID = buf[2 + POINT_SIZE*position];
            icn83xx_ts->point_info[temp].u16PosX = (buf[3 + POINT_SIZE*position]<<8) + buf[4 + POINT_SIZE*position];
            icn83xx_ts->point_info[temp].u16PosY = (buf[5 + POINT_SIZE*position]<<8) + buf[6 + POINT_SIZE*position];
            icn83xx_ts->point_info[temp].u8Pressure = buf[7 + POINT_SIZE*position];
            icn83xx_ts->point_info[temp].u8EventId = buf[8 + POINT_SIZE*position];
            
            if(icn83xx_ts->point_info[temp].u8EventId == 4)
                finger_current[temp] = 0;
                            
            if(1 == icn83xx_ts->revert_x_flag)
            {
                icn83xx_ts->point_info[temp].u16PosX = icn83xx_ts->screen_max_x- icn83xx_ts->point_info[temp].u16PosX;
            }
            if(1 == icn83xx_ts->revert_y_flag)
            {
                icn83xx_ts->point_info[temp].u16PosY = icn83xx_ts->screen_max_y- icn83xx_ts->point_info[temp].u16PosY;
            }
            icn83xx_info("temp %d\n", temp);
            icn83xx_info("u16PosX %d\n", icn83xx_ts->point_info[temp].u16PosX);
            icn83xx_info("u16PosY %d\n", icn83xx_ts->point_info[temp].u16PosY);            
            //icn83xx_info("u8Pressure %d\n", icn83xx_ts->point_info[temp].u8Pressure*16);
        }
    }   
    else
    {
        for(position = 1; position < POINT_NUM+1; position++)
        {
            finger_current[position] = 0;
        }
        input_report_key(icn83xx_ts->input_dev, BTN_TOUCH, 0);
		input_mt_sync(icn83xx_ts->input_dev);
		reported = 1;
		icn83xx_info("input_report up----\n");
    }

    for(position = 1; position < POINT_NUM + 1; position++)
    {
		if(finger_current[position])
        {
            //input_mt_slot(icn83xx_ts->input_dev, position-1);
            //input_mt_report_slot_state(icn83xx_ts->input_dev, MT_TOOL_FINGER, true);          
            //input_report_abs(icn83xx_ts->input_dev, ABS_MT_PRESSURE, icn83xx_ts->point_info[position].u8Pressure);
            //input_report_abs(icn83xx_ts->input_dev, ABS_MT_PRESSURE, 200);
            input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_X, icn83xx_ts->point_info[position].u16PosX);
            input_report_abs(icn83xx_ts->input_dev, ABS_MT_POSITION_Y, icn83xx_ts->point_info[position].u16PosY);
			input_report_abs(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, 8);
			input_report_key(icn83xx_ts->input_dev, BTN_TOUCH, 1);
			input_mt_sync(icn83xx_ts->input_dev);
			reported = 1;
			icn83xx_point_info("===position: %d, x = %d,y = %d, press = %d ====\n", position, icn83xx_ts->point_info[position].u16PosX,icn83xx_ts->point_info[position].u16PosY, icn83xx_ts->point_info[position].u8Pressure);
        }

    }
	if (reported) {
    	input_sync(icn83xx_ts->input_dev);
	} else {
		input_report_key(icn83xx_ts->input_dev, BTN_TOUCH, 0);
		input_mt_sync(icn83xx_ts->input_dev);
		input_sync(icn83xx_ts->input_dev);
	}
    for(position = 1; position < POINT_NUM + 1; position++)
    {
        finger_last[position] = finger_current[position];
    }
    icn83xx_point_info("===reported: %d ====\n", reported);
}
#endif

/***********************************************************************************************
Name    :   icn83xx_ts_pen_irq_work
Input   :   void
Output  :   
function    : work_struct
***********************************************************************************************/
static void icn83xx_ts_pen_irq_work(struct work_struct *work)
{
    int ret = -1;
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);  
#if SUPPORT_PROC_FS
    if(down_interruptible(&icn83xx_ts->sem))  
    {  
        return -1;   
    }  
#endif
      
    if(icn83xx_ts->work_mode == 0)
    {
#if CTP_REPORT_PROTOCOL
        icn83xx_report_value_B();
#else
        icn83xx_report_value_A();
#endif 

#if (SUPPORT_ALLWINNER_A13 == 0)  
        if(icn83xx_ts->use_irq)
        {
            icn83xx_irq_enable();
        }
#endif
    }
#if SUPPORT_FW_UPDATE    
    else if(icn83xx_ts->work_mode == 1)
    {
        printk("log raw data\n");
        icn83xx_log(0);   //raw data
    }
    else if(icn83xx_ts->work_mode == 2)
    {
        printk("log diff data\n");
        icn83xx_log(1);   //diff data
    }
#endif

#if SUPPORT_PROC_FS
    up(&icn83xx_ts->sem);
#endif


}
/***********************************************************************************************
Name    :   chipone_timer_func
Input   :   void
Output  :   
function    : Timer interrupt service routine.
***********************************************************************************************/
static enum hrtimer_restart chipone_timer_func(struct hrtimer *timer)
{
    struct icn83xx_ts_data *icn83xx_ts = container_of(timer, struct icn83xx_ts_data, timer);
    queue_work(icn83xx_ts->ts_workqueue, &icn83xx_ts->pen_event_work);

    if(icn83xx_ts->use_irq == 1)
    {
        if((icn83xx_ts->work_mode == 1) || (icn83xx_ts->work_mode == 2))
        {
            hrtimer_start(&icn83xx_ts->timer, ktime_set(CTP_POLL_TIMER/1000, (CTP_POLL_TIMER%1000)*1000000), HRTIMER_MODE_REL);
        }
    }
    else
    {
        hrtimer_start(&icn83xx_ts->timer, ktime_set(CTP_POLL_TIMER/1000, (CTP_POLL_TIMER%1000)*1000000), HRTIMER_MODE_REL);
    }
    return HRTIMER_NORESTART;
}
/***********************************************************************************************
Name    :   icn83xx_ts_interrupt
Input   :   void
Output  :   
function    : interrupt service routine
***********************************************************************************************/
static irqreturn_t icn83xx_ts_interrupt(int irq, void *dev_id)
{
    struct icn83xx_ts_data *icn83xx_ts = dev_id;
       
    icn83xx_info("==========------icn83xx_ts TS Interrupt-----============\n"); 

    if(icn83xx_ts->work_mode != 0)
    {
        return IRQ_HANDLED;
    }
#if SUPPORT_ALLWINNER_A13
// irq share, can not disable irq?
    if(!ctp_ops.judge_int_occur()){
        icn83xx_info("==IRQ_EINT21=\n");
        ctp_ops.clear_penirq();
        if (!work_pending(&icn83xx_ts->pen_event_work)) 
        {
            icn83xx_info("Enter work\n");
            queue_work(icn83xx_ts->ts_workqueue, &icn83xx_ts->pen_event_work);
        }
    }else{
        icn83xx_info("Other Interrupt\n");
        return IRQ_NONE;
    }
#else
    icn83xx_irq_disable();
    if (!work_pending(&icn83xx_ts->pen_event_work)) 
    {
        icn83xx_info("Enter work\n");
        queue_work(icn83xx_ts->ts_workqueue, &icn83xx_ts->pen_event_work);
    }
#endif

    return IRQ_HANDLED;
}


#ifdef CONFIG_HAS_EARLYSUSPEND
/***********************************************************************************************
Name    :   icn83xx_ts_suspend
Input   :   void
Output  :   
function    : tp enter sleep mode
***********************************************************************************************/
static void icn83xx_ts_suspend(struct early_suspend *handler)
{
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    icn83xx_trace("icn83xx_ts_suspend: write ICN83XX_REG_PMODE .\n");
    if (icn83xx_ts->use_irq)
    {
        icn83xx_irq_disable();
    }
    else
    {
        hrtimer_cancel(&icn83xx_ts->timer);
    }    
     icn83xx_write_reg(ICN83XX_REG_PMODE, PMODE_HIBERNATE); 

}

/***********************************************************************************************
Name    :   icn83xx_ts_resume
Input   :   void
Output  :   
function    : wakeup tp or reset tp
***********************************************************************************************/
static void icn83xx_ts_resume(struct early_suspend *handler)
{
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(this_client);
    int i;
    icn83xx_trace("==icn83xx_ts_resume== \n");

  
    icn83xx_ts_wakeup();
    icn83xx_ts_reset();
    if (icn83xx_ts->use_irq)
    {
        icn83xx_irq_enable();
    }
    else
    {
        hrtimer_start(&icn83xx_ts->timer, ktime_set(CTP_START_TIMER/1000, (CTP_START_TIMER%1000)*1000000), HRTIMER_MODE_REL);
    }
    
}
#endif

/***********************************************************************************************
Name    :   icn83xx_request_io_port
Input   :   void
Output  :   
function    : 0 success,
***********************************************************************************************/
static int icn83xx_request_io_port(struct icn83xx_ts_data *icn83xx_ts)
{
    int err = 0;
    icn83xx_ts->screen_max_x = SCREEN_MAX_X;
    icn83xx_ts->screen_max_y = SCREEN_MAX_Y;
    icn83xx_ts->irq = CTP_IRQ_PORT;
    return err;
}

/***********************************************************************************************
Name    :   icn83xx_free_io_port
Input   :   void
Output  :   
function    : 0 success,
***********************************************************************************************/
static int icn83xx_free_io_port(struct icn83xx_ts_data *icn83xx_ts)
{    
#if SUPPORT_ALLWINNER_A13    
    ctp_ops.free_platform_resource();
#endif

#if SUPPORT_ROCKCHIP

#endif

#if SUPPORT_SPREADTRUM

#endif    
}

/***********************************************************************************************
Name    :   icn83xx_request_irq
Input   :   void
Output  :   
function    : 0 success,
***********************************************************************************************/
static int icn83xx_request_irq(struct icn83xx_ts_data *icn83xx_ts)
{
    int err = -1;

    //icn83xx_ts->irq = IRQ_SIRQ0;
	err = gpio_request(icn83xx_ts->irq , "icn83xx_irq");

	gpio_direction_input(icn83xx_ts->irq);

    err = request_irq(gpio_to_irq(icn83xx_ts->irq), icn83xx_ts_interrupt, IRQ_TYPE_EDGE_RISING, "icn83xx_ts", icn83xx_ts);
    if (err < 0) 
    {
        icn83xx_error("icn83xx_ts_probe: request irq failed\n");
        return err;
    } 
    else
    {
        icn83xx_irq_disable();
        icn83xx_ts->use_irq = 1;        
    } 
    return 0;
}


/***********************************************************************************************
Name    :   icn83xx_free_irq
Input   :   void
Output  :   
function    : 0 success,
***********************************************************************************************/
static int icn83xx_free_irq(struct icn83xx_ts_data *icn83xx_ts)
{
    if (icn83xx_ts) 
    {
        if (icn83xx_ts->use_irq)
        {
            free_irq(icn83xx_ts->irq, icn83xx_ts);
        }
        else
        {
            hrtimer_cancel(&icn83xx_ts->timer);
        }
    } 
}

/***********************************************************************************************
Name    :   icn83xx_request_input_dev
Input   :   void
Output  :   
function    : 0 success,
***********************************************************************************************/
static int icn83xx_request_input_dev(struct icn83xx_ts_data *icn83xx_ts)
{
    int ret = -1;    
    struct input_dev *input_dev;

    input_dev = input_allocate_device();
    if (!input_dev) {
        icn83xx_error("failed to allocate input device\n");
        return -ENOMEM;
    }
    icn83xx_ts->input_dev = input_dev;

    icn83xx_ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;

    __set_bit(INPUT_PROP_DIRECT, icn83xx_ts->input_dev->propbit);
    set_bit(EV_ABS, icn83xx_ts->input_dev->evbit);
	set_bit(EV_SYN, icn83xx_ts->input_dev->evbit);
	set_bit(BTN_TOUCH, icn83xx_ts->input_dev->keybit);

    input_set_abs_params(icn83xx_ts->input_dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
    input_set_abs_params(icn83xx_ts->input_dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
    input_set_abs_params(icn83xx_ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 8, 0, 0);  

    input_dev->name = CTP_NAME;
    ret = input_register_device(input_dev);
    if (ret) {
        icn83xx_error("Register %s input device failed\n", input_dev->name);
        input_free_device(input_dev);
        return -ENODEV;        
    }
    
#ifdef CONFIG_HAS_EARLYSUSPEND
    icn83xx_trace("==register_early_suspend =\n");
    icn83xx_ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
    icn83xx_ts->early_suspend.suspend = icn83xx_ts_suspend;
    icn83xx_ts->early_suspend.resume  = icn83xx_ts_resume;
    register_early_suspend(&icn83xx_ts->early_suspend);
#endif

    return 0;
}

void inc83xx_ts_charger_mode()
{		
	icn83xx_write_reg(ICN83XX_REG_PMODE, 0x55);
}
EXPORT_SYMBOL_GPL(inc83xx_ts_charger_mode);

void inc83xx_ts_charger_mode_disable()
{
	icn83xx_write_reg(ICN83XX_REG_PMODE, 0x66);
}
EXPORT_SYMBOL_GPL(inc83xx_ts_charger_mode_disable);

char FbCap[4][16]={
            {0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14},
            {0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12},
            {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},           
            {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08},
            };  

static int icn83xx_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    struct icn83xx_ts_data *icn83xx_ts;
    short fwVersion = 0;
    short curVersion = 0;
    int average;
    int err = 0;
    char value;
    int retry;

    icn83xx_trace("====%s begin=====.  \n", __func__);
    
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 
    {
        icn83xx_error("I2C check functionality failed.\n");
        
        return -ENODEV;
    }

    icn83xx_ts = kzalloc(sizeof(*icn83xx_ts), GFP_KERNEL);
    if (!icn83xx_ts)
    {
        icn83xx_error("Alloc icn83xx_ts memory failed.\n");
        return -ENOMEM;
    }
    memset(icn83xx_ts, 0, sizeof(*icn83xx_ts));

    this_client = client;
    this_client->addr = client->addr;
    i2c_set_clientdata(client, icn83xx_ts);

    icn83xx_ts->work_mode = 0;
    spin_lock_init(&icn83xx_ts->irq_lock);
//    icn83xx_ts->irq_lock = SPIN_LOCK_UNLOCKED;

    icn83xx_ts_reset();

    INIT_WORK(&icn83xx_ts->pen_event_work, icn83xx_ts_pen_irq_work);
    icn83xx_ts->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));
    if (!icn83xx_ts->ts_workqueue) {
        icn83xx_error("create_singlethread_workqueue failed.\n");
        kfree(icn83xx_ts);
        return -ESRCH;
    }

    err= icn83xx_request_input_dev(icn83xx_ts);
    if (err < 0)
    {
        icn83xx_error("request input dev failed\n");
        kfree(icn83xx_ts);
        return err;        
    }

    err = icn83xx_request_io_port(icn83xx_ts);
    if (err != 0)
    {
        icn83xx_error("icn83xx_request_io_port failed.\n");
        kfree(icn83xx_ts);
        return err;
    }
    err = icn83xx_iic_test();
    if (err < 0)
    {
        icn83xx_error("icn83xx_iic_test  failed.\n");
#if SUPPORT_FW_UPDATE

    #if COMPILE_FW_WITH_DRIVER
        icn83xx_set_fw(sizeof(icn83xx_fw), &icn83xx_fw[0]);
    #endif
        if(icn83xx_check_progmod() == 0)
        {
            retry = 5;
            icn83xx_trace("in prog mode\n");  
            while(retry > 0)
            {
                if(R_OK == icn83xx_fw_update(firmware))
                {
                    break;
                }
                retry--;
                icn83xx_error("icn83xx_fw_update failed.\n");
            }
        }
        else // 
        {
            icn83xx_error("I2C communication failed.\n");
            kfree(icn83xx_ts);
            return -1;
        }
            
#endif        
    }
    else
    {
        icn83xx_trace("iic communication ok\n"); 
    }

#if SUPPORT_FW_UPDATE  
    fwVersion = icn83xx_read_fw_Ver(firmware);
    curVersion = icn83xx_readVersion();
    icn83xx_trace("fwVersion : 0x%x\n", fwVersion); 
    icn83xx_trace("current version: 0x%x\n", curVersion);  


#if FORCE_UPDATA_FW
    retry = 5;
    while(retry > 0)
    {
        if(R_OK == icn83xx_fw_update(firmware))
        {
            break;
        }
        retry--;
        icn83xx_error("icn83xx_fw_update failed.\n");        
    }
#else
    if(fwVersion > curVersion)
    {
        retry = 5;
        while(retry > 0)
        {
            if(R_OK == icn83xx_fw_update(firmware))
            {
                break;
            }
            retry--;
            icn83xx_error("icn83xx_fw_update failed.\n");   
        }
    }
#endif

#endif

#if SUPPORT_FW_CALIB
    err = icn83xx_read_reg(0, &value);
    if(err > 0)
    {
//auto calib fw
        average = icn83xx_calib(0, NULL);
//fix FbCap
//      average = icn83xx_calib(0, FbCap[1]);
        icn83xx_trace("average : %d\n", average); 
        icn83xx_setPeakGroup(250, 150);
        icn83xx_setDownUp(400, 300);
    }
#endif

#if TOUCH_VIRTUAL_KEYS
    icn83xx_ts_virtual_keys_init();
#endif
    err = icn83xx_request_irq(icn83xx_ts);
    if (err != 0)
    {
        icn83xx_error("request irq error, use timer\n");
        icn83xx_ts->use_irq = 0;
        hrtimer_init(&icn83xx_ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
        icn83xx_ts->timer.function = chipone_timer_func;
        hrtimer_start(&icn83xx_ts->timer, ktime_set(CTP_START_TIMER/1000, (CTP_START_TIMER%1000)*1000000), HRTIMER_MODE_REL);
    }
#if SUPPORT_SYSFS
    icn83xx_create_sysfs(client);
#endif

#if SUPPORT_PROC_FS
    sema_init(&icn83xx_ts->sem, 1);
    init_proc_node();
#endif

    icn83xx_irq_enable();
/*
	if(atc260x_get_charge_status() == 1) 
	{
		printk("atc260x_get_charge_status====1\n");
		inc83xx_ts_charger_mode();
	}
	else 
	{
		inc83xx_ts_charger_mode_disable();
	}
	
	void callback(int status)
	{
		printk("CALLBACK TP %d !!!!!!!!!\n",status);
		if(status ==1) 
		{
			inc83xx_ts_charger_mode();
		}
		else
		{
			inc83xx_ts_charger_mode_disable();
		}
	}
	atc260x_set_adjust_tp_para(callback);    
 */   
    icn83xx_trace("==%s over =\n", __func__);    
    return 0;
}

static int __devexit icn83xx_ts_remove(struct i2c_client *client)
{
    struct icn83xx_ts_data *icn83xx_ts = i2c_get_clientdata(client);  
    icn83xx_trace("==icn83xx_ts_remove=\n");
    icn83xx_irq_disable();

	gpio_direction_input(CTP_RST_PORT);
	gpio_free(CTP_RST_PORT);
	//free_irq(client->irq, icn83xx_ts);


#ifdef CONFIG_HAS_EARLYSUSPEND
    unregister_early_suspend(&icn83xx_ts->early_suspend);
#endif

#if SUPPORT_PROC_FS
    uninit_proc_node();
#endif

    input_unregister_device(icn83xx_ts->input_dev);
    input_free_device(icn83xx_ts->input_dev);
    cancel_work_sync(&icn83xx_ts->pen_event_work);
    destroy_workqueue(icn83xx_ts->ts_workqueue);
    icn83xx_free_irq(icn83xx_ts);
    icn83xx_free_io_port(icn83xx_ts);
    kfree(icn83xx_ts);    
    i2c_set_clientdata(client, NULL);
    return 0;
}

static const struct i2c_device_id icn83xx_ts_id[] = {
    { CTP_NAME, 0 },
    {}
};
MODULE_DEVICE_TABLE(i2c, icn83xx_ts_id);

static struct i2c_driver icn83xx_ts_driver = {
    .class      = I2C_CLASS_HWMON,
    .probe      = icn83xx_ts_probe,
    .remove     = __devexit_p(icn83xx_ts_remove),
#ifndef CONFIG_HAS_EARLYSUSPEND
    .suspend    = icn83xx_ts_suspend,
    .resume     = icn83xx_ts_resume,
#endif
    .id_table   = icn83xx_ts_id,
    .driver = {
        .name   = CTP_NAME,
        .owner  = THIS_MODULE,
    },
};

static struct i2c_board_info tp_info = {
    .type	= CTP_NAME,
    .addr	=  0x40,
};
////POWER
/*
static struct regulator *regulator_init(const char *name, int minvol, int maxvol)
{

    struct regulator *power;

    power = regulator_get(NULL,"sensor28");// name);
    if (IS_ERR(power)) {
        printk("Nova err,regulator_get fail\n!!!");
        return NULL;
    }

    if (regulator_set_voltage(power, minvol, maxvol)) {
        printk("Nova err,cannot set voltage\n!!!");
        regulator_put(power);
        
        return NULL;
    }
    regulator_enable(power);
    return (power);
}
*/
static int icn83xx_hw_init(void)
{
    int err = 0;
	err = gpio_request(CTP_RST_PORT, "icn83xx_rest");
	if ( err ) {
		err = -EINVAL;
		return err;
	}

	err = gpio_direction_output(CTP_RST_PORT, 1);
	if ( err ) {
		err = -EINVAL;
		return err;
    }
/*
 	tp_regulator = regulator_init(CTP_POWER_ID, 
		CTP_POWER_MIN_VOL, CTP_POWER_MAX_VOL);
	if ( !tp_regulator ) {
		printk(KERN_ERR "icn83xx tp init power failed");
		err = -EINVAL;
		return err;
	}
    */
    msleep(50);

    gpio_set_value_cansleep(CTP_RST_PORT, 0);
	msleep(100);
	gpio_set_value_cansleep(CTP_RST_PORT, 1);
    msleep(300);
        
    return err;
}
static int __init icn83xx_ts_init(void)
{ 
    int ret = -1;
    icn83xx_trace("===========================%s=====================\n", __func__);

    icn83xx_hw_init();
/*
	struct i2c_adapter *adap = i2c_get_adapter(3);
	printk(KERN_ERR "==icn83xx_init %d!!!!!!!!\n",__LINE__);

	i2c_new_device(adap, &tp_info); 
*/
    ret = i2c_add_driver(&icn83xx_ts_driver);
    return ret;
}

static void __exit icn83xx_ts_exit(void)
{
    icn83xx_trace("==icn83xx_ts_exit==\n");
    i2c_del_driver(&icn83xx_ts_driver);
}

module_init(icn83xx_ts_init);
module_exit(icn83xx_ts_exit);

MODULE_AUTHOR("<zmtian@chiponeic.com>");
MODULE_DESCRIPTION("Chipone icn83xx TouchScreen driver");
MODULE_LICENSE("GPL");