哇酷®开发者社区(WhyCan® Forum)

/*
 * drivers/input/touchscreen/ft5x0x_ts.c
 *
 * FocalTech ft5x TouchScreen driver.
 *
 * Copyright (c) 2010  Focal tech Ltd.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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.
 *
 *
 *	note: only support mulititouch	Wenfs 2010-10-01
 *  for this touchscreen to work, it's slave addr must be set to 0x7e | 0x70
 */
#include <linux/i2c.h>
#include <linux/input.h>
#include "ft5x_ts.h"
#ifdef CONFIG_HAS_EARLYSUSPEND
#include <linux/pm.h>
#include <linux/earlysuspend.h>
#endif
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/async.h>
#include <linux/hrtimer.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/gpio.h>
#include <asm/irq.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include "../../init-input.h"



#define CONFIG_SUPPORT_FTS_CTP_UPG

#define FOR_TSLIB_TEST
#ifdef TOUCH_KEY_SUPPORT
#define TOUCH_KEY_FOR_EVB13
#ifdef TOUCH_KEY_FOR_ANGDA
#define TOUCH_KEY_X_LIMIT	        (60000)
#define TOUCH_KEY_NUMBER	        (4)
#endif
#ifdef TOUCH_KEY_FOR_EVB13
#define TOUCH_KEY_LOWER_X_LIMIT	        (848)
#define TOUCH_KEY_HIGHER_X_LIMIT	(852)
#define TOUCH_KEY_NUMBER	        (5)
#endif
#endif


/* FT5X02_CONFIG */
#define FT5X02_CONFIG_NAME "fttpconfig_5x02public.ini"
extern int ft5x02_Init_IC_Param(struct i2c_client *client);
extern int ft5x02_get_ic_param(struct i2c_client *client);
extern int ft5x02_Get_Param_From_Ini(char *config_name);

struct i2c_dev{
	    struct list_head list;
        struct i2c_adapter *adap;
        struct device *dev;
};

static struct class *i2c_dev_class;
static LIST_HEAD (i2c_dev_list);
static DEFINE_SPINLOCK(i2c_dev_list_lock);


struct Upgrade_Info {
	u16 delay_aa;		/*delay of write FT_UPGRADE_AA */
	u16 delay_55;		/*delay of write FT_UPGRADE_55 */
	u8 upgrade_id_1;	/*upgrade id 1 */
	u8 upgrade_id_2;	/*upgrade id 2 */
	u16 delay_readid;	/*delay of read id */
};

#define FT5X_NAME	"ft5x_ts"

static struct i2c_client *this_client;

#ifdef TOUCH_KEY_SUPPORT
static int key_tp  = 0;
static int key_val = 0;
#endif

/*********************************************************************************************/
#define CTP_IRQ_NUMBER                  (config_info.int_number)
#define CTP_IRQ_MODE                    (IRQF_TRIGGER_LOW | IRQF_ONESHOT)
#define SCREEN_MAX_X			(screen_max_x)
#define SCREEN_MAX_Y			(screen_max_y)
#define CTP_NAME			 FT5X_NAME
#define PRESS_MAX			(255)

static int screen_max_x = 0;
static int screen_max_y = 0;
static int revert_x_flag = 0;
static int revert_y_flag = 0;
static int exchange_x_y_flag = 0;
static __u32 twi_id = 0;

static struct ctp_config_info config_info = {
	.input_type = CTP_TYPE,
	.name = NULL,
	.int_number = 0,
};

static u32 debug_mask = 0;

enum{
	DEBUG_INIT = 1U << 0,
	DEBUG_SUSPEND = 1U << 1,
	DEBUG_INT_INFO = 1U << 2,
	DEBUG_X_Y_INFO = 1U << 3,
	DEBUG_KEY_INFO = 1U << 4,
	DEBUG_WAKEUP_INFO = 1U << 5,
	DEBUG_OTHERS_INFO = 1U << 6,
};

#define dprintk(level_mask,fmt,arg...)    if(unlikely(debug_mask & level_mask)) \
        printk("***CTP***"fmt, ## arg)
module_param_named(debug_mask,debug_mask,int,S_IRUGO | S_IWUSR | S_IWGRP);
/*********************************************************************************************/
/*------------------------------------------------------------------------------------------*/
/* Addresses to scan */
static const unsigned short normal_i2c[2] = {0x38,I2C_CLIENT_END};
static const int chip_id_value[] = {0x55,0x06,0x08,0x02,0xa3};
static int chip_id = 0;

static void ft5x_resume_events(struct work_struct *work);
struct workqueue_struct *ft5x_resume_wq;
static DECLARE_WORK(ft5x_resume_work, ft5x_resume_events);

static void ft5x_init_events(struct work_struct *work);
struct workqueue_struct *ft5x_wq;
static DECLARE_WORK(ft5x_init_work, ft5x_init_events);
/*------------------------------------------------------------------------------------------*/

static int ctp_detect(struct i2c_client *client, struct i2c_board_info *info)
{
	struct i2c_adapter *adapter = client->adapter;
        int ret = 0;

        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;

	if(twi_id == adapter->nr){

	        ret = i2c_smbus_read_byte_data(client,0xA3);
		if(ret == -70) {
			msleep(10);
			ret = i2c_smbus_read_byte_data(client,0xA3);
		}

        dprintk(DEBUG_INIT,"addr:0x%x,chip_id_value:0x%x\n",client->addr,ret);
        if(ret < 0){
            printk("%s:I2C connection might be something wrong ! \n",__func__);
        	return -ENODEV;
		} else {

            strlcpy(info->type, CTP_NAME, I2C_NAME_SIZE);
			chip_id = ret;
    		return 0;
		}

	}else{
		return -ENODEV;
	}
}

/**
 * ctp_print_info - sysconfig print function
 * return value:
 *
 */
static void ctp_print_info(struct ctp_config_info info,int debug_level)
{
	if(debug_level == DEBUG_INIT)
	{
		dprintk(DEBUG_INIT,"info.ctp_used:%d\n",info.ctp_used);
		dprintk(DEBUG_INIT,"info.twi_id:%d\n",info.twi_id);
		dprintk(DEBUG_INIT,"info.screen_max_x:%d\n",info.screen_max_x);
		dprintk(DEBUG_INIT,"info.screen_max_y:%d\n",info.screen_max_y);
		dprintk(DEBUG_INIT,"info.revert_x_flag:%d\n",info.revert_x_flag);
		dprintk(DEBUG_INIT,"info.revert_y_flag:%d\n",info.revert_y_flag);
		dprintk(DEBUG_INIT,"info.exchange_x_y_flag:%d\n",info.exchange_x_y_flag);
		dprintk(DEBUG_INIT,"info.irq_gpio_number:%d\n",info.irq_gpio.gpio);
		dprintk(DEBUG_INIT,"info.wakeup_gpio_number:%d\n",info.wakeup_gpio.gpio);
	}
}

/**
 * ctp_wakeup - function
 *
 */
static int ctp_wakeup(int status,int ms)
{
	dprintk(DEBUG_INIT,"***CTP*** %s:status:%d,ms = %d\n",__func__,status,ms);

	if (status == 0) {

		if(ms == 0) {
			__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
		}else {
			__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
			msleep(ms);
			__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
		}
	}
	if (status == 1) {
		if(ms == 0) {
			__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
		}else {
			__gpio_set_value(config_info.wakeup_gpio.gpio, 1);
			msleep(ms);
			__gpio_set_value(config_info.wakeup_gpio.gpio, 0);
		}
	}
	msleep(5);

	return 0;
}

int fts_ctpm_fw_upgrade_with_i_file(void);

static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
{
	struct i2c_dev *i2c_dev = NULL;
	spin_lock(&i2c_dev_list_lock);

	list_for_each_entry(i2c_dev,&i2c_dev_list,list){
		dprintk(DEBUG_OTHERS_INFO,"--line = %d ,i2c_dev->adapt->nr = %d,index = %d.\n",\
		        __LINE__,i2c_dev->adap->nr,index);
		if(i2c_dev->adap->nr == index){
		     goto found;
		}
	}
	i2c_dev = NULL;

found:
	spin_unlock(&i2c_dev_list_lock);

	return i2c_dev ;
}

static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
{
	struct i2c_dev *i2c_dev;

	if (adap->nr >= I2C_MINORS){
		dprintk(DEBUG_OTHERS_INFO,"i2c-dev:out of device minors (%d) \n",adap->nr);
		return ERR_PTR (-ENODEV);
	}

	i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
	if (!i2c_dev){
		return ERR_PTR(-ENOMEM);
	}
	i2c_dev->adap = adap;

	spin_lock(&i2c_dev_list_lock);
	list_add_tail(&i2c_dev->list, &i2c_dev_list);
	spin_unlock(&i2c_dev_list_lock);

	return i2c_dev;
}


static int ft5x_i2c_rxdata(char *rxdata, int length);

struct ts_event {
	u16	x1;
	u16	y1;
	u16	x2;
	u16	y2;
	u16	x3;
	u16	y3;
	u16	x4;
	u16	y4;
	u16	x5;
	u16	y5;
	u16	pressure;
	s16     touch_ID1;
	s16     touch_ID2;
	s16     touch_ID3;
	s16     touch_ID4;
	s16     touch_ID5;
        u8      touch_point;
};

struct ft5x_ts_data {
	struct input_dev	*input_dev;
	struct ts_event		event;
	struct work_struct 	pen_event_work;
	struct workqueue_struct *ts_workqueue;
#ifdef CONFIG_HAS_EARLYSUSPEND
	struct early_suspend	early_suspend;
#endif
    bool is_suspended;
};


/* ---------------------------------------------------------------------
*
*   Focal Touch panel upgrade related driver
*
*
----------------------------------------------------------------------*/

typedef enum
{
	ERR_OK,
	ERR_MODE,
	ERR_READID,
	ERR_ERASE,
	ERR_STATUS,
	ERR_ECC,
	ERR_DL_ERASE_FAIL,
	ERR_DL_PROGRAM_FAIL,
	ERR_DL_VERIFY_FAIL
}E_UPGRADE_ERR_TYPE;

typedef unsigned char         FTS_BYTE;     //8 bit
typedef unsigned short        FTS_WORD;    //16 bit
typedef unsigned int          FTS_DWRD;    //16 bit
typedef unsigned char         FTS_BOOL;    //8 bit

#define FTS_NULL                0x0
#define FTS_TRUE                0x01
#define FTS_FALSE               0x0

#define I2C_CTPM_ADDRESS        (0x3b)

static void delay_ms(FTS_WORD  w_ms)
{
	//platform related, please implement this function
	msleep( w_ms );
}

void delay_qt_ms(unsigned long  w_ms)
{
	unsigned long i;
	unsigned long j;

	for (i = 0; i < w_ms; i++)
	{
		for (j = 0; j < 1000; j++)
		{
			 udelay(1);
		}
	}
}
/*
[function]:
    callback: read data from ctpm by i2c interface,implemented by special user;
[parameters]:
    bt_ctpm_addr[in]    :the address of the ctpm;
    pbt_buf[out]        :data buffer;
    dw_lenth[in]        :the length of the data buffer;
[return]:
    FTS_TRUE     :success;
    FTS_FALSE    :fail;
*/
int i2c_read_interface(u8 bt_ctpm_addr, u8* pbt_buf, u16 dw_lenth)
{
	int ret;

	ret = i2c_master_recv(this_client, pbt_buf, dw_lenth);

	if(ret != dw_lenth){
		printk("ret = %d. \n", ret);
		printk("i2c_read_interface error\n");
		return FTS_FALSE;
	}

	return FTS_TRUE;
}

/*
[function]:
    callback: write data to ctpm by i2c interface,implemented by special user;
[parameters]:
    bt_ctpm_addr[in]    :the address of the ctpm;
    pbt_buf[in]        :data buffer;
    dw_lenth[in]        :the length of the data buffer;
[return]:
    FTS_TRUE     :success;
    FTS_FALSE    :fail;
*/
int i2c_write_interface(u8 bt_ctpm_addr, u8* pbt_buf, u16 dw_lenth)
{
	int ret;
	ret=i2c_master_send(this_client, pbt_buf, dw_lenth);
	if(ret != dw_lenth){
		printk("i2c_write_interface error\n");
		return FTS_FALSE;
	}

	return FTS_TRUE;
}


/***************************************************************************************/

/*
[function]:
    read out the register value.
[parameters]:
    e_reg_name[in]    :register name;
    pbt_buf[out]    :the returned register value;
    bt_len[in]        :length of pbt_buf, should be set to 2;
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
u8 fts_register_read(u8 e_reg_name, u8* pbt_buf, u8 bt_len)
{
	u8 read_cmd[3]= {0};
	u8 cmd_len     = 0;

	read_cmd[0] = e_reg_name;
	cmd_len = 1;

	/*call the write callback function*/
	//    if(!i2c_write_interface(I2C_CTPM_ADDRESS, &read_cmd, cmd_len))
	//    {
	//        return FTS_FALSE;
	//    }


	if(!i2c_write_interface(I2C_CTPM_ADDRESS, read_cmd, cmd_len))	{//change by zhengdixu
		return FTS_FALSE;
	}

	/*call the read callback function to get the register value*/
	if(!i2c_read_interface(I2C_CTPM_ADDRESS, pbt_buf, bt_len)){
		return FTS_FALSE;
	}
	return FTS_TRUE;
}

