kernel_samsung_a34x-permissive/drivers/input/touchscreen/ili9881x/ili9881x_mp.c

/*
 * ILITEK Touch IC driver
 *
 * Copyright (C) 2011 ILI Technology Corporation.
 *
 * Author: Dicky Chiang <dicky_chiang@ilitek.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "ili9881x.h"

#define VALUE			0
#define RETRY_COUNT		3
#define INT_CHECK		0
#define POLL_CHECK		1

#define BENCHMARK		1
#define NODETYPE		1

#define TYPE_BENCHMARK		0
#define TYPE_NO_JUGE		1
#define TYPE_JUGE		2

#define NORMAL_CSV_PASS_NAME	"mp_pass"
#define NORMAL_CSV_FAIL_NAME	"mp_fail"
#define NORMAL_CSV_WARNING_NAME	"mp_warning"

#define CSV_FILE_SIZE		(1 * M)

#define PARSER_MAX_CFG_BUF		(512 * 3)
#define PARSER_MAX_KEY_NUM		(600 * 3)
#define PARSER_MAX_KEY_NAME_LEN		100
#define PARSER_MAX_KEY_VALUE_LEN	2000
#define MAX_SECTION_NUM			100
#define BENCHMARK_KEY_NAME		"benchmark_data"
#define NODE_TYPE_KEY_NAME		"node type"
#define INI_ERR_OUT_OF_LINE		-1

#define CMD_MUTUAL_DAC			0x1
#define CMD_MUTUAL_BG			0x2
#define CMD_MUTUAL_SIGNAL		0x3
#define CMD_MUTUAL_NO_BK		0x5
#define CMD_MUTUAL_HAVE_BK		0x8
#define CMD_MUTUAL_BK_DAC		0x10
#define CMD_SELF_DAC			0xC
#define CMD_SELF_BG			0xF
#define CMD_SELF_SIGNAL			0xD
#define CMD_SELF_NO_BK			0xE
#define CMD_SELF_HAVE_BK		0xB
#define CMD_SELF_BK_DAC			0x11
#define CMD_KEY_DAC			0x14
#define CMD_KEY_BG			0x16
#define CMD_KEY_NO_BK			0x7
#define CMD_KEY_HAVE_BK			0x15
#define CMD_KEY_OPEN			0x12
#define CMD_KEY_SHORT			0x13
#define CMD_ST_DAC			0x1A
#define CMD_ST_BG			0x1C
#define CMD_ST_NO_BK			0x17
#define CMD_ST_HAVE_BK			0x1B
#define CMD_ST_OPEN			0x18
#define CMD_TX_SHORT			0x19
#define CMD_RX_SHORT			0x4
#define CMD_RX_OPEN			0x6
#define CMD_TX_RX_DELTA			0x1E
#define CMD_CM_DATA			0x9
#define CMD_CS_DATA			0xA
#define CMD_TRCRQ_PIN			0x20
#define CMD_RESX2_PIN			0x21
#define CMD_MUTUAL_INTEGRA_TIME		0x22
#define CMD_SELF_INTEGRA_TIME		0x23
#define CMD_KEY_INTERGRA_TIME		0x24
#define CMD_ST_INTERGRA_TIME		0x25
#define CMD_PEAK_TO_PEAK		0x1D
#define CMD_GET_TIMING_INFO		0x30
#define CMD_DOZE_P2P			0x32
#define CMD_DOZE_RAW			0x33
#define CMD_PIN_TEST			0x61

#define MP_DATA_PASS			0
#define MP_DATA_FAIL			-1

#define Mathabs(x) ({					\
		long ret;				\
		if (sizeof(x) == sizeof(long)) {	\
		long __x = (x);				\
		ret = (__x < 0) ? -__x : __x;		\
		} else {				\
		int __x = (x);				\
		ret = (__x < 0) ? -__x : __x;		\
		}					\
		ret;					\
	})

#define DUMP(fmt, arg...)		\
	do {				\
		if (debug_en)	\
		pr_cont(fmt, ##arg);	\
	} while (0)

static struct ini_file_data {
	char section_name[PARSER_MAX_KEY_NAME_LEN];
	char key_name[PARSER_MAX_KEY_NAME_LEN];
	char key_value[PARSER_MAX_KEY_VALUE_LEN];
	int section_len;
	int key_name_len;
	int key_val_len;
} *ini_info;

enum open_test_node_type {
	NO_COMPARE = 0x00,	/* Not A Area, No Compare */
	AA_Area = 0x01,		/* AA Area, Compare using Charge_AA */
	Border_Area = 0x02,	/* Border Area, Compare using Charge_Border */
	Notch = 0x04,		/* Notch Area, Compare using Charge_Notch */
	Round_Corner = 0x08,	/* Round Corner, No Compare */
	Skip_Micro = 0x10	/* Skip_Micro, No Compare */
};

enum mp_test_catalog {
	MUTUAL_TEST = 0,
	SELF_TEST = 1,
	KEY_TEST = 2,
	ST_TEST = 3,
	TX_RX_DELTA = 4,
	UNTOUCH_P2P = 5,
	PIXEL = 6,
	OPEN_TEST = 7,
	PEAK_TO_PEAK_TEST = 8,
	SHORT_TEST = 9,
	PIN_TEST = 10,
};

struct mp_test_P540_open {
	s32 *tdf_700;
	s32 *tdf_250;
	s32 *tdf_200;
	s32 *cbk_700;
	s32 *cbk_250;
	s32 *cbk_200;
	s32 *charg_rate;
	s32 *full_Open;
	s32 *dac;
};

struct mp_test_open_c {
	s32 *cap_dac;
	s32 *cap_raw;
	s32 *dcl_cap;
};

struct open_test_para {
	int tvch;
	int tvcl;
	int gain;
	int cbk_step;
	int cint;
} open_para;

struct shor_test_para {
	int tvch;
	int tvcl;
	int variation;
	int rinternal;
	int cint;
} short_para;

static struct core_mp_test_data {
	u32 chip_pid;
	u16 chip_id;
	u8 chip_type;
	u8 chip_ver;
	u32 fw_ver;
	u32 protocol_ver;
	u32 core_ver;
	char ini_date[128];
	char ini_ver[64];
	int no_bk_shift;
	bool retry;
	bool m_signal;
	bool m_dac;
	bool s_signal;
	bool s_dac;
	bool key_dac;
	bool st_dac;
	bool p_no_bk;
	bool p_has_bk;
	bool open_integ;
	bool open_cap;
	bool isLongV;
	bool td_retry;
	bool all_pass;

	int cdc_len;
	int xch_len;
	int ych_len;
	int stx_len;
	int srx_len;
	int key_len;
	int st_len;
	int frame_len;
	int mp_items;
	int final_result;
	int short_varia;

	u32 overlay_start_addr;
	u32 overlay_end_addr;
	u32 mp_flash_addr;
	u32 mp_size;
	u8 dma_trigger_enable;

	/* Tx/Rx threshold & buffer */
	int TxDeltaMax;
	int TxDeltaMin;
	int RxDeltaMax;
	int RxDeltaMin;
	s32 *tx_delta_buf;
	s32 *rx_delta_buf;
	s32 *tx_max_buf;
	s32 *tx_min_buf;
	s32 *rx_max_buf;
	s32 *rx_min_buf;

	int tdf;
	int busy_cdc;
	bool ctrl_lcm;
	bool lost_benchmark;
	bool lost_parameter;
} core_mp = {0};

struct mp_test_items {
	/* The description must be the same as ini's section name */
	char *desp;
	char *result;
	int catalog;
	u8 cmd;
	u8 spec_option;
	u8 type_option;
	bool run;
	bool lcm;
	int bch_mrk_multi;
	int max;
	int max_res;
	int item_result;
	int min;
	int min_res;
	int frame_count;
	int trimmed_mean;
	int lowest_percentage;
	int highest_percentage;
	int v_tdf_1;
	int v_tdf_2;
	int h_tdf_1;
	int h_tdf_2;
	int goldenmode;
	int max_min_mode;
	int bch_mrk_frm_num;
	int retry_cnt;
	u8  delay_time;
	u8  test_int_pin;
	u8  int_pulse_test;
	s32 *result_buf;
	s32 *buf;
	s32 *max_buf;
	s32 *min_buf;
	s32 *bench_mark_max;
	s32 *bench_mark_min;
	s32 **bch_mrk_max;
	s32 **bch_mrk_min;
	s32 *node_type;
	int (*do_test)(int index);
};

#define MP_TEST_ITEM	50
static struct mp_test_items tItems[MP_TEST_ITEM] = {
	{.desp = "baseline data(bg)", .catalog = MUTUAL_TEST, .cmd = CMD_MUTUAL_BG, .lcm = ON},
	{.desp = "untouch signal data(bg-raw-4096) - mutual",
			.catalog = MUTUAL_TEST, .cmd = CMD_MUTUAL_SIGNAL, .lcm = ON},
	{.desp = "manual bk data(mutual)", .catalog = MUTUAL_TEST, .cmd = CMD_MUTUAL_BK_DAC, .lcm = ON},
	{.desp = "calibration data(dac) - self", .catalog = SELF_TEST, .cmd = CMD_SELF_DAC, .lcm = ON},
	{.desp = "baselin data(bg,self_tx,self_r)", .catalog = SELF_TEST, .cmd = CMD_SELF_BG, .lcm = ON},
	{.desp = "untouch signal data(bg-raw-4096) - self", .catalog = SELF_TEST, .cmd = CMD_SELF_SIGNAL, .lcm = ON},
	{.desp = "raw data(no bk) - self", .catalog = SELF_TEST, .cmd = CMD_SELF_NO_BK, .lcm = ON},
	{.desp = "raw data(have bk) - self", .catalog = SELF_TEST, .cmd = CMD_SELF_HAVE_BK, .lcm = ON},
	{.desp = "manual bk dac data(self_tx,self_rx)", .catalog = SELF_TEST, .cmd = CMD_SELF_BK_DAC, .lcm = ON},
	{.desp = "calibration data(dac/icon)", .catalog = KEY_TEST, .cmd = CMD_KEY_DAC, .lcm = ON},
	{.desp = "key baseline data", .catalog = KEY_TEST, .cmd = CMD_KEY_BG, .lcm = ON},
	{.desp = "key raw data", .catalog = KEY_TEST, .cmd = CMD_KEY_NO_BK, .lcm = ON},
	{.desp = "key raw bk dac", .catalog = KEY_TEST, .cmd = CMD_KEY_HAVE_BK, .lcm = ON},
	{.desp = "key raw open test", .catalog = KEY_TEST, .cmd = CMD_KEY_OPEN, .lcm = ON},
	{.desp = "key raw short test", .catalog = KEY_TEST, .cmd = CMD_KEY_SHORT, .lcm = ON},
	{.desp = "st calibration data(dac)", .catalog = ST_TEST, .cmd = CMD_ST_DAC, .lcm = ON},
	{.desp = "st baseline data(bg)", .catalog = ST_TEST, .cmd = CMD_ST_BG, .lcm = ON},
	{.desp = "st raw data(no bk)", .catalog = ST_TEST, .cmd = CMD_ST_NO_BK, .lcm = ON},
	{.desp = "st raw(have bk)", .catalog = ST_TEST, .cmd = CMD_ST_HAVE_BK, .lcm = ON},
	{.desp = "st open data", .catalog = ST_TEST, .cmd = CMD_ST_OPEN, .lcm = ON},
	{.desp = "tx short test", .catalog = MUTUAL_TEST, .cmd = CMD_TX_SHORT, .lcm = ON},
	{.desp = "rx open", .catalog = MUTUAL_TEST, .cmd = CMD_RX_OPEN, .lcm = ON},
	{.desp = "untouch cm data", .catalog = MUTUAL_TEST, .cmd = CMD_CM_DATA, .lcm = ON},
	{.desp = "untouch cs data", .catalog = MUTUAL_TEST, .cmd = CMD_CS_DATA, .lcm = ON},
	{.desp = "tx/rx delta", .catalog = TX_RX_DELTA, .cmd = CMD_TX_RX_DELTA, .lcm = ON},
	{.desp = "untouch peak to peak", .catalog = UNTOUCH_P2P, .cmd = CMD_MUTUAL_SIGNAL, .lcm = ON},
	{.desp = "pixel raw (no bk)", .catalog = PIXEL, .cmd = CMD_MUTUAL_NO_BK, .lcm = ON},
	{.desp = "pixel raw (have bk)", .catalog = PIXEL, .cmd = CMD_MUTUAL_HAVE_BK, .lcm = ON},
	{.desp = "noise peak to peak(cut panel)", .catalog = PEAK_TO_PEAK_TEST, .lcm = ON},
	{.desp = "open test(integration)", .catalog = OPEN_TEST, .cmd = CMD_RX_SHORT, .lcm = ON},
	{.desp = "open test(cap)", .catalog = OPEN_TEST, .cmd = CMD_RX_SHORT, .lcm = ON},
	/* Following is the new test items for protocol 5.4.0 above */
	{.desp = "pin test ( int and rst )", .catalog = PIN_TEST, .cmd = CMD_PIN_TEST, .lcm = ON},
	{.desp = "noise peak to peak(with panel)", .catalog = PEAK_TO_PEAK_TEST, .lcm = ON},
	{.desp = "noise peak to peak(ic only)", .catalog = PEAK_TO_PEAK_TEST, .cmd = CMD_PEAK_TO_PEAK, .lcm = ON},
	{.desp = "open test(integration)_sp", .catalog = OPEN_TEST, .lcm = ON},
	{.desp = "raw data(no bk)", .catalog = MUTUAL_TEST, .cmd = CMD_MUTUAL_NO_BK, .lcm = ON},
	{.desp = "raw data(have bk)", .catalog = MUTUAL_TEST, .cmd = CMD_MUTUAL_HAVE_BK, .lcm = ON},
	{.desp = "calibration data(dac)", .catalog = MUTUAL_TEST, .cmd = CMD_MUTUAL_DAC, .lcm = ON},
	{.desp = "short test -ili9881", .catalog = SHORT_TEST, .cmd = CMD_RX_SHORT, .lcm = ON},
	{.desp = "short test", .catalog = SHORT_TEST, .lcm = ON},
	{.desp = "doze raw data", .catalog = MUTUAL_TEST, .lcm = ON},
	{.desp = "doze peak to peak", .catalog = PEAK_TO_PEAK_TEST, .lcm = ON},
	{.desp = "open test_c", .catalog = OPEN_TEST, .lcm = ON},
	{.desp = "touch deltac", .catalog = MUTUAL_TEST, .lcm = ON},
	/* LCM OFF TEST */
	{.desp = "raw data(have bk) (lcm off)", .catalog = MUTUAL_TEST, .lcm = OFF},
	{.desp = "raw data(no bk) (lcm off)", .catalog = MUTUAL_TEST, .lcm = OFF},
	{.desp = "noise peak to peak(with panel) (lcm off)", .catalog = PEAK_TO_PEAK_TEST, .lcm = OFF},
	{.desp = "noise peak to peak(ic only) (lcm off)", .catalog = PEAK_TO_PEAK_TEST, .lcm = OFF},
	{.desp = "raw data_td (lcm off)", .catalog = MUTUAL_TEST, .lcm = OFF},
	{.desp = "peak to peak_td (lcm off)", .catalog = PEAK_TO_PEAK_TEST, .lcm = OFF},
};

static struct run_index {
	int count;
	int index[MP_TEST_ITEM];
} ri;

static s32 *frame_buf;
static s32 **frm_buf;
static s32 *key_buf;
static s32 *frame1_cbk700, *frame1_cbk250, *frame1_cbk200;
static s32 *cap_dac, *cap_raw;
static int g_ini_items = 0;
static char csv_name[128] = {0};
static char seq_item[MAX_SECTION_NUM][PARSER_MAX_KEY_NAME_LEN] = {{0} };

static int isspace_t(int x)
{
	if (x == ' ' || x == '\t' || x == '\n' ||
			x == '\f' || x == '\b' || x == '\r')
		return 1;
	else
		return 0;
}

static void dump_benchmark_data(s32 *max_ptr, s32 *min_ptr)
{
	ili_dump_data(max_ptr, 32, core_mp.frame_len, 0, "Dump Benchmark Max : ");
	ili_dump_data(min_ptr, 32, core_mp.frame_len, 0, "Dump Benchmark Min : ");
}

static void dump_node_type_buffer(s32 *node_ptr, u8 *name)
{
	ili_dump_data(node_ptr, 32, core_mp.frame_len, 0, "Dump NodeType : ");
}

static int parser_get_ini_key_value(char *section, char *key, char *value)
{
	int i = 0;
	int ret = -2;

	for (i = 0; i < g_ini_items; i++) {
		if (ipio_strcmp(section, ini_info[i].section_name) != 0)
			continue;

		if (ipio_strcmp(key, ini_info[i].key_name) == 0) {
			ipio_memcpy(value, ini_info[i].key_value, ini_info[i].key_val_len, PARSER_MAX_KEY_VALUE_LEN);
			ILI_DBG("%s (key: %s, value:%s) => (ini key: %s, val: %s)\n",
					__func__, key, value, ini_info[i].key_name, ini_info[i].key_value);
			ret = 0;
			break;
		}
	}
	return ret;
}

static void parser_ini_nodetype(s32 *type_ptr, char *desp, int frame_len)
{
	int i = 0, j = 0, index1 = 0, temp, count = 0;
	char str[512] = {0}, record = ',';

	for (i = 0; i < g_ini_items; i++) {
		if (!strstr(ini_info[i].section_name, desp) ||
			ipio_strcmp(ini_info[i].key_name, NODE_TYPE_KEY_NAME) != 0) {
			continue;
		}

		record = ',';
		for (j = 0, index1 = 0; j <= ini_info[i].key_val_len; j++) {
			if (ini_info[i].key_value[j] == ';' || j == ini_info[i].key_val_len) {
				if (record != '.') {
					memset(str, 0, sizeof(str));
					ipio_memcpy(str, &ini_info[i].key_value[index1], (j - index1), sizeof(str));
					temp = ili_katoi(str);

					/* Over boundary, end to calculate. */
					if (count >= frame_len) {
						input_err(true, ilits->dev,
							"%s count(%d) is larger than frame length, break\n",
							__func__, count);
						break;
					}
					type_ptr[count] = temp;
					count++;
				}
				record = ini_info[i].key_value[j];
				index1 = j + 1;
			}
		}
	}
}

