/*
 * 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_sec_fn.h"

static int sec_fn_load_fw(int update_mode, bool signing)
{
	int ret = 0;
	bool esd_en = ilits->wq_esd_ctrl, bat_en = ilits->wq_bat_ctrl;
	static unsigned char g_user_buf[USER_STR_BUFF] = {0};

	input_info(true, ilits->dev, "%s Prepar to upgarde firmware\n", __func__);

	mutex_lock(&ilits->touch_mutex);

	memset(g_user_buf, 0, USER_STR_BUFF * sizeof(unsigned char));

	if (esd_en)
		ili_wq_ctrl(WQ_ESD, DISABLE);
	if (bat_en)
		ili_wq_ctrl(WQ_BAT, DISABLE);

	ilits->signing = signing;

	if (update_mode == BUILT_IN) {
		ilits->fw_open = REQUEST_FIRMWARE;
	} else if (update_mode == UMS) {
		ilits->fw_open = FILP_OPEN;
		if (ilits->signing)
			ilits->md_fw_filp_path = TSP_PATH_EXTERNAL_FW_SIGNED;
		else
			ilits->md_fw_filp_path = TSP_PATH_EXTERNAL_FW;
	} else {
		ilits->fw_open = REQUEST_FIRMWARE;
	}

	ilits->force_fw_update = ENABLE;
	ilits->node_update = true;

	ret = ili_fw_upgrade_handler(NULL);

	ilits->node_update = false;
	ilits->force_fw_update = DISABLE;
	ilits->fw_open = REQUEST_FIRMWARE;

	g_user_buf[0] = 0x0;
	g_user_buf[1] = (ret < 0) ? -ret : ret;

	if (g_user_buf[1] == 0)
		input_info(true, ilits->dev, "%s Upgrade firmware = PASS\n", __func__);
	else
		input_err(true, ilits->dev, "%s Upgrade firmware = FAIL\n", __func__);

	/* Reason for fail */
	if (g_user_buf[1] == EFW_CONVERT_FILE) {
		g_user_buf[0] = 0xFF;
		input_err(true, ilits->dev, "%s Failed to convert hex/ili file, abort!\n", __func__);
	} else if (g_user_buf[1] == ENOMEM) {
		input_err(true, ilits->dev, "%s Failed to allocate memory, abort!\n", __func__);
	} else if (g_user_buf[1] == EFW_ICE_MODE) {
		input_err(true, ilits->dev, "%s Failed to operate ice mode, abort!\n", __func__);
	} else if (g_user_buf[1] == EFW_CRC) {
		input_err(true, ilits->dev, "%s CRC not matched, abort!\n", __func__);
	} else if (g_user_buf[1] == EFW_REST) {
		input_err(true, ilits->dev, "%s Failed to do reset, abort!\n", __func__);
	} else if (g_user_buf[1] == EFW_ERASE) {
		input_err(true, ilits->dev, "%s Failed to erase flash, abort!\n", __func__);
	} else if (g_user_buf[1] == EFW_PROGRAM) {
		input_err(true, ilits->dev, "%s Failed to program flash, abort!\n", __func__);
	} else if (g_user_buf[1] == EFW_INTERFACE) {
		input_err(true, ilits->dev, "%s Failed to hex file interface no match, abort!\n", __func__);
	}

	if (esd_en)
		ili_wq_ctrl(WQ_ESD, ENABLE);
	if (bat_en)
		ili_wq_ctrl(WQ_BAT, ENABLE);

	set_current_ic_mode(SET_MODE_NORMAL);

	mutex_unlock(&ilits->touch_mutex);
	return ret;
}

static void fw_update(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[64] = { 0 };
	int retval = 0;

	sec_cmd_set_default_result(sec);

	/* Factory cmd for firmware update
	 * argument represent what is source of firmware like below.
	 *
	 * 0 : [BUILT_IN] Getting firmware which is for user.
	 * 1 : [UMS] Getting firmware from sd card.
	 * 2 : none
	 * 3 : [FFU] Getting firmware from apk.
	 */

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	switch (sec->cmd_param[0]) {
	case BUILT_IN:
		retval = sec_fn_load_fw(BUILT_IN, NORMAL);
		break;
	case UMS:
#ifdef CONFIG_SAMSUNG_PRODUCT_SHIP
		retval = sec_fn_load_fw(UMS, SIGNING);
#else
		retval = sec_fn_load_fw(UMS, NORMAL);
#endif
		break;
	default:
		input_info(true, ilits->dev, "%s: Not supported value:%d\n", __func__, sec->cmd_param[0]);
		retval = -1;
		break;
	}
	if (retval < 0)
		snprintf(buff, sizeof(buff), "FAIL");
	else
		snprintf(buff, sizeof(buff), "OK");

	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;

out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));

}