/*
[function]:
    write a value to register.
[parameters]:
    e_reg_name[in]    :register name;
    pbt_buf[in]        :the returned register value;
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
int fts_register_write(u8 e_reg_name, u8 bt_value)
{
	FTS_BYTE write_cmd[2] = {0};

	write_cmd[0] = e_reg_name;
	write_cmd[1] = bt_value;

	/*call the write callback function*/
	//return i2c_write_interface(I2C_CTPM_ADDRESS, &write_cmd, 2);
	return i2c_write_interface(I2C_CTPM_ADDRESS, write_cmd, 2); //change by zhengdixu
}

/*
[function]:
    send a command to ctpm.
[parameters]:
    btcmd[in]        :command code;
    btPara1[in]    :parameter 1;
    btPara2[in]    :parameter 2;
    btPara3[in]    :parameter 3;
    num[in]        :the valid input parameter numbers, if only command code needed and no parameters followed,then the num is 1;
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
int cmd_write(u8 btcmd,u8 btPara1,u8 btPara2,u8 btPara3,u8 num)
{
	FTS_BYTE write_cmd[4] = {0};

	write_cmd[0] = btcmd;
	write_cmd[1] = btPara1;
	write_cmd[2] = btPara2;
	write_cmd[3] = btPara3;
	//return i2c_write_interface(I2C_CTPM_ADDRESS, &write_cmd, num);
	return i2c_write_interface(I2C_CTPM_ADDRESS, write_cmd, num);//change by zhengdixu
}

/*
[function]:
    write data to ctpm , the destination address is 0.
[parameters]:
    pbt_buf[in]    :point to data buffer;
    bt_len[in]        :the data numbers;
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
int byte_write(u8* pbt_buf, u16 dw_len)
{
	return i2c_write_interface(I2C_CTPM_ADDRESS, pbt_buf, dw_len);
}

/*
[function]:
    read out data from ctpm,the destination address is 0.
[parameters]:
    pbt_buf[out]    :point to data buffer;
    bt_len[in]        :the data numbers;
[return]:
    FTS_TRUE    :success;
    FTS_FALSE    :io fail;
*/
int byte_read(u8* pbt_buf, u8 bt_len)
{
	return i2c_read_interface(I2C_CTPM_ADDRESS, pbt_buf, bt_len);
	//ft5x_i2c_rxdata
}


/*
[function]:
    burn the FW to ctpm.
[parameters]:(ref. SPEC)
    pbt_buf[in]    :point to Head+FW ;
    dw_lenth[in]:the length of the FW + 6(the Head length);
    bt_ecc[in]    :the ECC of the FW
[return]:
    ERR_OK        :no error;
    ERR_MODE    :fail to switch to UPDATE mode;
    ERR_READID    :read id fail;
    ERR_ERASE    :erase chip fail;
    ERR_STATUS    :status error;
    ERR_ECC        :ecc error.
*/


#define    FTS_PACKET_LENGTH       128 //2//4//8//16//32//64//128//256

static unsigned char CTPM_FW[]=
{
        #include "ft_app.i"
};
unsigned char fts_ctpm_get_i_file_ver(void)
{
        unsigned int ui_sz;
        ui_sz = sizeof(CTPM_FW);
        if (ui_sz > 2){
                return CTPM_FW[ui_sz - 2];
        }else{
                //TBD, error handling?
                return 0xff; //default value
        }
}

/*
*get upgrade information depend on the ic type
*/
static void fts_get_upgrade_info(struct Upgrade_Info *upgrade_info)
{
#ifdef WILLIAM_DEBUG
		printk("####ft5x chip_id=%d####\n", chip_id);
#endif
	switch (chip_id) {
	case 0x55:    //IC_FT5X06:
		upgrade_info->delay_55 = FT5X06_UPGRADE_55_DELAY;
		upgrade_info->delay_aa = FT5X06_UPGRADE_AA_DELAY;
		upgrade_info->upgrade_id_1 = FT5X06_UPGRADE_ID_1;
		upgrade_info->upgrade_id_2 = FT5X06_UPGRADE_ID_2;
		upgrade_info->delay_readid = FT5X06_UPGRADE_READID_DELAY;
		break;
	case 0x08:    //IC_FT5606IC_FT5506
		upgrade_info->delay_55 = FT5606_UPGRADE_55_DELAY;
		upgrade_info->delay_aa = FT5606_UPGRADE_AA_DELAY;
		upgrade_info->upgrade_id_1 = FT5606_UPGRADE_ID_1;
		upgrade_info->upgrade_id_2 = FT5606_UPGRADE_ID_2;
		upgrade_info->delay_readid = FT5606_UPGRADE_READID_DELAY;
		break;
	case 0x00:    //IC FT5316
	case 0x0a:    //IC FT5316
		upgrade_info->delay_55 = FT5316_UPGRADE_55_DELAY;
		upgrade_info->delay_aa = FT5316_UPGRADE_AA_DELAY;
		upgrade_info->upgrade_id_1 = FT5316_UPGRADE_ID_1;
		upgrade_info->upgrade_id_2 = FT5316_UPGRADE_ID_2;
		upgrade_info->delay_readid = FT5316_UPGRADE_READID_DELAY;
		break;
	default:
		break;
	}
}

