/drivers/input/touchscreen/ntrig.c

Large files files are truncated, but you can click here to view the full file

/* drivers/input/touchscreen/ntrig.c - NTRIG G3.5 Touch driver
 *
 * Copyright (C) 2010-2011 HTC Corporation.
 *
 * 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.
 *
 */

#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/earlysuspend.h>
#include <mach/vreg.h>
#include <asm/mach-types.h>
#include <linux/ntrig.h>
#include <linux/ntrig_fw.h>
#include <linux/spi/spi.h>
#include <linux/stat.h>
#include <linux/earlysuspend.h>
#include <asm/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/workqueue.h>
#include <linux/hrtimer.h>
#include <linux/mutex.h>
#include <linux/wait.h>
#include <linux/sched.h>

#if 0
#define SPIBUF(buf) do { \
	int q; \
	for (q = 0; q < 8; q++) \
		pr_info("[ts]%.2x %.2x %.2x %.2x\\%.2x %.2x %.2x %.2x\\%.2x %.2x %.2x %.2x\\%.2x %.2x %.2x %.2x\\%.2x",\
			buf[0+17*q],  buf[1+17*q], buf[2+17*q],  buf[3+17*q],  buf[4+17*q],  buf[5+17*q],  buf[6+17*q], \
			buf[7+17*q],  buf[8+17*q], buf[9+17*q], buf[10+17*q], buf[11+17*q], buf[12+17*q], buf[13+17*q], \
			buf[14+17*q], buf[15+17*q], buf[16+17*q]); } while (0)
#endif
#define SPIBUF(buf) {}

#define ESDSEQ	3000
#define POWERONSEQ 320
#define ESDEXECUTE 25000
#define USBDISABLE_DELAY 20000
#define ABS_MT_TRACKING_ID_MAX 10

static bool aLive, fUsboff, fPalmRej;
static bool fTSLogFlag = false;
static short CalState;

char spiAnalyRx[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];

static const char NTRIGNAME[] = "Ntrig";
static short anpidx;
static int TSLog, count_isr_from_resume, cResetESD, gFingerMap[ABS_MT_TRACKING_ID_MAX];
static int event_google_enable = 1;
u32 g_lastcht = 0, g_missRep = 0;
static uint32_t ntg_fwver;

static DEFINE_MUTEX(ntg_spi_transfer_lock);

#ifdef COUNTER_DEBUG
unsigned char byte_muti_tp[MTM_REPORT_SIZE+1+4] = {0};
#else
unsigned char byte_muti_tp[MTM_REPORT_SIZE+1] = {0};
#endif

struct ntg_tsData {
	struct input_dev 	*input_dev;
	struct input_dev	*input_devP;
	struct spi_device 	*spiDev;
	struct workqueue_struct *ntg_wq;
	struct work_struct 	ntg_work;
	struct ntg_touch_event *touchEvnt;
	uint16_t  abs_x_min;
	uint16_t  abs_x_max;
	uint16_t  abs_y_min;
	uint16_t  abs_y_max;
	uint16_t  fwtwozero;
	uint8_t orientate;
	uint8_t abs_pressure_min;
	uint8_t abs_pressure_max;
	uint8_t abs_width_min;
	uint8_t abs_width_max;
	int spi_enable;
	int irq_gpio;
	int	(*power)(int on);
	bool esdFlag;
	wait_queue_head_t get_data_wq;
	wait_queue_head_t send_data_wq;
	int get_data;
	int send_lib;
	atomic_t data_ok_agent;
	atomic_t info_send_agent;
	atomic_t start_agent;
	struct early_suspend early_suspend;
	struct workqueue_struct *ntg_wq_esd;
	struct delayed_work ntg_work_esd;
	struct workqueue_struct *ntg_wq_usb_disable;
	struct delayed_work ntg_work_usb_disable;
	struct workqueue_struct *ntg_wq_resume;
	struct delayed_work ntg_work_resume;
};
static struct ntg_tsData *private_ts;

struct ntg_AnalyData {
	unsigned short fn;
	unsigned short han;
	unsigned short van;
	unsigned short fnId;
	unsigned short phyfrq;
	unsigned char *map;
	struct ntg_AnaPen pen;
};
static struct ntg_AnalyData *mapData;

static int ntg_spi_transfer(struct ntg_tsData *, char *);

#ifdef CONFIG_HAS_EARLYSUSPEND
static void ntrig_ts_early_suspend(struct early_suspend *h);
static void ntrig_ts_late_resume(struct early_suspend *h);
#endif
extern int board_mfg_mode(void);
static char data_agent[DEBUG_ANGENT_ALL_REPORT_SIZE];
struct ntg_debug_agent_uart g_data_uart;
static DECLARE_WAIT_QUEUE_HEAD(data_ready_agent_wq);
static DECLARE_WAIT_QUEUE_HEAD(data_send_agent_wq);

static ssize_t spiDuplex_Lock(struct spi_device *dev, char *txbuf,
			      char *rxbuf, size_t len)
{
	struct spi_msg msg;
	int err = 0;
	if (!dev)
		return 0;
	msg.data = (u8 *)txbuf;

	if (TSLog & Dbg_L9) {
		pr_info("[ts]Txbuf\n");
		SPIBUF(txbuf);
	}
	err = spi_read_write_lock(dev, &msg, rxbuf, len, 2);
        if (err < 0)
          printk(KERN_ERR "%s: failed (error %d)\n", __func__, err);
	return err;
}

static int ntg_checksumCal(unsigned char *PacketData, u16 PackLen)
{
	int sum = 0, i;
	for (i = 0; i < PackLen; i++)
		sum += PacketData[i];

	sum = 0 - sum;
	return sum;
}

static void ntg_usb_powoff(struct ntg_tsData *ntg)
{
	short i;
	char spiUsbTx[NTRIG_PACKET_SIZE];

	for (i = 0; i < 4 && fUsboff == false; i++) {
		pr_info("[tp]usb_powoff (%d)\n", i+1);
		memset(spiUsbTx, 0xAA, NTRIG_PACKET_SIZE);
		memcpy(spiUsbTx, ntgFW_usbDis, sizeof(ntgFW_usbDis));
		ntg_spi_transfer(ntg, spiUsbTx);
		msleep(150);
	}
}

static void ntg_palmRejOff(struct ntg_tsData *ntg)
{
	short i;
	char spiPalmTx[NTRIG_PACKET_SIZE];

	memset(spiPalmTx, 0xAA, NTRIG_PACKET_SIZE);

	if ((uint16_t)ntg_fwver >= ntg->fwtwozero) {
		memcpy(spiPalmTx, ntgFW_palmrejoff2, sizeof(ntgFW_palmrejoff2));
	} else {
		memcpy(spiPalmTx, ntgFW_palmrejoff, sizeof(ntgFW_palmrejoff));
	}
	for (i = 0; i < 4 && fPalmRej == false; i++) {
		pr_info("[tp]palm_rejoff (%d)\n", i+1);
		ntg_spi_transfer(ntg, spiPalmTx);
		msleep(150);
	}
}

static void ntg_usb_disable_mechanism(struct work_struct *work)
{
	struct ntg_tsData *ntg;
	ntg = container_of(work, struct ntg_tsData, ntg_work_usb_disable.work);
	pr_info("[tp]%s: enter\n", __func__);
	ntg_usb_powoff(ntg);
	ntg_palmRejOff(ntg);
}