static void parser_ini_benchmark(s32 *max_ptr, s32 *min_ptr, int8_t type, char *desp, int frame_len, char *bchmrk_name)
{
	int i = 0, j = 0, index1 = 0, temp, count = 0;
	char str[512] = {0}, record = ',';
	s32 data[4];
	char benchmark_str[256] = {0};

	/* format complete string from the name of section "_Benchmark_Data". */
	snprintf(benchmark_str, sizeof(benchmark_str), "%s%s%s", desp, "_", bchmrk_name);
	ILI_DBG("%s benchmark_str = %s\n", __func__, benchmark_str);

	for (i = 0; i < g_ini_items; i++) {
		if ((ipio_strcmp(ini_info[i].section_name, benchmark_str) != 0))
			continue;
		record = ',';
		for (j = 0, index1 = 0; j <= ini_info[i].key_val_len; j++) {
			if (ini_info[i].key_value[j] == ',' || ini_info[i].key_value[j] == ';' ||
				ini_info[i].key_value[j] == '.' || j == ini_info[i].key_val_len) {

				if (record != '.') {
					memset(str, 0, sizeof(str));
					ipio_memcpy(str, &ini_info[i].key_value[index1], (j - index1), sizeof(str));
					temp = ili_katoi(str);
					data[(count % 4)] = temp;

					/* Over boundary, end to calculate. */
					if ((count / 4) >= frame_len) {
						input_err(true, ilits->dev,
							"%s count (%d) is larger than frame length, break\n",
							__func__, (count / 4));
						break;
					}

					if ((count % 4) == 3) {
						if (data[0] == 1) {
							if (type == VALUE) {
								max_ptr[count/4] = data[1] + data[2];
								min_ptr[count/4] = data[1] - data[3];
							} else {
								max_ptr[count/4] = data[1] + (data[1] * data[2]) / 100;
								min_ptr[count/4] = data[1] - (data[1] * data[3]) / 100;
							}
						} else {
							max_ptr[count/4] = INT_MAX;
							min_ptr[count/4] = INT_MIN;
						}
					}
					count++;
				}
				record = ini_info[i].key_value[j];
				index1 = j + 1;
			}
		}
	}
}

static int parser_get_tdf_value(char *str, int catalog)
{
	u32 i, ans, index = 0, flag = 0, count = 0, size = 0;
	char s[10] = {0};

	if (!str) {
		input_err(true, ilits->dev, "%s String is null\n", __func__);
		return -1;
	}

	size = strlen(str);
	for (i = 0, count = 0; i < size; i++) {
		if (str[i] == '.') {
			flag = 1;
			continue;
		}
		s[index++] = str[i];
		if (flag)
			count++;
	}
	ans = ili_katoi(s);

	/* Multiply by 100 to shift out of decimal point */
	if (catalog == SHORT_TEST) {
		if (count == 0)
			ans = ans * 100;
		else if (count == 1)
			ans = ans * 10;
	}

	return ans;
}

static int parser_get_u8_array(char *key, u8 *buf, u16 base, int len)
{
	char *s = key;
	char *pToken;
	int ret, conut = 0;
	long s_to_long = 0;

	if (strlen(s) == 0 || len <= 0) {
		input_err(true, ilits->dev, "%s Can't find any characters inside buffer\n", __func__);
		return -1;
	}

	/*
	 *	@base: The number base to use. The maximum supported base is 16. If base is
	 *	given as 0, then the base of the string is automatically detected with the
	 *	conventional semantics - If it begins with 0x the number will be parsed as a
	 *	hexadecimal (case insensitive), if it otherwise begins with 0, it will be
	 *	parsed as an octal number. Otherwise it will be parsed as a decimal.
	 */
	if (isspace_t((int)(unsigned char)*s) == 0) {
		while ((pToken = strsep(&s, ",")) != NULL) {
			ret = kstrtol(pToken, base, &s_to_long);
			if (ret == 0)
				buf[conut] = s_to_long;
			else
				input_info(true, ilits->dev, "%s convert string too long, ret = %d\n", __func__, ret);
			conut++;

			if (conut >= len)
				break;
		}
	}

	return conut;
}

static int parser_get_int_data(char *section, char *keyname, char *rv, int rv_len)
{
	int len = 0;
	char value[512] = { 0 };

	if (rv == NULL || section == NULL || keyname == NULL) {
		input_err(true, ilits->dev, "%s Parameters are invalid\n", __func__);
		return -EINVAL;
	}

	/* return a white-space string if get nothing */
	if (parser_get_ini_key_value(section, keyname, value) < 0) {
		snprintf(rv, rv_len, "%s", value);
		return 0;
	}

	len = snprintf(rv, rv_len, "%s", value);
	return len;
}

/* Count the number of each line and assign the content to tmp buffer */
static int parser_get_ini_phy_line(char *data, char *buffer, int maxlen)
{
	int i = 0;
	int j = 0;
	int iRetNum = -1;
	char ch1 = '\0';

	for (i = 0, j = 0; i < maxlen; j++) {
		ch1 = data[j];
		iRetNum = j + 1;
		if (ch1 == '\n' || ch1 == '\r') {	/* line end */
			ch1 = data[j + 1];
			if (ch1 == '\n' || ch1 == '\r')
				iRetNum++;
			break;
		} else if (ch1 == 0x00) {
			//iRetNum = -1;
			break;	/* file end */
		}

		buffer[i++] = ch1;
	}

	buffer[i] = '\0';
	return iRetNum;
}

static char *parser_ini_str_trim_r(char *buf)
{
	int len, i;
	char *tmp = NULL;
	char x[512] = {0};
	char *y = NULL;
	char *empty = "";

	len = strlen(buf);

	if (len < sizeof(x)) {
		tmp = x;
		goto copy;
	}

	y = kzalloc(len, GFP_KERNEL);
	if (ERR_ALLOC_MEM(y)) {
		input_err(true, ilits->dev, "%s Failed to allocate tmp buf\n", __func__);
		return empty;
	}
	tmp = y;

copy:
	for (i = 0; i < len; i++) {
		if (buf[i] != ' ')
			break;
	}

	if (i < len)
		strncpy(tmp, (buf + i), (len - i));

	strncpy(buf, tmp, len);
	ipio_kfree((void **)&y);
	return buf;
}

static int parser_get_ini_phy_data(char *data, int fsize)
{
	int i, n = 0, ret = 0, banchmark_flag = 0, empty_section, nodetype_flag = 0;
	int offset = 0, isEqualSign = 0, scount = 0;
	char *ini_buf = NULL, *tmpSectionName = NULL;
	char M_CFG_SSL = '[';
	char M_CFG_SSR = ']';
/* char M_CFG_NIS = ':'; */
	char M_CFG_NTS = '#';
	char M_CFG_EQS = '=';

	if (data == NULL) {
		input_err(true, ilits->dev, "%s INI data is NULL\n", __func__);
		ret = -EINVAL;
		goto out;
	}

	ini_buf = kzalloc((PARSER_MAX_CFG_BUF + 1) * sizeof(char), GFP_KERNEL);
	if (ERR_ALLOC_MEM(ini_buf)) {
		input_err(true, ilits->dev, "%s Failed to allocate ini_buf memory, %ld\n", __func__, PTR_ERR(ini_buf));
		ret = -ENOMEM;
		goto out;
	}

	tmpSectionName = kzalloc((PARSER_MAX_CFG_BUF + 1) * sizeof(char), GFP_KERNEL);
	if (ERR_ALLOC_MEM(tmpSectionName)) {
		input_err(true, ilits->dev, "%s Failed to allocate tmpSectionName memory, %ld\n",
			__func__, PTR_ERR(tmpSectionName));
		ret = -ENOMEM;
		goto out;
	}

	memset(seq_item, 0, MP_TEST_ITEM * PARSER_MAX_KEY_NAME_LEN * sizeof(char));

	while (true) {
		banchmark_flag = 0;
		empty_section = 0;
		nodetype_flag = 0;
		if (g_ini_items > PARSER_MAX_KEY_NUM) {
			input_err(true, ilits->dev, "%s MAX_KEY_NUM: Out of length\n", __func__);
			goto out;
		}

		if (offset >= fsize)
			goto out;/*over size*/

		n = parser_get_ini_phy_line(data + offset, ini_buf, PARSER_MAX_CFG_BUF);
		if (n < 0) {
			input_err(true, ilits->dev, "%s End of Line\n", __func__);
			goto out;
		}

		offset += n;

		n = strlen(parser_ini_str_trim_r(ini_buf));

		if (n == 0 || ini_buf[0] == M_CFG_NTS)
			continue;

		/* Get section names */
		if (n > 2 && ((ini_buf[0] == M_CFG_SSL && ini_buf[n - 1] != M_CFG_SSR))) {
			input_err(true, ilits->dev, "%s Bad Section: %s\n", __func__, ini_buf);
			ret = -EINVAL;
			goto out;
		} else {
			if (ini_buf[0] == M_CFG_SSL) {
				ini_info[g_ini_items].section_len = n - 2;
				if (ini_info[g_ini_items].section_len > PARSER_MAX_KEY_NAME_LEN) {
					input_err(true, ilits->dev, "%s MAX_KEY_NAME_LEN: Out Of Length\n", __func__);
					ret = INI_ERR_OUT_OF_LINE;
					goto out;
				}

				if (scount > MAX_SECTION_NUM) {
					input_err(true, ilits->dev,
						"%s seq_item is over than its define (%d), abort\n", __func__, scount);
					ret = INI_ERR_OUT_OF_LINE;
					goto out;
				}

				ini_buf[n - 1] = 0x00;
				strncpy((char *)tmpSectionName, ini_buf + 1, (PARSER_MAX_CFG_BUF + 1) * sizeof(char));
				banchmark_flag = 0;
				nodetype_flag = 0;
				strncpy(seq_item[scount], tmpSectionName, PARSER_MAX_KEY_NAME_LEN);
				scount++;
				ILI_DBG("%s Section Name: %s, Len: %d, offset = %d\n",
					__func__, seq_item[scount], n - 2, offset);
				continue;
			}
		}

		/* copy section's name without square brackets to its real buffer */
		strncpy(ini_info[g_ini_items].section_name, tmpSectionName, (PARSER_MAX_KEY_NAME_LEN * sizeof(char)));
		ini_info[g_ini_items].section_len = strlen(tmpSectionName);

		isEqualSign = 0;
		for (i = 0; i < n; i++) {
			if (ini_buf[i] == M_CFG_EQS) {
				isEqualSign = i;
				break;
			}
			if (ini_buf[i] == M_CFG_SSL || ini_buf[i] == M_CFG_SSR) {
				empty_section = 1;
				break;
			}
		}

		if (isEqualSign == 0) {
			if (empty_section)
				continue;

			if (strstr(ini_info[g_ini_items].section_name, BENCHMARK_KEY_NAME) != NULL) {
				isEqualSign = -1;
				ini_info[g_ini_items].key_name_len = strlen(ini_info[g_ini_items].section_name);
				strncpy(ini_info[g_ini_items].key_name, ini_info[g_ini_items].section_name,
						(PARSER_MAX_KEY_NAME_LEN * sizeof(char)));
				ini_info[g_ini_items].key_val_len = n;
			} else if (strstr(ini_info[g_ini_items].section_name, NODE_TYPE_KEY_NAME) != NULL) {
				isEqualSign = -1;
				ini_info[g_ini_items].key_name_len = strlen(NODE_TYPE_KEY_NAME);
				strncpy(ini_info[g_ini_items].key_name, NODE_TYPE_KEY_NAME,
						(PARSER_MAX_KEY_NAME_LEN * sizeof(char)));
				ini_info[g_ini_items].key_val_len = n;
			} else {
				continue;
			}
		} else {
			ini_info[g_ini_items].key_name_len = isEqualSign;
			if (ini_info[g_ini_items].key_name_len > PARSER_MAX_KEY_NAME_LEN) {
				/* ret = CFG_ERR_OUT_OF_LEN; */
				input_err(true, ilits->dev, "%s MAX_KEY_NAME_LEN: Out Of Length\n", __func__);
				ret = INI_ERR_OUT_OF_LINE;
				goto out;
			}

			ipio_memcpy(ini_info[g_ini_items].key_name, ini_buf,
						ini_info[g_ini_items].key_name_len, PARSER_MAX_KEY_NAME_LEN);
			ini_info[g_ini_items].key_val_len = n - isEqualSign - 1;
		}

		if (ini_info[g_ini_items].key_val_len > PARSER_MAX_KEY_VALUE_LEN) {
			input_err(true, ilits->dev, "%s MAX_KEY_VALUE_LEN: Out Of Length\n", __func__);
			ret = INI_ERR_OUT_OF_LINE;
			goto out;
		}

		ipio_memcpy(ini_info[g_ini_items].key_value,
			   ini_buf + isEqualSign + 1, ini_info[g_ini_items].key_val_len, PARSER_MAX_KEY_VALUE_LEN);

		ILI_DBG("%s %s = %s\n", __func__, ini_info[g_ini_items].key_name,
			ini_info[g_ini_items].key_value);

		g_ini_items++;
	}
out:
	ipio_kfree((void **)&ini_buf);
	ipio_kfree((void **)&tmpSectionName);
	return ret;
}

static int ilitek_tddi_mp_ini_parser(const char *path)
{
	int i, ret = 0, fsize = 0;
	char *tmp = NULL;
	const struct firmware *ini = NULL;
	struct file *f = NULL;
	mm_segment_t old_fs;
	loff_t pos = 0;

	input_info(true, ilits->dev, "%s ini file path = %s\n", __func__, path);

	f = filp_open(path, O_RDONLY, 644);
	if (ERR_ALLOC_MEM(f)) {
		input_err(true, ilits->dev, "%s Failed to open ini file at %ld, try to request_firmware\n",
			__func__, PTR_ERR(f));
		f = NULL;
		path = ilits->md_ini_rq_path;
		input_info(true, ilits->dev, "%s request path = %s\n", __func__, path);
		if (request_firmware(&ini, path, ilits->dev) < 0) {
			input_err(true, ilits->dev, "%s Request ini file failed\n", __func__);
			return -EINVAL;
		}
	}

	if (f != NULL) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
		fsize = f->f_inode->i_size;
#else
		struct inode *inode;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 18, 0))
		inode = f->f_dentry->d_inode;
#else
		inode = f->f_path.dentry->d_inode;
#endif
		fsize = inode->i_size;
#endif
	} else {
		fsize = ini->size;
	}

	input_info(true, ilits->dev, "%s ini file size = %d\n", __func__, fsize);
	if (fsize <= 0) {
		input_err(true, ilits->dev, "%s The size of file is invaild\n", __func__);
		ret = -EINVAL;
		goto out;
	}

	tmp = vmalloc(fsize+1);
	if (ERR_ALLOC_MEM(tmp)) {
		input_err(true, ilits->dev, "%s Failed to allocate tmp memory, %ld\n", __func__, PTR_ERR(tmp));
		ret = -ENOMEM;
		goto out;
	}

	if (f != NULL) {
		old_fs = get_fs();
		set_fs(get_ds());
		vfs_read(f, tmp, fsize, &pos);
		set_fs(old_fs);
		tmp[fsize] = 0x0;
	} else {
		memcpy(tmp, ini->data, fsize);
	}

	g_ini_items = 0;

	/* Initialise ini strcture */
	for (i = 0; i < PARSER_MAX_KEY_NUM; i++) {
		memset(ini_info[i].section_name, 0, PARSER_MAX_KEY_NAME_LEN);
		memset(ini_info[i].key_name, 0, PARSER_MAX_KEY_NAME_LEN);
		memset(ini_info[i].key_value, 0, PARSER_MAX_KEY_VALUE_LEN);
		ini_info[i].section_len = 0;
		ini_info[i].key_name_len = 0;
		ini_info[i].key_val_len = 0;
	}

	/* change all characters to lower case */
	for (i = 0; i < fsize; i++)
		tmp[i] = tolower(tmp[i]);

	ret = parser_get_ini_phy_data(tmp, fsize);
	if (ret < 0) {
		input_err(true, ilits->dev, "%s Failed to get physical ini data, ret = %d\n", __func__, ret);
		goto out;
	}

	input_info(true, ilits->dev, "%s Parsed ini file done\n", __func__);
out:
	ipio_vfree((void **)&tmp);

	if (f != NULL)
		filp_close(f, NULL);
	else
		release_firmware(ini);

	return ret;
}

static void run_pixel_test(int index)
{
	int i, x, y;
	s32 *p_comb = frame_buf;

	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			int tmp[4] = { 0 }, max = 0;
			int shift = y * core_mp.xch_len;
			int centre = p_comb[shift + x];

			/*
			 * if its position is in corner, the number of point
			 * we have to minus is around 2 to 3.
			 */
			if (y == 0 && x == 0) {
				tmp[0] = Mathabs(centre - p_comb[(shift + 1) + x]);	/* down */
				tmp[1] = Mathabs(centre - p_comb[shift + (x + 1)]);	/* right */
			} else if (y == (core_mp.ych_len - 1) && x == 0) {
				tmp[0] = Mathabs(centre - p_comb[(shift - 1) + x]);	/* up */
				tmp[1] = Mathabs(centre - p_comb[shift + (x + 1)]);	/* right */
			} else if (y == 0 && x == (core_mp.xch_len - 1)) {
				tmp[0] = Mathabs(centre - p_comb[(shift + 1) + x]);	/* down */
				tmp[1] = Mathabs(centre - p_comb[shift + (x - 1)]);	/* left */
			} else if (y == (core_mp.ych_len - 1) && x == (core_mp.xch_len - 1)) {
				tmp[0] = Mathabs(centre - p_comb[(shift - 1) + x]);	/* up */
				tmp[1] = Mathabs(centre - p_comb[shift + (x - 1)]);	/* left */
			} else if (y == 0 && x != 0) {
				tmp[0] = Mathabs(centre - p_comb[(shift + 1) + x]);	/* down */
				tmp[1] = Mathabs(centre - p_comb[shift + (x - 1)]);	/* left */
				tmp[2] = Mathabs(centre - p_comb[shift + (x + 1)]);	/* right */
			} else if (y != 0 && x == 0) {
				tmp[0] = Mathabs(centre - p_comb[(shift - 1) + x]);	/* up */
				tmp[1] = Mathabs(centre - p_comb[shift + (x + 1)]);	/* right */
				tmp[2] = Mathabs(centre - p_comb[(shift + 1) + x]);	/* down */

			} else if (y == (core_mp.ych_len - 1) && x != 0) {
				tmp[0] = Mathabs(centre - p_comb[(shift - 1) + x]);	/* up */
				tmp[1] = Mathabs(centre - p_comb[shift + (x - 1)]);	/* left */
				tmp[2] = Mathabs(centre - p_comb[shift + (x + 1)]);	/* right */
			} else if (y != 0 && x == (core_mp.xch_len - 1)) {
				tmp[0] = Mathabs(centre - p_comb[(shift - 1) + x]);	/* up */
				tmp[1] = Mathabs(centre - p_comb[shift + (x - 1)]);	/* left */
				tmp[2] = Mathabs(centre - p_comb[(shift + 1) + x]);	/* down */
			} else {
				/* middle minus four directions */
				tmp[0] = Mathabs(centre - p_comb[(shift - 1) + x]);	/* up */
				tmp[1] = Mathabs(centre - p_comb[(shift + 1) + x]);	/* down */
				tmp[2] = Mathabs(centre - p_comb[shift + (x - 1)]);	/* left */
				tmp[3] = Mathabs(centre - p_comb[shift + (x + 1)]);	/* right */
			}

			max = tmp[0];

			for (i = 0; i < 4; i++) {
				if (tmp[i] > max)
					max = tmp[i];
			}

			tItems[index].buf[shift + x] = max;
		}
	}
}

static void run_untouch_p2p_test(int index)
{
	int x, y;
	s32 *p_comb = frame_buf;

	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			int shift = y * core_mp.xch_len;

			if (p_comb[shift + x] > tItems[index].max_buf[shift + x])
				tItems[index].max_buf[shift + x] = p_comb[shift + x];

			if (p_comb[shift + x] < tItems[index].min_buf[shift + x])
				tItems[index].min_buf[shift + x] = p_comb[shift + x];

			tItems[index].buf[shift + x] =
				tItems[index].max_buf[shift + x] - tItems[index].min_buf[shift + x];
		}
	}
}

