mtk android tp 调试

msg2133 tp调试

重要函数为：

tpd_local_init(tpd_probe), tpd_suspend, tpd_resume

Msg2133_driver.c:

/* Copyright Statement:
*
* This software/firmware and related documentation ("MediaTek Software") are
* protected under relevant copyright laws. The information contained herein
* is confidential and proprietary to MediaTek Inc. and/or its licensors.
* Without the prior written permission of MediaTek inc. and/or its licensors,
* any reproduction, modification, use or disclosure of MediaTek Software,
* and information contained herein, in whole or in part, shall be strictly prohibited.
*/
/* MediaTek Inc. (C) 2010. All rights reserved.
*
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
* THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
* CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
* SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
* CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
* The following software/firmware and/or related documentation ("MediaTek Software")
* have been modified by MediaTek Inc. All revisions are subject to any receiver's
* applicable license agreements with MediaTek Inc.
*/


#include "tpd.h"
#include <linux/interrupt.h>
#include <cust_eint.h>
#include <linux/i2c.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/rtpm_prio.h>
#include <linux/wait.h>
#include <linux/time.h>
#include <linux/delay.h>

#include <linux/dma-mapping.h>
#include <linux/slab.h>

#include "cust_gpio_usage.h"
#include "cust_gpio_usage.h"

#include "Tpd_custom_msg2133.h"

#ifdef MT6575
#include <mach/mt6575_pm_ldo.h>
#include <mach/mt6575_typedefs.h>
#include <mach/mt6575_boot.h>
#endif

#define GPIO_CTP_MSG2133_EN_PIN          125 // GPIO_CTP_EN_PIN
#define GPIO_CTP_MSG2133_EN_PIN_M_GPIO    GPIO_MODE_00

#define GPIO_CTP_MSG2133_EINT_PIN         75 //  GPIO_CTP_EINT_PIN
#define GPIO_CTP_MSG2133_EINT_PIN_M_GPIO   GPIO_CTP_EINT_PIN_M_EINT

extern struct tpd_device *tpd;

struct i2c_client *i2c_client = NULL;
struct task_struct *mthread = NULL;

struct TpdTouchDataT
{
	U8 packet_id;
	U8 x_h_y_h;
	U8 x_l;
	U8 y_l;
	U8 disx_h_disy_h;
	U8 disx_l;
	U8 disy_l;
    U8 checksum;
};
static struct TpdTouchDataT TpdTouchData;

static DECLARE_WAIT_QUEUE_HEAD(waiter);


static void tpd_eint_interrupt_handler(void);


extern void mt65xx_eint_unmask(unsigned int line);
extern void mt65xx_eint_mask(unsigned int line);
extern void mt65xx_eint_set_hw_debounce(kal_uint8 eintno, kal_uint32 ms);
extern kal_uint32 mt65xx_eint_set_sens(kal_uint8 eintno, kal_bool sens);
extern void mt65xx_eint_registration(kal_uint8 eintno, kal_bool Dbounce_En,
									 kal_bool ACT_Polarity, void (EINT_FUNC_PTR)(void),
									 kal_bool auto_umask);


static int __devinit tpd_probe(struct i2c_client *client, const struct i2c_device_id *id);
static int tpd_detect(struct i2c_client *client, int kind, struct i2c_board_info *info);
static int __devexit tpd_remove(struct i2c_client *client);
static int touch_event_handler(void *unused);

static int tpd_flag = 0;
static int point_num = 0;
static int p_point_num = 0;

#ifdef TPD_HAVE_BUTTON
static int tpd_keys_local[TPD_KEY_COUNT] = TPD_KEYS;
static int tpd_keys_dim_local[TPD_KEY_COUNT][4] = TPD_KEYS_DIM;
#endif

//#define TPD_CLOSE_POWER_IN_SLEEP
//#define TP_DEBUG
#define TP_FIRMWARE_UPDATE
#define TP_PROXIMITY_SENSOR
#define TPD_OK 0
// debug macros