static void ntg_alive_mechanism(struct work_struct *work)
{
	short i;
	struct ntg_tsData *ntg;
	char spiTxEbuf[NTRIG_PACKET_SIZE];
	ntg = container_of(work, struct ntg_tsData, ntg_work_esd.work);
	memset(spiTxEbuf, 0xAA, NTRIG_PACKET_SIZE);
	for (i = 0; i < 3; i++) {
		memcpy(spiTxEbuf, &ntgFW_getfw, sizeof(ntgFW_getfw));
		ntg_spi_transfer(ntg, spiTxEbuf);

		msleep(50*(i+1));
		if (TSLog & (Dbg_L9 | Dbg_L2))
			pr_err("[E-ts(%d)] AlIVE=%d\n", i, aLive);

		if (aLive) {
			cResetESD = 0;
			if (!fTSLogFlag)
				TSLog = 0;
			break;
		}
	}

	if (!aLive) {
		cResetESD++;
		if ((!fTSLogFlag) && (cResetESD == 3))
                  TSLog = 0;

		if ((cResetESD == 13) && (!fTSLogFlag))
			TSLog = 0;

		fUsboff = false;
		fPalmRej = false;
		pr_err("[ts]ESD reset\n");
		disable_irq(ntg->spiDev->irq);
		ntg->power(0);
		msleep(15);
		ntg->power(1);
		msleep(350);
		gpio_set_value(ntg->spi_enable, 1);
		enable_irq(ntg->spiDev->irq);
		ntg_usb_powoff(ntg);
		ntg_palmRejOff(ntg);
	}
	aLive = false;
	queue_delayed_work(ntg->ntg_wq_esd, &ntg->ntg_work_esd, msecs_to_jiffies(ESDSEQ));
}

static bool analy_init(void)
{
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

	pr_info("[ts]%s\n", __func__);
	if (mapData == NULL || (mapData->fn == 0))
		mapData = kzalloc(sizeof(struct ntg_AnalyData), GFP_KERNEL);
	else
		pr_info("[ts]Already allocate mapData!!\n");

	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	ntgFW_map[9] = 0x17;
	ntgFW_map[17] = 0x0F;
	ntgFW_map[21] = ANA_SEN_CONF;
	ntgFW_map[sizeof(ntgFW_map)-3] = ntg_checksumCal(&ntgFW_map[14], 14);
	memcpy(spiTxbuf, ntgFW_map, sizeof(ntgFW_map)-2);

	spiDuplex_Lock(ts->spiDev, spiTxbuf, spiRxbuf, NTRIG_PACKET_SIZE);

	msleep(500);

	if (mapData->map == NULL)
		mapData->map = kzalloc(mapData->han*mapData->van*sizeof(unsigned char *), GFP_KERNEL);

	pr_info("[ts_anaConf]Fn=%d, HAN=%d, VAN=%d\n", mapData->fn,  mapData->han, mapData->van);
	return true;
}

static bool analy_opfreq(void)
{
	int err;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	if (mapData == NULL)
		mapData = kzalloc(sizeof(struct ntg_AnalyData), GFP_KERNEL);
	else if (mapData != NULL)
		pr_info("[ts_ana]Already allocat mapData!!\n");

	pr_info("[ts]%s\n", __func__);

	ntgFW_setting[21] = CMD_OPERATE_FREQ;
	ntgFW_setting[sizeof(ntgFW_setting)-1] = ntg_checksumCal(&ntgFW_setting[14], 14);
	memcpy(spiTxbuf, ntgFW_setting, sizeof(ntgFW_setting));

	mapData->fnId = 0;
	mapData->phyfrq = 0;

	err = spiDuplex_Lock(ts->spiDev , spiTxbuf, spiRxbuf,
			     sizeof(char)*NTRIG_PACKET_SIZE);
	msleep(500);
	pr_info("[ts_ana]FreqID=%d, Freq=%d\n", mapData->fnId, mapData->phyfrq*10);
	return true;
}

static bool analy_base(short map)
{
	short i;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

	if (mapData == NULL) {
		pr_info("[ts_ana]Execute cat anaConf First!!\n");
		return false;
	}
	anpidx = 0;
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);
	ntgFW_map[9] = 0x1F;
	ntgFW_map[17] = 0x11;
	ntgFW_map[21] = ANA_GET_BASEMAP;

	switch (map) {
	case 1:
		ntgFW_map[28] = 1;
		memset((char *)mapData->map, mapData->han * mapData->van, 0);
		break;
	case 2:
		ntgFW_map[28] = 2;
		memset((char *)mapData->map, mapData->han * mapData->van, 0);
		break;
	case 3:
		ntgFW_map[28] = 3;
		memset((char *)mapData->map, mapData->han * mapData->van, 0);
		break;
	case 4:
		ntgFW_map[28] = 4;
		memset((char *)mapData->map, mapData->han * mapData->van, 0);
		break;
	}
	for (i = 1; i <= mapData->han; i++) {
		ntgFW_map[29] = i;
		ntgFW_map[sizeof(ntgFW_map)-1] = ntg_checksumCal(&ntgFW_map[14], 16);

		memcpy(spiTxbuf, ntgFW_map , sizeof(ntgFW_map));
		spiDuplex_Lock(ts->spiDev, spiTxbuf, spiRxbuf, NTRIG_PACKET_SIZE);
		msleep(30);
	}

	if (anpidx != mapData->han) {
		 pr_info("[ts_ana]Base map(%d) Reply channel Error!!\n", map);
		 return false;
	} else
		pr_info("[ts_ana]Base map(%d) OK\n", map);
	return true;
}

static bool analy_active(void)
{
	short i;

	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	if (mapData == NULL) {
		pr_info("[ts_ana]Execute cat anaConf First!!\n");
		return false;
	}
	pr_info("[ts]%s\n", __func__);
	anpidx = 0;
	ntgFW_map[9] = 0x1E;
	ntgFW_map[17] = 0x10;
	ntgFW_map[21] = ANA_GET_ACTMAP;
	memset((char *)mapData->map, mapData->han * mapData->van, 0);

	for (i = 1; i <= mapData->han; i++) {
		ntgFW_map[28] = i;
		ntgFW_map[sizeof(ntgFW_map)-2] = ntg_checksumCal(&ntgFW_map[14], 15);

		memcpy(spiTxbuf, ntgFW_map , sizeof(ntgFW_map)-1);
		spiDuplex_Lock(ts->spiDev, spiTxbuf, spiRxbuf, NTRIG_PACKET_SIZE);
		msleep(30);
	}
	if (anpidx != mapData->han) {
		 pr_info("[ts_ana]Reply channel Error!!\n");
		 return false;
	} else
		pr_info("[ts_ana]Actmap OK\n");

	return true;
}

static bool analy_finger(void)
{
	short i;

	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	if (mapData == NULL) {
		pr_info("[ts_ana]Execute cat anaConf First!!\n");
		return false;
	}
	pr_info("[ts]%s\n", __func__);
	anpidx = 0;
	ntgFW_map[9] = 0x1E;
	ntgFW_map[17] = 0x10;
	ntgFW_map[21] = ANA_GET_FINMAP;
	memset((char *)mapData->map, mapData->han * mapData->van, 0);

	for (i = 1; i <= mapData->han; i++) {
		ntgFW_map[28] = i;
		ntgFW_map[sizeof(ntgFW_map)-2] = ntg_checksumCal(&ntgFW_map[14], 15);

		memcpy(spiTxbuf, ntgFW_map , sizeof(ntgFW_map)-1);
		spiDuplex_Lock(ts->spiDev, spiTxbuf, spiRxbuf, NTRIG_PACKET_SIZE);
		msleep(30);
	}
	if (anpidx != mapData->han) {
		pr_info("[ts_ana]Reply channel Error!!\n");
		return false;
	} else
		pr_info("[ts_ana]Finger Map OK\n");
	return true;
}

static bool analy_pen(void)
{
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	if (mapData == NULL) {
		pr_info("[ts_ana]Execute cat anaConf First!!\n");
		return false;
	}
	pr_info("[ts]%s\n", __func__);

	ntgFW_map[9] = 0x1D;
	ntgFW_map[17] = 0x0F;
	ntgFW_map[21] = ANA_GET_PEN;
	ntgFW_map[sizeof(ntgFW_map)-3] = ntg_checksumCal(&ntgFW_map[14], 14);
	memcpy(spiTxbuf, ntgFW_map, sizeof(ntgFW_map)-2);

	spiDuplex_Lock(ts->spiDev, spiTxbuf, spiRxbuf, NTRIG_PACKET_SIZE);
	memset(&mapData->pen, 0, sizeof(struct ntg_AnaPen));
	msleep(500);

	pr_info("[ts_ana]PenState:%d,Th:%d,Mag:%d,Pressure:%d,X:%d,Y:%d,Btn:%d\n",
		mapData->pen.pState, mapData->pen.pTh, mapData->pen.mag,
		mapData->pen.pPress, mapData->pen.posX, mapData->pen.posY,
		mapData->pen.pBtn);
	return true;
}