E_UPGRADE_ERR_TYPE  ft5x06_ctpm_fw_upgrade(u8* pbt_buf, u16 dw_lenth)
{
        u8 reg_val[2] = {0};
        FTS_BOOL i_ret = 0;
        u16 i = 0;


        u16  packet_number;
        u16  j;
        u16  temp;
        u16  lenght;
        u8  packet_buf[FTS_PACKET_LENGTH + 6];
        //u8  auc_i2c_write_buf[10];
        u8 bt_ecc;

        struct  Upgrade_Info upgradeinfo = {0, 0, 0, 0 , 0};


	fts_get_upgrade_info(&upgradeinfo);

        /*********Step 1:Reset  CTPM *****/
        /*write 0xaa to register 0xfc*/
        //delay_ms(100);//µԴȥʱ
        fts_register_write(0xfc,0xaa);
        delay_ms(upgradeinfo.delay_aa);

        /*write 0x55 to register 0xfc*/
        fts_register_write(0xfc,0x55);
        printk("Step 1: Reset CTPM test\n");
        delay_ms(upgradeinfo.delay_55);

        /*********Step 2:Enter upgrade mode *****/
        //auc_i2c_write_buf[0] = 0x55;
        //auc_i2c_write_buf[1] = 0xaa;
        i = 0;
        do{
                i++;
                //i_ret = i2c_write_interface(I2C_CTPM_ADDRESS, auc_i2c_write_buf, 2);
		cmd_write(0x55,0xaa,0x00,0x00,2);
                printk("Step 2: Enter update mode. \n");
                delay_ms(5);
        }while((FTS_FALSE == i_ret) && i<5);

        /*********Step 3:check READ-ID***********************/
        /*send the opration head*/
	msleep(upgradeinfo.delay_readid);
	cmd_write(0x90,0x00,0x00,0x00,4);
	byte_read(reg_val,2);
	if (reg_val[0] == upgradeinfo.upgrade_id_1&& reg_val[1] == upgradeinfo.upgrade_id_2) {
		printk("Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
	}
	else {
		printk("Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
		return ERR_READID;
	}
	cmd_write(0xcd,0x00,0x00,0x00,1);
	byte_read(reg_val,1);

        /*Step 4:erase app and panel paramenter area*/
        cmd_write(0x61,0x00,0x00,0x00,1);
        msleep(2000);
	cmd_write(0x63,0x00,0x00,0x00,1);
        msleep(100);
        printk("Step 4: erase. \n");

        /*********Step 5:write firmware(FW) to ctpm flash*********/
        bt_ecc = 0;
        printk("Step 5: start upgrade. \n");
        dw_lenth = dw_lenth - 8;
        packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
        packet_buf[0] = 0xbf;
        packet_buf[1] = 0x00;
        for (j=0;j<packet_number;j++){
                temp = j * FTS_PACKET_LENGTH;
                packet_buf[2] = (FTS_BYTE)(temp>>8);
                packet_buf[3] = (FTS_BYTE)temp;
                lenght = FTS_PACKET_LENGTH;
                packet_buf[4] = (FTS_BYTE)(lenght>>8);
                packet_buf[5] = (FTS_BYTE)lenght;

                for (i=0;i<FTS_PACKET_LENGTH;i++){
                        packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
                        bt_ecc ^= packet_buf[6+i];
                }

                byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
                //delay_ms(FTS_PACKET_LENGTH/6 + 1);
		msleep(FTS_PACKET_LENGTH/6 + 1);
                if ((j * FTS_PACKET_LENGTH % 1024) == 0){
                        printk("upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
                }
        }

        if ((dw_lenth) % FTS_PACKET_LENGTH > 0){
                temp = packet_number * FTS_PACKET_LENGTH;
                packet_buf[2] = (FTS_BYTE)(temp>>8);
                packet_buf[3] = (FTS_BYTE)temp;

                temp = (dw_lenth) % FTS_PACKET_LENGTH;
                packet_buf[4] = (FTS_BYTE)(temp>>8);
                packet_buf[5] = (FTS_BYTE)temp;

                for (i=0;i<temp;i++){
                        packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
                        bt_ecc ^= packet_buf[6+i];
                }

                byte_write(&packet_buf[0],temp+6);
                //delay_ms(20);
		msleep(20);
        }

        //send the last six byte
        for (i = 0; i<6; i++){
                temp = 0x6ffa + i;
                packet_buf[2] = (FTS_BYTE)(temp>>8);
                packet_buf[3] = (FTS_BYTE)temp;
                temp =1;
                packet_buf[4] = (FTS_BYTE)(temp>>8);
                packet_buf[5] = (FTS_BYTE)temp;
                packet_buf[6] = pbt_buf[ dw_lenth + i];
                bt_ecc ^= packet_buf[6];

                byte_write(&packet_buf[0],7);
                //delay_ms(20);
		msleep(20);
        }

        /*********Step 6: read out checksum***********************/
        /*send the opration head*/
        //cmd_write(0xcc,0x00,0x00,0x00,1);//0xccĴַȥһֽ
        // byte_read(reg_val,1);//change by zhengdixu

	fts_register_read(0xcc, reg_val,1);
        printk("Step 6:  ecc read 0x%x, new firmware 0x%x. \n", reg_val[0], bt_ecc);
        if(reg_val[0] != bt_ecc){
                //cmd_write(0x07,0x00,0x00,0x00,1);
		printk("ecc error! \n");
		return ERR_ECC;
        }

        /*********Step 7: reset the new FW***********************/
        cmd_write(0x07,0x00,0x00,0x00,1);
        msleep(300);
        return ERR_OK;
}

E_UPGRADE_ERR_TYPE  ft5x02_ctpm_fw_upgrade(u8* pbt_buf, u32 dw_lenth)
{

	u8 reg_val[2] = {0};
	u32 i = 0;

	u32  packet_number;
	u32  j;
	u32  temp;
	u32  lenght;
	u8	packet_buf[FTS_PACKET_LENGTH + 6];
	//u8	auc_i2c_write_buf[10];
	u8	bt_ecc;

	//struct timeval begin_tv, end_tv;
	//do_gettimeofday(&begin_tv);

	for (i=0; i<16; i++) {
		/*********Step 1:Reset	CTPM *****/
		/*write 0xaa to register 0xfc*/
		fts_register_write(0xfc,0xaa);
		msleep(30);
		/*write 0x55 to register 0xfc*/
		fts_register_write(0xfc,0x55);
		//delay_qt_ms(18);
		delay_qt_ms(25);
		/*********Step 2:Enter upgrade mode *****/
		#if 0
		//auc_i2c_write_buf[0] = 0x55;
		//auc_i2c_write_buf[1] = 0xaa;
		do
		{
			i ++;
			//i_ret = ft5x02_i2c_Write(client, auc_i2c_write_buf, 2);
			//i_ret = i2c_write_interface(I2C_CTPM_ADDRESS, auc_i2c_write_buf, 2);
			cmd_write(0x55,0xaa,0x00,0x00,2);
			delay_qt_ms(5);
		}while(i_ret <= 0 && i < 5 );
		#else
		//auc_i2c_write_buf[0] = 0x55;
		//ft5x02_i2c_Write(client, auc_i2c_write_buf, 1);
		cmd_write(0x55,0x00,0x00,0x00,1);
		delay_qt_ms(1);
		//auc_i2c_write_buf[0] = 0xaa;
		//ft5x02_i2c_Write(client, auc_i2c_write_buf, 1);
		cmd_write(0xaa,0x00,0x00,0x00,1);
		#endif

		/*********Step 3:check READ-ID***********************/
		delay_qt_ms(1);

		//ft5x02_upgrade_send_head(client);
		cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
		//auc_i2c_write_buf[0] = 0x90;
		//auc_i2c_write_buf[1] = auc_i2c_write_buf[2] = auc_i2c_write_buf[3] = 0x00;
		//ft5x02_i2c_Read(client, auc_i2c_write_buf, 4, reg_val, 2);
		cmd_write(0x90,0x00,0x00,0x00,4);
		byte_read(reg_val,2);

		if (reg_val[0] == 0x79
			&& reg_val[1] == 0x02) {
			//dev_dbg(&client->dev, "[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
			printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
			break;
		} else {
			printk("[FTS] Step 3 ERROR: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
			//delay_qt_ms(1);
		}
	}
	if (i >= 6)
		return ERR_READID;
	/********Step 4:enable write function*/
	//ft5x02_upgrade_send_head(client);
	cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
	//auc_i2c_write_buf[0] = 0x06;
	//ft5x02_i2c_Write(client, auc_i2c_write_buf, 1);
	cmd_write(0x06,0x00,0x00,0x00,1);

	/*********Step 5:write firmware(FW) to ctpm flash*********/
	bt_ecc = 0;

	packet_number = (dw_lenth) / FTS_PACKET_LENGTH;

	packet_buf[0] = 0xbf;
	packet_buf[1] = 0x00;
	for (j=0; j<packet_number; j++) {
		temp = j * FTS_PACKET_LENGTH;
		packet_buf[2] = (u8)(temp>>8);
		packet_buf[3] = (u8)temp;
		lenght = FTS_PACKET_LENGTH;
		packet_buf[4] = (u8)(lenght>>8);
		packet_buf[5] = (u8)lenght;
		if(temp>=0x4c00 && temp <(0x4c00+512))
			continue;

		for (i=0; i<FTS_PACKET_LENGTH; i++) {
			packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
			bt_ecc ^= packet_buf[6+i];
		}
		//ft5x02_upgrade_send_head(client);
		cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
		//ft5x02_i2c_Write(client, packet_buf, FTS_PACKET_LENGTH+6);
		byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
		delay_qt_ms(2);
	}

	if ((dw_lenth) % FTS_PACKET_LENGTH > 0) {
		temp = packet_number * FTS_PACKET_LENGTH;
		packet_buf[2] = (u8)(temp>>8);
		packet_buf[3] = (u8)temp;

		temp = (dw_lenth) % FTS_PACKET_LENGTH;
		packet_buf[4] = (u8)(temp>>8);
		packet_buf[5] = (u8)temp;

		for (i=0; i<temp; i++) {
			packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
			bt_ecc ^= packet_buf[6+i];
		}
		//ft5x02_upgrade_send_head(client);
		cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
		//ft5x02_i2c_Write(client, packet_buf, temp+6);
		byte_write(&packet_buf[0],temp + 6);
		delay_qt_ms(2);
	}

	/********Disable write function*/
	//ft5x02_upgrade_send_head(client);
	cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
	//auc_i2c_write_buf[0] = 0x04;
	//ft5x02_i2c_Write(client, auc_i2c_write_buf, 1);
	cmd_write(0x04,0x00,0x00,0x00,1);

	delay_qt_ms(1);
	/*********Step 6: read out checksum***********************/
	//ft5x02_upgrade_send_head(client);
	cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
	//auc_i2c_write_buf[0] = 0xcc;
	//ft5x02_i2c_Read(client, auc_i2c_write_buf, 1, reg_val, 1);
	cmd_write(0xcc,0x00,0x00,0x00,1);
	byte_read(reg_val,1);

	if (reg_val[0] != bt_ecc) {
		printk("[FTS]--ecc error! FW=%02x bt_ecc=%02x\n", reg_val[0], bt_ecc);
		//return -EIO;
		return ERR_READID;
	}

	/*********Step 7: reset the new FW***********************/
	//ft5x02_upgrade_send_head(client);
	cmd_write(0xFA,0xFA,0x00,0x00,2);//ft5x02_upgrade_send_head
	//auc_i2c_write_buf[0] = 0x07;
	//ft5x02_i2c_Write(client, auc_i2c_write_buf, 1);
	cmd_write(0x07,0x00,0x00,0x00,1);
	msleep(200);  /*make sure CTP startup normally*/
	//DBG("-------upgrade successful-----\n");

	//do_gettimeofday(&end_tv);
	//DBG("cost time=%lu.%lu\n", end_tv.tv_sec-begin_tv.tv_sec,
	//		end_tv.tv_usec-begin_tv.tv_usec);
	return ERR_OK;
}

int fts_ctpm_auto_clb(void)
{
        unsigned char uc_temp;
        unsigned char i ;

        printk("[FTS] start auto CLB.\n");
        msleep(200);
        fts_register_write(0, 0x40);
        //delay_ms(100);                       //make sure already enter factory mode
	msleep(100);
        fts_register_write(2, 0x4);               //write command to start calibration
        //delay_ms(300);
	msleep(300);
        for(i=0;i<100;i++){
                fts_register_read(0,&uc_temp,1);
                if (((uc_temp&0x70)>>4) == 0x0){    //return to normal mode, calibration finish
                        break;
                }
                //delay_ms(200);
		msleep(200);
                printk("[FTS] waiting calibration %d\n",i);
        }

        printk("[FTS] calibration OK.\n");

        msleep(300);
        fts_register_write(0, 0x40);          //goto factory mode
        delay_ms(100);                       //make sure already enter factory mode
        fts_register_write(2, 0x5);          //store CLB result
        delay_ms(300);
        fts_register_write(0, 0x0);          //return to normal mode
        msleep(300);
        printk("[FTS] store CLB result OK.\n");
        return 0;
}
void getVerNo(u8* buf, int len)
{
	u8 start_reg=0x0;
	int ret = -1;
	//int status = 0;
	int i = 0;
	start_reg = 0xa6;
	(void)i;

#if 0
	printk("read 0xa6 one time. \n");
	if(FTS_FALSE == fts_register_read(0xa6, buf, len)){
                return ;
	}

	for (i=0; i< len; i++) {
		printk("=========buf[%d] = 0x%x \n", i, buf);
	}

	printk("read 0xa8. \n");
	if(FTS_FALSE == fts_register_read(0xa8, buf, len)){
                return ;
	}
	for (i=0; i< len; i++) {
		printk("=========buf[%d] = 0x%x \n", i, buf);
	}

	ft5x_i2c_rxdata(buf, len);

        for (i=0; i< len; i++) {
                printk("=========buf[%d] = 0x%x \n", i, buf);
        }

        byte_read(buf, len);
        for (i=0; i< len; i++) {
                printk("=========buf[%d] = 0x%x \n", i, buf);
        }

#endif

	ret =fts_register_read(0xa6, buf, len);
	//et = ft5406_read_regs(ft5x0x_ts_data_test->client,start_reg, buf, 2);
	if (ret < 0) {
		printk("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
		return;
	}
#if 0
	for (i=0; i<2; i++) {
		printk("=========buf[%d] = 0x%x \n", i, buf);
	}
	return;
#endif
}

int fts_ctpm_fw_upgrade_with_i_file(void)
{
	FTS_BYTE*     pbt_buf = FTS_NULL;
	int i_ret = 0;
	unsigned char a;
	unsigned char b;
#define BUFFER_LEN (2)            //len == 2
	unsigned char buf[BUFFER_LEN] = {0};

	//=========FW upgrade========================*/
	printk("%s. \n", __func__);

	pbt_buf = CTPM_FW;
	//msleep(200);
        // cmd_write(0x07,0x00,0x00,0x00,1);
	msleep(100);
	getVerNo(buf, BUFFER_LEN);
	a = buf[0];
	b = fts_ctpm_get_i_file_ver();
	/* printk("a == %hu,  b== %hu \n",a, b);*/
	/*
	 * when the firmware in touch panel maybe corrupted,
	 * or the firmware in host flash is new, need upgrade
	 */
	if ( 0xa6 == a || a != b ){
		/*call the upgrade function*/
		if(chip_id == 0x55 || chip_id == 0x08 || chip_id == 0x00 || chip_id == 0x0a){
			i_ret =  ft5x06_ctpm_fw_upgrade(&pbt_buf[0],sizeof(CTPM_FW));
			if (i_ret != 0){
				printk("[FTS] upgrade failed i_ret = %d.\n", i_ret);
			}
			else {
				printk("[FTS] upgrade successfully.\n");
#ifdef AUTO_CLB
				fts_ctpm_auto_clb();  //start auto CLB
#endif
			}
		}
	}
	return i_ret;

}

unsigned char fts_ctpm_get_upg_ver(void)
{
	unsigned int ui_sz;
	ui_sz = sizeof(CTPM_FW);
	if (ui_sz > 2){
		return CTPM_FW[0];
	}
	else{
		return 0xff; //default value
	}
}

static int ft5x_i2c_rxdata(char *rxdata, int length)
{
	int ret;

	struct i2c_msg msgs[] = {
		{
			.addr	= this_client->addr,
			.flags	= 0,
			.len	= 1,
			.buf	= rxdata,
		},
		{
			.addr	= this_client->addr,
			.flags	= I2C_M_RD,
			.len	= length,
			.buf	= rxdata,
		},
	};
	ret = i2c_transfer(this_client->adapter, msgs, 2);
	if (ret < 0)
		printk("msg %s i2c read error: %d\n", __func__, ret);

	return ret;
}

static int ft5x_i2c_txdata(char *txdata, int length)
{
	int ret;

	struct i2c_msg msg[] = {
		{
			.addr	= this_client->addr,
			.flags	= 0,
			.len	= length,
			.buf	= txdata,
		},
	};

   	//msleep(1);
	ret = i2c_transfer(this_client->adapter, msg, 1);
	if (ret < 0)
		pr_err("%s i2c write error: %d\n", __func__, ret);

	return ret;
}

static int ft5x_set_reg(u8 addr, u8 para)
{
	u8 buf[3];
	int ret = -1;

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

	return 0;
}

static void ft5x_ts_release(void)
{
	struct ft5x_ts_data *data = i2c_get_clientdata(this_client);
#ifdef CONFIG_FT5X0X_MULTITOUCH
#ifdef TOUCH_KEY_SUPPORT
	if(1 == key_tp){
		input_report_key(data->input_dev, key_val, 0);
		dprintk(DEBUG_KEY_INFO,"Release Key = %d\n",key_val);
	} else{
		input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 0);
	}
#else
	input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 0);
	input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 0);
#endif

	input_report_key(data->input_dev, BTN_TOUCH, 0);

#else
	input_report_abs(data->input_dev, ABS_PRESSURE, 0);
	input_report_key(data->input_dev, BTN_TOUCH, 0);
#endif

	input_sync(data->input_dev);
	return;

}

static int ft5x_read_data(void)
{
	struct ft5x_ts_data *data = i2c_get_clientdata(this_client);
	struct ts_event *event = &data->event;
	unsigned char buf[32]={0};
	int ret = -1;

#ifdef CONFIG_FT5X0X_MULTITOUCH
	ret = ft5x_i2c_rxdata(buf, 31);
#else
	ret = ft5x_i2c_rxdata(buf, 31);
#endif
	if (ret < 0) {
		dprintk(DEBUG_X_Y_INFO,"%s read_data i2c_rxdata failed: %d\n", __func__, ret);
		return ret;
	}

	memset(event, 0, sizeof(struct ts_event));

	event->touch_point = buf[2] & 0x07;// 000 0111
	dprintk(DEBUG_X_Y_INFO,"touch point = %d\n",event->touch_point);

	if (event->touch_point == 0) {
		ft5x_ts_release();
		return 1;
	}

	switch (event->touch_point) {
	case 5:
		event->x5 = (s16)(buf[0x1b] & 0x0F)<<8 | (s16)buf[0x1c];
		event->y5 = (s16)(buf[0x1d] & 0x0F)<<8 | (s16)buf[0x1e];
		dprintk(DEBUG_X_Y_INFO,"source data:event->x5 = %d, event->y5 = %d. \n", event->x5, event->y5);
		if(1 == exchange_x_y_flag){
			swap(event->x5, event->y5);
		}
		if(1 == revert_x_flag){
			event->x5 = SCREEN_MAX_X - event->x5;
		}
		if(1 == revert_y_flag){
			event->y5 = SCREEN_MAX_Y - event->y5;
		}
		event->touch_ID5=(s16)(buf[0x1d] & 0xF0)>>4;

		dprintk(DEBUG_X_Y_INFO,"touch id : %d. \n",event->touch_ID5);
	case 4:
		event->x4 = (s16)(buf[0x15] & 0x0F)<<8 | (s16)buf[0x16];
		event->y4 = (s16)(buf[0x17] & 0x0F)<<8 | (s16)buf[0x18];
		dprintk(DEBUG_X_Y_INFO,"source data:event->x4 = %d, event->y4 = %d. \n", event->x4, event->y4);
		if(1 == exchange_x_y_flag){
			swap(event->x4, event->y4);
		}
		if(1 == revert_x_flag){
			event->x4 = SCREEN_MAX_X - event->x4;
		}
		if(1 == revert_y_flag){
			event->y4 = SCREEN_MAX_Y - event->y4;
		}
		event->touch_ID4=(s16)(buf[0x17] & 0xF0)>>4;

		dprintk(DEBUG_X_Y_INFO,"touch id : %d. \n",event->touch_ID4);
	case 3:
		event->x3 = (s16)(buf[0x0f] & 0x0F)<<8 | (s16)buf[0x10];
		event->y3 = (s16)(buf[0x11] & 0x0F)<<8 | (s16)buf[0x12];
		dprintk(DEBUG_X_Y_INFO,"source data:event->x3 = %d, event->y3 = %d. \n", event->x3, event->y3);
		if(1 == exchange_x_y_flag){
			swap(event->x3, event->y3);
		}
		if(1 == revert_x_flag){
			event->x3 = SCREEN_MAX_X - event->x3;
		}
		if(1 == revert_y_flag){
			event->y3 = SCREEN_MAX_Y - event->y3;
		}
		event->touch_ID3=(s16)(buf[0x11] & 0xF0)>>4;
		dprintk(DEBUG_X_Y_INFO,"touch id : %d. \n",event->touch_ID3);
	case 2:
		event->x2 = (s16)(buf[9] & 0x0F)<<8 | (s16)buf[10];
		event->y2 = (s16)(buf[11] & 0x0F)<<8 | (s16)buf[12];
		dprintk(DEBUG_X_Y_INFO,"source data:event->x2 = %d, event->y2 = %d. \n", event->x2, event->y2);
		if(1 == exchange_x_y_flag){
			swap(event->x2, event->y2);
		}
		if(1 == revert_x_flag){
			event->x2 = SCREEN_MAX_X - event->x2;
		}
		if(1 == revert_y_flag){
			event->y2 = SCREEN_MAX_Y - event->y2;
		}
		event->touch_ID2=(s16)(buf[0x0b] & 0xF0)>>4;

		dprintk(DEBUG_X_Y_INFO,"touch id : %d. \n",event->touch_ID2);
	case 1:
		event->x1 = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
		event->y1 = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
		dprintk(DEBUG_X_Y_INFO,"source data:event->x1 = %d, event->y1 = %d. \n", event->x1, event->y1);
		if(1 == exchange_x_y_flag){
			swap(event->x1, event->y1);
		}
		if(1 == revert_x_flag){
			event->x1 = SCREEN_MAX_X - event->x1;
		}
		if(1 == revert_y_flag){
			event->y1 = SCREEN_MAX_Y - event->y1;
		}
		event->touch_ID1=(s16)(buf[0x05] & 0xF0)>>4;
		dprintk(DEBUG_X_Y_INFO,"touch id : %d. \n",event->touch_ID1);
		break;
	default:
		return -1;
	}
	event->pressure = 20;
        return 0;
}

#ifdef TOUCH_KEY_LIGHT_SUPPORT
static void ft5x_lighting(void)
{
        ctp_key_light(1,15);
	return;
}
#endif

static void ft5x_report_multitouch(void)
{
	struct ft5x_ts_data *data = i2c_get_clientdata(this_client);
	struct ts_event *event = &data->event;

#ifdef WILLIAM_DEBUG
	printk("####%s####\n", __func__);
#endif

#ifdef TOUCH_KEY_SUPPORT
	if(1 == key_tp){
		return;
	}
#endif
	if (event->touch_point)
		input_report_key(data->input_dev, BTN_TOUCH, 1);
	else
		input_report_key(data->input_dev, BTN_TOUCH, 0);

	switch(event->touch_point) {
	case 5:
		input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID5);
		input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
		input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x5);
		input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y5);
		input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 30);
		input_mt_sync(data->input_dev);
		dprintk(DEBUG_X_Y_INFO,"report data:===x5 = %d,y5 = %d ====\n",event->x5,event->y5);
	case 4:
		input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID4);
		input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
		input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x4);
		input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y4);
		input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 30);
		input_mt_sync(data->input_dev);
		dprintk(DEBUG_X_Y_INFO,"report data:===x4 = %d,y4 = %d ====\n",event->x4,event->y4);
	case 3:
		input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID3);
		input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
		input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x3);
		input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y3);
		input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 30);
		input_mt_sync(data->input_dev);
		dprintk(DEBUG_X_Y_INFO,"report data:===x3 = %d,y3 = %d ====\n",event->x3,event->y3);
	case 2:
		input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID2);
		input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
		input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x2);
		input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y2);
		input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 30);
		input_mt_sync(data->input_dev);
		dprintk(DEBUG_X_Y_INFO,"report data:===x2 = %d,y2 = %d ====\n",event->x2,event->y2);
	case 1:
		input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->touch_ID1);
		input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
		input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x1);
		input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y1);
		input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 30);
		input_mt_sync(data->input_dev);
		dprintk(DEBUG_X_Y_INFO,"report data:===x1 = %d,y1 = %d ====\n",event->x1,event->y1);
		break;
	default:
		dprintk(DEBUG_X_Y_INFO,"report data:==touch_point default =\n");
		break;
	}

	input_sync(data->input_dev);
	return;
}