#define TPD_LOGI  printk
#define TPD_LOGV printk
#if defined(TP_DEBUG_MSG)
#define pr_tp(format, args...) printk("<MSG>" format, ##args)
#define pr_ch(format, args...)                      \
	printk("<MSG>" "%s <%d>,%s(),cheehwa_print:\n\t"  \
	format,__FILE__,__LINE__,__func__, ##arg)
#else
#define pr_tp(format, args...)  do {} while (0)
#define pr_ch(format, args...)  do {} while (0)
#define pr_k(format, args...)  do {} while (0)
#endif

#ifdef TP_PROXIMITY_SENSOR
char ps_data_state[1] = {0};
enum
{
	DISABLE_CTP_PS,
	ENABLE_CTP_PS,
	RESET_CTP_PS
};
#endif

struct TouchInfoT
{
	int x1, y1;
	int x2, y2;
	int pressure;
	int count;
#ifdef TPD_HAVE_BUTTON 
    int key_id;
    int key_value;
#endif
};

#ifdef TP_FIRMWARE_UPDATE
#define U8 unsigned char
#define S8 signed char
#define U16 unsigned short
#define S16 signed short
#define U32 unsigned int
#define S32 signed int
#define TOUCH_ADDR_MSG21XX   0x4C
#define FW_ADDR_MSG21XX      0xC4
#define FW_UPDATE_ADDR_MSG21XX   0x92
static  char *fw_version;
#define DWIIC_MODE_ISP    0
#define DWIIC_MODE_DBBUS  1
#define   DOWNLOAD_FIRMWARE_BUF_SIZE   59*1024
static U8 *download_firmware_buf = NULL;
static int FwDataCnt=0;
//static int FwVersion;
struct class *firmware_class;
struct device *firmware_cmd_dev;

static int update_switch = 0;
#define ENABLE_DMA      0
#if ENABLE_DMA
static u8 *gpDMABuf_va = NULL;
static u32 gpDMABuf_pa = NULL;
#endif

#endif

struct touch_info
{
	unsigned short y[3];
	unsigned short x[3];
	unsigned short p[3];
	unsigned short count;
};

typedef struct
{
	unsigned short pos_x;
	unsigned short pos_y;
	unsigned short pos_x2;
	unsigned short pos_y2;
	unsigned short temp2;
	unsigned short temp;
	short dst_x;
	short dst_y;
	unsigned char checksum;
} SHORT_TOUCH_STATE;

static const struct i2c_device_id tpd_id[] = {{"msg2133", 0}, {}};
unsigned short myforce[] = {0, TOUCH_ADDR_MSG21XX, I2C_CLIENT_END, I2C_CLIENT_END};
static const unsigned short *const forces[] = { myforce, NULL };
static struct i2c_client_address_data addr_data = { .forces = forces, };

#ifdef TP_FIRMWARE_UPDATE
static void i2c_write(u8 addr, u8 *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->addr = addr;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_send(i2c_client, pbt_buf, dw_lenth);
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;

	if(ret <= 0)
	{
		printk("i2c_write_interface error line = %d, ret = %d\n", __LINE__, ret);
	}
}

static void i2c_read(u8 addr, u8 *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->addr = addr;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_recv(i2c_client, pbt_buf, dw_lenth);
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
    i2c_client->addr|=I2C_ENEXT_FLAG;

	if(ret <= 0)
	{
		printk("i2c_read_interface error line = %d, ret = %d\n", __LINE__, ret);
	}
}

static void i2c_write_update_msg2133(u8 *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->addr = FW_UPDATE_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_send(i2c_client, pbt_buf, dw_lenth);
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;

	// ret = i2c_smbus_write_i2c_block_data(i2c_client, *pbt_buf, dw_lenth-1, pbt_buf+1);
	if(ret <= 0)
	{
		printk("i2c_write_interface error line = %d, ret = %d\n", __LINE__, ret);
	}
}

static void i2c_write_msg2133(u8 *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->timing = 40;
	i2c_client->addr = FW_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_send(i2c_client, pbt_buf, dw_lenth);
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	i2c_client->timing = 240;

	// ret = i2c_smbus_write_i2c_block_data(i2c_client, *pbt_buf, dw_lenth-1, pbt_buf+1);
	if(ret <= 0)
	{
		printk("i2c_write_interface error line = %d, ret = %d\n", __LINE__, ret);
	}
}
static void i2c_read_update_msg2133(u8 *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->addr = FW_UPDATE_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_recv(i2c_client, pbt_buf, dw_lenth);
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	//  ret=i2c_smbus_read_i2c_block_data(i2c_client, *pbt_buf, dw_lenth-1, pbt_buf+1);

	if(ret <= 0)
	{
		printk("i2c_read_interface error line = %d, ret = %d\n", __LINE__, ret);
	}
}

static void i2c_read_msg2133(u8 *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->timing = 40;
	i2c_client->addr = FW_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_recv(i2c_client, pbt_buf, dw_lenth);
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	i2c_client->timing = 240;
	//  ret=i2c_smbus_read_i2c_block_data(i2c_client, *pbt_buf, dw_lenth-1, pbt_buf+1);

	if(ret <= 0)
	{
		printk("i2c_read_interface error line = %d, ret = %d\n", __LINE__, ret);
	}
}

#if ENABLE_DMA
ssize_t msg2133_dma_read_m_byte(u8 *returnData_va, u32 returnData_pa, U16 len)
{
	char     readData = 0;
	int     ret = 0, read_count = 0, read_length = 0;
	int    i, total_count = len;

	if(len == 0)
	{
		printk("[Error]msg2133_dma_read Read Len should not be zero!! \n");
		return 0;
	}

	//gpDMABuf_va = returnData_va; //mtk
	i2c_client->addr = FW_UPDATE_ADDR_MSG21XX;
	i2c_client->addr |= I2C_DMA_FLAG;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	returnData_va[0] = 0x11;
	ret = i2c_master_send(i2c_client, returnData_pa, 1);

	if(ret < 0)
	{
		printk("[Error]MATV sends command error!! \n");
		i2c_client->addr = TOUCH_ADDR_MSG21XX;
		i2c_client->addr|=I2C_ENEXT_FLAG;
		return 0;
	}

	ret = i2c_master_recv(i2c_client, returnData_pa, len); // mtk
	i2c_client->addr = TOUCH_ADDR_MSG21XX;
	i2c_client->addr|=I2C_ENEXT_FLAG;

	if(ret < 0)
	{
		printk("[Error]msg2133_dma_read reads data error!! \n");
		return 0;
	}

	//for (i = 0; i< total_count; i++)
	//    MATV_LOGD("[MATV]I2C ReadData[%d] = %x\n",i,returnData_va[i]);
	return 1;
}

#define MAX_CMD_LEN 255
ssize_t msg2133_dma_write_m_byte(u8 *Data, U16 len)
{
	char addr_bak;
	u32 phyAddr = 0;
	u8 *buf_dma = NULL;
	u32 old_addr = 0;
	int ret = 0;
	int retry = 3;

	addr_bak = i2c_client->addr;
	i2c_client->addr = FW_UPDATE_ADDR_MSG21XX;
	i2c_client->addr |= I2C_ENEXT_FLAG;
	if (len > MAX_CMD_LEN) {
		//TPD_LOGI("[i2c_master_send_ext] exceed the max write length \n");
		return -1;
	}

	phyAddr = 0;
	buf_dma = dma_alloc_coherent(0, len, &phyAddr, GFP_KERNEL);
	if (NULL == buf_dma) {
		//TPD_LOGI("[i2c_master_send_ext] Not enough memory \n");
		return -1;
	}
	memcpy(buf_dma, Data, len);
	i2c_client->addr |= I2C_DMA_FLAG;
	i2c_client->addr|=I2C_ENEXT_FLAG;

	do {
		ret = i2c_master_send(i2c_client, (u8*)phyAddr, len);
		retry --;
		if (ret != len) {
			//TPD_LOGI("[i2c_master_send_ext] Error sent I2C ret = %d\n", ret);
		}
	}while ((ret != len) && (retry > 0));

	dma_free_coherent(0, len, buf_dma, phyAddr);

	i2c_client->addr = addr_bak;

	return 1;
}

U8 drvISP_DMA_Read(U8 *pDataToRead, U32 pa_addr, U8 n)    //First it needs send 0x11 to notify we want to get flash data back.
{
	//    U8 Read_cmd = 0x11;
	//    unsigned char dbbus_rx_data[2] = {0};
	//    i2c_write_update_msg2133( &Read_cmd, 1);
	msg2133_dma_read_m_byte(pDataToRead, pa_addr, n);
	return 0;
}

#endif

void Get_Chip_Version(void)
{
	unsigned char dbbus_tx_data[3];
	unsigned char dbbus_rx_data[2];
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0xCE;
	i2c_write_msg2133(&dbbus_tx_data[0], 3);
	i2c_read_msg2133(&dbbus_rx_data[0], 2);

	if(dbbus_rx_data[1] == 0)
	{
		// it is Catch2
		pr_tp("*** Catch2 ***\n");
		//FwVersion  = 2;// 2 means Catch2
	}
	else
	{
		// it is catch1
		pr_tp("*** Catch1 ***\n");
		//FwVersion  = 1;// 1 means Catch1
	}
}

void dbbusDWIICEnterSerialDebugMode(void)
{
	U8 data[5];
	// Enter the Serial Debug Mode
	data[0] = 0x53;
	data[1] = 0x45;
	data[2] = 0x52;
	data[3] = 0x44;
	data[4] = 0x42;
	i2c_write_msg2133(data, 5);
}

void dbbusDWIICStopMCU(void)
{
	U8 data[1];
	// Stop the MCU
	data[0] = 0x37;
	i2c_write_msg2133(data, 1);
}

void dbbusDWIICIICUseBus(void)
{
	U8 data[1];
	// IIC Use Bus
	data[0] = 0x35;
	i2c_write_msg2133(data, 1);
}

void dbbusDWIICIICReshape(void)
{
	U8 data[1];
	// IIC Re-shape
	data[0] = 0x71;
	i2c_write_msg2133(data, 1);
}

void dbbusDWIICIICNotUseBus(void)
{
	U8 data[1];
	// IIC Not Use Bus
	data[0] = 0x34;
	i2c_write_msg2133(data, 1);
}

void dbbusDWIICNotStopMCU(void)
{
	U8 data[1];
	// Not Stop the MCU
	data[0] = 0x36;
	i2c_write_msg2133(data, 1);
}

void dbbusDWIICExitSerialDebugMode(void)
{
	U8 data[1];
	// Exit the Serial Debug Mode
	data[0] = 0x45;
	i2c_write_msg2133(data, 1);
	// Delay some interval to guard the next transaction
	//udelay ( 200 );        // delay about 0.2ms
}

void drvISP_EntryIspMode(void)
{
	U8 bWriteData[5] =
	{
		0x4D, 0x53, 0x54, 0x41, 0x52
	};
	i2c_write_update_msg2133(bWriteData, 5);
	mdelay(10);           // delay about 1ms
}

U8 drvISP_Read(U8 n, U8 *pDataToRead)    //First it needs send 0x11 to notify we want to get flash data back.
{
	U8 Read_cmd = 0x11;
	U8 i = 0;
	unsigned char dbbus_rx_data[16] = {0};
	i2c_write_update_msg2133(&Read_cmd, 1);
	//if (n == 1)
	{
		i2c_read_update_msg2133(&dbbus_rx_data[0], n + 1);

		for(i = 0; i < n; i++)
		{
			*(pDataToRead + i) = dbbus_rx_data[i + 1];
		}
	}
	//else
	{
		//     i2c_read_update_msg2133(pDataToRead, n);
	}
	return 0;
}

void drvISP_WriteEnable(void)
{
	U8 bWriteData[2] =
	{
		0x10, 0x06
	};
	U8 bWriteData1 = 0x12;
	i2c_write_update_msg2133(bWriteData, 2);
	i2c_write_update_msg2133(&bWriteData1, 1);
}


void drvISP_ExitIspMode(void)
{
	U8 bWriteData = 0x24;
	i2c_write_update_msg2133(&bWriteData, 1);
}

U8 drvISP_ReadStatus(void)
{
	U8 bReadData = 0;
	U8 bWriteData[2] =
	{
		0x10, 0x05
	};
	U8 bWriteData1 = 0x12;
	i2c_write_update_msg2133(bWriteData, 2);
	drvISP_Read(1, &bReadData);
	i2c_write_update_msg2133(&bWriteData1, 1);
	return bReadData;
}


void drvISP_BlockErase(U32 addr)
{
	U8 bWriteData[5] = { 0x00, 0x00, 0x00, 0x00, 0x00 };
	U8 bWriteData1 = 0x12;
	pr_ch("The drvISP_ReadStatus0=%d\n", drvISP_ReadStatus());
	drvISP_WriteEnable();
	pr_ch("The drvISP_ReadStatus1=%d\n", drvISP_ReadStatus());
	//Enable write status register
	bWriteData[0] = 0x10;
	bWriteData[1] = 0x50;
	i2c_write_update_msg2133(bWriteData, 2);
	i2c_write_update_msg2133(&bWriteData1, 1);
	//Write Status
	bWriteData[0] = 0x10;
	bWriteData[1] = 0x01;
	bWriteData[2] = 0x00;
	i2c_write_update_msg2133(bWriteData, 3);
	i2c_write_update_msg2133(&bWriteData1, 1);
	//Write disable
	bWriteData[0] = 0x10;
	bWriteData[1] = 0x04;
	i2c_write_update_msg2133(bWriteData, 2);
	i2c_write_update_msg2133(&bWriteData1, 1);

	while((drvISP_ReadStatus() & 0x01) == 0x01)
	{
		;
	}

	pr_ch("The drvISP_ReadStatus3=%d\n", drvISP_ReadStatus());
	drvISP_WriteEnable();
	pr_ch("The drvISP_ReadStatus4=%d\n", drvISP_ReadStatus());
	bWriteData[0] = 0x10;
	bWriteData[1] = 0xC7;        //Block Erase
	//bWriteData[2] = ((addr >> 16) & 0xFF) ;
	//bWriteData[3] = ((addr >> 8) & 0xFF) ;
	// bWriteData[4] = (addr & 0xFF) ;
	i2c_write_update_msg2133(bWriteData, 2);
	//i2c_write_update_msg2133( &bWriteData, 5);
	i2c_write_update_msg2133(&bWriteData1, 1);

	while((drvISP_ReadStatus() & 0x01) == 0x01)
	{
		;
	}
}

void drvISP_Program(U16 k, U8 *pDataToWrite)
{
	U16 i = 0;
	U16 j = 0;
	//U16 n = 0;
	U8 TX_data[133];
	U8 bWriteData1 = 0x12;
	U32 addr = k * 1024;
#if ENABLE_DMA

	for(j = 0; j < 8; j++)    //128*8 cycle
	{
		TX_data[0] = 0x10;
		TX_data[1] = 0x02;// Page Program CMD
		TX_data[2] = (addr + 128 * j) >> 16;
		TX_data[3] = (addr + 128 * j) >> 8;
		TX_data[4] = (addr + 128 * j);

		for(i = 0; i < 128; i++)
		{
			TX_data[5 + i] = pDataToWrite[j * 128 + i];
		}

		while((drvISP_ReadStatus() & 0x01) == 0x01)
		{
			;    //wait until not in write operation
		}

		drvISP_WriteEnable();
		//        i2c_write_update_msg2133( TX_data, 133);   //write 133 byte per cycle
		msg2133_dma_write_m_byte(TX_data, 133);
		i2c_write_update_msg2133(&bWriteData1, 1);
	}

#else

	for(j = 0; j < 512; j++)    //128*8 cycle
	{
		TX_data[0] = 0x10;
		TX_data[1] = 0x02;// Page Program CMD
		TX_data[2] = (addr + 2 * j) >> 16;
		TX_data[3] = (addr + 2 * j) >> 8;
		TX_data[4] = (addr + 2 * j);

		for(i = 0; i < 2; i++)
		{
			TX_data[5 + i] = pDataToWrite[j * 2 + i];
		}

		while((drvISP_ReadStatus() & 0x01) == 0x01)
		{
			;    //wait until not in write operation
		}

		drvISP_WriteEnable();
		i2c_write_update_msg2133(TX_data, 7);    //write 133 byte per cycle
		i2c_write_update_msg2133(&bWriteData1, 1);
	}

#endif
}


void drvISP_Verify(U16 k, U8 *pDataToVerify)
{
	U16 i = 0, j = 0;
	U8 bWriteData[5] =
	{
		0x10, 0x03, 0, 0, 0
	};
	U8 bWriteData1 = 0x12;
	U32 addr = k * 1024;
	U8 index = 0;
#if ENABLE_DMA
	U8 *RX_data = gpDMABuf_va; //mtk

	for(j = 0; j < 8; j++)    //128*8 cycle
	{
		bWriteData[2] = (U8)((addr + j * 128) >> 16);
		bWriteData[3] = (U8)((addr + j * 128) >> 8);
		bWriteData[4] = (U8)(addr + j * 128);

		while((drvISP_ReadStatus() & 0x01) == 0x01)
		{
			;    //wait until not in write operation
		}

		i2c_write_update_msg2133(bWriteData, 5);     //write read flash addr
		drvISP_DMA_Read(gpDMABuf_va, gpDMABuf_pa, 128); //mtk
		i2c_write_update_msg2133(&bWriteData1, 1);     //cmd end

		for(i = 0; i < 128; i++)    //log out if verify error
		{
			if((RX_data[i] != 0) && index < 10)
			{
				pr_tp("j=%d,RX_data[%d]=0x%x\n", j, i, RX_data[i]);
				index++;
			}

			if(RX_data[i] != pDataToVerify[128 * j + i])
			{
				pr_tp("k=%d,j=%d,i=%d===============Update Firmware Error================", k, j, i);
			}
		}
	}

#else
	U8 RX_data[128];

	for(j = 0; j < 256; j++)    //128*8 cycle
	{
		bWriteData[2] = (U8)((addr + j * 4) >> 16);
		bWriteData[3] = (U8)((addr + j * 4) >> 8);
		bWriteData[4] = (U8)(addr + j * 4);

		while((drvISP_ReadStatus() & 0x01) == 0x01)
		{
			;    //wait until not in write operation
		}

		i2c_write_update_msg2133(bWriteData, 5);     //write read flash addr
		drvISP_Read(4, RX_data);
		i2c_write_update_msg2133(&bWriteData1, 1);     //cmd end

		for(i = 0; i < 4; i++)    //log out if verify error
		{
			if((RX_data[i] != 0) && index < 10)
			{
				pr_tp("j=%d,RX_data[%d]=0x%x\n", j, i, RX_data[i]);
				index++;
			}

			if(RX_data[i] != pDataToVerify[4 * j + i])
			{
				pr_tp("k=%d,j=%d,RX_data[%d]=0x%x===============Update Firmware Error================", k, j, i, RX_data[i]);
			}
		}
	}

#endif
}

static ssize_t firmware_update_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%s\n", fw_version);
}

