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

struct sec_ts_data *tsp_info;

#include "sec_ts.h"

/* Switch GPIO values */
#define SEC_SWITCH_GPIO_VALUE_SLPI_MASTER	1
#define SEC_SWITCH_GPIO_VALUE_AP_MASTER		0

struct sec_ts_data *ts_dup;

#ifndef CONFIG_SEC_SYSFS
/* Declare extern sec_class */
struct class *sec_class;
#endif

#ifdef USE_POWER_RESET_WORK
static void sec_ts_reset_work(struct work_struct *work);
#endif
static void sec_ts_fw_update_work(struct work_struct *work);
static void sec_ts_suspend_work(struct work_struct *work);
static void sec_ts_resume_work(struct work_struct *work);
static void sec_ts_charger_work(struct work_struct *work);

#ifdef USE_OPEN_CLOSE
static int sec_ts_input_open(struct input_dev *dev);
static void sec_ts_input_close(struct input_dev *dev);
#endif

int sec_ts_read_information(struct sec_ts_data *ts);

#ifndef I2C_INTERFACE
int sec_ts_spi_delay(u8 reg)
{
	switch (reg) {
	case SEC_TS_READ_TOUCH_RAWDATA:
		return 400;
	case SEC_TS_CMD_HEATMAP_READ:
		return 500;
	case SEC_TS_READ_ALL_EVENT:
		return 500;
	case SEC_TS_READ_CSRAM_RTDP_DATA:
		return 500;
	case SEC_TS_CAAT_READ_STORED_DATA:
		return 500;
	case SEC_TS_CMD_FLASH_READ_DATA:
		return 1800;
	case SEC_TS_READ_FIRMWARE_INTEGRITY:
		return 20*1000;
	case SEC_TS_READ_SELFTEST_RESULT:
		return 3500;
	default: return 100;
	}
}

int sec_ts_spi_post_delay(u8 reg)
{
	switch (reg) {
	case SEC_TS_READ_TOUCH_RAWDATA:
	case SEC_TS_CMD_FLASH_READ_DATA:
	case SEC_TS_READ_SELFTEST_RESULT:
		return 500;
	default: return 0;
	}
}
#endif

int sec_ts_write(struct sec_ts_data *ts, u8 reg, u8 *data, int len)
{
	u8 *buf;
	int ret;
	unsigned char retry;
#ifdef I2C_INTERFACE
	struct i2c_msg msg;
#else
	struct spi_message msg;
	struct spi_transfer transfer[1] = { { 0 } };
	unsigned int i;
	unsigned int spi_len = 0;
	unsigned char checksum = 0x0;
#endif

	if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
		input_err(true, &ts->client->dev,
			"%s: POWER_STATUS : OFF\n", __func__);
		goto err;
	}

#ifdef I2C_INTERFACE
	if (len + 1 > sizeof(ts->io_write_buf)) {
		input_err(true, &ts->client->dev,
			"%s: len is larger than buffer size\n", __func__);
		return -EINVAL;
	}
#else
	/* add 3 zero stuffing tx bytes at last */
	if (SEC_TS_SPI_HEADER_SIZE + 1 + len + SEC_TS_SPI_CHECKSUM_SIZE + 3 >
		sizeof(ts->io_write_buf)) {
		input_err(true, &ts->client->dev,
			"%s: len is larger than buffer size\n", __func__);
		return -EINVAL;
	}
#endif

	mutex_lock(&ts->io_mutex);

	buf = ts->io_write_buf;
#ifdef I2C_INTERFACE
	buf[0] = reg;
	memcpy(buf + 1, data, len);

	msg.addr = ts->client->addr;
	msg.flags = 0;
	msg.len = len + 1;
	msg.buf = buf;
#else

	buf[0] = SEC_TS_SPI_SYNC_CODE;
	buf[1] = ((len + 1) >> 8) & 0xFF;
	buf[2] = (len + 1) & 0xFF;
	buf[3] = 0x00;
	buf[4] = 0x00;
	buf[5] = reg;
	memcpy(buf + SEC_TS_SPI_HEADER_SIZE + 1, data, len);

	spi_len = SEC_TS_SPI_HEADER_SIZE + 1 + len;
	// spi_len = SPI header size(5)+register(1)+data size(len)
	for (i = 0; i < spi_len ; i++)
		checksum += buf[i];
	buf[spi_len++] = checksum;
	// spi_len += checksum(1)

	spi_message_init(&msg);

	/* add 3 zero stuffing tx bytes at last */
	memset(ts->io_write_buf + spi_len, 0x00, 3);
	/* spi transfer size should be multiple of 4
	 **/
	spi_len = (spi_len + 3) & ~3;
	transfer[0].len = spi_len;
	transfer[0].tx_buf = buf;
	transfer[0].rx_buf = NULL;
	spi_message_add_tail(&transfer[0], &msg);

#ifdef SEC_TS_DEBUG_IO
	input_info(true, &ts->client->dev, "%s: ", __func__);
//	for (i = 0; i < SEC_TS_SPI_HEADER_SIZE + 1 + len + 1; i++)
	for (i = 0; i < 8; i++)
		input_info(true, &ts->client->dev, "%X ", buf[i]);
	input_info(true, &ts->client->dev, "\n");
#endif

#endif

	for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
#ifdef I2C_INTERFACE
		if ((ret = i2c_transfer(ts->client->adapter, &msg, 1)) == 1)
			break;
#else
		if ((ret = spi_sync(ts->client, &msg)) == 0)
			break;
#endif

		if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
			input_err(true, &ts->client->dev,
				  "%s: POWER_STATUS : OFF, retry:%d\n",
				  __func__, retry);
			mutex_unlock(&ts->io_mutex);
			goto err;
		}

		usleep_range(1 * 1000, 1 * 1000);

		if (retry > 1) {
			input_err(true, &ts->client->dev,
				  "%s: retry %d\n", __func__, retry + 1);
			ts->comm_err_count++;
		}
	}

	mutex_unlock(&ts->io_mutex);

	if (retry == SEC_TS_IO_RETRY_CNT) {
		input_err(true, &ts->client->dev,
			  "%s: write over retry limit\n", __func__);
		ret = -EIO;
#ifdef USE_POR_AFTER_I2C_RETRY
		if (ts->probe_done && !ts->reset_is_on_going)
			schedule_delayed_work(&ts->reset_work,
				msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
#endif
	}

#ifdef I2C_INTERFACE
	if (ret == 1)
#else
	if (ret == 0)
#endif
		return 0;
err:
	return -EIO;
}

static int sec_ts_read_internal(struct sec_ts_data *ts, u8 reg,
			     u8 *data, int len, bool dma_safe)
{
	u8 *buf;
	int ret;
	unsigned char retry;
#ifdef I2C_INTERFASCE
	struct i2c_msg msg[2];
#else
	struct spi_message msg;
	struct spi_transfer transfer[1] = { { 0 } };
	unsigned int i;
	unsigned int spi_write_len = 0, spi_read_len = 0;
	unsigned char write_checksum = 0x0, read_checksum = 0x0;
	int copy_size = 0, copy_cur = 0;
#endif
	int remain = len;

	if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
		input_err(true, &ts->client->dev,
			"%s: POWER_STATUS : OFF\n", __func__);
		goto err;
	}

#ifndef I2C_INTERFACE
	/* add 3 zero stuffing tx bytes at last */
	if (SEC_TS_SPI_HEADER_SIZE + 1 + SEC_TS_SPI_CHECKSUM_SIZE + 3 >
		sizeof(ts->io_write_buf)) {
		input_err(true, &ts->client->dev,
			"%s: len is larger than buffer size\n", __func__);
		return -EINVAL;
	}
#endif

	if (len > sizeof(ts->io_read_buf) && dma_safe == false) {
		input_err(true, &ts->client->dev,
			"%s: len %d over pre-allocated size %d\n",
			__func__, len, IO_PREALLOC_READ_BUF_SZ);
		return -ENOSPC;
	}

	mutex_lock(&ts->io_mutex);

	buf = ts->io_write_buf;
#ifdef I2C_INTERFACE
	buf[0] = reg;

	msg[0].addr = ts->client->addr;
	msg[0].flags = 0;
	msg[0].len = 1;
	msg[0].buf = buf;

	msg[1].addr = ts->client->addr;
	msg[1].flags = I2C_M_RD;
	msg[1].len = len;
	if (dma_safe == false)
		msg[1].buf = ts->io_read_buf;
	else
		msg[1].buf = data;
#else

	buf[0] = SEC_TS_SPI_SYNC_CODE;
	buf[1] = 0x00;
	buf[2] = 0x01;
	buf[3] = (len >> 8) & 0xFF;
	buf[4] = len & 0xFF;
	buf[5] = reg;

	spi_write_len = SEC_TS_SPI_HEADER_SIZE + 1;
	for (i = 0; i < spi_write_len; i++)
		write_checksum += buf[i];
	buf[spi_write_len] = write_checksum;
	spi_write_len += SEC_TS_SPI_CHECKSUM_SIZE;
	/* add 3 zero stuffing tx bytes at last */
	memset(ts->io_write_buf + spi_write_len, 0x00, 3);
	spi_write_len = (spi_write_len + 3) & ~3;

	spi_read_len = len +
		SEC_TS_SPI_READ_HEADER_SIZE + SEC_TS_SPI_CHECKSUM_SIZE;
	spi_read_len = (spi_read_len + 3) & ~3;
#endif
	if (len <= ts->io_burstmax) {
#ifdef I2C_INTERFACE
		for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
			ret = i2c_transfer(ts->client->adapter, msg, 2);
			if (ret == 2)
				break;

			usleep_range(1 * 1000, 1 * 1000);
			if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
				input_err(true, &ts->client->dev,
					  "%s: POWER_STATUS : OFF, retry:%d\n",
					  __func__, retry);
				mutex_unlock(&ts->io_mutex);
				goto err;
			}

			if (retry > 1) {
				input_err(true, &ts->client->dev,
					"%s: retry %d\n", __func__, retry + 1);
				ts->comm_err_count++;
			}
		}
		if (ret == 2 && dma_safe == false)
			memcpy(data,
			       ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE],
			       len);
#else
		for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
			spi_message_init(&msg);
			// spi transfer size should be multiple of 4
			transfer[0].len = spi_write_len;
			transfer[0].tx_buf = buf;
			transfer[0].rx_buf = NULL;
			spi_message_add_tail(&transfer[0], &msg);

			ret = spi_sync(ts->client, &msg);
#ifdef SEC_TS_DEBUG_IO
			input_info(true, &ts->client->dev,
				"%s: spi write buf %X %X %X %X %X %X %X\n",
				__func__, buf[0], buf[1], buf[2],
				buf[3], buf[4], buf[5], buf[6]);
#endif
			// write fail
			if (ret != 0) {
				ret = -EIO;

				input_err(true, &ts->client->dev,
					"%s: spi write retry %d\n",
					__func__, retry + 1);
				ts->comm_err_count++;

				usleep_range(1 * 1000, 1 * 1000);
				if (ts->power_status ==
					SEC_TS_STATE_POWER_OFF) {
					input_err(true, &ts->client->dev,
						"%s: POWER_STATUS : OFF, retry:%d\n",
						__func__, retry);
					mutex_unlock(&ts->io_mutex);
					goto err;
				}

				if (retry == SEC_TS_IO_RETRY_CNT - 1) {
					input_err(true, &ts->client->dev,
						"%s: write reg retry over retry limit, skip read\n",
						__func__);
					goto skip_spi_read;
				}

				continue;
			}

			usleep_range(sec_ts_spi_delay(reg),
					sec_ts_spi_delay(reg) + 1);

			// read sequence start
			spi_message_init(&msg);
			transfer[0].len = spi_read_len;
			transfer[0].tx_buf = NULL;
			transfer[0].rx_buf = ts->io_read_buf;
			spi_message_add_tail(&transfer[0], &msg);
			ret = spi_sync(ts->client, &msg);

			for (i = 0, read_checksum = 0x0;
				i < (SEC_TS_SPI_READ_HEADER_SIZE + len);
				i++)
				read_checksum += ts->io_read_buf[i];

#ifdef SEC_TS_DEBUG_IO
			input_info(true, &ts->client->dev, "%s: ", __func__);
//			for (i = 0; i < spi_read_len; i++)
			for (i = 0; i < 8; i++)
				input_info(true, &ts->client->dev,
					"%X ",
					ts->io_read_buf[i]);
			input_info(true, &ts->client->dev,
				"\n%s: checksum = %X",
				__func__, read_checksum);
#endif
			// read fail
			if (ret != 0 ||
				ts->io_read_buf[0] != SEC_TS_SPI_SYNC_CODE ||
				reg != ts->io_read_buf[5] ||
				// ts->io_read_buf[6] != SEC_TS_SPI_CMD_OK ||
				read_checksum !=
					ts->io_read_buf[
						SEC_TS_SPI_READ_HEADER_SIZE +
					len]) {

				ret = -EIO;

				input_err(true, &ts->client->dev,
					"%s: retry %d\n",
					__func__, retry + 1);
				ts->comm_err_count++;

				usleep_range(1 * 1000, 1 * 1000);
				if (ts->power_status ==
					SEC_TS_STATE_POWER_OFF) {
					input_err(true, &ts->client->dev,
						"%s: POWER_STATUS : OFF, retry:%d\n",
						__func__, retry);
					mutex_unlock(&ts->io_mutex);
					goto err;
				}
				continue;
			} else
				break;
		}
		if (ret == 0)
			memcpy(data, ts->io_read_buf +
			       SEC_TS_SPI_READ_HEADER_SIZE, len);

		usleep_range(sec_ts_spi_post_delay(reg),
			     sec_ts_spi_post_delay(reg) + 1);

#endif //I2C_INTERFACE
	} else {
		/*
		 * read buffer is 256 byte. do not support long buffer over
		 * than 256. So, try to separate reading data about 256 bytes.
		 **/
#ifdef I2C_INTERFACE
		for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
			ret = i2c_transfer(ts->client->adapter, msg, 1);
			if (ret == 1)
				break;

			usleep_range(1 * 1000, 1 * 1000);
			if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
				input_err(true, &ts->client->dev,
					"%s: POWER_STATUS : OFF, retry:%d\n",
					__func__, retry);
				mutex_unlock(&ts->io_mutex);
				goto err;
			}

			if (retry > 1) {
				input_err(true, &ts->client->dev,
					"%s: retry %d\n",
					__func__, retry + 1);
				ts->comm_err_count++;
			}
		}

		do {
			if (remain > ts->io_burstmax)
				msg[1].len = ts->io_burstmax;
			else
				msg[1].len = remain;

			remain -= ts->io_burstmax;

			for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
				ret = i2c_transfer(ts->client->adapter,
						   &msg[1], 1);
				if (ret == 1)
					break;
				usleep_range(1 * 1000, 1 * 1000);
				if (ts->power_status ==
					SEC_TS_STATE_POWER_OFF) {
					input_err(true, &ts->client->dev,
						"%s: POWER_STATUS : OFF, retry:%d\n",
						__func__, retry);
					mutex_unlock(&ts->io_mutex);
					goto err;
				}

				if (retry > 1) {
					input_err(true, &ts->client->dev,
						"%s: retry %d\n",
						__func__, retry + 1);
					ts->comm_err_count++;
				}
			}

			msg[1].buf += msg[1].len;

		} while (remain > 0);

		if (ret == 1 && dma_safe == false)
			memcpy(data, ts->io_read_buf, len);
#else
		for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
			spi_message_init(&msg);
			// spi transfer size should be multiple of 4
			transfer[0].len = spi_write_len;
			transfer[0].tx_buf = buf;
			transfer[0].rx_buf = NULL;
			spi_message_add_tail(&transfer[0], &msg);

			ret = spi_sync(ts->client, &msg);

			// write fail
			if (ret != 0) {
				ret = -EIO;

				input_err(true, &ts->client->dev,
					"%s: spi write retry %d\n",
					__func__, retry + 1);
				ts->comm_err_count++;

				usleep_range(1 * 1000, 1 * 1000);

				if (ts->power_status ==
					SEC_TS_STATE_POWER_OFF) {
					input_err(true, &ts->client->dev,
						"%s: POWER_STATUS : OFF, retry:%d\n",
						__func__, retry);
					mutex_unlock(&ts->io_mutex);
					goto err;
				}

				if (retry == SEC_TS_IO_RETRY_CNT - 1) {
					input_err(true, &ts->client->dev,
						"%s: write reg retry over retry limit, skip read\n",
						__func__);
					goto skip_spi_read;
				}

				continue;
			}

			usleep_range(sec_ts_spi_delay(reg),
					sec_ts_spi_delay(reg) + 1);

			copy_size = 0;
			remain = spi_read_len;
			do {
				if (remain > ts->io_burstmax)
					copy_cur = ts->io_burstmax;
				else
					copy_cur = remain;

				spi_message_init(&msg);

				transfer[0].len = copy_cur;
				transfer[0].tx_buf = NULL;
				transfer[0].rx_buf =
					&ts->io_read_buf[copy_size];
				// CS needs to stay low until read seq. is done
				transfer[0].cs_change =
					(remain > ts->io_burstmax) ? 1 : 0;

				spi_message_add_tail(&transfer[0], &msg);

				copy_size += copy_cur;
				remain -= copy_cur;

				ret = spi_sync(ts->client, &msg);
#ifdef SEC_TS_DEBUG_IO
				input_info(true, &ts->client->dev,
					"%s: ", __func__);
				for (i = 0; i < 8; i++)
					input_info(true,
						   &ts->client->dev, "%X ",
						   ts->io_read_buf[i]);
				input_info(true, &ts->client->dev,
					"\n%s: checksum = %X",
					__func__, read_checksum);
#endif

				if (ret != 0) {
					ret = -EIO;

					input_err(true, &ts->client->dev,
						"%s: retry %d\n",
						__func__, retry + 1);
					ts->comm_err_count++;

					usleep_range(1 * 1000, 1 * 1000);
					if (ts->power_status
						== SEC_TS_STATE_POWER_OFF) {
						input_err(true,
							&ts->client->dev,
							"%s: POWER_STATUS : OFF, retry:%d\n",
							__func__, retry);
						mutex_unlock(&ts->io_mutex);
						goto err;
					}
					break;
				}
			} while (remain > 0);
			if (ret != 0) { // read fail, retry
				ret = -EIO;
				continue;
			}

			for (i = 0, read_checksum = 0x0;
				i < SEC_TS_SPI_READ_HEADER_SIZE + len; i++)
				read_checksum += ts->io_read_buf[i];
			//read success
			if (ts->io_read_buf[0] == SEC_TS_SPI_SYNC_CODE &&
				// ts->io_read_buf[6] == SEC_TS_SPI_CMD_OK &&
				reg == ts->io_read_buf[5] &&
				read_checksum ==
				ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE +
				len])
				break;
			//read data fail
			else if (ts->io_read_buf[6]
				 == SEC_TS_SPI_CMD_UNKNOWN ||
				 ts->io_read_buf[6]
				 == SEC_TS_SPI_CMD_BAD_PARAM) {
				input_info(true, &ts->client->dev,
					"%s: CMD_NG cmd(M) = %X, cmd(S) = %X, cmd_result = %X\n",
					__func__, reg, ts->io_read_buf[5],
					ts->io_read_buf[6]);
				ret = -EIO;
				continue;
			} else {
				input_info(true, &ts->client->dev,
					"%s: spi fail, ret %d, sync code %X, reg(M) %X, reg(S) %X, cmd_result %X, chksum(M) %X, chksum(S) %X\n",
					__func__, ret, ts->io_read_buf[0],
					reg, ts->io_read_buf[5],
					ts->io_read_buf[6], read_checksum,
					ts->io_read_buf[
						SEC_TS_SPI_READ_HEADER_SIZE +
					len]);
				ret = -EIO;
				continue;
			}
		}
		if (ret == 0)
			memcpy(data, ts->io_read_buf +
				SEC_TS_SPI_READ_HEADER_SIZE, len);

		usleep_range(sec_ts_spi_post_delay(reg),
			     sec_ts_spi_post_delay(reg) + 1);
#endif
	}
skip_spi_read:
	mutex_unlock(&ts->io_mutex);

	if (retry == SEC_TS_IO_RETRY_CNT) {
		input_err(true, &ts->client->dev,
			"%s: read reg(%#x) over retry limit, comm_err_count %d, io_err_count %d\n",
			__func__, reg, ts->comm_err_count, ts->io_err_count);
		ret = -EIO;
		ts->io_err_count++;
#ifdef USE_POR_AFTER_I2C_RETRY
		if (ts->probe_done && !ts->reset_is_on_going)
			schedule_delayed_work(&ts->reset_work,
				msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
#endif

	} else
		ts->io_err_count = 0;

	/* do hw reset if continuously failed over SEC_TS_IO_RESET_CNT times */
	if (ts->io_err_count >= SEC_TS_IO_RESET_CNT) {
		ts->io_err_count = 0;
		sec_ts_hw_reset(ts);
	}

	return ret;

err:
	return -EIO;
}