#ifndef CONFIG_FT5X0X_MULTITOUCH
static void ft5x_report_singletouch(void)
{
	struct ft5x_ts_data *data = i2c_get_clientdata(this_client);
	struct ts_event *event = &data->event;

	if (event->touch_point == 1) {
		input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->x1);
		input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->y1);
		input_report_abs(data->input_dev, ABS_PRESSURE, event->pressure);
	}
	dprintk(DEBUG_X_Y_INFO,"report:===x1 = %d,y1 = %d ====\n",event->x1,event->y1);
	input_report_key(data->input_dev, BTN_TOUCH, 1);
	input_sync(data->input_dev);
	return;
}
#endif

#ifdef TOUCH_KEY_SUPPORT
static void ft5x_report_touchkey(void)
{
	struct ft5x_ts_data *data = i2c_get_clientdata(this_client);
	struct ts_event *event = &data->event;

#ifdef TOUCH_KEY_FOR_ANGDA
	if((1==event->touch_point)&&(event->x1 > TOUCH_KEY_X_LIMIT)){
		key_tp = 1;
		if(event->y1 < 40){
			key_val = 1;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 1====\n");
		}else if(event->y1 < 90){
			key_val = 2;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 2 ====\n");
		}else{
			key_val = 3;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 3====\n");
		}
	} else{
		key_tp = 0;
	}
#endif
#ifdef TOUCH_KEY_FOR_EVB13
	if((1==event->touch_point)&&((event->x1 > TOUCH_KEY_LOWER_X_LIMIT)&&(event->x1<TOUCH_KEY_HIGHER_X_LIMIT))){
		key_tp = 1;
		if(event->y1 < 5){
			key_val = 1;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 1====\n");
		}else if((event->y1 < 45)&&(event->y1>35)){
			key_val = 2;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 2 ====\n");
		}else if((event->y1 < 75)&&(event->y1>65)){
			key_val = 3;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 3====\n");
		}else if ((event->y1 < 105)&&(event->y1>95))	{
			key_val = 4;
			input_report_key(data->input_dev, key_val, 1);
			input_sync(data->input_dev);
			dprintk(DEBUG_KEY_INFO,"===KEY 4====\n");
		}
	}else{
		key_tp = 0;
	}
#endif

#ifdef TOUCH_KEY_LIGHT_SUPPORT
	ft5x_lighting();
#endif
	return;
}
#endif