static ssize_t firmware_update_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
	U8 i;
	U8 dbbus_tx_data[4];
	unsigned char dbbus_rx_data[2] = {0};
	update_switch = 1;
	pr_ch("\n");
	//drvISP_EntryIspMode();
	//drvISP_BlockErase(0x00000);
	//M by cheehwa _HalTscrHWReset();
	mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ZERO);
	msleep(100);
	mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ONE);
	mdelay(500);
	//msctpc_LoopDelay ( 100 );        // delay about 100ms*****
	// Enable slave's ISP ECO mode
	dbbusDWIICEnterSerialDebugMode();
	dbbusDWIICStopMCU();
	dbbusDWIICIICUseBus();
	dbbusDWIICIICReshape();
	pr_ch("dbbusDWIICIICReshape\n");
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x08;
	dbbus_tx_data[2] = 0x0c;
	dbbus_tx_data[3] = 0x08;
	// Disable the Watchdog
	i2c_write_msg2133(dbbus_tx_data, 4);
	//Get_Chip_Version();
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x11;
	dbbus_tx_data[2] = 0xE2;
	dbbus_tx_data[3] = 0x00;
	i2c_write_msg2133(dbbus_tx_data, 4);
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x3C;
	dbbus_tx_data[2] = 0x60;
	dbbus_tx_data[3] = 0x55;
	i2c_write_msg2133(dbbus_tx_data, 4);
	pr_ch("update\n");
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x3C;
	dbbus_tx_data[2] = 0x61;
	dbbus_tx_data[3] = 0xAA;
	i2c_write_msg2133(dbbus_tx_data, 4);
	//Stop MCU
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x0F;
	dbbus_tx_data[2] = 0xE6;
	dbbus_tx_data[3] = 0x01;
	i2c_write_msg2133(dbbus_tx_data, 4);
	//Enable SPI Pad
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x02;
	i2c_write_msg2133(dbbus_tx_data, 3);
	i2c_read_msg2133(&dbbus_rx_data[0], 2);
	pr_tp("dbbus_rx_data[0]=0x%x", dbbus_rx_data[0]);
	dbbus_tx_data[3] = (dbbus_rx_data[0] | 0x20);  //Set Bit 5
	i2c_write_msg2133(dbbus_tx_data, 4);
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x25;
	i2c_write_msg2133(dbbus_tx_data, 3);
	dbbus_rx_data[0] = 0;
	dbbus_rx_data[1] = 0;
	i2c_read_msg2133(&dbbus_rx_data[0], 2);
	pr_tp("dbbus_rx_data[0]=0x%x", dbbus_rx_data[0]);
	dbbus_tx_data[3] = dbbus_rx_data[0] & 0xFC;  //Clear Bit 1,0
	i2c_write_msg2133(dbbus_tx_data, 4);
	/*
	//------------
	// ISP Speed Change to 400K
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x11;
	dbbus_tx_data[2] = 0xE2;
	i2c_write_msg2133( dbbus_tx_data, 3);
	i2c_read_msg2133( &dbbus_rx_data[3], 1);
	//pr_tp("dbbus_rx_data[0]=0x%x", dbbus_rx_data[0]);
	dbbus_tx_data[3] = dbbus_tx_data[3]&0xf7;  //Clear Bit3
	i2c_write_msg2133( dbbus_tx_data, 4);
	*/
	//WP overwrite
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x0E;
	dbbus_tx_data[3] = 0x02;
	i2c_write_msg2133(dbbus_tx_data, 4);
	//set pin high
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x10;
	dbbus_tx_data[3] = 0x08;
	i2c_write_msg2133(dbbus_tx_data, 4);
	dbbusDWIICIICNotUseBus();
	dbbusDWIICNotStopMCU();
	dbbusDWIICExitSerialDebugMode();
	///////////////////////////////////////
	// Start to load firmware
	///////////////////////////////////////
	drvISP_EntryIspMode();
	pr_ch("entryisp\n");
	drvISP_BlockErase(0x00000);
	//msleep(1000);
	pr_tp("FwVersion=2");

	for(i = 0; i < 59; i++)    // total  94 KB : 1 byte per R/W
	{

		pr_ch("drvISP_Program\n");
		if (download_firmware_buf == NULL)
			return 0;
		drvISP_Program(i,&download_firmware_buf[i*1024]);
		//pr_ch("drvISP_Verify\n");
		//drvISP_Verify ( i,&download_firmware_buf[i*1024] ); //verify data
	}

	pr_tp("update OK\n");
	drvISP_ExitIspMode();
	FwDataCnt = 0;
	if (download_firmware_buf != NULL)
	{
		kfree(download_firmware_buf);
		download_firmware_buf = NULL;
	}

	mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ZERO);
	msleep(100);
	mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ONE);
	msleep(500);
	update_switch = 0;
	return size;
}