static void aot_enable(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[SEC_CMD_STR_LEN] = { 0 };
	struct gesture_symbol *ptr_sym = &ilits->ges_sym;
	u8 *ptr;
	u32 ges_sym_value = 0;

	sec_cmd_set_default_result(sec);

	if (!ilits->enable_settings_aot) {
		input_err(true, ilits->dev, "%s: Not support AOT!\n", __func__);
		goto out;
	}

	ptr = (u8 *) ptr_sym;
	ges_sym_value = (ptr[0] | (ptr[1] << 8) | (ptr[2] << 16)) & DOUBLE_TAP_MASK;

	input_info(true, ilits->dev, "%s cmd:%d, gesture:%d, ilits->ges_sym:0x%x, ges_sym_value:0x%x\n",
			__func__, sec->cmd_param[0], ilits->gesture, ilits->ges_sym, ges_sym_value);

	if (!!sec->cmd_param[0]) {
		ilits->gesture = !!sec->cmd_param[0];
	} else {
		if (!ges_sym_value)
			ilits->gesture = !!sec->cmd_param[0];
	}
	ilits->ges_sym.double_tap = (u8)!!sec->cmd_param[0];

	snprintf(buff, sizeof(buff), "%s", "OK");
	sec->cmd_state = SEC_CMD_STATUS_OK;
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);

	input_info(true, ilits->dev, "%s, %s, gesture:%d, ilits->ges_sym:0x%x\n",
			__func__, sec->cmd_result, ilits->gesture, ilits->ges_sym);
	return;

out:
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);

	input_info(true, ilits->dev, "%s, %s, gesture:%d, ilits->ges_sym:0x%x\n",
			__func__, sec->cmd_result, ilits->gesture, ilits->ges_sym);
}

static void spay_enable(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[SEC_CMD_STR_LEN] = { 0 };
	struct gesture_symbol *ptr_sym = &ilits->ges_sym;
	u8 *ptr;
	u32 ges_sym_value = 0;

	sec_cmd_set_default_result(sec);

	if (!ilits->support_spay_gesture_mode) {
		input_err(true, ilits->dev, "%s: Not support SPAY!\n", __func__);
		goto out;
	}

	ptr = (u8 *) ptr_sym;
	ges_sym_value = (ptr[0] | (ptr[1] << 8) | (ptr[2] << 16)) & ALPHABET_LINE_2_TOP_MASK;

	input_info(true, ilits->dev, "%s cmd:%d, gesture:%d, ilits->ges_sym:0x%x, ges_sym_value:0x%x\n",
			__func__, sec->cmd_param[0], ilits->gesture, ilits->ges_sym, ges_sym_value);

	if (!!sec->cmd_param[0]) {
		ilits->gesture = !!sec->cmd_param[0];
	} else {
		if (!ges_sym_value)
			ilits->gesture = !!sec->cmd_param[0];
	}
	ilits->ges_sym.alphabet_line_2_top = (u8)!!sec->cmd_param[0];

	snprintf(buff, sizeof(buff), "%s", "OK");
	sec->cmd_state = SEC_CMD_STATUS_OK;
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);

	input_info(true, ilits->dev, "%s, %s, gesture:%d, ilits->ges_sym:0x%x\n",
			__func__, sec->cmd_result, ilits->gesture, ilits->ges_sym);
	return;
out:
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);

	input_info(true, ilits->dev, "%s, %s, gesture:%d, ilits->ges_sym:0x%x\n",
			__func__, sec->cmd_result, ilits->gesture, ilits->ges_sym);
}

static void get_chip_vendor(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	char buff[16] = { 0 };

	strncpy(buff, "ILI", sizeof(buff));
	sec_cmd_set_default_result(sec);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, strnlen(buff, sizeof(buff)), "IC_VENDOR");
	sec->cmd_state = SEC_CMD_STATUS_OK;
	input_info(true, ilits->dev, "%s: %s\n", __func__, buff);
}

static void get_chip_name(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	char buff[16] = { 0 };

	strncpy(buff, "ILI9881X", sizeof(buff));

	sec_cmd_set_default_result(sec);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, strnlen(buff, sizeof(buff)), "IC_NAME");
	sec->cmd_state = SEC_CMD_STATUS_OK;
	input_info(true, ilits->dev, "%s: %s\n", __func__, buff);
}

static void get_fw_ver_bin(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	snprintf(buff, sizeof(buff), "%c%c%02d%02d%02d%02d",
		ilits->fw_customer_info[0], ilits->fw_customer_info[1], ilits->fw_customer_info[2],
		ilits->fw_customer_info[3], ilits->fw_customer_info[4], ilits->fw_customer_info[5]);

	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, strnlen(buff, sizeof(buff)), "FW_VER_BIN");
	sec->cmd_state = SEC_CMD_STATUS_OK;

	input_info(true, ilits->dev, "%s: %s\n", __func__, buff);
}