static int sec_ts_write_burst_internal(struct sec_ts_data *ts,
					   u8 *data, int len, bool dma_safe)
{
	int ret;
	int retry;
#ifndef I2C_INTERFACE
	struct spi_message msg;
	struct spi_transfer transfer[1] = { { 0 } };
	unsigned int i;
	unsigned int spi_len = 0;
	unsigned char checksum = 0x0;
#endif

#ifdef I2C_INTERFACE
	if (len > sizeof(ts->io_write_buf) && dma_safe == false) {
		input_err(true, &ts->client->dev,
			"%s: len %d over pre-allocated size %d\n",
			__func__, len, sizeof(ts->io_write_buf));
		return -ENOSPC;
	}
#else
	/* add 3 zero stuffing tx bytes at last */
	if (SEC_TS_SPI_HEADER_SIZE + len + SEC_TS_SPI_CHECKSUM_SIZE + 3 >
		sizeof(ts->io_write_buf)) {
		input_err(true, &ts->client->dev,
			"%s: len is larger than buffer size\n", __func__);
		return -EINVAL;
	}
#endif

	mutex_lock(&ts->io_mutex);
#ifdef I2C_INTERFACE
	if (dma_safe == false) {
		memcpy(ts->io_write_buf, data, len);
		data = ts->io_write_buf;
	}
#else

	ts->io_write_buf[0] = SEC_TS_SPI_SYNC_CODE;
	ts->io_write_buf[1] = (len >> 8) & 0xFF;
	ts->io_write_buf[2] = len & 0xFF;
	ts->io_write_buf[3] = 0x0;
	ts->io_write_buf[4] = 0x0;

	memcpy(ts->io_write_buf + SEC_TS_SPI_HEADER_SIZE, data, len);


	spi_len = SEC_TS_SPI_HEADER_SIZE + len;
	for (i = 0; i < spi_len; i++)
		checksum += ts->io_write_buf[i];

	ts->io_write_buf[spi_len] = checksum;
	spi_len += SEC_TS_SPI_CHECKSUM_SIZE;

	spi_message_init(&msg);

	/* add 3 zero stuffing tx bytes at last */
	memset(ts->io_write_buf + spi_len, 0x00, 3);
	spi_len = (spi_len + 3) & ~3;
	transfer[0].len = spi_len;
	transfer[0].tx_buf = ts->io_write_buf;
	transfer[0].rx_buf = NULL;
	spi_message_add_tail(&transfer[0], &msg);

#ifdef SEC_TS_DEBUG_IO
	input_info(true, &ts->client->dev, "%s:\n", __func__);
	for (i = 0; i < spi_len; i++)
		input_info(true, &ts->client->dev, "%X ", ts->io_write_buf[i]);
	input_info(true, &ts->client->dev, "\n");
#endif

#endif

	for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
#ifdef I2C_INTERFACE
		if ((ret = i2c_master_send(ts->client, data, len)) == len)
			break;
#else
		if ((ret = spi_sync(ts->client, &msg)) == 0)
			break;
#endif

		usleep_range(1 * 1000, 1 * 1000);

		if (retry > 1) {
			input_err(true, &ts->client->dev,
				  "%s: retry %d\n", __func__, retry + 1);
			ts->comm_err_count++;
		}
	}

	mutex_unlock(&ts->io_mutex);
	if (retry == SEC_TS_IO_RETRY_CNT) {
		input_err(true, &ts->client->dev,
			  "%s: write over retry limit\n", __func__);
		ret = -EIO;
	}

	return ret;
}

static int sec_ts_read_bulk_internal(struct sec_ts_data *ts,
					 u8 *data, int len, bool dma_safe)
{
	int ret;
	unsigned char retry;
	int remain = len;
#ifdef I2C_INTERFACE
	struct i2c_msg msg;
#else
	struct spi_message msg;
	struct spi_transfer transfer[1] = { { 0 } };
	unsigned int i;
	unsigned int spi_len = 0;
	unsigned char checksum = 0x0;
	int copy_size = 0, copy_cur = 0;
	int retry_msg = 0;
#endif

	if (len > sizeof(ts->io_read_buf) && dma_safe == false) {
		input_err(true, &ts->client->dev,
			  "%s: len %d over pre-allocated size %d\n", __func__,
			  len, sizeof(ts->io_read_buf));
		return -ENOSPC;
	}

	mutex_lock(&ts->io_mutex);

#ifdef I2C_INTERFACE
	msg.addr = ts->client->addr;
	msg.flags = I2C_M_RD;
	msg.len = len;
	if (dma_safe == false)
		msg.buf = ts->io_read_buf;
	else
		msg.buf = data;

	do {
		if (remain > ts->io_burstmax)
			msg.len = ts->io_burstmax;
		else
			msg.len = remain;

		remain -= ts->io_burstmax;

		for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
			ret = i2c_transfer(ts->client->adapter, &msg, 1);
			if (ret == 1)
				break;
			usleep_range(1 * 1000, 1 * 1000);

			if (retry > 1) {
				input_err(true, &ts->client->dev,
					  "%s: retry %d\n",
					  __func__, retry + 1);
				ts->comm_err_count++;
			}
		}

		if (retry == SEC_TS_IO_RETRY_CNT) {
			input_err(true, &ts->client->dev,
				  "%s: read over retry limit\n", __func__);
			ret = -EIO;
			break;
		}

		msg.buf += msg.len;

	} while (remain > 0);

	if (ret == 1 && dma_safe == false)
		memcpy(data, ts->io_read_buf, len);
#else
retry_message:
	remain = spi_len = (SEC_TS_SPI_READ_HEADER_SIZE + len +
			    SEC_TS_SPI_CHECKSUM_SIZE + 3) & ~3;
	do {
		if (remain > ts->io_burstmax)
			copy_cur = ts->io_burstmax;
		else
			copy_cur = remain;

		spi_message_init(&msg);
		transfer[0].len = copy_cur;
		transfer[0].tx_buf = NULL;
		transfer[0].rx_buf = &ts->io_read_buf[copy_size];
		/* CS needs to stay low until read seq. is done
		 */
		transfer[0].cs_change = (remain > ts->io_burstmax) ? 1 : 0;

		spi_message_add_tail(&transfer[0], &msg);

		copy_size += copy_cur;
		remain -= copy_cur;

		for (retry = 0; retry < SEC_TS_IO_RETRY_CNT; retry++) {
			ret = spi_sync(ts->client, &msg);
			if (ret == 0)
				break;

			usleep_range(1 * 1000, 1 * 1000);
			if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
				input_err(true, &ts->client->dev,
					  "%s: POWER_STATUS : OFF, retry:%d\n",
					  __func__, retry);
				mutex_unlock(&ts->io_mutex);
				goto err;
			}

			if (retry > 1) {
				input_err(true, &ts->client->dev,
					"%s: retry %d\n", __func__, retry + 1);
				ts->comm_err_count++;
			}
		}
	} while (remain > 0);

	for (i = 0, checksum = 0; i < SEC_TS_SPI_READ_HEADER_SIZE + len; i++)
		checksum += ts->io_read_buf[i];

	if (ret == 0 && ts->io_read_buf[0] == SEC_TS_SPI_SYNC_CODE &&
		checksum == ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE + len])
		memcpy(data, ts->io_read_buf + SEC_TS_SPI_READ_HEADER_SIZE,
		       len);
	else {
		input_info(true, &ts->client->dev,
			   "%s: spi fail, ret %d, sync code %X, reg(S) %X, chksum(M) %X, chksum(S) %X\n",
			__func__, ret, ts->io_read_buf[0], ts->io_read_buf[5],
			checksum,
			ts->io_read_buf[SEC_TS_SPI_READ_HEADER_SIZE + len]);
		if (retry_msg++ < SEC_TS_IO_RETRY_CNT)
			goto retry_message;
	}
#endif
	mutex_unlock(&ts->io_mutex);

#ifdef I2C_INTERFACE
	if (ret == 1)
#else
	if (ret == 0)
#endif
		return 0;
err:
	return -EIO;
}

/* Wrapper API for read and write */
int sec_ts_read(struct sec_ts_data *ts, u8 reg, u8 *data, int len)
{
	return sec_ts_read_internal(ts, reg, data, len, false);
}

int sec_ts_read_heap(struct sec_ts_data *ts, u8 reg, u8 *data, int len)
{
	return sec_ts_read_internal(ts, reg, data, len, true);
}

int sec_ts_write_burst(struct sec_ts_data *ts, u8 *data, int len)
{
	return sec_ts_write_burst_internal(ts, data, len, false);
}

int sec_ts_write_burst_heap(struct sec_ts_data *ts, u8 *data, int len)
{
	return sec_ts_write_burst_internal(ts, data, len, true);
}

int sec_ts_read_bulk(struct sec_ts_data *ts, u8 *data, int len)
{
	return sec_ts_read_bulk_internal(ts, data, len, false);
}

int sec_ts_read_bulk_heap(struct sec_ts_data *ts, u8 *data, int len)
{
	return sec_ts_read_bulk_internal(ts, data, len, true);
}

static int sec_ts_read_from_customlib(struct sec_ts_data *ts, u8 *data, int len)
{
	int ret;

	ret = sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_READ_PARAM, data, 2);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			"%s: fail to read custom library command\n", __func__);

	ret = sec_ts_read(ts, SEC_TS_CMD_CUSTOMLIB_READ_PARAM, (u8 *)data, len);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			"%s: fail to read custom library command\n", __func__);

	return ret;
}

#if defined(CONFIG_TOUCHSCREEN_DUMP_MODE)
#include <linux/sec_debug.h>
extern struct tsp_dump_callbacks dump_callbacks;
static struct delayed_work *p_ghost_check;

static void sec_ts_check_rawdata(struct work_struct *work)
{
	struct sec_ts_data *ts = container_of(work, struct sec_ts_data,
					      ghost_check.work);

	if (ts->tsp_dump_lock == 1) {
		input_err(true, &ts->client->dev,
			  "%s: ignored ## already checking..\n", __func__);
		return;
	}
	if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
		input_err(true, &ts->client->dev,
			  "%s: ignored ## IC is power off\n", __func__);
		return;
	}

	ts->tsp_dump_lock = 1;
	input_info(true, &ts->client->dev, "%s: start ##\n", __func__);
	sec_ts_run_rawdata_all((void *)ts, false);
	msleep(100);

	input_info(true, &ts->client->dev, "%s: done ##\n", __func__);
	ts->tsp_dump_lock = 0;

}

static void dump_tsp_log(void)
{
	pr_info("%s: %s %s: start\n", SEC_TS_NAME, SECLOG, __func__);

#ifdef CONFIG_BATTERY_SAMSUNG
	if (lpcharge == 1) {
		pr_err("%s: %s %s: ignored ## lpm charging Mode!!\n",
		       SEC_TS_NAME, SECLOG, __func__);
		return;
	}
#endif

	if (p_ghost_check == NULL) {
		pr_err("%s: %s %s: ignored ## tsp probe fail!!\n",
		       SEC_TS_NAME, SECLOG, __func__);
		return;
	}
	schedule_delayed_work(p_ghost_check, msecs_to_jiffies(100));
}
#endif


void sec_ts_delay(unsigned int ms)
{
	if (ms < 20)
		usleep_range(ms * 1000, ms * 1000);
	else
		msleep(ms);
}

int sec_ts_wait_for_ready(struct sec_ts_data *ts, unsigned int ack)
{
	return sec_ts_wait_for_ready_with_count(ts, ack,
						SEC_TS_WAIT_RETRY_CNT);
}

int sec_ts_wait_for_ready_with_count(struct sec_ts_data *ts, unsigned int ack,
				     unsigned int count)
{
	int rc = -1;
	int retry = 0;
	u8 tBuff[SEC_TS_EVENT_BUFF_SIZE] = {0,};

	while (retry < count) {
		if (sec_ts_read(ts, SEC_TS_READ_ONE_EVENT, tBuff,
			SEC_TS_EVENT_BUFF_SIZE) >= 0) {
			if (((tBuff[0] >> 2) & 0xF) == TYPE_STATUS_EVENT_INFO) {
				if (tBuff[1] == ack) {
					rc = 0;
					break;
				}
			} else if (((tBuff[0] >> 2) & 0xF) ==
				   TYPE_STATUS_EVENT_VENDOR_INFO) {
				if (tBuff[1] == ack) {
					rc = 0;
					break;
				}
			}
		}
		sec_ts_delay(20);
		retry++;
	}
	if (retry == count)
		input_err(true, &ts->client->dev, "%s: Time Over\n",
			__func__);

	input_info(true, &ts->client->dev,
		"%s: %02X, %02X, %02X, %02X, %02X, %02X, %02X, %02X [%d]\n",
		__func__, tBuff[0], tBuff[1], tBuff[2], tBuff[3],
		tBuff[4], tBuff[5], tBuff[6], tBuff[7], retry);

	return rc;
}

int sec_ts_read_calibration_report(struct sec_ts_data *ts)
{
	int ret;

	memset(ts->cali_report, 0, sizeof(ts->cali_report));
	ret = sec_ts_read(ts, SEC_TS_READ_CALIBRATION_REPORT,
		ts->cali_report, sizeof(ts->cali_report));
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: failed to read, %d\n", __func__, ret);
		return ret;
	}

	input_info(true, &ts->client->dev,
		"%s: count:%d, pass count:%d, fail count:%d, status:%X, param version:%X %X %X %X\n",
		__func__, ts->cali_report_try_cnt, ts->cali_report_pass_cnt,
		ts->cali_report_fail_cnt, ts->cali_report_status,
		ts->cali_report_param_ver[0], ts->cali_report_param_ver[1],
		ts->cali_report_param_ver[2], ts->cali_report_param_ver[3]);

	return ts->cali_report_status;
}

static void sec_ts_reinit(struct sec_ts_data *ts)
{
	u8 w_data[2] = {0x00, 0x00};
	int ret = 0;

	input_info(true, &ts->client->dev,
		"%s : charger=0x%x, Cover=0x%x, Power mode=0x%x\n",
		__func__, ts->charger_mode, ts->touch_functions,
		ts->lowpower_status);

	/* charger mode */
	if (ts->charger_mode != SEC_TS_BIT_CHARGER_MODE_NO) {
		w_data[0] = ts->charger_mode;
		ret = ts->sec_ts_write(ts, SET_TS_CMD_SET_CHARGER_MODE,
				       (u8 *)&w_data[0], 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: Failed to send command(0x%x)",
				__func__, SET_TS_CMD_SET_CHARGER_MODE);
	}

	/* Cover mode */
	if (ts->touch_functions & SEC_TS_BIT_SETFUNC_COVER) {
		w_data[0] = ts->cover_cmd;
		ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE,
				   (u8 *)&w_data[0], 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: Failed to send command(0x%x)",
				__func__, SEC_TS_CMD_SET_COVERTYPE);

		ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
				   (u8 *)&(ts->touch_functions), 2);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: Failed to send command(0x%x)",
				__func__, SEC_TS_CMD_SET_TOUCHFUNCTION);
	}

	#ifdef SEC_TS_SUPPORT_CUSTOMLIB
	if (ts->use_customlib)
		sec_ts_set_custom_library(ts);
	#endif

	/* Power mode */
	if (ts->lowpower_status == TO_LOWPOWER_MODE) {
		w_data[0] = (ts->lowpower_mode &
			     SEC_TS_MODE_LOWPOWER_FLAG) >> 1;
		ret = sec_ts_write(ts, SEC_TS_CMD_WAKEUP_GESTURE_MODE,
				   (u8 *)&w_data[0], 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: Failed to send command(0x%x)",
				__func__, SEC_TS_CMD_WAKEUP_GESTURE_MODE);

		w_data[0] = TO_LOWPOWER_MODE;
		ret = sec_ts_write(ts, SEC_TS_CMD_SET_POWER_MODE,
				   (u8 *)&w_data[0], 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: Failed to send command(0x%x)",
				__func__, SEC_TS_CMD_SET_POWER_MODE);

		sec_ts_delay(50);

		if (ts->lowpower_mode & SEC_TS_MODE_CUSTOMLIB_AOD) {
			int i, ret;
			u8 data[10] = {0x02, 0};

			for (i = 0; i < 4; i++) {
				data[i * 2 + 2] = ts->rect_data[i] & 0xFF;
				data[i * 2 + 3] =
					(ts->rect_data[i] >> 8) & 0xFF;
			}

			ret = ts->sec_ts_write(ts,
					SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM,
					&data[0], 10);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: Failed to write offset\n",
					__func__);

			ret = ts->sec_ts_write(ts,
				SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: Failed to send notify\n",
					__func__);

		}

	} else {

		sec_ts_set_grip_type(ts, ONLY_EDGE_HANDLER);

		if (ts->dex_mode) {
			input_info(true, &ts->client->dev,
				   "%s: set dex mode\n", __func__);
			ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE,
					       &ts->dex_mode, 1);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: failed to set dex mode %x\n",
					__func__, ts->dex_mode);
		}

		if (ts->brush_mode) {
			input_info(true, &ts->client->dev,
				   "%s: set brush mode\n", __func__);
			ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE,
					       &ts->brush_mode, 1);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: failed to set brush mode\n",
					__func__);
		}

		if (ts->touchable_area) {
			input_info(true, &ts->client->dev,
				   "%s: set 16:9 mode\n", __func__);
			ret = ts->sec_ts_write(ts,
					SEC_TS_CMD_SET_TOUCHABLE_AREA,
					&ts->touchable_area, 1);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: failed to set 16:9 mode\n",
					__func__);
		}

	}
}

#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
/* Update a state machine used to toggle control of the touch IC's motion
 * filter.
 */
static void update_motion_filter(struct sec_ts_data *ts)
{
	/* Motion filter timeout, in milliseconds */
	const u32 mf_timeout_ms = 500;
	u8 next_state;
	/* Count the active touches */
	u8 touches = hweight32(ts->tid_touch_state);

	if (ts->use_default_mf)
		return;

	/* Determine the next filter state. The motion filter is enabled by
	 * default and it is disabled while a single finger is touching the
	 * screen. If another finger is touched down or if a timeout expires,
	 * the motion filter is reenabled and remains enabled until all fingers
	 * are lifted.
	 */
	next_state = ts->mf_state;
	switch (ts->mf_state) {
	case SEC_TS_MF_FILTERED:
		if (touches == 1) {
			next_state = SEC_TS_MF_UNFILTERED;
			ts->mf_downtime = ktime_get();
		}
		break;
	case SEC_TS_MF_UNFILTERED:
		if (touches == 0) {
			next_state = SEC_TS_MF_FILTERED;
		} else if (touches > 1 ||
			   ktime_after(ktime_get(),
				       ktime_add_ms(ts->mf_downtime,
						    mf_timeout_ms))) {
			next_state = SEC_TS_MF_FILTERED_LOCKED;
		}
		break;
	case SEC_TS_MF_FILTERED_LOCKED:
		if (touches == 0)
			next_state = SEC_TS_MF_FILTERED;
		break;
	}

	/* Send command to update filter state */
	if ((next_state == SEC_TS_MF_UNFILTERED) !=
	    (ts->mf_state == SEC_TS_MF_UNFILTERED)) {
		int ret;
		u8 para;

		pr_debug("%s: setting motion filter = %s.\n", __func__,
			 (next_state == SEC_TS_MF_UNFILTERED) ?
			 "false" : "true");
		para = (next_state == SEC_TS_MF_UNFILTERED) ? 0x01 : 0x00;
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_CONT_REPORT,
				       &para, 1);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
			 "%s: write reg %#x para %#x failed, returned %i\n",
			__func__, SEC_TS_CMD_SET_CONT_REPORT, para, ret);
		}
	}
	ts->mf_state = next_state;
}

static bool read_heatmap_raw(struct v4l2_heatmap *v4l2)
{
	struct sec_ts_data *ts = container_of(v4l2, struct sec_ts_data, v4l2);
	const struct sec_ts_plat_data *pdata = ts->plat_data;
	int result;
	int max_x = v4l2->format.width;
	int max_y = v4l2->format.height;

	if (ts->tsp_dump_lock == 1) {
		input_info(true, &ts->client->dev,
			"%s: drop this because raw data reading by others\n",
			__func__);
		return false;
	}

	if (pdata->heatmap_mode == HEATMAP_PARTIAL) {
		strength_t heatmap_value;
		int heatmap_x, heatmap_y;
		/* index for through the heatmap buffer read over the bus */
		unsigned int local_i;
		/* final position of the heatmap value in the full frame */
		unsigned int frame_i;
		unsigned int num_elements;
		u8 enable;
		struct heatmap_report report = {0};

		result = sec_ts_read(ts,
			SEC_TS_CMD_HEATMAP_ENABLE, &enable, 1);
		if (result < 0) {
			input_err(true, &ts->client->dev,
				 "%s: read reg %#x failed, returned %i\n",
				__func__, SEC_TS_CMD_HEATMAP_ENABLE, result);
			return false;
		}

		if (!enable) {
			enable = 1;
			result = sec_ts_write(ts,
				SEC_TS_CMD_HEATMAP_ENABLE, &enable, 1);
			if (result < 0)
				input_err(true, &ts->client->dev,
					"%s: enable local heatmap failed, returned %i\n",
					__func__, result);
			/*
			 * After local heatmap enabled, it takes `1/SCAN_RATE`
			 * time to make data ready. But, we don't want to wait
			 * here to cause overhead. Just drop this and wait for
			 * next reading.
			 */
			return false;
		}

		result = sec_ts_read(ts, SEC_TS_CMD_HEATMAP_READ,
			(uint8_t *) &report, sizeof(report));
		if (result < 0) {
			input_err(true, &ts->client->dev,
				 "%s: read failed, returned %i\n",
				__func__, result);
			return false;
		}

		num_elements = report.size_x * report.size_y;
		if (num_elements > LOCAL_HEATMAP_WIDTH * LOCAL_HEATMAP_HEIGHT) {
			input_err(true, &ts->client->dev,
				"Unexpected heatmap size: %i x %i",
				report.size_x, report.size_y);
				return false;
		}

		/*
		 * Set all to zero, will only write to non-zero locations
		 * in the loop.
		 */
		memset(v4l2->frame, 0, v4l2->format.sizeimage);
		/* populate the data buffer, rearranging into final locations */
		for (local_i = 0; local_i < num_elements; local_i++) {
			/* big-endian order raw data into heatmap data type */
			be16_to_cpus(&report.data[local_i]);
			heatmap_value = report.data[local_i];

			if (heatmap_value == 0) {
				/*
				 * Already initialized to zero. More
				 * importantly, samples around edges may go out
				 * of bounds.
				 * If their value is zero, this is ok.
				 */
				continue;
			}
			heatmap_x = report.offset_x + (local_i % report.size_x);
			heatmap_y = report.offset_y + (local_i / report.size_x);

			if (heatmap_x < 0 || heatmap_x >= max_x ||
				heatmap_y < 0 || heatmap_y >= max_y) {
				input_err(true, &ts->client->dev,
					"Invalid x or y: (%i, %i), value=%i, ending loop\n",
					heatmap_x, heatmap_y,
					heatmap_value);
					return false;
			}
			frame_i = heatmap_y * max_x + heatmap_x;
			v4l2->frame[frame_i] = heatmap_value;
		}
	} else if (pdata->heatmap_mode == HEATMAP_FULL) {
		int i, j, index = 0;
		int ret = 0;
		u8 type;

		if (!ts->heatmap_buff) {
			ts->heatmap_buff = kmalloc(
				sizeof(strength_t) * max_x * max_y, GFP_KERNEL);
			if (!ts->heatmap_buff) {
				input_err(true, &ts->client->dev,
				"%s: alloc heatmap_buff failed\n", __func__);
				return false;
			}
		}

		ret = sec_ts_read(ts,
			SEC_TS_CMD_MUTU_RAW_TYPE, &ts->ms_frame_type, 1);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				"%s: read rawdata type failed\n",
				__func__);
			return false;
		}

		/* Check raw type is TYPE_SIGNAL_DATA */
		if (ts->ms_frame_type != TYPE_SIGNAL_DATA) {
			input_info(true, &ts->client->dev,
				"%s: ms_frame_type change from %#x\n",
				__func__, ts->ms_frame_type);

			/* Check raw type is TYPE_INVALID_DATA */
			if (ts->ms_frame_type != TYPE_INVALID_DATA) {
				type = TYPE_INVALID_DATA;
				ret = sec_ts_write(ts,
					SEC_TS_CMD_MUTU_RAW_TYPE, &type, 1);
				if (ret < 0) {
					input_err(true, &ts->client->dev,
						"%s: recover rawdata type failed\n",
						__func__);
					return false;
				}
				ts->ms_frame_type = type;
			}

			/* Set raw type to TYPE_SIGNAL_DATA */
			type = TYPE_SIGNAL_DATA;
			ret = sec_ts_write(ts, SEC_TS_CMD_MUTU_RAW_TYPE,
				&type, 1);
			if (ret < 0) {
				input_err(true, &ts->client->dev,
					"%s: Set rawdata type failed\n",
					__func__);
				return false;
			}
			ts->ms_frame_type = type;

			/*
			 * If raw type change, need to wait 50 ms to read data
			 * back. But, we don't wanto to wait here to cause
			 * overhead. Just drop this and wait for next reading.
			 */
			return false;
		}

		ret = sec_ts_read_heap(ts, SEC_TS_READ_TOUCH_RAWDATA,
			(u8 *)ts->heatmap_buff,
			sizeof(strength_t) * max_x * max_y);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				"%s: Read delta frame failed\n", __func__);
			return false;
		}

		/* big-endian order raw data into heatmap data type */
		for (i = max_y - 1; i >= 0; i--)
			for (j = max_x - 1; j >= 0 ; j--)
				v4l2->frame[index++] = be16_to_cpup(
					ts->heatmap_buff + (j * max_y) + i);
	} else
		return false;

	return true;
}
#endif