static void ft5x_report_value(void)
{

#ifdef TOUCH_KEY_SUPPORT
	ft5x_report_touchkey();
#endif

#ifdef CONFIG_FT5X0X_MULTITOUCH
	ft5x_report_multitouch();
#else	/* CONFIG_FT5X0X_MULTITOUCH*/
	ft5x_report_singletouch();
#endif	/* CONFIG_FT5X0X_MULTITOUCH*/
	return;
}

static void ft5x_ts_pen_irq_work(struct work_struct *work)
{
	int ret = -1;
	ret = ft5x_read_data();
	if (ret == 0) {
		ft5x_report_value();
	}
	dprintk(DEBUG_INT_INFO,"%s:ret:%d\n",__func__,ret);
}

irqreturn_t ft5x_ts_interrupt(int irq, void *dev_id)
{
	struct ft5x_ts_data *ft5x_ts = (struct ft5x_ts_data *)dev_id;
	dprintk(DEBUG_INT_INFO,"==========ft5x_ts TS Interrupt============\n");
	queue_work(ft5x_ts->ts_workqueue, &ft5x_ts->pen_event_work);
	return IRQ_HANDLED;
}

static void ft5x_resume_events (struct work_struct *work)
{
	int i = 0;
    int ret = 0;
	ctp_wakeup(0, 20);

#ifdef CONFIG_HAS_EARLYSUSPEND
	if(STANDBY_WITH_POWER_OFF != standby_level){
		goto standby_with_power_on;
	}
#endif

	if(chip_id == 0x02 ){
#ifdef FT5X02_CONFIG_INI
		if (ft5x02_Get_Param_From_Ini(FT5X02_CONFIG_NAME) >= 0)
			ft5x02_Init_IC_Param(this_client);
		else
			printk("Get ft5x02 param from INI file failed\n");
#else
		msleep(200);	/*wait...*/
		while(i<5){
			dprintk(DEBUG_INIT,"-----------------------------------------Init ic param\r\n");
			if (ft5x02_Init_IC_Param(this_client) >=0 ){
				dprintk(DEBUG_INIT,"---------------------------------------get ic param\r\n");
				if(ft5x02_get_ic_param(this_client) >=0)
					break;
			}
			i++;
		}
#endif
        }

#ifdef CONFIG_HAS_EARLYSUSPEND
standby_with_power_on:
#endif
	ret = input_set_int_enable(&(config_info.input_type), 1);
	if (ret < 0)
		dprintk(DEBUG_SUSPEND,"%s irq disable failed\n", __func__);
}