static long ntrig_analy_ioctl(struct file *file, unsigned int cmd,
			     unsigned long arg)
{
	char buf[100];
	int err = 0;
        long ret = 0;
	unsigned long size = 0;
	void __user *argp = (void __user *)arg;
	if (_IOC_TYPE(cmd) != ANALY_IOC_MAGIC)
		return -ENOTTY;
	if (_IOC_NR(cmd) > ANALY_MAXNR)
		return -ENOTTY;

	if (_IOC_DIR(cmd) & _IOC_READ)
		err = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));
	else if (_IOC_DIR(cmd) & _IOC_WRITE)
		err = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));

	if (err)
		return -EFAULT;
	memset(buf, 0, 100);

	switch (cmd) {
	case ANALY_INIT:
		if (analy_init()) {
			sprintf(buf, "Fn=%d, HAN=%d, VAN=%d\n",
				     mapData->fn,  mapData->han, mapData->van);
			size = copy_to_user(argp, &buf, sizeof(buf));
		}
		break;
	case ANALY_BASE1:
		if (analy_base(1))
			size = copy_to_user(argp, mapData->map, mapData->han*mapData->van);
		break;
	case ANALY_BASE2:
		if (analy_base(2))
			size = copy_to_user(argp, mapData->map, mapData->han*mapData->van);
		break;
	case ANALY_BASE3:
		if (analy_base(3))
			size = copy_to_user(argp, mapData->map, mapData->han*mapData->van);
		break;
	case ANALY_BASE4:
		if (analy_base(4))
			size = copy_to_user(argp, mapData->map, mapData->han*mapData->van);
		break;
	case ANALY_OPFREQ:
		if (analy_opfreq()) {
			sprintf(buf, "FreqID=%d, Freq=%d\n", mapData->fnId, mapData->phyfrq*10);
			size = copy_to_user(argp, &buf, sizeof(buf));
		}
		break;
	case ANALY_ACTIVE:
		if (analy_active())
			size = copy_to_user(argp, mapData->map, mapData->han*mapData->van);
		break;
	case ANALY_FINGER:
		if (analy_finger())
			size = copy_to_user(argp, mapData->map, mapData->han*mapData->van);
		break;
	case ANALY_PEN:
		if (analy_pen()) {
			sprintf(buf + ret, "PenState:%d,Th:%d,Mag:%d,Pressure:%d,X:%d,Y:%d,Btn:%d\n",
					   mapData->pen.pState, mapData->pen.pTh, mapData->pen.mag,
					   mapData->pen.pPress, mapData->pen.posX, mapData->pen.posY,
					   mapData->pen.pBtn);
			size = copy_to_user(argp, &buf, sizeof(buf));
		}
		break;
	}
	if (size)
		pr_info("[ts]analysis ioctl copy_to_user Error (%ld)", size);

	return 0;
}


static int ntrig_analy_open(struct inode *inode, struct file *file)
{
	return nonseekable_open(inode, file);
}
static int ntrig_analy_release(struct inode *inode, struct file *file)
{
	return 0;
}

static struct file_operations ntrig_analy_fops = {
	.owner = THIS_MODULE,
	.open = ntrig_analy_open,
	.release = ntrig_analy_release,
	.unlocked_ioctl = ntrig_analy_ioctl,
};

static struct miscdevice ntrig_map_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "ntrig_analysis",
	.fops = &ntrig_analy_fops,
};

static ssize_t stop_esdwq(struct device *dev, struct device_attribute *attr, char *buf)
{
	ssize_t ret;
	struct ntg_tsData *ts;

	ts = private_ts;
	if (!cancel_delayed_work_sync(&ts->ntg_work_esd)) {
		cancel_delayed_work(&ts->ntg_work_esd);
	}
	sprintf(buf, "Destory ESD delayworkqueue\n");
	ret = strlen(buf) + 1;
	return ret;
}
DEVICE_ATTR(stopesd, 0444, stop_esdwq, NULL);

static void ntg_powSeq_machanism(struct work_struct *work)
{
	struct ntg_tsData *ts;
	ts = container_of(work, struct ntg_tsData, ntg_work_resume.work);
	pr_info("[tp]%s\n", __func__);
	gpio_set_value(ts->spi_enable, 1);
	enable_irq(ts->spiDev->irq);
	ntg_usb_powoff(ts);
	ntg_palmRejOff(ts);
}

static ssize_t touch_vendor_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	ssize_t ret = 0;
	short err = 0;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];

	if (ntg_fwver) {
		sprintf(buf, "%s_%#x\n", NTRIGNAME, ntg_fwver);
		ntg_fwver = 0x00;
		ret = strlen(buf) + 1;
	} else {
		ts = private_ts;
		pr_info("[ts]%s\n", __func__);
		memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
		memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

		memcpy(spiTxbuf, ntgFW_getfw, sizeof(ntgFW_getfw));

		err = spiDuplex_Lock(ts->spiDev, spiTxbuf, spiRxbuf,
					sizeof(char)*NTRIG_PACKET_SIZE);
		msleep(1500);
		sprintf(buf, "%s_%#x\n", NTRIGNAME, ntg_fwver);
		ret = strlen(buf) + 1;
	}
	return ret;
}
DEVICE_ATTR(vendor, 0444, touch_vendor_show, NULL);

static ssize_t ts_setting(struct device  *dev, struct device_attribute *attr, char *buf)
{
	int ret, err;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	ntgFW_setting[21] = 0x08;
	ntgFW_setting[sizeof(ntgFW_setting)-1] = ntg_checksumCal(&ntgFW_setting[14], 14);
	memcpy(spiTxbuf, ntgFW_setting, sizeof(ntgFW_setting));

	err = spiDuplex_Lock(ts->spiDev , spiTxbuf, spiRxbuf,
				sizeof(char)*NTRIG_PACKET_SIZE);

	sprintf(buf, "0x00:DPSM OFF\n0x01:single\n0x02:multi\
		     \n\r0x03:Palm Rejection On\n0x04:Palm Rejection Off\
		     \n\r0x05:3D Active\n0x06:3D inactive\n0x20:Pen only\
		     \n\r0x30:NO pen, No touch\n");

	ret	= strlen(buf) + 1;
	return ret;
}

static ssize_t ts_switch(struct device *dev, struct device_attribute *attr,
						const char *buf, size_t count)
{
	int ret = 0, mode;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

	mode  = simple_strtoul(buf, NULL, 10);

	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	switch (mode) {
	case 0x00:/*DPSM off*/
		ntgFW_mode[28] = 0x02;
		ntgFW_mode[29] = 0x00;
		break;
	case 0x01:/*single*/
		ntgFW_mode[28] = 0x01;
		ntgFW_mode[29] = 0x0A;
		break;
	case 0x02:/*multi*/
		ntgFW_mode[28] = 0x02;
		ntgFW_mode[29] = 0x0A;
		break;
	case 0x03:/*Plam Rejection On*/
		ntgFW_mode[28] = 0x02;
		ntgFW_mode[29] = 0x0A;
		ntgFW_mode[31] = 0x01;
		break;
	case 0x04:/*Plam Rejection Off*/
		ntgFW_mode[28] = 0x02;
		ntgFW_mode[29] = 0x0A;
		ntgFW_mode[31] = 0x00;
		break;
	case 0x05:/*3D Active*/
		ntgFW_mode[28] = 0x02;
		ntgFW_mode[29] = 0x0A;
		ntgFW_mode[32] = 0x01;
		break;
	case 0x06:/*3D inactive*/
		ntgFW_mode[28] = 0x02;
		ntgFW_mode[29] = 0x0A;
		ntgFW_mode[32] = 0x00;
		break;
	case 0x30:/*No pen ,NO touch*/
		ntgFW_mode[28] = 0x30;
		ntgFW_mode[29] = 0x0A;
		break;
	case 0x20:/*Pen only*/
		ntgFW_mode[28] = 0x20;
		ntgFW_mode[29] = 0x0A;
		break;
	}

	if ((uint16_t)ntg_fwver >= ts->fwtwozero) {
		ntgFW_mode[sizeof(ntgFW_mode)-1] = ntg_checksumCal(&ntgFW_mode[14], 21);
		memcpy(spiTxbuf, ntgFW_mode, sizeof(ntgFW_mode));

	} else {
		ntgFW_mode[9] = 0x1A;
		ntgFW_mode[17] = 0x14;
		ntgFW_mode[sizeof(ntgFW_mode)-3] = ntg_checksumCal(&ntgFW_mode[14], 19);
		memcpy(spiTxbuf, ntgFW_mode, (sizeof(ntgFW_mode)-2));
	}

	ret = spiDuplex_Lock(ts->spiDev , spiTxbuf, spiRxbuf,
				sizeof(char)*NTRIG_PACKET_SIZE);

	ret	= strlen(buf);
	return count;
}
DEVICE_ATTR(mode, 0644, ts_setting, ts_switch);