#ifdef SEC_TS_SUPPORT_CUSTOMLIB
/* WARNING: touch_offload does not currently support the custom library
 * interface!
 * TODO: when custom library support is enabled, ensure that the output is
 * routed through touch_offload.
 */
static void sec_ts_handle_lib_status_event(struct sec_ts_data *ts,
				struct sec_ts_event_status *p_event_status)
{
	if ((p_event_status->stype == TYPE_STATUS_EVENT_CUSTOMLIB_INFO) &&
	    (p_event_status->status_id == SEC_TS_EVENT_CUSTOMLIB_FORCE_KEY)) {
		if (ts->power_status == SEC_TS_STATE_POWER_ON) {
			if (p_event_status->status_data_1 &
			    SEC_TS_CUSTOMLIB_EVENT_PRESSURE_TOUCHED) {
				ts->all_force_count++;
				ts->scrub_id =
					CUSTOMLIB_EVENT_TYPE_PRESSURE_TOUCHED;
			} else {
				if (ts->scrub_id ==
				    CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS) {
					input_report_key(ts->input_dev,
							 KEY_HOMEPAGE,
							 0);
					ts->scrub_id =
				CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RELEASE;
				} else {
					ts->scrub_id =
					CUSTOMLIB_EVENT_TYPE_PRESSURE_RELEASED;
				}
			}

			input_report_key(ts->input_dev,
					 KEY_BLACK_UI_GESTURE, 1);
		} else {
			if (p_event_status->status_data_1 &
			    SEC_TS_CUSTOMLIB_EVENT_PRESSURE_RELEASED) {
				input_report_key(ts->input_dev,
						 KEY_HOMEPAGE, 0);
				input_report_key(ts->input_dev,
						 KEY_BLACK_UI_GESTURE, 1);
				ts->scrub_id =
				CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_RLS_NO_HAPTIC;
				input_sync(ts->input_dev);
				haptic_homekey_release();
			} else {
				input_report_key(ts->input_dev,
						 KEY_HOMEPAGE, 1);
				input_sync(ts->input_dev);
				ts->scrub_id =
					CUSTOMLIB_EVENT_TYPE_AOD_HOMEKEY_PRESS;
				haptic_homekey_press();
				ts->all_force_count++;
			}
		}

		ts->scrub_x =
			((p_event_status->status_data_4 >> 4) & 0xF) << 8 |
			(p_event_status->status_data_3 & 0xFF);
		ts->scrub_y =
			((p_event_status->status_data_4 >> 0) & 0xF) << 8 |
			(p_event_status->status_data_2 & 0xFF);

		input_info(true, &ts->client->dev, "%s: PRESSURE[%d]\n",
			   __func__, ts->scrub_id);

		input_sync(ts->input_dev);
		input_report_key(ts->input_dev, KEY_BLACK_UI_GESTURE, 0);
	}
}
#endif

static void sec_ts_handle_coord_event(struct sec_ts_data *ts,
				struct sec_ts_event_coordinate *p_event_coord)
{
	u8 t_id;

	if (ts->input_closed) {
		input_err(true, &ts->client->dev, "%s: device is closed\n",
			__func__);
		return;
	}

	t_id = (p_event_coord->tid - 1);

	if (t_id < MAX_SUPPORT_TOUCH_COUNT + MAX_SUPPORT_HOVER_COUNT) {
		ts->coord[t_id].id = t_id;
		ts->coord[t_id].action = p_event_coord->tchsta;
		ts->coord[t_id].x = (p_event_coord->x_11_4 << 4) |
					(p_event_coord->x_3_0);
		ts->coord[t_id].y = (p_event_coord->y_11_4 << 4) |
					(p_event_coord->y_3_0);
		ts->coord[t_id].z = p_event_coord->z &
					SEC_TS_PRESSURE_MAX;
		ts->coord[t_id].ttype = p_event_coord->ttype_3_2 << 2 |
					p_event_coord->ttype_1_0 << 0;
		ts->coord[t_id].major = p_event_coord->major;
		ts->coord[t_id].minor = p_event_coord->minor;

		if (!ts->coord[t_id].palm &&
			(ts->coord[t_id].ttype == SEC_TS_TOUCHTYPE_PALM))
			ts->coord[t_id].palm_count++;

		ts->coord[t_id].palm =
			(ts->coord[t_id].ttype == SEC_TS_TOUCHTYPE_PALM);

		ts->coord[t_id].grip =
			(ts->coord[t_id].ttype == SEC_TS_TOUCHTYPE_GRIP);

		ts->coord[t_id].left_event = p_event_coord->left_event;

		if (ts->coord[t_id].z <= 0)
			ts->coord[t_id].z = 1;

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
		ts->offload.coords[t_id].x = ts->coord[t_id].x;
		ts->offload.coords[t_id].y = ts->coord[t_id].y;
		ts->offload.coords[t_id].major = ts->coord[t_id].major;
		ts->offload.coords[t_id].minor = ts->coord[t_id].minor;
		ts->offload.coords[t_id].pressure = ts->coord[t_id].z;
#endif

		if ((ts->coord[t_id].ttype ==
		     SEC_TS_TOUCHTYPE_NORMAL) ||
		    (ts->coord[t_id].ttype ==
		     SEC_TS_TOUCHTYPE_PALM) ||
		    (ts->coord[t_id].ttype ==
		     SEC_TS_TOUCHTYPE_GRIP) ||
		    (ts->coord[t_id].ttype ==
		     SEC_TS_TOUCHTYPE_WET) ||
		    (ts->coord[t_id].ttype ==
		     SEC_TS_TOUCHTYPE_GLOVE)) {

			if (ts->coord[t_id].action ==
				SEC_TS_COORDINATE_ACTION_RELEASE) {

				do_gettimeofday(&ts->time_released[t_id]);

				if (ts->time_longest <
					(ts->time_released[t_id].tv_sec -
						ts->time_pressed[t_id].tv_sec))
					ts->time_longest =
					(ts->time_released[t_id].tv_sec
					  - ts->time_pressed[t_id].tv_sec);

				if (ts->touch_count > 0)
					ts->touch_count--;
				if (ts->touch_count == 0 ||
					ts->tid_touch_state == 0) {
					ts->check_multi = 0;
				}
				__clear_bit(t_id, &ts->tid_palm_state);
				__clear_bit(t_id, &ts->tid_grip_state);
				__clear_bit(t_id, &ts->tid_touch_state);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
				ts->offload.coords[t_id].status =
					COORD_STATUS_INACTIVE;
				if (!ts->offload.offload_running) {
#endif
				input_mt_slot(ts->input_dev, t_id);
				if (ts->plat_data->support_mt_pressure)
					input_report_abs(ts->input_dev,
						ABS_MT_PRESSURE, 0);
				input_mt_report_slot_state(ts->input_dev,
					MT_TOOL_FINGER, 0);

				if (ts->touch_count == 0 ||
					ts->tid_touch_state == 0) {
					input_report_key(ts->input_dev,
						BTN_TOUCH, 0);
					input_report_key(ts->input_dev,
						BTN_TOOL_FINGER, 0);
				}
#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
				}
#endif
			} else if (ts->coord[t_id].action ==
					SEC_TS_COORDINATE_ACTION_PRESS) {
				do_gettimeofday(&ts->time_pressed[t_id]);

				ts->touch_count++;
				if ((ts->touch_count > 4) &&
					(ts->check_multi == 0)) {
					ts->check_multi = 1;
					ts->multi_count++;
				}
				ts->all_finger_count++;

				ts->max_z_value = max_t(unsigned int,
							ts->coord[t_id].z,
							ts->max_z_value);
				ts->min_z_value = min_t(unsigned int,
							ts->coord[t_id].z,
							ts->min_z_value);
				ts->sum_z_value +=
						(unsigned int)ts->coord[t_id].z;

				__set_bit(t_id, &ts->tid_touch_state);
				__clear_bit(t_id, &ts->tid_palm_state);
				__clear_bit(t_id, &ts->tid_grip_state);
				if (ts->coord[t_id].palm)
					__set_bit(t_id, &ts->tid_palm_state);
				else if (ts->coord[t_id].grip)
					__set_bit(t_id, &ts->tid_grip_state);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
				ts->offload.coords[t_id].status =
					COORD_STATUS_FINGER;
				if (!ts->offload.offload_running) {
#endif
				input_mt_slot(ts->input_dev, t_id);
				if (ts->coord[t_id].palm)
					input_mt_report_slot_state(
						ts->input_dev, MT_TOOL_PALM, 1);
				else if (ts->coord[t_id].grip)
					input_mt_report_slot_state(
						ts->input_dev, MT_TOOL_PALM, 1);
				else
					input_mt_report_slot_state(
						ts->input_dev,
						MT_TOOL_FINGER, 1);

				input_report_key(ts->input_dev, BTN_TOUCH, 1);
				input_report_key(ts->input_dev,
							BTN_TOOL_FINGER, 1);

				input_report_abs(ts->input_dev,
					ABS_MT_POSITION_X, ts->coord[t_id].x);
				input_report_abs(ts->input_dev,
					ABS_MT_POSITION_Y, ts->coord[t_id].y);
				input_report_abs(ts->input_dev,
						ABS_MT_TOUCH_MAJOR,
						ts->coord[t_id].major);
				input_report_abs(ts->input_dev,
						ABS_MT_TOUCH_MINOR,
						ts->coord[t_id].minor);
#ifdef ABS_MT_CUSTOM
				if (ts->brush_mode)
					input_report_abs(ts->input_dev,
						ABS_MT_CUSTOM,
						(ts->coord[t_id].z << 1) |
							ts->coord[t_id].palm);
				else
					input_report_abs(ts->input_dev,
						ABS_MT_CUSTOM,
						(BRUSH_Z_DATA << 1) |
							ts->coord[t_id].palm);
#endif
				if (ts->plat_data->support_mt_pressure)
					input_report_abs(ts->input_dev,
						ABS_MT_PRESSURE,
						ts->coord[t_id].z);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
				}
#endif
			} else if (ts->coord[t_id].action ==
					SEC_TS_COORDINATE_ACTION_MOVE) {

				ts->coord[t_id].mcount++;

#ifdef SW_GLOVE
				if ((ts->coord[t_id].ttype ==
					SEC_TS_TOUCHTYPE_GLOVE) &&
				    !ts->touchkey_glove_mode_status) {
					ts->touchkey_glove_mode_status = true;
				} else if ((ts->coord[t_id].ttype !=
						SEC_TS_TOUCHTYPE_GLOVE) &&
					   ts->touchkey_glove_mode_status) {
					ts->touchkey_glove_mode_status = false;
				}
#endif
				__set_bit(t_id, &ts->tid_touch_state);
				__clear_bit(t_id, &ts->tid_palm_state);
				__clear_bit(t_id, &ts->tid_grip_state);
				if (ts->coord[t_id].palm)
					__set_bit(t_id, &ts->tid_palm_state);
				else if (ts->coord[t_id].grip)
					__set_bit(t_id, &ts->tid_grip_state);
#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
				ts->offload.coords[t_id].status =
					COORD_STATUS_FINGER;
				if (!ts->offload.offload_running) {
#endif
#ifdef SW_GLOVE
				if ((ts->coord[t_id].ttype ==
					SEC_TS_TOUCHTYPE_GLOVE) &&
				    !ts->touchkey_glove_mode_status) {
					input_report_switch(ts->input_dev,
						SW_GLOVE, 1);
				} else if ((ts->coord[t_id].ttype !=
						SEC_TS_TOUCHTYPE_GLOVE) &&
					   ts->touchkey_glove_mode_status) {
					input_report_switch(ts->input_dev,
						SW_GLOVE, 0);
				}
#endif
				input_mt_slot(ts->input_dev, t_id);
				if (ts->coord[t_id].palm)
					input_mt_report_slot_state(
						ts->input_dev, MT_TOOL_PALM, 1);
				else if (ts->coord[t_id].grip)
					input_mt_report_slot_state(
						ts->input_dev, MT_TOOL_PALM, 1);
				else
					input_mt_report_slot_state(
						ts->input_dev,
						MT_TOOL_FINGER, 1);

				input_report_key(ts->input_dev, BTN_TOUCH, 1);
				input_report_key(ts->input_dev,
							BTN_TOOL_FINGER, 1);

				input_report_abs(ts->input_dev,
					ABS_MT_POSITION_X, ts->coord[t_id].x);
				input_report_abs(ts->input_dev,
					ABS_MT_POSITION_Y, ts->coord[t_id].y);
				input_report_abs(ts->input_dev,
						ABS_MT_TOUCH_MAJOR,
						ts->coord[t_id].major);
				input_report_abs(ts->input_dev,
						ABS_MT_TOUCH_MINOR,
						ts->coord[t_id].minor);
#ifdef ABS_MT_CUSTOM
				if (ts->brush_mode)
					input_report_abs(ts->input_dev,
						ABS_MT_CUSTOM,
						(ts->coord[t_id].z << 1) |
							ts->coord[t_id].palm);
				else
					input_report_abs(ts->input_dev,
						ABS_MT_CUSTOM,
						(BRUSH_Z_DATA << 1) |
							ts->coord[t_id].palm);
#endif
				if (ts->plat_data->support_mt_pressure)
					input_report_abs(ts->input_dev,
							ABS_MT_PRESSURE,
							ts->coord[t_id].z);
#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
				}
#endif
			} else
				input_dbg(true, &ts->client->dev,
					"%s: do not support coordinate action(%d)\n",
					__func__, ts->coord[t_id].action);
		} else
			input_dbg(true, &ts->client->dev,
				"%s: do not support coordinate type(%d)\n",
				__func__, ts->coord[t_id].ttype);
	} else
		input_err(true, &ts->client->dev,
				"%s: tid(%d) is out of range\n",
				__func__, t_id);

	if (t_id < MAX_SUPPORT_TOUCH_COUNT + MAX_SUPPORT_HOVER_COUNT) {
		if (ts->coord[t_id].action == SEC_TS_COORDINATE_ACTION_PRESS) {
			input_dbg(false, &ts->client->dev,
				"%s[P] tID:%d x:%d y:%d z:%d major:%d minor:%d tc:%d type:%X\n",
				ts->dex_name,
				t_id, ts->coord[t_id].x,
				ts->coord[t_id].y, ts->coord[t_id].z,
				ts->coord[t_id].major,
				ts->coord[t_id].minor,
				ts->touch_count,
				ts->coord[t_id].ttype);

		} else if (ts->coord[t_id].action ==
			   SEC_TS_COORDINATE_ACTION_RELEASE) {
			input_dbg(false, &ts->client->dev,
				"%s[R] tID:%d mc:%d tc:%d lx:%d ly:%d v:%02X%02X cal:%02X(%02X) id(%d,%d) p:%d\n",
				ts->dex_name,
				t_id, ts->coord[t_id].mcount,
				ts->touch_count,
				ts->coord[t_id].x, ts->coord[t_id].y,
				ts->plat_data->img_version_of_ic[2],
				ts->plat_data->img_version_of_ic[3],
				ts->cal_status, ts->nv, ts->tspid_val,
				ts->tspicid_val,
				ts->coord[t_id].palm_count);

			ts->coord[t_id].mcount = 0;
			ts->coord[t_id].palm_count = 0;
		}
	}
}

#ifdef SEC_TS_SUPPORT_CUSTOMLIB
static void sec_ts_handle_gesture_event(struct sec_ts_data *ts,
				struct sec_ts_gesture_status *p_gesture_status)
{
	if ((p_gesture_status->eid == 0x02) &&
	    (p_gesture_status->stype == 0x00)) {
		u8 customlib[3] = { 0 };

		ret = sec_ts_read_from_customlib(ts, customlib, 3);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: fail to read custom library data\n",
				__func__);

		input_info(true, &ts->client->dev,
			"%s: Custom Library, %x, %x, %x\n",
			__func__, customlib[0], customlib[1], customlib[2]);

		if (p_gesture_status->gesture_id == SEC_TS_GESTURE_CODE_SPAY ||
		    p_gesture_status->gesture_id ==
			SEC_TS_GESTURE_CODE_DOUBLE_TAP) {
			/* will be fixed to data structure */
			if (customlib[1] & SEC_TS_MODE_CUSTOMLIB_AOD) {
				u8 data[5] = { 0x0A, 0x00, 0x00, 0x00, 0x00 };

				ret = sec_ts_read_from_customlib(ts, data, 5);
				if (ret < 0)
					input_err(true, &ts->client->dev,
						"%s: fail to read custom library data\n",
						__func__);

				if (data[4] & SEC_TS_AOD_GESTURE_DOUBLETAB)
					ts->scrub_id =
					CUSTOMLIB_EVENT_TYPE_AOD_DOUBLETAB;

				ts->scrub_x = (data[1] & 0xFF) << 8 |
						(data[0] & 0xFF);
				ts->scrub_y = (data[3] & 0xFF) << 8 |
						(data[2] & 0xFF);
				input_info(true, &ts->client->dev,
					"%s: aod: %d\n",
					__func__, ts->scrub_id);
				ts->all_aod_tap_count++;
			}
			if (customlib[1] & SEC_TS_MODE_CUSTOMLIB_SPAY) {
				ts->scrub_id = CUSTOMLIB_EVENT_TYPE_SPAY;
				input_info(true, &ts->client->dev,
					"%s: SPAY: %d\n",
					__func__, ts->scrub_id);
				ts->all_spay_count++;
			}
			input_report_key(ts->input_dev,
					 KEY_BLACK_UI_GESTURE, 1);
			input_sync(ts->input_dev);
			input_report_key(ts->input_dev,
					 KEY_BLACK_UI_GESTURE, 0);
		}
	}
}
#endif

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)

static void sec_ts_populate_coordinate_channel(struct sec_ts_data *ts,
					struct touch_offload_frame *frame,
					int channel)
{
	int j;

	struct TouchOffloadDataCoord *dc =
		(struct TouchOffloadDataCoord *)frame->channel_data[channel];
	memset(dc, 0, frame->channel_data_size[channel]);
	dc->header.channel_type = TOUCH_DATA_TYPE_COORD;
	dc->header.channel_size = TOUCH_OFFLOAD_FRAME_SIZE_COORD;

	for (j = 0; j < MAX_COORDS; j++) {
		dc->coords[j].x = ts->offload.coords[j].x;
		dc->coords[j].y = ts->offload.coords[j].y;
		dc->coords[j].major = ts->offload.coords[j].major;
		dc->coords[j].minor = ts->offload.coords[j].minor;
		dc->coords[j].pressure = ts->offload.coords[j].pressure;
		dc->coords[j].status = ts->offload.coords[j].status;
	}
}