static int ft5x_ts_suspend(struct device *dev, pm_message_t mesg)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ft5x_ts_data *data = i2c_get_clientdata(client);
	int ret = 0;
	dprintk(DEBUG_SUSPEND,"==ft5x_ts_suspend=\n");
	dprintk(DEBUG_SUSPEND,"CONFIG_PM: write FT5X0X_REG_PMODE .\n");
#ifndef CONFIG_HAS_EARLYSUSPEND
	data->is_suspended = true;
#endif
	if (data->is_suspended == true) {
		//ft5x_ts_release();
		flush_workqueue(ft5x_resume_wq);
		ret = input_set_int_enable(&(config_info.input_type), 0);
		if (ret < 0)
			dprintk(DEBUG_SUSPEND,"%s irq disable failed\n", __func__);
		cancel_work_sync(&data->pen_event_work);
		flush_workqueue(data->ts_workqueue);
		ft5x_set_reg(FT5X0X_REG_PMODE, PMODE_HIBERNATE);
		msleep(5);
		input_set_power_enable(&(config_info.input_type), 0);
	}
	return 0;
}

static int ft5x_ts_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ft5x_ts_data *data = i2c_get_clientdata(client);
	dprintk(DEBUG_SUSPEND,"==CONFIG_PM:ft5x_ts_resume== \n");
	data->is_suspended = true;
	input_set_power_enable(&(config_info.input_type), 1);
        msleep(5);
    queue_work(ft5x_resume_wq, &ft5x_resume_work);

	return 0;
}

#ifdef CONFIG_HAS_EARLYSUSPEND
static void ft5x_ts_early_suspend(struct early_suspend *handler)
{
    int ret = 0;
	struct ft5x_ts_data *data = i2c_get_clientdata(this_client);
	dprintk(DEBUG_SUSPEND,"==ft5x_ts_suspend=\n");
	dprintk(DEBUG_SUSPEND,"CONFIG_HAS_EARLYSUSPEND: write FT5X0X_REG_PMODE .\n");
	ft5x_ts_release();
    data->is_suspended = false;
	flush_workqueue(ft5x_resume_wq);
	ret = input_set_int_enable(&(config_info.input_type), 0);
	if (ret < 0)
		dprintk(DEBUG_SUSPEND,"%s irq disable failed\n", __func__);
	cancel_work_sync(&data->pen_event_work);
	flush_workqueue(data->ts_workqueue);
	ft5x_set_reg(FT5X0X_REG_PMODE, PMODE_HIBERNATE);
	msleep(5);
	input_set_power_enable(&(config_info.input_type), 0);
}

static void ft5x_ts_late_resume(struct early_suspend *handler)
{
	struct ft5x_ts_data *data = container_of(handler, struct ft5x_ts_data, early_suspend);
	dprintk(DEBUG_SUSPEND,"==CONFIG_HAS_EARLYSUSPEND:ft5x_ts_resume== \n");
	if (data->is_suspended == false) {
		input_set_power_enable(&(config_info.input_type), 1);
		msleep(5);
		queue_work(ft5x_resume_wq, &ft5x_resume_work);
	}

	printk("ts->is_suspended:%d\n",data->is_suspended);
}

#endif

static void ft5x_init_events (struct work_struct *work)
{
	int i = 0;
	int ret;
	dprintk(DEBUG_INIT,"====%s begin=====.  \n", __func__);

	while((chip_id == 0x00) || (chip_id == 0xa3)){
		delay_ms(5);
		ret = i2c_smbus_read_byte_data(this_client,0xA3);
        	dprintk(DEBUG_INIT,"addr:0x%x,chip_id_value:0x%x\n",this_client->addr,ret);
		if((ret != 0x00) && (ret != 0xa3)) {
			chip_id = ret;
			break;
		}
		if((i++)>10) {
			break;
		}
	}
	dprintk(DEBUG_INIT,"read chip_id timers,timers=%d\n",i);
	i = 0;

#ifdef CONFIG_SUPPORT_FTS_CTP_UPG
	fts_ctpm_fw_upgrade_with_i_file();
#endif

	if(chip_id == 0x02 ){
#ifdef FT5X02_CONFIG_INI
		if (ft5x02_Get_Param_From_Ini(FT5X02_CONFIG_NAME) >= 0)
			ft5x02_Init_IC_Param(this_client);
		else
			printk("Get ft5x02 param from INI file failed\n");
#else
		msleep(1000);	/*wait...*/
		while(i<5){
			dprintk(DEBUG_INIT,"-----------------------------------------Init ic param\r\n");
			if (ft5x02_Init_IC_Param(this_client) >=0 ){
				dprintk(DEBUG_INIT,"---------------------------------------get ic param\r\n");
				if(ft5x02_get_ic_param(this_client) >=0)
					break;
			}
			i++;
		}
#endif
        }

}

static int ft5x_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	printk("==ft5x_ts_probe==\n");
	struct ft5x_ts_data *ft5x_ts;
	struct input_dev *input_dev;
	struct device *dev;
	struct i2c_dev *i2c_dev;
	int err = 0;

#ifdef TOUCH_KEY_SUPPORT
	int i = 0;
#endif

	dprintk(DEBUG_INIT,"====%s begin=====.  \n", __func__);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		err = -ENODEV;
		printk("check_functionality_failed\n");
		goto exit_check_functionality_failed;
	}

	ft5x_ts = kzalloc(sizeof(*ft5x_ts), GFP_KERNEL);
	if (!ft5x_ts)	{
		err = -ENOMEM;
		printk("alloc_data_failed\n");
		goto exit_alloc_data_failed;
	}

	this_client = client;
	i2c_set_clientdata(client, ft5x_ts);

	ft5x_wq = create_singlethread_workqueue("ft5x_init");
	if (ft5x_wq == NULL) {
		printk("create ft5x_wq fail!\n");
		return -ENOMEM;
	}

	queue_work(ft5x_wq, &ft5x_init_work);

	INIT_WORK(&ft5x_ts->pen_event_work, ft5x_ts_pen_irq_work);
	ft5x_ts->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));
	if (!ft5x_ts->ts_workqueue) {
		err = -ESRCH;
		printk("ts_workqueue fail!\n");
		goto exit_create_singlethread;
	}

	input_dev = input_allocate_device();
	if (!input_dev) {
		err = -ENOMEM;
		dev_err(&client->dev, "failed to allocate input device\n");
		goto exit_input_dev_alloc_failed;
	}

	ft5x_ts->input_dev = input_dev;

#ifdef CONFIG_FT5X0X_MULTITOUCH
	set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit);
	set_bit(ABS_MT_POSITION_X, input_dev->absbit);
	set_bit(ABS_MT_POSITION_Y, input_dev->absbit);
	set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);
#ifdef FOR_TSLIB_TEST
	set_bit(BTN_TOUCH, input_dev->keybit);