static ssize_t ts_algget(struct device  *dev, struct device_attribute *attr, char *buf)
{
	int ret, err;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	ntgFW_setting[21] = 0x0F;
	ntgFW_setting[sizeof(ntgFW_setting)-1] = ntg_checksumCal(&ntgFW_setting[14], 14);
	memcpy(spiTxbuf, ntgFW_setting, sizeof(ntgFW_setting));

	err = spiDuplex_Lock(ts->spiDev , spiTxbuf, spiRxbuf,
				sizeof(char)*NTRIG_PACKET_SIZE);
	sprintf(buf, "[ts]Algo Control get\
			\n\r0x00:OTFC Disalbe\n\r0x01:OTFC Enable\
			\r0x10:FH auto\n\r0x11:FH mode 1\n\
			\r0x12:FH mode 2\n\r0x13:FH mode 3\n\
			\r0x14:FH mode 4\n");
	ret = strlen(buf);
	return ret;
}

static ssize_t ts_otfc(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
{
	int ret = 0, mode;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

/*        mode = simple_strtoul(buf, NULL, 10);*/
	mode = strict_strtoul(buf, 10, NULL);

	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	switch (mode) {
	case 0x01:/*OTFC Enable*/
		ntgFW_otfcmode[28] = 0x01;
		ntgFW_otfcmode[29] = 0x00;
		break;
	case 0x00:/*OTFC Disable*/
		ntgFW_otfcmode[28] = 0x00;
		ntgFW_otfcmode[29] = 0x00;
		break;
	case 0x10:/*FH auto*/
		ntgFW_otfcmode[28] = 0x01;
		ntgFW_otfcmode[29] = 0x00;
		break;
	case 0x11:/*FH 1*/
		ntgFW_otfcmode[28] = 0x01;
		ntgFW_otfcmode[29] = 0x01;
		break;
	case 0x12:/*FH 2*/
		ntgFW_otfcmode[28] = 0x01;
		ntgFW_otfcmode[29] = 0x02;
		break;
	case 0x13:/*FH 3*/
		ntgFW_otfcmode[28] = 0x01;
		ntgFW_otfcmode[29] = 0x03;
		break;
	case 0x14:/*FH 4*/
		ntgFW_otfcmode[28] = 0x01;
		ntgFW_otfcmode[29] = 0x04;
		break;
	}
	ntgFW_otfcmode[sizeof(ntgFW_otfcmode)-1] = ntg_checksumCal(&ntgFW_otfcmode[14], 24);
	memcpy(spiTxbuf, ntgFW_otfcmode, sizeof(ntgFW_otfcmode));

	ret = spiDuplex_Lock(ts->spiDev , spiTxbuf, spiRxbuf,
				sizeof(char)*NTRIG_PACKET_SIZE);
	ret = strlen(buf);
	return count;
}
DEVICE_ATTR(OTFC, 0644, ts_algget, ts_otfc);

static ssize_t ts_logen(struct device *dev, struct device_attribute *attr,
						const char *buf, size_t count)
{
	int buglevel;
	buglevel = simple_strtoul(buf, NULL, 10);
        //	if (buglevel) {
        //		TSLog = buglevel;
        //		fTSLogFlag = true;
        //	} else {
		TSLog = 0x00;
		fTSLogFlag = false;
                //	}
	pr_info("[ts]log enable  = %.2x\n", TSLog);
	return count;
}

static ssize_t show_ts_logen(struct device *dev, struct device_attribute *attr, char *buf)
{
	int ret = 0;
	ret = sprintf(buf, "log enable  = %d\n0x00:Flag for ESD log\n0x01:Rx after state machine\
			\n\r0x02:Rx Befor state machine\n0x04:For deamon partial log\
			\n\r0x08:For DA & x-y cooridate\n0x10:For all deamon log\n0x20:For ESD pulling log\
			\n\r0x40:For Deamon Raw data\n0x80:For Pen state\n0x100:For Tx buf\n", TSLog);
	ret += 1;
	return ret;
}
DEVICE_ATTR(debug_level, 0644, show_ts_logen, ts_logen);

static ssize_t set_event_google(struct device *dev, struct device_attribute *attr,
						const char *buf, size_t count)
{
	int buglevel;
	buglevel = simple_strtoul(buf, NULL, 10);
	event_google_enable = buglevel;

	pr_info("[ts]event google enable = %d\n", event_google_enable);
	return count;
}

static ssize_t show_event_google(struct device *dev, struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "event google enable = %d\n", event_google_enable);
}
DEVICE_ATTR(event_google, 0664, show_event_google, set_event_google);

static ssize_t ntg_SetCal(struct device *dev, struct device_attribute *attr, char *buf)
{
	int ret, err;
	struct ntg_tsData *ts_data;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts_data = private_ts;

	if (ts_data->esdFlag)
		cancel_delayed_work(&ts_data->ntg_work_esd);
	CalState = NTG_CALSTART;
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);

	memcpy(spiTxbuf, &ntgFW_setCal, sizeof(ntgFW_setCal));
	memset(spiRxbuf, 0, sizeof(char)*NTRIG_PACKET_SIZE);

	pr_info("[ts-SetCal]SetCal test send\n");
	err = spiDuplex_Lock(ts_data->spiDev , spiTxbuf, spiRxbuf,
								sizeof(char)*NTRIG_PACKET_SIZE);
	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	mdelay(1500);
	while (!CalState) {
		memcpy(spiTxbuf, &ntgFW_getCal, sizeof(ntgFW_getCal));
		memset(spiRxbuf, 0, sizeof(char)*NTRIG_PACKET_SIZE);
		pr_info("[ts-GetCal]Calibrating!!\n");
		err = spiDuplex_Lock(ts_data->spiDev, spiTxbuf, spiRxbuf,
							NTRIG_PACKET_SIZE);
		mdelay(2500);
	}
	if (CalState == NTG_CALPASS)
		ret = sprintf(buf, "Calibration PASS!!\n");
	else if (CalState == NTG_CALDEFEAT)
		ret = sprintf(buf, "Calibration FAILURE!!\n");
	ret = strlen(buf)+1;

	if (ts_data->esdFlag)
		queue_delayed_work(ts_data->ntg_wq_esd, &ts_data->ntg_work_esd, msecs_to_jiffies(ESDSEQ));

	return ret;
}
DEVICE_ATTR(ts_SetCal, 0444, ntg_SetCal, NULL);

static ssize_t ts_gpio(struct device *dev, struct device_attribute *attr, char *buf)
{
	int ret = 0;
	struct ntg_tsData *ts;
	ts  = private_ts;

	ret  = gpio_get_value(ts->irq_gpio);

	printk(KERN_DEBUG "GPIO_TP_INT_N=%d\n", ret);
	sprintf(buf, "GPIO_TP_INT_N=%d\n", ret);
	ret = strlen(buf) + 1;
	return ret;
}
DEVICE_ATTR(gpio, 0444, ts_gpio, NULL);