static void get_fw_ver_ic(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	u8 cmd[1] = {0x26};
	u8 buf[8] = {0};
	u8 retry = 25, checksum = 0;

	char buff[16] = { 0 };
	char model[7] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	do {
		if (ilits->wrapper(cmd, sizeof(u8), buf, 8, ON, OFF) < 0)
			input_err(true, ilits->dev, "%s Write pre cmd failed\n", __func__);

		checksum = ili_calc_packet_checksum(buf, 7);

		if (retry <= 0) {
			input_info(true, ilits->dev, "%s failed get ic version\n", __func__);
			memset(&buf, 0x00, sizeof(buf));
			break;
		}
		retry--;
	} while (checksum != buf[7]);
	input_info(true, ilits->dev, "%s %02d%c%c%02d%02d%02d%02d%02d\n",
		__func__, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);

	snprintf(buff, sizeof(buff), "%c%c%02d%02d%02d%02d", buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
	snprintf(model, sizeof(model), "%c%c%02d%02d", buf[1], buf[2], buf[3], buf[4]);

	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING) {
		sec_cmd_set_cmd_result_all(sec, buff, strnlen(buff, sizeof(buff)), "FW_VER_IC");
		sec_cmd_set_cmd_result_all(sec, model, strnlen(model, sizeof(model)), "FW_MODEL");
	}
	sec->cmd_state = SEC_CMD_STATUS_OK;
	input_info(true, ilits->dev, "%s: %s\n", __func__, buff);
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING) {
		sec_cmd_set_cmd_result_all(sec, buff, strnlen(buff, sizeof(buff)), "FW_VER_IC");
		sec_cmd_set_cmd_result_all(sec, buff, strnlen(model, sizeof(model)), "FW_MODEL");
	}
}

static void get_x_num(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);
	snprintf(buff, sizeof(buff), "%d", ilits->xch_num);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec->cmd_state = SEC_CMD_STATUS_OK;
	input_info(true, ilits->dev, "%s: %s\n", __func__, buff);
}

static void get_y_num(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);
	snprintf(buff, sizeof(buff), "%d", ilits->ych_num);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec->cmd_state = SEC_CMD_STATUS_OK;
	input_info(true, ilits->dev, "%s: %s\n", __func__, buff);
}

static void run_sram_test(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	sec_cmd_set_default_result(sec);

	test_sram(sec);

}

static void run_raw_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "raw data(no bk)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, RAWDATANOBK_LCMON_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "RAW");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "RAW");
}

static void run_raw_doze_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "doze raw data";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;

	ret = ilitek_node_mp_test_read(sec, DOZERAW_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "RAW_DOZE");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "RAW_DOZE");
}

static void run_cal_dac_test_read(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "calibration data(dac)";
	ilits->allnode = TEST_MODE_MIN_MAX;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, DAC_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "CAL_DAC");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "CAL_DAC");
}

static void run_cal_dac_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "calibration data(dac)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, DAC_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "CAL_DAC");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "CAL_DAC");
}

static void run_open_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "open test_c";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, OPENTESTC_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "OPEN");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "OPEN");
}

static void run_short_test_read(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "short test";
	ilits->allnode = TEST_MODE_MIN_MAX;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, SHORTTEST_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "SHORT");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "SHORT");
}

static void run_short_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "short test";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, SHORTTEST_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "SHORT");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;

	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "SHORT");

}

static void run_noise_test_read(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "noise peak to peak(with panel)";
	ilits->allnode = TEST_MODE_MIN_MAX;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, NOISEPP_LCMON_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "NOISE");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "NOISE");
}

static void run_noise_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "noise peak to peak(with panel)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, NOISEPP_LCMON_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "NOISE");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "NOISE");
}

static void run_noise_doze_test_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "doze peak to peak";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;

	ret = ilitek_node_mp_test_read(sec, DOZEPP_PATH, ON);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "NOISE_DOZE");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "NOISE_DOZE");
}

static void run_noise_test_read_lcdoff(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->power_status == POWER_OFF_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "noise peak to peak(with panel) (lcm off)";
	ilits->allnode = TEST_MODE_MIN_MAX;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, NOISEPP_LCMOFF_PATH, OFF);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "NOISE_OFF");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "NOISE_OFF");
}

static void run_noise_test_read_all_lcdoff(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->power_status == POWER_OFF_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "noise peak to peak(with panel) (lcm off)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, NOISEPP_LCMOFF_PATH, OFF);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "NOISE_OFF");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "NOISE_OFF");
}

static void run_noise_doze_test_read_all_lcdoff(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->power_status == POWER_OFF_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "peak to peak_td (lcm off)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;

	ret = ilitek_node_mp_test_read(sec, P2P_TD_PATH, OFF);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "NOISE_DOZE_OFF");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "NOISE_DOZE_OFF");
}

static void run_raw_doze_test_read_all_lcdoff(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->power_status == POWER_OFF_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "raw data_td (lcm off)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;

	ret = ilitek_node_mp_test_read(sec, RAWDATATD_PATH, OFF);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "RAW_DOZE_OFF");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "RAW_DOZE_OFF");
}