static int run_open_test(int index)
{
	int i, x, y, k, ret = 0;
	int border_x[] = {-1, 0, 1, 1, 1, 0, -1, -1};
	int border_y[] = {-1, -1, -1, 0, 1, 1, 1, 0};
	s32 *p_comb = frame_buf;

	if (ipio_strcmp(tItems[index].desp, "open test(integration)") == 0) {
		for (i = 0; i < core_mp.frame_len; i++)
			tItems[index].buf[i] = p_comb[i];
	} else if (ipio_strcmp(tItems[index].desp, "open test(cap)") == 0) {
		/*
		 * Each result is getting from a 3 by 3 grid depending on where the centre location is.
		 * So if the centre is at corner, the number of node grabbed from a grid will be different.
		 */
		for (y = 0; y < core_mp.ych_len; y++) {
			for (x = 0; x < core_mp.xch_len; x++) {
				int sum = 0, avg = 0, count = 0;
				int shift = y * core_mp.xch_len;
				int centre = p_comb[shift + x];

				for (k = 0; k < 8; k++) {
					if (((y + border_y[k] >= 0) && (y + border_y[k] < core_mp.ych_len)) &&
					((x + border_x[k] >= 0) && (x + border_x[k] < core_mp.xch_len))) {
						count++;
						sum += p_comb[(y + border_y[k]) * core_mp.xch_len + (x + border_x[k])];
					}
				}

				avg = (sum + centre) / (count + 1);	/* plus 1 because of centre */
				tItems[index].buf[shift + x] = (centre * 100) / avg;
			}
		}
	}
	return ret;
}

static void run_tx_rx_delta_test(int index)
{
	int x, y;
	s32 *p_comb = frame_buf;

	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			int shift = y * core_mp.xch_len;

			/* Tx Delta */
			if (y != (core_mp.ych_len - 1))
				core_mp.tx_delta_buf[shift + x] = Mathabs(p_comb[shift + x] - p_comb[(shift + 1) + x]);

			/* Rx Delta */
			if (x != (core_mp.xch_len - 1))
				core_mp.rx_delta_buf[shift + x] = Mathabs(p_comb[shift + x] - p_comb[shift + (x + 1)]);
		}
	}
}

static char *get_date_time_str(void)
{
	struct timespec now_time;
	struct rtc_time rtc_now_time;
	static char time_data_buf[128] = { 0 };

	getnstimeofday(&now_time);
	rtc_time_to_tm(now_time.tv_sec, &rtc_now_time);
	snprintf(time_data_buf, sizeof(time_data_buf), "%04d%02d%02d-%02d%02d%02d",
		(rtc_now_time.tm_year + 1900), rtc_now_time.tm_mon + 1,
		rtc_now_time.tm_mday, rtc_now_time.tm_hour, rtc_now_time.tm_min,
		rtc_now_time.tm_sec);

	return time_data_buf;
}

static void mp_print_csv_header(char *csv, int *csv_len, int *csv_line, int file_size)
{
	int i, seq, tmp_len = *csv_len, tmp_line = *csv_line;

	/* header must has 19 line*/
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len),
			"==============================================================================\n");
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len),
			"ILITek C-TP Utility V%s	%x : Driver Sensor Test\n", DRIVER_VERSION, core_mp.chip_pid);
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "Confidentiality Notice:\n");
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len),
			"Any information of this tool is confidential and privileged.\n");
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "@ ILI TECHNOLOGY CORP. All Rights Reserved.\n");
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len),
			"==============================================================================\n");
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "Firmware Version ,0x%x\n", core_mp.fw_ver);
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "Panel information ,XCH=%d, YCH=%d\n",
				core_mp.xch_len, core_mp.ych_len);
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "INI Release Version ,%s\n", core_mp.ini_ver);
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "INI Release Date ,%s\n", core_mp.ini_date);
	tmp_line++;
	tmp_line++;
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "Test Item:\n");
	tmp_line++;

	for (seq = 0; seq < ri.count; seq++) {
		i = ri.index[seq];
		tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "	  ---%s\n", tItems[i].desp);
		tmp_line++;
	}

	while (tmp_line < 19) {
		tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "\n");
		tmp_line++;
	}

	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len),
			"==============================================================================\n");

	*csv_len = tmp_len;
	*csv_line = tmp_line;
}

static void mp_print_csv_tail(char *csv, int *csv_len, int file_size)
{
	int i, seq, tmp_len = *csv_len;

	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len),
			"==============================================================================\n");
	tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "Result_Summary			\n");

	for (seq = 0; seq < ri.count; seq++) {
		i = ri.index[seq];
		if (tItems[i].item_result == MP_DATA_PASS) {
			tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "	  {%s}	   ,OK\n",
					tItems[i].desp);
		} else {
			tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "	  {%s}	   ,NG\n",
					tItems[i].desp);
		}
	}

	*csv_len = tmp_len;
}

static void mp_print_csv_cdc_cmd(char *csv, int *csv_len, int index, int file_size)
{
	int i, slen = 0, tmp_len = *csv_len, size;
	char str[128] = {0};
	char *open_sp_cmd[] = {"open dac", "open raw1", "open raw2", "open raw3"};
	char *open_c_cmd[] = {"open cap1 dac", "open cap1 raw"};
	char *name = tItems[index].desp;

	if (ipio_strcmp(name, "open test(integration)_sp") == 0) {
		size = ARRAY_SIZE(open_sp_cmd);
		for (i = 0; i < size; i++) {
			slen = parser_get_int_data("pv5_4 command", open_sp_cmd[i], str, sizeof(str));
			if (slen < 0)
				input_err(true, ilits->dev, "%s Failed to get CDC command %s from ini\n",
					__func__, open_sp_cmd[i]);
			else
				tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "%s = ,%s\n",
						open_sp_cmd[i], str);
		}
	} else if (ipio_strcmp(name, "open test_c") == 0) {
		size = ARRAY_SIZE(open_c_cmd);
		for (i = 0; i < size; i++) {
			slen = parser_get_int_data("pv5_4 command", open_c_cmd[i], str, sizeof(str));
			if (slen < 0)
				input_err(true, ilits->dev, "%s Failed to get CDC command %s from ini\n",
					__func__, open_sp_cmd[i]);
			else
				tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "%s = ,%s\n",
						open_c_cmd[i], str);
		}
	} else {
		slen = parser_get_int_data("pv5_4 command", name, str, sizeof(str));
		if (slen < 0)
			input_err(true, ilits->dev, "%s Failed to get CDC command %s from ini\n", __func__, name);
		else
			tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "CDC command = ,%s\n", str);

		/* Print short parameters */
		if (ipio_strcmp(name, "short test") == 0)
			tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "Variation = ,%d\n",
					short_para.variation);

		/* Print td second command */
		if (core_mp.td_retry && (ipio_strcmp(name, "peak to peak_td (lcm off)") == 0)) {
			name = "peak to peak_td (lcm off)_2";
			parser_get_int_data("pv5_4 command", name, str, sizeof(str));
			tmp_len += snprintf(csv + tmp_len, (file_size - tmp_len), "CDC command 2 = ,%s\n", str);
		}
	}
	*csv_len = tmp_len;
}

static void mp_compare_cdc_show_result(int index, s32 *tmp, char *csv,
				int *csv_len, int type, s32 *max_ts,
				s32 *min_ts, const char *desp, int file_zise)
{
	int x, y, tmp_len = *csv_len;
	int mp_result = MP_DATA_PASS;

	if (ERR_ALLOC_MEM(tmp)) {
		input_err(true, ilits->dev, "%s The data of test item is null (%p)\n", __func__, tmp);
		mp_result = -EMP_INVAL;
		goto out;
	}

	/* print X raw only */
	for (x = 0; x < core_mp.xch_len; x++) {
		if (x == 0) {
			DUMP("\n %s ", desp);
			tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "\n	   %s ,", desp);
		}
		DUMP("  X_%d	,", (x+1));
		tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "	 X_%d  ,", (x+1));
	}

	DUMP("\n");
	tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "\n");

	for (y = 0; y < core_mp.ych_len; y++) {
		DUMP("  Y_%d	,", (y+1));
		tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "	 Y_%d  ,", (y+1));

		for (x = 0; x < core_mp.xch_len; x++) {
			int shift = y * core_mp.xch_len + x;

			/* In Short teset, we only identify if its value is low than min threshold. */
			if (tItems[index].catalog == SHORT_TEST) {
				if (tmp[shift] < min_ts[shift]) {
					DUMP(" #%7d ", tmp[shift]);
					tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "#%7d,", tmp[shift]);
					mp_result = MP_DATA_FAIL;
				} else {
					DUMP(" %7d ", tmp[shift]);
					tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), " %7d, ",
							tmp[shift]);
				}
				continue;
			}

			if ((tmp[shift] <= max_ts[shift] && tmp[shift] >= min_ts[shift]) || (type != TYPE_JUGE)) {
				if ((tmp[shift] == INT_MAX || tmp[shift] == INT_MIN) && (type == TYPE_BENCHMARK)) {
					DUMP("%s", "BYPASS,");
					tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "BYPASS,");
				} else {
					DUMP(" %7d ", tmp[shift]);
					tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), " %7d, ",
							tmp[shift]);
				}
			} else {
				if (tmp[shift] > max_ts[shift]) {
					DUMP(" *%7d ", tmp[shift]);
					tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "*%7d,", tmp[shift]);
				} else {
					DUMP(" #%7d ", tmp[shift]);
					tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "#%7d,", tmp[shift]);
				}
				mp_result = MP_DATA_FAIL;
			}
		}
		DUMP("\n");
		tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "\n");
	}

out:
	if (type == TYPE_JUGE) {
		if (mp_result == MP_DATA_PASS) {
			pr_info("\n Result : PASS\n");
			tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "Result : PASS\n");
		} else {
			pr_info("\n Result : FAIL\n");
			tmp_len += snprintf(csv + tmp_len, (file_zise - tmp_len), "Result : FAIL\n");
		}
	}
	*csv_len = tmp_len;
}

#define ABS(a, b) ((a > b) ? (a - b) : (b - a))
#define ADDR(x, y) ((y * core_mp.xch_len) + (x))