static void sec_ts_populate_mutual_channel(struct sec_ts_data *ts,
					struct touch_offload_frame *frame,
					int channel)
{
	uint32_t frame_index = 0;
	int32_t x, y;
	uint16_t heatmap_value;
	int ret = 0;
	u8 target_data_type, type;
	struct TouchOffloadData2d *mutual_strength =
		(struct TouchOffloadData2d *)frame->channel_data[channel];

	switch (frame->channel_type[channel] & ~TOUCH_SCAN_TYPE_MUTUAL) {
	case TOUCH_DATA_TYPE_RAW:
		target_data_type = TYPE_DECODED_DATA;
		break;
	case TOUCH_DATA_TYPE_FILTERED:
		target_data_type = TYPE_REMV_AMB_DATA;
		break;
	case TOUCH_DATA_TYPE_STRENGTH:
		target_data_type = TYPE_SIGNAL_DATA;
		break;
	case TOUCH_DATA_TYPE_BASELINE:
		target_data_type = TYPE_AMBIENT_DATA;
		break;
	}

	mutual_strength->tx_size = ts->tx_count;
	mutual_strength->rx_size = ts->rx_count;
	mutual_strength->header.channel_type = frame->channel_type[channel];
	mutual_strength->header.channel_size =
		TOUCH_OFFLOAD_FRAME_SIZE_2D(mutual_strength->rx_size,
					    mutual_strength->tx_size);

	ret = sec_ts_read(ts,
		SEC_TS_CMD_MUTU_RAW_TYPE, &ts->ms_frame_type, 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			"%s: read rawdata type failed\n",
			__func__);
		return;
	}

	/* Check raw type is correct */
	if (ts->ms_frame_type != target_data_type) {
		input_info(true, &ts->client->dev,
			"%s: ms_frame_type change from %#x\n",
			__func__, ts->ms_frame_type);

		/* Check raw type is TYPE_INVALID_DATA */
		if (ts->ms_frame_type != TYPE_INVALID_DATA) {
			type = TYPE_INVALID_DATA;
			ret = sec_ts_write(ts,
				SEC_TS_CMD_MUTU_RAW_TYPE, &type, 1);
			if (ret < 0) {
				input_err(true, &ts->client->dev,
					"%s: recover rawdata type failed\n",
					__func__);
				return;
			}
			ts->ms_frame_type = type;
		}

		/* Set the targeted data type */
		ret = sec_ts_write(ts, SEC_TS_CMD_MUTU_RAW_TYPE,
			&target_data_type, 1);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				"%s: Set rawdata type failed\n",
				__func__);
			return;
		}
		ts->ms_frame_type = target_data_type;

		/*
		 * If raw type change, need to wait 50 ms to read data
		 * back. But, we don't wanto to wait here to cause
		 * overhead. Just drop this and wait for next reading.
		 */

		return;
	}

	ret = sec_ts_read_heap(ts, SEC_TS_READ_TOUCH_RAWDATA,
		(u8 *)ts->heatmap_buff,
		mutual_strength->header.channel_size);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			"%s: Read mutual frame failed\n", __func__);
		return;
	}

	for (y = mutual_strength->rx_size - 1; y >= 0; y--) {
		for (x = mutual_strength->tx_size - 1; x >= 0; x--) {
			heatmap_value =
			    ts->heatmap_buff[x * mutual_strength->rx_size + y];
			((uint16_t *)
			 mutual_strength->data)[frame_index++] =
			    be16_to_cpu(heatmap_value);
		}
	}
}

static void sec_ts_populate_self_channel(struct sec_ts_data *ts,
					struct touch_offload_frame *frame,
					int channel)
{
	uint32_t frame_index = 0;
	int32_t x, y;
	uint16_t heatmap_value;
	int ret = 0;
	u8 target_data_type, type;
	struct TouchOffloadData1d *self_strength =
		(struct TouchOffloadData1d *)frame->channel_data[channel];

	switch (frame->channel_type[channel] & ~TOUCH_SCAN_TYPE_SELF) {
	case TOUCH_DATA_TYPE_RAW:
		target_data_type = TYPE_DECODED_DATA;
		break;
	case TOUCH_DATA_TYPE_FILTERED:
		target_data_type = TYPE_REMV_AMB_DATA;
		break;
	case TOUCH_DATA_TYPE_STRENGTH:
		target_data_type = TYPE_SIGNAL_DATA;
		break;
	case TOUCH_DATA_TYPE_BASELINE:
		target_data_type = TYPE_AMBIENT_DATA;
		break;
	}

	self_strength->tx_size = ts->tx_count;
	self_strength->rx_size = ts->rx_count;
	self_strength->header.channel_type = frame->channel_type[channel];
	self_strength->header.channel_size =
		TOUCH_OFFLOAD_FRAME_SIZE_1D(self_strength->rx_size,
					    self_strength->tx_size);

	ret = sec_ts_read(ts,
		SEC_TS_CMD_SELF_RAW_TYPE, &ts->ss_frame_type, 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			"%s: read rawdata type failed\n",
			__func__);
		return;
	}

	/* Check raw type is TYPE_SIGNAL_DATA */
	if (ts->ss_frame_type != target_data_type) {
		input_info(true, &ts->client->dev,
			"%s: ss_frame_type change from %#x\n",
			__func__, ts->ss_frame_type);

		/* Check raw type is TYPE_INVALID_DATA */
		if (ts->ss_frame_type != TYPE_INVALID_DATA) {
			type = TYPE_INVALID_DATA;
			ret = sec_ts_write(ts,
				SEC_TS_CMD_SELF_RAW_TYPE, &type, 1);
			if (ret < 0) {
				input_err(true, &ts->client->dev,
					"%s: recover rawdata type failed\n",
					__func__);
				return;
			}
			ts->ss_frame_type = type;
		}

		/* Set the targeted data type */
		ret = sec_ts_write(ts, SEC_TS_CMD_SELF_RAW_TYPE,
			&target_data_type, 1);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				"%s: Set rawdata type failed\n",
				__func__);
			return;
		}
		ts->ss_frame_type = target_data_type;

		/*
		 * If raw type change, need to wait 50 ms to read data
		 * back. But, we don't wanto to wait here to cause
		 * overhead. Just drop this and wait for next reading.
		 */

		return;
	}

	ret = sec_ts_read_heap(ts, SEC_TS_READ_TOUCH_SELF_RAWDATA,
		(u8 *)ts->heatmap_buff,
		self_strength->header.channel_size);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			"%s: Read self frame failed\n", __func__);
		return;
	}

	for (x = self_strength->tx_size - 1; x >= 0; x--) {
		heatmap_value = ts->heatmap_buff[x];
		((uint16_t *)
		 self_strength->data)[frame_index++] =
		    be16_to_cpu(heatmap_value);
	}
	for (y = self_strength->rx_size - 1; y >= 0; y--) {
		heatmap_value = ts->heatmap_buff[self_strength->tx_size + y];
		((uint16_t *)
		 self_strength->data)[frame_index++] =
		    be16_to_cpu(heatmap_value);
	}
}

static void sec_ts_populate_frame(struct sec_ts_data *ts,
				struct touch_offload_frame *frame)
{
	static u64 index;
	int i;

	frame->header.index = index++;
	frame->header.timestamp = ts->timestamp;

	if (!ts->heatmap_buff) {
		ts->heatmap_buff = kmalloc(
			ts->rx_count * ts->rx_count * 2, GFP_KERNEL);
	}

	/* Populate all channels */
	for (i = 0; i < frame->num_channels; i++) {
		if (frame->channel_type[i] == TOUCH_DATA_TYPE_COORD)
			sec_ts_populate_coordinate_channel(ts, frame, i);
		else if ((frame->channel_type[i] & TOUCH_SCAN_TYPE_MUTUAL) != 0)
			sec_ts_populate_mutual_channel(ts, frame, i);
		else if ((frame->channel_type[i] & TOUCH_SCAN_TYPE_SELF) != 0)
			sec_ts_populate_self_channel(ts, frame, i);
	}
}

int sec_ts_enable_grip(struct sec_ts_data *ts, bool enable)
{
	u8 value = enable ? 1 : 0;
	int ret;
	int final_result = 0;

	/* Set grip */
	ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_GRIP_DETEC, &value, 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			 "%s: SEC_TS_CMD_SET_GRIP_DETEC failed with ret=%d\n",
			__func__, ret);
		final_result = ret;
	}

	/* Set deadzone */
	value = enable ? 1 : 0;
	ret = ts->sec_ts_write(ts, SEC_TS_CMD_EDGE_DEADZONE, &value, 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			 "%s: SEC_TS_CMD_EDGE_DEADZONE failed with ret=%d\n",
			__func__, ret);
		final_result = ret;
	}

	return final_result;
}

static void sec_ts_offload_set_running(struct sec_ts_data *ts, bool running)
{
	if (ts->offload.offload_running != running) {
		ts->offload.offload_running = running;
		if (running) {
			pr_info("%s: disabling FW grip.\n", __func__);
			sec_ts_enable_grip(ts, false);
		} else {
			pr_info("%s: enabling FW grip.\n", __func__);
			sec_ts_enable_grip(ts, true);
		}
	}
}

#endif /* CONFIG_TOUCHSCREEN_OFFLOAD */

#define MAX_EVENT_COUNT 32
static void sec_ts_read_event(struct sec_ts_data *ts)
{
	int ret;
	u8 event_id;
	u8 left_event_count;
	u8 read_event_buff[MAX_EVENT_COUNT][SEC_TS_EVENT_BUFF_SIZE] = { { 0 } };
	u8 *event_buff;
	struct sec_ts_gesture_status *p_gesture_status;
	struct sec_ts_event_status *p_event_status;
	int curr_pos;
	int remain_event_count = 0;
	bool processed_pointer_event = false;
	unsigned long last_tid_palm_state = ts->tid_palm_state;
	unsigned long last_tid_grip_state = ts->tid_grip_state;
#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	struct touch_offload_frame *frame = NULL;
#endif

	if (ts->power_status == SEC_TS_STATE_LPM) {

		pm_wakeup_event(&ts->client->dev, 3 * MSEC_PER_SEC);
		/* waiting for blsp block resuming, if not occurs error */
		ret = wait_for_completion_interruptible_timeout(
				&ts->resume_done,
				msecs_to_jiffies(3 * MSEC_PER_SEC));
		if (ret == 0) {
			input_err(true, &ts->client->dev,
				  "%s: LPM: pm resume is not handled\n",
				  __func__);
			return;
		}

		if (ret < 0) {
			input_err(true, &ts->client->dev,
				  "%s: LPM: -ERESTARTSYS if interrupted, %d\n",
				  __func__, ret);
			return;
		}

		input_info(true, &ts->client->dev,
			"%s: run LPM interrupt handler, %d\n", __func__, ret);
		/* run lpm interrupt handler */
	}

	ret = event_id = curr_pos = remain_event_count = 0;
	/* repeat READ_ONE_EVENT until buffer is empty(No event) */
	ret = sec_ts_read(ts, SEC_TS_READ_ONE_EVENT,
			  (u8 *)read_event_buff[0], SEC_TS_EVENT_BUFF_SIZE);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: read one event failed\n", __func__);
		return;
	}

	if (ts->temp == 0x01)
		input_info(true, &ts->client->dev,
			"ONE: %02X %02X %02X %02X %02X %02X %02X %02X\n",
			read_event_buff[0][0], read_event_buff[0][1],
			read_event_buff[0][2], read_event_buff[0][3],
			read_event_buff[0][4], read_event_buff[0][5],
			read_event_buff[0][6], read_event_buff[0][7]);

	if (read_event_buff[0][0] == 0) {
		input_info(true, &ts->client->dev,
			"%s: event buffer is empty\n", __func__);
		return;
	}

	left_event_count = read_event_buff[0][7] & 0x3F;
	remain_event_count = left_event_count;

	if (left_event_count > MAX_EVENT_COUNT - 1 ||
		left_event_count == 0xFF) {
		input_err(true, &ts->client->dev,
			"%s: event buffer overflow %d\n",
			__func__, left_event_count);

		/* write clear event stack command
		 * when read_event_count > MAX_EVENT_COUNT
		 **/
		ret = sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: write clear event failed\n", __func__);
		return;
	}

	if (left_event_count > 0) {
		ret = sec_ts_read(ts, SEC_TS_READ_ALL_EVENT,
			(u8 *)read_event_buff[1],
			sizeof(u8) * (SEC_TS_EVENT_BUFF_SIZE) *
				(left_event_count));
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				  "%s: read one event failed\n", __func__);
			return;
		}
	}

	do {
		event_buff = read_event_buff[curr_pos];
		event_id = event_buff[0] & 0x3;

		if (ts->temp == 0x01)
			input_info(true, &ts->client->dev,
				 "ALL: %02X %02X %02X %02X %02X %02X %02X %02X\n",
				event_buff[0], event_buff[1], event_buff[2],
				event_buff[3], event_buff[4], event_buff[5],
				event_buff[6], event_buff[7]);

		switch (event_id) {
		case SEC_TS_STATUS_EVENT:
			p_event_status =
				(struct sec_ts_event_status *)event_buff;

			/* tchsta == 0 && ttype == 0 && eid == 0 : buffer empty
			 **/
			if (p_event_status->stype > 0) {
				/* Demote 'vendor' messages */
				if (p_event_status->stype ==
					TYPE_STATUS_EVENT_VENDOR_INFO) {
					u8 status_id =
						p_event_status->status_id;
					u8 status_data_1 =
						p_event_status->status_data_1;

					input_dbg(true, &ts->client->dev,
						"%s: STATUS %x %x %x %x %x %x %x %x\n",
						__func__, event_buff[0],
						event_buff[1], event_buff[2],
						event_buff[3], event_buff[4],
						event_buff[5], event_buff[6],
						event_buff[7]);

					switch (status_id) {
					case SEC_TS_EVENT_STATUS_ID_WLC:
						input_info(true,
							&ts->client->dev,
							"STATUS: wlc mode change to %x\n",
							status_data_1);
						break;

					case SEC_TS_EVENT_STATUS_ID_NOISE:
						input_info(true,
							&ts->client->dev,
							"STATUS: noise mode change to %x\n",
							status_data_1);
						break;

					case SEC_TS_EVENT_STATUS_ID_GRIP:
						input_info(true,
							&ts->client->dev,
							"STATUS: detect grip %s!\n",
							(status_data_1) ?
							"enter" : "leave");
						break;

					case SEC_TS_EVENT_STATUS_ID_PALM:
						input_info(true,
							&ts->client->dev,
							"STATUS: detect palm!\n");
						break;

					default:
						break;
					}
				} else
					input_info(true, &ts->client->dev,
						"%s: STATUS %x %x %x %x %x %x %x %x\n",
						__func__, event_buff[0],
						event_buff[1], event_buff[2],
						event_buff[3], event_buff[4],
						event_buff[5], event_buff[6],
						event_buff[7]);
			}

			if ((p_event_status->stype ==
					TYPE_STATUS_EVENT_INFO) &&
				(p_event_status->status_id ==
					SEC_TS_ACK_BOOT_COMPLETE)) {
				u8 status_data_1 =
					p_event_status->status_data_1;

				switch (status_data_1) {
				case 0x20:
					/* watchdog reset !? */
					sec_ts_locked_release_all_finger(ts);
					ret = sec_ts_write(ts,
						SEC_TS_CMD_SENSE_ON, NULL, 0);
					if (ret < 0)
						input_err(true,
							&ts->client->dev,
							"%s: fail to write Sense_on\n",
							__func__);
						sec_ts_reinit(ts);
					break;
				case 0x40:
					input_info(true, &ts->client->dev,
						"%s: sw_reset done\n",
						__func__);
					sec_ts_locked_release_all_finger(ts);
					complete_all(&ts->boot_completed);
					break;
				case 0x10:
					input_info(true, &ts->client->dev,
						"%s: hw_reset done\n",
						__func__);
					sec_ts_locked_release_all_finger(ts);
					complete_all(&ts->boot_completed);
					break;
				default:
					break;
				}

			}

			/* event queue full-> all finger release */
			if ((p_event_status->stype == TYPE_STATUS_EVENT_ERR) &&
				(p_event_status->status_id ==
					SEC_TS_ERR_EVENT_QUEUE_FULL)) {
				input_err(true, &ts->client->dev,
					"%s: IC Event Queue is full\n",
					__func__);
				sec_ts_locked_release_all_finger(ts);
			}

			if ((p_event_status->stype ==
				TYPE_STATUS_EVENT_ERR) &&
			    (p_event_status->status_id ==
				SEC_TS_ERR_EVENT_ESD)) {
				input_err(true, &ts->client->dev,
					  "%s: ESD detected. run reset\n",
					  __func__);
#ifdef USE_RESET_DURING_POWER_ON
				schedule_work(&ts->reset_work.work);
#endif
			}

			if ((p_event_status->stype ==
				TYPE_STATUS_EVENT_INFO) &&
			    (p_event_status->status_id ==
				SEC_TS_ACK_WET_MODE)) {
				ts->wet_mode = p_event_status->status_data_1;
				input_info(true, &ts->client->dev,
					"%s: water wet mode %d\n",
					__func__, ts->wet_mode);
				if (ts->wet_mode)
					ts->wet_count++;

				}

#ifdef SEC_TS_SUPPORT_CUSTOMLIB
			mutex_lock(&ts->eventlock);
			sec_ts_handle_lib_status_event(ts, p_event_status);
			mutex_unlock(&ts->eventlock);
#endif
			break;

		case SEC_TS_COORDINATE_EVENT:
			processed_pointer_event = true;
			mutex_lock(&ts->eventlock);
			sec_ts_handle_coord_event(ts,
				(struct sec_ts_event_coordinate *)event_buff);
			mutex_unlock(&ts->eventlock);
			break;

		case SEC_TS_GESTURE_EVENT:
			p_gesture_status =
				(struct sec_ts_gesture_status *)event_buff;
#ifdef SEC_TS_SUPPORT_CUSTOMLIB
			mutex_lock(&ts->eventlock);
			sec_ts_handle_gesture_event(ts, p_gesture_status);
			mutex_unlock(&ts->eventlock);
#endif
			break;

		default:
			input_err(true, &ts->client->dev,
				"%s: unknown event %x %x %x %x %x %x\n",
				__func__,
				event_buff[0], event_buff[1], event_buff[2],
				event_buff[3], event_buff[4], event_buff[5]);
			break;
		}
		curr_pos++;
		remain_event_count--;
	} while (remain_event_count >= 0);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	if (!ts->offload.offload_running) {
#endif
	mutex_lock(&ts->eventlock);
	input_sync(ts->input_dev);
	mutex_unlock(&ts->eventlock);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	}

	if (processed_pointer_event) {
		ret = touch_offload_reserve_frame(&ts->offload, &frame);
		if (ret != 0) {
			input_dbg(true, &ts->client->dev,
				  "Could not reserve a frame: ret=%d.\n", ret);

			/* Stop offload when there are no buffers available */
			sec_ts_offload_set_running(ts, false);
		} else {
			sec_ts_offload_set_running(ts, true);

			sec_ts_populate_frame(ts, frame);

			ret = touch_offload_queue_frame(&ts->offload, frame);
			if (ret != 0) {
				pr_err("%s: Failed to queue reserved frame: ret=%d.\n",
				       __func__, ret);
			}
		}
	}
#endif

	/* TODO: If the mutual strength heatmap was already read into the touch
	 * offload interface, use it here instead of reading again.
	 */
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
	if (processed_pointer_event) {
		heatmap_read(&ts->v4l2, ktime_to_ns(ts->timestamp));

		/* palm */
		if (last_tid_palm_state == 0 &&
			ts->tid_palm_state >= 1) {
			input_info(true, &ts->client->dev,
				"COORD: detect palm enter(tid 0x0 -> %#x)\n",
				ts->tid_palm_state);
		}
		if (last_tid_palm_state >= 1 &&
			ts->tid_palm_state == 0) {
			input_info(true, &ts->client->dev,
				"COORD: detect palm leave(tid %#x -> 0x0), tid_touch %#x\n",
				last_tid_palm_state, ts->tid_touch_state);
			if (ts->touch_count || ts->tid_touch_state) {
				ts->palms_leaved_once = true;
				input_dbg(true, &ts->client->dev,
					"COORD: wait all finger(s) release after palm entered\n");
			}
		}
		/* grip */
		if (last_tid_grip_state == 0 &&
			ts->tid_grip_state >= 1) {
			input_info(true, &ts->client->dev,
				"COORD: detect grip enter(tid 0x0 -> %#x)\n",
				ts->tid_grip_state);
		}
		if (last_tid_grip_state >= 1 &&
			ts->tid_grip_state == 0) {
			input_info(true, &ts->client->dev,
				"COORD: detect grip leave(tid %#x -> 0x0), tid_touch %#x\n",
				last_tid_grip_state, ts->tid_touch_state);
			if (ts->touch_count || ts->tid_touch_state) {
				ts->grips_leaved_once = true;
				input_dbg(true, &ts->client->dev,
					"COORD: wait all finger(s) release after grip entered\n");
			}
		}
		if ((ts->touch_count == 0 || ts->tid_touch_state == 0) &&
			(ts->palms_leaved_once || ts->grips_leaved_once)) {
			ts->palms_leaved_once = false;
			ts->grips_leaved_once = false;
			input_info(true, &ts->client->dev,
				"COORD: all fingers released with palm(s)/grip(s) leaved once\n");
		}
	}
#endif
}

static irqreturn_t sec_ts_isr(int irq, void *handle)
{
	struct sec_ts_data *ts = (struct sec_ts_data *)handle;

	ts->timestamp = ktime_get();
#if !IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	input_set_timestamp(ts->input_dev, ts->timestamp);
#endif

	return IRQ_WAKE_THREAD;
}

static irqreturn_t sec_ts_irq_thread(int irq, void *ptr)
{
	struct sec_ts_data *ts = (struct sec_ts_data *)ptr;

	if (sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_IRQ, true) < 0) {
		/* Interrupt during bus suspend */
		input_info(true, &ts->client->dev,
			"%s: Skipping stray interrupt since bus is suspended(power_status: %d)\n",
			__func__, ts->power_status);
		return IRQ_HANDLED;
	}

	/* prevent CPU from entering deep sleep */
	pm_qos_update_request(&ts->pm_qos_req, 100);
	pm_wakeup_event(&ts->client->dev, MSEC_PER_SEC);

	sec_ts_read_event(ts);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
	/* Disable the firmware motion filter during single touch */
	update_motion_filter(ts);
#endif

	pm_qos_update_request(&ts->pm_qos_req, PM_QOS_DEFAULT_VALUE);

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_IRQ, false);

	return IRQ_HANDLED;
}

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
static void sec_ts_offload_report(void *handle,
				  struct TouchOffloadIocReport *report)
{
	struct sec_ts_data *ts = (struct sec_ts_data *)handle;
	bool touch_down = 0;
	int i;