static DEVICE_ATTR(update, 0777, firmware_update_show, firmware_update_store);

/*test=================*/
static ssize_t firmware_clear_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
	U16 k = 0, i = 0, j = 0;
	U8 bWriteData[5] =
	{
		0x10, 0x03, 0, 0, 0
	};
	U8 RX_data[256];
	U8 bWriteData1 = 0x12;
	U32 addr = 0;
	pr_ch("\n");

	for(k = 0; k < 94; i++)    // total  94 KB : 1 byte per R/W
	{
		addr = k * 1024;

		for(j = 0; j < 8; j++)    //128*8 cycle
		{
			bWriteData[2] = (U8)((addr + j * 128) >> 16);
			bWriteData[3] = (U8)((addr + j * 128) >> 8);
			bWriteData[4] = (U8)(addr + j * 128);

			while((drvISP_ReadStatus() & 0x01) == 0x01)
			{
				;    //wait until not in write operation
			}

			i2c_write_update_msg2133(bWriteData, 5);     //write read flash addr
			drvISP_Read(128, RX_data);
			i2c_write_update_msg2133(&bWriteData1, 1);    //cmd end

			for(i = 0; i < 128; i++)    //log out if verify error
			{
				if(RX_data[i] != 0xFF)
				{
					pr_tp("k=%d,j=%d,i=%d===============erase not clean================", k, j, i);
				}
			}
		}
	}

	pr_tp("read finish\n");
	return sprintf(buf, "%s\n", fw_version);
}