static int compare_charge(s32 *charge_rate, int x, int y, s32 *inNodeType,
		int Charge_AA, int Charge_Border, int Charge_Notch)
{
	int OpenThreadhold, tempY, tempX, ret, k;
	int sx[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
	int sy[8] = {-1, -1, -1, 0, 0, 1, 1, 1};

	ret = charge_rate[ADDR(x, y)];

	/*Setting Threadhold from node type	 */
	if (charge_rate[ADDR(x, y)] == 0)
		return ret;
	else if ((inNodeType[ADDR(x, y)] & AA_Area) == AA_Area)
		OpenThreadhold = Charge_AA;
	else if ((inNodeType[ADDR(x, y)] & Border_Area) == Border_Area)
		OpenThreadhold = Charge_Border;
	else if ((inNodeType[ADDR(x, y)] & Notch) == Notch)
		OpenThreadhold = Charge_Notch;
	else
		return ret;

	/* compare carge rate with 3*3 node */
	/* by pass => 1.no compare 2.corner 3.Skip_Micro 4.full open fail node */
	for (k = 0; k < 8; k++) {
		tempX = x + sx[k];
		tempY = y + sy[k];

		/*out of range */
		if ((tempX < 0) || (tempX >= core_mp.xch_len) || (tempY < 0) || (tempY >= core_mp.ych_len))
			continue;

		if ((inNodeType[ADDR(tempX, tempY)] == NO_COMPARE) ||
				((inNodeType[ADDR(tempX, tempY)] & Round_Corner) == Round_Corner) ||
		((inNodeType[ADDR(tempX, tempY)] & Skip_Micro) == Skip_Micro) || charge_rate[ADDR(tempX, tempY)] == 0)
			continue;

		if ((charge_rate[ADDR(tempX, tempY)] - charge_rate[ADDR(x, y)]) > OpenThreadhold)
			return OpenThreadhold;
	}
	return ret;
}

static int full_open_rate_compare(s32 *full_open, s32 *cbk, int x, int y, s32 inNodeType, int full_open_rate)
{
	int ret = true;

	if ((inNodeType == NO_COMPARE) || ((inNodeType & Round_Corner) == Round_Corner))
		return true;

	if (full_open[ADDR(x, y)] < (cbk[ADDR(x, y)] * full_open_rate / 100))
		ret = false;

	return ret;
}

static s32 open_sp_formula(int dac, int raw, int tvch, int tvcl)
{
	s32 ret = 0;
	u16 id = core_mp.chip_id;

	if (id == ILI9881_CHIP) {
		ret = ((dac * 10000 * 161 / 100) - (16384 / 2 - raw) * 20000 * 7 /
				16384 * 36 / 10) / (tvch - tvcl) / 2;
	} else {
		ret = ((dac * 10000 * 131 / 100) - (16384 / 2 - raw) * 20000 * 7 /
				16384 * 36 / 10) / (tvch - tvcl) / 2;
	}
	return ret;
}

static s32 open_c_formula(int inCap1DAC, int inCap1Raw, int accuracy)
{
	s32 inCap1Value = 0;

	u16 id = core_mp.chip_id;
	u8 type = core_mp.chip_type;

	int inFoutRange = 16384;
	int inFoutRange_half = 8192;
	int inVadc_range = 36;
	int inVbk = 39;
	int inCbk_step = open_para.cbk_step;/* from mp.ini */
	int inCint = open_para.cint;/* from mp.ini */
	int inVdrv = open_para.tvch - open_para.tvcl;/* from mp.ini */
	int inGain = open_para.gain;/*  from mp.ini */
	int inMagnification = 10;
	int inPartDac = 0;
	int inPartRaw = 0;

	if ((inCbk_step == 0) || (inCint == 0)) {
		if (id == ILI9881_CHIP) {
			if ((type == ILI_N) || (type == ILI_O)) {
				inCbk_step = 32;
				inCint = 70;
			}
		} else if (id == ILI9882_CHIP) {
			if (type == ILI_N) {
				inCbk_step = 42;
				inCint = 70;
			} else if (type == ILI_H) {
				inCbk_step = 42;
				inCint = 69;
			}
		} else if (id == ILI7807_CHIP) {
			if (type == ILI_Q) {
				inCbk_step = 28;
				inCint = 70;
			} else if (type == ILI_S) {
				inCbk_step = 38;
				inCint = 66;
				inVbk = 42;
				inVdrv = inVdrv / 10;
				inGain = inGain / 10;

			} else if (type == ILI_V) {
				inCbk_step = 28;
				inCint = 70;
			}
		}
	}

	inPartDac = (inCap1DAC * inCbk_step * inVbk / 2);
	inPartRaw = ((inCap1Raw - inFoutRange_half) * inVadc_range * inCint * 10 / inFoutRange);

	if (accuracy)
		inCap1Value = ((inPartDac + inPartRaw) * 10) / inVdrv / inMagnification / inGain;
	else
		inCap1Value = (inPartDac + inPartRaw) / inVdrv / inMagnification / inGain;

	return inCap1Value;
}

static void allnode_open_cdc_result(int index, int *buf, int *dac, int *raw)
{
	int i;
	char *desp = tItems[index].desp;
	char str[32] = {0};
	int accuracy = 0;

	if (ipio_strcmp(desp, "open test(integration)_sp") == 0) {
		for (i = 0; i < core_mp.frame_len; i++)
			buf[i] = open_sp_formula(dac[i], raw[i], open_para.tvch, open_para.tvcl);
	} else if (ipio_strcmp(desp, "open test_c") == 0) {

		if (parser_get_int_data(desp, "accuracy", str, sizeof(str)) > 0)
			accuracy = ili_katoi(str);

		for (i = 0; i < core_mp.frame_len; i++)
			buf[i] = open_c_formula(dac[i], raw[i], accuracy);
	}
}

static int codeToOhm(s32 *ohm, s32 *Code, u16 *v_tdf, u16 *h_tdf)
{
	u16 id = core_mp.chip_id;
	u8 type = core_mp.chip_type;

	int inTVCH = short_para.tvch;
	int inTVCL = short_para.tvcl;
	int inVariation = short_para.variation;
	int inTDF1 = 0;
	int inTDF2 = 0;
	int inCint = short_para.cint;
	int inRinternal = short_para.rinternal;
	s32 temp = 0;
	int j = 0;

	if (core_mp.isLongV) {
		inTDF1 = *v_tdf;
		inTDF2 = *(v_tdf + 1);
	} else {
		inTDF1 = *h_tdf;
		inTDF2 = *(h_tdf + 1);
	}

	if (inVariation == 0)
		inVariation = 100;

	if ((inCint == 0) ||  (inRinternal == 0)) {
		if (id == ILI9881_CHIP) {
			if ((type == ILI_N) || (type == ILI_O)) {
				inRinternal = 1915;
				inCint = 70;
			}
		} else if (id == ILI9882_CHIP) {
			if (type == ILI_N) {
				inRinternal = 1354;
				inCint = 70;
			} else if (type == ILI_H) {
				inRinternal = 1354;
				inCint = 69;
			}
		} else if (id == ILI7807_CHIP) {
			if (type == ILI_Q) {
				inRinternal = 1500;
				inCint = 70;
			} else if (type == ILI_S) {
				inRinternal = 1500;
				inCint = 66;
				inTVCH = inTVCH/10;
				inTVCL = inTVCL/10;
			} else if (type == ILI_V) {
				inRinternal = 1500;
				inCint = 70;
			}
		}
	}
	for (j = 0; j < core_mp.frame_len; j++) {
		if (Code[j] == 0) {
			input_err(true, ilits->dev, "%s code is invalid\n", __func__);
		} else {
			temp = ((inTVCH - inTVCL) * inVariation * (inTDF1 - inTDF2) *
					(1 << 12) / (9 * Code[j] * inCint)) * 1000;
			temp = (temp - inRinternal) / 1000;
		}
		ohm[j] = temp;
	}

	/* Unit = M Ohm */
	return temp;

}

static int short_test(int index, int frame_index)
{
	u32 pid = core_mp.chip_pid >> 8;
	int j = 0, ret = 0;
	u16 v_tdf[2] = {0};
	u16 h_tdf[2] = {0};
	char str[32] = {0};

	v_tdf[0] = tItems[index].v_tdf_1;
	v_tdf[1] = tItems[index].v_tdf_2;
	h_tdf[0] = tItems[index].h_tdf_1;
	h_tdf[1] = tItems[index].h_tdf_2;

	parser_get_int_data("short test", "tvch", str, sizeof(str));
	short_para.tvch = ili_katoi(str);

	parser_get_int_data("short test", "tvcl", str, sizeof(str));
	short_para.tvcl = ili_katoi(str);

	parser_get_int_data("short test", "variation", str, sizeof(str));
	short_para.variation = ili_katoi(str);

	parser_get_int_data("short test", "cint", str, sizeof(str));
	short_para.cint = ili_katoi(str);

	parser_get_int_data("short test", "rinternal", str, sizeof(str));
	short_para.rinternal = ili_katoi(str);

	/* 9881N, 9881O, 7807Q, 7807S not support cbk_step and cint read from mp.ini */
	if ((pid != 0x988117) && (pid != 0x988118) && (pid != 0x78071A) && (pid != 0x78071C)) {
		if ((short_para.cint == 0) || (short_para.rinternal == 0)) {
			input_err(true, ilits->dev, "%s Failed to get short parameter", __func__);
			core_mp.lost_parameter = true;
			return -1;
		}
	}

	input_info(true, ilits->dev,
		"%s TVCH = %d, TVCL = %d, Variation = %d, V_TDF1 = %d, V_TDF2 = %d, H_TDF1 = %d, H_TDF2 = %d, Cint = %d, Rinternal = %d\n",
		__func__, short_para.tvch, short_para.tvcl, short_para.variation, tItems[index].v_tdf_1,
		tItems[index].v_tdf_2, tItems[index].h_tdf_1, tItems[index].h_tdf_2, short_para.cint,
		 short_para.rinternal);

	if (core_mp.protocol_ver >= PROTOCOL_VER_540) {
		/* Calculate code to ohm and save to tItems[index].buf */
		ili_dump_data(frame_buf, 10, core_mp.frame_len, core_mp.xch_len, "Short Raw 1");
		codeToOhm(&tItems[index].buf[frame_index * core_mp.frame_len], frame_buf, v_tdf, h_tdf);
		ili_dump_data(&tItems[index].buf[frame_index * core_mp.frame_len], 10,
			core_mp.frame_len, core_mp.xch_len, "Short Ohm 1");
	} else {
		for (j = 0; j < core_mp.frame_len; j++)
			tItems[index].buf[frame_index * core_mp.frame_len + j] = frame_buf[j];
	}

	return ret;
}

static int allnode_key_cdc_data(int index)
{
	int i, ret = 0, len = 0;
	int inDACp = 0, inDACn = 0;
	u8 cmd[3] = {0};
	u8 *ori = NULL;

	len = core_mp.key_len * 2;

	ILI_DBG("%s Read key's length = %d\n", __func__, len);
	ILI_DBG("%s core_mp.key_len = %d\n", __func__, core_mp.key_len);

	if (len <= 0) {
		input_err(true, ilits->dev, "%s Length is invalid\n", __func__);
		ret = -1;
		goto out;
	}

	/* CDC init */
	cmd[0] = P5_X_SET_CDC_INIT;
	cmd[1] = tItems[index].cmd;
	cmd[2] = 0;

	// /* Allocate a buffer for the original */
	ori = kcalloc(len, sizeof(u8), GFP_KERNEL);
	if (ERR_ALLOC_MEM(ori)) {
		input_err(true, ilits->dev, "%s Failed to allocate ori mem (%ld)\n", __func__, PTR_ERR(ori));
		ret = -1;
		goto out;
	}
	ret = ilits->wrapper(cmd, sizeof(cmd), ori, len, ON, ON);
	if (ret < 0) {
		input_err(true, ilits->dev, "%s  fail to get cdc data\n", __func__);
		goto out;
	}
	ili_dump_data(ori, 8, len, 0, "Key CDC original");

	if (key_buf == NULL) {
		key_buf = kcalloc(core_mp.key_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(key_buf)) {
			input_err(true, ilits->dev, "%s Failed to allocate FrameBuffer mem (%ld)\n",
				__func__, PTR_ERR(key_buf));
			goto out;
		}
	} else {
		memset(key_buf, 0x0, core_mp.key_len);
	}

	/* Convert original data to the physical one in each node */
	for (i = 0; i < core_mp.frame_len; i++) {
		if (tItems[index].cmd == CMD_KEY_DAC) {
			/* DAC - P */
			if (((ori[(2 * i) + 1] & 0x80) >> 7) == 1) {
				/* Negative */
				inDACp = 0 - (int)(ori[(2 * i) + 1] & 0x7F);
			} else {
				inDACp = ori[(2 * i) + 1] & 0x7F;
			}

			/* DAC - N */
			if (((ori[(1 + (2 * i)) + 1] & 0x80) >> 7) == 1) {
				/* Negative */
				inDACn = 0 - (int)(ori[(1 + (2 * i)) + 1] & 0x7F);
			} else {
				inDACn = ori[(1 + (2 * i)) + 1] & 0x7F;
			}

			key_buf[i] = (inDACp + inDACn) / 2;
		}
	}
	ili_dump_data(key_buf, 32, core_mp.frame_len, core_mp.xch_len, "Key CDC combined data");

out:
	ipio_kfree((void **)&ori);
	return ret;
}

static int mp_cdc_get_pv5_4_command(u8 *cmd, int len, int index)
{
	int slen = 0;
	char str[128] = {0};
	char *key = tItems[index].desp;

	if (core_mp.td_retry && (ipio_strcmp(key, "peak to peak_td (lcm off)") == 0))
		key = "peak to peak_td (lcm off)_2";

	slen = parser_get_int_data("pv5_4 command", key, str, sizeof(str));
	if (slen < 0)
		return -1;

	if (parser_get_u8_array(str, cmd, 16, len) < 0)
		return -1;

	return 0;
}

static int mp_cdc_init_cmd_common(u8 *cmd, int len, int index)
{
	int ret = 0;

	if (core_mp.protocol_ver >= PROTOCOL_VER_540) {
		core_mp.cdc_len = 15;
		return mp_cdc_get_pv5_4_command(cmd, len, index);
	}

	cmd[0] = P5_X_SET_CDC_INIT;
	cmd[1] = tItems[index].cmd;
	cmd[2] = 0;

	core_mp.cdc_len = 3;

	if (ipio_strcmp(tItems[index].desp, "open test(integration)") == 0)
		cmd[2] = 0x2;
	if (ipio_strcmp(tItems[index].desp, "open test(cap)") == 0)
		cmd[2] = 0x3;

	if (tItems[index].catalog == PEAK_TO_PEAK_TEST) {
		cmd[2] = ((tItems[index].frame_count & 0xff00) >> 8);
		cmd[3] = tItems[index].frame_count & 0xff;
		cmd[4] = 0;

		core_mp.cdc_len = 5;

		if (ipio_strcmp(tItems[index].desp, "noise peak to peak(cut panel)") == 0)
			cmd[4] = 0x1;

		ILI_DBG("%s P2P CMD: %d,%d,%d,%d,%d\n",
			__func__, cmd[0], cmd[1], cmd[2], cmd[3], cmd[4]);
	}

	return ret;
}

static int allnode_open_cdc_data(int mode, int *buf)
{
	int i = 0, ret = 0, len = 0;
	int inDACp = 0, inDACn = 0;
	u8 cmd[15] = {0};
	u8 *ori = NULL;
	char str[128] = {0};
	char *key[] = {"open dac", "open raw1", "open raw2", "open raw3",
			"open cap1 dac", "open cap1 raw"};

	/* Multipling by 2 is due to the 16 bit in each node */
	len = (core_mp.xch_len * core_mp.ych_len * 2) + 2;

	ILI_DBG("%s Read X/Y Channel length = %d, mode = %d\n", __func__, len, mode);

	if (len <= 2) {
		input_err(true, ilits->dev, "%s Length is invalid\n", __func__);
		ret = -EMP_INVAL;
		goto out;
	}

	/* CDC init. Read command from ini file */
	if (parser_get_int_data("pv5_4 command", key[mode], str, sizeof(str)) < 0) {
		input_err(true, ilits->dev, "%s Failed to parse PV54 command, ret = %d\n", __func__, ret);
		ret = -EMP_PARSE;
		goto out;
	}

	parser_get_u8_array(str, cmd, 16, sizeof(cmd));

	ili_dump_data(cmd, 8, sizeof(cmd), 0, "Open SP command");

	/* Allocate a buffer for the original */
	ori = kcalloc(len, sizeof(u8), GFP_KERNEL);
	if (ERR_ALLOC_MEM(ori)) {
		input_err(true, ilits->dev, "%s Failed to allocate ori, (%ld)\n", __func__, PTR_ERR(ori));
		ret = -EMP_NOMEM;
		goto out;
	}

	/* Get original frame(cdc) data */
	if (ilits->wrapper(cmd, core_mp.cdc_len, ori, len, ON, ON) < 0) {
		input_err(true, ilits->dev, "%s Failed to get cdc data\n", __func__);
		ret = -EMP_GET_CDC;
		goto out;
	}

	ili_dump_data(ori, 8, len, 0, "Open SP CDC original");

	/* Convert original data to the physical one in each node */
	for (i = 0; i < core_mp.frame_len; i++) {
		if ((mode == 0) || (mode == 4)) {
			/* DAC - P */
			if (((ori[(2 * i) + 1] & 0x80) >> 7) == 1) {
				/* Negative */
				inDACp = 0 - (int)(ori[(2 * i) + 1] & 0x7F);
			} else {
				inDACp = ori[(2 * i) + 1] & 0x7F;
			}

			/* DAC - N */
			if (((ori[(1 + (2 * i)) + 1] & 0x80) >> 7) == 1) {
				/* Negative */
				inDACn = 0 - (int)(ori[(1 + (2 * i)) + 1] & 0x7F);
			} else {
				inDACn = ori[(1 + (2 * i)) + 1] & 0x7F;
			}

			buf[i] = inDACp + inDACn;
		} else {
			/* H byte + L byte */
			s32 tmp = (ori[(2 * i) + 1] << 8) + ori[(1 + (2 * i)) + 1];

			if ((tmp & 0x8000) == 0x8000)
				buf[i] = tmp - 65536;
			else
				buf[i] = tmp;

		}
	}
	ili_dump_data(buf, 10, core_mp.frame_len,  core_mp.xch_len, "Open SP CDC combined");
out:

	ipio_kfree((void **)&ori);
	return ret;
}

static int allnode_peak_to_peak_cdc_data(int index)
{
	int i, k, ret = 0, len = 0, rd_frame_num = 1, cmd_len = 0;
	u8 cmd[15] = {0};
	u8 *ori = NULL;

	/* Multipling by 2 is due to the 16 bit in each node */
	len = (core_mp.frame_len * 2) + 2;

	ILI_DBG("%s Read X/Y Channel length = %d\n", __func__, len);

	if (len <= 2) {
		input_err(true, ilits->dev, "%s Length is invalid\n", __func__);
		ret = -EMP_INVAL;
		goto out;
	}

	memset(cmd, 0xFF, sizeof(cmd));

	/* Allocate a buffer for the original */
	ori = kcalloc(len, sizeof(u8), GFP_KERNEL);
	if (ERR_ALLOC_MEM(ori)) {
		input_err(true, ilits->dev, "%s Failed to allocate ori, (%ld)\n", __func__, PTR_ERR(ori));
		ret = -EMP_NOMEM;
		goto out;
	}

	if (tItems[index].bch_mrk_multi)
		rd_frame_num = tItems[index].bch_mrk_frm_num - 1;

	if (frm_buf == NULL) {
		frm_buf = (s32 **)kzalloc(tItems[index].bch_mrk_frm_num * sizeof(s32 *), GFP_KERNEL);
		if (ERR_ALLOC_MEM(frm_buf)) {
			input_err(true, ilits->dev, "%s Failed to allocate frm_buf mem (%ld)\n",
				__func__, PTR_ERR(frm_buf));
			ret = -EMP_NOMEM;
			goto out;
		}
		for (i = 0 ; i < tItems[index].bch_mrk_frm_num ; i++) {
			frm_buf[i] = (s32 *)kzalloc(core_mp.frame_len * sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(frm_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate frm_buf[%d] mem (%ld)\n",
					__func__, i, PTR_ERR(frm_buf));
				ret = -EMP_NOMEM;
				goto out;
			}
		}
	}

	/* CDC init */
	if (mp_cdc_init_cmd_common(cmd, sizeof(cmd), index) < 0) {
		input_err(true, ilits->dev, "%s Failed to get cdc command\n", __func__);
		ret = -EMP_CMD;
		goto out;
	}

	ili_dump_data(cmd, 8, core_mp.cdc_len, 0, "Mutual CDC command");

	for (k = 0; k < rd_frame_num; k++) {
		if (k == 0)
			cmd_len = core_mp.cdc_len;
		else
			cmd_len = 0;
		memset(ori, 0, len);
		/* Get original frame(cdc) data */
		if (ilits->wrapper(cmd, cmd_len, ori, len, ON, ON) < 0) {
			input_err(true, ilits->dev, "%s Failed to get cdc data\n", __func__);
			ret = -EMP_GET_CDC;
			goto out;
		}

		ili_dump_data(ori, 8, len, 0, "Mutual CDC original");

		/* Convert original data to the physical one in each node */
		for (i = 0; i < core_mp.frame_len; i++) {
			/* H byte + L byte */
			s32 tmp = (ori[(2 * i) + 1] << 8) + ori[(1 + (2 * i)) + 1];

			if ((tmp & 0x8000) == 0x8000)
				frm_buf[k][i] = tmp - 65536;
			else
				frm_buf[k][i] = tmp;

			// multiple case frame3 = frame1 - frame2
			if (tItems[index].bch_mrk_multi && rd_frame_num == k + 1)
				frm_buf[k+1][i] = frm_buf[k-1][i] - frm_buf[k][i];
		}
	}

	if (tItems[index].bch_mrk_multi) {
		ili_dump_data(frm_buf[0], 32, core_mp.frame_len, core_mp.xch_len, "Mutual CDC combined[0]/frame1");
		ili_dump_data(frm_buf[1], 32, core_mp.frame_len, core_mp.xch_len, "Mutual CDC combined[1]/frame2");
		ili_dump_data(frm_buf[2], 32, core_mp.frame_len, core_mp.xch_len, "Mutual CDC combined[2]/frame3");
	} else {
		ili_dump_data(frm_buf[0], 32, core_mp.frame_len, core_mp.xch_len, "Mutual CDC combined[0]/frame1");
	}

out:
	ipio_kfree((void **)&ori);
	return ret;
}

static int allnode_mutual_cdc_data(int index)
{
	int i, ret = 0, len = 0;
	int inDACp = 0, inDACn = 0;
	u8 cmd[15] = {0};
	u8 *ori = NULL;

	/* Multipling by 2 is due to the 16 bit in each node */
	len = (core_mp.frame_len * 2) + 2;

	ILI_DBG("%s Read X/Y Channel length = %d\n", __func__, len);

	if (len <= 2) {
		input_err(true, ilits->dev, "%s Length is invalid\n", __func__);
		ret = -EMP_INVAL;
		goto out;
	}

	memset(cmd, 0xFF, sizeof(cmd));

	/* CDC init */
	if (mp_cdc_init_cmd_common(cmd, sizeof(cmd), index) < 0) {
		input_err(true, ilits->dev, "%s Failed to get cdc command\n", __func__);
		ret = -EMP_CMD;
		goto out;
	}

	ili_dump_data(cmd, 8, core_mp.cdc_len, 0, "Mutual CDC command");

	/* Allocate a buffer for the original */
	ori = kcalloc(len, sizeof(u8), GFP_KERNEL);
	if (ERR_ALLOC_MEM(ori)) {
		input_err(true, ilits->dev, "%s Failed to allocate ori, (%ld)\n", __func__, PTR_ERR(ori));
		ret = -EMP_NOMEM;
		goto out;
	}

	/* Get original frame(cdc) data */
	if (ilits->wrapper(cmd, core_mp.cdc_len, ori, len, ON, ON) < 0) {
		input_err(true, ilits->dev, "%s Failed to get cdc data\n", __func__);
		ret = -EMP_GET_CDC;
		goto out;
	}

	ili_dump_data(ori, 8, len, 0, "Mutual CDC original");

	if (frame_buf == NULL) {
		frame_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(frame_buf)) {
			input_err(true, ilits->dev, "%s Failed to allocate FrameBuffer mem (%ld)\n",
				__func__, PTR_ERR(frame_buf));
			ret = -EMP_NOMEM;
			goto out;
		}
	} else {
		memset(frame_buf, 0x0, core_mp.frame_len);
	}

	/* Convert original data to the physical one in each node */
	for (i = 0; i < core_mp.frame_len; i++) {
		if (ipio_strcmp(tItems[index].desp, "calibration data(dac)") == 0) {
			/* DAC - P */
			if (((ori[(2 * i) + 1] & 0x80) >> 7) == 1) {
				/* Negative */
				inDACp = 0 - (int)(ori[(2 * i) + 1] & 0x7F);
			} else {
				inDACp = ori[(2 * i) + 1] & 0x7F;
			}

			/* DAC - N */
			if (((ori[(1 + (2 * i)) + 1] & 0x80) >> 7) == 1) {
				/* Negative */
				inDACn = 0 - (int)(ori[(1 + (2 * i)) + 1] & 0x7F);
			} else {
				inDACn = ori[(1 + (2 * i)) + 1] & 0x7F;
			}

			frame_buf[i] = (inDACp + inDACn) / 2;
		} else {
			/* H byte + L byte */
			s32 tmp = (ori[(2 * i) + 1] << 8) + ori[(1 + (2 * i)) + 1];

			if ((tmp & 0x8000) == 0x8000)
				frame_buf[i] = tmp - 65536;
			else
				frame_buf[i] = tmp;

			if (ipio_strcmp(tItems[index].desp, "raw data(no bk)") == 0 ||
					ipio_strcmp(tItems[index].desp, "raw data(no bk) (lcm off)") == 0) {
				frame_buf[i] -= core_mp.no_bk_shift;
			}
		}
	}

	ili_dump_data(frame_buf, 32, core_mp.frame_len, core_mp.xch_len, "Mutual CDC combined");

out:
	ipio_kfree((void **)&ori);
	return ret;
}

static void compare_MaxMin_result(int index, s32 *data)
{
	int x, y;

	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			int shift = y * core_mp.xch_len;

			if (tItems[index].catalog == UNTOUCH_P2P)
				return;
			else if (tItems[index].catalog == TX_RX_DELTA) {
				/* Tx max/min comparison */
				if (core_mp.tx_delta_buf[shift + x] < data[shift + x])
					core_mp.tx_max_buf[shift + x] = data[shift + x];

				if (core_mp.tx_delta_buf[shift + x] > data[shift + x])
					core_mp.tx_min_buf[shift + x] = data[shift + x];

				/* Rx max/min comparison */
				if (core_mp.rx_delta_buf[shift + x] < data[shift + x])
					core_mp.rx_max_buf[shift + x] = data[shift + x];

				if (core_mp.rx_delta_buf[shift + x] > data[shift + x])
					core_mp.rx_min_buf[shift + x] = data[shift + x];
			} else {
				if (tItems[index].max_buf[shift + x] < data[shift + x])
					tItems[index].max_buf[shift + x] = data[shift + x];

				if (tItems[index].min_buf[shift + x] > data[shift + x])
					tItems[index].min_buf[shift + x] = data[shift + x];
			}
		}
	}
}