static void run_raw_test_read_all_lcdoff(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->power_status == POWER_OFF_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		goto out;
	}

	ilits->current_mpitem = "raw data(no bk) (lcm off)";
	ilits->allnode = TEST_MODE_ALL_NODE;
	ilits->node_min = ilits->node_max = 0;
	ret = ilitek_node_mp_test_read(sec, RAWDATANOBK_LCMOFF_PATH, OFF);
	if (ret < 0) {
		snprintf(ilits->print_buf, SEC_CMD_STR_LEN, "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	}
	sec_cmd_set_cmd_result(sec, ilits->print_buf, strlen(ilits->print_buf));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, ilits->print_buf, SEC_CMD_STR_LEN, "RAW_OFF");

	ilits->current_mpitem = "";
	sec->cmd_state = SEC_CMD_STATUS_OK;
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	if (sec->cmd_all_factory_state == SEC_CMD_STATUS_RUNNING)
		sec_cmd_set_cmd_result_all(sec, buff, SEC_CMD_STR_LEN, "RAW_OFF");
}

static void factory_cmd_result_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		sec->cmd_all_factory_state = SEC_CMD_STATUS_FAIL;
		return;
	}

	sec->item_count = 0;

	memset(sec->cmd_result_all, 0x00, SEC_CMD_RESULT_STR_LEN);

	sec->cmd_all_factory_state = SEC_CMD_STATUS_RUNNING;

	get_chip_vendor(sec);
	get_chip_name(sec);
	get_fw_ver_bin(sec);
	get_fw_ver_ic(sec);

	run_sram_test(sec);
	run_cal_dac_test_read(sec);
	run_short_test_read(sec);
	run_noise_test_read(sec);

	ilits->actual_tp_mode = P5_X_FW_AP_MODE;
	if (ilits->fw_upgrade_mode == UPGRADE_IRAM) {
		if (ili_fw_upgrade_handler(NULL) < 0)
			input_err(true, ilits->dev, "%s FW upgrade failed during mp test\n", __func__);
	} else {
		if (ili_reset_ctrl(ilits->reset) < 0)
			input_err(true, ilits->dev, "%s TP Reset failed during mp test\n", __func__);
	}

	atomic_set(&ilits->mp_stat, DISABLE);
	sec->cmd_all_factory_state = SEC_CMD_STATUS_OK;

	input_info(true, ilits->dev,
		"%s: %d%s\n", __func__, sec->item_count, sec->cmd_result_all);
}

static void factory_lcdoff_cmd_result_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;

	if (ilits->power_status == POWER_OFF_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		sec->cmd_all_factory_state = SEC_CMD_STATUS_FAIL;
		return;
	}

	sec->item_count = 0;
	memset(sec->cmd_result_all, 0x00, SEC_CMD_RESULT_STR_LEN);

	sec->cmd_all_factory_state = SEC_CMD_STATUS_RUNNING;

	run_noise_test_read_lcdoff(sec);

	atomic_set(&ilits->mp_stat, DISABLE);
	sec->cmd_all_factory_state = SEC_CMD_STATUS_OK;

	input_info(true, ilits->dev,
		"%s: %d%s\n", __func__, sec->item_count, sec->cmd_result_all);
}

static void incell_power_control(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	int ret = 0;
	char buff[SEC_CMD_STR_LEN] = { 0 };

	sec_cmd_set_default_result(sec);
	input_info(true, ilits->dev, "%s: %d\n", __func__, sec->cmd_param[0]);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		ret = -1;
		goto out;
	}

	switch (sec->cmd_param[0]) {
	case INCELL_POWER_DISABLE:
		ilits->incell_power_state = INCELL_POWER_DISABLE;
		ili_incell_power_control(INCELL_POWER_DISABLE);
		break;
	case INCELL_POWER_ENABLE:
		ilits->incell_power_state = INCELL_POWER_ENABLE;
		ili_incell_power_control(INCELL_POWER_ENABLE);
		break;
	default:
		input_info(true, ilits->dev, "%s: Not supported value:%d\n", __func__, sec->cmd_param[0]);
		ret = -1;
		break;
	}
out:
	if (ret < 0) {
		snprintf(buff, sizeof(buff), "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	} else {
		snprintf(buff, sizeof(buff), "OK");
		sec->cmd_state = SEC_CMD_STATUS_OK;
	}

	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);
}



static void run_prox_intensity_read_all(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char data[SEC_CMD_STR_LEN] = { 0 };
	int ret = 0;
	char buff[16] = { 0 };

	sec_cmd_set_default_result(sec);

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		goto out;
	}

	if (ilits->prox_face_mode && !ilits->started_prox_intensity) {
		input_info(true, ilits->dev, "%s: start\n", __func__);
		ilits->started_prox_intensity = true;
		ret = debug_mode_onoff(true);
		if (ret < 0)
			input_err(true, ilits->dev, "%s: debug_mode_onoff setting  failed\n", __func__);
	}

	if (ret < 0) {
		input_err(true, ilits->dev, "%s: debug_mode_onoff setting  failed\n", __func__);
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	} else {
		snprintf(data, sizeof(data), "SUM_X:%d THD_X:%d", ilits->proximity_sum, ilits->proximity_thd);
		sec->cmd_state = SEC_CMD_STATUS_OK;
	}
	sec_cmd_set_cmd_result(sec, data, strlen(data));
	return;