static ssize_t ts_touch(struct device *dev, struct device_attribute *attr,
						const char *buf, size_t count)
{
	int ret = 0, mode;
	struct ntg_tsData *ts;
	char spiTxbuf[NTRIG_PACKET_SIZE], spiRxbuf[NTRIG_PACKET_SIZE];
	ts = private_ts;

	mode  = simple_strtoul(buf, NULL, 10);

	memset(spiTxbuf, 0xAA, NTRIG_PACKET_SIZE);
	memset(spiRxbuf, 0x00, NTRIG_PACKET_SIZE);

	switch (mode) {
	case 0x01:/*Touch Enable*/
		ntgFW_ctltouch[16] = 0x0F;
		break;
	case 0x00:/*Touch Disable*/
		ntgFW_ctltouch[16] = 0x14;
		break;
	}
	memcpy(spiTxbuf, ntgFW_ctltouch, sizeof(ntgFW_ctltouch));

	ret = spiDuplex_Lock(ts->spiDev , spiTxbuf, spiRxbuf,
			     sizeof(char)*NTRIG_PACKET_SIZE);
	ret = strlen(buf);
	return count;
}
DEVICE_ATTR(touch, 0644, NULL, ts_touch);

static ssize_t opfreq(struct device *dev, struct device_attribute *attr, char *buf)
{
	int ret = 0;

	if (analy_opfreq())
		ret = sprintf(buf, "FreqID=%d, Freq=%d\n", mapData->fnId, mapData->phyfrq*10);
	else
		ret = sprintf(buf, "Fetch Frequency Data FAILURE\n");
	return ret;
}
DEVICE_ATTR(opfreq, 0444, opfreq, NULL);

static struct kobject *android_touch_kobj;