static int create_mp_test_frame_buffer(int index, int frame_count)
{
	int i;

	ILI_DBG("%s Create MP frame buffers (index = %d), count = %d\n",
			__func__, index, frame_count);

	if (tItems[index].catalog == TX_RX_DELTA) {
		if (core_mp.tx_delta_buf == NULL) {
			core_mp.tx_delta_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(core_mp.tx_delta_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate tx_delta_buf mem\n", __func__);
				ipio_kfree((void **)&core_mp.tx_delta_buf);
				return -ENOMEM;
			}
		}

		if (core_mp.rx_delta_buf == NULL) {
			core_mp.rx_delta_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(core_mp.rx_delta_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate rx_delta_buf mem\n", __func__);
				ipio_kfree((void **)&core_mp.rx_delta_buf);
				return -ENOMEM;
			}
		}

		if (core_mp.tx_max_buf == NULL) {
			core_mp.tx_max_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(core_mp.tx_max_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate tx_max_buf mem\n", __func__);
				ipio_kfree((void **)&core_mp.tx_max_buf);
				return -ENOMEM;
			}
		}

		if (core_mp.tx_min_buf == NULL) {
			core_mp.tx_min_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(core_mp.tx_min_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate tx_min_buf mem\n", __func__);
				ipio_kfree((void **)&core_mp.tx_min_buf);
				return -ENOMEM;
			}
		}

		if (core_mp.rx_max_buf == NULL) {
			core_mp.rx_max_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(core_mp.rx_max_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate rx_max_buf mem\n", __func__);
				ipio_kfree((void **)&core_mp.rx_max_buf);
				return -ENOMEM;
			}
		}

		if (core_mp.rx_min_buf == NULL) {
			core_mp.rx_min_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(core_mp.rx_min_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate rx_min_buf mem\n", __func__);
				ipio_kfree((void **)&core_mp.rx_min_buf);
				return -ENOMEM;
			}
		}
	} else {
		if (tItems[index].buf == NULL) {
			tItems[index].buf = vmalloc(frame_count * core_mp.frame_len * sizeof(s32));
			if (ERR_ALLOC_MEM(tItems[index].buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate buf mem\n", __func__);
				ipio_kfree((void **)&tItems[index].buf);
				return -ENOMEM;
			}
		}

		if (tItems[index].result_buf == NULL) {
			tItems[index].result_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(tItems[index].result_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate result_buf mem\n", __func__);
				ipio_kfree((void **)&tItems[index].result_buf);
				return -ENOMEM;
			}
		}

		if (tItems[index].max_buf == NULL) {
			tItems[index].max_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(tItems[index].max_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate max_buf mem\n", __func__);
				ipio_kfree((void **)&tItems[index].max_buf);
				return -ENOMEM;
			}
		}

		if (tItems[index].min_buf == NULL) {
			tItems[index].min_buf = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
			if (ERR_ALLOC_MEM(tItems[index].min_buf)) {
				input_err(true, ilits->dev, "%s Failed to allocate min_buf mem\n", __func__);
				ipio_kfree((void **)&tItems[index].min_buf);
				return -ENOMEM;
			}
		}

		if (tItems[index].spec_option == BENCHMARK) {
			if (tItems[index].bch_mrk_max == NULL) {
				tItems[index].bch_mrk_max =
					(s32 **)kzalloc(tItems[index].bch_mrk_frm_num * sizeof(s32 *), GFP_KERNEL);
				if (ERR_ALLOC_MEM(tItems[index].bch_mrk_max)) {
					input_err(true, ilits->dev,
						"%s Failed to allocate bch_mrk_max mem\n", __func__);
					ipio_kfree((void **)&tItems[index].bch_mrk_max);
					return -ENOMEM;
				}

				for (i = 0; i < tItems[index].bch_mrk_frm_num; i++) {
					tItems[index].bch_mrk_max[i] =
						(s32 *)kzalloc(core_mp.frame_len * sizeof(s32), GFP_KERNEL);
					if (ERR_ALLOC_MEM(tItems[index].bch_mrk_max[i])) {
						input_err(true, ilits->dev,
							"%s Failed to allocate bch_mrk_max[%d] mem\n", __func__, i);
						ipio_kfree((void **)&tItems[index].bch_mrk_max[i]);
						return -ENOMEM;
					}
				}
			}

			if (tItems[index].bch_mrk_min == NULL) {
				tItems[index].bch_mrk_min =
					(s32 **)kzalloc(tItems[index].bch_mrk_frm_num * sizeof(s32 *), GFP_KERNEL);
				if (ERR_ALLOC_MEM(tItems[index].bch_mrk_min)) {
					input_err(true, ilits->dev, "%s Failed to allocate bch_mrk_min mem\n",
						__func__);
					ipio_kfree((void **)&tItems[index].bch_mrk_min);
					return -ENOMEM;
				}
				for (i = 0; i < tItems[index].bch_mrk_frm_num; i++) {
					tItems[index].bch_mrk_min[i] =
						(s32 *)kzalloc(core_mp.frame_len * sizeof(s32), GFP_KERNEL);
					if (ERR_ALLOC_MEM(tItems[index].bch_mrk_min[i])) {
						input_err(true, ilits->dev,
							"%s Failed to allocate bch_mrk_min[%d] mem\n", __func__, i);
						ipio_kfree((void **)&tItems[index].bch_mrk_min[i]);
						return -ENOMEM;
					}
				}
			}

			if (tItems[index].bench_mark_max == NULL) {
				tItems[index].bench_mark_max = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
				if (ERR_ALLOC_MEM(tItems[index].bench_mark_max)) {
					input_err(true, ilits->dev, "%s Failed to allocate bench_mark_max mem\n",
						__func__);
					ipio_kfree((void **)&tItems[index].bench_mark_max);
					return -ENOMEM;
				}
			}
			if (tItems[index].bench_mark_min == NULL) {
				tItems[index].bench_mark_min = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
				if (ERR_ALLOC_MEM(tItems[index].bench_mark_min)) {
					input_err(true, ilits->dev, "%s Failed to allocate bench_mark_min mem\n",
						__func__);
					ipio_kfree((void **)&tItems[index].bench_mark_min);
					return -ENOMEM;
				}
			}
		}
	}
	return 0;
}

static int pin_test(int index)
{
	int ret = 0;
	u8 cmd[5] = {0};

	input_info(true, ilits->dev, "%s PIN test start", __func__);
	input_info(true, ilits->dev, "%s test_int_pin = 0x%x\n", __func__, tItems[index].test_int_pin);
	input_info(true, ilits->dev, "%s int_pulse_test = 0x%x\n", __func__, tItems[index].int_pulse_test);
	input_info(true, ilits->dev, "%s delay_time = 0x%x\n", __func__, tItems[index].delay_time);

	if (tItems[index].test_int_pin == ENABLE) {
		/* test HIGH level*/
		cmd[0] = tItems[index].cmd;
		cmd[1] = 0x1;
		ret = ilits->wrapper(cmd, 2, NULL, 0, OFF, OFF);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Write command failed\n", __func__);
			ret = -EMP_CMD;
			goto out;
		}

		ret =  ilits->detect_int_stat(false);
		if (ret < 0) {
			ret = -EMP_INT;
			goto out;
		}

		/* test LOW level*/
		cmd[1] = 0x0;
		ret = ilits->wrapper(cmd, 2, NULL, 0, OFF, OFF);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Write command failed\n", __func__);
			ret = -EMP_CMD;
			goto out;
		}

		ret =  ilits->detect_int_stat(false);
		if (ret < 0) {
			ret = -EMP_INT;
			goto out;
		}
	}

	if (tItems[index].int_pulse_test == ENABLE) {

		input_info(true, ilits->dev, "%s MP IRQ Rising Trigger Test\n", __func__);
		cmd[1] = 0x2;
		cmd[2] = tItems[index].delay_time;

		ili_irq_unregister();
		ret = ili_irq_register(IRQF_TRIGGER_RISING);
		if (ret < 0) {
			ret = -EMP_INT;
			goto out;
		}

		atomic_set(&ilits->cmd_int_check, ENABLE);
		ret = ilits->wrapper(cmd, 3, NULL, 0, OFF, OFF);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Write command failed\n", __func__);
			ret = -EMP_CMD;
			goto out;
		}

		ret = ilits->detect_int_stat(false);
		if (ret < 0) {
			ret = -EMP_INT;
			goto out;
		}

		input_info(true, ilits->dev, "%s MP IRQ Falling Trigger Test\n", __func__);
		ili_irq_unregister();
		ret = ili_irq_register(IRQF_TRIGGER_FALLING);
		if (ret < 0) {
			ret = -EMP_INT;
			goto out;
		}

		atomic_set(&ilits->cmd_int_check, ENABLE);

		ret = ilits->wrapper(cmd, 3, NULL, 0, OFF, OFF);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Write command failed\n", __func__);
			ret = -EMP_CMD;
			goto out;
		}

		ret = ilits->detect_int_stat(false);
		if (ret < 0) {
			ret = -EMP_INT;
			goto out;
		}
	}

	tItems[index].item_result = MP_DATA_PASS;

out:
	if (ret < 0)
		tItems[index].item_result = MP_DATA_FAIL;

	input_info(true, ilits->dev, "%s Change to defualt IRQ trigger type\n", __func__);
	ili_irq_unregister();
	ili_irq_register(ilits->irq_tirgger_type);
	atomic_set(&ilits->cmd_int_check, DISABLE);

	return ret;
}

static int mutual_test(int index)
{
	int i = 0, j = 0, x = 0, y = 0, ret = 0, get_frame_cont = 1;

	ILI_DBG("%s index = %d, desp = %s, Frame Count = %d\n",
		__func__, index, tItems[index].desp, tItems[index].frame_count);

	/*
	 * We assume that users who are calling the test forget to config frame count
	 * as 1, so we just help them to set it up.
	 */
	if (tItems[index].frame_count <= 0) {
		input_err(true, ilits->dev, "%s Frame count is zero, which is at least set as 1\n", __func__);
		tItems[index].frame_count = 1;
	}

	ret = create_mp_test_frame_buffer(index, tItems[index].frame_count);
	if (ret < 0) {
		ret = -EMP_NOMEM;
		goto out;
	}

	/* Init Max/Min buffer */
	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			if (tItems[i].catalog == TX_RX_DELTA) {
				core_mp.tx_max_buf[y * core_mp.xch_len + x] = INT_MIN;
				core_mp.rx_max_buf[y * core_mp.xch_len + x] = INT_MIN;
				core_mp.tx_min_buf[y * core_mp.xch_len + x] = INT_MAX;
				core_mp.rx_min_buf[y * core_mp.xch_len + x] = INT_MAX;
			} else {
				tItems[index].max_buf[y * core_mp.xch_len + x] = INT_MIN;
				tItems[index].min_buf[y * core_mp.xch_len + x] = INT_MAX;
			}
		}
	}

	if (tItems[index].catalog != PEAK_TO_PEAK_TEST)
		get_frame_cont = tItems[index].frame_count;

	if (tItems[index].spec_option == BENCHMARK) {
		parser_ini_benchmark(tItems[index].bench_mark_max, tItems[index].bench_mark_min,
			tItems[index].type_option, tItems[index].desp, core_mp.frame_len, BENCHMARK_KEY_NAME);
		dump_benchmark_data(tItems[index].bench_mark_max, tItems[index].bench_mark_min);
	}

	for (i = 0; i < get_frame_cont; i++) {
		ret = allnode_mutual_cdc_data(index);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to initialise CDC data, %d\n", __func__, ret);
			goto out;
		}
		switch (tItems[index].catalog) {
		case PIXEL:
			run_pixel_test(index);
			break;
		case UNTOUCH_P2P:
			run_untouch_p2p_test(index);
			break;
		case OPEN_TEST:
			run_open_test(index);
			break;
		case TX_RX_DELTA:
			run_tx_rx_delta_test(index);
			break;
		case SHORT_TEST:
			ret = short_test(index, i);
			if (ret < 0) {
				ret = -EMP_PARA_NULL;
				goto out;
			}
			break;
		default:
			for (j = 0; j < core_mp.frame_len; j++)
				tItems[index].buf[i * core_mp.frame_len + j] = frame_buf[j];
			break;
		}
		compare_MaxMin_result(index, &tItems[index].buf[i * core_mp.frame_len]);
	}

out:
	return ret;
}

static int  peak_to_peak_test(int index)
{
	int i = 0, j = 0, x = 0, y = 0, ret = 0;
	char benchmark_str[128] = {0};

	ILI_DBG("%s index = %d, desp = %s bch_mrk_frm_num = %d\n",
		__func__, index, tItems[index].desp, tItems[index].bch_mrk_frm_num);

	ret = create_mp_test_frame_buffer(index, tItems[index].bch_mrk_frm_num);
	if (ret < 0) {
		ret = -EMP_NOMEM;
		goto out;
	}

	if (tItems[index].spec_option == BENCHMARK) {
		for (i = 0 ; i < tItems[index].bch_mrk_frm_num ; i++) {
			if (tItems[index].bch_mrk_multi)
				snprintf(benchmark_str, sizeof(benchmark_str), "%s%d", BENCHMARK_KEY_NAME, i+1);
			else
				snprintf(benchmark_str, sizeof(benchmark_str), "%s", BENCHMARK_KEY_NAME);
			parser_ini_benchmark(tItems[index].bch_mrk_max[i], tItems[index].bch_mrk_min[i],
				tItems[index].type_option, tItems[index].desp, core_mp.frame_len, benchmark_str);

			dump_benchmark_data(tItems[index].bch_mrk_max[i], tItems[index].bch_mrk_min[i]);
		}
	}

	/* Init Max/Min buffer */
	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			tItems[index].max_buf[y * core_mp.xch_len + x] = INT_MIN;
			tItems[index].min_buf[y * core_mp.xch_len + x] = INT_MAX;
		}
	}

	ret = allnode_peak_to_peak_cdc_data(index);
	if (ret < 0) {
		input_err(true, ilits->dev, "%s Failed to initialise CDC data, %d\n", __func__, ret);
		goto out;
	}
	for (i = 0; i < tItems[index].bch_mrk_frm_num; i++) {
		for (j = 0; j < core_mp.frame_len; j++)
			tItems[index].buf[i * core_mp.frame_len + j] = frm_buf[i][j];

		compare_MaxMin_result(index, &tItems[index].buf[i * core_mp.frame_len]);
	}
out:
	return ret;
}


static int open_test_sp(int index)
{
	struct mp_test_P540_open *open;
	int i = 0, x = 0, y = 0, ret = 0, addr = 0;
	int Charge_AA = 0, Charge_Border = 0, Charge_Notch = 0, full_open_rate = 0;
	char str[512] = {0};

	ILI_DBG("%s index = %d, desp = %s, Frame Count = %d\n",
		__func__, index, tItems[index].desp, tItems[index].frame_count);

	/*
	 * We assume that users who are calling the test forget to config frame count
	 * as 1, so we just help them to set it up.
	 */
	if (tItems[index].frame_count <= 0) {
		input_err(true, ilits->dev, "%s Frame count is zero, which is at least set as 1\n", __func__);
		tItems[index].frame_count = 1;
	}

	open = kzalloc(tItems[index].frame_count * sizeof(struct mp_test_P540_open), GFP_KERNEL);
	if (ERR_ALLOC_MEM(open)) {
		input_err(true, ilits->dev, "%s Failed to allocate open mem (%ld)\n", __func__, PTR_ERR(open));
		ret = -EMP_NOMEM;
		goto out;
	}

	ret = create_mp_test_frame_buffer(index, tItems[index].frame_count);
	if (ret < 0) {
		ret = -EMP_NOMEM;
		goto out;
	}

	if (frame1_cbk700 == NULL) {
		frame1_cbk700 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(frame1_cbk700)) {
			input_err(true, ilits->dev, "%s Failed to allocate frame1_cbk700 buffer\n", __func__);
			return -EMP_NOMEM;
		}
	} else {
		memset(frame1_cbk700, 0x0, core_mp.frame_len);
	}

	if (frame1_cbk250 == NULL) {
		frame1_cbk250 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(frame1_cbk250)) {
			input_err(true, ilits->dev, "%s Failed to allocate frame1_cbk250 buffer\n", __func__);
			ipio_kfree((void **)&frame1_cbk700);
			return -EMP_NOMEM;
		}
	} else {
		memset(frame1_cbk250, 0x0, core_mp.frame_len);
	}

	if (frame1_cbk200 == NULL) {
		frame1_cbk200 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(frame1_cbk200)) {
			input_err(true, ilits->dev, "%s Failed to allocate cbk buffer\n", __func__);
			ipio_kfree((void **)&frame1_cbk700);
			ipio_kfree((void **)&frame1_cbk250);
			return -EMP_NOMEM;
		}
	} else {
		memset(frame1_cbk200, 0x0, core_mp.frame_len);
	}

	tItems[index].node_type = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	if (ERR_ALLOC_MEM(tItems[index].node_type)) {
		input_err(true, ilits->dev, "%s Failed to allocate node_type FRAME buffer\n", __func__);
		return -EMP_NOMEM;
	}

	/* Init Max/Min buffer */
	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			tItems[index].max_buf[y * core_mp.xch_len + x] = INT_MIN;
			tItems[index].min_buf[y * core_mp.xch_len + x] = INT_MAX;
		}
	}

	if (tItems[index].spec_option == BENCHMARK) {
		parser_ini_benchmark(tItems[index].bench_mark_max, tItems[index].bench_mark_min,
			tItems[index].type_option, tItems[index].desp, core_mp.frame_len, BENCHMARK_KEY_NAME);
		dump_benchmark_data(tItems[index].bench_mark_max, tItems[index].bench_mark_min);
	}

	parser_ini_nodetype(tItems[index].node_type, NODE_TYPE_KEY_NAME, core_mp.frame_len);
	dump_node_type_buffer(tItems[index].node_type, "node type");

	parser_get_int_data(tItems[index].desp, "charge_aa", str, sizeof(str));
	Charge_AA = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "charge_border", str, sizeof(str));
	Charge_Border = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "charge_notch", str, sizeof(str));
	Charge_Notch = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "full open", str, sizeof(str));
	full_open_rate = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "tvch", str, sizeof(str));
	open_para.tvch = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "tvcl", str, sizeof(str));
	open_para.tvcl = ili_katoi(str);

	ILI_DBG("%s AA = %d, Border = %d, Notch = %d, full_open_rate = %d, tvch = %d, tvcl = %d\n",
			__func__, Charge_AA, Charge_Border, Charge_Notch, full_open_rate,
			open_para.tvch, open_para.tvcl);

	for (i = 0; i < tItems[index].frame_count; i++) {
		open[i].tdf_700 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].tdf_250 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].tdf_200 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].cbk_700 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].cbk_250 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].cbk_200 = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].charg_rate = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].full_Open = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].dac = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	}

	for (i = 0; i < tItems[index].frame_count; i++) {
		ret = allnode_open_cdc_data(0, open[i].dac);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to get Open SP DAC data, %d\n", __func__, ret);
			goto out;
		}
		ret = allnode_open_cdc_data(1, open[i].tdf_700);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to get Open SP Raw1 data, %d\n", __func__, ret);
			goto out;
		}
		ret = allnode_open_cdc_data(2, open[i].tdf_250);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to get Open SP Raw2 data, %d\n", __func__, ret);
			goto out;
		}
		ret = allnode_open_cdc_data(3, open[i].tdf_200);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to get Open SP Raw3 data, %d\n", __func__, ret);
			goto out;
		}
		allnode_open_cdc_result(index, open[i].cbk_700, open[i].dac, open[i].tdf_700);
		allnode_open_cdc_result(index, open[i].cbk_250, open[i].dac, open[i].tdf_250);
		allnode_open_cdc_result(index, open[i].cbk_200, open[i].dac, open[i].tdf_200);

		addr = 0;

		/* record fist frame for debug */
		if (i == 0) {
			ipio_memcpy(frame1_cbk700, open[i].cbk_700, core_mp.frame_len * sizeof(s32),
					core_mp.frame_len * sizeof(s32));
			ipio_memcpy(frame1_cbk250, open[i].cbk_250, core_mp.frame_len * sizeof(s32),
					core_mp.frame_len * sizeof(s32));
			ipio_memcpy(frame1_cbk200, open[i].cbk_200, core_mp.frame_len * sizeof(s32),
					core_mp.frame_len * sizeof(s32));
		}

		ili_dump_data(open[i].cbk_700, 10, core_mp.frame_len, core_mp.xch_len, "cbk 700");
		ili_dump_data(open[i].cbk_250, 10, core_mp.frame_len, core_mp.xch_len, "cbk 250");
		ili_dump_data(open[i].cbk_200, 10, core_mp.frame_len, core_mp.xch_len, "cbk 200");

		for (y = 0; y < core_mp.ych_len; y++) {
			for (x = 0; x < core_mp.xch_len; x++) {
				open[i].charg_rate[addr] = open[i].cbk_250[addr] * 100 / open[i].cbk_700[addr];
				open[i].full_Open[addr] = open[i].cbk_700[addr] - open[i].cbk_200[addr];
				addr++;
			}
		}

		ili_dump_data(open[i].charg_rate, 10, core_mp.frame_len, core_mp.xch_len, "origin charge rate");
		ili_dump_data(open[i].full_Open, 10, core_mp.frame_len, core_mp.xch_len, "origin full open");

		addr = 0;
		for (y = 0; y < core_mp.ych_len; y++) {
			for (x = 0; x < core_mp.xch_len; x++) {
				if (full_open_rate_compare(open[i].full_Open, open[i].cbk_700, x, y,
				tItems[index].node_type[addr], full_open_rate) == false) {
					tItems[index].buf[(i * core_mp.frame_len) + addr] = 0;
					open[i].charg_rate[addr] = 0;
				}
				addr++;
			}
		}

		ili_dump_data(&tItems[index].buf[(i * core_mp.frame_len)], 10, core_mp.frame_len, core_mp.xch_len,
			"after full_open_rate_compare");

		addr = 0;
		for (y = 0; y < core_mp.ych_len; y++) {
			for (x = 0; x < core_mp.xch_len; x++) {
				tItems[index].buf[(i * core_mp.frame_len) + addr] =
					compare_charge(open[i].charg_rate, x, y, tItems[index].node_type,
					Charge_AA, Charge_Border, Charge_Notch);
				addr++;
			}
		}

		ili_dump_data(&tItems[index].buf[(i * core_mp.frame_len)], 10, core_mp.frame_len, core_mp.xch_len,
			"after compare charge rate");

		compare_MaxMin_result(index, &tItems[index].buf[(i * core_mp.frame_len)]);
	}