static ssize_t firmware_clear_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
	U8 dbbus_tx_data[4];
	unsigned char dbbus_rx_data[2] = {0};
	//msctpc_LoopDelay ( 100 );        // delay about 100ms*****
	// Enable slave's ISP ECO mode
	/*
	dbbusDWIICEnterSerialDebugMode();
	dbbusDWIICStopMCU();
	dbbusDWIICIICUseBus();
	dbbusDWIICIICReshape();*/

	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x08;
	dbbus_tx_data[2] = 0x0c;
	dbbus_tx_data[3] = 0x08;
	// Disable the Watchdog
	i2c_write_msg2133(dbbus_tx_data, 4);
	//Get_Chip_Version();
	//FwVersion  = 2;
	//if (FwVersion  == 2)
	{
		dbbus_tx_data[0] = 0x10;
		dbbus_tx_data[1] = 0x11;
		dbbus_tx_data[2] = 0xE2;
		dbbus_tx_data[3] = 0x00;
		i2c_write_msg2133(dbbus_tx_data, 4);
	}
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x3C;
	dbbus_tx_data[2] = 0x60;
	dbbus_tx_data[3] = 0x55;
	i2c_write_msg2133(dbbus_tx_data, 4);
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x3C;
	dbbus_tx_data[2] = 0x61;
	dbbus_tx_data[3] = 0xAA;
	i2c_write_msg2133(dbbus_tx_data, 4);
	//Stop MCU
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x0F;
	dbbus_tx_data[2] = 0xE6;
	dbbus_tx_data[3] = 0x01;
	i2c_write_msg2133(dbbus_tx_data, 4);
	//Enable SPI Pad
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x02;
	i2c_write_msg2133(dbbus_tx_data, 3);
	i2c_read_msg2133(&dbbus_rx_data[0], 2);
	pr_tp("dbbus_rx_data[0]=0x%x", dbbus_rx_data[0]);
	dbbus_tx_data[3] = (dbbus_rx_data[0] | 0x20);  //Set Bit 5
	i2c_write_msg2133(dbbus_tx_data, 4);
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x25;
	i2c_write_msg2133(dbbus_tx_data, 3);
	dbbus_rx_data[0] = 0;
	dbbus_rx_data[1] = 0;
	i2c_read_msg2133(&dbbus_rx_data[0], 2);
	pr_tp("dbbus_rx_data[0]=0x%x", dbbus_rx_data[0]);
	dbbus_tx_data[3] = dbbus_rx_data[0] & 0xFC;  //Clear Bit 1,0
	i2c_write_msg2133(dbbus_tx_data, 4);
	//WP overwrite
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x0E;
	dbbus_tx_data[3] = 0x02;
	i2c_write_msg2133(dbbus_tx_data, 4);
	//set pin high
	dbbus_tx_data[0] = 0x10;
	dbbus_tx_data[1] = 0x1E;
	dbbus_tx_data[2] = 0x10;
	dbbus_tx_data[3] = 0x08;
	i2c_write_msg2133(dbbus_tx_data, 4);
	dbbusDWIICIICNotUseBus();
	dbbusDWIICNotStopMCU();
	dbbusDWIICExitSerialDebugMode();
	///////////////////////////////////////
	// Start to load firmware
	///////////////////////////////////////
	drvISP_EntryIspMode();
	pr_tp("chip erase+\n");
	drvISP_BlockErase(0x00000);
	pr_tp("chip erase-\n");
	drvISP_ExitIspMode();
	return size;
}

static DEVICE_ATTR(clear, 0777, firmware_clear_show, firmware_clear_store);

/*test=================*/
/*Add by Tracy.Lin for update touch panel firmware and get fw version*/

static ssize_t firmware_version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
	pr_ch("*** firmware_version_show fw_version = %s***\n", fw_version);
	return sprintf(buf, "%s\n", fw_version);
}