#endif
	input_set_abs_params(input_dev,
			     ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
	input_set_abs_params(input_dev,
			     ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
	input_set_abs_params(input_dev,
			     ABS_MT_TOUCH_MAJOR, 0, PRESS_MAX, 0, 0);
	input_set_abs_params(input_dev,
			     ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);
	input_set_abs_params(input_dev,
			     ABS_MT_TRACKING_ID, 0, 4, 0, 0);
#ifdef TOUCH_KEY_SUPPORT
	key_tp = 0;
	input_dev->evbit[0] = BIT_MASK(EV_KEY);
	for (i = 1; i < TOUCH_KEY_NUMBER; i++)
		set_bit(i, input_dev->keybit);
#endif
#else
	set_bit(ABS_MT_POSITION_X, input_dev->absbit);
	set_bit(ABS_MT_POSITION_Y, input_dev->absbit);
	set_bit(ABS_PRESSURE, input_dev->absbit);
	set_bit(BTN_TOUCH, input_dev->keybit);
	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
	input_set_abs_params(input_dev,
			     ABS_PRESSURE, 0, PRESS_MAX, 0 , 0);
#endif

	set_bit(EV_ABS, input_dev->evbit);
	set_bit(EV_KEY, input_dev->evbit);
	set_bit(INPUT_PROP_DIRECT, input_dev->propbit);

	input_dev->name	= CTP_NAME;		//dev_name(&client->dev)
	err = input_register_device(input_dev);
	if (err) {
		dev_err(&client->dev,"ft5x_ts_probe: failed to register input device: %s\n",
		        dev_name(&client->dev));
		goto exit_input_register_device_failed;
	}

    ft5x_ts->is_suspended = false;

	ft5x_resume_wq = create_singlethread_workqueue("ft5x_resume");
	if (ft5x_resume_wq == NULL) {
		printk("create ft5x_resume_wq fail!\n");
		return -ENOMEM;
	}

#ifdef CONFIG_HAS_EARLYSUSPEND
	printk("==register_early_suspend =\n");
	ft5x_ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	ft5x_ts->early_suspend.suspend = ft5x_ts_early_suspend;
	ft5x_ts->early_suspend.resume	= ft5x_ts_late_resume;
	register_early_suspend(&ft5x_ts->early_suspend);
#endif

#ifdef CONFIG_FT5X0X_MULTITOUCH
	dprintk(DEBUG_INIT,"CONFIG_FT5X0X_MULTITOUCH is defined. \n");
#endif

    config_info.dev = &(ft5x_ts->input_dev->dev);
	err = input_request_int(&(config_info.input_type), ft5x_ts_interrupt,
				CTP_IRQ_MODE, ft5x_ts);
	if (err) {
		pr_info( "goodix_probe: request irq failed\n");
		goto exit_irq_request_failed;
	}

    i2c_dev = get_free_i2c_dev(client->adapter);
	if (IS_ERR(i2c_dev)){
		err = PTR_ERR(i2c_dev);
		printk("i2c_dev fail!");
		return err;
	}

	dev = device_create(i2c_dev_class, &client->adapter->dev, MKDEV(I2C_MAJOR,client->adapter->nr),
	         NULL, "aw_i2c_ts%d", client->adapter->nr);
	if (IS_ERR(dev))	{
			err = PTR_ERR(dev);
			printk("dev fail!\n");
			return err;
	}

	device_enable_async_suspend(&client->dev);
	dprintk(DEBUG_INIT,"==%s over =\n", __func__);

	return 0;

exit_irq_request_failed:
    cancel_work_sync(&ft5x_resume_work);
	destroy_workqueue(ft5x_resume_wq);
exit_input_register_device_failed:
	input_free_device(input_dev);
exit_input_dev_alloc_failed:
	input_free_int(&(config_info.input_type), ft5x_ts);
    i2c_set_clientdata(client, NULL);
    cancel_work_sync(&ft5x_ts->pen_event_work);
	destroy_workqueue(ft5x_ts->ts_workqueue);
exit_create_singlethread:
	kfree(ft5x_ts);
exit_alloc_data_failed:
exit_check_functionality_failed:
	cancel_work_sync(&ft5x_init_work);
	destroy_workqueue(ft5x_wq);

	return err;
}

static int ft5x_ts_remove(struct i2c_client *client)
{

	struct ft5x_ts_data *ft5x_ts = i2c_get_clientdata(client);
	ft5x_set_reg(FT5X0X_REG_PMODE, PMODE_HIBERNATE);

	printk("==ft5x_ts_remove=\n");
	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR,client->adapter->nr));
	input_free_int(&(config_info.input_type), ft5x_ts);
#ifdef CONFIG_HAS_EARLYSUSPEND
	unregister_early_suspend(&ft5x_ts->early_suspend);
#endif
	cancel_work_sync(&ft5x_resume_work);
	destroy_workqueue(ft5x_resume_wq);
	input_unregister_device(ft5x_ts->input_dev);
	input_free_device(ft5x_ts->input_dev);
	cancel_work_sync(&ft5x_ts->pen_event_work);
	destroy_workqueue(ft5x_ts->ts_workqueue);
	input_set_power_enable(&(config_info.input_type), 0);
	kfree(ft5x_ts);

	i2c_set_clientdata(this_client, NULL);

	return 0;

}

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

static struct i2c_driver ft5x_ts_driver = {
	.class          = I2C_CLASS_HWMON,
	.probe		= ft5x_ts_probe,
	.remove		= ft5x_ts_remove,
	.id_table	= ft5x_ts_id,
	.driver	= {
		.name	= CTP_NAME,
		.owner	= THIS_MODULE,
		.suspend        = ft5x_ts_suspend,
		.resume         = ft5x_ts_resume,
	},
	.address_list	= normal_i2c,

};

static int aw_open(struct inode *inode, struct file *file)
{
	int subminor;
	struct i2c_client *client;
	struct i2c_adapter *adapter;
	struct i2c_dev *i2c_dev;

	printk("====%s======.\n", __func__);
	dprintk(DEBUG_OTHERS_INFO,"enter aw_open function\n");
	subminor = iminor(inode);
	dprintk(DEBUG_OTHERS_INFO,"subminor=%d\n",subminor);

	i2c_dev = i2c_dev_get_by_minor(2);
	if (!i2c_dev)	{
		printk("error i2c_dev\n");
		return -ENODEV;
	}
	adapter = i2c_get_adapter(i2c_dev->adap->nr);
	if (!adapter)	{
		return -ENODEV;
	}

	client = kzalloc(sizeof(*client), GFP_KERNEL);

	if (!client)	{
		i2c_put_adapter(adapter);
		return -ENOMEM;
	}
	snprintf(client->name, I2C_NAME_SIZE, "pctp_i2c_ts%d", adapter->nr);
	//client->driver = &ft5x_ts_driver;
	client->adapter = adapter;
	file->private_data = client;

	return 0;
}

static long aw_ioctl(struct file *file, unsigned int cmd,unsigned long arg )
{
	dprintk(DEBUG_OTHERS_INFO,"====%s====\n",__func__);
	dprintk(DEBUG_OTHERS_INFO,"line :%d,cmd = %d,arg = %ld.\n",__LINE__,cmd,arg);

	switch (cmd) {
	case UPGRADE:
	        dprintk(DEBUG_OTHERS_INFO,"==UPGRADE_WORK=\n");
		fts_ctpm_fw_upgrade_with_i_file();
		// calibrate();
		break;
	default:
		break;
	}
	return 0;
}

static int aw_release (struct inode *inode, struct file *file)
{
	struct i2c_client *client = file->private_data;
	dprintk(DEBUG_OTHERS_INFO,"enter aw_release function.\n");
	i2c_put_adapter(client->adapter);
	kfree(client);
	file->private_data = NULL;
	return 0;
}

static const struct file_operations aw_i2c_ts_fops ={
	.owner = THIS_MODULE,
	.open = aw_open,
	.unlocked_ioctl = aw_ioctl,
	.release = aw_release,
};
static int ctp_get_system_config(void)
{
        ctp_print_info(config_info,DEBUG_INIT);
        twi_id = config_info.twi_id;
        screen_max_x = config_info.screen_max_x;
        screen_max_y = config_info.screen_max_y;
        revert_x_flag = config_info.revert_x_flag;
        revert_y_flag = config_info.revert_y_flag;
        exchange_x_y_flag = config_info.exchange_x_y_flag;
        if((screen_max_x == 0) || (screen_max_y == 0)){
                printk("%s:read config error!\n",__func__);
                return 0;
        }
        return 1;
}
static int __init ft5x_ts_init(void)
{
	printk("==ft5x_ts_init==\n");
	int ret = -1;
	dprintk(DEBUG_INIT,"***************************init begin*************************************\n");
#ifdef WILLIAM_DEBUG
	printk("####%s start####\n", __func__);
#endif
	if (input_sensor_startup(&(config_info.input_type))) {
		printk("%s: ctp_fetch_sysconfig_para err.\n", __func__);
		return 0;
	} else {
		ret = input_sensor_init(&(config_info.input_type));
		if (0 != ret) {
			printk("%s:ctp_ops.init_platform_resource err. \n", __func__);
		}
	}

	if(config_info.ctp_used == 0){
	        printk("*** ctp_used set to 0 !\n");
	        printk("*** if use ctp,please put the sys_config.fex ctp_used set to 1. \n");
	        return 0;
	}

        if(!ctp_get_system_config()){
                printk("%s:read config fail!\n",__func__);
                return ret;
        }
	input_set_power_enable(&(config_info.input_type), 1);
	msleep(10);
	ctp_wakeup(0, 10);

	ft5x_ts_driver.detect = ctp_detect;

	ret= register_chrdev(I2C_MAJOR,"aw_i2c_ts",&aw_i2c_ts_fops );
	if(ret) {
		printk("%s:register chrdev failed\n",__FILE__);
		return ret;
	}

	i2c_dev_class = class_create(THIS_MODULE,"aw_i2c_dev");
	if (IS_ERR(i2c_dev_class)) {
		ret = PTR_ERR(i2c_dev_class);
		class_destroy(i2c_dev_class);
	}
        ret = i2c_add_driver(&ft5x_ts_driver);

        dprintk(DEBUG_INIT,"****************************init end************************************\n");
#ifdef WILLIAM_DEBUG
	printk("####%s end####\n", __func__);
#endif
	return ret;
}

static void __exit ft5x_ts_exit(void)
{
	printk("==ft5x_ts_exit==\n");
	i2c_del_driver(&ft5x_ts_driver);
	class_destroy(i2c_dev_class);
	unregister_chrdev(I2C_MAJOR, "aw_i2c_ts");
	input_sensor_free(&(config_info.input_type));
}

late_initcall(ft5x_ts_init);
module_exit(ft5x_ts_exit);
MODULE_AUTHOR("<wenfs@Focaltech-systems.com>");
MODULE_DESCRIPTION("FocalTech ft5x TouchScreen driver");
MODULE_LICENSE("GPL");