static int ntrig_touch_sysfs_init(void)
{
	int ret;
	android_touch_kobj = kobject_create_and_add("android_touch", NULL);
	if (android_touch_kobj == NULL) {
		pr_err("[tp_ntg_err]subsystem_register_failed\n");
		ret = -ENOMEM;
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_ts_SetCal.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_gpio.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_debug_level.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_mode.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_event_google.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_vendor.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_stopesd.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_OTFC.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_touch.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	ret = sysfs_create_file(android_touch_kobj, &dev_attr_opfreq.attr);
	if (ret) {
		pr_err("[tp_ntg_err]sysfs_create_file failed\n");
		return ret;
	}
	return 0;
}

static void ntrig_touch_sysfs_remove(void)
{
	sysfs_remove_file(android_touch_kobj, &dev_attr_ts_SetCal.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_debug_level.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_gpio.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_mode.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_event_google.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_vendor.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_stopesd.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_OTFC.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_touch.attr);
	sysfs_remove_file(android_touch_kobj, &dev_attr_opfreq.attr);

	kobject_del(android_touch_kobj);
}

static u32 CalcCheck_agentsum(unsigned char *PacketData, u16 PackLen)
{
	int i;
	u32  sum = 0;
	for (i = 0 ; i < PackLen; i++)
		sum += PacketData[i];
	return sum;
}

static int ntrig_debug_agent_reset(struct ntg_tsData *ntg)
{
	memset(&g_data_uart, 0x00, sizeof(struct ntg_debug_agent_uart));
	return 0;
}
static void ntrig_debug_agent_fragment(struct ntg_tsData *ntg)
{
	char preamble[] = {0xA5, 0x5A, 0xE7, 0x7E};
	u32 c_sum, i;

	memset(&data_agent[0], 0xff, 4);
	memcpy(&data_agent[4], &preamble[0], 4);
	data_agent[8] = g_data_uart.header.type;
	data_agent[9] = (g_data_uart.header.length & 0xff);
	data_agent[10] = (g_data_uart.header.length & 0xff00) >> 8;
	data_agent[11] = g_data_uart.header.flag;
	data_agent[12] = g_data_uart.header.channel;
	data_agent[13] = g_data_uart.header.function;
	memcpy(&data_agent[14], &g_data_uart.data, g_data_uart.header.length - 6);
	c_sum = CalcCheck_agentsum((unsigned char *)&data_agent[8], g_data_uart.header.length);
	data_agent[g_data_uart.header.length + 8] = (c_sum & 0xff);
	data_agent[g_data_uart.header.length + 9] = (c_sum & 0xff00) >> 8;
	data_agent[g_data_uart.header.length + 10] = (c_sum & 0xff0000) >> 16;
	data_agent[g_data_uart.header.length + 11] = (c_sum & 0xff000000) >> 24;
	if (TSLog & Dbg_L4) {
		pr_info("ntrig agent [from agent] c_sum = 0x%.4x, length 0x%.2x\n",
			c_sum, g_data_uart.header.length);

		pr_info("ntrig agent [from agent] 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x\n",
			data_agent[0], data_agent[1], data_agent[2], data_agent[3],
			data_agent[4], data_agent[5], data_agent[6], data_agent[7]);

		pr_info("ntrig agent [from agent] 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x\n",
			data_agent[8], data_agent[9], data_agent[10], data_agent[11],
			data_agent[12], data_agent[13]);

		for (i = 0; i < (g_data_uart.header.length - 6 + 4)/8; i++) {
			pr_info("ntrig agent %d[from agent] %.2x %.2x %.2x %.2x\\%.2x %.2x %.2x %.2x\n",
				i+1, data_agent[14+0+i*8], data_agent[14+1+i*8],
				data_agent[14+2+i*8], data_agent[14+3+i*8], data_agent[14+4+i*8], data_agent[14+5+i*8],
				data_agent[14+6+i*8], data_agent[14+7+i*8]);
		}
		for (i = 0; i < ((g_data_uart.header.length - 6 + 4)%8); i++) {
			pr_info("ntrig agent [from agent]the last %d byte => 0x%.2x,\n",
				14+1+i+8 + (((g_data_uart.header.length  - 6 + 4)/8) - 1)*8,
				data_agent[14+i+8+(((g_data_uart.header.length - 6 + 4)/8) - 1)*8]);
		}
	}
	atomic_set(&ntg->data_ok_agent, 1);
	wake_up_interruptible(&data_ready_agent_wq);
	if (TSLog & Dbg_L4)
		pr_info("ntrig [ts]%s: wait_event  data_send_agent_wq\n", __func__);
	wait_event_interruptible(data_send_agent_wq, atomic_read(&ntg->info_send_agent));
	atomic_set(&ntg->info_send_agent, 0);
	if (TSLog & Dbg_L4)
		pr_info("ntrig [ts]%s: wait_event  ok\n", __func__);
	memset(&data_agent, 0x00, DEBUG_ANGENT_ALL_REPORT_SIZE);
	ntrig_debug_agent_reset(ntg);
	/*atomic_set(&ntg->start_agent, 0);*/
}

static int ntrig_debug_agent_copy(struct ntg_tsData *ntg, char *buf, int index)
{
	int i;

	g_data_uart.header = ntg->touchEvnt->header;
	memcpy(&g_data_uart.data[index],
				&buf[10],
				ntg->touchEvnt->header.length - 6);
	if (TSLog & Dbg_L4) {
		pr_info("ntrig agent [spi]type 0x%x, length 0x%x, flag 0x%x, channel 0x%x, function 0x%x\n",
			g_data_uart.header.type, g_data_uart.header.length,
			g_data_uart.header.flag, g_data_uart.header.channel,
			g_data_uart.header.function);

		for (i = 0; i < ((ntg->touchEvnt->header.length - 6)/8); i++) {
			pr_info("ntrig agent [spi] %.2x %.2x %.2x %.2x\\%.2x %.2x %.2x %.2x\n",
				g_data_uart.data[index+0+i*8], g_data_uart.data[index+1+i*8],
				g_data_uart.data[index+2+i*8], g_data_uart.data[index+3+i*8],
				g_data_uart.data[index+4+i*8], g_data_uart.data[index+5+i*8],
				g_data_uart.data[index+6+i*8], g_data_uart.data[index+7+i*8]);
		}
		for (i = 0; i < ((ntg->touchEvnt->header.length - 6)%8); i++) {
			pr_info("ntrig agent [spi]the last %d byte => 0x%.2x,\n",
				1 + i + 8 + (((ntg->touchEvnt->header.length - 6)/8) - 1)*8,
				g_data_uart.data[index + 1 + i + 7 + (((ntg->touchEvnt->header.length - 6)/8) - 1)*8]);
		}
	}
	return 0;
}

static int ntrig_debug_agent_parser(struct ntg_tsData *ntg, char *buf)
{
	static int pre_flag, data_uart_length;
	struct ntg_touch_header  temp_header;

	if (atomic_read(&ntg->start_agent) == 0) {
		return 0;
	}

	temp_header = ntg->touchEvnt->header;
	if (temp_header.flag > 0xf || temp_header.flag < 0x0) {
		pr_info("ntrig [ts]%s: err flag 0x%x\n", __func__, temp_header.flag);
		ntrig_debug_agent_reset(ntg);
		pre_flag = 0;
		data_uart_length = 0;
		return -1;
	}

	if (temp_header.channel == 0x30) {
		if (temp_header.flag == 0 && pre_flag == 0) {/*only one packet*/
			ntrig_debug_agent_copy(ntg, buf, 0);
			ntrig_debug_agent_fragment(ntg);
			pre_flag = 0;
			data_uart_length = 0;
		} else {
			if (pre_flag == 0 || (temp_header.flag >= 0 &&/*check flag*/
			    (pre_flag == (temp_header.flag+1)) &&
			    (temp_header.function ==/*check function*/
			    g_data_uart.header.function))) {
				ntrig_debug_agent_copy(ntg, buf, data_uart_length);
				data_uart_length = data_uart_length + (temp_header.length - 6);
				pre_flag = temp_header.flag;

				if (temp_header.flag == 0) {
					g_data_uart.header.length = data_uart_length + 6; /*add type ~func*/
					ntrig_debug_agent_fragment(ntg);
					pre_flag = 0;
					data_uart_length = 0;
				}
			} else {
				pr_info("ntrig [ts]%s: err flag 0x%x, pre_flag 0x%x, function 0x%x, pre function 0x%x\n",
					__func__, temp_header.flag, pre_flag, temp_header.function ,
					g_data_uart.header.function);
				ntrig_debug_agent_reset(ntg);
				pre_flag = 0;
				data_uart_length = 0;
				return -2;
			}
		}
	}
	return 0;
}

static int ntg_parser_agent_usbcmd(struct ntg_tsData *ntg, char* usbRxbuf)
{
	short DataLen, nIdx_pre = 0;
	static int status, index_next;
	static char tempusbTx[NTRIG_PACKET_SIZE];
	int ret = 0, loop_i = 0;
	char usbAnalyTx[NTRIG_PACKET_SIZE], tempRxbuf[NTRIG_PACKET_SIZE];

	if (status == CHK5A) {
		for (loop_i = 0; loop_i < NTRIG_PACKET_SIZE; loop_i++) {
			if (usbRxbuf[loop_i] == 0xA5) {
				nIdx_pre = loop_i;
				if (TSLog & Dbg_L4)
					pr_info("[ts]CHK5A-for-loop, loop_i = %d\n", loop_i);
				break;
			}
			if (loop_i == NTRIG_PACKET_SIZE - 1) {
				if (TSLog & Dbg_L4)
					pr_info("[ts]CHK5A-for-loop,no pre, loop_i = %d\n", loop_i);
				return 0;
			}
		}
	}

	memcpy((char *)&DataLen, (usbRxbuf + nIdx_pre + 4 + 1), 2);
	memcpy(tempusbTx, (usbRxbuf + nIdx_pre), DataLen+4);

	memset(usbAnalyTx, 0xFF, sizeof(char)*NTRIG_PACKET_SIZE);
	memcpy(&usbAnalyTx[4], tempusbTx, DataLen+4);
	if (TSLog & Dbg_L4) {
		pr_info("[ntrig agent form usb]%s, data length 0x%x\n", __func__, DataLen);
		SPIBUF(usbAnalyTx);
	}
	memset(tempRxbuf, 0x00, sizeof(char)*NTRIG_PACKET_SIZE);
	atomic_set(&ntg->start_agent, 1);
	ntg_spi_transfer(ntg, usbAnalyTx);
	memset(tempusbTx, 0x00, sizeof(char)*NTRIG_PACKET_SIZE);
	status = CHK5A;
	index_next = 0;

	return ret;
}

static ssize_t ntrig_agent_read(struct file *file,
			  char __user *buf, size_t count, loff_t *pos)
{
	unsigned long size;
	struct ntg_tsData *ntg;
	size_t length_report;
	static size_t remain_report_len;
	int start_report;

	ntg  = private_ts;

	if (remain_report_len == 0) {
		wait_event_interruptible(data_ready_agent_wq, atomic_read(&ntg->data_ok_agent));

		if ((g_data_uart.header.length + 8 + 4) > DEBUG_ANGENT_REPORT_SIZE) {
			length_report = DEBUG_ANGENT_REPORT_SIZE;
			remain_report_len = (g_data_uart.header.length + 8 + 4) - DEBUG_ANGENT_REPORT_SIZE;
		} else {
			length_report = (g_data_uart.header.length + 8 + 4);
			remain_report_len = 0;
		}
		start_report = 0;
	} else {
		length_report = remain_report_len;
		start_report = DEBUG_ANGENT_REPORT_SIZE;
		remain_report_len = 0;
	}
	if (TSLog & Dbg_L4)
		pr_info(" %s start,report length %#x, all length %#x\n",
			__func__, length_report, (g_data_uart.header.length + 8 + 4));
	size = copy_to_user(buf, &data_agent[start_report], length_report);
	if (size) {
		pr_info(" %s copy_to_user err\n", __func__);
	}

	atomic_set(&ntg->data_ok_agent, 0);

	if (remain_report_len == 0) {
		atomic_set(&ntg->info_send_agent, 1);
		wake_up_interruptible(&data_send_agent_wq);
	}
	if (TSLog & Dbg_L4)
		pr_info(" %s end\n", __func__);

	return length_report;
}

static ssize_t ntrig_agent_write(struct file *file,
			   const char __user *buf, size_t count, loff_t *pos)
{
	char data_form_usb[NTRIG_PACKET_SIZE];
	int i;
	unsigned long size;
	struct ntg_tsData *ts_data;

	ts_data  = private_ts;

	if (count > NTRIG_PACKET_SIZE) {
		printk(KERN_ERR "%s: Err :command length %d > %d or < 5\n",
			__func__, count, NTRIG_PACKET_SIZE);
		return count;
	}

	memset(data_form_usb, 0xFF, sizeof(char)*NTRIG_PACKET_SIZE);
	if (TSLog & Dbg_L4)
		printk(KERN_INFO "%s: send agent command length, count %d\n", __func__, count);

	size = copy_from_user(data_form_usb, buf, count);
	if (TSLog & Dbg_L4)
		for (i = 0; i < NTRIG_PACKET_SIZE/8; i++) {
			pr_info("ntrig agent %d[cmd from usb] %.2x %.2x %.2x %.2x\\%.2x %.2x %.2x %.2x\n",
				i+1, data_form_usb[0+i*8], data_form_usb[1+i*8], data_form_usb[2+i*8],
				data_form_usb[3+i*8], data_form_usb[4+i*8], data_form_usb[5+i*8],
				data_form_usb[6+i*8], data_form_usb[7+i*8]);
		}
	ntg_parser_agent_usbcmd(ts_data, data_form_usb);

	return count;
}

static int ntrig_agent_open(struct inode *inode, struct file *file)
{
	return nonseekable_open(inode, file);
}

static int ntrig_agent_release(struct inode *inode, struct file *file)
{
	return 0;
}

static const struct file_operations ntrig_agent_fops = {
	.read		= ntrig_agent_read,
	.write		= ntrig_agent_write,
	.open		= ntrig_agent_open,
	.release	= ntrig_agent_release,
};

static struct miscdevice ntrigi_miscdev = {
	.name	= "ttyntrig-debug",
	.fops	= &ntrig_agent_fops,
	.minor	= MISC_DYNAMIC_MINOR,
};

static void ntg_orientate(short orien, unsigned short *posX, unsigned short *posY)
{
	u16 switchTmp = 0;
	struct ntg_tsData *ts_data;
	ts_data = private_ts;

	if (orien & 0x01) {
		switchTmp = *posX;
		*posX = *posY;
		*posY = switchTmp;
	}
	if (orien & 0x02) {
		(*posX) = ts_data->abs_x_max - (*posX);
	}
	if (orien & 0x04) {
		(*posY) = ts_data->abs_y_max - (*posY);
	}
}

static void compatible_tp_report(struct input_dev *idev, void *event, int index, bool finger, bool ontip)
{
	if (!ontip) {
		input_report_abs(idev, ABS_MT_TOUCH_MAJOR, 0x00);
                input_report_abs(idev, ABS_MT_PRESSURE, 0x00);
	} else {
		if (finger) {
			NtrTrackedFinger *touch = (NtrTrackedFinger *)event;
                        input_report_abs(idev, ABS_MT_TRACKING_ID, index);
			input_report_abs(idev, ABS_MT_PRESSURE, 0xFF);
			input_report_abs(idev, ABS_MT_TOUCH_MAJOR, 0x28);
			input_report_abs(idev, ABS_MT_WIDTH_MAJOR,
					 (touch->posDx + touch->posDy)/140);
			input_report_abs(idev, ABS_MT_POSITION_X, touch->posX);
			input_report_abs(idev, ABS_MT_POSITION_Y, touch->posY);
		} else {
			struct ntg_touch_Stouch *touch = (struct ntg_touch_Stouch *)event;
                        input_report_abs(idev, ABS_MT_TRACKING_ID, index);
			input_report_abs(idev, ABS_MT_TOUCH_MAJOR, touch->bit);
			input_report_abs(idev, ABS_MT_PRESSURE, touch->bit);
			input_report_abs(idev, ABS_MT_WIDTH_MAJOR, touch->posDx);
			input_report_abs(idev, ABS_MT_POSITION_X, touch->posX);
			input_report_abs(idev, ABS_MT_POSITION_Y, touch->posY);
		}
	}
	input_mt_sync(idev);
}

static int ntrig_open(struct inode *inode, struct file *file)
{
	return nonseekable_open(inode, file);
}
static int ntrig_release(struct inode *inode, struct file *file)
{
	return 0;
}

int get_finger_index(int id)
{
	static int first = 1;
	int i;

	if (first) {
		first = 0;
		for (i = 0; i < ABS_MT_TRACKING_ID_MAX; i++)
			gFingerMap[i] = -1;
	}

	/* search for existing finger */
	for (i = 0; i < ABS_MT_TRACKING_ID_MAX; i++) {
		if (gFingerMap[i] == id)
			return i;
	}
	/* search for place for new finger */
	for (i = 0; i < ABS_MT_TRACKING_ID_MAX; i++) {
		if (gFingerMap[i] < 0) {
			/* found */
			gFingerMap[i] = id;
			return i;
		}
	}
	/* new finger, and all places are in use (should not happen) */
	return -1;
}

void ntrig_send_multi_touch_to_android(struct input_dev *input,
		NtrTrackedFingersReport *multi_touch, short orien)
{
	int i = 0, index;
	int fingers_num = multi_touch->FingerCount;
	NtrTrackedFinger *fingers = multi_touch->Fingers;

	if (!input)
		return;

	for (i = 0; i < fingers_num; i++) {
		index = get_finger_index(fingers[i].TrackID);
		if (index < 0)
			continue;

		if (fingers[i].IsRemoved) {
                  {
			input_report_abs(input, ABS_MT_TOUCH_MAJOR, 0x00);
                        input_report_abs(input, ABS_MT_PRESSURE, 0x00);
                  }
		} else {
			if (TSLog & Dbg_L5) {
				pr_info("NTRIG #finger%d,[Id:%d][X:Y][%#x,%#x][dX:dY][%d,%d][Palm:%d][Removed:%d]htc:dzdw=%#x, posi=%x\n",
					i+1, fingers[i].TrackID, fingers[i].posX, (int)fingers[i].posY,
					(int)fingers[i].posDx, fingers[i].posDy,
					(int)fingers[i].IsPalm, (int)fingers[i].IsRemoved,
					(0x28 << 16) | ((fingers[i].posDx + fingers[i].posDy)/60),
					(fingers[i].posX << 16 | fingers[i].posY));
			}
			ntg_orientate(orien, &fingers[i].posX, &fingers[i].posY);
			if (TSLog & Dbg_L4) {
				pr_info("[ts] Finger=%d, X=%d, Y=%d\n", i+1, fingers[i].posX, fingers[i].posY);
			}

                        compatible_tp_report(input, (void *)&fingers[i], index, true, true);
		}
	}
        input_sync(input);
        if (((1 == fingers_num) && (fingers[0].IsRemoved)) || (0 == fingers_num)) {
          input_report_abs(input, ABS_MT_PRESSURE, 0x00);
          input_report_abs(input, ABS_MT_TOUCH_MAJOR, 0x00);
          input_sync(input);
          if (TSLog & Dbg_L4)
            pr_info("[ts]Finger Leave\n");
        }
	for (i = 0; i < fingers_num; i++) {
		if (0 != fingers[i].IsRemoved) {
			index = get_finger_index(fingers[i].TrackID);
			if (index >= 0)
				gFingerMap[index] = -1;
		}
	}
}

static long ntrig_ioctl(struct file *file, unsigned int cmd,
	   unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	long ret = 0;
	NtrTrackedFingersReport outReport;
	struct ntg_tsData *ntg;

	ntg  = private_ts;
	switch (cmd) {
	case NTRIG_IOCTL_READ_DATA:
		ret = wait_event_interruptible(ntg->get_data_wq, ntg->get_data);
		if (ret) {
			pr_err("[ts] get_data = %x\n", ntg->get_data);
			return -EFAULT;
		}
		ntg->get_data = 0;
		if (copy_to_user(argp, &byte_muti_tp, sizeof(byte_muti_tp))) {
			ntg->send_lib = 1;
			wake_up(&ntg->send_data_wq);
			pr_err("%s: copy_to_user error\n", __func__);
			return -EFAULT;
		}
		if (count_isr_from_resume == 2) {/*fisrt report FW ver then mt report after resume*/
			count_isr_from_resume++;
			pr_info("[ntrig MT] IOCTL_READ_DATA, after resume send data to lib: repID = 0x%x, Contact count(1 byte) = 0x%x",
				byte_muti_tp[0], byte_muti_tp[MTM_REPORT_SIZE-1]);
		}
		if (TSLog & Dbg_L3)
			pr_info("[ntrig MT] NTRIG_IOCTL_READ_DATA: repID = 0x%x, Contact count(1 byte) = 0x%x",
				byte_muti_tp[0], byte_muti_tp[MTM_REPORT_SIZE-1]);

		memset(byte_muti_tp, 0x00, MTM_REPORT_SIZE+1);
		ntg->send_lib = 1;
		wake_up(&ntg->send_data_wq);
		break;

	case NTRIG_IOCTL_SEND_DATA:
		if (copy_from_user(&outReport, argp, sizeof(outReport))) {
			pr_err("%s: copy_from_user error\n", __func__);
			return -EFAULT;
		}
		if (TSLog & Dbg_L3)
			pr_info("[NTRIG] FingerCount = %d\n", outReport.FingerCount);

		ntrig_send_multi_touch_to_android(ntg->input_dev, &outReport, ntg->orientate);
		break;
	default:
		break;
	}

	return 0;
}

static struct file_operations ntrig_fops = {
	.owner = THIS_MODULE,
	.open = ntrig_open,
	.release = ntrig_release,
	.unlocked_ioctl = ntrig_ioctl,
};

static struct miscdevice ntrig_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name = "ntrig_touch",
	.fops = &ntrig_fops,
};