	mutex_lock(&ts->eventlock);

	input_set_timestamp(ts->input_dev, report->timestamp);

	for (i = 0; i < MAX_COORDS; i++) {
		if (report->coords[i].status != COORD_STATUS_INACTIVE) {
			int mt_tool = MT_TOOL_FINGER;

			input_mt_slot(ts->input_dev, i);
			touch_down = 1;
			input_report_key(ts->input_dev, BTN_TOUCH,
					 touch_down);

			if (report->coords[i].status == COORD_STATUS_EDGE ||
			    report->coords[i].status == COORD_STATUS_PALM ||
			    report->coords[i].status == COORD_STATUS_CANCEL)
				mt_tool = MT_TOOL_PALM;

			input_mt_report_slot_state(ts->input_dev,
						   mt_tool, 1);
			input_report_abs(ts->input_dev, ABS_MT_POSITION_X,
					 report->coords[i].x);
			input_report_abs(ts->input_dev, ABS_MT_POSITION_Y,
					 report->coords[i].y);
			input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR,
					 report->coords[i].major);
			input_report_abs(ts->input_dev, ABS_MT_TOUCH_MINOR,
					 report->coords[i].minor);
			if (ts->plat_data->support_mt_pressure)
				input_report_abs(ts->input_dev,
					ABS_MT_PRESSURE,
					report->coords[i].pressure);
		} else {
			input_mt_slot(ts->input_dev, i);
			input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);
			input_mt_report_slot_state(ts->input_dev,
						   MT_TOOL_FINGER, 0);
			input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID,
					 -1);
		}
	}

	input_report_key(ts->input_dev, BTN_TOUCH, touch_down);

	input_sync(ts->input_dev);

	mutex_unlock(&ts->eventlock);
}
#endif /* CONFIG_TOUCHSCREEN_OFFLOAD */

int get_tsp_status(void)
{
	return 0;
}
EXPORT_SYMBOL(get_tsp_status);

int sec_ts_glove_mode_enables(struct sec_ts_data *ts, int mode)
{
	int ret;

	if (mode)
		ts->touch_functions = (ts->touch_functions |
				       SEC_TS_BIT_SETFUNC_GLOVE |
				       SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC);
	else
		ts->touch_functions = ((ts->touch_functions &
					(~SEC_TS_BIT_SETFUNC_GLOVE)) |
				       SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC);

	if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
		input_err(true, &ts->client->dev,
			"%s: pwr off, glove:%d, status:%x\n", __func__,
			mode, ts->touch_functions);
		goto glove_enable_err;
	}

	ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
			   (u8 *)&ts->touch_functions, 2);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: Failed to send command", __func__);
		goto glove_enable_err;
	}

	input_info(true, &ts->client->dev,
		"%s: glove:%d, status:%x\n", __func__,
		mode, ts->touch_functions);

	return 0;

glove_enable_err:
	return -EIO;
}
EXPORT_SYMBOL(sec_ts_glove_mode_enables);

int sec_ts_set_cover_type(struct sec_ts_data *ts, bool enable)
{
	int ret;

	input_info(true, &ts->client->dev, "%s: %d\n",
		   __func__, ts->cover_type);


	switch (ts->cover_type) {
	case SEC_TS_VIEW_WIRELESS:
	case SEC_TS_VIEW_COVER:
	case SEC_TS_VIEW_WALLET:
	case SEC_TS_FLIP_WALLET:
	case SEC_TS_LED_COVER:
	case SEC_TS_MONTBLANC_COVER:
	case SEC_TS_CLEAR_FLIP_COVER:
	case SEC_TS_QWERTY_KEYBOARD_EUR:
	case SEC_TS_QWERTY_KEYBOARD_KOR:
		ts->cover_cmd = (u8)ts->cover_type;
		break;
	case SEC_TS_CHARGER_COVER:
	case SEC_TS_COVER_NOTHING1:
	case SEC_TS_COVER_NOTHING2:
	default:
		ts->cover_cmd = 0;
		input_err(true, &ts->client->dev,
			 "%s: not chage touch state, %d\n",
			__func__, ts->cover_type);
		break;
	}

	if (enable)
		ts->touch_functions = (ts->touch_functions |
				       SEC_TS_BIT_SETFUNC_COVER |
				       SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC);
	else
		ts->touch_functions = ((ts->touch_functions &
					(~SEC_TS_BIT_SETFUNC_COVER)) |
				       SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC);

	if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
		input_err(true, &ts->client->dev,
			  "%s: pwr off, close:%d, status:%x\n", __func__,
			enable, ts->touch_functions);
		goto cover_enable_err;
	}

	if (enable) {
		ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE,
				   &ts->cover_cmd, 1);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				  "%s: Failed to send covertype command: %d",
				  __func__, ts->cover_cmd);
			goto cover_enable_err;
		}
	}

	ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
			   (u8 *)&(ts->touch_functions), 2);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: Failed to send command", __func__);
		goto cover_enable_err;
	}

	input_info(true, &ts->client->dev,
		"%s: close:%d, status:%x\n", __func__,
		enable, ts->touch_functions);

	return 0;

cover_enable_err:
	return -EIO;


}
EXPORT_SYMBOL(sec_ts_set_cover_type);

void sec_ts_set_grip_type(struct sec_ts_data *ts, u8 set_type)
{
	u8 mode = G_NONE;

	input_info(true, &ts->client->dev,
		"%s: re-init grip(%d), edh:%d, edg:%d, lan:%d\n", __func__,
		set_type, ts->grip_edgehandler_direction, ts->grip_edge_range,
		ts->grip_landscape_mode);

	/* edge handler */
	if (ts->grip_edgehandler_direction != 0)
		mode |= G_SET_EDGE_HANDLER;

	if (set_type == GRIP_ALL_DATA) {
		/* edge */
		if (ts->grip_edge_range != 60)
			mode |= G_SET_EDGE_ZONE;

		/* dead zone */
		if (ts->grip_landscape_mode == 1)	/* default 0 mode, 32 */
			mode |= G_SET_LANDSCAPE_MODE;
		else
			mode |= G_SET_NORMAL_MODE;
	}

	if (mode)
		set_grip_data_to_ic(ts, mode);

}

/* for debugging--------------------------------------------------------------*/

static int sec_ts_pinctrl_configure(struct sec_ts_data *ts, bool enable)
{
	struct pinctrl_state *state;

	input_info(true, &ts->client->dev, "%s: %s\n",
		   __func__, enable ? "ACTIVE" : "SUSPEND");

	if (enable) {
		state = pinctrl_lookup_state(ts->plat_data->pinctrl,
					     "on_state");
		if (IS_ERR(ts->plat_data->pinctrl))
			input_err(true, &ts->client->dev,
				"%s: could not get active pinstate\n",
				__func__);
	} else {
		state = pinctrl_lookup_state(ts->plat_data->pinctrl,
					     "off_state");
		if (IS_ERR(ts->plat_data->pinctrl))
			input_err(true, &ts->client->dev,
				"%s: could not get suspend pinstate\n",
				__func__);
	}

	if (!IS_ERR_OR_NULL(state))
		return pinctrl_select_state(ts->plat_data->pinctrl, state);

	return 0;

}

static int sec_ts_power(void *data, bool on)
{
	struct sec_ts_data *ts = (struct sec_ts_data *)data;
	const struct sec_ts_plat_data *pdata = ts->plat_data;
	struct regulator *regulator_dvdd = NULL;
	struct regulator *regulator_avdd = NULL;
	static bool dvdd_enabled, avdd_enabled;
	int ret = 0;

	if (pdata->regulator_dvdd) {
		regulator_dvdd = regulator_get(&ts->client->dev,
			pdata->regulator_dvdd);
		if (IS_ERR_OR_NULL(regulator_dvdd))
			input_err(true, &ts->client->dev,
				"%s: Failed to get %s regulator.\n",
				__func__, pdata->regulator_dvdd);
	}

	if (pdata->regulator_avdd) {
		regulator_avdd = regulator_get(&ts->client->dev,
			pdata->regulator_avdd);
		if (IS_ERR_OR_NULL(regulator_avdd))
			input_err(true, &ts->client->dev,
				"%s: Failed to get %s regulator.\n",
				 __func__, pdata->regulator_avdd);
	}

	if (regulator_dvdd && (dvdd_enabled != on)) {
		ret = (on) ? regulator_enable(regulator_dvdd) :
			regulator_disable(regulator_dvdd);
		if (ret)
			input_err(true, &ts->client->dev,
				"%s: Failed to control dvdd: %d\n",
				__func__, ret);
		else {
			sec_ts_delay(1);
			dvdd_enabled = on;
		}
	}

	if (regulator_avdd && (avdd_enabled != on)) {
		ret = (on) ? regulator_enable(regulator_avdd) :
			regulator_disable(regulator_avdd);
		if (ret)
			input_err(true, &ts->client->dev,
				"%s: Failed to control avdd: %d\n",
				__func__, ret);
		else
			avdd_enabled = on;
	}

	if (regulator_dvdd) {
		input_info(true, &ts->client->dev, "%s: %s: dvdd:%s\n",
			__func__, on ? "on" : "off",
			regulator_is_enabled(regulator_dvdd) ? "on" : "off");
		regulator_put(regulator_dvdd);
	}

	if (regulator_avdd) {
		input_info(true, &ts->client->dev, "%s: %s: avdd:%s\n",
			__func__, on ? "on" : "off",
			regulator_is_enabled(regulator_avdd) ? "on" : "off");
		regulator_put(regulator_avdd);
	}

	return ret;
}

#ifdef I2C_INTERFACE
static int sec_ts_parse_dt(struct i2c_client *client)
#else
static int sec_ts_parse_dt(struct spi_device *client)
#endif
{
	struct device *dev = &client->dev;
	struct sec_ts_plat_data *pdata = dev->platform_data;
	struct device_node *np = dev->of_node;
	u32 coords[2];
	int ret = 0;
	int count = 0;
	u32 ic_match_value;
	int lcdtype = 0;
#if defined(CONFIG_EXYNOS_DECON_FB)
	int connected;
#endif
	int index;
	struct of_phandle_args panelmap;
	struct drm_panel *panel = NULL;

	if (of_property_read_bool(np, "sec,panel_map")) {
		for (index = 0 ;; index++) {
			ret = of_parse_phandle_with_fixed_args(np,
					"sec,panel_map",
					1,
					index,
					&panelmap);
			if (ret)
				return -EPROBE_DEFER;
			panel = of_drm_find_panel(panelmap.np);
			of_node_put(panelmap.np);
			if (!IS_ERR_OR_NULL(panel)) {
				pdata->panel = panel;
				pdata->initial_panel_index = panelmap.args[0];
				break;
			}
		}
	}

	pdata->tsp_icid = of_get_named_gpio(np, "sec,tsp-icid_gpio", 0);
	if (gpio_is_valid(pdata->tsp_icid)) {
		input_info(true, dev, "%s: TSP_ICID : %d\n",
			   __func__, gpio_get_value(pdata->tsp_icid));
		if (of_property_read_u32(np, "sec,icid_match_value",
					 &ic_match_value)) {
			input_err(true, dev,
				"%s: Failed to get icid match value\n",
				__func__);
			return -EINVAL;
		}

		if (gpio_get_value(pdata->tsp_icid) != ic_match_value) {
			input_err(true, dev,
				  "%s: Do not match TSP_ICID\n", __func__);
			return -EINVAL;
		}
	} else {
		input_dbg(true, dev,
			  "%s: Failed to get tsp-icid gpio\n", __func__);
	}

	pdata->tsp_vsync = of_get_named_gpio(np, "sec,tsp_vsync_gpio", 0);
	if (gpio_is_valid(pdata->tsp_vsync))
		input_info(true, &client->dev, "%s: vsync %s\n", __func__,
			gpio_get_value(pdata->tsp_vsync) ?
				"disable" : "enable");

	pdata->irq_gpio = of_get_named_gpio(np, "sec,irq_gpio", 0);
	if (gpio_is_valid(pdata->irq_gpio)) {
		ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN,
				       "sec,tsp_int");
		if (ret) {
			input_err(true, &client->dev,
				  "%s: Unable to request tsp_int [%d]\n",
				  __func__, pdata->irq_gpio);
			return -EINVAL;
		}
	} else {
		input_err(true, &client->dev,
			  "%s: Failed to get irq gpio\n", __func__);
		return -EINVAL;
	}

	client->irq = gpio_to_irq(pdata->irq_gpio);

	if (of_property_read_u32(np, "sec,irq_type", &pdata->irq_type)) {
		input_dbg(true, dev,
			"%s: no irq_type property, set to default!\n",
			__func__);
		pdata->irq_type = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
	}

	if (of_property_read_u32(np, "sec,i2c-burstmax", &pdata->io_burstmax)) {
		input_dbg(false, &client->dev,
			  "%s: Failed to get io_burstmax property\n", __func__);
		pdata->io_burstmax = 1024; //TODO: check this
	}
	if (pdata->io_burstmax > IO_PREALLOC_READ_BUF_SZ ||
	    pdata->io_burstmax > IO_PREALLOC_WRITE_BUF_SZ) {
		input_err(true, &client->dev,
			  "%s: io_burstmax is larger than io_read_buf and/or io_write_buf.\n",
			  __func__);
//TODO: check this
//		return -EINVAL;
	}

	if (of_property_read_u32_array(np, "sec,max_coords", coords, 2)) {
		input_err(true, &client->dev,
			  "%s: Failed to get max_coords property\n", __func__);
		return -EINVAL;
	}
	pdata->max_x = coords[0] - 1;
	pdata->max_y = coords[1] - 1;

#ifdef PAT_CONTROL
	if (of_property_read_u32(np, "sec,pat_function",
				 &pdata->pat_function) < 0) {
		pdata->pat_function = 0;
		input_err(true, dev,
			"%s: Failed to get pat_function property\n", __func__);
	}

	if (of_property_read_u32(np, "sec,afe_base", &pdata->afe_base) < 0) {
		pdata->afe_base = 0;
		input_err(true, dev,
			  "%s: Failed to get afe_base property\n", __func__);
	}
#endif

	pdata->tsp_id = of_get_named_gpio(np, "sec,tsp-id_gpio", 0);
	if (gpio_is_valid(pdata->tsp_id))
		input_info(true, dev, "%s: TSP_ID : %d\n", __func__,
			   gpio_get_value(pdata->tsp_id));
	else
		input_dbg(true, dev,
			  "%s: Failed to get tsp-id gpio\n", __func__);

	pdata->switch_gpio = of_get_named_gpio(np,
					       "sec,switch_gpio", 0);
	if (gpio_is_valid(pdata->switch_gpio)) {
		ret = gpio_request_one(pdata->switch_gpio,
				       GPIOF_OUT_INIT_LOW,
				       "sec,touch_i2c_switch");
		if (ret) {
			input_err(true, dev,
				  "%s: Failed to request gpio %d\n",
				  __func__, pdata->switch_gpio);
			return -EINVAL;
		}

		ret = gpio_direction_output(pdata->switch_gpio,
					    SEC_SWITCH_GPIO_VALUE_AP_MASTER);
		if (ret) {
			input_err(true, dev,
				  "%s: Failed to set gpio %d direction\n",
				  __func__, pdata->switch_gpio);
			return -EINVAL;
		}
	} else {
		input_err(true, dev, "%s: Failed to get switch_gpio\n",
			  __func__);
	}

	pdata->reset_gpio = of_get_named_gpio(np, "sec,reset_gpio", 0);
	if (gpio_is_valid(pdata->reset_gpio)) {
		ret = gpio_request_one(pdata->reset_gpio,
					GPIOF_OUT_INIT_HIGH,
					"sec,touch_reset_gpio");
		if (ret) {
			input_err(true, dev,
				  "%s: Failed to request gpio %d, ret %d\n",
				  __func__, pdata->reset_gpio, ret);
			pdata->reset_gpio = -1;
		}
		//TODO: check this
		ret = gpio_direction_output(pdata->reset_gpio, 1);
		mdelay(10);
		ret = gpio_direction_output(pdata->reset_gpio, 0);
		mdelay(10);
		ret = gpio_direction_output(pdata->reset_gpio, 1);

	} else
		input_err(true, dev, "%s: Failed to get reset_gpio\n",
			__func__);

	count = of_property_count_strings(np, "sec,firmware_name");
	if (count <= 0) {
		pdata->firmware_name = NULL;
	} else {
		if (gpio_is_valid(pdata->tsp_id))
			of_property_read_string_index(np, "sec,firmware_name",
						gpio_get_value(pdata->tsp_id),
						&pdata->firmware_name);
		else
			of_property_read_string_index(np, "sec,firmware_name",
						      0, &pdata->firmware_name);
	}

	if (of_property_read_string_index(np, "sec,project_name", 0,
					  &pdata->project_name))
		input_dbg(true, &client->dev,
			"%s: skipped to get project_name property\n", __func__);
	if (of_property_read_string_index(np, "sec,project_name",
					  1, &pdata->model_name))
		input_dbg(true, &client->dev,
			  "%s: skipped to get model_name property\n", __func__);

#if defined(CONFIG_FB_MSM_MDSS_SAMSUNG)
	lcdtype = get_lcd_attached("GET");
	if (lcdtype < 0) {
		input_err(true, &client->dev,
			  "%s: lcd is not attached\n", __func__);
		return -ENODEV;
	}
#endif

#if defined(CONFIG_EXYNOS_DECON_FB)
	connected = get_lcd_info("connected");
	if (connected < 0) {
		input_err(true, dev, "%s: Failed to get lcd info\n", __func__);
		return -EINVAL;
	}

	if (!connected) {
		input_err(true, &client->dev,
			  "%s: lcd is disconnected\n", __func__);
		return -ENODEV;
	}

	input_info(true, &client->dev, "%s: lcd is connected\n", __func__);

	lcdtype = get_lcd_info("id");
	if (lcdtype < 0) {
		input_err(true, dev, "%s: Failed to get lcd info\n", __func__);
		return -EINVAL;
	}
#endif

	input_info(true, &client->dev,
		   "%s: lcdtype 0x%08X\n", __func__, lcdtype);

	if (pdata->model_name && strncmp(pdata->model_name, "G950", 4) == 0)
		pdata->panel_revision = 0;
	else
		pdata->panel_revision = ((lcdtype >> 8) & 0xFF) >> 4;

	if (of_property_read_string(np,
		"sec,regulator_dvdd", &pdata->regulator_dvdd))
		input_dbg(true, dev,
			"%s: Failed to get regulator_dvdd name property\n",
			__func__);

	if (of_property_read_string(np,
		"sec,regulator_avdd", &pdata->regulator_avdd))
		input_dbg(true, dev,
			"%s: Failed to get regulator_avdd name property\n",
			__func__);

	pdata->power = sec_ts_power;

	if (of_property_read_u32(np, "sec,always_lpmode",
				 &pdata->always_lpmode) < 0)
		pdata->always_lpmode = 0;

	if (of_property_read_u32(np, "sec,bringup", &pdata->bringup) < 0)
		pdata->bringup = 0;

	if (of_property_read_u32(np, "sec,mis_cal_check",
				 &pdata->mis_cal_check) < 0)
		pdata->mis_cal_check = 0;

	if (of_property_read_u32(np, "sec,heatmap_mode",
		&pdata->heatmap_mode) < 0)
		pdata->heatmap_mode = 0;

	pdata->regulator_boot_on = of_property_read_bool(np,
						"sec,regulator_boot_on");
	pdata->support_sidegesture = of_property_read_bool(np,
						"sec,support_sidegesture");
	pdata->support_dex = of_property_read_bool(np, "support_dex_mode");

	pdata->support_mt_pressure = true;

#ifdef PAT_CONTROL
	input_info(true, &client->dev,
		"%s: buffer limit: %d, lcd_id:%06X, bringup:%d, FW:%s(%d), id:%d,%d, pat_function:%d mis_cal:%d dex:%d, gesture:%d\n",
		__func__, pdata->io_burstmax, lcdtype, pdata->bringup,
		pdata->firmware_name, count, pdata->tsp_id, pdata->tsp_icid,
		pdata->pat_function, pdata->mis_cal_check, pdata->support_dex,
		pdata->support_sidegesture);
#else
	input_info(true, &client->dev,
		  "%s: buffer limit: %d, lcd_id:%06X, bringup:%d, FW:%s(%d), id:%d,%d, dex:%d, gesture:%d\n",
		  __func__, pdata->io_burstmax, lcdtype, pdata->bringup,
		  pdata->firmware_name, count, pdata->tsp_id, pdata->tsp_icid,
		  pdata->support_dex, pdata->support_sidegesture);
#endif
	return ret;
}

int sec_ts_read_information(struct sec_ts_data *ts)
{
	unsigned char data[13] = { 0 };
	int ret;

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_READ_INFO, true);

	memset(data, 0x0, 3);
	ret = sec_ts_read(ts, SEC_TS_READ_ID, data, 3);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
					"%s: failed to read device id(%d)\n",
					__func__, ret);
		goto out;
	}

	input_info(true, &ts->client->dev,
				"%s: %X, %X, %X\n",
				__func__, data[0], data[1], data[2]);
	memset(data, 0x0, 11);
	ret = sec_ts_read(ts,  SEC_TS_READ_PANEL_INFO, data, 11);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
					"%s: failed to read sub id(%d)\n",
					__func__, ret);
		goto out;
	}

	input_info(true, &ts->client->dev,
		   "%s: nTX:%X, nRX:%X, rY:%d, rX:%d\n",
		   __func__, data[8], data[9],
		   (data[2] << 8) | data[3], (data[0] << 8) | data[1]);

	/* Set X,Y Resolution from IC information. */
	if (((data[0] << 8) | data[1]) > 0)
		ts->plat_data->max_x = ((data[0] << 8) | data[1]) - 1;

	if (((data[2] << 8) | data[3]) > 0)
		ts->plat_data->max_y = ((data[2] << 8) | data[3]) - 1;

	ts->tx_count = data[8];
	ts->rx_count = data[9];

	data[0] = 0;
	ret = sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS, data, 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
					"%s: failed to read sub id(%d)\n",
					__func__, ret);
		goto out;
	}

	input_info(true, &ts->client->dev,
				"%s: STATUS : %X\n",
				__func__, data[0]);

	memset(data, 0x0, 4);
	ret = sec_ts_read(ts, SEC_TS_READ_TS_STATUS, data, 4);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
					"%s: failed to read sub id(%d)\n",
					__func__, ret);
		goto out;
	}

	input_info(true, &ts->client->dev,
		   "%s: TOUCH STATUS : %02X, %02X, %02X, %02X\n",
		   __func__, data[0], data[1], data[2], data[3]);
	ret = sec_ts_read(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
			  (u8 *)&(ts->touch_functions), 2);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			"%s: failed to read touch functions(%d)\n",
			__func__, ret);
		goto out;
	}

	input_info(true, &ts->client->dev,
				"%s: Functions : %02X\n",
				__func__, ts->touch_functions);