static ssize_t firmware_version_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
	unsigned char dbbus_tx_data[3];
	unsigned char dbbus_rx_data[4] ;
	unsigned short major = 0, minor = 0;
	dbbusDWIICEnterSerialDebugMode();
	dbbusDWIICStopMCU();
	dbbusDWIICIICUseBus();
	dbbusDWIICIICReshape();
	fw_version = kzalloc(sizeof(char), GFP_KERNEL);
	pr_ch("\n");
	//Get_Chip_Version();
	dbbus_tx_data[0] = 0x53;
	dbbus_tx_data[1] = 0x00;
	dbbus_tx_data[2] = 0x74;
	i2c_write(TOUCH_ADDR_MSG21XX, &dbbus_tx_data[0], 3);
	i2c_read(TOUCH_ADDR_MSG21XX, &dbbus_rx_data[0], 4);
	major = (dbbus_rx_data[1] << 8) + dbbus_rx_data[0];
	minor = (dbbus_rx_data[3] << 8) + dbbus_rx_data[2];
	pr_tp("***major = %d ***\n", major);
	pr_tp("***minor = %d ***\n", minor);
	sprintf(fw_version, "%03d%03d", major, minor);
	pr_tp("***fw_version = %s ***\n", fw_version);
	return size;
}
static DEVICE_ATTR(version, 0777, firmware_version_show, firmware_version_store);

static ssize_t firmware_data_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
	return FwDataCnt;
}

static ssize_t firmware_data_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
	pr_ch("***FwDataCnt = %d ***\n", FwDataCnt);
	if (download_firmware_buf == NULL) {
		download_firmware_buf = kzalloc(DOWNLOAD_FIRMWARE_BUF_SIZE, GFP_KERNEL);
		if (download_firmware_buf == NULL)
			return NULL;
	}
	if(FwDataCnt<59)
	{
		memcpy(&download_firmware_buf[FwDataCnt*1024], buf, 1024);
	}
	FwDataCnt++;
	return size;
}
static DEVICE_ATTR(data, 0777, firmware_data_show, firmware_data_store);
#endif

#ifdef TP_PROXIMITY_SENSOR
static ssize_t show_proximity_sensor(struct device *dev, struct device_attribute *attr, char *buf)
{
	static char temp=2;
	buf = ps_data_state;
	if(temp!=*buf)
	{
		printk("proximity_sensor_show: buf=%d\n\n", *buf);
		temp=*buf;
	}    return 1;
}

static ssize_t store_proximity_sensor(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
	U8 ps_store_data[4];

	if(buf != NULL && size != 0)
	{
		if(DISABLE_CTP_PS == *buf)
		{
			printk("DISABLE_CTP_PS buf=%d,size=%d\n", *buf, size);
			ps_store_data[0] = 0x52;
			ps_store_data[1] = 0x00;
			ps_store_data[2] = 0x62;
			ps_store_data[3] = 0xa1;
			i2c_write(TOUCH_ADDR_MSG21XX, &ps_store_data[0], 4);
			msleep(2000);
			printk("RESET_CTP_PS buf=%d\n", *buf);
			mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
			mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
			mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
			mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ZERO);
			msleep(100);
			mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
			mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
			mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ONE);
			mdelay(500);
			mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
		}
		else if(ENABLE_CTP_PS == *buf)
		{
			printk("ENABLE_CTP_PS buf=%d,size=%d\n", *buf, size);
			ps_store_data[0] = 0x52;
			ps_store_data[1] = 0x00;
			ps_store_data[2] = 0x62;
			ps_store_data[3] = 0xa0;
			i2c_write(TOUCH_ADDR_MSG21XX, &ps_store_data[0], 4);
		}
	}

	return size;
}
static DEVICE_ATTR(proximity_sensor, 0777, show_proximity_sensor, store_proximity_sensor);
#endif

static struct i2c_driver tpd_i2c_driver =
{
	.driver = {
        .name = "msg2133",
		.owner = THIS_MODULE,
	},
	.probe = tpd_probe,
	.remove = __devexit_p(tpd_remove),
	.id_table = tpd_id,
	.detect = tpd_detect,
	.address_data = &addr_data,
};


static void tpd_down(int x, int y, int p)
{
	input_report_abs(tpd->dev, ABS_PRESSURE, p);
	input_report_key(tpd->dev, BTN_TOUCH, 1);
	input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, p);
	input_report_abs(tpd->dev, ABS_MT_POSITION_X, x);
	input_report_abs(tpd->dev, ABS_MT_POSITION_Y, y);
	printk("[MSG2133]######tpd_down[%4d %4d %4d] ", x, y, p);
	input_mt_sync(tpd->dev);
	TPD_DOWN_DEBUG_TRACK(x,y);
}

static  int tpd_up(int x, int y)
{
	#ifdef TPD_HAVE_BUTTON
	if (y > TPD_BUTTON_HEIGHT)
	{
		tpd_button(x, y,0);
		return;
	}
	#endif
	input_mt_sync(tpd->dev);
	input_sync(tpd->dev);
	TPD_DOWN_DEBUG_TRACK(x, y);
	return 1;
}
unsigned char tpd_check_sum(unsigned char *pval)
{
	int i, sum = 0;

	for(i = 0; i < 7; i++)
	{
		sum += pval[i];
	}

	return (unsigned char)((-sum) & 0xFF);
}

static bool msg2133_i2c_read(char *pbt_buf, int dw_lenth)
{
	int ret;
	i2c_client->timing = 100;
	i2c_client->addr|=I2C_ENEXT_FLAG;
	ret = i2c_master_recv(i2c_client, pbt_buf, dw_lenth);

	if(ret <= 0)
	{
		pr_tp("msg_i2c_read_interface error\n");
		return false;
	}

	return true;
}

static int i2c_master_recv_ext(struct i2c_client *client, char *buf ,int count)
{
    u32 phyAddr = 0; 
    u8  buf_dma[8] = {0};
    u32 old_addr = 0; 
    int ret = 0; 
    int retry = 3; 
    int i = 0; 
   // u8  *buf_test ;
//	buf_test = &buf_dma[0];

    old_addr = client->addr; 
    client->addr |= I2C_ENEXT_FLAG ;
	
	printk("[MSG2133][i2c_master_recv_ext] client->addr = %x\n", client->addr); 

    do {
        ret = i2c_master_recv(client, buf_dma, count);   
        retry --; 
        if (ret != count) {
            printk("[MSG2133][i2c_master_recv_ext] Error sent I2C ret = %d\n", ret); 
        }
    }while ((ret != count) && (retry > 0)); 
    
    memcpy(buf, buf_dma, count); 
	
    client->addr = old_addr; 

    return ret; 
}