out:
	ipio_kfree((void **)&tItems[index].node_type);

	if (open != NULL) {
		for (i = 0; i < tItems[index].frame_count; i++) {
			ipio_kfree((void **)&open[i].tdf_700);
			ipio_kfree((void **)&open[i].tdf_250);
			ipio_kfree((void **)&open[i].tdf_200);
			ipio_kfree((void **)&open[i].cbk_700);
			ipio_kfree((void **)&open[i].cbk_250);
			ipio_kfree((void **)&open[i].cbk_200);
			ipio_kfree((void **)&open[i].charg_rate);
			ipio_kfree((void **)&open[i].full_Open);
			ipio_kfree((void **)&open[i].dac);
		}
		kfree(open);
		open = NULL;
	}

	return ret;
}

static int open_test_cap(int index)
{
	u32 pid = core_mp.chip_pid >> 8;
	struct mp_test_open_c *open;
	int i = 0, x = 0, y = 0, ret = 0, addr = 0;
	char str[512] = {0};

	ILI_DBG("%s index = %d, desp = %s, Frame Count = %d\n",
		__func__, index, tItems[index].desp, tItems[index].frame_count);

	if (tItems[index].frame_count <= 0) {
		input_err(true, ilits->dev, "%s Frame count is zero, which is at least set as 1\n", __func__);
		tItems[index].frame_count = 1;
	}

	open = kzalloc(tItems[index].frame_count * sizeof(struct mp_test_open_c), GFP_KERNEL);
	if (ERR_ALLOC_MEM(open)) {
		input_err(true, ilits->dev, "%s Failed to allocate open mem (%ld)\n", __func__, PTR_ERR(open));
		ret = -EMP_NOMEM;
		goto out;
	}

	if (create_mp_test_frame_buffer(index, tItems[index].frame_count) < 0) {
		ret = -EMP_NOMEM;
		goto out;
	}

	if (cap_dac == NULL) {
		cap_dac = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(cap_dac)) {
			input_err(true, ilits->dev, "%s Failed to allocate cap_dac buffer\n", __func__);
			return -EMP_NOMEM;
		}
	} else {
		memset(cap_dac, 0x0, core_mp.frame_len);
	}

	if (cap_raw == NULL) {
		cap_raw = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		if (ERR_ALLOC_MEM(cap_raw)) {
			input_err(true, ilits->dev, "%s Failed to allocate cap_raw buffer\n", __func__);
			ipio_kfree((void **)&cap_dac);
			return -EMP_NOMEM;
		}
	} else {
		memset(cap_raw, 0x0, core_mp.frame_len);
	}

	/* Init Max/Min buffer */
	for (y = 0; y < core_mp.ych_len; y++) {
		for (x = 0; x < core_mp.xch_len; x++) {
			tItems[index].max_buf[y * core_mp.xch_len + x] = INT_MIN;
			tItems[index].min_buf[y * core_mp.xch_len + x] = INT_MAX;
		}
	}

	if (tItems[index].spec_option == BENCHMARK) {
		parser_ini_benchmark(tItems[index].bench_mark_max, tItems[index].bench_mark_min,
				tItems[index].type_option, tItems[index].desp, core_mp.frame_len, BENCHMARK_KEY_NAME);
		dump_benchmark_data(tItems[index].bench_mark_max, tItems[index].bench_mark_min);
	}

	parser_get_int_data(tItems[index].desp, "gain", str, sizeof(str));
	open_para.gain = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "tvch", str, sizeof(str));
	open_para.tvch = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "tvcl", str, sizeof(str));
	open_para.tvcl = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "cbk_step", str, sizeof(str));
	open_para.cbk_step = ili_katoi(str);

	parser_get_int_data(tItems[index].desp, "cint", str, sizeof(str));
	open_para.cint = ili_katoi(str);

	/* 9881N, 9881O, 7807Q, 7807S not support cbk_step and cint read from mp.ini */
	if ((pid != 0x988117) && (pid != 0x988118) && (pid != 0x78071A) && (pid != 0x78071C)) {
		if ((open_para.cbk_step == 0) || (open_para.cint == 0)) {
			input_err(true, ilits->dev, "%s Failed to get open parameter", __func__);
			ret = -EMP_PARA_NULL;
			core_mp.lost_parameter = true;
			goto out;
		}
	}

	input_info(true, ilits->dev, "%s gain = %d, tvch = %d, tvcl = %d, cbk_step = %d, cint = %d\n",
		__func__, open_para.gain, open_para.tvch, open_para.tvcl, open_para.cbk_step, open_para.cint);
	for (i = 0; i < tItems[index].frame_count; i++) {
		open[i].cap_dac = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].cap_raw = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
		open[i].dcl_cap = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	}

	for (i = 0; i < tItems[index].frame_count; i++) {
		ret = allnode_open_cdc_data(4, open[i].cap_dac);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to get Open CAP DAC data, %d\n", __func__, ret);
			goto out;
		}
		ret = allnode_open_cdc_data(5, open[i].cap_raw);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to get Open CAP RAW data, %d\n", __func__, ret);
			goto out;
		}

		allnode_open_cdc_result(index, open[i].dcl_cap, open[i].cap_dac, open[i].cap_raw);

		/* record fist frame for debug */
		if (i == 0) {
			ipio_memcpy(cap_dac, open[i].cap_dac, core_mp.frame_len * sizeof(s32),
					core_mp.frame_len * sizeof(s32));
			ipio_memcpy(cap_raw, open[i].cap_raw, core_mp.frame_len * sizeof(s32),
					core_mp.frame_len * sizeof(s32));
		}

		ili_dump_data(open[i].dcl_cap, 10, core_mp.frame_len, core_mp.xch_len, "DCL_Cap");

		addr = 0;
		for (y = 0; y < core_mp.ych_len; y++) {
			for (x = 0; x < core_mp.xch_len; x++) {
				tItems[index].buf[(i * core_mp.frame_len) + addr] = open[i].dcl_cap[addr];
				addr++;
			}
		}
		compare_MaxMin_result(index, &tItems[index].buf[i * core_mp.frame_len]);
	}

out:
	if (open != NULL) {
		for (i = 0; i < tItems[index].frame_count; i++) {
			ipio_kfree((void **)&open[i].cap_dac);
			ipio_kfree((void **)&open[i].cap_raw);
			ipio_kfree((void **)&open[i].dcl_cap);
		}
		kfree(open);
		open = NULL;
	}

	return ret;
}

static int key_test(int index)
{
	int i, j = 0, ret = 0;

	ILI_DBG("%s Item = %s, Frame Count = %d\n",
		__func__, tItems[index].desp, tItems[index].frame_count);

	if (tItems[index].frame_count == 0) {
		input_err(true, ilits->dev, "%s Frame count is zero, which at least sets as 1\n", __func__);
		ret = -EINVAL;
		goto out;
	}

	ret = create_mp_test_frame_buffer(index, tItems[index].frame_count);
	if (ret < 0)
		goto out;

	for (i = 0; i < tItems[index].frame_count; i++) {
		ret = allnode_key_cdc_data(index);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to initialise CDC data, %d\n", __func__, ret);
			goto out;
		}

		for (j = 0; j < core_mp.key_len; j++)
			tItems[index].buf[j] = key_buf[j];
	}

	compare_MaxMin_result(index, tItems[index].buf);

out:
	return ret;
}

static int self_test(int index)
{
	input_err(true, ilits->dev, "%s TDDI has no self to be tested currently\n", __func__);
	return -1;
}

static int st_test(int index)
{
	input_err(true, ilits->dev, "%s ST Test is not supported by the driver\n", __func__);
	return -1;
}

static int mp_get_timing_info(void)
{
	int slen = 0;
	char str[256] = {0};
	u8 info[64] = {0};
	char *key = "timing_info_raw";

	core_mp.isLongV = 0;

	slen = parser_get_int_data("pv5_4 command", key, str, sizeof(str));
	if (slen < 0)
		return -1;

	if (parser_get_u8_array(str, info, 16, slen) < 0)
		return -1;

	core_mp.isLongV = info[6];

	input_info(true, ilits->dev, "%s DDI Mode = %s\n", __func__, (core_mp.isLongV ? "Long V" : "Long H"));

	return 0;
}

static int mp_test_data_sort_average(s32 *oringin_data, int index, s32 *avg_result)
{
	int i, j, k, x, y, len = 5, size;
	s32 u32temp;
	int u32up_frame, u32down_frame;
	s32 *u32sum_raw_data = NULL;
	s32 *u32data_buff = NULL;
	int ret = 0;

	if (tItems[index].frame_count <= 1) {
		ret = 0;
		goto out;
	}

	if (ERR_ALLOC_MEM(oringin_data)) {
		input_err(true, ilits->dev, "%s Input wrong address\n", __func__);
		ret = -ENOMEM;
		goto out;
	}

	u32data_buff = kcalloc(core_mp.frame_len * tItems[index].frame_count, sizeof(s32), GFP_KERNEL);
	if (ERR_ALLOC_MEM(u32data_buff)) {
		input_err(true, ilits->dev, "%s Failed to allocate u32data_buff FRAME buffer\n", __func__);
		ret = -ENOMEM;
		goto out;
	}

	u32sum_raw_data = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	if (ERR_ALLOC_MEM(u32data_buff)) {
		input_err(true, ilits->dev, "%s Failed to allocate u32sum_raw_data FRAME buffer\n", __func__);
		ret = -ENOMEM;
		goto out;
	}

	size = core_mp.frame_len * tItems[index].frame_count;
	for (i = 0; i < size; i++)
		u32data_buff[i] = oringin_data[i];

	u32up_frame = tItems[index].frame_count * tItems[index].highest_percentage / 100;
	u32down_frame = tItems[index].frame_count * tItems[index].lowest_percentage / 100;
	ILI_DBG("%s Up=%d, Down=%d -%s\n", __func__, u32up_frame, u32down_frame, tItems[index].desp);

	if (debug_en) {
		pr_cont("\n[Show Original frist%d and last%d node data]\n", len, len);
		for (i = 0; i < core_mp.frame_len; i++) {
			for (j = 0 ; j < tItems[index].frame_count ; j++) {
				if ((i < len) || (i >= (core_mp.frame_len-len)))
					pr_cont("%d,", u32data_buff[j * core_mp.frame_len + i]);
			}
			if ((i < len) || (i >= (core_mp.frame_len-len)))
				pr_cont("\n");
		}
	}

	for (i = 0; i < core_mp.frame_len; i++) {
		for (j = 0; j < tItems[index].frame_count-1; j++) {
			for (k = 0; k < (tItems[index].frame_count-1-j); k++) {
				x = i+k*core_mp.frame_len;
				y = i+(k+1)*core_mp.frame_len;
				if (*(u32data_buff+x) > *(u32data_buff+y)) {
					u32temp = *(u32data_buff+x);
					*(u32data_buff+x) = *(u32data_buff+y);
					*(u32data_buff+y) = u32temp;
				}
			}
		}
	}

	if (debug_en) {
		pr_cont("\n[After sorting frist%d and last%d node data]\n", len, len);
		for (i = 0; i < core_mp.frame_len; i++) {
			for (j = u32down_frame; j < tItems[index].frame_count - u32up_frame; j++) {
				if ((i < len) || (i >= (core_mp.frame_len - len)))
					pr_cont("%d,", u32data_buff[i + j * core_mp.frame_len]);
			}
			if ((i < len) || (i >= (core_mp.frame_len-len)))
				pr_cont("\n");
		}
	}

	for (i = 0 ; i < core_mp.frame_len ; i++) {
		u32sum_raw_data[i] = 0;
		for (j = u32down_frame; j < tItems[index].frame_count - u32up_frame; j++)
			u32sum_raw_data[i] += u32data_buff[i + j * core_mp.frame_len];

		avg_result[i] = u32sum_raw_data[i] / (tItems[index].frame_count - u32down_frame - u32up_frame);
	}

	if (debug_en) {
		pr_cont("\n[Average result frist%d and last%d node data]\n", len, len);
		for (i = 0; i < core_mp.frame_len; i++) {
			if ((i < len) || (i >= (core_mp.frame_len-len)))
				pr_cont("%d,", avg_result[i]);
		}
		if ((i < len) || (i >= (core_mp.frame_len-len)))
			pr_cont("\n");
	}

out:
	ipio_kfree((void **)&u32data_buff);
	ipio_kfree((void **)&u32sum_raw_data);
	return ret;
}

static void mp_compare_cdc_result(int index, s32 *tmp, s32 *max_ts, s32 *min_ts, int *result)
{
	int i;

	if (ERR_ALLOC_MEM(tmp)) {
		input_err(true, ilits->dev, "%s The data of test item is null (%p)\n", __func__, tmp);
		*result = MP_DATA_FAIL;
		return;
	}

	if (tItems[index].catalog == SHORT_TEST) {
		for (i = 0; i < core_mp.frame_len; i++) {
			if (tmp[i] < min_ts[i]) {
				*result = MP_DATA_FAIL;
				return;
			}
		}
	} else {
		for (i = 0; i < core_mp.frame_len; i++) {
			if (tmp[i] > max_ts[i] || tmp[i] < min_ts[i]) {
				ILI_DBG("%s Fail No.%d: max=%d, val=%d, min=%d\n",
					__func__, i, max_ts[i], tmp[i], min_ts[i]);
				*result = MP_DATA_FAIL;
				return;
			}
		}
	}
}

static int mp_compare_test_result(int index)
{
	int i, test_result = MP_DATA_PASS;
	s32 *max_threshold = NULL, *min_threshold = NULL;

	if (tItems[index].catalog == PIN_TEST)
		return tItems[index].item_result;

	max_threshold = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	if (ERR_ALLOC_MEM(max_threshold)) {
		input_err(true, ilits->dev, "%s Failed to allocate threshold FRAME buffer\n", __func__);
		test_result = MP_DATA_FAIL;
		goto out;
	}

	min_threshold = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	if (ERR_ALLOC_MEM(min_threshold)) {
		input_err(true, ilits->dev, "%s Failed to allocate threshold FRAME buffer\n", __func__);
		test_result = MP_DATA_FAIL;
		goto out;
	}

	/* Show test result as below */
	if (tItems[index].catalog == TX_RX_DELTA) {
		if (ERR_ALLOC_MEM(core_mp.rx_delta_buf) || ERR_ALLOC_MEM(core_mp.tx_delta_buf)) {
			input_err(true, ilits->dev, "%s This test item (%s) has no data inside its buffer\n",
				__func__, tItems[index].desp);
			test_result = MP_DATA_FAIL;
			goto out;
		}

		for (i = 0; i < core_mp.frame_len; i++) {
			max_threshold[i] = core_mp.TxDeltaMax;
			min_threshold[i] = core_mp.TxDeltaMin;
		}
		mp_compare_cdc_result(index, core_mp.tx_max_buf, max_threshold, min_threshold, &test_result);
		mp_compare_cdc_result(index, core_mp.tx_min_buf, max_threshold, min_threshold, &test_result);

		for (i = 0; i < core_mp.frame_len; i++) {
			max_threshold[i] = core_mp.RxDeltaMax;
			min_threshold[i] = core_mp.RxDeltaMin;
		}

		mp_compare_cdc_result(index, core_mp.rx_max_buf, max_threshold, min_threshold, &test_result);
		mp_compare_cdc_result(index, core_mp.rx_min_buf, max_threshold, min_threshold, &test_result);
	} else {
		if (ERR_ALLOC_MEM(tItems[index].buf) || ERR_ALLOC_MEM(tItems[index].max_buf) ||
				ERR_ALLOC_MEM(tItems[index].min_buf) || ERR_ALLOC_MEM(tItems[index].result_buf)) {
			input_err(true, ilits->dev, "%s This test item (%s) has no data inside its buffer\n",
				__func__, tItems[index].desp);
			test_result = MP_DATA_FAIL;
			goto out;
		}

		if (tItems[index].spec_option == BENCHMARK) {
			if (tItems[index].catalog == PEAK_TO_PEAK_TEST) {
				for (i = 0; i < core_mp.frame_len; i++) {
					max_threshold[i] = tItems[index].bch_mrk_max[0][i];
					min_threshold[i] = tItems[index].bch_mrk_min[0][i];
				}
			} else {
				for (i = 0; i < core_mp.frame_len; i++) {
					max_threshold[i] = tItems[index].bench_mark_max[i];
					min_threshold[i] = tItems[index].bench_mark_min[i];
				}
			}
		} else {
			for (i = 0; i < core_mp.frame_len; i++) {
				max_threshold[i] = tItems[index].max;
				min_threshold[i] = tItems[index].min;
			}
		}

		/* general result */
		if (tItems[index].trimmed_mean && tItems[index].catalog != PEAK_TO_PEAK_TEST) {
			mp_test_data_sort_average(tItems[index].buf, index, tItems[index].result_buf);
			mp_compare_cdc_result(index, tItems[index].result_buf, max_threshold, min_threshold,
				&test_result);
		} else {
			if (tItems[index].bch_mrk_multi) {
				for (i = 0; i < tItems[index].bch_mrk_frm_num; i++) {
					mp_compare_cdc_result(index, frm_buf[i], tItems[index].bch_mrk_max[i],
						tItems[index].bch_mrk_min[i], &test_result);
				}
			} else {
				mp_compare_cdc_result(index, tItems[index].max_buf, max_threshold, min_threshold,
						&test_result);
				mp_compare_cdc_result(index, tItems[index].min_buf, max_threshold, min_threshold,
						&test_result);
			}
		}
	}

out:
	ipio_kfree((void **)&max_threshold);
	ipio_kfree((void **)&min_threshold);
	if (frm_buf != NULL) {
		for (i = 0; i < tItems[index].bch_mrk_frm_num; i++)
			if (frm_buf[i] != NULL) {
				kfree(frm_buf[i]);
				frm_buf[i] = NULL;
			}
		kfree(frm_buf);
		frm_buf = NULL;
	}
	if (core_mp.all_pass == true)
		test_result = MP_DATA_PASS;
	tItems[index].item_result = test_result;
	return test_result;
}

