/* drivers/input/touchscreen/sec_ts_selftest.c
 *
 * Copyright (C) 2016 Samsung Electronics Co., Ltd.
 * http://www.samsungsemi.com/
 *
 * Core file for Samsung TSC driver
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <asm/uaccess.h>
#include <linux/delay.h>
#include <linux/delay.h>
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/gpio.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/proc_fs.h>
#include <linux/regulator/consumer.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/slab.h>
#include <linux/wakelock.h>

#ifdef SAMSUNG_PROJECT
#include <linux/sec_sysfs.h>
#endif
#include <linux/irq.h>
#include <linux/of_gpio.h>
#include <linux/time.h>
#if defined(CONFIG_FB)
#include <linux/fb.h>
#include <linux/notifier.h>
#elif defined(CONFIG_HAS_EARLYSUSPEND)
#include <linux/earlysuspend.h>
#endif

#include "sec_ts.h"
#include "sec_ts_selftest.h"

#if SEC_TS_SELFTEST

#define sec_ts_seq_printf(m, fmt, args...)                                     \
	do {                                                                         \
		seq_printf(m, fmt, ##args);                                                \
		if (!sec_ts_test_result_printed)                                           \
			printk(fmt, ##args);                                                     \
	} while (0)

static uint8_t *sec_ts_report_buf = NULL;
static struct sec_ts_data *ts_data;

static struct proc_dir_entry *android_touch_entry = NULL;
static struct proc_dir_entry *sec_ts_proc_selftest_entry = NULL;
static int8_t sec_ts_test_result_printed = 0;
static int8_t sec_ts_test_result = -1;

void sec_ts_print_report_frame(struct sec_ts_data *ts, u16 *pFrame, bool digit,
															 bool data16) {
	int i = 0;
	int j = 0;
	unsigned char *pStr = NULL;
	unsigned char pTmp[16] = {0};
	u16 *pFrame_u16 = (u16 *)pFrame;
	u8 *pFrame_u8 = (u8 *)pFrame;
	s16 *pFrame_s16 = (s16 *)pFrame;
	s8 *pFrame_s8 = (s8 *)pFrame;

	pStr = kzalloc(6 * (ts->tx_count + 1), GFP_KERNEL);
	if (pStr == NULL)
		return;

	memset(pStr, 0x0, 6 * (ts->tx_count + 1));
	snprintf(pTmp, sizeof(pTmp), "           ");
	strncat(pStr, pTmp, 6 * ts->tx_count);

	for (i = 0; i < ts->tx_count; i++) {
		snprintf(pTmp, sizeof(pTmp), "Tx%02d  ", i);
		strncat(pStr, pTmp, 6 * ts->tx_count);
	}

	printk("SEC_TS %s\n", pStr);
	memset(pStr, 0x0, 6 * (ts->tx_count + 1));
	snprintf(pTmp, sizeof(pTmp), "      +");
	strncat(pStr, pTmp, 6 * ts->tx_count);

	for (i = 0; i < ts->tx_count; i++) {
		snprintf(pTmp, sizeof(pTmp), "------");
		strncat(pStr, pTmp, 6 * ts->rx_count);
	}

	printk("SEC_TS %s\n", pStr);

	for (i = 0; i < ts->rx_count; i++) {
		memset(pStr, 0x0, 6 * (ts->tx_count + 1));
		snprintf(pTmp, sizeof(pTmp), "Rx%02d | ", i);
		strncat(pStr, pTmp, 6 * ts->tx_count);

		for (j = 0; j < ts->tx_count; j++) {
			if (digit && data16)
				snprintf(pTmp, sizeof(pTmp), "%5d ",
								 pFrame_u16[(j * ts->rx_count) + i]);
			else if (!digit && data16)
				snprintf(pTmp, sizeof(pTmp), "%5d ",
								 pFrame_s16[(j * ts->rx_count) + i]);
			else if (digit && !data16)
				snprintf(pTmp, sizeof(pTmp), "%5d ", pFrame_u8[(j * ts->rx_count) + i]);
			else
				snprintf(pTmp, sizeof(pTmp), "%5d ", pFrame_s8[(j * ts->rx_count) + i]);
			strncat(pStr, pTmp, 6 * ts->rx_count);
		}
		printk("SEC_TS %s\n", pStr);
	}
	kfree(pStr);
}

/*******************************************************
Description:
	Novatek touchscreen self-test sequence print show
	function.

return:
	Executive outcomes. 0---succeed.
*******************************************************/
#define SUCCESS 0
#define FAIL -1
static int32_t c_show_selftest(struct seq_file *m, void *v) {
#if 0	
	struct sec_ts_data *ts = ts_data;
	struct selftest_header *st_header; 
	u8 *ptrBuff = sec_ts_report_buf;
	u16 *ptrBuff16 = (u16 *)sec_ts_report_buf;
	int i,j;
	u8 failcnt = 0;
	int result = SUCCESS;

	sec_ts_test_result_printed = 0;
	printk( "FW Version: %d.%d.%d.%d\n",
		ts->plat_data->img_version_of_ic[0],
		ts->plat_data->img_version_of_ic[1],
		ts->plat_data->img_version_of_ic[2],
		ts->plat_data->img_version_of_ic[3]);
	
	st_header = (struct selftest_header *)ptrBuff;	
	printk( "selftest signature:%08X\n", st_header->signature);
	printk( "selftest version:%08X\n", st_header->version);
	printk( "selftest total size:%d\n", st_header->totalsize);	
	printk( "selftest crc32:%08X\n", st_header->crc32);	
	printk( "selftest result:%08X\n", st_header->result);	
	printk( "selftest trycnt:%d\n", st_header->trycnt);	
	printk( "selftest passcnt:%d\n", st_header->passcnt);	
	printk( "selftest failcnt:%d\n", st_header->failcnt);
	ptrBuff += sizeof(struct selftest_header);	
	ptrBuff += sizeof(u32)*12;

	ptrBuff16 = (u16 *)ptrBuff;
	printk( "ambient:\n");
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, false, true);

	result = SUCCESS;
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			int ratio = ((sec_ts_selftest_ambient[j*ts->rx_count] / 100) * 25);
			int min = sec_ts_selftest_ambient[j*ts->rx_count] - ratio;
			int max = sec_ts_selftest_ambient[j*ts->rx_count] + ratio;
			if ((ptrBuff16[j*ts->rx_count] < min) ||
				(ptrBuff16[j*ts->rx_count] > max))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "ambient 1st Fail\n");
		failcnt++;
	}
	else
		printk( "ambient 1st Pass\n");

	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk( "ambient 2nd:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j*ts->rx_count] < sec_ts_selftest_ambient_2nd[0]) ||
				(ptrBuff16[j*ts->rx_count] > sec_ts_selftest_ambient_2nd[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "ambient 2nd Fail\n");
		failcnt++;
	}
	else
		printk( "ambient 2nd Pass\n");
		
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk( "ambient 3rd:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, true, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j*ts->rx_count] < sec_ts_selftest_ambient_3rd[0]) ||
				(ptrBuff16[j*ts->rx_count] > sec_ts_selftest_ambient_3rd[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "ambient 3rd Fail\n");
		failcnt++;
	}
	else
		printk( "ambient 3rd Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;

	printk( "P2P min:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (s16 *)ptrBuff, m, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j*ts->rx_count] < sec_ts_selftest_p2pmin[0]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "P2P Min Fail\n");
		failcnt++;
	}
	else
		printk( "P2P Min Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;

	printk( "P2P Max:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, true, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j*ts->rx_count] > sec_ts_selftest_p2pmax[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "P2P Max Fail\n");
		failcnt++;
	}
	else
		printk( "P2P Max Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk( "Raw variance X:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, true, false);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff[j*ts->rx_count] < sec_ts_selftest_rawvarX[0]) ||
				(ptrBuff[j*ts->rx_count] > sec_ts_selftest_rawvarX[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "Raw variance X Fail\n");
		failcnt++;
	}
	else
		printk( "Raw variance X Pass\n");
	ptrBuff += (SEC_TS_RAWDATA_MAXSIZE/2);
	ptrBuff16 = (u16 *)ptrBuff;

	printk( "Raw variance Y:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, true, false);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff[j*ts->rx_count] < sec_ts_selftest_rawvarY[0]) ||
				(ptrBuff[j*ts->rx_count] > sec_ts_selftest_rawvarY[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "Raw variance Y Fail\n");
		failcnt++;
	}
	else
		printk( "Raw variance Y Pass\n");
	ptrBuff += (SEC_TS_RAWDATA_MAXSIZE/2);
	ptrBuff16 = (u16 *)ptrBuff;

	printk( "Short :\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j*ts->rx_count] < sec_ts_selftest_short2nd[0]) ||
				(ptrBuff16[j*ts->rx_count] > sec_ts_selftest_short2nd[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "Short Fail\n");
		failcnt++;
	}
	else
		printk( "Short Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;

	printk( "Rawdata:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j*ts->rx_count] < sec_ts_selftest_rawdata[0]) ||
				(ptrBuff16[j*ts->rx_count] > sec_ts_selftest_rawdata[1]))
				result = FAIL;			
		}
	}
	if (result == FAIL) {
		printk( "Rawdata Fail\n");
		failcnt++;
	}
	else
		printk( "Short Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk( "Offset Cal data:\n");
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, m, true, false);
	ptrBuff += (SEC_TS_RAWDATA_MAXSIZE/2);
	ptrBuff16 = (u16 *)ptrBuff;
	printk( "\n");
#endif

	if (sec_ts_test_result < 0) {
		sec_ts_seq_printf(m, "%d\n", 0);
	} else {

		sec_ts_seq_printf(m, "%d\n", 1);
	}
	sec_ts_test_result_printed = 1;
	return 0;
}

/*******************************************************
Description:
	Sec touchscreen self-test sequence print start
	function.

return:
	Executive outcomes. 1---call next function.
	NULL---not call next function and sequence loop
	stop.
*******************************************************/
static void *c_start(struct seq_file *m, loff_t *pos) {
	return *pos < 1 ? (void *)1 : NULL;
}

/*******************************************************
Description:
	Sec touchscreen self-test sequence print next
	function.

return:
	Executive outcomes. NULL---no next and call sequence
	stop function.
*******************************************************/
static void *c_next(struct seq_file *m, void *v, loff_t *pos) {
	++*pos;
	return NULL;
}

/*******************************************************
Description:
	Sec touchscreen self-test sequence print stop
	function.

return:
	n.a.
*******************************************************/
static void c_stop(struct seq_file *m, void *v) { return; }

const struct seq_operations sec_ts_selftest_seq_ops = {
		.start = c_start, .next = c_next, .stop = c_stop, .show = c_show_selftest};

static int32_t sec_ts_print_selftest(void) {
	struct sec_ts_data *ts = ts_data;
	struct selftest_header *st_header;
	u8 *ptrBuff = sec_ts_report_buf;
	u16 *ptrBuff16 = (u16 *)sec_ts_report_buf;
	int i, j;
	u8 failcnt = 0;
	int result = SUCCESS;
	int ratio, min, max;

	sec_ts_test_result_printed = 0;
	printk("FW Version: %d.%d.%d.%d\n", ts->plat_data->img_version_of_ic[0],
				 ts->plat_data->img_version_of_ic[1],
				 ts->plat_data->img_version_of_ic[2],
				 ts->plat_data->img_version_of_ic[3]);

	st_header = (struct selftest_header *)ptrBuff;
	printk("selftest signature:%08X\n", st_header->signature);
	printk("selftest version:%08X\n", st_header->version);
	printk("selftest total size:%d\n", st_header->totalsize);
	printk("selftest crc32:%08X\n", st_header->crc32);
	printk("selftest result:%08X\n", st_header->result);
	printk("selftest trycnt:%d\n", st_header->trycnt);
	printk("selftest passcnt:%d\n", st_header->passcnt);
	printk("selftest failcnt:%d\n", st_header->failcnt);
	ptrBuff += sizeof(struct selftest_header);
	ptrBuff += sizeof(u32) * 12;

	ptrBuff16 = (u16 *)ptrBuff;
	printk("ambient:\n");
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, false, true);

	result = SUCCESS;
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			ratio = ((sec_ts_selftest_ambient[j * ts->rx_count] / 100) * 25);
			min = sec_ts_selftest_ambient[j * ts->rx_count] - ratio;
			max = sec_ts_selftest_ambient[j * ts->rx_count] + ratio;
			if ((ptrBuff16[j * ts->rx_count] < min) ||
					(ptrBuff16[j * ts->rx_count] > max))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("ambient 1st Fail\n");
		failcnt++;
	} else
		printk("ambient 1st Pass\n");

	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk("ambient 2nd:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j * ts->rx_count] < sec_ts_selftest_ambient_2nd[0]) ||
					(ptrBuff16[j * ts->rx_count] > sec_ts_selftest_ambient_2nd[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("ambient 2nd Fail\n");
		failcnt++;
	} else
		printk("ambient 2nd Pass\n");

	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk("ambient 3rd:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, true, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j * ts->rx_count] < sec_ts_selftest_ambient_3rd[0]) ||
					(ptrBuff16[j * ts->rx_count] > sec_ts_selftest_ambient_3rd[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("ambient 3rd Fail\n");
		failcnt++;
	} else
		printk("ambient 3rd Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;

	printk("P2P min:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (s16 *)ptrBuff, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j * ts->rx_count] < sec_ts_selftest_p2pmin[0]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("P2P Min Fail\n");
		failcnt++;
	} else
		printk("P2P Min Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;

	printk("P2P Max:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, true, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j * ts->rx_count] > sec_ts_selftest_p2pmax[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("P2P Max Fail\n");
		failcnt++;
	} else
		printk("P2P Max Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk("Raw variance X:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, true, false);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff[j * ts->rx_count] < sec_ts_selftest_rawvarX[0]) ||
					(ptrBuff[j * ts->rx_count] > sec_ts_selftest_rawvarX[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("Raw variance X Fail\n");
		failcnt++;
	} else
		printk("Raw variance X Pass\n");
	ptrBuff += (SEC_TS_RAWDATA_MAXSIZE / 2);
	ptrBuff16 = (u16 *)ptrBuff;

	printk("Raw variance Y:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, true, false);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff[j * ts->rx_count] < sec_ts_selftest_rawvarY[0]) ||
					(ptrBuff[j * ts->rx_count] > sec_ts_selftest_rawvarY[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("Raw variance Y Fail\n");
		failcnt++;
	} else
		printk("Raw variance Y Pass\n");
	ptrBuff += (SEC_TS_RAWDATA_MAXSIZE / 2);
	ptrBuff16 = (u16 *)ptrBuff;

	printk("Short :\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j * ts->rx_count] < sec_ts_selftest_short2nd[0]) ||
					(ptrBuff16[j * ts->rx_count] > sec_ts_selftest_short2nd[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("Short Fail\n");
		failcnt++;
	} else
		printk("Short Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;

	printk("Rawdata:\n");
	result = SUCCESS;
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, false, true);
	for (i = 0; i < ts->rx_count; i++) {
		for (j = 0; j < ts->tx_count; j++) {
			if ((ptrBuff16[j * ts->rx_count] < sec_ts_selftest_rawdata[0]) ||
					(ptrBuff16[j * ts->rx_count] > sec_ts_selftest_rawdata[1]))
				result = FAIL;
		}
	}
	if (result == FAIL) {
		printk("Rawdata Fail\n");
		failcnt++;
	} else
		printk("Short Pass\n");
	ptrBuff += SEC_TS_RAWDATA_MAXSIZE;
	ptrBuff16 = (u16 *)ptrBuff;
	printk("Offset Cal data:\n");
	sec_ts_print_report_frame(ts, (u16 *)ptrBuff, true, false);
	ptrBuff += (SEC_TS_RAWDATA_MAXSIZE / 2);
	ptrBuff16 = (u16 *)ptrBuff;
	/*for (i = 0; i < 8; i++) {
		printk( "%d, ", *((u32 *)ptrBuff));
		ptrBuff += sizeof(u16);
	}*/
	printk("\n");
	if (failcnt > 0) {
		printk("Selftest result Fail\n");
		sec_ts_test_result_printed = 1;
		return -1;
	} else {
		printk("Selftest result Pass\n");
		sec_ts_test_result_printed = 1;
		return 0;
	}
}

/*******************************************************
Description:
	Sec touchscreen /proc/sec_ts_selftest open function.

return:
	Executive outcomes. 0---succeed. negative---failed.
*******************************************************/
static int32_t sec_ts_selftest_open(struct inode *inode, struct file *file) {
	struct sec_ts_data *ts = ts_data;
	int rc;
	u8 tpara = 0x03;
	u8 cmd_data[10];
	u8 *report_buff;
	u32 result_size = SEC_TS_SELFTEST_REPORT_SIZE;
	u32 remain_size;
	u32 read_size;

	disable_irq(ts->client->irq);
	input_info(true, &ts->client->dev, "%s: Self test start!\n", __func__);
	cmd_data[0] = 0xFF;
	rc = ts->sec_ts_i2c_write(ts, SEC_TS_CMD_SELFTEST_TYPE, cmd_data, 1);
	if (rc < 0) {
		input_err(true, &ts->client->dev, "%s: Send selftest cmd failed!\n",
							__func__);
		goto err_exit;
	}
	sec_ts_delay(100);

	cmd_data[0] = 0x0;
	cmd_data[1] = 0x64;
	rc = ts->sec_ts_i2c_write(ts, SEC_TS_CMD_SELFTEST_PTOP, cmd_data, 4);
	if (rc < 0) {
		input_err(true, &ts->client->dev, "%s: Send selftest cmd failed!\n",
							__func__);
		goto err_init;
	}
	sec_ts_delay(100);

	input_info(true, &ts->client->dev, "%s: send selftest cmd!\n", __func__);
	rc = ts->sec_ts_i2c_write(ts, SEC_TS_CMD_SELFTEST, &tpara, 1);
	if (rc < 0) {
		input_err(true, &ts->client->dev, "%s: Send selftest cmd failed!\n",
							__func__);
		goto err_init;
	}
	sec_ts_delay(1000);
	rc = sec_ts_wait_for_ready(ts, SEC_TS_ACK_SELF_TEST_DONE);
	if (rc < 0) {
		input_err(true, &ts->client->dev, "%s: Selftest execution time out!\n",
							__func__);
		goto err_init;
	}

	sec_ts_sw_reset(ts);
	sec_ts_delay(500);

	input_info(true, &ts->client->dev, "%s: Self test done!\n", __func__);

	sec_ts_report_buf = kzalloc(result_size, GFP_KERNEL);
	if (!sec_ts_report_buf)
		goto err_init;

	rc = ts->sec_ts_i2c_write(ts, SEC_TS_READ_SELFTEST_RESULT, NULL, 0);
	if (rc < 0) {
		input_err(true, &ts->client->dev,
							"%s: Send selftest read result cmd failed!\n", __func__);
		goto err_exit;
	}
	report_buff = sec_ts_report_buf;
	remain_size = result_size;
	read_size = (remain_size > 256) ? (256) : (remain_size);
	do {
		rc = ts->sec_ts_i2c_read_bulk(ts, report_buff, read_size);
		if (rc < 0) {
			input_err(true, &ts->client->dev,
								"%s: Selftest result read failed remain = %d!\n", __func__,
								remain_size);
			goto err_exit;
		}
		remain_size -= read_size;
		report_buff += read_size;
		read_size = (remain_size > 256) ? 256 : remain_size;
		sec_ts_delay(1);
	} while (remain_size > 0);

	sec_ts_test_result = sec_ts_print_selftest();

	enable_irq(ts->client->irq);
	if(sec_ts_report_buf)
		kfree(sec_ts_report_buf);

	return seq_open(file, &sec_ts_selftest_seq_ops);

err_exit:
	if(sec_ts_report_buf)
		kfree(sec_ts_report_buf);
err_init:
	enable_irq(ts->client->irq);
	return -1;
}

static const struct file_operations sec_ts_selftest_fops = {
		.owner = THIS_MODULE,
		.open = sec_ts_selftest_open,
		.read = seq_read,
		.llseek = seq_lseek,
		.release = seq_release,
};

/*******************************************************
Description:
	Novatek touchscreen MP function proc. file node
	initial function.

return:
	Executive outcomes. 0---succeed. -1---failed.
*******************************************************/
int32_t sec_ts_test_proc_init(struct sec_ts_data *ts) {
	ts_data = ts;

	android_touch_entry = proc_mkdir("android_touch", NULL);
	if (android_touch_entry == NULL) {
		input_err(true, &ts->client->dev, "create /proc/android_touch Failed!\n");
		return -1;
	}

	sec_ts_proc_selftest_entry = proc_create(
			"self_test", 0444, android_touch_entry, &sec_ts_selftest_fops);
	if (sec_ts_proc_selftest_entry == NULL) {
		input_err(true, &ts->client->dev, "create /proc/self_test Failed!\n");
		return -1;
	} else {
		input_info(true, &ts->client->dev, "create /proc/self_test Succeeded!\n");
		return 0;
	}
}

#endif /* #if SEC_TS_SELFTEST */