static int tpd_touchinfo(struct TouchInfoT *cinfo, struct TouchInfoT *pinfo)
{
	u32 retval;
    u8 key;
    u8 touchData = 0;
	
	//pinfo->count = cinfo->count;
    memcpy(pinfo, cinfo, sizeof(struct TouchInfoT));
    
    //add for sure addr correct
    //i2c_client->addr = 0x4c;
    retval = i2c_master_recv_ext(i2c_client, (u8 *)&TpdTouchData, sizeof(TpdTouchData));

	if(TpdTouchData.packet_id != 0x52 )
       {
		return 0;
       }
	/*touch*/
	if(TpdTouchData.packet_id == 0x52)
	{
	
		if(TpdTouchData.x_h_y_h == 0xFF 
			&& TpdTouchData.x_l == 0xFF 
			&& TpdTouchData.y_l == 0xFF 
			&& TpdTouchData.disx_h_disy_h == 0xFF 
          )
        {
#ifdef TPD_HAVE_BUTTON
		 {
			U8 *p = &TpdTouchData;
			cinfo->key_value = 0;
			cinfo->key_value = *(p+5);			
			printk("+++++++zym+++++++TPD_HAVE_BUTTON:(%d)\n",cinfo->key_value);
			{
				//tpd_button_msg213x(cinfo->key_value);
				//tpd_button(0,0,cinfo->key_value);
				if(cinfo->key_value == 1)
				{
#ifdef HQ_A25_NANBO_CTP_MSG2133_KEY
                             touchData = KEY_BACK;  
#else  
                             touchData = KEY_MENU;
#endif
				}
				else if(cinfo->key_value == 2)
				{
#ifdef HQ_CTP_MSG21XX_REVERT
					touchData = KEY_BACK;
#elif defined(HQ_A25_NANBO_CTP_MSG2133_KEY)
                                        touchData = KEY_MENU;
#elif defined(HQ_A25P_MUDONG_CTP_MSG2133_KEY)
                                         touchData = KEY_BACK;
#else
					touchData = KEY_HOME;
#endif
				}
				else if(cinfo->key_value == 4)
				{
					touchData = KEY_BACK;
				}
				else if(cinfo->key_value == 8)
				{
					touchData = KEY_SEARCH;
				}
				else
				{
					touchData = 0;
				}
				TPD_LOGV("[MSG2133]+++++++zym+++++++:(%d)\n",touchData);
				if(touchData)
					input_report_key(tpd->dev,touchData,1);
				else
				{
					input_report_key(tpd->dev,KEY_MENU,0);
					input_report_key(tpd->dev,KEY_HOME,0);
					input_report_key(tpd->dev,KEY_BACK,0);
					input_report_key(tpd->dev,KEY_SEARCH,0);
				}
			}
		 }
#endif
			cinfo->count = 0;
        }
		else if(TpdTouchData.disx_h_disy_h == 0
			&& TpdTouchData.disx_l == 0 
			&& TpdTouchData.disy_l == 0)
			cinfo->count = 1;
		else
			cinfo->count = 2;
		
		TPD_LOGV("[MSG2133]cinfo: count=%d\n",cinfo->count);
		if(cinfo->count > 0)
		{
			int tmp_x,tmp_y;
			/*point1*/
			cinfo->x1 = (((TpdTouchData.x_h_y_h&0xF0)<<4) | (TpdTouchData.x_l));
			cinfo->y1 = (((TpdTouchData.x_h_y_h&0x0F)<<8) | (TpdTouchData.y_l));
			TPD_LOGV("[MSG2133]+++zym+++(%3d,%3d)\n",cinfo->x1,cinfo->y1);

			if(cinfo->count >1)
			{	
				/*point2*/
				short disx,disy;
	
				disx = (((TpdTouchData.disx_h_disy_h&0xF0)<<4) | (TpdTouchData.disx_l));
				disy = (((TpdTouchData.disx_h_disy_h&0x0F)<<8) | (TpdTouchData.disy_l));
				disy = (disy<<4);
				disy = disy/16;
				if(disx >= 2048)
					disx -= 4096;
				if(disy >= 2048)
					disy -= 4096;
				cinfo->x2 = cinfo->x1 + disx;
				cinfo->y2 = cinfo->y1 + disy;				

				tmp_x = cinfo->x2;
				tmp_y = cinfo->y2;
				cinfo->y2 = tmp_x * (TPD_RES_Y - 1)/ 2047;
				cinfo->x2 = tmp_y * (TPD_RES_X - 1) / 2047;		
			}
			tmp_x = cinfo->x1;
			tmp_y = cinfo->y1;
			cinfo->y1 = tmp_x * (TPD_RES_Y - 1) / 2047;
			cinfo->x1 = tmp_y * (TPD_RES_X - 1) / 2047;
			
			//add by zym 2012-04-16
			#ifdef HQ_CTP_MSG21XX_REVERT
			#else
			cinfo->x1 = TPD_RES_X -1 - cinfo->x1;
			cinfo->x2 = TPD_RES_X - 1 -cinfo->x2;
			#endif
			TPD_LOGV("[MSG2133]++++++++zym+++++++++p1: (%3d,%3d)(%3d,%3d)\n",cinfo->x1,cinfo->y1,TPD_RES_X,TPD_RES_Y);
	        cinfo->pressure = 1;
	        TPD_LOGV("[MSG2133]pressure: %d\n",cinfo->pressure);
		}
	}
	else
	{
		cinfo->count = 0;
	}

    /*ergate-012 start*/
    /*ergate-012 end*/

	return 1;
}



static int touch_event_handler(void *unused)
{

	int pending = 0;
	struct TouchInfoT cinfo, pinfo;
	struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
	sched_setscheduler(current, SCHED_RR, ¶m);

    memset(&cinfo, 0, sizeof(struct TouchInfoT));
    memset(&pinfo, 0, sizeof(struct TouchInfoT));
	do
	{
	
		set_current_state(TASK_INTERRUPTIBLE); 
		if(!kthread_should_stop())
		{
			TPD_DEBUG_CHECK_NO_RESPONSE;
			do
			{
				if (pending) 
					wait_event_interruptible_timeout(waiter, tpd_flag != 0, HZ/10);
				else 
					wait_event_interruptible_timeout(waiter,tpd_flag != 0, HZ*2);
				 
			}while(0);
			 
			if (tpd_flag == 0 && !pending) 
				continue; // if timeout for no touch, then re-wait.
			 
			if (tpd_flag != 0 && pending > 0)	
				pending = 0;
			 
			tpd_flag = 0;
			TPD_DEBUG_SET_TIME; 
		}
		set_current_state(TASK_RUNNING);

		if (tpd_touchinfo(&cinfo, &pinfo))
		{
			if(cinfo.count >0)
			{
				tpd_down(cinfo.x1, cinfo.y1, cinfo.pressure);
				if(cinfo.count>1)
             	{            	
					tpd_down(cinfo.x2, cinfo.y2, cinfo.pressure);
				}
				input_sync(tpd->dev);		
				TPD_LOGV("[MSG2133]press  --->\n");
			}
			else if(cinfo.count==0 && pinfo.count!=0)
			{		
     
			    input_mt_sync(tpd->dev);
			    input_sync(tpd->dev);
		
				TPD_LOGV("[MSG2133]release --->\n"); 
			}
		}		   
	}while(!kthread_should_stop());

	return 0;

}

static int tpd_detect(struct i2c_client *client, int kind, struct i2c_board_info *info)
{
	strcpy(info->type, "msg2133");
	return 0;
}