out:
	sec->cmd_state = SEC_CMD_STATUS_FAIL;
	snprintf(buff, sizeof(buff), "%s", "NG");
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
}

static void ear_detect_enable(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	int ret = 0;
	char buff[SEC_CMD_STR_LEN] = { 0 };

	sec_cmd_set_default_result(sec);
	mutex_lock(&ilits->touch_mutex);
	input_info(true, ilits->dev, "%s: %d\n", __func__, sec->cmd_param[0]);

	if ((sec->cmd_param[0] != EAR_DETECT_DISABLE) && (sec->cmd_param[0] != EAR_DETECT_NORMAL_MODE) && (sec->cmd_param[0] != EAR_DETECT_INSENSITIVE_MODE)) {
		input_info(true, ilits->dev, "%s: Not supported value:%d\n", __func__, sec->cmd_param[0]);
		ret = -1;
		goto out;
	}

	ilits->prox_face_mode = sec->cmd_param[0];

	if (ilits->tp_suspend) {
		input_info(true, ilits->dev, "%s: now screen off stae, it'll setting after screen on(%d)\n", __func__, ilits->prox_face_mode);
		goto out;
	}

	ret = ili_ic_func_ctrl("proximity", ilits->prox_face_mode);
	if (ret < 0)
		input_err(true, ilits->dev, "%s Ear Detect Mode Setting failed\n", __func__);
	
	if((ilits->prox_face_mode == EAR_DETECT_DISABLE) && ilits->started_prox_intensity) {
		debug_mode_onoff(false);
		ilits->started_prox_intensity = false;
	}
out:
	if (ret < 0) {
		snprintf(buff, sizeof(buff), "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	} else {
		snprintf(buff, sizeof(buff), "OK");
		sec->cmd_state = SEC_CMD_STATUS_OK;
	}
	mutex_unlock(&ilits->touch_mutex);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);
}

static void prox_lp_scan_mode(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	int ret = 0;
	char buff[SEC_CMD_STR_LEN] = { 0 };

	sec_cmd_set_default_result(sec);
	mutex_lock(&ilits->touch_mutex);
	input_info(true, ilits->dev, "%s: %d\n", __func__, sec->cmd_param[0]);

	if (!ilits->prox_lp_scan_enabled) {
		input_err(true, ilits->dev, "%s: Not support LPSCAN!\n", __func__);
		ret = -1;
		goto out;
	}

	if (ilits->power_status == POWER_ON_STATUS) {
		input_info(true, ilits->dev, "%s  now screen on stae, it'll setting after screen off\n", __func__);
		if (sec->cmd_param[0] == PORX_LP_SCAN_ON)
			ilits->prox_lp_scan_mode_enabled = true;
		else
			ilits->prox_lp_scan_mode_enabled = false;
		goto out;
	}

	if (ilits->power_status != LP_PROX_STATUS) {
		input_err(true, ilits->dev, "%s failed(power off state).\n", __func__);
		ret = -1;
		goto out;
	}

	switch (sec->cmd_param[0]) {
	case PORX_LP_SCAN_OFF:
		if (ilits->prox_face_mode) {
			if (ili_ic_func_ctrl("sleep", SLEEP_IN) < 0)
				input_err(true, ilits->dev, "%s Write sleep in cmd failed\n", __func__);
			ilits->prox_lp_scan_mode_enabled = false;
		} else {
			input_err(true, ilits->dev, "%s prox_face_mode disabled\n", __func__);
		}
		break;
	case PORX_LP_SCAN_ON:
		if (ilits->prox_face_mode) {
			ili_switch_tp_mode(P5_X_FW_GESTURE_MODE);
			ret = ili_ic_func_ctrl("lpwg", 0x21);//proximity report start
			if (ret < 0)
				input_err(true, ilits->dev, "%s proximity report start failed\n", __func__);
			ilits->prox_lp_scan_mode_enabled = true;
		} else {
			input_err(true, ilits->dev, "%s prox_face_mode disabled\n", __func__);
		}

		break;
	default:
		input_info(true, ilits->dev, "%s: Not supported value:%d\n", __func__, sec->cmd_param[0]);
		ret = -1;
		break;
	}
out:
	if (ret < 0) {
		snprintf(buff, sizeof(buff), "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	} else {
		snprintf(buff, sizeof(buff), "OK");
		sec->cmd_state = SEC_CMD_STATUS_OK;
	}
	mutex_unlock(&ilits->touch_mutex);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);
}