static void touchEventReport(struct ntg_tsData *ntg)
{
  if (ntg->touchEvnt->header.type == 0x01
      && ntg->touchEvnt->header.channel == 0x02) {
    compatible_tp_report(ntg->input_dev, &ntg->touchEvnt->stouch, 0x00,
                         true, (ntg->touchEvnt->stouch.bit & 0x02));
    input_sync(ntg->input_dev);
    
  } else if (ntg->touchEvnt->header.type == 0x01
             && ntg->touchEvnt->header.channel == 0x03) {
    if (TSLog & Dbg_L8)
      pr_info("[ts_Pen] %d, %d, bit = %d\n", ntg->touchEvnt->ptouch.posX,
              ntg->touchEvnt->ptouch.posY, ntg->touchEvnt->ptouch.bit);
    
    compatible_tp_report(ntg->input_devP, (struct ntg_touch_Stouch *)&ntg->touchEvnt->ptouch, 0x00, false,
                         (ntg->touchEvnt->ptouch.bit & 0x02) || (ntg->touchEvnt->ptouch.bit & 0x4) ||
                         (ntg->touchEvnt->ptouch.bit & 0x08) || (ntg->touchEvnt->ptouch.bit & 0x1));
    input_sync(ntg->input_devP);
  }
  
  memset(ntg->touchEvnt, 0x00, sizeof(struct ntg_touch_event));
}