static void mp_do_retry(int index, int count)
{
	if (count == 0) {
		input_info(true, ilits->dev, "%s Finish retry action\n", __func__);
		return;
	}

	input_info(true, ilits->dev, "%s retry = %d, item = %s\n", __func__, count, tItems[index].desp);

	tItems[index].do_test(index);

	if (mp_compare_test_result(index) < 0)
		return mp_do_retry(index, count - 1);
}

static int mp_show_result(bool lcm_on)
{
	int ret = MP_DATA_PASS, seq;
	int i, x, y, j, k = 0, csv_len = 0, pass_item_count = 0, line_count = 0, get_frame_cont = 1;
	s32 *max_threshold = NULL, *min_threshold = NULL;
	char *csv = NULL;
	char *ret_pass_name = NULL, *ret_fail_name = NULL;
	struct file *f = NULL;
	mm_segment_t fs;
	loff_t pos;

	csv = vmalloc(CSV_FILE_SIZE);
	if (ERR_ALLOC_MEM(csv)) {
		input_err(true, ilits->dev, "%s Failed to allocate CSV mem\n", __func__);
		ret = -EMP_NOMEM;
		goto fail_open;
	}

	max_threshold = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	min_threshold = kcalloc(core_mp.frame_len, sizeof(s32), GFP_KERNEL);
	if (ERR_ALLOC_MEM(max_threshold) || ERR_ALLOC_MEM(min_threshold)) {
		input_err(true, ilits->dev, "%s Failed to allocate threshold FRAME buffer\n", __func__);
		ret = -EMP_NOMEM;
		goto fail_open;
	}

	if (parser_get_ini_key_value("pv5_4 command", "date", core_mp.ini_date) < 0)
		ipio_memcpy(core_mp.ini_date, "Unknown", strlen("Unknown"), strlen("Unknown"));
	if (parser_get_ini_key_value("pv5_4 command", "version", core_mp.ini_ver) < 0)
		ipio_memcpy(core_mp.ini_ver, "Unknown", strlen("Unknown"), strlen("Unknown"));

	mp_print_csv_header(csv, &csv_len, &line_count, CSV_FILE_SIZE);

	for (seq = 0; seq < ri.count; seq++) {
		i = ri.index[seq];
		get_frame_cont = 1;

		if (tItems[i].item_result == MP_DATA_PASS) {
			pr_info("\n[%s],OK \n\n", tItems[i].desp);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "\n[%s],OK\n\n", tItems[i].desp);
		} else {
			pr_info("\n[%s],NG\n\n", tItems[i].desp);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "\n[%s],NG\n\n", tItems[i].desp);
		}

		if (tItems[i].catalog == PIN_TEST) {
			pr_info("Test INT Pin = %d\n", tItems[i].test_int_pin);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "Test INT Pin = %d\n",
				tItems[i].test_int_pin);
			pr_info("Pulse Test = %d\n", tItems[i].int_pulse_test);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "Pulse Test = %d\n",
				tItems[i].int_pulse_test);
			pr_info("Delay Time = %d\n", tItems[i].delay_time);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "Delay Time = %d\n",
				tItems[i].delay_time);
			continue;
		}

		mp_print_csv_cdc_cmd(csv, &csv_len, i, CSV_FILE_SIZE);

		pr_info("Frame count = %d\n", tItems[i].frame_count);
		csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "Frame count = %d\n",
			tItems[i].frame_count);

		if (tItems[i].trimmed_mean && tItems[i].catalog != PEAK_TO_PEAK_TEST) {
			pr_info("lowest percentage = %d\n", tItems[i].lowest_percentage);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "lowest percentage = %d\n",
				tItems[i].lowest_percentage);

			pr_info("highest percentage = %d\n", tItems[i].highest_percentage);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "highest percentage = %d\n",
				tItems[i].highest_percentage);
		}

		/* Show result of benchmark max and min */
		if (tItems[i].spec_option == BENCHMARK) {
			if (tItems[i].catalog == PEAK_TO_PEAK_TEST) {
				for (j = 0; j < core_mp.frame_len; j++) {
					max_threshold[j] = tItems[i].bch_mrk_max[0][j];
					min_threshold[j] = tItems[i].bch_mrk_min[0][j];
				}

				for (j = 0; j < tItems[i].bch_mrk_frm_num; j++) {
					char bench_name[128] = {0};

					snprintf(bench_name, (CSV_FILE_SIZE - csv_len), "Max_Bench%d", (j+1));
					mp_compare_cdc_show_result(i, tItems[i].bch_mrk_max[j], csv, &csv_len,
						TYPE_BENCHMARK, max_threshold, min_threshold,
						bench_name, CSV_FILE_SIZE);

					snprintf(bench_name, (CSV_FILE_SIZE - csv_len), "Min_Bench%d", (j+1));
					mp_compare_cdc_show_result(i, tItems[i].bch_mrk_min[j], csv, &csv_len,
						TYPE_BENCHMARK, max_threshold, min_threshold,
						bench_name, CSV_FILE_SIZE);
				}
			} else {
				for (j = 0; j < core_mp.frame_len; j++) {
					max_threshold[j] = tItems[i].bench_mark_max[j];
					min_threshold[j] = tItems[i].bench_mark_min[j];
				}
				mp_compare_cdc_show_result(i, tItems[i].bench_mark_max, csv, &csv_len, TYPE_BENCHMARK,
					max_threshold, min_threshold, "Max_Bench", CSV_FILE_SIZE);
				mp_compare_cdc_show_result(i, tItems[i].bench_mark_min, csv, &csv_len, TYPE_BENCHMARK,
					max_threshold, min_threshold, "Min_Bench", CSV_FILE_SIZE);
			}

		} else {
			for (j = 0; j < core_mp.frame_len; j++) {
				max_threshold[j] = tItems[i].max;
				min_threshold[j] = tItems[i].min;
			}

			pr_info("Max = %d\n", tItems[i].max);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "Max = %d\n", tItems[i].max);

			pr_info("Min = %d\n", tItems[i].min);
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "Min = %d\n", tItems[i].min);
		}

		if (ipio_strcmp(tItems[i].desp, "open test(integration)_sp") == 0) {
			mp_compare_cdc_show_result(i, frame1_cbk700, csv, &csv_len, TYPE_NO_JUGE, max_threshold,
				min_threshold, "frame1 cbk700", CSV_FILE_SIZE);
			mp_compare_cdc_show_result(i, frame1_cbk250, csv, &csv_len, TYPE_NO_JUGE, max_threshold,
				min_threshold, "frame1 cbk250", CSV_FILE_SIZE);
			mp_compare_cdc_show_result(i, frame1_cbk200, csv, &csv_len, TYPE_NO_JUGE, max_threshold,
				min_threshold, "frame1 cbk200", CSV_FILE_SIZE);
		}

		if (ipio_strcmp(tItems[i].desp, "open test_c") == 0) {
			mp_compare_cdc_show_result(i, cap_dac, csv, &csv_len, TYPE_NO_JUGE, max_threshold,
				min_threshold, "CAP_DAC", CSV_FILE_SIZE);
			mp_compare_cdc_show_result(i, cap_raw, csv, &csv_len, TYPE_NO_JUGE, max_threshold,
				min_threshold, "CAP_RAW", CSV_FILE_SIZE);
		}

		if (tItems[i].catalog == TX_RX_DELTA) {
			if (ERR_ALLOC_MEM(core_mp.rx_delta_buf) || ERR_ALLOC_MEM(core_mp.tx_delta_buf)) {
				input_err(true, ilits->dev, "%s This test item (%s) has no data inside its buffer\n",
					__func__, tItems[i].desp);
				continue;
			}
		} else {
			if (ERR_ALLOC_MEM(tItems[i].buf) || ERR_ALLOC_MEM(tItems[i].max_buf) ||
					ERR_ALLOC_MEM(tItems[i].min_buf)) {
				input_err(true, ilits->dev, "%s This test item (%s) has no data inside its buffer\n",
					__func__, tItems[i].desp);
				continue;
			}
		}

		/* Show test result as below */
		if (tItems[i].catalog == KEY_TEST) {
			for (x = 0; x < core_mp.key_len; x++) {
				DUMP("KEY_%02d ", x);
				csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "KEY_%02d,", x);
			}

			DUMP("\n");
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "\n");

			for (y = 0; y < core_mp.key_len; y++) {
				DUMP(" %3d   ", tItems[i].buf[y]);
				csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), " %3d, ",
					tItems[i].buf[y]);
			}

			DUMP("\n");
			csv_len += snprintf(csv + csv_len, (CSV_FILE_SIZE - csv_len), "\n");
		} else if (tItems[i].catalog == TX_RX_DELTA) {
			for (j = 0; j < core_mp.frame_len; j++) {
				max_threshold[j] = core_mp.TxDeltaMax;
				min_threshold[j] = core_mp.TxDeltaMin;
			}
			mp_compare_cdc_show_result(i, core_mp.tx_max_buf, csv, &csv_len, TYPE_JUGE, max_threshold,
				min_threshold, "TX Max Hold", CSV_FILE_SIZE);
			mp_compare_cdc_show_result(i, core_mp.tx_min_buf, csv, &csv_len, TYPE_JUGE, max_threshold,
				min_threshold, "TX Min Hold", CSV_FILE_SIZE);

			for (j = 0; j < core_mp.frame_len; j++) {
				max_threshold[j] = core_mp.RxDeltaMax;
				min_threshold[j] = core_mp.RxDeltaMin;
			}
			mp_compare_cdc_show_result(i, core_mp.rx_max_buf, csv, &csv_len, TYPE_JUGE, max_threshold,
				min_threshold, "RX Max Hold", CSV_FILE_SIZE);
			mp_compare_cdc_show_result(i, core_mp.rx_min_buf, csv, &csv_len, TYPE_JUGE, max_threshold,
				min_threshold, "RX Min Hold", CSV_FILE_SIZE);
		} else {
			/* general result */
			if (tItems[i].trimmed_mean && tItems[i].catalog != PEAK_TO_PEAK_TEST) {
				mp_compare_cdc_show_result(i, tItems[i].result_buf, csv, &csv_len, TYPE_JUGE,
					max_threshold, min_threshold, "Mean result", CSV_FILE_SIZE);
			} else {
				if (!tItems[i].bch_mrk_multi) {
					mp_compare_cdc_show_result(i, tItems[i].max_buf, csv, &csv_len, TYPE_JUGE,
						max_threshold, min_threshold, "Max Hold", CSV_FILE_SIZE);
					mp_compare_cdc_show_result(i, tItems[i].min_buf, csv, &csv_len, TYPE_JUGE,
						max_threshold, min_threshold, "Min Hold", CSV_FILE_SIZE);
				}

			}
			if (tItems[i].catalog != PEAK_TO_PEAK_TEST)
				get_frame_cont = tItems[i].frame_count;

			if (tItems[i].bch_mrk_multi)
				get_frame_cont = tItems[i].bch_mrk_frm_num;

			/* result of each frame */
			for (j = 0; j < get_frame_cont; j++) {
				char frame_name[128] = {0};

				snprintf(frame_name, (CSV_FILE_SIZE - csv_len), "Frame %d", (j+1));
				mp_compare_cdc_show_result(i, &tItems[i].buf[(j*core_mp.frame_len)], csv, &csv_len,
					TYPE_NO_JUGE, max_threshold, min_threshold, frame_name, CSV_FILE_SIZE);
			}
		}
		k = i;
	}

	memset(csv_name, 0, 128 * sizeof(char));

	mp_print_csv_tail(csv, &csv_len, CSV_FILE_SIZE);

	for (i = 0; i < MP_TEST_ITEM; i++) {
		if (tItems[i].run) {
			if (tItems[i].item_result < 0) {
				pass_item_count = 0;
				break;
			}
			pass_item_count++;
		}
	}

	/* define csv file name */
	ret_pass_name = NORMAL_CSV_PASS_NAME;
	ret_fail_name = NORMAL_CSV_FAIL_NAME;

	if (pass_item_count == 0) {
		core_mp.final_result = MP_DATA_FAIL;
		if ((ilits->sec.cmd_all_factory_state == SEC_CMD_STATUS_RUNNING) ||
				(ilits->sec.cmd_state == SEC_CMD_STATUS_RUNNING))
			ret = MP_DATA_PASS;//Sec using this value for check fucntion error. Not a test result.
		else
			ret = MP_DATA_FAIL;

		if (core_mp.lost_parameter) {
			ret_fail_name = NULL;
			ret_fail_name = NORMAL_CSV_WARNING_NAME;
			input_err(true, ilits->dev, "%s WARNING! OPEN or SHORT parameter not found in ini file!!\n",
				 __func__);
		}

		if (lcm_on) {
			snprintf(csv_name, (CSV_FILE_SIZE - csv_len), "%s/%s_%s_%s.csv",
				CSV_LCM_ON_PATH, get_date_time_str(), ret_fail_name, tItems[k].desp);
		} else {
			snprintf(csv_name, (CSV_FILE_SIZE - csv_len), "%s/%s_%s_%s.csv",
				CSV_LCM_OFF_PATH, get_date_time_str(), ret_fail_name, tItems[k].desp);
		}
	} else {
		core_mp.final_result = MP_DATA_PASS;
		ret = MP_DATA_PASS;

		if (core_mp.lost_benchmark) {
			ret_pass_name = NULL;
			ret_pass_name = NORMAL_CSV_WARNING_NAME;
			input_err(true, ilits->dev, "%s WARNING! Golden and SPEC in ini file aren't matched!!\n",
				__func__);
		}
		if (lcm_on) {
			snprintf(csv_name, (CSV_FILE_SIZE - csv_len), "%s/%s_%s_%s.csv",
				CSV_LCM_ON_PATH, get_date_time_str(), ret_pass_name, tItems[k].desp);
		} else {
			snprintf(csv_name, (CSV_FILE_SIZE - csv_len), "%s/%s_%s_%s.csv",
				CSV_LCM_OFF_PATH, get_date_time_str(), ret_pass_name, tItems[k].desp);
		}
	}

	input_info(true, ilits->dev, "%s Open CSV : %s\n", __func__, csv_name);

	if (f == NULL)
		f = filp_open(csv_name, O_WRONLY | O_CREAT | O_TRUNC, 644);

	if (ERR_ALLOC_MEM(f)) {
		input_err(true, ilits->dev, "%s Failed to open CSV file", __func__);
		ret = -EMP_NOMEM;
		goto fail_open;
	}

	input_info(true, ilits->dev, "%s Open CSV succeed, its length = %d\n ", __func__, csv_len);

	if (csv_len >= CSV_FILE_SIZE) {
		input_err(true, ilits->dev, "%s The length saved to CSV is too long !\n", __func__);
		ret = -EMP_INVAL;
		goto fail_open;
	}

	fs = get_fs();
	set_fs(KERNEL_DS);
	pos = 0;
	vfs_write(f, csv, csv_len, &pos);
	set_fs(fs);
	filp_close(f, NULL);

	input_info(true, ilits->dev, "%s Writing Data into CSV succeed\n", __func__);

fail_open:
	ipio_vfree((void **)&csv);
	ipio_kfree((void **)&max_threshold);
	ipio_kfree((void **)&min_threshold);
	return ret;
}

static void ilitek_tddi_mp_init_item(void)
{
	int i = 0;

	memset(&core_mp, 0, sizeof(core_mp));
	memset(&open_para, 0, sizeof(open_para));
	memset(&short_para, 0, sizeof(short_para));

	core_mp.chip_pid = ilits->chip->pid;
	core_mp.chip_id = ilits->chip->id;
	core_mp.chip_type = ilits->chip->type;
	core_mp.chip_ver = ilits->chip->ver;
	core_mp.fw_ver = ilits->chip->fw_ver;
	core_mp.protocol_ver = ilits->protocol->ver;
	core_mp.core_ver = ilits->chip->core_ver;
	core_mp.cdc_len = ilits->protocol->cdc_len;
	core_mp.no_bk_shift = ilits->chip->no_bk_shift;
	core_mp.xch_len = ilits->xch_num;
	core_mp.ych_len = ilits->ych_num;
	core_mp.frame_len = core_mp.xch_len * core_mp.ych_len;
	core_mp.stx_len = 0;
	core_mp.srx_len = 0;
	core_mp.key_len = 0;
	core_mp.st_len = 0;
	core_mp.tdf = 240;
	core_mp.busy_cdc = INT_CHECK;
	core_mp.retry = ilits->mp_retry;
	core_mp.td_retry = false;
	core_mp.final_result = MP_DATA_FAIL;
	core_mp.lost_benchmark = false;
	core_mp.lost_parameter = false;
	core_mp.all_pass = false;

	input_info(true, ilits->dev, "%s ============== TP & Panel info ================\n", __func__);
	input_info(true, ilits->dev, "Driver version = %s\n", DRIVER_VERSION);
	input_info(true, ilits->dev, "TP Module = %s\n", ilits->md_name);
	input_info(true, ilits->dev, "CHIP = 0x%x\n", core_mp.chip_pid);
	input_info(true, ilits->dev, "Firmware version = %x\n", core_mp.fw_ver);
	input_info(true, ilits->dev, "Protocol version = %x\n", core_mp.protocol_ver);
	input_info(true, ilits->dev, "Core version = %x\n", core_mp.core_ver);
	input_info(true, ilits->dev, "Read CDC Length = %d\n", core_mp.cdc_len);
	input_info(true, ilits->dev, "X length = %d, Y length = %d\n", core_mp.xch_len, core_mp.ych_len);
	input_info(true, ilits->dev, "Frame length = %d\n", core_mp.frame_len);
	input_info(true, ilits->dev, "Check busy method = %s\n", (core_mp.busy_cdc ? "Polling" : "Interrupt"));
	input_info(true, ilits->dev, "%s ===============================================\n", __func__);

	for (i = 0; i < MP_TEST_ITEM; i++) {
		tItems[i].spec_option = 0;
		tItems[i].type_option = 0;
		tItems[i].run = false;
		tItems[i].max = 0;
		tItems[i].max_res = MP_DATA_FAIL;
		tItems[i].item_result = MP_DATA_PASS;
		tItems[i].min = 0;
		tItems[i].min_res = MP_DATA_FAIL;
		tItems[i].frame_count = 0;
		tItems[i].trimmed_mean = 0;
		tItems[i].lowest_percentage = 0;
		tItems[i].highest_percentage = 0;
		tItems[i].v_tdf_1 = 0;
		tItems[i].v_tdf_2 = 0;
		tItems[i].h_tdf_1 = 0;
		tItems[i].h_tdf_2 = 0;
		tItems[i].max_min_mode = 0;
		tItems[i].bch_mrk_multi = false;
		tItems[i].bch_mrk_frm_num = 1;
		tItems[i].goldenmode = 0;
		tItems[i].retry_cnt = RETRY_COUNT;
		tItems[i].result_buf = NULL;
		tItems[i].buf = NULL;
		tItems[i].max_buf = NULL;
		tItems[i].min_buf = NULL;
		tItems[i].bench_mark_max = NULL;
		tItems[i].bench_mark_min = NULL;
		tItems[i].bch_mrk_max = NULL;
		tItems[i].bch_mrk_min = NULL;
		tItems[i].node_type = NULL;
		tItems[i].delay_time = 0;
		tItems[i].test_int_pin = 0;
		tItems[i].int_pulse_test = 0;

		if (tItems[i].catalog == MUTUAL_TEST) {
			tItems[i].do_test = mutual_test;
		} else if (tItems[i].catalog == TX_RX_DELTA) {
			tItems[i].do_test = mutual_test;
		} else if (tItems[i].catalog == UNTOUCH_P2P) {
			tItems[i].do_test = mutual_test;
		} else if (tItems[i].catalog == PIXEL) {
			tItems[i].do_test = mutual_test;
		} else if (tItems[i].catalog == OPEN_TEST) {
			if (ipio_strcmp(tItems[i].desp, "open test(integration)_sp") == 0)
				tItems[i].do_test = open_test_sp;
			else if (ipio_strcmp(tItems[i].desp, "open test_c") == 0)
				tItems[i].do_test = open_test_cap;
			else
				tItems[i].do_test = mutual_test;
		} else if (tItems[i].catalog == KEY_TEST) {
			tItems[i].do_test = key_test;
		} else if (tItems[i].catalog == SELF_TEST) {
			tItems[i].do_test = self_test;
		} else if (tItems[i].catalog == ST_TEST) {
			tItems[i].do_test = st_test;
		} else if (tItems[i].catalog == PEAK_TO_PEAK_TEST) {
			tItems[i].do_test = peak_to_peak_test;
		} else if (tItems[i].catalog == SHORT_TEST) {
			tItems[i].do_test = mutual_test;
		} else if (tItems[i].catalog == PIN_TEST) {
			tItems[i].do_test = pin_test;
		}

		tItems[i].result = kmalloc(16, GFP_KERNEL);
		snprintf(tItems[i].result, 16, "%s", "FAIL");
	}
}