static void dead_zone_enable(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[SEC_CMD_STR_LEN] = { 0 };
	int ret;

	sec_cmd_set_default_result(sec);
	mutex_lock(&ilits->touch_mutex);
	if (sec->cmd_param[0] < 0 || sec->cmd_param[0] > 1) {
		snprintf(buff, sizeof(buff), "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	} else {
		if (ilits->tp_suspend) {
			input_info(true, ilits->dev, "%s: now screen off stae, it'll setting after screen on\n",
					__func__, sec->cmd_param[0]);
			ilits->dead_zone_enabled = sec->cmd_param[0];
			snprintf(buff, sizeof(buff), "OK");
			goto out;
		}
		if (sec->cmd_param[0])
			ret = ili_ic_func_ctrl("dead_zone_ctrl", DEAD_ZONE_ENABLE);
		else
			ret = ili_ic_func_ctrl("dead_zone_ctrl", DEAD_ZONE_DISABLE);

		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to enable dead zone, cmd:%d\n",
					__func__, sec->cmd_param[0]);
			snprintf(buff, sizeof(buff), "NG");
			sec->cmd_state = SEC_CMD_STATUS_FAIL;
		} else {
			snprintf(buff, sizeof(buff), "OK");
			sec->cmd_state = SEC_CMD_STATUS_OK;
		}
	}
out:
	mutex_unlock(&ilits->touch_mutex);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);
}

static void set_sip_mode(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[SEC_CMD_STR_LEN] = { 0 };
	int ret;

	sec_cmd_set_default_result(sec);
	mutex_lock(&ilits->touch_mutex);
	if (sec->cmd_param[0] < 0 || sec->cmd_param[0] > 1) {
		snprintf(buff, sizeof(buff), "NG");
		sec->cmd_state = SEC_CMD_STATUS_FAIL;
	} else {
		if (ilits->tp_suspend) {
			input_info(true, ilits->dev, "%s: now screen off stae, it'll setting after screen on\n",
					__func__, sec->cmd_param[0]);
			ilits->sip_mode_enabled = sec->cmd_param[0];
			snprintf(buff, sizeof(buff), "OK");
			goto out;
		}
		if (sec->cmd_param[0])
			ret = ili_ic_func_ctrl("sip_mode", SIP_MODE_ENABLE);
		else
			ret = ili_ic_func_ctrl("sip_mode", SIP_MODE_DISABLE);

		if (ret < 0) {
			input_err(true, ilits->dev, "%s Failed to enable sip_mode, cmd:%d\n",
					__func__, sec->cmd_param[0]);
			snprintf(buff, sizeof(buff), "NG");
			sec->cmd_state = SEC_CMD_STATUS_FAIL;
		} else {
			snprintf(buff, sizeof(buff), "OK");
			sec->cmd_state = SEC_CMD_STATUS_OK;
		}
	}
out:
	mutex_unlock(&ilits->touch_mutex);
	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec_cmd_set_cmd_exit(sec);
}

static void not_support_cmd(void *device_data)
{
	struct sec_cmd_data *sec = (struct sec_cmd_data *)device_data;
	char buff[SEC_CMD_STR_LEN] = { 0 };

	sec_cmd_set_default_result(sec);
	snprintf(buff, sizeof(buff), "NA");

	sec_cmd_set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
	sec->cmd_state = SEC_CMD_STATUS_NOT_APPLICABLE;
	sec_cmd_set_cmd_exit(sec);
}

static struct sec_cmd sec_cmds[] = {
	{SEC_CMD("fw_update", fw_update),},
	{SEC_CMD_H("aot_enable", aot_enable),},
	{SEC_CMD_H("spay_enable", spay_enable),},
	{SEC_CMD("get_chip_vendor", get_chip_vendor),},
	{SEC_CMD("get_chip_name", get_chip_name),},
	{SEC_CMD("get_fw_ver_bin", get_fw_ver_bin),},
	{SEC_CMD("get_fw_ver_ic", get_fw_ver_ic),},
	{SEC_CMD("get_x_num", get_x_num),},
	{SEC_CMD("get_y_num", get_y_num),},
	{SEC_CMD("run_sram_test", run_sram_test),},
	{SEC_CMD("run_raw_test_read_all", run_raw_test_read_all),},
	{SEC_CMD("run_raw_doze_test_read_all", run_raw_doze_test_read_all),},
	{SEC_CMD("run_cal_dac_test_read", run_cal_dac_test_read),},
	{SEC_CMD("run_cal_dac_test_read_all", run_cal_dac_test_read_all),},
	{SEC_CMD("run_open_test_read_all", run_open_test_read_all),},
	{SEC_CMD("run_short_test_read", run_short_test_read),},
	{SEC_CMD("run_short_test_read_all", run_short_test_read_all),},
	{SEC_CMD("run_noise_test_read", run_noise_test_read),},
	{SEC_CMD("run_noise_test_read_all", run_noise_test_read_all),},
	{SEC_CMD("run_noise_doze_test_read_all", run_noise_doze_test_read_all),},
	{SEC_CMD("run_noise_test_read_lcdoff", run_noise_test_read_lcdoff),},
	{SEC_CMD("run_noise_test_read_all_lcdoff", run_noise_test_read_all_lcdoff),},
	{SEC_CMD("run_noise_doze_test_read_all_lcdoff", run_noise_doze_test_read_all_lcdoff),},
	{SEC_CMD("run_raw_doze_test_read_all_lcdoff", run_raw_doze_test_read_all_lcdoff),},
	{SEC_CMD("run_raw_test_read_all_lcdoff", run_raw_test_read_all_lcdoff),},
	{SEC_CMD("factory_cmd_result_all", factory_cmd_result_all),},
	{SEC_CMD("factory_lcdoff_cmd_result_all", factory_lcdoff_cmd_result_all),},
	{SEC_CMD_H("incell_power_control", incell_power_control),},
	{SEC_CMD("run_prox_intensity_read_all", run_prox_intensity_read_all),},
	{SEC_CMD_H("ear_detect_enable", ear_detect_enable),},
	{SEC_CMD_H("prox_lp_scan_mode", prox_lp_scan_mode),},
	{SEC_CMD("dead_zone_enable", dead_zone_enable),},
	{SEC_CMD("set_sip_mode", set_sip_mode),},
	{SEC_CMD("not_support_cmd", not_support_cmd),},
};