twi0: twi@0x05002000{
			clock-frequency = <100000>;
			pinctrl-0 = <&twi0_pins_a>;
			pinctrl-1 = <&twi0_pins_b>;
			status = "okay";
			ctp@3b {
				compatible = "ft5x_ts";
				reg = <0x3b>;
				device_type = "ctp";
				status = "okay";
				ctp_name = "ft5x_ts";
				ctp_twi_id = <0x0>;
				ctp_twi_addr = <0x3b>;
				ctp_screen_max_x = <0x02D0>;
				ctp_screen_max_y = <0x0500>;
				ctp_revert_x_flag = <1>;
				ctp_revert_y_flag = <1>;

				ctp_exchange_x_y_flag = <0x1>;
				ctp_int_port = <&pio PH 15 6 0xffffffff 0xffffffff 0>;
				ctp_wakeup = <&pio PH 14 1 0xffffffff 0xffffffff 1>;
				ctp_power_io = <&pio PB 5 1 0xffffffff 0xffffffff 1>;
				ctp-supply = <&reg_cldo2>;
				ctp_power_ldo_vol = <3300>;
			};
		};

pio: pinctrl@0300b000 {
			twi0_pins_a: twi0@0 {
				allwinner,pins = "PH0", "PH1";
				allwinner,pname = "twi0_scl", "twi0_sda";
				allwinner,function = "twi0";
				allwinner,muxsel = <2>;
				allwinner,drive = <1>;
				allwinner,pull = <0>;
			};

			twi0_pins_b: twi0@1 {
				allwinner,pins = "PH0", "PH1";
				allwinner,function = "io_disabled";
				allwinner,muxsel = <7>;
				allwinner,drive = <1>;
				allwinner,pull = <0>;
			};
}

[  107.311165] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3)
[  107.320956] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4)
[  107.330676] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5)
[  107.340367] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6)
[  107.350250] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x7)
[  107.359835] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x8)
[  107.369453] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x9)
[  107.379070] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0xa)
[  107.388751] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0xb)
[  107.398379] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0xc)
[  107.407991] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0xd)
[  107.417682] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0xe)
[  107.427290] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0xf)
[  107.437429] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x10)
[  107.447131] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x11)
[  107.456932] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x12)
[  107.466689] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x13)
[  107.476443] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x14)
[  107.486187] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x15)
[  107.495887] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x16)
[  107.505627] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x17)
[  107.515488] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x18)
[  107.525335] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x19)
[  107.535075] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x1a)
[  107.544771] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x1b)
[  107.554712] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x1c)
[  107.564565] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x1d)
[  107.574809] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x1e)
[  107.584560] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x1f)
[  107.594328] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x20)
[  107.599813] healthd: battery l=79 v=4003 t=30.0 h=2 st=2 fc=1771 chg=u
[  107.611603] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x21)
[  107.621483] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x22)
[  107.631398] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x23)
[  107.641359] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x24)
[  107.651147] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x25)
[  107.660840] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x26)
[  107.670569] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x27)
[  107.680301] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x28)
[  107.690746] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x29)
[  107.700783] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x2a)
[  107.710488] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x2b)
[  107.720374] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x2c)
[  107.730071] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x2d)
[  107.739777] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x2e)
[  107.749500] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  107.759010] msg ft5x_i2c_rxdata i2c read error: -70
[  107.764648] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x2f)
[  107.774298] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  107.783673] msg ft5x_i2c_rxdata i2c read error: -70
[  107.789257] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x30)
[  107.798948] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  107.808392] msg ft5x_i2c_rxdata i2c read error: -70
[  107.814000] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x31)
[  107.823651] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  107.833054] msg ft5x_i2c_rxdata i2c read error: -70
[  107.838659] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x32)
[  107.848292] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  107.857735] msg ft5x_i2c_rxdata i2c read error: -70
[  107.863393] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x33)
[  107.873097] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  107.882583] msg ft5x_i2c_rxdata i2c read error: -70
[  107.882836] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x34)
[  107.883142] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x35)
[  107.883424] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x36)
[  107.883699] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x37)
[  107.883968] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x38)
[  107.884241] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x39)
[  107.884581] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3a)
[  107.884880] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3c)
[  107.885151] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3d)
[  107.885420] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3e)
[  107.885689] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3f)
[  107.885991] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x40)
[  107.886260] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x41)
[  107.886529] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x42)
[  107.886798] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x43)
[  107.887066] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x44)
[  107.887335] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x45)
[  107.887611] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x46)
[  107.887880] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x47)
[  107.888148] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x48)
[  107.888420] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x49)
[  107.888708] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4a)
[  107.888977] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4b)
[  107.889239] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4c)
[  107.889501] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4d)
[  107.889771] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4e)
[  107.890038] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x4f)
[  107.890340] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x50)
[  107.890607] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x51)
[  107.890886] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x52)
[  107.891155] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x53)
[  107.891422] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x54)
[  107.891687] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x55)
[  107.891952] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x56)
[  107.892219] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x57)
[  107.892484] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x58)
[  107.892749] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x59)
[  107.893016] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5a)
[  107.893282] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5b)
[  107.893548] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5c)
[  107.893814] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5d)
[  107.894079] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5e)
[  107.894399] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x5f)
[  107.894702] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x60)
[  107.894973] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x61)
[  107.895241] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x62)
[  107.895509] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x63)
[  107.895778] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x64)
[  107.896048] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x65)
[  107.896317] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x66)
[  107.896584] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x67)
[  107.896853] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x68)
[  107.897122] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x69)
[  107.897391] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6a)
[  107.897666] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6b)
[  107.897938] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6c)
[  107.898208] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6d)
[  107.898476] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6e)
[  107.898744] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x6f)
[  107.899045] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x70)
[  107.899313] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x71)
[  107.899581] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x72)
[  107.899850] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x73)
[  107.900118] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x74)
[  107.900386] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x75)
[  107.900656] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x76)
[  107.900928] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x77)
[  108.516483] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.525921] msg ft5x_i2c_rxdata i2c read error: -70
[  108.531723] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.541209] msg ft5x_i2c_rxdata i2c read error: -70
[  108.546989] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.556390] msg ft5x_i2c_rxdata i2c read error: -70
[  108.562104] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.571472] msg ft5x_i2c_rxdata i2c read error: -70
[  108.577197] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.586569] msg ft5x_i2c_rxdata i2c read error: -70
[  108.592297] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.601670] msg ft5x_i2c_rxdata i2c read error: -70
[  108.607396] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.616769] msg ft5x_i2c_rxdata i2c read error: -70
[  108.622474] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.632107] msg ft5x_i2c_rxdata i2c read error: -70
[  108.637920] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.647337] msg ft5x_i2c_rxdata i2c read error: -70
[  108.653059] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.662524] msg ft5x_i2c_rxdata i2c read error: -70
[  108.668299] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.677696] msg ft5x_i2c_rxdata i2c read error: -70
[  108.683468] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.692978] msg ft5x_i2c_rxdata i2c read error: -70
[  108.698772] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.708168] msg ft5x_i2c_rxdata i2c read error: -70
[  108.713881] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.723296] msg ft5x_i2c_rxdata i2c read error: -70
[  108.729010] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.738384] msg ft5x_i2c_rxdata i2c read error: -70
[  108.744121] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.753495] msg ft5x_i2c_rxdata i2c read error: -70
[  108.759232] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.768662] msg ft5x_i2c_rxdata i2c read error: -70
[  108.774445] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.783824] msg ft5x_i2c_rxdata i2c read error: -70
[  108.789573] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.798964] msg ft5x_i2c_rxdata i2c read error: -70
[  108.804677] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.814068] msg ft5x_i2c_rxdata i2c read error: -70
[  108.819784] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.829172] msg ft5x_i2c_rxdata i2c read error: -70
[  108.834884] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.844356] msg ft5x_i2c_rxdata i2c read error: -70
[  108.850192] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.867975] msg ft5x_i2c_rxdata i2c read error: -70
[  108.875015] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.884979] msg ft5x_i2c_rxdata i2c read error: -70
[  108.893156] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.903009] msg ft5x_i2c_rxdata i2c read error: -70
[  108.909402] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.918950] msg ft5x_i2c_rxdata i2c read error: -70
[  108.924824] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.934287] msg ft5x_i2c_rxdata i2c read error: -70
[  108.940130] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.949631] msg ft5x_i2c_rxdata i2c read error: -70
[  108.955409] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.964898] msg ft5x_i2c_rxdata i2c read error: -70
[  108.971172] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.980763] msg ft5x_i2c_rxdata i2c read error: -70
[  108.986597] sunxi_i2c_do_xfer()1951 - [i2c0] incomplete xfer (status: 0x20, dev addr: 0x3b)
[  108.996107] msg ft5x_i2c_rxdata i2c read error: -70
[  117.627842] healthd: battery l=79 v=4006 t=30.0 h=2 st=2 fc=1771 chg=u\

ceres-b6:/ # dmesg
[  206.502538] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.502847] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.503154] twi_start()481 - [i2c0] START can't sendout!
[  206.503157] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.503261] msg ft5x_i2c_rxdata i2c read error: -121
[  206.503468] twi_start()481 - [i2c0] START can't sendout!
[  206.503470] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.503777] twi_start()481 - [i2c0] START can't sendout!
[  206.503779] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.504087] twi_start()481 - [i2c0] START can't sendout!
[  206.504089] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.504193] msg ft5x_i2c_rxdata i2c read error: -121
[  206.504401] twi_start()481 - [i2c0] START can't sendout!
[  206.504403] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.504710] twi_start()481 - [i2c0] START can't sendout!
[  206.504712] sunxi_i2c_do_xfer()1928 - [i2c0] twi_regulator:
[  206.505020] twi_start()481 - [i2c0] START can't sendout!