static void tpd_eint_interrupt_handler(void)
{
	tpd_flag = 1;
	wake_up_interruptible(&waiter);
}

static int __devinit tpd_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int retval = TPD_OK;
	client->timing = 100;
	i2c_client = client;
	msleep(10);
	hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");
	mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ONE);

    msleep(100);
	mt_set_gpio_mode(GPIO_CTP_MSG2133_EINT_PIN, GPIO_CTP_MSG2133_EINT_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EINT_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_CTP_MSG2133_EINT_PIN, GPIO_PULL_ENABLE);
	mt_set_gpio_pull_select(GPIO_CTP_MSG2133_EINT_PIN, GPIO_PULL_UP);


	mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
	mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
	mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);
	mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
	msleep(100);
	tpd_load_status = 1;
	mthread = kthread_run(touch_event_handler, 0, "msg2133");

	if(IS_ERR(mthread))
	{
		retval = PTR_ERR(mthread);
		pr_tp(TPD_DEVICE " failed to create kernel thread: %d\n", retval);
	}
#ifdef TP_FIRMWARE_UPDATE
#if ENABLE_DMA
	gpDMABuf_va = (u8 *)dma_alloc_coherent(NULL, 4096, &gpDMABuf_pa, GFP_KERNEL);

	if(!gpDMABuf_va)
	{
		printk("[MATV][Error] Allocate DMA I2C Buffer failed!\n");
	}

#endif
    firmware_class = class_create(THIS_MODULE, "ms-touchscreen-msg20xx");

	if(IS_ERR(firmware_class))
	{
		pr_err("Failed to create class(firmware)!\n");
	}

	firmware_cmd_dev = device_create(firmware_class,NULL, 0, NULL, "device");

	if(IS_ERR(firmware_cmd_dev))
	{
		pr_err("Failed to create device(firmware_cmd_dev)!\n");
	}

	// version
	if(device_create_file(firmware_cmd_dev, &dev_attr_version) < 0)
	{
		pr_err("Failed to create device file(%s)!\n", dev_attr_version.attr.name);
	}

	// update
	if(device_create_file(firmware_cmd_dev, &dev_attr_update) < 0)
	{
		pr_err("Failed to create device file(%s)!\n", dev_attr_update.attr.name);
	}

	// data
	if(device_create_file(firmware_cmd_dev, &dev_attr_data) < 0)
	{
		pr_err("Failed to create device file(%s)!\n", dev_attr_data.attr.name);
	}

	if(device_create_file(firmware_cmd_dev, &dev_attr_clear) < 0)
	{
		pr_err("Failed to create device file(%s)!\n", dev_attr_clear.attr.name);
	}

#endif
#ifdef TP_PROXIMITY_SENSOR

	if(device_create_file(firmware_cmd_dev, &dev_attr_proximity_sensor) < 0) // /sys/class/mtk-tpd/device/proximity_sensor
	{
		pr_err("Failed to create device file(%s)!\n", dev_attr_proximity_sensor.attr.name);
	}
#endif
	printk("Touch Panel Device Probe %s\n", (retval < TPD_OK) ? "FAIL" : "PASS");
	return 0;
}

static int __devexit tpd_remove(struct i2c_client *client)

{
	printk("TPD removed\n");
#ifdef TP_FIRMWARE_UPDATE
#if ENABLE_DMA

	if(gpDMABuf_va)
	{
		dma_free_coherent(NULL, 4096, gpDMABuf_va, gpDMABuf_pa);
		gpDMABuf_va = NULL;
		gpDMABuf_pa = NULL;
	}

#endif
#endif
	return 0;
}


static int tpd_local_init(void)
{
	printk(" MSG2133 I2C Touchscreen Driver (Built %s @ %s)\n", __DATE__, __TIME__);

	if(i2c_add_driver(&tpd_i2c_driver) != 0)
	{
		printk("unable to add i2c driver.\n");
		return -1;
	}

#ifdef TPD_HAVE_BUTTON
	tpd_button_setting(TPD_KEY_COUNT, tpd_keys_local, tpd_keys_dim_local);// initialize tpd button data
#endif
	pr_tp("end %s, %d\n", __FUNCTION__, __LINE__);
	tpd_type_cap = 1;
	return 0;
}

static int tpd_resume(struct i2c_client *client)
{
	int retval = TPD_OK;
	printk("TPD wake up\n");

	 hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");
	 msleep(10);
	mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
	mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
	mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ONE);

	msleep(200);
	mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
	mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 1);

	return retval;
}

static int tpd_suspend(struct i2c_client *client, pm_message_t message)
{
	int retval = TPD_OK;
	static char data = 0x3;
	printk("TPD enter sleep\n");

	{
		mt65xx_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
		mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, NULL, 1);


		mt_set_gpio_mode(GPIO_CTP_MSG2133_EN_PIN, GPIO_CTP_MSG2133_EN_PIN_M_GPIO);
		mt_set_gpio_dir(GPIO_CTP_MSG2133_EN_PIN, GPIO_DIR_OUT);
		mt_set_gpio_out(GPIO_CTP_MSG2133_EN_PIN, GPIO_OUT_ZERO);
	
		hwPowerDown(MT65XX_POWER_LDO_VGP2, "TP");
	
	}
	return retval;
}

int tpd_power_switch( int flag )
{
	return 0;
}

EXPORT_SYMBOL( tpd_power_switch );

static struct tpd_driver_t tpd_device_driver =
{
	.tpd_device_name = "msg2133",
	.tpd_local_init = tpd_local_init,
	.suspend = tpd_suspend,
	.resume = tpd_resume,
#ifdef TPD_HAVE_BUTTON
	.tpd_have_button = 1,
#else
	.tpd_have_button = 0,
#endif
};
/* called when loaded into kernel */
static int __init tpd_driver_init(void)
{
	printk("MediaTek MSG2133 touch panel driver init\n");
	if(tpd_driver_add(&tpd_device_driver) < 0)
	{
		printk("add MSG2133 driver failed\n");
	}

	return 0;
}

/* should never be called */
static void __exit tpd_driver_exit(void)
{
	printk("MediaTek MSG2133 touch panel driver exit\n");
	//input_unregister_device(tpd->dev);
	tpd_driver_remove(&tpd_device_driver);
}

module_init(tpd_driver_init);
module_exit(tpd_driver_exit);

Tpd_custom_msg2133.h:

#ifndef TOUCHPANEL_H
#define TOUCHPANEL_H

#define TPD_RES_X                320
#define TPD_RES_Y                480

#define TPD_HAVE_BUTTON


#define TPD_BUTTON_HEIGHT	480
#define TPD_KEY_COUNT           3
#define TPD_KEYS                {KEY_MENU, KEY_HOME, KEY_BACK}
#define TPD_KEYS_DIM            {{40,505,80,50},{120,505,80,50},{200,505,80,50}}

#endif