static ssize_t sensitivity_mode_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	int i;
	char tempv[10] = { 0 };
	char buff[SENSITIVITY_POINT_CNT * 10] = { 0 };

	for (i = 0; i < SENSITIVITY_POINT_CNT; i++) {
		if (i != 0)
			strlcat(buff, ",", sizeof(buff));
		snprintf(tempv, 10, "%d", ilits->sensitivity_info[i]);
		strlcat(buff, tempv, sizeof(buff));
	}

	input_info(true, ilits->dev, "%s: sensitivity mode : %s\n", __func__, buff);

	return snprintf(buf, SEC_CMD_BUF_SIZE, "%s", buff);
}

static ssize_t sensitivity_mode_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	int ret;
	unsigned long value = 0;

	if (ilits->tp_suspend) {
		input_err(true, ilits->dev, "%s failed(screen off state).\n", __func__);
		return -EINVAL;
	}

	if (count > 2)
		return -EINVAL;

	ret = kstrtoul(buf, 10, &value);
	if (ret != 0)
		return ret;

	input_info(true, ilits->dev, "%s: start on/off:%d\n", __func__, value);

	if (value)
		debug_mode_onoff(true);
	else
		debug_mode_onoff(false);

	input_info(true, ilits->dev, "%s: done\n", __func__);
	return count;
}

static ssize_t read_support_feature(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	u32 feature = 0;

	if (ilits->enable_settings_aot)
		feature |= INPUT_FEATURE_ENABLE_SETTINGS_AOT;

	if (ilits->enable_sysinput_enabled)
		feature |= INPUT_FEATURE_ENABLE_SYSINPUT_ENABLED;

	if (ilits->prox_lp_scan_enabled)
		feature |= INPUT_FEATURE_ENABLE_PROX_LP_SCAN_ENABLED;

	input_info(true, ilits->dev, "%s: %d%s%s%s\n",
				__func__, feature,
				feature & INPUT_FEATURE_ENABLE_SETTINGS_AOT ? " aot" : "",
				feature & INPUT_FEATURE_ENABLE_SYSINPUT_ENABLED ? " SE" : "",
				feature & INPUT_FEATURE_ENABLE_PROX_LP_SCAN_ENABLED ? " LPSCAN" : "");

	return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", feature);
}

static ssize_t prox_power_off_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	input_info(true, ilits->dev, "%s: %d\n", __func__,
			ilits->prox_power_off);

	return snprintf(buf, SEC_CMD_BUF_SIZE, "%ld", ilits->prox_power_off);
}

static ssize_t prox_power_off_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	long data;
	int ret;

	ret = kstrtol(buf, 10, &data);
	if (ret < 0)
		return ret;

	input_info(true, ilits->dev, "%s: %ld\n", __func__, data);

	ilits->prox_power_off = data;

	return count;
}

static ssize_t protos_event_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	input_info(true, ilits->dev, "%s: %d\n", __func__,
			ilits->proxmity_face);

	return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", ilits->proxmity_face != 3 ? 0 : 3);
}