static bool ntg_CheckSum(char *buf, struct ntg_tsData *ntg)
{
	short i;
	u16 sum = 0, oriSum, length = 0;

	if (atomic_read(&ntg->start_agent))
		return true;

	memcpy((void *)&length, (void *)&buf[1], 2);

	for (i = 0; i < length; i++)
		sum += buf[i];

	memcpy((void *)&oriSum, (void *)&buf[length+4], 2);

	if (sum == oriSum) {
		return true;
	} else {
		pr_info("[ts]c_sum = %.2x, o_Sum = %.2x", sum, oriSum);
		SPIBUF(buf);
		return false;
	}
}

static int ntrig_frame_parser(struct ntg_tsData *ntg, char *buf)
{
	bool fCheckSum = true;
	short anIdx = 0, nIndex = 0, region = 0;
	int i, contact_count, DTime = 0;
	struct ntg_touch_Mtouch *mtouch;
#ifdef COUNTER_DEBUG
	u32 cnt = 0, cnt_mt = 0;
#endif
	i = 0;
	if (buf[i] == 0xA5 && buf[i+1] == 0x5A &&
	    buf[i+2] == 0xE7 && buf[i+3] == 0x7E) {
		nIndex = i+4;
		if (TSLog & Dbg_L1) {
			pr_info("[ts-Rx]%s\n", __func__);
			SPIBUF(buf);
		}
		memcpy((void *)&ntg->touchEvnt->header, &buf[nIndex], sizeof(struct ntg_touch_header));

#ifdef COUNTER_DEBUG
		if (ntg->touchEvnt->header.channel == 0x01)	{
			memcpy(&cnt, &buf[104], 4);
			if (cnt != 0x00) {
				if ((g_lastcht+1) != cnt) {
					if (cnt != 0xFFFFFFFF)
						g_lastcht = cnt;

					g_missRep++;
					pr_info("ts cnt = %d] counter not match, miss cnt = 0x%.4x\n", cnt, g_missRep);
					SPIBUF(buf);
				}
				if (cnt % 100 == 0) {
					pr_info("[ts cnt = %d ] missRep = %.4x\n", cnt, g_missRep);
				}
			}
			g_lastcht = cnt;
		} else {
			memcpy(&cnt, &buf[104], 4);
			pr_info("[ts cnt = %d] counter , channel = 0x%.4x, type = 0x%.4x\n", cnt, ntg->touchEvnt->header.channel,
					 ntg->touchEvnt->header.type);
		}
#endif
		if (ntg->touchEvnt->header.channel == 0x30) {
			 ntrig_debug_agent_parser(ntg, buf);
		} else if (ntg->touchEvnt->header.type == 0x02 || ntg->touchEvnt->header.type == 0x01) {
			switch (ntg->touchEvnt->header.channel) {
			case 0x01:
#ifdef COUNTER_DEBUG
				memcpy(byte_muti_tp, &buf[nIndex+6], MTM_REPORT_SIZE+4);
				memcpy(&cnt_mt, &byte_muti_tp[MTM_REPORT_SIZE], 4);
				byte_muti_tp[MTM_REPORT_SIZE+4] = TSLog;
				pr_info("[ts_MT] cnt_mt %d for multi tp\n", cnt_mt);
				if (cnt_mt != cnt)
					pr_info("[ts_MT] miss cnt_mt %d for multi tp, cnt %d\n", cnt_mt, cnt);
#else
				memcpy(byte_muti_tp, &buf[nIndex+6], MTM_REPORT_SIZE);
				byte_muti_tp[MTM_REPORT_SIZE] = TSLog;/*for daemon to enable log*/
#endif
				fCheckSum = ntg_CheckSum(&buf[nIndex], ntg);
				if (fCheckSum) {
					contact_count = byte_muti_tp[MTM_REPORT_SIZE - 1];
					for (i = 0; i < contact_count; i++) {
						mtouch = (struct ntg_touch_Mtouch *)&(byte_muti_tp[3+sizeof(struct ntg_touch_Mtouch)*i]);
						if (mtouch->bit & 0x10) {
							mtouch->posX = 0;
							mtouch->posY = 0;
							mtouch->posDx = 250;
							mtouch->posDy = 150;
							mtouch->vdefine = 0x0D000B00;
							pr_info("[ts_inPalmRegion] bit = %d, i= %d\n", mtouch->bit, i+1);
						}
					}

					if (TSLog & Dbg_L5) {
						pr_info("[ts_MT]repID = %#x, Report Count= %#x, %#x\n",
							byte_muti_tp[0], byte_muti_tp[1], byte_muti_tp[2]);
						for (i = 0; i < 6; i++) {
							pr_info("[ts_MT]State= %#x,Fgr-idx= %#x,%#x;x= %#x,%#x;y=%#x,%#x;dx=%#x,%#x;dy=%#x,%#x,VDef= %#x,%#x,%#x,%#x\n",
								byte_muti_tp[3+(i*15)], byte_muti_tp[4+(i*15)], byte_muti_tp[5+(i*15)], byte_muti_tp[6+(i*15)],
								byte_muti_tp[7+(i*15)], byte_muti_tp[8+(i*15)], byte_muti_tp[9+(i*15)], byte_muti_tp[10+(i*15)],
								byte_muti_tp[11+(i*15)], byte_muti_tp[12+(i*15)], byte_muti_tp[13+(i*15)], byte_muti_tp[14+(i*15)],
								byte_muti_tp[15+(i*15)], byte_muti_tp[16+(i*15)], byte_muti_tp[17+(i*15)]);
						}
						pr_info("[ts_MT] contact cnt = %d\n", byte_muti_tp[93]);
						i = 0;
					}
					if (TSLog & Dbg_L7) {
						pr_info("[ts_DM]%#x,%#x,%#x\n", byte_muti_tp[0], byte_muti_tp[1], byte_muti_tp[2]);
						for (i = 0; i < 3; i++) {
							pr_info("[ts_DM]%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x,%#x\n",
								byte_muti_tp[3+(i*15)], byte_muti_tp[4+(i*15)], byte_muti_tp[5+(i*15)], byte_muti_tp[6+(i*15)],
								byte_muti_tp[7+(i*15)], byte_muti_tp[8+(i*15)], byte_muti_tp[9+(i*15)], byte_muti_tp[10+(i*15)],
								byte_muti_tp[11+(i*15)], byte_muti_tp[12+(i*15)], byte_muti_tp[13+(i*15)], byte_muti_tp[14+(i*15)],
								byte_muti_tp[15+(i*15)], byte_muti_tp[16+(i*15)], byte_muti_tp[17+(i*15)]);
						}
						pr_info("[ts_DM]%#x\n", byte_muti_tp[93]);
						i = 0;
					}
					if (count_isr_from_resume == 2)/*fisrt report FW ver then mt report after resume*/
						pr_info("[ts_MT] after resume mt report from FW:Contact count(1 byte) = %d\n", contact_count);
					if (TSLog & Dbg_L3)
						pr_info("[ts_MT] :Contact count(1 byte) = %d\n", contact_count);

					ntg->get_data = 1;
					wake_up(&ntg->ge…