out:
	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_READ_INFO, false);
	return ret;
}

#ifdef SEC_TS_SUPPORT_CUSTOMLIB
int sec_ts_set_custom_library(struct sec_ts_data *ts)
{
	u8 data[3] = { 0 };
	int ret;

	input_err(true, &ts->client->dev, "%s: Custom Library (0x%02x)\n",
				__func__, ts->lowpower_mode);

	data[2] = ts->lowpower_mode;

	ret = sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 3);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: Failed to Custom Library\n", __func__);

	ret = sec_ts_write(ts, SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			"%s: Failed to send NOTIFY Custom Library\n", __func__);

	return ret;
}

int sec_ts_check_custom_library(struct sec_ts_data *ts)
{
	u8 data[10] = { 0 };
	int ret = -1;

	ret = ts->sec_ts_read(ts, SEC_TS_CMD_CUSTOMLIB_GET_INFO, &data[0], 10);

	input_info(true, &ts->client->dev,
		"%s: (%d) %c%c%c%c, || %02X, %02X, %02X, %02X, || %02X, %02X\n",
		__func__, ret, data[0], data[1], data[2], data[3], data[4],
		data[5], data[6], data[7], data[8], data[9]);

	/* compare model name with device tree */
	if (ts->plat_data->model_name)
		ret = strncmp(data, ts->plat_data->model_name, 4);

	if (ret == 0)
		ts->use_customlib = true;
	else
		ts->use_customlib = false;

	input_err(true, &ts->client->dev, "%s: use %s\n",
		  __func__, ts->use_customlib ? "CUSTOMLIB" : "VENDOR");

	return ret;
}
#endif

static void sec_ts_set_input_prop(struct sec_ts_data *ts,
				  struct input_dev *dev, u8 propbit)
{
	static char sec_ts_phys[64] = { 0 };

	snprintf(sec_ts_phys, sizeof(sec_ts_phys), "%s/input1",
			dev->name);
	dev->phys = sec_ts_phys;
#ifdef I2C_INTERFACE
	dev->id.bustype = BUS_I2C;
#else
	dev->id.bustype = BUS_SPI;
#endif
	dev->dev.parent = &ts->client->dev;

	set_bit(EV_SYN, dev->evbit);
	set_bit(EV_KEY, dev->evbit);
	set_bit(EV_ABS, dev->evbit);
	set_bit(EV_SW, dev->evbit);
	set_bit(BTN_TOUCH, dev->keybit);
	set_bit(BTN_TOOL_FINGER, dev->keybit);
#ifdef SEC_TS_SUPPORT_CUSTOMLIB
	set_bit(KEY_BLACK_UI_GESTURE, dev->keybit);
#endif
#ifdef SEC_TS_SUPPORT_TOUCH_KEY
	if (ts->plat_data->support_mskey) {
		int i;

		for (i = 0 ; i < ts->plat_data->num_touchkey ; i++)
			set_bit(ts->plat_data->touchkey[i].keycode,
				dev->keybit);

		set_bit(EV_LED, dev->evbit);
		set_bit(LED_MISC, dev->ledbit);
	}
#endif
#ifdef KEY_SIDE_GESTURE
	if (ts->plat_data->support_sidegesture) {
		set_bit(KEY_SIDE_GESTURE, dev->keybit);
		set_bit(KEY_SIDE_GESTURE_RIGHT, dev->keybit);
		set_bit(KEY_SIDE_GESTURE_LEFT, dev->keybit);
	}
#endif
	set_bit(propbit, dev->propbit);
	set_bit(KEY_HOMEPAGE, dev->keybit);

#ifdef SW_GLOVE
	input_set_capability(dev, EV_SW, SW_GLOVE);
#endif
	input_set_abs_params(dev, ABS_MT_POSITION_X, 0, ts->plat_data->max_x,
			     0, 0);
	input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, ts->plat_data->max_y,
			     0, 0);
	input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
	input_set_abs_params(dev, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
	input_set_abs_params(dev, ABS_MT_TOOL_TYPE, MT_TOOL_FINGER,
			     MT_TOOL_FINGER, 0, 0);
#ifdef ABS_MT_CUSTOM
	input_set_abs_params(dev, ABS_MT_CUSTOM, 0, 0xFFFF, 0, 0);
#endif
	if (ts->plat_data->support_mt_pressure)
		input_set_abs_params(dev, ABS_MT_PRESSURE, 0,
				     SEC_TS_PRESSURE_MAX, 0, 0);

	if (propbit == INPUT_PROP_POINTER)
		input_mt_init_slots(dev, MAX_SUPPORT_TOUCH_COUNT,
				    INPUT_MT_POINTER);
	else
		input_mt_init_slots(dev, MAX_SUPPORT_TOUCH_COUNT,
				    INPUT_MT_DIRECT);

	input_set_drvdata(dev, ts);
}

static int sec_ts_fw_init(struct sec_ts_data *ts)
{
	int ret = SEC_TS_ERR_NA;
	bool force_update = false;
	bool valid_firmware_integrity = false;
	unsigned char data[5] = { 0 };
	unsigned char deviceID[5] = { 0 };
	unsigned char result = 0;

	ret = sec_ts_read(ts, SEC_TS_READ_DEVICE_ID, deviceID, 5);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: failed to read device ID(%d)\n",
			  __func__, ret);
	else
		input_info(true, &ts->client->dev,
			"%s: TOUCH DEVICE ID : %02X, %02X, %02X, %02X, %02X\n",
			__func__, deviceID[0], deviceID[1], deviceID[2],
			deviceID[3], deviceID[4]);

	ret = sec_ts_read(ts, SEC_TS_READ_FIRMWARE_INTEGRITY, &result, 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: failed to integrity check (%d)\n",
			  __func__, ret);
	} else {
		if (result & 0x80)
			valid_firmware_integrity = true;
		else
			input_err(true, &ts->client->dev,
				  "%s: invalid integrity result (0x%x)\n",
				  __func__, result);
	}

	ret = sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS, &data[0], 1);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: failed to read sub id(%d)\n", __func__, ret);
	} else {
		ret = sec_ts_read(ts, SEC_TS_READ_TS_STATUS, &data[1], 4);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: failed to touch status(%d)\n",
				  __func__, ret);
	}
	input_info(true, &ts->client->dev,
		"%s: TOUCH STATUS : %02X || %02X, %02X, %02X, %02X\n",
		__func__, data[0], data[1], data[2], data[3], data[4]);

	if (data[0] == SEC_TS_STATUS_BOOT_MODE)
		ts->checksum_result = 1;

	if (((data[0] == SEC_TS_STATUS_APP_MODE &&
	      data[2] == TOUCH_SYSTEM_MODE_FLASH) || ret < 0) &&
	    (valid_firmware_integrity == false))
		force_update = true;

	ret = sec_ts_read_information(ts);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: fail to read information 0x%x\n",
			  __func__, ret);
		return SEC_TS_ERR_INIT;
	}

	ts->touch_functions |= SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC;
	ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
			       (u8 *)&ts->touch_functions, 2);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: Failed to send touch func_mode command",
			  __func__);

	/* Sense_on */
	ret = sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: fail to write Sense_on 0x%x\n",
			  __func__, ret);
		return SEC_TS_ERR_INIT;
	}

	ts->pFrame = kzalloc(ts->tx_count * ts->rx_count * 2, GFP_KERNEL);
	if (!ts->pFrame)
		return SEC_TS_ERR_ALLOC_FRAME;

	ts->gainTable = kzalloc(ts->tx_count * ts->rx_count, GFP_KERNEL);
	if (!ts->gainTable) {
		kfree(ts->pFrame);
		ts->pFrame = NULL;
		return SEC_TS_ERR_ALLOC_GAINTABLE;
	}

	if (ts->plat_data->support_dex) {
		ts->input_dev_pad->name = "sec_touchpad";
		sec_ts_set_input_prop(ts, ts->input_dev_pad,
				      INPUT_PROP_POINTER);
	}
	ts->dex_name = "";

	ts->input_dev->name = "sec_touchscreen";
	sec_ts_set_input_prop(ts, ts->input_dev, INPUT_PROP_DIRECT);
#ifdef USE_OPEN_CLOSE
	ts->input_dev->open = sec_ts_input_open;
	ts->input_dev->close = sec_ts_input_close;
#endif
	ts->input_dev_touch = ts->input_dev;

	ret = input_register_device(ts->input_dev);
	if (ret) {
		input_err(true, &ts->client->dev,
			  "%s: Unable to register %s input device 0x%x\n",
			  __func__, ts->input_dev->name, ret);
		return SEC_TS_ERR_REG_INPUT_DEV;
	}

	if (ts->plat_data->support_dex) {
		ret = input_register_device(ts->input_dev_pad);
		if (ret) {
			input_err(true, &ts->client->dev,
				  "%s: Unable to register %s input device 0x%x\n",
				  __func__, ts->input_dev_pad->name, ret);
			return SEC_TS_ERR_REG_INPUT_PAD_DEV;
		}
	}

	return SEC_TS_ERR_NA;
}

static void sec_ts_device_init(struct sec_ts_data *ts)
{
#if (1) //!defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
	sec_ts_raw_device_init(ts);
#endif
	sec_ts_fn_init(ts);

#ifdef SEC_TS_SUPPORT_CUSTOMLIB
	sec_ts_check_custom_library(ts);
	if (ts->use_customlib)
		sec_ts_set_custom_library(ts);
#endif
}

static struct notifier_block sec_ts_screen_nb;
static struct notifier_block sec_ts_psy_nb;

#ifdef I2C_INTERFACE
static int sec_ts_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
#else
static int sec_ts_probe(struct spi_device *client)
#endif
{
	struct sec_ts_data *ts;
	struct sec_ts_plat_data *pdata;
	int ret = 0;

	input_info(true, &client->dev, "%s\n", __func__);

#ifdef I2C_INTERFACE
	input_info(true, &client->dev, "%s: I2C interface\n", __func__);
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		input_err(true, &client->dev, "%s: EIO err!\n", __func__);
		return -EIO;
	}
#else
	input_info(true, &client->dev, "%s: SPI interface\n", __func__);
#endif
	/* parse dt */
	if (client->dev.of_node) {
		pdata = devm_kzalloc(&client->dev,
				sizeof(struct sec_ts_plat_data), GFP_KERNEL);

		if (!pdata) {
			input_err(true, &client->dev,
				"%s: Failed to allocate platform data\n",
				__func__);
			goto error_allocate_pdata;
		}

		client->dev.platform_data = pdata;

		ret = sec_ts_parse_dt(client);
		if (ret) {
			input_err(true, &client->dev,
				  "%s: Failed to parse dt\n", __func__);
			goto error_allocate_mem;
		}
	} else {
		pdata = client->dev.platform_data;
		if (!pdata) {
			input_err(true, &client->dev,
				  "%s: No platform data found\n", __func__);
			goto error_allocate_pdata;
		}
	}

	if (!pdata->power) {
		input_err(true, &client->dev, "%s: No power contorl found\n",
			  __func__);
		goto error_allocate_mem;
	}

	pdata->pinctrl = devm_pinctrl_get(&client->dev);
	if (IS_ERR(pdata->pinctrl))
		input_err(true, &client->dev, "%s: could not get pinctrl\n",
			  __func__);

	ts = kzalloc(sizeof(struct sec_ts_data), GFP_KERNEL);
	if (!ts)
		goto error_allocate_mem;

	ts->client = client;
	ts->plat_data = pdata;
	ts->crc_addr = 0x0001FE00;
	ts->fw_addr = 0x00002000;
	ts->para_addr = 0x18000;
	ts->flash_page_size = SEC_TS_FW_BLK_SIZE_DEFAULT;
	ts->sec_ts_read = sec_ts_read;
	ts->sec_ts_read_heap = sec_ts_read_heap;
	ts->sec_ts_write = sec_ts_write;
	ts->sec_ts_write_burst = sec_ts_write_burst;
	ts->sec_ts_write_burst_heap = sec_ts_write_burst_heap;
	ts->sec_ts_read_bulk = sec_ts_read_bulk;
	ts->sec_ts_read_bulk_heap = sec_ts_read_bulk_heap;
	ts->io_burstmax = pdata->io_burstmax;
#ifdef USE_POWER_RESET_WORK
	INIT_DELAYED_WORK(&ts->reset_work, sec_ts_reset_work);
#endif
	INIT_WORK(&ts->suspend_work, sec_ts_suspend_work);
	INIT_WORK(&ts->resume_work, sec_ts_resume_work);
	INIT_WORK(&ts->charger_work, sec_ts_charger_work);
	ts->event_wq = alloc_workqueue("sec_ts-event-queue", WQ_UNBOUND |
					 WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1);
	if (!ts->event_wq) {
		input_err(true, &ts->client->dev,
			"%s: Cannot create work thread\n", __func__);
		ret = -ENOMEM;
		goto error_alloc_workqueue;
	}

	init_completion(&ts->bus_resumed);
	complete_all(&ts->bus_resumed);

#ifdef SEC_TS_FW_UPDATE_ON_PROBE
	INIT_WORK(&ts->fw_update_work, sec_ts_fw_update_work);
#else
	input_info(true, &ts->client->dev, "%s: fw update on probe disabled!\n",
		   __func__);
	ts->fw_update_wq = alloc_workqueue("sec_ts-fw-update-queue",
					    WQ_UNBOUND | WQ_HIGHPRI |
					    WQ_CPU_INTENSIVE, 1);
	if (!ts->fw_update_wq) {
		input_err(true, &ts->client->dev,
			  "%s: Can't alloc fw update work thread\n",
			  __func__);
		ret = -ENOMEM;
		goto error_alloc_fw_update_wq;
	}
	INIT_DELAYED_WORK(&ts->fw_update_work, sec_ts_fw_update_work);
#endif

	ts->is_fw_corrupted = false;

	/* Assume screen is on throughout probe */
	ts->bus_refmask = SEC_TS_BUS_REF_SCREEN_ON;
#ifdef I2C_INTERFACE
	i2c_set_clientdata(client, ts);
#else
	spi_set_drvdata(client, ts);
#endif

#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
	ts->tbn = tbn_init(&ts->client->dev);
	if (!ts->tbn) {
		input_err(true, &ts->client->dev,
			  "%s: TBN initialization error\n", __func__);
		ret = -ENODEV;
		goto err_init_tbn;
	}
#endif

	if (gpio_is_valid(ts->plat_data->tsp_id))
		ts->tspid_val = gpio_get_value(ts->plat_data->tsp_id);

	if (gpio_is_valid(ts->plat_data->tsp_icid))
		ts->tspicid_val = gpio_get_value(ts->plat_data->tsp_icid);

	ts->input_dev = input_allocate_device();
	if (!ts->input_dev) {
		input_err(true, &ts->client->dev,
			  "%s: allocate device err!\n", __func__);
		ret = -ENOMEM;
		goto err_allocate_input_dev;
	}

	if (ts->plat_data->support_dex) {
		ts->input_dev_pad = input_allocate_device();
		if (!ts->input_dev_pad) {
			input_err(true, &ts->client->dev,
				  "%s: allocate device err!\n", __func__);
			ret = -ENOMEM;
			goto err_allocate_input_dev_pad;
		}
	}

	ts->touch_count = 0;
	ts->tid_palm_state = 0;
	ts->tid_grip_state = 0;
	ts->tid_touch_state = 0;
	ts->palms_leaved_once = false;
	ts->grips_leaved_once = false;

	ts->sec_ts_write = sec_ts_write;
	ts->sec_ts_read = sec_ts_read;
	ts->sec_ts_read_heap = sec_ts_read_heap;
	ts->sec_ts_read_customlib = sec_ts_read_from_customlib;

	ts->max_z_value = 0;
	ts->min_z_value = 0xFFFFFFFF;
	ts->sum_z_value = 0;

	mutex_init(&ts->bus_mutex);
	mutex_init(&ts->lock);
	mutex_init(&ts->device_mutex);
	mutex_init(&ts->io_mutex);
	mutex_init(&ts->eventlock);

	init_completion(&ts->resume_done);
	complete_all(&ts->resume_done);

	init_completion(&ts->boot_completed);
	complete_all(&ts->boot_completed);

	if (pdata->always_lpmode)
		ts->lowpower_mode |= SEC_TS_MODE_CUSTOMLIB_FORCE_KEY;
	else
		ts->lowpower_mode &= ~SEC_TS_MODE_CUSTOMLIB_FORCE_KEY;

	sec_ts_pinctrl_configure(ts, true);

	/* power enable */
	sec_ts_power(ts, true);
	if (!pdata->regulator_boot_on)
		sec_ts_delay(70);
	ts->power_status = SEC_TS_STATE_POWER_ON;
	ts->external_factory = false;

	ret = sec_ts_wait_for_ready(ts, SEC_TS_ACK_BOOT_COMPLETE);
	if (ret < 0) {
		u8 boot_status;
		/* Read the boot status in case device is in bootloader mode */
		ret = ts->sec_ts_read(ts, SEC_TS_READ_BOOT_STATUS,
					  &boot_status, 1);
		if (ret < 0) {
			input_err(true, &ts->client->dev,
				  "%s: could not read boot status. Assuming no device connected.\n",
				  __func__);
			goto err_init;
		}

		input_info(true, &ts->client->dev,
			   "%s: Attempting to reflash the firmware. Boot status = 0x%02X\n",
			   __func__, boot_status);
		if (boot_status != SEC_TS_STATUS_BOOT_MODE)
			input_err(true, &ts->client->dev,
				  "%s: device is not in bootloader mode!\n",
				  __func__);

		ts->is_fw_corrupted = true;
	}

	input_info(true, &client->dev, "%s: power enable\n", __func__);

	if (ts->is_fw_corrupted == false) {
		switch (sec_ts_fw_init(ts)) {
		case SEC_TS_ERR_INIT:
			goto err_init;
		case SEC_TS_ERR_ALLOC_FRAME:
			goto err_allocate_frame;
		case SEC_TS_ERR_ALLOC_GAINTABLE:
			goto err_allocate_gaintable;
		case SEC_TS_ERR_REG_INPUT_DEV:
			goto err_input_register_device;
		case SEC_TS_ERR_REG_INPUT_PAD_DEV:
			goto err_input_pad_register_device;
		}
	}

	pm_qos_add_request(&ts->pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
		PM_QOS_DEFAULT_VALUE);

	ts->ignore_charger_nb = 0;
	/* init motion filter mode */
	ts->use_default_mf = 0;
	ts->mf_state = SEC_TS_MF_FILTERED;
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
	/*
	 * Heatmap_probe must be called before irq routine is registered,
	 * because heatmap_read is called from the irq context.
	 * If the ISR runs before heatmap_probe is finished, it will invoke
	 * heatmap_read and cause NPE, since read_frame would not yet be set.
	 */
	ts->v4l2.parent_dev = &ts->client->dev;
	ts->v4l2.input_dev = ts->input_dev;
	ts->v4l2.read_frame = read_heatmap_raw;
	ts->v4l2.width = ts->tx_count;
	ts->v4l2.height = ts->rx_count;
	/* 120 Hz operation */
	ts->v4l2.timeperframe.numerator = 1;
	ts->v4l2.timeperframe.denominator = 120;
	ret = heatmap_probe(&ts->v4l2);
	if (ret) {
		input_err(true, &ts->client->dev,
			"%s: Heatmap probe failed\n", __func__);
		goto err_irq;
	}
#endif

	input_info(true, &ts->client->dev, "%s: request_irq = %d\n", __func__,
			client->irq);

	ret = request_threaded_irq(client->irq, sec_ts_isr, sec_ts_irq_thread,
			ts->plat_data->irq_type, SEC_TS_NAME, ts);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			"%s: Unable to request threaded irq\n", __func__);
		goto err_heatmap;
	}

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	ts->offload.caps.touch_offload_major_version = 1;
	ts->offload.caps.touch_offload_minor_version = 0;
	/* ID equivalent to the 4-byte, little-endian string: '00r3' */
	ts->offload.caps.device_id =
	    '3' << 24 | 'r' << 16 | '0' << 8 | '0' << 0;
	ts->offload.caps.display_width = ts->plat_data->max_x + 1;
	ts->offload.caps.display_height = ts->plat_data->max_y + 1;
	ts->offload.caps.tx_size = ts->tx_count;
	ts->offload.caps.rx_size = ts->rx_count;
	ts->offload.caps.heatmap_size = HEATMAP_SIZE_FULL;
#ifdef I2C_INTERFACE
	ts->offload.caps.bus_type = BUS_TYPE_I2C;
	ts->offload.caps.bus_speed_hz = 1000000;
#else
	ts->offload.caps.bus_type = BUS_TYPE_SPI;
	ts->offload.caps.bus_speed_hz = client->max_speed_hz;