static ssize_t protos_event_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	u8 data;
	int ret;

	ret = kstrtou8(buf, 10, &data);
	if (ret < 0)
		return ret;

	mutex_lock(&ilits->touch_mutex);
	input_info(true, ilits->dev, "%s: %d\n", __func__, data);

	if ((data != EAR_DETECT_DISABLE) && (data != EAR_DETECT_NORMAL_MODE) && (data != EAR_DETECT_INSENSITIVE_MODE)) {
		input_info(true, ilits->dev, "%s: Not supported value:%d\n", __func__, data);
		mutex_unlock(&ilits->touch_mutex);
		return count;
	}

	ilits->prox_face_mode = data;

	if (ilits->tp_suspend) {
		input_info(true, ilits->dev, "%s: now screen off stae, it'll setting after screen on(%d)\n", __func__, ilits->prox_face_mode);
		mutex_unlock(&ilits->touch_mutex);
		return count;
	}

	ret = ili_ic_func_ctrl("proximity", ilits->prox_face_mode);
	if (ret < 0)
		input_err(true, ilits->dev, "%s Ear Detect Mode Setting failed\n", __func__);

	mutex_unlock(&ilits->touch_mutex);
	return count;
}

static ssize_t enabled_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	input_info(true, ilits->dev, "%s: %d\n", __func__, ilits->screen_off_sate);

	return snprintf(buf, SEC_CMD_BUF_SIZE, "%d", ilits->screen_off_sate);
}

static ssize_t enabled_store(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
{
	int buff[2];
	int ret;

	ret = sscanf(buf, "%d,%d", &buff[0], &buff[1]);
	if (ret != 2) {
		input_err(true, ilits->dev,
				"%s: failed read params [%d]\n", __func__, ret);
		return -EINVAL;
	}

	input_info(true, ilits->dev, "%s: %d %d\n", __func__, buff[0], buff[1]);

	/* handle same sequence : buff[0] = LCD_ON, LCD_DOZE1, LCD_DOZE2*/
	if (buff[0] == LCD_DOZE1 || buff[0] == LCD_DOZE2)
		buff[0] = LCD_ON;

	switch (buff[0]) {
	case LCD_OFF:
		if (buff[1] == LCD_EARLY_EVENT) {
			if (ili_sleep_handler(TP_EARLY_SUSPEND) < 0)
				input_err(true, ilits->dev, "%s TP suspend failed\n", __func__);
		}
		break;
	case LCD_ON:
		if (buff[1] == LCD_EARLY_EVENT) {
			if ((ilits->screen_off_sate != TP_EARLY_RESUME) && (ilits->screen_off_sate != TP_RESUME))
				ili_sleep_handler(TP_EARLY_RESUME);
		} else if (buff[1] == LCD_LATE_EVENT) {
			if (ili_sleep_handler(TP_RESUME) < 0)
				input_err(true, ilits->dev, "%s TP resume failed\n", __func__);
		}
		break;
	default:
		ILI_DBG("%s Unknown event\n", __func__);
		break;
	}

	return count;
}
static DEVICE_ATTR(sensitivity_mode, S_IRUGO | S_IWUSR | S_IWGRP, sensitivity_mode_show, sensitivity_mode_store);
static DEVICE_ATTR(support_feature,  S_IRUGO, read_support_feature, NULL);
static DEVICE_ATTR(prox_power_off, S_IRUGO | S_IWUSR | S_IWGRP, prox_power_off_show, prox_power_off_store);
static DEVICE_ATTR(virtual_prox, S_IRUGO | S_IWUSR | S_IWGRP, protos_event_show, protos_event_store);
static DEVICE_ATTR(enabled, S_IRUGO | S_IWUSR | S_IWGRP, enabled_show, enabled_store);


static struct attribute *cmd_attributes[] = {
	&dev_attr_sensitivity_mode.attr,
	&dev_attr_support_feature.attr,
	&dev_attr_prox_power_off.attr,
	&dev_attr_virtual_prox.attr,
	&dev_attr_enabled.attr,
	NULL,
};

static struct attribute_group cmd_attr_group = {
	.attrs = cmd_attributes,
};

int ili_sec_fn_init(void)
{
	int retval;

	input_info(true, ilits->dev, "%s\n", __func__);
	retval = sec_cmd_init(&ilits->sec, sec_cmds,
			ARRAY_SIZE(sec_cmds), SEC_CLASS_DEVT_TSP);
	if (retval < 0) {
		input_err(true, ilits->dev,
						"%s: Failed to sec_cmd_init\n", __func__);
		goto exit;
	}

	retval = sysfs_create_group(&ilits->sec.fac_dev->kobj,
			&cmd_attr_group);
	if (retval < 0) {
		input_err(true, ilits->dev,
				"%s: Failed to create sysfs attributes\n", __func__);
		goto exit;
	}

	ilits->pFrame = kzalloc(ilits->panel_wid * ilits->panel_hei * sizeof(short), GFP_KERNEL);
	if (!ilits->pFrame) {
		input_err(true, ilits->dev,
				"%s: Failed to alloc memory pFrame\n", __func__);
		retval = -EINVAL;
		goto exit;
	}

	return 0;

exit:
	return retval;
}

void ili_sec_fn_remove(void)
{
	input_info(true, ilits->dev, "%s\n", __func__);

	kfree(ilits->pFrame);

	sysfs_remove_group(&ilits->sec.fac_dev->kobj,
			&cmd_attr_group);

	sec_cmd_exit(&ilits->sec, SEC_CLASS_DEVT_TSP);
}