static void mp_p2p_td_retry_after_ra_fail(int p2p_td)
{
	int i;

	for (i = 0; i < MP_TEST_ITEM; i++) {
		if (ipio_strcmp(tItems[i].desp, "noise peak to peak(with panel) (lcm off)") == 0)
			break;
	}

	if (i >= MP_TEST_ITEM)
		return;

	ILI_DBG("%s i = %d, p2p_noise_ret = %d, p2p_noise_run = %d\n",
		__func__, i, tItems[i].item_result, tItems[i].run);

	if (tItems[i].item_result == MP_DATA_PASS && tItems[i].run == 1)
		tItems[p2p_td].do_test(p2p_td);
}

static void mp_test_run(int index)
{
	int i = index, j;
	char str[512] = {0};


	/* Get parameters from ini */
	parser_get_int_data(tItems[i].desp, "spec option", str, sizeof(str));
	tItems[i].spec_option = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "type option", str, sizeof(str));
	tItems[i].type_option = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "frame count", str, sizeof(str));
	tItems[i].frame_count = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "trimmed mean", str, sizeof(str));
	tItems[i].trimmed_mean = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "lowest percentage", str, sizeof(str));
	tItems[i].lowest_percentage = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "highest percentage", str, sizeof(str));
	tItems[i].highest_percentage = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "goldenmode", str, sizeof(str));
	tItems[i].goldenmode = ili_katoi(str);
	parser_get_int_data(tItems[i].desp, "max min mode", str, sizeof(str));
	tItems[i].max_min_mode = ili_katoi(str);

	parser_get_int_data(tItems[i].desp, "retry count", str, sizeof(str));
	tItems[i].retry_cnt = ili_katoi(str);

	if (tItems[i].goldenmode && (tItems[i].spec_option != tItems[i].goldenmode))
		core_mp.lost_benchmark = true;

	/* Get pin test delay time */
	if (tItems[i].catalog == PIN_TEST) {
		parser_get_int_data(tItems[i].desp, "test int pin", str, sizeof(str));
		tItems[i].test_int_pin = ili_katoi(str);
		parser_get_int_data(tItems[i].desp, "int pulse test", str, sizeof(str));
		tItems[i].int_pulse_test = ili_katoi(str);
		parser_get_int_data(tItems[i].desp, "delay time", str, sizeof(str));
		tItems[i].delay_time = ili_katoi(str);
	}

	/* Get TDF value from ini */
	if (tItems[i].catalog == SHORT_TEST) {
		parser_get_int_data(tItems[i].desp, "v_tdf_1", str, sizeof(str));
		tItems[i].v_tdf_1 = parser_get_tdf_value(str, tItems[i].catalog);
		parser_get_int_data(tItems[i].desp, "v_tdf_2", str, sizeof(str));
		tItems[i].v_tdf_2 = parser_get_tdf_value(str, tItems[i].catalog);
		parser_get_int_data(tItems[i].desp, "h_tdf_1", str, sizeof(str));
		tItems[i].h_tdf_1 = parser_get_tdf_value(str, tItems[i].catalog);
		parser_get_int_data(tItems[i].desp, "h_tdf_2", str, sizeof(str));
		tItems[i].h_tdf_2 = parser_get_tdf_value(str, tItems[i].catalog);
	} else {
		parser_get_int_data(tItems[i].desp, "v_tdf", str, sizeof(str));
		tItems[i].v_tdf_1 = parser_get_tdf_value(str, tItems[i].catalog);
		parser_get_int_data(tItems[i].desp, "h_tdf", str, sizeof(str));
		tItems[i].h_tdf_1 = parser_get_tdf_value(str, tItems[i].catalog);
	}

	/* Get threshold from ini structure in parser */
	if (ipio_strcmp(tItems[i].desp, "tx/rx delta") == 0) {
		parser_get_int_data(tItems[i].desp, "tx max", str, sizeof(str));
		core_mp.TxDeltaMax = ili_katoi(str);
		parser_get_int_data(tItems[i].desp, "tx min", str, sizeof(str));
		core_mp.TxDeltaMin = ili_katoi(str);
		parser_get_int_data(tItems[i].desp, "rx max", str, sizeof(str));
		core_mp.RxDeltaMax = ili_katoi(str);
		parser_get_int_data(tItems[i].desp, "rx min", str, sizeof(str));
		core_mp.RxDeltaMin = ili_katoi(str);
		ILI_DBG("%s %s: Tx Max = %d, Tx Min = %d, Rx Max = %d,  Rx Min = %d\n",
				__func__, tItems[i].desp, core_mp.TxDeltaMax, core_mp.TxDeltaMin,
				core_mp.RxDeltaMax, core_mp.RxDeltaMin);
	} else {
		parser_get_int_data(tItems[i].desp, "max", str, sizeof(str));
		tItems[i].max = ili_katoi(str);
		parser_get_int_data(tItems[i].desp, "min", str, sizeof(str));
		tItems[i].min = ili_katoi(str);
	}


	/* Get pin test delay time */
	if (tItems[i].catalog == PEAK_TO_PEAK_TEST) {
		if (tItems[i].max_min_mode == 1 && tItems[i].spec_option == 1) {
			tItems[i].bch_mrk_multi = true;
			for (j = 1; j < 11; j++) {
				char tmp[8] = {0};
				/* format complete string from the name of section "_Benchmark_Data". */
				snprintf(str, sizeof(str), "%s%s%s%d", tItems[index].desp, "_", BENCHMARK_KEY_NAME, j);
				if (parser_get_int_data(str, str, tmp, sizeof(tmp)) <= 0)
					break;

				tItems[i].bch_mrk_frm_num = j;
			}
			ILI_DBG("%s set bch_mrk_frm_num = %d\n", __func__, tItems[i].bch_mrk_frm_num);
		}
	}

	ILI_DBG("%s %s: run = %d, max = %d, min = %d, frame_count = %d\n",
		__func__, tItems[i].desp, tItems[i].run, tItems[i].max, tItems[i].min, tItems[i].frame_count);

	ILI_DBG("%s v_tdf_1 = %d, v_tdf_2 = %d, h_tdf_1 = %d, h_tdf_2 = %d",
		__func__, tItems[i].v_tdf_1, tItems[i].v_tdf_2, tItems[i].h_tdf_1, tItems[i].h_tdf_2);

	input_info(true, ilits->dev, "%s Run MP Test Item : %s\n", __func__, tItems[i].desp);
	tItems[i].do_test(i);

	mp_compare_test_result(i);

	/* P2P TD retry after RA sample failed. */
	if (ipio_strcmp(tItems[i].desp, "peak to peak_td (lcm off)") == 0 &&
		tItems[i].item_result == MP_DATA_FAIL) {
		parser_get_int_data(tItems[i].desp, "recheck ptop lcm off", str, sizeof(str));
		input_info(true, ilits->dev, "%s Peak to Peak TD retry = %d\n", __func__, ili_katoi(str));
		core_mp.td_retry = ili_katoi(str);
		if (core_mp.td_retry)
			mp_p2p_td_retry_after_ra_fail(i);
	}

	if (core_mp.retry && tItems[i].item_result == MP_DATA_FAIL) {
		input_info(true, ilits->dev, "%s MP failed, doing retry %d times\n", __func__, tItems[i].retry_cnt);
		mp_do_retry(i, tItems[i].retry_cnt);
	}


	input_info(true, ilits->dev, "current_mp:%s, running:%s\n", ilits->current_mpitem, tItems[i].desp);
	if (ipio_strcmp(tItems[i].desp, ilits->current_mpitem) == 0)
		sec_factory_print_frame(tItems[i].buf);
}

static void mp_test_free(void)
{
	int i, j;

	input_info(true, ilits->dev, "%s Free all allocated mem for MP\n", __func__);

	core_mp.final_result = MP_DATA_FAIL;
	core_mp.td_retry = false;

	for (i = 0; i < MP_TEST_ITEM; i++) {
		tItems[i].run = false;
		tItems[i].max_res = MP_DATA_FAIL;
		tItems[i].min_res = MP_DATA_FAIL;
		tItems[i].item_result = MP_DATA_PASS;

		if (tItems[i].catalog == TX_RX_DELTA) {
			ipio_kfree((void **)&core_mp.rx_delta_buf);
			ipio_kfree((void **)&core_mp.tx_delta_buf);
			ipio_kfree((void **)&core_mp.tx_max_buf);
			ipio_kfree((void **)&core_mp.tx_min_buf);
			ipio_kfree((void **)&core_mp.rx_max_buf);
			ipio_kfree((void **)&core_mp.rx_min_buf);
		} else {
			if (tItems[i].spec_option == BENCHMARK) {
				ipio_kfree((void **)&tItems[i].bench_mark_max);
				ipio_kfree((void **)&tItems[i].bench_mark_min);
				if (tItems[i].bch_mrk_max != NULL) {
					for (j = 0; j < tItems[i].bch_mrk_frm_num; j++)
						if (tItems[i].bch_mrk_max[j] != NULL) {
							kfree(tItems[i].bch_mrk_max[j]);
							tItems[i].bch_mrk_max[j] = NULL;
						}
					kfree(tItems[i].bch_mrk_max);
					tItems[i].bch_mrk_max = NULL;
				}
				if (tItems[i].bch_mrk_min != NULL) {
					for (j = 0; j < tItems[i].bch_mrk_frm_num; j++)
						if (tItems[i].bch_mrk_min[j] != NULL) {
							kfree(tItems[i].bch_mrk_min[j]);
							tItems[i].bch_mrk_min[j] = NULL;
						}
					kfree(tItems[i].bch_mrk_min);
					tItems[i].bch_mrk_min = NULL;
				}
			}
			ipio_kfree((void **)&tItems[i].node_type);
			ipio_kfree((void **)&tItems[i].result);
			ipio_kfree((void **)&tItems[i].result_buf);
			ipio_kfree((void **)&tItems[i].max_buf);
			ipio_kfree((void **)&tItems[i].min_buf);
			ipio_vfree((void **)&tItems[i].buf);
		}
	}

	ipio_kfree((void **)&frame1_cbk700);
	ipio_kfree((void **)&frame1_cbk250);
	ipio_kfree((void **)&frame1_cbk200);
	ipio_kfree((void **)&frame_buf);
	ipio_kfree((void **)&key_buf);
	if (frm_buf != NULL) {
		for (j = 0; j < 3; j++)
			if (frm_buf[j] != NULL) {
				kfree(frm_buf[j]);
				frm_buf[j] = NULL;
			}
		kfree(frm_buf);
		frm_buf = NULL;
	}
}

/* The method to copy results to user depends on what APK needs */
static void mp_copy_ret_to_apk(char *buf)
{
	int i, seq, len = 2;

	if (!buf) {
		input_err(true, ilits->dev, "%s apk buffer is null\n", __func__);
		return;
	}

	len += snprintf(buf + len, PAGE_SIZE - len, "CSV path: %s\n\n", csv_name);
	for (seq = 0; seq < ri.count; seq++) {
		i = ri.index[seq];
		if (tItems[i].item_result == MP_DATA_FAIL) {
			input_err(true, ilits->dev, "%s [%s] = FAIL\n", __func__, tItems[i].desp);
			len += snprintf(buf + len, PAGE_SIZE - len, "[%s] = FAIL\n", tItems[i].desp);
		} else {
			input_info(true, ilits->dev, "%s [%s] = PASS\n", __func__, tItems[i].desp);
			len += snprintf(buf + len, PAGE_SIZE - len, "[%s] = PASS\n", tItems[i].desp);
		}
	}
	ilits->mp_ret_len = len;
}

static int mp_sort_item(bool lcm_on)
{
	int i, j;
	char str[128] = {0};

	ri.count = 0;
	memset(ri.index, 0x0, MP_TEST_ITEM);

	for (i = 0; i < MAX_SECTION_NUM; i++) {
		for (j = 0; j < MP_TEST_ITEM; j++) {
			if (ipio_strcmp(seq_item[i], tItems[j].desp) != 0)
				continue;

			parser_get_int_data(tItems[j].desp, "enable", str, sizeof(str));
			tItems[j].run = ili_katoi(str);
			if (tItems[j].run != 1 || tItems[j].lcm != lcm_on)
				continue;

			if (ri.count > MP_TEST_ITEM) {
				input_err(true, ilits->dev, "%s Test item(%d) is invaild, abort\n", __func__, ri.count);
				return -EINVAL;
			}

			ri.index[ri.count] = j;
			ri.count++;
		}
	}
	return 0;
}

static void ilitek_tddi_mp_all_pass_check(void)
{
	int ret = 0, retry = 5;
	u8 cmd[1] = {0xFD};
	u8 temp[3] = {0};

	ilits->wait_int_timeout = 20;
	do {
		ret = ilits->wrapper(cmd, 1, temp, 3, ON, OFF);
		if (ret < 0) {
			input_err(true, ilits->dev, "%s Write MP All Pass command failed\n", __func__);
			core_mp.all_pass = false;
		} else {
			if (temp[0] == 0xFD)
				break;
		}
	} while (--retry >= 0);
	ilits->wait_int_timeout = MP_INT_TIMEOUT;
	if (retry <= 0) {
		input_err(true, ilits->dev, "%s MP All Pass command failed, normal mode\n", __func__);
		core_mp.all_pass = false;
		return;
	}

	if (temp[2] == ili_calc_packet_checksum(temp, sizeof(temp) - 1) &&
			temp[0] == 0xFD && temp[1] == 0x02) {//0xFD:back door command header, 0x02:Normal mode
		core_mp.all_pass = true;
		input_err(true, ilits->dev, "%s MP mode check: Back door mode, MP All Pass\n", __func__);
	} else {
		core_mp.all_pass = false;//0xFD:back door command header, 0x01:Normal mode
		input_err(true, ilits->dev, "%s MP mode check: Normal mode\n", __func__);
	}
}

int ili_mp_test_main(char *apk, bool lcm_on)
{
	int i, ret = 0;
	char str[128] = {0}, ver[128] = {0};

	if (ilits->xch_num <= 0 || ilits->ych_num <= 0) {
		input_err(true, ilits->dev, "%s Invalid frame length (%d, %d)\n",
				__func__, ilits->xch_num, ilits->ych_num);
		ret = -EMP_INVAL;
		goto out;
	}

	if (ini_info == NULL) {
		ini_info = (struct ini_file_data *)vmalloc(sizeof(struct ini_file_data) * PARSER_MAX_KEY_NUM);
		if (ERR_ALLOC_MEM(ini_info)) {
			input_err(true, ilits->dev, "%s Failed to malloc ini_info\n", __func__);
			ret = -EMP_NOMEM;
			goto out;
		}
	}

	ilitek_tddi_mp_init_item();

	if ((ilits->sec.cmd_all_factory_state != SEC_CMD_STATUS_RUNNING) &&
			(ilits->sec.cmd_state != SEC_CMD_STATUS_RUNNING))
		ilitek_tddi_mp_all_pass_check();

	ret = ilitek_tddi_mp_ini_parser(ilits->md_ini_path);
	if (ret < 0) {
		input_err(true, ilits->dev, "%s Failed to parsing INI file\n", __func__);
		ret = -EMP_INI;
		goto out;
	}

	/* Compare both protocol version of ini and firmware */
	parser_get_ini_key_value("pv5_4 command", "protocol", str);
	snprintf(ver, sizeof(ver), "0x%s", str);
	if ((ili_str2hex(ver)) != (core_mp.protocol_ver >> 8)) {
		input_err(true, ilits->dev, "%s ERROR! MP Protocol version is invaild, 0x%x\n",
			__func__, ili_str2hex(ver));
		ret = -EMP_PROTOCOL;
		goto out;
	}

	/* Read timing info from ini file */
	if (mp_get_timing_info() < 0) {
		input_err(true, ilits->dev, "%s Failed to get timing info from ini\n", __func__);
		ret = -EMP_TIMING_INFO;
		goto out;
	}

#if MP_INT_LEVEL
	if (ili_ic_int_trigger_ctrl(true) < 0) {
		input_err(true, ilits->dev, "%s Failed to set INT as Level trigger", __func__);
		ret = -EMP_CMD;
		goto out;
	}
#endif

	/* Sort test item by ini file */
	if (mp_sort_item(lcm_on) < 0) {
		input_err(true, ilits->dev, "%s Failed to sort test item\n", __func__);
		ret = -EMP_INI;
		goto out;
	}

	for (i = 0; i < ri.count; i++)
		mp_test_run(ri.index[i]);

	ret = mp_show_result(lcm_on);

	mp_copy_ret_to_apk(apk);

out:
	mp_test_free();

#if MP_INT_LEVEL
	if (ili_ic_int_trigger_ctrl(false) < 0) {
		input_err(true, ilits->dev, "%s Failed to set INT back to pluse trigger", __func__);
		ret = -EMP_CMD;
	}
#endif

	ipio_vfree((void **)&ini_info);
	return ret;
};