#endif

	/* Currently can only reliably read mutual and self strength heatmaps
	 * each frame. Cannot support other formats due to penalties associated
	 * with switching data types.
	 */
	ts->offload.caps.touch_data_types =
	    TOUCH_DATA_TYPE_COORD | TOUCH_DATA_TYPE_STRENGTH;
	ts->offload.caps.touch_scan_types =
	    TOUCH_SCAN_TYPE_MUTUAL | TOUCH_SCAN_TYPE_SELF;

	ts->offload.caps.continuous_reporting = true;
	ts->offload.caps.noise_reporting = false;
	ts->offload.caps.cancel_reporting = false;
	ts->offload.caps.size_reporting = true;
	ts->offload.caps.filter_grip = true;
	ts->offload.caps.filter_palm = true;
	ts->offload.caps.num_sensitivity_settings = 1;

	ts->offload.hcallback = (void *)ts;
	ts->offload.report_cb = sec_ts_offload_report;
	touch_offload_init(&ts->offload);
#endif

	ts->notifier = sec_ts_screen_nb;
	ret = drm_panel_notifier_register(pdata->panel, &ts->notifier);
	if (ret < 0) {
		input_err(true, &ts->client->dev,
			  "%s: drm_panel_notifier_register failed. ret = 0x%08X\n",
			  __func__, ret);
		goto err_register_drm_client;
	}

#ifndef CONFIG_SEC_SYSFS
	sec_class = class_create(THIS_MODULE, "sec");
#endif

	device_init_wakeup(&client->dev, true);

	if (ts->is_fw_corrupted == false)
		sec_ts_device_init(ts);

#ifdef SEC_TS_FW_UPDATE_ON_PROBE
	schedule_work(&ts->fw_update_work);

	/* Do not finish probe without checking and flashing the firmware */
	flush_work(&ts->fw_update_work);
#else
	queue_delayed_work(ts->fw_update_wq, &ts->fw_update_work,
		    msecs_to_jiffies(SEC_TS_FW_UPDATE_DELAY_MS_AFTER_PROBE));
#endif

#if defined(CONFIG_TOUCHSCREEN_DUMP_MODE)
	dump_callbacks.inform_dump = dump_tsp_log;
	INIT_DELAYED_WORK(&ts->ghost_check, sec_ts_check_rawdata);
	p_ghost_check = &ts->ghost_check;
#endif

	ts_dup = ts;
	ts->probe_done = true;

	ts->wlc_online = false;
	ts->usb_present = false;
	ts->charger_mode = SEC_TS_BIT_CHARGER_MODE_NO;
	ts->wireless_psy = power_supply_get_by_name("wireless");
	ts->usb_psy = power_supply_get_by_name("usb");
	ts->psy_nb = sec_ts_psy_nb;
	ret = power_supply_reg_notifier(&ts->psy_nb);
	if (ret < 0)
		input_err(true, &ts->client->dev, "psy notifier register failed\n");

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

	return 0;

	/* need to be enabled when new goto statement is added */
/*
 *	sec_ts_fn_remove(ts);
 *	free_irq(client->irq, ts);
 **/
err_register_drm_client:
	free_irq(client->irq, ts);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	touch_offload_cleanup(&ts->offload);
#endif

err_heatmap:
#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
	heatmap_remove(&ts->v4l2);
err_irq:
#endif
	pm_qos_remove_request(&ts->pm_qos_req);
	if (ts->plat_data->support_dex) {
		input_unregister_device(ts->input_dev_pad);
		ts->input_dev_pad = NULL;
	}
err_input_pad_register_device:
	input_unregister_device(ts->input_dev);
	ts->input_dev = NULL;
	ts->input_dev_touch = NULL;
err_input_register_device:
	kfree(ts->gainTable);
err_allocate_gaintable:
	kfree(ts->pFrame);
err_allocate_frame:
err_init:
	sec_ts_power(ts, false);
	if (ts->plat_data->support_dex) {
		if (ts->input_dev_pad)
			input_free_device(ts->input_dev_pad);
	}
err_allocate_input_dev_pad:
	if (ts->input_dev)
		input_free_device(ts->input_dev);
err_allocate_input_dev:
#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
	tbn_cleanup(ts->tbn);
err_init_tbn:
#endif

#ifndef SEC_TS_FW_UPDATE_ON_PROBE
	if (ts->fw_update_wq)
		destroy_workqueue(ts->fw_update_wq);
error_alloc_fw_update_wq:
#endif

	if (ts->event_wq)
		destroy_workqueue(ts->event_wq);
error_alloc_workqueue:
	kfree(ts);

error_allocate_mem:
	if (gpio_is_valid(pdata->irq_gpio))
		gpio_free(pdata->irq_gpio);
	if (gpio_is_valid(pdata->tsp_id))
		gpio_free(pdata->tsp_id);
	if (gpio_is_valid(pdata->tsp_icid))
		gpio_free(pdata->tsp_icid);
	if (gpio_is_valid(pdata->switch_gpio))
		gpio_free(pdata->switch_gpio);
	if (gpio_is_valid(pdata->reset_gpio))
		gpio_free(pdata->reset_gpio);

error_allocate_pdata:
	if (ret == -ECONNREFUSED)
		sec_ts_delay(100);
	if (ret != -EPROBE_DEFER)
		ret = -ENODEV;
#ifdef CONFIG_TOUCHSCREEN_DUMP_MODE
	p_ghost_check = NULL;
#endif
	ts_dup = NULL;
	input_err(true, &client->dev, "%s: failed(%d)\n", __func__, ret);
	input_log_fix();
	return ret;
}

void sec_ts_unlocked_release_all_finger(struct sec_ts_data *ts)
{
	int i;

	for (i = 0; i < MAX_SUPPORT_TOUCH_COUNT; i++) {
		input_mt_slot(ts->input_dev, i);
		if (ts->plat_data->support_mt_pressure)
			input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);
		input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER,
					   false);

		if ((ts->coord[i].action == SEC_TS_COORDINATE_ACTION_PRESS) ||
			(ts->coord[i].action ==
			 SEC_TS_COORDINATE_ACTION_MOVE)) {

			input_info(true, &ts->client->dev,
				"%s: [RA] tID:%d mc:%d tc:%d v:%02X%02X cal:%02X(%02X) id(%d,%d) p:%d\n",
				__func__, i,
				ts->coord[i].mcount, ts->touch_count,
				ts->plat_data->img_version_of_ic[2],
				ts->plat_data->img_version_of_ic[3],
				ts->cal_status, ts->nv, ts->tspid_val,
				ts->tspicid_val, ts->coord[i].palm_count);

			do_gettimeofday(&ts->time_released[i]);

			if (ts->time_longest <
				(ts->time_released[i].tv_sec -
				 ts->time_pressed[i].tv_sec))
				ts->time_longest =
					(ts->time_released[i].tv_sec -
					 ts->time_pressed[i].tv_sec);
		}

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
		ts->offload.coords[i].status = COORD_STATUS_INACTIVE;
		ts->offload.coords[i].major = 0;
		ts->offload.coords[i].minor = 0;
		ts->offload.coords[i].pressure = 0;
#endif
		ts->coord[i].action = SEC_TS_COORDINATE_ACTION_RELEASE;
		ts->coord[i].mcount = 0;
		ts->coord[i].palm_count = 0;

	}

	input_mt_slot(ts->input_dev, 0);

	input_report_key(ts->input_dev, BTN_TOUCH, false);
	input_report_key(ts->input_dev, BTN_TOOL_FINGER, false);
#ifdef SW_GLOVE
	input_report_switch(ts->input_dev, SW_GLOVE, false);
#endif
	ts->touchkey_glove_mode_status = false;
	ts->touch_count = 0;
	ts->check_multi = 0;
	ts->tid_palm_state = 0;
	ts->tid_grip_state = 0;
	ts->tid_touch_state = 0;
	ts->palms_leaved_once = false;
	ts->grips_leaved_once = false;

#ifdef KEY_SIDE_GESTURE
	if (ts->plat_data->support_sidegesture) {
		input_report_key(ts->input_dev, KEY_SIDE_GESTURE, 0);
		input_report_key(ts->input_dev, KEY_SIDE_GESTURE_LEFT, 0);
		input_report_key(ts->input_dev, KEY_SIDE_GESTURE_RIGHT, 0);
	}
#endif
	input_report_key(ts->input_dev, KEY_HOMEPAGE, 0);
	input_sync(ts->input_dev);
}

void sec_ts_locked_release_all_finger(struct sec_ts_data *ts)
{
	mutex_lock(&ts->eventlock);
	sec_ts_unlocked_release_all_finger(ts);
	mutex_unlock(&ts->eventlock);
}

#ifdef USE_POWER_RESET_WORK
static void sec_ts_reset_work(struct work_struct *work)
{
	struct sec_ts_data *ts = container_of(work, struct sec_ts_data,
							reset_work.work);

	ts->reset_is_on_going = true;
	input_info(true, &ts->client->dev, "%s\n", __func__);

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_RESET, true);

	sec_ts_stop_device(ts);

	sec_ts_delay(30);

	sec_ts_start_device(ts);

	if (ts->input_dev_touch->disabled) {
		input_err(true, &ts->client->dev,
			  "%s: call input_close\n", __func__);

		sec_ts_input_close(ts->input_dev);

		if ((ts->lowpower_mode & SEC_TS_MODE_CUSTOMLIB_AOD) &&
		    ts->use_customlib) {
			int i, ret;
			u8 data[10] = {0x02, 0};

			for (i = 0; i < 4; i++) {
				data[i * 2 + 2] = ts->rect_data[i] & 0xFF;
				data[i * 2 + 3] =
						(ts->rect_data[i] >> 8) & 0xFF;
			}

			disable_irq(ts->client->irq);
			ret = ts->sec_ts_write(ts,
				SEC_TS_CMD_CUSTOMLIB_WRITE_PARAM, &data[0], 10);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: Failed to write offset\n",
					__func__);

			ret = ts->sec_ts_write(ts,
				SEC_TS_CMD_CUSTOMLIB_NOTIFY_PACKET, NULL, 0);
			if (ret < 0)
				input_err(true, &ts->client->dev,
					"%s: Failed to send notify\n",
					__func__);
			enable_irq(ts->client->irq);
		}
	}
	ts->reset_is_on_going = false;

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_RESET, false);
}
#endif

void sec_ts_read_init_info(struct sec_ts_data *ts)
{
#ifndef CONFIG_SEC_FACTORY
	struct sec_ts_test_mode mode;
	char para = TO_TOUCH_MODE;
#endif
#ifdef USE_PRESSURE_SENSOR
	unsigned char data[18] = { 0 };
#endif
	int ret;

	ts->nv = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_FAC_RESULT);
	ts->cal_count = get_tsp_nvm_data(ts, SEC_TS_NVM_OFFSET_CAL_COUNT);
	ts->pressure_cal_base = get_tsp_nvm_data(ts,
				SEC_TS_NVM_OFFSET_PRESSURE_BASE_CAL_COUNT);
	ts->pressure_cal_delta = get_tsp_nvm_data(ts,
				SEC_TS_NVM_OFFSET_PRESSURE_DELTA_CAL_COUNT);

	input_info(true, &ts->client->dev,
		    "%s: fac_nv:%02X, cal_count:%02X\n",
		    __func__, ts->nv, ts->cal_count);

#ifdef PAT_CONTROL
	ts->tune_fix_ver = (get_tsp_nvm_data(ts,
				SEC_TS_NVM_OFFSET_TUNE_VERSION) << 8) |
			    get_tsp_nvm_data(ts,
				SEC_TS_NVM_OFFSET_TUNE_VERSION + 1);
	input_info(true, &ts->client->dev,
	    "%s: tune_fix_ver [%04X]\n", __func__, ts->tune_fix_ver);
#endif

#ifdef USE_PRESSURE_SENSOR
	ret = ts->sec_ts_read(ts, SEC_TS_CMD_SET_GET_PRESSURE, data, 18);
	if (ret < 0)
		return;

	ts->pressure_left = ((data[16] << 8) | data[17]);
	ts->pressure_center = ((data[8] << 8) | data[9]);
	ts->pressure_right = ((data[0] << 8) | data[1]);
	input_info(true, &ts->client->dev,
		"%s: left: %d, center: %d, right: %d\n", __func__,
		ts->pressure_left, ts->pressure_center, ts->pressure_right);
#endif

#ifndef CONFIG_SEC_FACTORY
	/* run self-test */
	disable_irq(ts->client->irq);
	execute_selftest(ts,
		TEST_OPEN | TEST_NODE_VARIANCE |
		TEST_SHORT | TEST_SELF_NODE | TEST_NOT_SAVE);
	enable_irq(ts->client->irq);

	input_info(true, &ts->client->dev, "%s: %02X %02X %02X %02X\n",
		__func__, ts->ito_test[0], ts->ito_test[1]
		, ts->ito_test[2], ts->ito_test[3]);

	ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_POWER_MODE, &para, 1);
	if (ret < 0)
		input_err(true, &ts->client->dev, "%s: Failed to set\n",
				__func__);

	sec_ts_delay(350);

	/* run ambient read */
	memset(&mode, 0x00, sizeof(struct sec_ts_test_mode));
	mode.type = TYPE_AMBIENT_DATA;
	mode.allnode = TEST_MODE_ALL_NODE;

	sec_ts_read_raw_data(ts, NULL, &mode);
#endif

	input_log_fix();
}

static void sec_ts_fw_update_work(struct work_struct *work)
{
#ifdef SEC_TS_FW_UPDATE_ON_PROBE
	struct sec_ts_data *ts = container_of(work, struct sec_ts_data,
					      fw_update_work);
#else
	struct delayed_work *fw_update_work = container_of(work,
					struct delayed_work, work);
	struct sec_ts_data *ts = container_of(fw_update_work,
					struct sec_ts_data, fw_update_work);
#endif

	int ret;

	input_info(true, &ts->client->dev,
		   "%s: Beginning firmware update after probe.\n", __func__);

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_FW_UPDATE, true);

	ret = sec_ts_firmware_update_on_probe(ts, false);
	if (ret < 0)
		input_info(true, &ts->client->dev,
			   "%s: firmware update was unsuccessful.\n",
			   __func__);

	if (ts->is_fw_corrupted == true && ret == 0) {
		ret = sec_ts_fw_init(ts);
		if (ret == SEC_TS_ERR_NA) {
			ts->is_fw_corrupted = false;
			sec_ts_device_init(ts);
		} else
			input_info(true, &ts->client->dev,
				"%s: fail to sec_ts_fw_init 0x%x\n",
				__func__, ret);
	}

	if (ts->is_fw_corrupted == false)
		sec_ts_read_init_info(ts);
	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_FW_UPDATE, false);
}

int sec_ts_set_lowpowermode(struct sec_ts_data *ts, u8 mode)
{
	int ret;
	int retrycnt = 0;
	u8 data;
	char para = 0;

	input_err(true, &ts->client->dev, "%s: %s(%X)\n", __func__,
			mode == TO_LOWPOWER_MODE ? "ENTER" : "EXIT",
			ts->lowpower_mode);

	if (mode) {
		#ifdef SEC_TS_SUPPORT_CUSTOMLIB
		if (ts->use_customlib)
			sec_ts_set_custom_library(ts);
		#endif

		data = (ts->lowpower_mode & SEC_TS_MODE_LOWPOWER_FLAG) >> 1;
		ret = sec_ts_write(ts, SEC_TS_CMD_WAKEUP_GESTURE_MODE,
				   &data, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: Failed to set\n", __func__);
	}

retry_pmode:
	ret = sec_ts_write(ts, SEC_TS_CMD_SET_POWER_MODE, &mode, 1);
	if (ret < 0)
		input_err(true, &ts->client->dev,
				"%s: failed\n", __func__);
	sec_ts_delay(50);

	/* read data */

	ret = sec_ts_read(ts, SEC_TS_CMD_SET_POWER_MODE, &para, 1);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: read power mode failed!\n", __func__);
	else
		input_info(true, &ts->client->dev,
			   "%s: power mode - write(%d) read(%d)\n",
			   __func__, mode, para);

	if (mode != para) {
		retrycnt++;
		if (retrycnt < 5)
			goto retry_pmode;
	}

	ret = sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: write clear event failed\n", __func__);


	sec_ts_locked_release_all_finger(ts);

	if (device_may_wakeup(&ts->client->dev)) {
		if (mode)
			enable_irq_wake(ts->client->irq);
		else
			disable_irq_wake(ts->client->irq);
	}

	ts->lowpower_status = mode;
	input_info(true, &ts->client->dev, "%s: end\n", __func__);

	return ret;
}

#ifdef USE_OPEN_CLOSE
static int sec_ts_input_open(struct input_dev *dev)
{
	struct sec_ts_data *ts = input_get_drvdata(dev);
	int ret;

	ts->input_closed = false;

	input_info(true, &ts->client->dev, "%s\n", __func__);

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_INPUT_DEV, true);

	if (ts->lowpower_status) {
#ifdef USE_RESET_EXIT_LPM
		schedule_delayed_work(&ts->reset_work,
				      msecs_to_jiffies(TOUCH_RESET_DWORK_TIME));
#else
		sec_ts_set_lowpowermode(ts, TO_TOUCH_MODE);
#endif
		ts->power_status = SEC_TS_STATE_POWER_ON;
	} else {
		ret = sec_ts_start_device(ts);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: Failed to start device\n", __func__);
	}

	/* because edge and dead zone will recover soon */
	sec_ts_set_grip_type(ts, ONLY_EDGE_HANDLER);

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_INPUT_DEV, false);

	return 0;
}

static void sec_ts_input_close(struct input_dev *dev)
{
	struct sec_ts_data *ts = input_get_drvdata(dev);

	ts->input_closed = true;

	input_info(true, &ts->client->dev, "%s\n", __func__);

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_INPUT_DEV, true);

	cancel_work_sync(&ts->suspend_work);
	cancel_work_sync(&ts->resume_work);

#ifdef USE_POWER_RESET_WORK
	cancel_delayed_work(&ts->reset_work);
#endif

#ifndef CONFIG_SEC_FACTORY
	ts->lowpower_mode |= SEC_TS_MODE_CUSTOMLIB_FORCE_KEY;
#endif
	if (ts->lowpower_mode) {
		sec_ts_set_lowpowermode(ts, TO_LOWPOWER_MODE);
		ts->power_status = SEC_TS_STATE_LPM;
	} else {
		sec_ts_stop_device(ts);
	}

	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_INPUT_DEV, false);
}
#endif

#ifdef I2C_INTERFACE
static int sec_ts_remove(struct i2c_client *client)
#else
static int sec_ts_remove(struct spi_device *client)
#endif
{
#ifdef I2C_INTERFACE
	struct sec_ts_data *ts = i2c_get_clientdata(client);
#else
	struct sec_ts_data *ts = spi_get_drvdata(client);
#endif
	const struct sec_ts_plat_data *pdata = ts->plat_data;

	input_info(true, &ts->client->dev, "%s\n", __func__);

	if (ts_dup == NULL || ts->probe_done == false)
		return 0;

	/* Force the bus active throughout removal of the client */
	sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_FORCE_ACTIVE, true);

	power_supply_unreg_notifier(&ts->psy_nb);
	drm_panel_notifier_unregister(pdata->panel, &ts->notifier);

	cancel_work_sync(&ts->suspend_work);
	cancel_work_sync(&ts->resume_work);
	cancel_work_sync(&ts->charger_work);
	destroy_workqueue(ts->event_wq);

#ifdef SEC_TS_FW_UPDATE_ON_PROBE
	cancel_work_sync(&ts->fw_update_work);
#else
	cancel_delayed_work_sync(&ts->fw_update_work);
	destroy_workqueue(ts->fw_update_wq);
#endif

	disable_irq_nosync(ts->client->irq);
	free_irq(ts->client->irq, ts);
	input_info(true, &ts->client->dev, "%s: irq disabled\n", __func__);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	touch_offload_cleanup(&ts->offload);
#endif

#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
	heatmap_remove(&ts->v4l2);
#endif

	pm_qos_remove_request(&ts->pm_qos_req);

#ifdef USE_POWER_RESET_WORK
	cancel_delayed_work_sync(&ts->reset_work);
	flush_delayed_work(&ts->reset_work);

	input_info(true, &ts->client->dev, "%s: flush queue\n", __func__);

#endif

	sec_ts_fn_remove(ts);

#ifdef CONFIG_TOUCHSCREEN_DUMP_MODE
	p_ghost_check = NULL;
#endif
	device_init_wakeup(&client->dev, false);

	ts->lowpower_mode = false;
	ts->probe_done = false;

	if (ts->plat_data->support_dex) {
		input_mt_destroy_slots(ts->input_dev_pad);
		input_unregister_device(ts->input_dev_pad);
	}

	ts->input_dev = ts->input_dev_touch;
	input_mt_destroy_slots(ts->input_dev);
	input_unregister_device(ts->input_dev);

	ts->input_dev_pad = NULL;
	ts->input_dev = NULL;
	ts->input_dev_touch = NULL;
	ts_dup = NULL;

	/* need to do software reset for next sec_ts_probe() without error */
	ts->sec_ts_write(ts, SEC_TS_CMD_SW_RESET, NULL, 0);

	ts->plat_data->power(ts, false);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
	tbn_cleanup(ts->tbn);
#endif

	if (gpio_is_valid(ts->plat_data->irq_gpio))
		gpio_free(ts->plat_data->irq_gpio);
	if (gpio_is_valid(ts->plat_data->switch_gpio))
		gpio_free(ts->plat_data->switch_gpio);
	if (gpio_is_valid(ts->plat_data->reset_gpio))
		gpio_free(ts->plat_data->reset_gpio);

	sec_ts_raw_device_exit(ts);
#ifndef CONFIG_SEC_SYSFS
	class_destroy(sec_class);
#endif

#if IS_ENABLED(CONFIG_TOUCHSCREEN_HEATMAP)
	kfree(ts->heatmap_buff);
#endif
	kfree(ts->gainTable);
	kfree(ts->pFrame);
	kfree(ts);
	return 0;
}

#ifdef I2C_INTERFACE
static void sec_ts_shutdown(struct i2c_client *client)
#else
static void sec_ts_shutdown(struct spi_device *client)
#endif
{
	pr_info("%s\n", __func__);
	if (ts_dup)
		sec_ts_remove(client);
}

int sec_ts_stop_device(struct sec_ts_data *ts)
{
	input_info(true, &ts->client->dev, "%s\n", __func__);

	mutex_lock(&ts->device_mutex);

	if (ts->power_status == SEC_TS_STATE_POWER_OFF) {
		input_err(true, &ts->client->dev,
			  "%s: already power off\n", __func__);
		goto out;
	}

	ts->power_status = SEC_TS_STATE_POWER_OFF;

	disable_irq(ts->client->irq);
	sec_ts_locked_release_all_finger(ts);

	ts->plat_data->power(ts, false);

	if (ts->plat_data->enable_sync)
		ts->plat_data->enable_sync(false);

	sec_ts_pinctrl_configure(ts, false);

out:
	mutex_unlock(&ts->device_mutex);
	return 0;
}

int sec_ts_start_device(struct sec_ts_data *ts)
{
	int ret;

	input_info(true, &ts->client->dev, "%s\n", __func__);

	sec_ts_pinctrl_configure(ts, true);

	mutex_lock(&ts->device_mutex);

	if (ts->power_status == SEC_TS_STATE_POWER_ON) {
		input_info(true, &ts->client->dev,
			  "%s: already power on\n", __func__);
		goto out;
	}

	sec_ts_locked_release_all_finger(ts);

	ts->plat_data->power(ts, true);
	sec_ts_delay(70);
	ts->power_status = SEC_TS_STATE_POWER_ON;
	sec_ts_wait_for_ready(ts, SEC_TS_ACK_BOOT_COMPLETE);

	if (ts->plat_data->enable_sync)
		ts->plat_data->enable_sync(true);

	if (ts->flip_enable) {
		ret = sec_ts_write(ts, SEC_TS_CMD_SET_COVERTYPE,
				   &ts->cover_cmd, 1);

		ts->touch_functions = ts->touch_functions |
				SEC_TS_BIT_SETFUNC_COVER;
		input_info(true, &ts->client->dev,
				"%s: cover cmd write type:%d, mode:%x, ret:%d",
				__func__, ts->touch_functions,
				ts->cover_cmd, ret);
	} else {
		ts->touch_functions = (ts->touch_functions &
				       (~SEC_TS_BIT_SETFUNC_COVER));
		input_info(true, &ts->client->dev,
			"%s: cover open, not send cmd", __func__);
	}

	ts->touch_functions = ts->touch_functions |
				SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC;
	ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
			   (u8 *)&ts->touch_functions, 2);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			"%s: Failed to send touch function command", __func__);

	#ifdef SEC_TS_SUPPORT_CUSTOMLIB
	if (ts->use_customlib)
		sec_ts_set_custom_library(ts);
	#endif

	sec_ts_set_grip_type(ts, ONLY_EDGE_HANDLER);

	if (ts->dex_mode) {
		input_info(true, &ts->client->dev,
			   "%s: set dex mode\n", __func__);
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE,
				       &ts->dex_mode, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: failed to set dex mode %x\n",
				__func__, ts->dex_mode);
	}

	if (ts->brush_mode) {
		input_info(true, &ts->client->dev,
			   "%s: set brush mode\n", __func__);
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE,
				       &ts->brush_mode, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: failed to set brush mode\n", __func__);
	}

	if (ts->touchable_area) {
		input_info(true, &ts->client->dev,
			   "%s: set 16:9 mode\n", __func__);
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA,
				       &ts->touchable_area, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				"%s: failed to set 16:9 mode\n", __func__);
	}

	/* Sense_on */
	ret = sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: fail to write Sense_on\n", __func__);

	enable_irq(ts->client->irq);

out:
	mutex_unlock(&ts->device_mutex);
	return 0;
}

#ifdef CONFIG_PM
static int sec_ts_pm_suspend(struct device *dev)
{
	struct sec_ts_data *ts = dev_get_drvdata(dev);

	if (ts->bus_refmask)
		input_info(true, &ts->client->dev,
			"%s: bus_refmask 0x%X\n", __func__, ts->bus_refmask);

	if (ts->power_status != SEC_TS_STATE_SUSPEND) {
		input_err(true, &ts->client->dev,
			"%s: can't suspend because touch bus is in use!\n",
			__func__);
		return -EBUSY;
	}

	if (ts->lowpower_mode)
		reinit_completion(&ts->resume_done);

	return 0;
}

static int sec_ts_pm_resume(struct device *dev)
{
	struct sec_ts_data *ts = dev_get_drvdata(dev);

	if (ts->lowpower_mode)
		complete_all(&ts->resume_done);

	return 0;
}
#endif

static const struct i2c_device_id sec_ts_id[] = {
	{ SEC_TS_NAME, 0 },
	{ },
};

#ifdef CONFIG_PM
static const struct dev_pm_ops sec_ts_dev_pm_ops = {
	.suspend = sec_ts_pm_suspend,
	.resume = sec_ts_pm_resume,
};
#endif

/*
 * Configure the switch GPIO to toggle bus master between AP and SLPI.
 * gpio_value takes one of
 * { SEC_SWITCH_GPIO_VALUE_SLPI_MASTER, SEC_SWITCH_GPIO_VALUE_AP_MASTER }
 */
static void sec_set_switch_gpio(struct sec_ts_data *ts, int gpio_value)
{
	int retval;
	unsigned int gpio = ts->plat_data->switch_gpio;

	if (!gpio_is_valid(gpio))
		return;

	input_info(true, &ts->client->dev, "%s: toggling switch to %s\n",
		   __func__, gpio_value == SEC_SWITCH_GPIO_VALUE_AP_MASTER ?
		   "AP" : "SLPI");

	retval = gpio_direction_output(gpio, gpio_value);
	if (retval < 0)
		input_err(true, &ts->client->dev,
			  "%s: Failed to toggle switch_gpio, err = %d\n",
			  __func__, retval);
}

static void sec_ts_suspend_work(struct work_struct *work)
{
	struct sec_ts_data *ts = container_of(work, struct sec_ts_data,
					      suspend_work);
	int ret = 0;

	input_info(true, &ts->client->dev, "%s\n", __func__);

	mutex_lock(&ts->device_mutex);

	reinit_completion(&ts->bus_resumed);

	if (ts->power_status == SEC_TS_STATE_SUSPEND) {
		input_err(true, &ts->client->dev, "%s: already suspended.\n",
			  __func__);
		mutex_unlock(&ts->device_mutex);
		return;
	}

	pm_stay_awake(&ts->client->dev);

	/* Stop T-IC */
	sec_ts_fix_tmode(ts, TOUCH_SYSTEM_MODE_SLEEP, TOUCH_MODE_STATE_STOP);
	ret = sec_ts_write(ts, SEC_TS_CMD_CLEAR_EVENT_STACK, NULL, 0);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			"%s: write clear event failed\n", __func__);

	disable_irq_nosync(ts->client->irq);
	sec_ts_locked_release_all_finger(ts);

	if (ts->plat_data->enable_sync)
		ts->plat_data->enable_sync(false);

	ts->power_status = SEC_TS_STATE_SUSPEND;

	sec_ts_pinctrl_configure(ts, false);

	sec_set_switch_gpio(ts, SEC_SWITCH_GPIO_VALUE_SLPI_MASTER);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
	if (ts->tbn)
		tbn_release_bus(ts->tbn);
#endif
	pm_relax(&ts->client->dev);
	mutex_unlock(&ts->device_mutex);
}

static void sec_ts_resume_work(struct work_struct *work)
{
	struct sec_ts_data *ts = container_of(work, struct sec_ts_data,
					      resume_work);
	int ret = 0;

	input_info(true, &ts->client->dev, "%s\n", __func__);

	mutex_lock(&ts->device_mutex);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_TBN)
	if (ts->tbn)
		tbn_request_bus(ts->tbn);
#endif

	sec_set_switch_gpio(ts, SEC_SWITCH_GPIO_VALUE_AP_MASTER);

	sec_ts_pinctrl_configure(ts, true);

	if (ts->power_status == SEC_TS_STATE_POWER_ON) {
		input_err(true, &ts->client->dev, "%s: already resumed.\n",
			  __func__);
		mutex_unlock(&ts->device_mutex);
		return;
	}

	sec_ts_locked_release_all_finger(ts);

	ts->power_status = SEC_TS_STATE_POWER_ON;

	ret = sec_ts_system_reset(ts);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			"%s: reset failed! ret %d\n", __func__, ret);

	if (ts->plat_data->enable_sync)
		ts->plat_data->enable_sync(true);

	ts->touch_functions =
	    ts->touch_functions | SEC_TS_DEFAULT_ENABLE_BIT_SETFUNC;
	ret = sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHFUNCTION,
			       (u8 *)&ts->touch_functions, 2);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: Failed to send touch function command.",
			  __func__);

#ifdef SEC_TS_SUPPORT_CUSTOMLIB
	if (ts->use_customlib)
		sec_ts_set_custom_library(ts);
#endif

	sec_ts_set_grip_type(ts, ONLY_EDGE_HANDLER);

	if (ts->dex_mode) {
		input_info(true, &ts->client->dev, "%s: set dex mode.\n",
			   __func__);
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_DEX_MODE,
					   &ts->dex_mode, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: failed to set dex mode %x.\n", __func__,
				  ts->dex_mode);
	}

	if (ts->brush_mode) {
		input_info(true, &ts->client->dev, "%s: set brush mode.\n",
			   __func__);
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_BRUSH_MODE,
					   &ts->brush_mode, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: failed to set brush mode.\n", __func__);
	}

	if (ts->touchable_area) {
		input_info(true, &ts->client->dev, "%s: set 16:9 mode.\n",
			   __func__);
		ret = ts->sec_ts_write(ts, SEC_TS_CMD_SET_TOUCHABLE_AREA,
					   &ts->touchable_area, 1);
		if (ret < 0)
			input_err(true, &ts->client->dev,
				  "%s: failed to set 16:9 mode.\n", __func__);
	}

	/* set charger mode */
	ret = ts->sec_ts_write(ts, SET_TS_CMD_SET_CHARGER_MODE,
			       &ts->charger_mode, 1);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: write reg %#x %#x failed, returned %i\n",
			__func__, SET_TS_CMD_SET_CHARGER_MODE, ts->charger_mode,
			ret);
	else
		input_info(true, &ts->client->dev, "%s: set charger mode %#x\n",
			__func__, ts->charger_mode);
	queue_work(ts->event_wq, &ts->charger_work);

	/* Sense_on */
	ret = sec_ts_write(ts, SEC_TS_CMD_SENSE_ON, NULL, 0);
	if (ret < 0)
		input_err(true, &ts->client->dev,
			  "%s: failed to write Sense_on.\n", __func__);

#if IS_ENABLED(CONFIG_TOUCHSCREEN_OFFLOAD)
	/* Set touch_offload configuration */
	if (ts->offload.offload_running) {
		input_info(true, &ts->client->dev,
			   "applying touch_offload settings.\n");

		if (!ts->offload.config.filter_grip)
			sec_ts_enable_grip(ts, false);
	}
#endif

	enable_irq(ts->client->irq);

	complete_all(&ts->bus_resumed);

	mutex_unlock(&ts->device_mutex);
}

static void sec_ts_charger_work(struct work_struct *work)
{
	int ret;
	union power_supply_propval prop = {0,};
	struct sec_ts_data *ts = container_of(work, struct sec_ts_data,
					      charger_work);
	u8 charger_mode = SEC_TS_BIT_CHARGER_MODE_NO;
	bool usb_present = ts->usb_present;
	bool wlc_online = ts->wlc_online;

	/* usb case */
	ret = power_supply_get_property(ts->usb_psy,
					POWER_SUPPLY_PROP_PRESENT, &prop);
	if (ret == 0) {
		usb_present = !!prop.intval;
		if (usb_present)
			charger_mode = SEC_TS_BIT_CHARGER_MODE_WIRE_CHARGER;
	}

	/* wlc case */
	ret = power_supply_get_property(ts->wireless_psy,
					POWER_SUPPLY_PROP_ONLINE, &prop);
	if (ret == 0) {
		wlc_online = !!prop.intval;
		if (wlc_online)
			charger_mode = SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER;
	}

	/* rtx case */
	ret = power_supply_get_property(ts->wireless_psy,
					POWER_SUPPLY_PROP_RTX, &prop);
	if (ret == 0)
		pr_debug("%s: RTX %s", __func__,
			(!!prop.intval) ? "ON" : "OFF");

	if (usb_present == ts->usb_present &&
	    wlc_online == ts->wlc_online &&
	    ts->keep_wlc_mode == false)
		return;

	/* keep wlc mode if usb plug in w/ wlc off case */
	if (ts->keep_wlc_mode) {
		input_info(true, &ts->client->dev,
			   "keep wlc mode after usb plug in during wlc online");
		charger_mode = SEC_TS_BIT_CHARGER_MODE_WIRELESS_CHARGER;
	}

	input_info(true, &ts->client->dev,
		"%s: keep_wlc_mode %d, USB(%d->%d), WLC(%d->%d), charger_mode(%#x->%#x)",
		__func__,
		ts->keep_wlc_mode,
		ts->usb_present, usb_present,
		ts->wlc_online, wlc_online,
		ts->charger_mode, charger_mode);

	if (ts->charger_mode != charger_mode) {
		if (ts->power_status == SEC_TS_STATE_POWER_ON) {
			ret = ts->sec_ts_write(ts, SET_TS_CMD_SET_CHARGER_MODE,
				       &charger_mode, 1);
			if (ret < 0) {
				input_err(true, &ts->client->dev,
				"%s: write reg %#x %#x failed, returned %i\n",
				__func__, SET_TS_CMD_SET_CHARGER_MODE,
				charger_mode, ret);
				return;
			}

			input_info(true, &ts->client->dev,
				"%s: charger_mode change from %#x to %#x\n",
				__func__, ts->charger_mode, charger_mode);
		} else {
			input_info(true, &ts->client->dev,
				"%s: ONLY update charger_mode status from %#x to %#x, then will apply during resume\n",
				__func__, ts->charger_mode, charger_mode);
		}
		ts->charger_mode = charger_mode;
	}

	/* update final charger state */
	ts->wlc_online = wlc_online;
	ts->usb_present = usb_present;
	ts->keep_wlc_mode = false;
}

static void sec_ts_aggregate_bus_state(struct sec_ts_data *ts)
{
	input_dbg(true, &ts->client->dev, "%s: bus_refmask = 0x%02X.\n",
		  __func__, ts->bus_refmask);

	/* Complete or cancel any outstanding transitions */
	cancel_work_sync(&ts->suspend_work);
	cancel_work_sync(&ts->resume_work);

	if ((ts->bus_refmask == 0 &&
		ts->power_status == SEC_TS_STATE_SUSPEND) ||
	    (ts->bus_refmask != 0 &&
		ts->power_status != SEC_TS_STATE_SUSPEND))
		return;

	if (ts->bus_refmask == 0)
		queue_work(ts->event_wq, &ts->suspend_work);
	else
		queue_work(ts->event_wq, &ts->resume_work);
}

int sec_ts_set_bus_ref(struct sec_ts_data *ts, u16 ref, bool enable)
{
	int result = 0;

	mutex_lock(&ts->bus_mutex);

	input_dbg(true, &ts->client->dev, "%s: bus_refmask = 0x%02X.\n",
		  __func__, ref);

	if ((enable && (ts->bus_refmask & ref)) ||
	    (!enable && !(ts->bus_refmask & ref))) {
		input_info(true, &ts->client->dev,
			"%s: reference is unexpectedly set: mask=0x%04X, ref=0x%04X, enable=%d.\n",
			__func__, ts->bus_refmask, ref, enable);
		mutex_unlock(&ts->bus_mutex);
		return -EINVAL;
	}

	if (enable) {
		/* IRQs can only keep the bus active. IRQs received while the
		 * bus is transferred to SLPI should be ignored.
		 */
		if (ref == SEC_TS_BUS_REF_IRQ && ts->bus_refmask == 0)
			result = -EAGAIN;
		else
			ts->bus_refmask |= ref;
	} else
		ts->bus_refmask &= ~ref;
	sec_ts_aggregate_bus_state(ts);

	mutex_unlock(&ts->bus_mutex);

	/* When triggering a wake, wait up to one second to resume. SCREEN_ON
	 * and IRQ references do not need to wait.
	 */
	if (enable &&
	    ref != SEC_TS_BUS_REF_SCREEN_ON && ref != SEC_TS_BUS_REF_IRQ) {
		wait_for_completion_timeout(&ts->bus_resumed, HZ);
		if (ts->power_status != SEC_TS_STATE_POWER_ON) {
			input_info(true, &ts->client->dev,
				   "%s: Failed to wake the touch bus.\n",
				   __func__);
			result = -ETIMEDOUT;
		}
	}

	return result;
}

static int sec_ts_screen_state_chg_callback(struct notifier_block *nb,
					    unsigned long val, void *data)
{
	struct sec_ts_data *ts = container_of(nb, struct sec_ts_data,
					      notifier);
	struct drm_panel_notifier *evdata = (struct drm_panel_notifier *)data;
	unsigned int blank;

	input_dbg(true, &ts->client->dev, "%s: enter.\n", __func__);

	if (val != DRM_PANEL_EVENT_BLANK && val != DRM_PANEL_EARLY_EVENT_BLANK)
		return NOTIFY_DONE;

	if (!ts || !evdata || !evdata->data) {
		input_err(true, &ts->client->dev,
			  "%s: Bad screen state change notifier call.\n",
			  __func__);
		return NOTIFY_DONE;
	}

	blank = *((unsigned int *)evdata->data);
	switch (blank) {
	case DRM_PANEL_BLANK_POWERDOWN:
	case DRM_PANEL_BLANK_LP:
		if (val == DRM_PANEL_EARLY_EVENT_BLANK) {
			input_dbg(true, &ts->client->dev,
				  "%s: DRM_PANEL_BLANK_POWERDOWN.\n", __func__);
			sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SCREEN_ON, false);
		}
		break;
	case DRM_PANEL_BLANK_UNBLANK:
		if (val == DRM_PANEL_EVENT_BLANK) {
			input_dbg(true, &ts->client->dev,
				  "%s: DRM_PANEL_BLANK_UNBLANK.\n", __func__);
			sec_ts_set_bus_ref(ts, SEC_TS_BUS_REF_SCREEN_ON, true);
		}
		break;
	}

	return NOTIFY_OK;
}

static struct notifier_block sec_ts_screen_nb = {
	.notifier_call = sec_ts_screen_state_chg_callback,
};

/*
 * power supply callback
 */
static int sec_ts_psy_cb(struct notifier_block *nb,
			       unsigned long val, void *data)
{
	u64 debounce = 500;
	struct sec_ts_data *ts = container_of(nb, struct sec_ts_data, psy_nb);

	pr_debug("%s: val %lu", __func__, val);

	if (val != PSY_EVENT_PROP_CHANGED ||
	    ts->wireless_psy == NULL ||
	    ts->usb_psy == NULL ||
	    (ts->wireless_psy != data && ts->usb_psy != data) ||
	    ts->ignore_charger_nb == 1)
		return NOTIFY_OK;

	if (ts->usb_psy == data) {
		ts->usb_changed_timestamp = ktime_get();
		if (ts->wlc_online) {
			input_dbg(true, &ts->client->dev,
				"%s: ignore this usb_psy changed during wlc_online!",
				__func__);
			return NOTIFY_OK;
		}
	}

	if (ts->wireless_psy == data) {
		/* keep wlc mode after usb plug in during wlc online */
		if (ts->wlc_online == true &&
		    ts->usb_present == false &&
		    ktime_before(ktime_get(),
			ktime_add_ms(ts->usb_changed_timestamp, debounce)))
			ts->keep_wlc_mode = true;
	}

	if (ts->power_status == SEC_TS_STATE_POWER_ON)
		queue_work(ts->event_wq, &ts->charger_work);

	return NOTIFY_OK;
}

static struct notifier_block sec_ts_psy_nb = {
	.notifier_call = sec_ts_psy_cb,
};

#ifdef CONFIG_OF
static const struct of_device_id sec_ts_match_table[] = {
	{ .compatible = "sec,sec_ts",},
	{ },
};
#else
#define sec_ts_match_table NULL
#endif

#ifdef I2C_INTERFACE
static struct i2c_driver sec_ts_driver = {
	.probe		= sec_ts_probe,
	.remove		= sec_ts_remove,
	.shutdown	= sec_ts_shutdown,
	.id_table	= sec_ts_id,
	.driver = {
		.owner	= THIS_MODULE,
		.name	= SEC_TS_NAME,
#ifdef CONFIG_OF
		.of_match_table = sec_ts_match_table,
#endif
#ifdef CONFIG_PM
		.pm = &sec_ts_dev_pm_ops,
#endif
	},
};
#else
static struct spi_driver sec_ts_driver = {
	.probe    = sec_ts_probe,
	.remove   = sec_ts_remove,
	.shutdown   = sec_ts_shutdown,
	.driver   = {
		.owner  = THIS_MODULE,
		.name = SEC_TS_NAME,
#ifdef CONFIG_OF
		.of_match_table = sec_ts_match_table,
#endif
#ifdef CONFIG_PM
		.pm = &sec_ts_dev_pm_ops,
#endif
	},
};
#endif


static int __init sec_ts_init(void)
{
#ifdef CONFIG_BATTERY_SAMSUNG
	if (lpcharge == 1) {
		pr_err("%s %s: Do not load driver due to : lpm %d\n",
				SECLOG, __func__, lpcharge);
		return -ENODEV;
	}
#endif

#ifdef I2C_INTERFACE
	return i2c_add_driver(&sec_ts_driver);
#else
	return spi_register_driver(&sec_ts_driver);
#endif
}

static void __exit sec_ts_exit(void)
{

#ifdef I2C_INTERFACE
	i2c_del_driver(&sec_ts_driver);
#else
	spi_unregister_driver(&sec_ts_driver);
#endif
}

MODULE_AUTHOR("Hyobae, Ahn<hyobae.ahn@samsung.com>");
MODULE_DESCRIPTION("Samsung Electronics TouchScreen driver");
MODULE_LICENSE("GPL");

module_init(sec_ts_init);
module_exit(sec_ts_exit);